From 89f5f115d8867e997e51e99b6b8303016c43460b Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 19:03:05 +0000 Subject: [PATCH 1/8] Make vortex_ensure_eq! show both values by default Mirror assert_eq!: with no message the error shows both expressions and their Display values. A custom message (with an optional error variant) keeps the values appended, so callers no longer need to format "expected {}, got {}" by hand. Each operand is now evaluated once. Claude-Session: https://claude.ai/code/session_01YUXDBd65US5mcKTxb2Xcer Signed-off-by: Claude --- vortex-error/src/lib.rs | 73 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 65 insertions(+), 8 deletions(-) diff --git a/vortex-error/src/lib.rs b/vortex-error/src/lib.rs index 2787b4bef67..3e68c677308 100644 --- a/vortex-error/src/lib.rs +++ b/vortex-error/src/lib.rs @@ -418,7 +418,7 @@ macro_rules! vortex_bail { #[macro_export] macro_rules! vortex_ensure { ($cond:expr) => { - vortex_ensure!($cond, AssertionFailed: "{}", stringify!($cond)); + $crate::vortex_ensure!($cond, AssertionFailed: "{}", stringify!($cond)); }; ($cond:expr, $($tt:tt)*) => { if !$cond { @@ -427,18 +427,75 @@ macro_rules! vortex_ensure { }; } -/// A macro that mirrors `assert_eq!` but instead of panicking when left != right, -/// it will immediately return an erroneous `VortexResult` to the calling context. +/// A macro that mirrors `assert_eq!` but instead of panicking when `left != right`, it will +/// immediately return an erroneous `VortexResult` to the calling context. +/// +/// Both values must implement [`PartialEq`] and [`Display`](std::fmt::Display), and each is +/// evaluated exactly once. Use [`vortex_ensure!`] for values that do not implement `Display`. +/// +/// By default this returns an [`AssertionFailed`](VortexError::AssertionFailed) error that +/// shows both expressions and their values, so most callers do not need a message: +/// +/// ``` +/// # use vortex_error::{VortexResult, vortex_ensure_eq}; +/// fn check(len: usize) -> VortexResult<()> { +/// vortex_ensure_eq!(len, 2); +/// Ok(()) +/// } +/// +/// let err = check(3).unwrap_err().to_string(); +/// assert!(err.starts_with("Assertion failed error: `len == 2`\n left: 3\n right: 2")); +/// ``` +/// +/// A custom message, optionally prefixed with an error variant, replaces the expressions. The +/// values are still appended, so the message does not need to repeat them: +/// +/// ``` +/// # use vortex_error::{VortexResult, vortex_ensure_eq}; +/// fn check(len: usize) -> VortexResult<()> { +/// vortex_ensure_eq!(len, 2, InvalidArgument: "map entries must have {} fields", 2); +/// Ok(()) +/// } +/// +/// let err = check(3).unwrap_err().to_string(); +/// assert!(err.starts_with( +/// "Invalid argument error: map entries must have 2 fields\n left: 3\n right: 2" +/// )); +/// ``` #[macro_export] macro_rules! vortex_ensure_eq { - ($left:expr, $right:expr) => { - $crate::vortex_ensure_eq!($left, $right, AssertionFailed: "{} != {}: {:?} != {:?}", stringify!($left), stringify!($right), $left, $right); + ($left:expr, $right:expr $(,)?) => { + match (&$left, &$right) { + (left_val, right_val) => { + if *left_val != *right_val { + $crate::vortex_bail!( + AssertionFailed: "`{} == {}`\n left: {}\n right: {}", + stringify!($left), + stringify!($right), + left_val, + right_val + ); + } + } + } }; - ($left:expr, $right:expr, $($tt:tt)*) => { - if $left != $right { - $crate::vortex_bail!($($tt)*); + ($left:expr, $right:expr, $variant:ident: $fmt:literal $(, $arg:expr)* $(,)?) => { + match (&$left, &$right) { + (left_val, right_val) => { + if *left_val != *right_val { + $crate::vortex_bail!( + $variant: "{}\n left: {}\n right: {}", + format_args!($fmt $(, $arg)*), + left_val, + right_val + ); + } + } } }; + ($left:expr, $right:expr, $fmt:literal $(, $arg:expr)* $(,)?) => { + $crate::vortex_ensure_eq!($left, $right, Other: $fmt $(, $arg)*) + }; } /// A convenient macro for panicking with a VortexError in the presence of a programmer error From ebcf515f61b208a8e718c5a7896256683a888b05 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 19:10:52 +0000 Subject: [PATCH 2/8] Drop redundant vortex_ensure_eq! messages in vortex-array Remove custom messages that only restated the compared values, and turn plain equality vortex_ensure! checks into vortex_ensure_eq!. Messages that add context are kept without the values, since the macro now appends them. Claude-Session: https://claude.ai/code/session_01YUXDBd65US5mcKTxb2Xcer Signed-off-by: Claude --- vortex-array/src/aggregate_fn/accumulator.rs | 45 +++++-------- .../src/aggregate_fn/accumulator_grouped.rs | 29 ++++----- .../src/aggregate_fn/fns/bounded_max/mod.rs | 8 +-- .../src/aggregate_fn/fns/bounded_min/mod.rs | 8 +-- vortex-array/src/array/erased.rs | 65 +++++++++---------- vortex-array/src/array/mod.rs | 28 ++++---- vortex-array/src/array/plugin.rs | 12 ++-- vortex-array/src/builders/bool.rs | 9 ++- vortex-array/src/builders/child.rs | 9 ++- vortex-array/src/builders/decimal.rs | 9 ++- vortex-array/src/builders/extension.rs | 9 ++- vortex-array/src/builders/fixed_size_list.rs | 37 +++-------- vortex-array/src/builders/list.rs | 16 ++--- vortex-array/src/builders/listview.rs | 22 ++----- vortex-array/src/builders/map.rs | 25 ++++--- vortex-array/src/builders/null.rs | 9 ++- vortex-array/src/builders/primitive.rs | 9 ++- vortex-array/src/builders/struct_.rs | 9 ++- vortex-array/src/builders/varbinview.rs | 9 ++- vortex-array/src/dtype/union.rs | 16 +---- vortex-array/src/executor.rs | 22 ++++--- .../src/expr/transform/bound_partition.rs | 9 +-- vortex-array/src/extension/datetime/date.rs | 11 ++-- vortex-array/src/extension/datetime/time.rs | 11 ++-- .../src/extension/tests/divisible_int.rs | 3 +- vortex-array/src/optimizer/rules.rs | 10 +-- vortex-array/src/patches.rs | 6 +- vortex-array/src/scalar/constructor.rs | 3 +- vortex-array/src/scalar/proto.rs | 5 +- .../src/scalar/typed_view/primitive/scalar.rs | 9 ++- vortex-array/src/scalar/validate.rs | 7 +- .../src/scalar_fn/fns/binary/numeric/mod.rs | 8 +-- vortex-array/src/scalar_fn/fns/byte_length.rs | 4 +- vortex-array/src/scalar_fn/fns/mask/mod.rs | 10 +-- .../src/scalar_fn/internal/row_count.rs | 12 ++-- vortex-array/src/scalar_fn/typed.rs | 9 ++- .../unstable/row/batch/execute/output.rs | 11 ++-- .../scalar_fn/unstable/row/batch/planning.rs | 3 +- .../src/scalar_fn/unstable/row/batch/tests.rs | 2 +- .../scalar_fn/unstable/row/execute/owned.rs | 6 +- .../scalar_fn/unstable/row/execute/sink.rs | 14 ++-- .../unstable/row/types/element/primitive.rs | 6 +- .../row/types/element/tuple/element_tuple.rs | 15 +---- .../scalar_fn/unstable/row/visitor/plan.rs | 12 ++-- .../src/scalar_fn/unstable/row/vtable.rs | 4 +- vortex-array/src/serde.rs | 7 +- vortex-array/src/test_harness/trace/tests.rs | 15 +++-- 47 files changed, 258 insertions(+), 359 deletions(-) diff --git a/vortex-array/src/aggregate_fn/accumulator.rs b/vortex-array/src/aggregate_fn/accumulator.rs index 6604afb8a7b..f4d8ca6aa17 100644 --- a/vortex-array/src/aggregate_fn/accumulator.rs +++ b/vortex-array/src/aggregate_fn/accumulator.rs @@ -7,6 +7,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::Columnar; @@ -155,12 +156,7 @@ impl DynAccumulator for Accumulator { return Ok(()); } - vortex_ensure!( - batch.dtype() == &self.dtypes.dtype, - "Input DType mismatch: expected {}, got {}", - self.dtypes.dtype, - batch.dtype() - ); + vortex_ensure_eq!(batch.dtype(), &self.dtypes.dtype, "Input DType mismatch"); // 0. Legacy stats bridge: if this aggregate is still cached under a legacy Stat slot, // consume that exact stat before kernel dispatch or decode. @@ -200,11 +196,10 @@ impl DynAccumulator for Accumulator { if let Some(kernel) = kernel && let Some(result) = kernel.aggregate(&self.aggregate_fn, batch, ctx)? { - vortex_ensure!( - result.dtype() == &self.dtypes.partial_dtype, - "Aggregate kernel returned {}, expected {}", + vortex_ensure_eq!( result.dtype(), - self.dtypes.partial_dtype, + &self.dtypes.partial_dtype, + "Aggregate kernel returned the wrong partial dtype", ); self.fold_partial_scalar(result)?; return Ok(()); @@ -237,11 +232,10 @@ impl DynAccumulator for Accumulator { .find_aggregate_kernel(batch.encoding_id(), self.aggregate_fn.id()) && let Some(result) = kernel.aggregate(&self.aggregate_fn, &batch, ctx)? { - vortex_ensure!( - result.dtype() == &self.dtypes.partial_dtype, - "Aggregate kernel returned {}, expected {}", + vortex_ensure_eq!( result.dtype(), - self.dtypes.partial_dtype, + &self.dtypes.partial_dtype, + "Aggregate kernel returned the wrong partial dtype", ); self.fold_partial_scalar(result)?; return Ok(()); @@ -278,12 +272,11 @@ impl DynAccumulator for Accumulator { } fn combine_partials(&mut self, partial: Scalar) -> VortexResult<()> { - vortex_ensure!( - partial.dtype() == &self.dtypes.partial_dtype, - "Partial DType mismatch for {}: expected {}, got {}", - self.aggregate_fn, - self.dtypes.partial_dtype, + vortex_ensure_eq!( partial.dtype(), + &self.dtypes.partial_dtype, + "Partial DType mismatch for {}", + self.aggregate_fn, ); self.fold_partial_scalar(partial) } @@ -312,11 +305,10 @@ impl DynAccumulator for Accumulator { #[cfg(debug_assertions)] { - vortex_ensure!( - partial.dtype() == args.partial_dtype, - "Aggregate returned incorrect DType on partial_scalar: expected {}, got {}", - args.partial_dtype, + vortex_ensure_eq!( partial.dtype(), + args.partial_dtype, + "Aggregate returned incorrect DType on partial_scalar", ); } @@ -330,11 +322,10 @@ impl DynAccumulator for Accumulator { None => self.vtable.finalize_scalar(args, &self.empty_partial()?)?, }; - vortex_ensure!( - result.dtype() == args.return_dtype, - "Aggregate returned incorrect DType on final_scalar: expected {}, got {}", - args.return_dtype, + vortex_ensure_eq!( result.dtype(), + args.return_dtype, + "Aggregate returned incorrect DType on final_scalar", ); Ok(result) diff --git a/vortex-array/src/aggregate_fn/accumulator_grouped.rs b/vortex-array/src/aggregate_fn/accumulator_grouped.rs index 631549bd036..16a49b94c6e 100644 --- a/vortex-array/src/aggregate_fn/accumulator_grouped.rs +++ b/vortex-array/src/aggregate_fn/accumulator_grouped.rs @@ -6,7 +6,7 @@ use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_mask::Mask; @@ -233,11 +233,10 @@ impl DynGroupedAccumulator for GroupedAccumulator { groups.dtype() ), }; - vortex_ensure!( - elements_dtype.as_ref() == &self.dtypes.dtype, - "Input DType mismatch: expected {}, got {}", - self.dtypes.dtype, - elements_dtype + vortex_ensure_eq!( + elements_dtype.as_ref(), + &self.dtypes.dtype, + "Input DType mismatch" ); // We first execute the groups until it is a ListView or FixedSizeList, since we only @@ -267,11 +266,10 @@ impl DynGroupedAccumulator for GroupedAccumulator { .vtable .finalize(self.dtypes.args(&self.options), states)?; - vortex_ensure!( - results.dtype() == &self.dtypes.return_dtype, - "Return DType mismatch: expected {}, got {}", - self.dtypes.return_dtype, - results.dtype() + vortex_ensure_eq!( + results.dtype(), + &self.dtypes.return_dtype, + "Return DType mismatch" ); Ok(results) @@ -363,11 +361,10 @@ impl GroupedAccumulator { } fn push_result(&mut self, state: ArrayRef) -> VortexResult<()> { - vortex_ensure!( - state.dtype() == &self.dtypes.partial_dtype, - "State DType mismatch: expected {}, got {}", - self.dtypes.partial_dtype, - state.dtype() + vortex_ensure_eq!( + state.dtype(), + &self.dtypes.partial_dtype, + "State DType mismatch" ); self.partials.push(state); Ok(()) diff --git a/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs b/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs index 2d9e6f3d4c8..75ae06bb95c 100644 --- a/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/bounded_max/mod.rs @@ -12,6 +12,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -139,11 +140,10 @@ impl AggregateFnVTable for BoundedMax { metadata: &[u8], _session: &VortexSession, ) -> VortexResult { - vortex_ensure!( - metadata.len() == size_of::(), - "BoundedMax options expected {} bytes, got {}", + vortex_ensure_eq!( + metadata.len(), size_of::(), - metadata.len() + "BoundedMax options have the wrong byte length" ); let mut bytes = [0u8; size_of::()]; bytes.copy_from_slice(metadata); diff --git a/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs b/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs index e1c0d51bc02..1169a901c25 100644 --- a/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs +++ b/vortex-array/src/aggregate_fn/fns/bounded_min/mod.rs @@ -10,6 +10,7 @@ use vortex_buffer::ByteBuffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -93,11 +94,10 @@ impl AggregateFnVTable for BoundedMin { metadata: &[u8], _session: &VortexSession, ) -> VortexResult { - vortex_ensure!( - metadata.len() == size_of::(), - "BoundedMin options expected {} bytes, got {}", + vortex_ensure_eq!( + metadata.len(), size_of::(), - metadata.len() + "BoundedMin options have the wrong byte length" ); let mut bytes = [0u8; size_of::()]; bytes.copy_from_slice(metadata); diff --git a/vortex-array/src/array/erased.rs b/vortex-array/src/array/erased.rs index 0608eecb5dc..ffa004ad322 100644 --- a/vortex-array/src/array/erased.rs +++ b/vortex-array/src/array/erased.rs @@ -13,6 +13,7 @@ use vortex_buffer::ByteBuffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_mask::Mask; @@ -514,19 +515,17 @@ impl ArrayRef { let existing = slots[slot_idx] .as_ref() .vortex_expect("with_slot cannot replace an absent slot"); - vortex_ensure!( - existing.dtype() == replacement.dtype(), - "slot {} dtype changed from {} to {} during physical rewrite", - slot_idx, + vortex_ensure_eq!( existing.dtype(), - replacement.dtype() + replacement.dtype(), + "slot {} dtype changed during physical rewrite", + slot_idx ); - vortex_ensure!( - existing.len() == replacement.len(), - "slot {} len changed from {} to {} during physical rewrite", - slot_idx, + vortex_ensure_eq!( existing.len(), - replacement.len() + replacement.len(), + "slot {} len changed during physical rewrite", + slot_idx ); slots[slot_idx] = Some(replacement); // SAFETY: upheld by the caller of this unsafe API. @@ -605,32 +604,30 @@ impl ArrayRef { /// parent statistics are preserved and must remain valid. pub unsafe fn with_slots(self, slots: ArraySlots) -> VortexResult { let old_slots = self.slots(); - vortex_ensure!( - old_slots.len() == slots.len(), - "slot count changed from {} to {} during physical rewrite", + vortex_ensure_eq!( old_slots.len(), - slots.len() + slots.len(), + "slot count changed during physical rewrite" ); for (idx, (old_slot, new_slot)) in old_slots.iter().zip(slots.iter()).enumerate() { - vortex_ensure!( - old_slot.is_some() == new_slot.is_some(), + vortex_ensure_eq!( + old_slot.is_some(), + new_slot.is_some(), "slot {} presence changed during physical rewrite", idx ); if let (Some(old_slot), Some(new_slot)) = (old_slot.as_ref(), new_slot.as_ref()) { - vortex_ensure!( - old_slot.dtype() == new_slot.dtype(), - "slot {} dtype changed from {} to {} during physical rewrite", - idx, + vortex_ensure_eq!( old_slot.dtype(), - new_slot.dtype() + new_slot.dtype(), + "slot {} dtype changed during physical rewrite", + idx ); - vortex_ensure!( - old_slot.len() == new_slot.len(), - "slot {} len changed from {} to {} during physical rewrite", - idx, + vortex_ensure_eq!( old_slot.len(), - new_slot.len() + new_slot.len(), + "slot {} len changed during physical rewrite", + idx ); } } @@ -655,11 +652,10 @@ impl ArrayRef { ) -> VortexResult { let buffers = buffers.into_iter().collect::>(); let nbuffers = self.nbuffers(); - vortex_ensure!( - nbuffers == buffers.len(), - "buffer count changed from {} to {} during physical rewrite", + vortex_ensure_eq!( nbuffers, - buffers.len() + buffers.len(), + "buffer count changed during physical rewrite" ); for (idx, (old_buffer, new_buffer)) in self .buffer_handles() @@ -667,12 +663,11 @@ impl ArrayRef { .zip(buffers.iter()) .enumerate() { - vortex_ensure!( - old_buffer.len() == new_buffer.len(), - "buffer {} length changed from {} to {} during physical rewrite", - idx, + vortex_ensure_eq!( old_buffer.len(), - new_buffer.len() + new_buffer.len(), + "buffer {} length changed during physical rewrite", + idx ); } self.0.data.with_buffers(&self, buffers) diff --git a/vortex-array/src/array/mod.rs b/vortex-array/src/array/mod.rs index 5b01372dfd1..4df9f3187d7 100644 --- a/vortex-array/src/array/mod.rs +++ b/vortex-array/src/array/mod.rs @@ -11,6 +11,7 @@ use vortex_buffer::ByteBuffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::registry::Id; @@ -295,7 +296,7 @@ impl DynArrayData for ArrayData { let view = unsafe { ArrayView::new_unchecked(this, &self.data) }; let validity = >::validity(view)?; if let Validity::Array(array) = &validity { - vortex_ensure!(array.len() == this.len(), "Validity array length mismatch"); + vortex_ensure_eq!(array.len(), this.len(), "Validity array length mismatch"); vortex_ensure!( matches!(array.dtype(), DType::Bool(Nullability::NonNullable)), "Validity array is not non-nullable boolean: {}", @@ -436,8 +437,9 @@ impl DynArrayData for ArrayData { let Some(reduced) = V::reduce(view)? else { return Ok(None); }; - vortex_ensure!( - reduced.len() == this.len(), + vortex_ensure_eq!( + reduced.len(), + this.len(), "Reduced array length mismatch from {} to {}", this.encoding_id(), reduced.encoding_id() @@ -467,14 +469,16 @@ impl DynArrayData for ArrayData { return Ok(None); }; - vortex_ensure!( - reduced.len() == parent.len(), + vortex_ensure_eq!( + reduced.len(), + parent.len(), "Reduced array length mismatch from {} to {}", parent.encoding_id(), reduced.encoding_id() ); - vortex_ensure!( - reduced.dtype() == parent.dtype(), + vortex_ensure_eq!( + reduced.dtype(), + parent.dtype(), "Reduced array dtype mismatch from {} to {}", parent.encoding_id(), reduced.encoding_id() @@ -491,13 +495,15 @@ impl DynArrayData for ArrayData { if matches!(result.step(), ExecutionStep::Done) { if cfg!(debug_assertions) { - vortex_ensure!( - result.array().len() == len, + vortex_ensure_eq!( + result.array().len(), + len, "Result length mismatch for {:?}", self.vtable ); - vortex_ensure!( - result.array().dtype() == &dtype, + vortex_ensure_eq!( + result.array().dtype(), + &dtype, "Executed canonical dtype mismatch for {:?}", self.vtable ); diff --git a/vortex-array/src/array/plugin.rs b/vortex-array/src/array/plugin.rs index 5b4fca39854..979d644228c 100644 --- a/vortex-array/src/array/plugin.rs +++ b/vortex-array/src/array/plugin.rs @@ -8,7 +8,7 @@ use std::sync::Arc; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use crate::ArrayRef; @@ -172,11 +172,10 @@ impl ArrayPlugin for V { array: &ArrayRef, session: &VortexSession, ) -> VortexResult> { - vortex_ensure!( - self.id() == array.encoding_id(), - "array plugin {} cannot serialize in-memory array {}", + vortex_ensure_eq!( self.id(), array.encoding_id(), + "array plugin cannot serialize an in-memory array of another encoding", ); Ok(V::serialize(array.as_::(), session)? .map(|metadata| ArraySerialization::from_array(self.id(), array, metadata))) @@ -187,11 +186,10 @@ impl ArrayPlugin for V { parts: ArrayDeserialization<'_>, session: &VortexSession, ) -> VortexResult { - vortex_ensure!( - self.id() == parts.serialized_id, - "array plugin {} does not recognize serialized ID {}", + vortex_ensure_eq!( self.id(), parts.serialized_id, + "array plugin does not recognize the serialized ID", ); Ok(Array::::try_from_parts(V::deserialize( self, diff --git a/vortex-array/src/builders/bool.rs b/vortex-array/src/builders/bool.rs index b5371d3a146..12306c2c7d3 100644 --- a/vortex-array/src/builders/bool.rs +++ b/vortex-array/src/builders/bool.rs @@ -6,7 +6,7 @@ use std::any::Any; use vortex_buffer::BitBufferMut; use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::ExecutionCtx; @@ -125,11 +125,10 @@ impl ArrayBuilder for BoolBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "BoolBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "BoolBuilder received a scalar with the wrong dtype" ); match scalar.as_bool().value() { diff --git a/vortex-array/src/builders/child.rs b/vortex-array/src/builders/child.rs index a9f5b46fc84..98bd7f50d00 100644 --- a/vortex-array/src/builders/child.rs +++ b/vortex-array/src/builders/child.rs @@ -3,7 +3,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::ExecutionCtx; @@ -74,11 +74,10 @@ impl ChildBuilder { /// nested builders forwarding their [`ExecutionCtx`] here do not have to explain why they /// don't. pub fn append_array(&mut self, array: &ArrayRef, _ctx: &mut ExecutionCtx) -> VortexResult<()> { - vortex_ensure!( - array.dtype() == &self.dtype, - "Cannot append an array of dtype {} to a child builder of dtype {}", + vortex_ensure_eq!( array.dtype(), - self.dtype, + &self.dtype, + "Cannot append an array to a child builder of a different dtype", ); if array.is_empty() { diff --git a/vortex-array/src/builders/decimal.rs b/vortex-array/src/builders/decimal.rs index 6d848b82aba..fbedf2cee65 100644 --- a/vortex-array/src/builders/decimal.rs +++ b/vortex-array/src/builders/decimal.rs @@ -7,7 +7,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_buffer::BufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; @@ -226,11 +226,10 @@ impl ArrayBuilder for DecimalBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "DecimalBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "DecimalBuilder received a scalar with the wrong dtype" ); match scalar.as_decimal().decimal_value() { diff --git a/vortex-array/src/builders/extension.rs b/vortex-array/src/builders/extension.rs index 544b119a0a6..326664cfa16 100644 --- a/vortex-array/src/builders/extension.rs +++ b/vortex-array/src/builders/extension.rs @@ -5,7 +5,7 @@ use std::any::Any; use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::ExecutionCtx; @@ -116,11 +116,10 @@ impl ArrayBuilder for ExtensionBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "ExtensionBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "ExtensionBuilder received a scalar with the wrong dtype" ); self.append_value(scalar.as_extension()) diff --git a/vortex-array/src/builders/fixed_size_list.rs b/vortex-array/src/builders/fixed_size_list.rs index e9a66b62d83..963d6c085a8 100644 --- a/vortex-array/src/builders/fixed_size_list.rs +++ b/vortex-array/src/builders/fixed_size_list.rs @@ -8,7 +8,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use crate::ArrayRef; @@ -122,18 +122,8 @@ impl FixedSizeListBuilder { array: &ArrayRef, ctx: &mut ExecutionCtx, ) -> VortexResult<()> { - vortex_ensure!( - array.dtype() == self.element_dtype(), - "Array dtype {:?} does not match list element dtype {:?}", - array.dtype(), - self.element_dtype() - ); - vortex_ensure!( - array.len() == self.list_size() as usize, - "Array length {} does not match fixed list size {}", - array.len(), - self.list_size() - ); + vortex_ensure_eq!(array.dtype(), self.element_dtype()); + vortex_ensure_eq!(array.len(), self.list_size() as usize); self.elements_builder.append_array(array, ctx)?; self.nulls.append_non_null(); @@ -157,18 +147,8 @@ impl FixedSizeListBuilder { n: usize, ctx: &mut ExecutionCtx, ) -> VortexResult<()> { - vortex_ensure!( - array.dtype() == self.element_dtype(), - "Array dtype {:?} does not match list element dtype {:?}", - array.dtype(), - self.element_dtype() - ); - vortex_ensure!( - array.len() == self.list_size() as usize, - "Array length {} does not match fixed list size {}", - array.len(), - self.list_size() - ); + vortex_ensure_eq!(array.dtype(), self.element_dtype()); + vortex_ensure_eq!(array.len(), self.list_size() as usize); if n == 0 { return Ok(()); @@ -325,11 +305,10 @@ impl ArrayBuilder for FixedSizeListBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "FixedSizeListBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "FixedSizeListBuilder received a scalar with the wrong dtype" ); let list_scalar = scalar.as_list(); diff --git a/vortex-array/src/builders/list.rs b/vortex-array/src/builders/list.rs index 5e97f122cba..330397cb259 100644 --- a/vortex-array/src/builders/list.rs +++ b/vortex-array/src/builders/list.rs @@ -9,7 +9,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use crate::ArrayRef; @@ -137,12 +137,7 @@ impl ListBuilder { array: &ArrayRef, ctx: &mut ExecutionCtx, ) -> VortexResult<()> { - vortex_ensure!( - array.dtype() == self.element_dtype(), - "Array dtype {:?} does not match list element dtype {:?}", - array.dtype(), - self.element_dtype() - ); + vortex_ensure_eq!(array.dtype(), self.element_dtype()); self.elements_builder.append_array(array, ctx)?; self.nulls.append_non_null(); @@ -392,11 +387,10 @@ impl ArrayBuilder for ListBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "ListBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "ListBuilder received a scalar with the wrong dtype" ); self.append_value(scalar.as_list()) diff --git a/vortex-array/src/builders/listview.rs b/vortex-array/src/builders/listview.rs index a0c326b7f37..8b4ae44d656 100644 --- a/vortex-array/src/builders/listview.rs +++ b/vortex-array/src/builders/listview.rs @@ -17,6 +17,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use crate::ArrayRef; @@ -169,12 +170,7 @@ impl ListViewBuilder { array: &ArrayRef, ctx: &mut ExecutionCtx, ) -> VortexResult<()> { - vortex_ensure!( - array.dtype() == self.element_dtype(), - "Array dtype {:?} does not match list element dtype {:?}", - array.dtype(), - self.element_dtype() - ); + vortex_ensure_eq!(array.dtype(), self.element_dtype()); let curr_offset = self.elements_builder.len(); let num_elements = array.len(); @@ -254,12 +250,7 @@ impl ListViewBuilder { n: usize, ctx: &mut ExecutionCtx, ) -> VortexResult<()> { - vortex_ensure!( - array.dtype() == self.element_dtype(), - "Array dtype {:?} does not match list element dtype {:?}", - array.dtype(), - self.element_dtype() - ); + vortex_ensure_eq!(array.dtype(), self.element_dtype()); if n == 0 { return Ok(()); @@ -517,11 +508,10 @@ impl ArrayBuilder for ListViewBuil } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "ListViewBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "ListViewBuilder received a scalar with the wrong dtype" ); let list_scalar = scalar.as_list(); diff --git a/vortex-array/src/builders/map.rs b/vortex-array/src/builders/map.rs index 4169000d96f..ce39bee96bf 100644 --- a/vortex-array/src/builders/map.rs +++ b/vortex-array/src/builders/map.rs @@ -6,7 +6,7 @@ use std::sync::Arc; use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::Canonical; @@ -89,11 +89,10 @@ impl MapBuilder { /// Appends one map scalar. pub fn append_value(&mut self, value: MapScalar<'_>) -> VortexResult<()> { - vortex_ensure!( - value.dtype() == &self.dtype, - "MapBuilder expected map scalar with dtype {}, got {}", - self.dtype, - value.dtype() + vortex_ensure_eq!( + value.dtype(), + &self.dtype, + "MapBuilder received a map scalar with the wrong dtype" ); if value.is_null() { @@ -124,11 +123,10 @@ impl MapBuilder { array: ArrayView<'_, Map>, ctx: &mut ExecutionCtx, ) -> VortexResult<()> { - vortex_ensure!( - array.dtype() == self.dtype(), - "MapBuilder expected map array with dtype {}, got {}", + vortex_ensure_eq!( + array.dtype(), self.dtype(), - array.dtype() + "MapBuilder received a map array with the wrong dtype" ); self.entries_builder .append_listview_array(array.entries().as_::(), ctx) @@ -161,11 +159,10 @@ impl ArrayBuilder for MapBuilder VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "MapBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "MapBuilder received a scalar with the wrong dtype" ); self.append_value(scalar.as_map()) } diff --git a/vortex-array/src/builders/null.rs b/vortex-array/src/builders/null.rs index 541a27c2c89..12f1c9b9df7 100644 --- a/vortex-array/src/builders/null.rs +++ b/vortex-array/src/builders/null.rs @@ -4,7 +4,7 @@ use std::any::Any; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::ExecutionCtx; @@ -58,11 +58,10 @@ impl ArrayBuilder for NullBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "NullBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "NullBuilder received a scalar with the wrong dtype" ); self.append_null(); diff --git a/vortex-array/src/builders/primitive.rs b/vortex-array/src/builders/primitive.rs index 5f43e059a34..7165558dff3 100644 --- a/vortex-array/src/builders/primitive.rs +++ b/vortex-array/src/builders/primitive.rs @@ -8,7 +8,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_buffer::BufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_mask::Mask; use crate::ArrayRef; @@ -199,11 +199,10 @@ impl ArrayBuilder for PrimitiveBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "PrimitiveBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "PrimitiveBuilder received a scalar with the wrong dtype" ); if let Some(pv) = scalar.as_primitive().pvalue() { diff --git a/vortex-array/src/builders/struct_.rs b/vortex-array/src/builders/struct_.rs index 21f4361ee36..a91add298a1 100644 --- a/vortex-array/src/builders/struct_.rs +++ b/vortex-array/src/builders/struct_.rs @@ -8,7 +8,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use crate::ArrayRef; @@ -204,11 +204,10 @@ impl ArrayBuilder for StructBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "StructBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "StructBuilder received a scalar with the wrong dtype" ); self.append_value(scalar.as_struct()) diff --git a/vortex-array/src/builders/varbinview.rs b/vortex-array/src/builders/varbinview.rs index e27336fe998..e0252a83390 100644 --- a/vortex-array/src/builders/varbinview.rs +++ b/vortex-array/src/builders/varbinview.rs @@ -16,7 +16,7 @@ use vortex_buffer::ByteBufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_mask::AllOr; use vortex_mask::Mask; use vortex_utils::aliases::hash_map::Entry; @@ -835,11 +835,10 @@ impl ArrayBuilder for VarBinViewBuilder { } fn append_scalar(&mut self, scalar: &Scalar) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == self.dtype(), - "VarBinViewBuilder expected scalar with dtype {}, got {}", + vortex_ensure_eq!( + scalar.dtype(), self.dtype(), - scalar.dtype() + "VarBinViewBuilder received a scalar with the wrong dtype" ); match self.dtype() { diff --git a/vortex-array/src/dtype/union.rs b/vortex-array/src/dtype/union.rs index 30df46e2d80..62a6ab759d6 100644 --- a/vortex-array/src/dtype/union.rs +++ b/vortex-array/src/dtype/union.rs @@ -168,20 +168,8 @@ impl UnionVariants { impl UnionVariants { /// Validate that `names`, `dtypes`, and `type_ids` are mutually consistent. fn validate_shape(names: &FieldNames, n_dtypes: usize, type_ids: &[u8]) -> VortexResult<()> { - vortex_ensure_eq!( - names.len(), - n_dtypes, - "length mismatch between names ({}) and dtypes ({})", - names.len(), - n_dtypes - ); - vortex_ensure_eq!( - names.len(), - type_ids.len(), - "length mismatch between names ({}) and type_ids ({})", - names.len(), - type_ids.len() - ); + vortex_ensure_eq!(names.len(), n_dtypes); + vortex_ensure_eq!(names.len(), type_ids.len()); vortex_ensure!( !names.is_empty(), "union must have at least one variant (for now)" diff --git a/vortex-array/src/executor.rs b/vortex-array/src/executor.rs index 18afd45e16c..c07eebcc2e2 100644 --- a/vortex-array/src/executor.rs +++ b/vortex-array/src/executor.rs @@ -26,7 +26,7 @@ use std::sync::atomic::Ordering; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -602,13 +602,15 @@ fn finalize_done( }; if cfg!(debug_assertions) { - vortex_ensure!( - output.len() == expected_len, + vortex_ensure_eq!( + output.len(), + expected_len, "Result length mismatch for {:?}", encoding_id ); - vortex_ensure!( - output.dtype() == &expected_dtype, + vortex_ensure_eq!( + output.dtype(), + &expected_dtype, "Executed canonical dtype mismatch for {:?}", encoding_id ); @@ -634,12 +636,14 @@ fn execute_parent_for_child( for (_plugin_idx, plugin) in plugins.as_ref().iter().enumerate() { if let Some(result) = plugin.execute_parent(child, parent, slot_idx, ctx)? { if cfg!(debug_assertions) { - vortex_ensure!( - result.len() == parent.len(), + vortex_ensure_eq!( + result.len(), + parent.len(), "Executed parent canonical length mismatch" ); - vortex_ensure!( - result.dtype() == parent.dtype(), + vortex_ensure_eq!( + result.dtype(), + parent.dtype(), "Executed parent canonical dtype mismatch" ); } diff --git a/vortex-array/src/expr/transform/bound_partition.rs b/vortex-array/src/expr/transform/bound_partition.rs index 29c717e8dca..6bf6cf0629b 100644 --- a/vortex-array/src/expr/transform/bound_partition.rs +++ b/vortex-array/src/expr/transform/bound_partition.rs @@ -8,7 +8,7 @@ use std::hash::Hash; use itertools::Itertools; use vortex_error::VortexExpect; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_utils::aliases::hash_map::HashMap; use crate::dtype::DType; @@ -147,12 +147,7 @@ where /// Replace the partition expressions and update every root dtype in the recombination tree. pub fn replace_partitions(&mut self, partitions: Box<[BoundExpression]>) -> VortexResult<()> { - vortex_ensure!( - partitions.len() == self.partition_names.len(), - "Expected {} partitions, got {}", - self.partition_names.len(), - partitions.len() - ); + vortex_ensure_eq!(partitions.len(), self.partition_names.len()); let root_dtype = partition_root_dtype(&self.partition_names, &partitions); let root = replace_root_dtype(self.root.clone(), root_dtype)?; diff --git a/vortex-array/src/extension/datetime/date.rs b/vortex-array/src/extension/datetime/date.rs index 8cbe5b019c2..1920af1a85f 100644 --- a/vortex-array/src/extension/datetime/date.rs +++ b/vortex-array/src/extension/datetime/date.rs @@ -8,6 +8,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::registry::CachedId; @@ -99,11 +100,11 @@ impl ExtVTable for Date { let ptype = date_ptype(metadata) .ok_or_else(|| vortex_err!("Date type does not support time unit {}", metadata))?; - vortex_ensure!( - ext_dtype.storage_dtype().as_ptype() == ptype, - "Date storage dtype for {} must be {}", - metadata, - ptype + vortex_ensure_eq!( + ext_dtype.storage_dtype().as_ptype(), + ptype, + "Date storage dtype for {} has the wrong ptype", + metadata ); Ok(()) diff --git a/vortex-array/src/extension/datetime/time.rs b/vortex-array/src/extension/datetime/time.rs index 125845e758c..750a1a183f7 100644 --- a/vortex-array/src/extension/datetime/time.rs +++ b/vortex-array/src/extension/datetime/time.rs @@ -8,6 +8,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::registry::CachedId; @@ -100,11 +101,11 @@ impl ExtVTable for Time { let ptype = time_ptype(metadata) .ok_or_else(|| vortex_err!("Time type does not support time unit {}", metadata))?; - vortex_ensure!( - ext_dtype.storage_dtype().as_ptype() == ptype, - "Time storage dtype for {} must be {}", - metadata, - ptype + vortex_ensure_eq!( + ext_dtype.storage_dtype().as_ptype(), + ptype, + "Time storage dtype for {} has the wrong ptype", + metadata ); Ok(()) diff --git a/vortex-array/src/extension/tests/divisible_int.rs b/vortex-array/src/extension/tests/divisible_int.rs index 2e42f9fa138..8ee2f960b69 100644 --- a/vortex-array/src/extension/tests/divisible_int.rs +++ b/vortex-array/src/extension/tests/divisible_int.rs @@ -8,6 +8,7 @@ use std::fmt; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::dtype::DType; use crate::dtype::PType; @@ -44,7 +45,7 @@ impl ExtVTable for DivisibleInt { } fn deserialize_metadata(&self, data: &[u8]) -> VortexResult { - vortex_ensure!(data.len() == 8, "divisible int metadata must be 8 bytes"); + vortex_ensure_eq!(data.len(), 8, "divisible int metadata has the wrong length"); let bytes: [u8; 8] = data .try_into() .map_err(|_| vortex_error::vortex_err!("divisible int metadata must be 8 bytes"))?; diff --git a/vortex-array/src/optimizer/rules.rs b/vortex-array/src/optimizer/rules.rs index 8539e39aea2..90c5e4a7381 100644 --- a/vortex-array/src/optimizer/rules.rs +++ b/vortex-array/src/optimizer/rules.rs @@ -191,15 +191,17 @@ impl ParentRuleSet { // Debug assertions because these checks are already run elsewhere. #[cfg(debug_assertions)] { - vortex_error::vortex_ensure!( - reduced.len() == parent.len(), + vortex_error::vortex_ensure_eq!( + reduced.len(), + parent.len(), "Reduced array length mismatch from {:?}\nFrom:\n{}\nTo:\n{}", rule, parent.encoding_id(), reduced.encoding_id() ); - vortex_error::vortex_ensure!( - reduced.dtype() == parent.dtype(), + vortex_error::vortex_ensure_eq!( + reduced.dtype(), + parent.dtype(), "Reduced array dtype mismatch from {:?}\nFrom:\n{}\nTo:\n{}", rule, parent.encoding_id(), diff --git a/vortex-array/src/patches.rs b/vortex-array/src/patches.rs index 8cef6f6add5..d4249521ed7 100644 --- a/vortex-array/src/patches.rs +++ b/vortex-array/src/patches.rs @@ -14,6 +14,7 @@ use vortex_error::VortexExpect as _; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::AllOr; use vortex_mask::Mask; @@ -246,10 +247,7 @@ impl Patches { values: ArrayRef, chunk_offsets: Option, ) -> VortexResult { - vortex_ensure!( - indices.len() == values.len(), - "Patch indices and values must have the same length" - ); + vortex_ensure_eq!(indices.len(), values.len()); vortex_ensure!( indices.dtype().is_unsigned_int() && !indices.dtype().is_nullable(), "Patch indices must be non-nullable unsigned integers, got {:?}", diff --git a/vortex-array/src/scalar/constructor.rs b/vortex-array/src/scalar/constructor.rs index 3ea25be816e..7a0b37ad585 100644 --- a/vortex-array/src/scalar/constructor.rs +++ b/vortex-array/src/scalar/constructor.rs @@ -279,8 +279,7 @@ impl Scalar { vortex_ensure_eq!( child.dtype(), &expected_dtype, - "union type ID {type_id} selects child dtype {expected_dtype}, got {}", - child.dtype() + "union type ID {type_id} selects a different child dtype" ); Self::try_new( diff --git a/vortex-array/src/scalar/proto.rs b/vortex-array/src/scalar/proto.rs index eab8ea23099..3a1100c43db 100644 --- a/vortex-array/src/scalar/proto.rs +++ b/vortex-array/src/scalar/proto.rs @@ -459,10 +459,9 @@ fn list_from_proto( .collect::>>()?, DType::Struct(fields, _) => { vortex_ensure_eq!( - v.values.len(), fields.nfields(), - Serde: "expected {} struct fields in ListValue, got {}", + v.values.len(), fields.nfields(), - v.values.len() + Serde: "ListValue has the wrong number of struct fields" ); v.values diff --git a/vortex-array/src/scalar/typed_view/primitive/scalar.rs b/vortex-array/src/scalar/typed_view/primitive/scalar.rs index 3ca4d337a45..a1e27d679ab 100644 --- a/vortex-array/src/scalar/typed_view/primitive/scalar.rs +++ b/vortex-array/src/scalar/typed_view/primitive/scalar.rs @@ -19,7 +19,7 @@ use vortex_error::VortexError; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use super::pvalue::CoercePValue; @@ -152,11 +152,10 @@ impl<'a> PrimitiveScalar<'a> { /// /// Returns an error if the primitive type of this scalar does not match the requested type. pub fn try_typed_value(&self) -> VortexResult> { - vortex_ensure!( - self.ptype == T::PTYPE, - "Attempting to read {} scalar as {}", + vortex_ensure_eq!( self.ptype, - T::PTYPE + T::PTYPE, + "Attempting to read a primitive scalar as the wrong type" ); if let Some(pv) = self.pvalue { diff --git a/vortex-array/src/scalar/validate.rs b/vortex-array/src/scalar/validate.rs index d6dba2c34b4..0c03da781f8 100644 --- a/vortex-array/src/scalar/validate.rs +++ b/vortex-array/src/scalar/validate.rs @@ -93,7 +93,7 @@ impl Scalar { vortex_ensure_eq!( len, *size as usize, - "fixed-size list dtype expected {size} elements, got {len}", + "fixed-size list scalar has the wrong number of elements", ); for (i, element) in elements.iter().enumerate() { @@ -121,8 +121,7 @@ impl Scalar { vortex_ensure_eq!( values.len(), 2, - "map entry at index {index} expected 2 values, got {}", - values.len(), + "map entry at index {index} has the wrong number of values", ); Self::validate(&key_dtype, values[0].as_ref()).map_err(|error| { @@ -143,7 +142,7 @@ impl Scalar { vortex_ensure_eq!( nvalues, nfields, - "struct dtype expected {nfields} fields, got {nvalues}", + "struct scalar has the wrong number of fields", ); for (field, field_value) in fields.fields().zip(values.iter()) { diff --git a/vortex-array/src/scalar_fn/fns/binary/numeric/mod.rs b/vortex-array/src/scalar_fn/fns/binary/numeric/mod.rs index a0c427b142e..c96aa433ba4 100644 --- a/vortex-array/src/scalar_fn/fns/binary/numeric/mod.rs +++ b/vortex-array/src/scalar_fn/fns/binary/numeric/mod.rs @@ -19,6 +19,7 @@ use decimal::execute_numeric_decimal; use row::execute_numeric_primitive; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::Canonical; @@ -49,11 +50,10 @@ pub(crate) fn execute_numeric( dtype ); - vortex_ensure!( - lhs.len() == rhs.len(), - "numeric operator requires equal lengths, got {} and {}", + vortex_ensure_eq!( lhs.len(), - rhs.len() + rhs.len(), + "numeric operator requires equal lengths" ); if lhs.is_empty() { diff --git a/vortex-array/src/scalar_fn/fns/byte_length.rs b/vortex-array/src/scalar_fn/fns/byte_length.rs index 91c463c519a..4113b1f02e4 100644 --- a/vortex-array/src/scalar_fn/fns/byte_length.rs +++ b/vortex-array/src/scalar_fn/fns/byte_length.rs @@ -6,7 +6,7 @@ use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -53,7 +53,7 @@ impl ExecuteParentKernel for ByteLengthExecuteAdaptor child_idx: usize, ctx: &mut ExecutionCtx, ) -> VortexResult> { - vortex_ensure!(child_idx == 0); + vortex_ensure_eq!(child_idx, 0); V::byte_length(array, ctx) } } diff --git a/vortex-array/src/scalar_fn/fns/mask/mod.rs b/vortex-array/src/scalar_fn/fns/mask/mod.rs index 42f1441059d..7c18cc13eeb 100644 --- a/vortex-array/src/scalar_fn/fns/mask/mod.rs +++ b/vortex-array/src/scalar_fn/fns/mask/mod.rs @@ -6,7 +6,7 @@ mod kernel; pub use kernel::*; use vortex_error::VortexExpect; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -91,10 +91,10 @@ impl ScalarFnVTable for Mask { } fn return_dtype(&self, _options: &Self::Options, arg_dtypes: &[DType]) -> VortexResult { - vortex_ensure!( - arg_dtypes[1] == DType::Bool(Nullability::NonNullable), - "The mask argument to 'mask' must be a non-nullable boolean array, got {}", - arg_dtypes[1] + vortex_ensure_eq!( + arg_dtypes[1], + DType::Bool(Nullability::NonNullable), + "The mask argument to 'mask' must be a non-nullable boolean array" ); Ok(arg_dtypes[0].as_nullable()) } diff --git a/vortex-array/src/scalar_fn/internal/row_count.rs b/vortex-array/src/scalar_fn/internal/row_count.rs index 1b94d45ed66..bc217db75bf 100644 --- a/vortex-array/src/scalar_fn/internal/row_count.rs +++ b/vortex-array/src/scalar_fn/internal/row_count.rs @@ -20,7 +20,7 @@ use vortex_array::scalar_fn::ScalarFnId; use vortex_array::scalar_fn::ScalarFnVTable; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::registry::CachedId; /// Zero-argument placeholder for the row count of the current evaluation scope. @@ -119,17 +119,15 @@ pub fn contains_row_count(array: &ArrayRef) -> bool { /// [`ScalarFnArray`]: vortex_array::arrays::ScalarFnArray pub fn substitute_row_count(array: ArrayRef, replacement: &ArrayRef) -> VortexResult { if array.is::>() { - vortex_ensure!( - replacement.len() == array.len(), - "RowCount replacement length {} does not match scope length {}", + vortex_ensure_eq!( replacement.len(), array.len(), + "RowCount replacement length does not match scope length", ); - vortex_ensure!( - replacement.dtype() == array.dtype(), - "RowCount replacement dtype {} does not match scope dtype {}", + vortex_ensure_eq!( replacement.dtype(), array.dtype(), + "RowCount replacement dtype does not match scope dtype", ); return Ok(replacement.clone()); } diff --git a/vortex-array/src/scalar_fn/typed.rs b/vortex-array/src/scalar_fn/typed.rs index f2c3c479ad5..aa5ba2d36b6 100644 --- a/vortex-array/src/scalar_fn/typed.rs +++ b/vortex-array/src/scalar_fn/typed.rs @@ -154,12 +154,11 @@ impl DynScalarFn for TypedScalarFnInstance { #[cfg(debug_assertions)] { - vortex_error::vortex_ensure!( - result.dtype() == &expected_dtype, - "Expression execution {} returned vector of invalid dtype. Expected {}, got {}", - self.vtable.id(), - expected_dtype, + vortex_error::vortex_ensure_eq!( result.dtype(), + &expected_dtype, + "Expression execution {} returned vector of invalid dtype", + self.vtable.id(), ); } diff --git a/vortex-array/src/scalar_fn/unstable/row/batch/execute/output.rs b/vortex-array/src/scalar_fn/unstable/row/batch/execute/output.rs index 3a83fba60e1..6afea5798dd 100644 --- a/vortex-array/src/scalar_fn/unstable/row/batch/execute/output.rs +++ b/vortex-array/src/scalar_fn/unstable/row/batch/execute/output.rs @@ -85,15 +85,14 @@ fn validate_output( vortex_ensure_eq!( values.len(), expected_len, - "the {id} kernel output must contain {expected_len} rows, got {}", - values.len(), + "the {id} kernel output has the wrong row count", ); let values_with_result_nullability = values.dtype().with_nullability(result_dtype.nullability()); - vortex_ensure!( - values_with_result_nullability == *result_dtype, - "the {id} output dtype must match {result_dtype} except for outer nullability, got {}", - values.dtype(), + vortex_ensure_eq!( + values_with_result_nullability, + *result_dtype, + "the {id} output dtype must match the result dtype except for outer nullability", ); Ok(()) diff --git a/vortex-array/src/scalar_fn/unstable/row/batch/planning.rs b/vortex-array/src/scalar_fn/unstable/row/batch/planning.rs index 0b7eb0aa728..1ae3d525437 100644 --- a/vortex-array/src/scalar_fn/unstable/row/batch/planning.rs +++ b/vortex-array/src/scalar_fn/unstable/row/batch/planning.rs @@ -33,8 +33,7 @@ impl RowFnExecutionArgs { vortex_ensure_eq!( input.len(), row_count, - "the {id} input {index} must have {row_count} rows, got {}", - input.len(), + "the {id} input {index} has the wrong row count", ); } diff --git a/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs b/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs index d2ae3bdf93f..fbb98bdc35f 100644 --- a/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs +++ b/vortex-array/src/scalar_fn/unstable/row/batch/tests.rs @@ -1444,7 +1444,7 @@ fn test_declared_output_dtype_rejects_mismatched_storage() -> VortexResult<()> { .to_string(); assert!( - error.contains("must store"), + error.contains("has the wrong storage dtype"), "the label error must report the expected storage dtype, got {error}", ); Ok(()) diff --git a/vortex-array/src/scalar_fn/unstable/row/execute/owned.rs b/vortex-array/src/scalar_fn/unstable/row/execute/owned.rs index 8a0b826a461..b73b255223c 100644 --- a/vortex-array/src/scalar_fn/unstable/row/execute/owned.rs +++ b/vortex-array/src/scalar_fn/unstable/row/execute/owned.rs @@ -136,8 +136,7 @@ where vortex_ensure_eq!( valid.true_count(), filtered_len, - "the filtered batch must contain one row per valid row: {} valid rows, got {filtered_len}", - valid.true_count(), + "the filtered batch must contain one row per valid row", ); let prepared = prepare(Args::const_values(&columns)); @@ -216,8 +215,7 @@ where vortex_ensure_eq!( valid_rows.len(), row_count, - "the validity mask must address exactly {row_count} rows, got {}", - valid_rows.len(), + "the validity mask has the wrong row count", ); let prepared = prepare(Args::const_values(&columns)); diff --git a/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs b/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs index 000521ff8d6..133d131aeca 100644 --- a/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs +++ b/vortex-array/src/scalar_fn/unstable/row/execute/sink.rs @@ -56,7 +56,7 @@ where vortex_ensure_eq!( sink_row_count, row_count, - "the output sink must address exactly {row_count} rows, got {sink_row_count}", + "the output sink has the wrong row count", ); let views = Args::views_if_no_consts(&columns); @@ -140,7 +140,7 @@ where vortex_ensure_eq!( initialized_row_count, row_count, - "the initialized output sink must address exactly {row_count} rows, got {initialized_row_count}", + "the initialized output sink has the wrong row count", ); if let Some(views) = views { @@ -204,8 +204,7 @@ where vortex_ensure_eq!( valid.true_count(), filtered_len, - "the filtered batch must contain one row per valid row: {} valid rows, got {filtered_len}", - valid.true_count(), + "the filtered batch must contain one row per valid row", ); let original_len = valid.len(); @@ -228,7 +227,7 @@ where vortex_ensure_eq!( initialized_row_count, original_len, - "the initialized output sink must address exactly {original_len} rows, got {initialized_row_count}", + "the initialized output sink has the wrong row count", ); let mut filtered_index = 0; @@ -324,8 +323,7 @@ where vortex_ensure_eq!( valid_rows.len(), row_count, - "the validity mask must address exactly {row_count} rows, got {}", - valid_rows.len(), + "the validity mask has the wrong row count", ); Ok(Some(ValidRowsSetup { @@ -421,7 +419,7 @@ mod tests { assert!( error .to_string() - .contains("initialized output sink must address exactly 2 rows, got 1"), + .contains("initialized output sink has the wrong row count"), "unexpected error: {error}", ); diff --git a/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs b/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs index 5f1e3fd2dd9..791397a8863 100644 --- a/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs +++ b/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs @@ -40,11 +40,7 @@ unsafe impl InputElement for T { let DType::Primitive(ptype, _) = dtype else { vortex_bail!("expected a {expected} column, got {dtype}"); }; - vortex_ensure_eq!( - *ptype, - expected, - "expected a {expected} column, got {dtype}" - ); + vortex_ensure_eq!(*ptype, expected); Ok(()) } diff --git a/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/element_tuple.rs b/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/element_tuple.rs index f035ab9cd19..77a0c13574d 100644 --- a/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/element_tuple.rs +++ b/vortex-array/src/scalar_fn/unstable/row/types/element/tuple/element_tuple.rs @@ -247,12 +247,7 @@ impl ElementTuple for () { const DECODE_INFALLIBLE: bool = true; fn validate(dtypes: &[DType]) -> VortexResult<()> { - vortex_ensure_eq!( - dtypes.len(), - 0, - "expected 0 argument dtypes, got {}", - dtypes.len(), - ); + vortex_ensure_eq!(dtypes.len(), 0); Ok(()) } @@ -311,13 +306,7 @@ macro_rules! element_tuple { const DECODE_INFALLIBLE: bool = $($t::DECODE_INFALLIBLE &&)+ true; fn validate(dtypes: &[DType]) -> VortexResult<()> { - vortex_ensure_eq!( - dtypes.len(), - $arity, - "expected {} argument dtypes, got {}", - $arity, - dtypes.len(), - ); + vortex_ensure_eq!(dtypes.len(), $arity); $($t::validate(&dtypes[$idx])?;)+ Ok(()) diff --git a/vortex-array/src/scalar_fn/unstable/row/visitor/plan.rs b/vortex-array/src/scalar_fn/unstable/row/visitor/plan.rs index 50ed6a3faf5..7e911681f7d 100644 --- a/vortex-array/src/scalar_fn/unstable/row/visitor/plan.rs +++ b/vortex-array/src/scalar_fn/unstable/row/visitor/plan.rs @@ -223,9 +223,8 @@ impl BatchPlan { /// Ensure an executing dispatch reproduced the planned output and policy. pub(crate) fn ensure_reproduced_by(&self, actual: &Self) -> VortexResult<()> { - vortex_ensure_eq!( - actual.policy, - self.policy, + vortex_ensure!( + actual.policy == self.policy, "row dispatch must select the planned nullable execution policy: planned {:?}, got {:?}", self.policy, actual.policy, @@ -233,9 +232,7 @@ impl BatchPlan { vortex_ensure_eq!( actual.storage_dtype, self.storage_dtype, - "row dispatch must select the planned storage dtype: planned {}, got {}", - self.storage_dtype, - actual.storage_dtype, + "row dispatch must select the planned storage dtype", ); vortex_ensure!( actual.output_label == self.output_label, @@ -281,8 +278,7 @@ fn validate_output_label( vortex_ensure_eq!( *output_label.storage_dtype(), *storage_dtype, - "a declared row extension output dtype must store {storage_dtype}, got {}", - output_label.storage_dtype(), + "a declared row extension output dtype has the wrong storage dtype", ); Ok(Some(output_label)) diff --git a/vortex-array/src/scalar_fn/unstable/row/vtable.rs b/vortex-array/src/scalar_fn/unstable/row/vtable.rs index b68fd24c164..4726f5bae98 100644 --- a/vortex-array/src/scalar_fn/unstable/row/vtable.rs +++ b/vortex-array/src/scalar_fn/unstable/row/vtable.rs @@ -156,7 +156,7 @@ fn ensure_arity(function: &F, actual: usize) -> VortexResult<()> { vortex_ensure_eq!( actual, expected, - "row function {} requires arity {expected}, got {actual}", + "row function {} has the wrong arity", RowFn::id(function), ); @@ -430,7 +430,7 @@ mod tests { #[track_caller] fn assert_arity_error(error: VortexError) { assert!( - error.to_string().contains("requires arity 1, got 0"), + error.to_string().contains("has the wrong arity"), "unexpected error: {error}", ); } diff --git a/vortex-array/src/serde.rs b/vortex-array/src/serde.rs index 21db181d52e..30d81c60976 100644 --- a/vortex-array/src/serde.rs +++ b/vortex-array/src/serde.rs @@ -774,6 +774,7 @@ mod tests { use vortex_buffer::ByteBufferMut; use vortex_error::vortex_ensure; + use vortex_error::vortex_ensure_eq; use vortex_session::registry::CachedId; use super::*; @@ -814,10 +815,10 @@ mod tests { array: &ArrayRef, _session: &VortexSession, ) -> VortexResult> { - vortex_ensure!( - array.encoding_id() == self.id(), - "versioned primitive serializer received {}", + vortex_ensure_eq!( array.encoding_id(), + self.id(), + "versioned primitive serializer received a different encoding", ); let serialized_id = if array.len() <= 4 { diff --git a/vortex-array/src/test_harness/trace/tests.rs b/vortex-array/src/test_harness/trace/tests.rs index bfe99c3857b..6f7da485bb9 100644 --- a/vortex-array/src/test_harness/trace/tests.rs +++ b/vortex-array/src/test_harness/trace/tests.rs @@ -11,6 +11,7 @@ use smallvec::smallvec; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -153,14 +154,14 @@ impl VTable for StackParent { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!(dtype == &test_dtype(), "unexpected stack parent dtype"); - vortex_ensure!(len == 3, "unexpected stack parent length"); - vortex_ensure!(slots.len() == 1, "stack parent must have one child slot"); + vortex_ensure_eq!(dtype, &test_dtype(), "unexpected stack parent dtype"); + vortex_ensure_eq!(len, 3, "unexpected stack parent length"); + vortex_ensure_eq!(slots.len(), 1, "unexpected stack parent slot count"); let Some(child) = &slots[0] else { vortex_bail!("stack parent child slot is missing"); }; - vortex_ensure!(child.dtype() == dtype, "stack parent child dtype mismatch"); - vortex_ensure!(child.len() == len, "stack parent child length mismatch"); + vortex_ensure_eq!(child.dtype(), dtype, "stack parent child dtype mismatch"); + vortex_ensure_eq!(child.len(), len, "stack parent child length mismatch"); Ok(()) } @@ -267,8 +268,8 @@ impl VTable for StackChild { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!(dtype == &test_dtype(), "unexpected stack child dtype"); - vortex_ensure!(len == 3, "unexpected stack child length"); + vortex_ensure_eq!(dtype, &test_dtype(), "unexpected stack child dtype"); + vortex_ensure_eq!(len, 3, "unexpected stack child length"); vortex_ensure!(slots.is_empty(), "stack child must not have slots"); Ok(()) } From c37781206b71afd2ca2d4a2b60c0fe0bf3c5a026 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 19:12:19 +0000 Subject: [PATCH 3/8] Drop redundant vortex_ensure_eq! messages in encodings Remove custom messages that only restated the compared values, and turn plain equality vortex_ensure! checks into vortex_ensure_eq!. Messages that add context are kept without the values. Claude-Session: https://claude.ai/code/session_01YUXDBd65US5mcKTxb2Xcer Signed-off-by: Claude --- encodings/alp/src/alp/array.rs | 34 +++------- encodings/alp/src/alp/plugin.rs | 8 +-- encodings/alp/src/alp_rd/array.rs | 34 +++------- encodings/bytebool/src/array.rs | 21 ++----- encodings/datetime-parts/src/array.rs | 4 +- .../src/decimal_byte_parts/array.rs | 14 ++--- .../src/decimal_byte_parts/assemble.rs | 7 +-- .../src/decimal_byte_parts/plugin/v1.rs | 13 ++-- .../src/decimal_byte_parts/plugin/v2.rs | 8 +-- .../fastlanes/src/bitpacking/array/mod.rs | 21 +++---- .../src/bitpacking/array/unpack_iter.rs | 7 +-- encodings/fastlanes/src/bitpacking/plugin.rs | 16 ++--- .../fastlanes/src/bitpacking/vtable/mod.rs | 8 +-- encodings/fastlanes/src/delta/vtable/mod.rs | 12 +--- encodings/fastlanes/src/for_/plugin/v2.rs | 11 ++-- encodings/fastlanes/src/for_/vtable/mod.rs | 29 ++++----- encodings/fastlanes/src/rle/vtable/mod.rs | 14 ++--- encodings/fastlanes/src/transposed_bool.rs | 22 +++---- encodings/fsst/src/array.rs | 14 ++--- encodings/fsst/src/canonical.rs | 7 +-- encodings/onpair/src/array.rs | 7 +-- encodings/onpair/src/canonical.rs | 9 +-- encodings/onpair/src/decode.rs | 8 +-- encodings/onpair/src/ops.rs | 6 +- encodings/parquet-variant/src/vtable.rs | 7 +-- encodings/pco/src/array.rs | 62 ++++++------------- encodings/runend/src/array.rs | 20 ++---- encodings/sparse/src/lib.rs | 43 +++---------- encodings/uuid/src/vtable.rs | 17 ++--- encodings/zigzag/src/array.rs | 13 +--- encodings/zstd/src/array.rs | 47 +++++--------- encodings/zstd/src/lib.rs | 9 +-- encodings/zstd/src/zstd_buffers.rs | 8 +-- 33 files changed, 182 insertions(+), 378 deletions(-) diff --git a/encodings/alp/src/alp/array.rs b/encodings/alp/src/alp/array.rs index 3e2010a1ad5..45530a53733 100644 --- a/encodings/alp/src/alp/array.rs +++ b/encodings/alp/src/alp/array.rs @@ -42,6 +42,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -288,12 +289,7 @@ impl ALPData { // Validate patches if let Some(patches) = patches { - vortex_ensure!( - patches.array_len() == encoded.len(), - "patches array_len != encoded len: {} != {}", - patches.array_len(), - encoded.len() - ); + vortex_ensure_eq!(patches.array_len(), encoded.len()); // Verify that the patches DType are of the proper DType. } @@ -318,19 +314,10 @@ impl ALPData { patches: &Patches, encoded: &ArrayRef, ) -> VortexResult<()> { - vortex_ensure!( - patches.array_len() == encoded.len(), - "patches array_len != encoded len: {} != {}", - patches.array_len(), - encoded.len() - ); + vortex_ensure_eq!(patches.array_len(), encoded.len()); let expected_type = DType::Primitive(T::PTYPE, encoded.dtype().nullability()); - vortex_ensure!( - patches.dtype() == &expected_type, - "Expected patches type {expected_type}, actual {}", - patches.dtype(), - ); + vortex_ensure_eq!(patches.dtype(), &expected_type); Ok(()) } @@ -443,16 +430,11 @@ fn validate_parts( ) -> VortexResult<()> { let logical_dtype = ALPData::logical_dtype(encoded)?; ALPData::validate_components(encoded, exponents, patches.as_ref())?; - vortex_ensure!( - encoded.len() == len, - "ALP encoded len {} != outer len {len}", - encoded.len(), - ); - vortex_ensure!( - &logical_dtype == dtype, - "ALP dtype {} does not match encoded logical dtype {}", + vortex_ensure_eq!(encoded.len(), len, "ALP encoded len must match outer len"); + vortex_ensure_eq!( + &logical_dtype, dtype, - logical_dtype, + "ALP dtype does not match encoded logical dtype" ); Ok(()) } diff --git a/encodings/alp/src/alp/plugin.rs b/encodings/alp/src/alp/plugin.rs index 5756dc5a991..68aaa1c9972 100644 --- a/encodings/alp/src/alp/plugin.rs +++ b/encodings/alp/src/alp/plugin.rs @@ -17,7 +17,7 @@ use vortex_array::IntoArray; use vortex_array::VortexSessionExecute; use vortex_array::arrays::Patched; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::VortexSession; @@ -52,10 +52,10 @@ impl ArrayPlugin for ALPPatchedPlugin { parts: ArrayDeserialization<'_>, session: &VortexSession, ) -> VortexResult { - vortex_ensure!( - parts.serialized_id == self.id(), - "ALP plugin does not recognize serialized ID {}", + vortex_ensure_eq!( parts.serialized_id, + self.id(), + "ALP plugin does not recognize serialized ID" ); let alp_array = Array::::try_from_parts(ArrayVTable::deserialize( &ALP, diff --git a/encodings/alp/src/alp_rd/array.rs b/encodings/alp/src/alp_rd/array.rs index b6ee50d7b1f..f3d0677e860 100644 --- a/encodings/alp/src/alp_rd/array.rs +++ b/encodings/alp/src/alp_rd/array.rs @@ -45,7 +45,7 @@ use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -475,16 +475,8 @@ fn validate_parts( vortex_bail!("ALPRDArray given invalid DType ({dtype})"); } - vortex_ensure!( - left_parts.len() == len, - "left_parts len {} != outer len {len}", - left_parts.len(), - ); - vortex_ensure!( - right_parts.len() == len, - "right_parts len {} != outer len {len}", - right_parts.len(), - ); + vortex_ensure_eq!(left_parts.len(), len); + vortex_ensure_eq!(right_parts.len(), len); if !left_parts.dtype().is_unsigned_int() { vortex_bail!("left_parts dtype must be uint"); @@ -502,29 +494,19 @@ fn validate_parts( DType::Primitive(PType::F64, _) => DType::Primitive(PType::U64, Nullability::NonNullable), _ => vortex_bail!("Expected f32 or f64 dtype, got {:?}", dtype), }; - vortex_ensure!( - right_parts.dtype() == &expected_right_parts_dtype, - "right_parts dtype {} does not match expected {}", - right_parts.dtype(), - expected_right_parts_dtype, - ); + vortex_ensure_eq!(right_parts.dtype(), &expected_right_parts_dtype); if let Some(patches) = left_parts_patches { - vortex_ensure!( - patches.array_len() == len, - "patches array_len {} != outer len {len}", - patches.array_len(), - ); + vortex_ensure_eq!(patches.array_len(), len); // Left-parts exceptions are always all-valid and are stored as the non-nullable left-parts // dtype. Requiring that exact dtype (rather than ignoring nullability) means each // construction path must produce correct patches, removing the need to normalize them. // Non-nullable also implies all-valid, so no separate validity check is required. let expected = left_parts.dtype().as_nonnullable(); - vortex_ensure!( - patches.dtype() == &expected, - "patches dtype {} must be the non-nullable left_parts dtype {}", + vortex_ensure_eq!( patches.dtype(), - expected, + &expected, + "patches dtype must be the non-nullable left_parts dtype" ); } diff --git a/encodings/bytebool/src/array.rs b/encodings/bytebool/src/array.rs index 02bb4fcb2b8..01985f0ce76 100644 --- a/encodings/bytebool/src/array.rs +++ b/encodings/bytebool/src/array.rs @@ -35,7 +35,7 @@ use vortex_buffer::BitBufferMut; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -101,11 +101,7 @@ impl VTable for ByteBool { array: ArrayView<'_, Self>, buffers: &[BufferHandle], ) -> VortexResult> { - vortex_ensure!( - buffers.len() == 1, - "Expected 1 buffer, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 1); let data = ByteBoolData::new(buffers[0].clone()); Ok( ArrayParts::new(self.clone(), array.dtype().clone(), array.len(), data) @@ -260,17 +256,10 @@ impl ByteBoolData { len: usize, ) -> VortexResult<()> { let expected_dtype = DType::Bool(validity.nullability()); - vortex_ensure!( - dtype == &expected_dtype, - "expected dtype {expected_dtype}, got {dtype}" - ); - vortex_ensure!( - buffer.len() == len, - "expected len {len}, got {}", - buffer.len() - ); + vortex_ensure_eq!(dtype, &expected_dtype); + vortex_ensure_eq!(buffer.len(), len); if let Some(vlen) = validity.maybe_len() { - vortex_ensure!(vlen == len, "expected validity len {len}, got {vlen}"); + vortex_ensure_eq!(vlen, len); } Ok(()) } diff --git a/encodings/datetime-parts/src/array.rs b/encodings/datetime-parts/src/array.rs index 30594c78367..744d650c73c 100644 --- a/encodings/datetime-parts/src/array.rs +++ b/encodings/datetime-parts/src/array.rs @@ -34,7 +34,7 @@ use vortex_array::vtable::ValidityChild; use vortex_array::vtable::ValidityVTableFromChild; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -309,7 +309,7 @@ impl DateTimePartsData { subseconds: &ArrayRef, len: usize, ) -> VortexResult<()> { - vortex_ensure!(days.len() == len, "expected len {len}, got {}", days.len()); + vortex_ensure_eq!(days.len(), len); if !days.dtype().is_int() || (dtype.is_nullable() != days.dtype().is_nullable()) { vortex_bail!( diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs index c1826ae46d4..592ca900909 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/array.rs @@ -34,6 +34,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -96,11 +97,8 @@ impl DecimalBytePartsData { } let expected_dtype = DType::Decimal(decimal_dtype, msp.dtype().nullability()); - vortex_ensure!( - dtype == &expected_dtype, - "expected dtype {expected_dtype}, got {dtype}" - ); - vortex_ensure!(msp.len() == len, "expected len {len}, got {}", msp.len()); + vortex_ensure_eq!(dtype, &expected_dtype); + vortex_ensure_eq!(msp.len(), len); let lower_part_count = lower_parts.len(); @@ -114,11 +112,7 @@ impl DecimalBytePartsData { "lower part {idx} must have a non-nullable unsigned integer dtype, got {}", part.dtype() ); - vortex_ensure!( - part.len() == len, - "lower part {idx} has len {}, expected {len}", - part.len() - ); + vortex_ensure_eq!(part.len(), len, "lower part {idx} length mismatch"); } Ok(()) } diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs index 35d93d4da1e..87389120bcf 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/assemble.rs @@ -23,6 +23,7 @@ use vortex_buffer::trusted_len::TrustedLen; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use super::LOWER_PART_BITS; use super::LOWER_PART_DTYPE; @@ -72,11 +73,7 @@ pub fn assemble_decimal( "lower part {idx} must have a non-nullable unsigned integer dtype, got {}", part.dtype() ); - vortex_ensure!( - part.len() == len, - "lower part {idx} has len {}, expected {len}", - part.len() - ); + vortex_ensure_eq!(part.len(), len, "lower part {idx} length mismatch"); } assemble_wide_decimal_from_arrays(msp, lower_parts, validity, decimal_dtype, exec_ctx) diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v1.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v1.rs index ec816c62736..b35824dffd1 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v1.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v1.rs @@ -14,6 +14,7 @@ use vortex_array::dtype::PType; use vortex_array::smallvec::smallvec; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use super::decimal_byte_parts_v1_id; use crate::DecimalByteParts; @@ -51,8 +52,9 @@ pub(super) fn serialize( } pub(super) fn deserialize(parts: ArrayDeserialization<'_>) -> VortexResult { - vortex_ensure!( - parts.serialized_id == decimal_byte_parts_v1_id(), + vortex_ensure_eq!( + parts.serialized_id, + decimal_byte_parts_v1_id(), "expected the v1 format" ); let metadata = DecimalBytePartsMetadata::decode(parts.metadata)?; @@ -60,11 +62,12 @@ pub(super) fn deserialize(parts: ArrayDeserialization<'_>) -> VortexResult) -> VortexResult( ); let elems_per_chunk = 128 * bit_width / size_of::(); let num_chunks = (offset + len).div_ceil(CHUNK_SIZE); - vortex_ensure!( - packed_len == num_chunks * elems_per_chunk, - "Invalid packed length: got {packed_len}, expected {}", - num_chunks * elems_per_chunk - ); + vortex_ensure_eq!(packed_len, num_chunks * elems_per_chunk); Ok((num_chunks, (offset + len) % CHUNK_SIZE)) } diff --git a/encodings/fastlanes/src/bitpacking/plugin.rs b/encodings/fastlanes/src/bitpacking/plugin.rs index aa8cc97c946..6383a041247 100644 --- a/encodings/fastlanes/src/bitpacking/plugin.rs +++ b/encodings/fastlanes/src/bitpacking/plugin.rs @@ -29,7 +29,7 @@ use vortex_array::validity::Validity; use vortex_array::vtable::validity_to_child; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::VortexSession; @@ -89,10 +89,10 @@ impl ArrayPlugin for BitPackedPlugin { parts: ArrayDeserialization<'_>, _session: &VortexSession, ) -> VortexResult { - vortex_ensure!( - parts.serialized_id == self.id(), - "BitPacked plugin does not recognize serialized ID {}", - parts.serialized_id + vortex_ensure_eq!( + parts.serialized_id, + self.id(), + "BitPacked plugin does not recognize serialized ID" ); let ArrayDeserialization { dtype, @@ -203,10 +203,10 @@ impl ArrayPlugin for BitPackedPatchedPlugin { parts: ArrayDeserialization<'_>, session: &VortexSession, ) -> VortexResult { - vortex_ensure!( - parts.serialized_id == self.id(), - "BitPacked plugin does not recognize serialized ID {}", + vortex_ensure_eq!( parts.serialized_id, + self.id(), + "BitPacked plugin does not recognize serialized ID" ); let bitpacked: BitPackedArray = BitPackedPlugin .deserialize(parts, session)? diff --git a/encodings/fastlanes/src/bitpacking/vtable/mod.rs b/encodings/fastlanes/src/bitpacking/vtable/mod.rs index aa18bd289c6..641c6b3a2fe 100644 --- a/encodings/fastlanes/src/bitpacking/vtable/mod.rs +++ b/encodings/fastlanes/src/bitpacking/vtable/mod.rs @@ -33,7 +33,7 @@ use vortex_array::vtable::validity_to_child; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -134,11 +134,7 @@ impl VTable for BitPacked { array: ArrayView<'_, Self>, buffers: &[BufferHandle], ) -> VortexResult> { - vortex_ensure!( - buffers.len() == 1, - "Expected 1 buffer, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 1); let mut data = array.data().clone(); data.packed = buffers[0].clone(); Ok( diff --git a/encodings/fastlanes/src/delta/vtable/mod.rs b/encodings/fastlanes/src/delta/vtable/mod.rs index 1f2e3823689..c15f0ca4a79 100644 --- a/encodings/fastlanes/src/delta/vtable/mod.rs +++ b/encodings/fastlanes/src/delta/vtable/mod.rs @@ -24,6 +24,7 @@ use vortex_array::serde::ArrayChildren; use vortex_array::vtable::VTable; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -154,11 +155,7 @@ impl VTable for Delta { "DeltaArray expects 0 buffers, got {}", buffers.len() ); - vortex_ensure!( - children.len() == 2, - "DeltaArray expects 2 children, got {}", - children.len() - ); + vortex_ensure_eq!(children.len(), 2, "DeltaArray expects 2 children"); let metadata = DeltaMetadata::decode(metadata)?; let ptype = PType::try_from(dtype)?; let lanes = lane_count(ptype); @@ -238,10 +235,7 @@ fn validate_parts( ); let expected_dtype = bases.dtype().with_nullability(deltas.dtype().nullability()); - vortex_ensure!( - dtype == &expected_dtype, - "DeltaArray dtype mismatch: expected {expected_dtype}, got {dtype}" - ); + vortex_ensure_eq!(dtype, &expected_dtype, "DeltaArray dtype mismatch"); let lanes = lane_count(bases.dtype().as_ptype()); diff --git a/encodings/fastlanes/src/for_/plugin/v2.rs b/encodings/fastlanes/src/for_/plugin/v2.rs index e228d7a6f59..e2485cf0795 100644 --- a/encodings/fastlanes/src/for_/plugin/v2.rs +++ b/encodings/fastlanes/src/for_/plugin/v2.rs @@ -11,6 +11,7 @@ use vortex_array::ArrayView; use vortex_array::IntoArray; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use super::for_v2_id; use crate::FL_CHUNK_SIZE; @@ -45,11 +46,11 @@ pub(super) fn deserialize(parts: ArrayDeserialization<'_>) -> VortexResult VortexResult<()> { vortex_ensure!(dtype.is_int(), "FoR requires an integer dtype, got {dtype}"); - vortex_ensure!( - encoded.dtype() == dtype, - "FoR encoded dtype mismatch: expected {dtype}, got {}", - encoded.dtype() - ); - vortex_ensure!( - encoded.len() == len, - "FoR encoded length mismatch: expected {len}, got {}", - encoded.len() - ); + vortex_ensure_eq!(encoded.dtype(), dtype, "FoR encoded dtype mismatch"); + vortex_ensure_eq!(encoded.len(), len, "FoR encoded length mismatch"); let references_dtype = dtype.as_nonnullable(); - vortex_ensure!( - references.dtype() == &references_dtype, - "FoR references dtype mismatch: expected {references_dtype}, got {}", - references.dtype() + vortex_ensure_eq!( + references.dtype(), + &references_dtype, + "FoR references dtype mismatch" ); let num_chunks = num_chunks(offset, len); - vortex_ensure!( - references.len() == num_chunks, - "FoR expects {num_chunks} references, got {}", - references.len() + vortex_ensure_eq!( + references.len(), + num_chunks, + "FoR expects one reference per chunk" ); Ok(()) } diff --git a/encodings/fastlanes/src/rle/vtable/mod.rs b/encodings/fastlanes/src/rle/vtable/mod.rs index a3f6f01fa5a..6e5e65000e3 100644 --- a/encodings/fastlanes/src/rle/vtable/mod.rs +++ b/encodings/fastlanes/src/rle/vtable/mod.rs @@ -25,6 +25,7 @@ use vortex_array::serde::ArrayChildren; use vortex_array::vtable::VTable; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -301,10 +302,10 @@ fn validate_parts( indices.len() ); - vortex_ensure!( - indices.len().div_ceil(crate::FL_CHUNK_SIZE) == values_idx_offsets.len(), - "RLE must have one value idx offset per chunk, got {}", - values_idx_offsets.len() + vortex_ensure_eq!( + indices.len().div_ceil(crate::FL_CHUNK_SIZE), + values_idx_offsets.len(), + "RLE must have one value idx offset per chunk" ); vortex_ensure!( @@ -315,10 +316,7 @@ fn validate_parts( ); let expected_dtype = DType::Primitive(values.dtype().as_ptype(), indices.dtype().nullability()); - vortex_ensure!( - dtype == &expected_dtype, - "RLE dtype mismatch: expected {expected_dtype}, got {dtype}" - ); + vortex_ensure_eq!(dtype, &expected_dtype, "RLE dtype mismatch"); Ok(()) } diff --git a/encodings/fastlanes/src/transposed_bool.rs b/encodings/fastlanes/src/transposed_bool.rs index 92da3b3b79c..3068bc8607d 100644 --- a/encodings/fastlanes/src/transposed_bool.rs +++ b/encodings/fastlanes/src/transposed_bool.rs @@ -37,6 +37,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -145,22 +146,19 @@ impl VTable for TransposedBool { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - dtype == &DType::Bool(Nullability::NonNullable), - "TransposedBoolArray must have non-nullable boolean dtype, got {dtype}" - ); - vortex_ensure!( - slots.len() == 1, - "TransposedBoolArray expects one slot, got {}", - slots.len() + vortex_ensure_eq!( + dtype, + &DType::Bool(Nullability::NonNullable), + "TransposedBoolArray must have non-nullable boolean dtype" ); + vortex_ensure_eq!(slots.len(), 1, "TransposedBoolArray expects one slot"); let transposed = slots[TRANSPOSED_SLOT] .as_ref() .vortex_expect("TransposedBoolArray transposed slot"); - vortex_ensure!( - transposed.dtype() == &DType::Bool(Nullability::NonNullable), - "TransposedBoolArray transposed child must be a non-nullable boolean array, got {}", - transposed.dtype() + vortex_ensure_eq!( + transposed.dtype(), + &DType::Bool(Nullability::NonNullable), + "TransposedBoolArray transposed child must be a non-nullable boolean array" ); vortex_ensure!( transposed.len().is_multiple_of(FL_CHUNK_SIZE), diff --git a/encodings/fsst/src/array.rs b/encodings/fsst/src/array.rs index 86b8fd0c34d..3504dae3305 100644 --- a/encodings/fsst/src/array.rs +++ b/encodings/fsst/src/array.rs @@ -55,6 +55,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -174,11 +175,7 @@ impl VTable for FSST { array: ArrayView<'_, Self>, buffers: &[BufferHandle], ) -> VortexResult> { - vortex_ensure!( - buffers.len() == 3, - "Expected 3 buffers, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 3); let symbols = Buffer::::from_byte_buffer(buffers[0].clone().try_to_host_sync()?); let symbol_lengths = Buffer::::from_byte_buffer(buffers[1].clone().try_to_host_sync()?); let data = FSSTData::try_new(symbols, symbol_lengths, buffers[2].clone(), array.len())?; @@ -745,11 +742,10 @@ impl FSSTData { codes_bytes: BufferHandle, len: usize, ) -> VortexResult { - vortex_ensure!( - symbols.len() == symbol_lengths.len(), - InvalidArgument: "symbols and symbol_lengths arrays must have same length, found {} and {}", + vortex_ensure_eq!( symbols.len(), - symbol_lengths.len() + symbol_lengths.len(), + InvalidArgument: "symbols and symbol_lengths arrays must have same length" ); vortex_ensure!( symbols.len() <= FSST_SYMBOL_TABLE_LEN, diff --git a/encodings/fsst/src/canonical.rs b/encodings/fsst/src/canonical.rs index dc06be67cb3..9d53b855356 100644 --- a/encodings/fsst/src/canonical.rs +++ b/encodings/fsst/src/canonical.rs @@ -20,6 +20,7 @@ use vortex_buffer::ByteBuffer; use vortex_buffer::ByteBufferMut; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::FSST; @@ -117,11 +118,7 @@ impl FsstDecodePlan { out: &mut [MaybeUninit], ) -> VortexResult { let len = decompressor.decompress_into(self.codes.as_slice(), out); - vortex_ensure!( - len == self.total_size, - "FSST decoded {len} bytes, expected {}", - self.total_size - ); + vortex_ensure_eq!(len, self.total_size, "FSST decoded length mismatch"); Ok(len) } } diff --git a/encodings/onpair/src/array.rs b/encodings/onpair/src/array.rs index 912fc27c278..ce49541da04 100644 --- a/encodings/onpair/src/array.rs +++ b/encodings/onpair/src/array.rs @@ -47,6 +47,7 @@ use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -490,11 +491,7 @@ impl VTable for OnPair { array: ArrayView<'_, Self>, buffers: &[BufferHandle], ) -> VortexResult> { - vortex_ensure!( - buffers.len() == 1, - "Expected 1 buffer, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 1); let mut data = array.data().clone(); data.dict_bytes = buffers[0].clone(); // The replacement blob may differ from the one the memoized dictionary diff --git a/encodings/onpair/src/canonical.rs b/encodings/onpair/src/canonical.rs index e4589e0871e..535a3610916 100644 --- a/encodings/onpair/src/canonical.rs +++ b/encodings/onpair/src/canonical.rs @@ -25,6 +25,7 @@ use vortex_buffer::ByteBufferMut; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::OnPair; @@ -137,10 +138,10 @@ impl<'a> OnPairDecodePlan<'a> { } }; - vortex_ensure!( - written == self.total_size, - "OnPair codes decoded to {written} bytes but uncompressed_lengths records {}", - self.total_size + vortex_ensure_eq!( + written, + self.total_size, + "OnPair codes decoded length must match uncompressed_lengths" ); Ok(written) } diff --git a/encodings/onpair/src/decode.rs b/encodings/onpair/src/decode.rs index d483d1d79af..d713be9cdd5 100644 --- a/encodings/onpair/src/decode.rs +++ b/encodings/onpair/src/decode.rs @@ -15,6 +15,7 @@ use vortex_buffer::Buffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::OnPair; @@ -83,11 +84,10 @@ pub(crate) fn collect_codes_window( ) -> VortexResult { let len = array.len(); let offsets = collect_widened::(array.codes_offsets(), ctx)?; - vortex_ensure!( - offsets.len() == len + 1, - "OnPair codes_offsets has {} entries, expected len + 1 = {}", + vortex_ensure_eq!( offsets.len(), - len + 1 + len + 1, + "OnPair codes_offsets must have len + 1 entries" ); vortex_ensure!( offsets.is_sorted(), diff --git a/encodings/onpair/src/ops.rs b/encodings/onpair/src/ops.rs index 95c161bc8af..33e64225ab0 100644 --- a/encodings/onpair/src/ops.rs +++ b/encodings/onpair/src/ops.rs @@ -10,6 +10,7 @@ use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::OnPair; @@ -61,10 +62,7 @@ impl OperationsVTable for OnPair { Ok(written) => written, Err(_) => vortex_bail!("OnPair row {index} exceeds its recorded length"), }; - vortex_ensure!( - written == len, - "OnPair row {index} decoded {written} bytes, recorded {len}" - ); + vortex_ensure_eq!(written, len, "OnPair row {index} decoded length mismatch"); // SAFETY: `try_decode_into` initialised exactly `written` bytes. unsafe { buf.set_len(written) }; Ok(varbin_scalar(ByteBuffer::from(buf), array.dtype())) diff --git a/encodings/parquet-variant/src/vtable.rs b/encodings/parquet-variant/src/vtable.rs index 894a732e4c1..d57c5e24f2f 100644 --- a/encodings/parquet-variant/src/vtable.rs +++ b/encodings/parquet-variant/src/vtable.rs @@ -96,12 +96,7 @@ impl VTable for ParquetVariant { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == ParquetVariantSlots::COUNT, - "ParquetVariantArray expects {} slots, got {}", - ParquetVariantSlots::COUNT, - slots.len() - ); + vortex_ensure_eq!(slots.len(), ParquetVariantSlots::COUNT); let validity = child_to_validity( slots[ParquetVariantSlots::VALIDITY].as_ref(), dtype.nullability(), diff --git a/encodings/pco/src/array.rs b/encodings/pco/src/array.rs index 2d9d563f473..6bd4e0f3841 100644 --- a/encodings/pco/src/array.rs +++ b/encodings/pco/src/array.rs @@ -52,6 +52,7 @@ use vortex_error::VortexError; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -231,7 +232,7 @@ impl VTable for Pco { .iter() .map(|info| info.pages.len()) .sum::(); - vortex_ensure!(pages.len() == expected_n_pages); + vortex_ensure_eq!(pages.len(), expected_n_pages); let slots = PcoSlots { validity: validity_to_child(&validity, len), @@ -399,18 +400,8 @@ impl PcoData { /// Validate dtype, validity, slice, and Pco component invariants. pub fn validate(&self, dtype: &DType, len: usize, validity: &Validity) -> VortexResult<()> { let _ = number_type_from_ptype(self.ptype); - vortex_ensure!( - dtype.as_ptype() == self.ptype, - "expected ptype {}, got {}", - self.ptype, - dtype.as_ptype() - ); - vortex_ensure!( - dtype.nullability() == validity.nullability(), - "expected nullability {}, got {}", - validity.nullability(), - dtype.nullability() - ); + vortex_ensure_eq!(dtype.as_ptype(), self.ptype); + vortex_ensure_eq!(dtype.nullability(), validity.nullability()); vortex_ensure!( self.slice_start <= self.slice_stop && self.slice_stop <= self.unsliced_n_rows, "invalid slice range {}..{} for {} rows", @@ -418,33 +409,18 @@ impl PcoData { self.slice_stop, self.unsliced_n_rows ); - vortex_ensure!( - self.slice_stop - self.slice_start == len, - "expected len {len}, got {}", - self.slice_stop - self.slice_start - ); + vortex_ensure_eq!(self.slice_stop - self.slice_start, len); if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == self.unsliced_n_rows, - "expected validity len {}, got {}", - self.unsliced_n_rows, - validity_len - ); + vortex_ensure_eq!(validity_len, self.unsliced_n_rows); } - vortex_ensure!( - self.chunk_metas.len() == self.metadata.chunks.len(), - "expected {} chunk metas, got {}", - self.metadata.chunks.len(), - self.chunk_metas.len() - ); - vortex_ensure!( - self.pages.len() - == self - .metadata - .chunks - .iter() - .map(|chunk| chunk.pages.len()) - .sum::(), + vortex_ensure_eq!(self.chunk_metas.len(), self.metadata.chunks.len()); + vortex_ensure_eq!( + self.pages.len(), + self.metadata + .chunks + .iter() + .map(|chunk| chunk.pages.len()) + .sum::(), "page count does not match metadata" ); @@ -475,13 +451,13 @@ impl PcoData { self.unsliced_n_rows ); if validity.definitely_no_nulls() { - vortex_ensure!( - n_values == self.unsliced_n_rows, - "Pco contains {n_values} values for {} non-null rows", - self.unsliced_n_rows + vortex_ensure_eq!( + n_values, + self.unsliced_n_rows, + "Pco value count must match the row count of a non-null array" ); } else if validity.definitely_all_null() { - vortex_ensure!(n_values == 0, "Pco contains values for an all-null array"); + vortex_ensure_eq!(n_values, 0, "Pco contains values for an all-null array"); } Ok(()) } diff --git a/encodings/runend/src/array.rs b/encodings/runend/src/array.rs index 3a0b10c5c4a..ad05aa5b0e2 100644 --- a/encodings/runend/src/array.rs +++ b/encodings/runend/src/array.rs @@ -41,6 +41,7 @@ use vortex_error::VortexExpect as _; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -104,12 +105,7 @@ impl VTable for RunEnd { // TODO(ctx): trait fixes - VTable::validate has a fixed signature. let mut ctx = legacy_session().create_execution_ctx(); RunEndData::validate_parts(ends, values, data.offset, len, &mut ctx)?; - vortex_ensure!( - values.dtype() == dtype, - "expected dtype {}, got {}", - dtype, - values.dtype() - ); + vortex_ensure_eq!(values.dtype(), dtype); Ok(()) } @@ -331,19 +327,11 @@ impl RunEndData { "run ends must be unsigned integers, was {}", ends.dtype(), ); - vortex_ensure!( - ends.len() == values.len(), - "run ends len != run values len, {} != {}", - ends.len(), - values.len() - ); + vortex_ensure_eq!(ends.len(), values.len()); // Handle empty run-ends if ends.is_empty() { - vortex_ensure!( - offset == 0, - "non-zero offset provided for empty RunEndArray" - ); + vortex_ensure_eq!(offset, 0, "non-zero offset provided for empty RunEndArray"); return Ok(()); } diff --git a/encodings/sparse/src/lib.rs b/encodings/sparse/src/lib.rs index 79edc647c37..66a64b8a5d5 100644 --- a/encodings/sparse/src/lib.rs +++ b/encodings/sparse/src/lib.rs @@ -51,7 +51,6 @@ use vortex_buffer::Buffer; use vortex_error::VortexExpect as _; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_mask::AllOr; @@ -276,12 +275,7 @@ impl VTable for Sparse { let scalar_value = ScalarValue::from_proto_bytes(scalar_bytes, dtype, session)?; let fill_value = Scalar::try_new(dtype.clone(), scalar_value)?; - vortex_ensure_eq!( - children.len(), - 2, - "SparseArray expects 2 children for sparse encoding, found {}", - children.len() - ); + vortex_ensure_eq!(children.len(), 2, "SparseArray expects 2 children"); let patch_indices = children.get( 0, @@ -425,11 +419,10 @@ impl Sparse { fill_value: Scalar, ) -> VortexResult { let dtype = fill_value.dtype().clone(); - vortex_ensure!( - values.dtype() == &dtype, - "sparse values dtype {} must match fill value dtype {}", + vortex_ensure_eq!( values.dtype(), - dtype, + &dtype, + "sparse values dtype must match fill value dtype" ); let patches = Patches::new(len, 0, indices, values, None)?; let slots = SparseData::make_slots(&patches); @@ -476,24 +469,9 @@ impl SparseData { dtype: &DType, len: usize, ) -> VortexResult<()> { - vortex_ensure!( - fill_value.dtype() == dtype, - "fill value dtype {} does not match array dtype {}", - fill_value.dtype(), - dtype, - ); - vortex_ensure!( - patches.array_len() == len, - "patches length {} does not match array length {}", - patches.array_len(), - len - ); - vortex_ensure!( - patches.values().dtype() == dtype, - "patch values dtype {} does not match array dtype {}", - patches.values().dtype(), - dtype, - ); + vortex_ensure_eq!(fill_value.dtype(), dtype); + vortex_ensure_eq!(patches.array_len(), len); + vortex_ensure_eq!(patches.values().dtype(), dtype); Ok(()) } @@ -519,12 +497,7 @@ impl SparseData { /// Patch values must already match the fill dtype; callers are expected to construct patches /// with the correct dtype rather than relying on this to normalize them. fn from_patches(patches: &Patches, fill_value: Scalar) -> VortexResult { - vortex_ensure!( - patches.values().dtype() == fill_value.dtype(), - "patch values dtype {} must match fill dtype {}", - patches.values().dtype(), - fill_value.dtype(), - ); + vortex_ensure_eq!(patches.values().dtype(), fill_value.dtype()); Ok(Self::from_patches_unchecked(patches, fill_value)) } diff --git a/encodings/uuid/src/vtable.rs b/encodings/uuid/src/vtable.rs index 13e67f38944..5d7eabb2aba 100644 --- a/encodings/uuid/src/vtable.rs +++ b/encodings/uuid/src/vtable.rs @@ -59,18 +59,14 @@ impl ExtVTable for Uuid { vortex_ensure_eq!( *list_size as usize, UUID_BYTE_LEN, - "UUID storage FixedSizeList must have size {UUID_BYTE_LEN}, got {list_size}" + "UUID storage FixedSizeList size mismatch" ); let DType::Primitive(ptype, elem_nullability) = element_dtype.as_ref() else { vortex_bail!("UUID element dtype must be Primitive(U8), got {element_dtype}"); }; - vortex_ensure_eq!( - *ptype, - PType::U8, - "UUID element dtype must be U8, got {ptype}" - ); + vortex_ensure_eq!(*ptype, PType::U8, "UUID element dtype must be U8"); vortex_ensure!( !elem_nullability.is_nullable(), "UUID element dtype must be non-nullable" @@ -87,8 +83,7 @@ impl ExtVTable for Uuid { vortex_ensure_eq!( elements.len(), UUID_BYTE_LEN, - "UUID scalar must have exactly {UUID_BYTE_LEN} bytes, got {}", - elements.len() + "UUID scalar byte length mismatch" ); let mut bytes = [0u8; UUID_BYTE_LEN]; @@ -112,11 +107,7 @@ impl ExtVTable for Uuid { .ok_or_else(|| vortex_err!("UUID has unrecognized version nibble"))? as u8; - vortex_ensure_eq!( - expected, - actual, - "UUID version mismatch: expected v{expected}, got v{actual}", - ); + vortex_ensure_eq!(expected, actual, "UUID version mismatch"); } Ok(parsed) diff --git a/encodings/zigzag/src/array.rs b/encodings/zigzag/src/array.rs index 187b2309803..ffddcb8b646 100644 --- a/encodings/zigzag/src/array.rs +++ b/encodings/zigzag/src/array.rs @@ -33,7 +33,7 @@ use vortex_array::vtable::ValidityVTableFromChild; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -67,15 +67,8 @@ impl VTable for ZigZag { ) -> VortexResult<()> { let encoded = ZigZagSlotsView::from_slots(slots).encoded; let expected_dtype = ZigZagData::dtype_from_encoded_dtype(encoded.dtype())?; - vortex_ensure!( - dtype == &expected_dtype, - "expected dtype {expected_dtype}, got {dtype}" - ); - vortex_ensure!( - encoded.len() == len, - "expected len {len}, got {}", - encoded.len() - ); + vortex_ensure_eq!(dtype, &expected_dtype); + vortex_ensure_eq!(encoded.len(), len); Ok(()) } diff --git a/encodings/zstd/src/array.rs b/encodings/zstd/src/array.rs index ce9d5d38b28..d66535f5f62 100644 --- a/encodings/zstd/src/array.rs +++ b/encodings/zstd/src/array.rs @@ -57,6 +57,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::AllOr; use vortex_mask::Mask; @@ -384,12 +385,11 @@ fn append_to_varbinview( builder.append_views_built_at(&mask, |next_buffer_index| { let (buffers, valid_views) = try_reconstruct_views(&value_bytes, next_buffer_index, MAX_BUFFER_LEN)?; - vortex_ensure!( - valid_views.len() == mask.true_count(), - "Corrupt zstd metadata: the decompressed frames hold {} values for the {} valid rows \ - of the slice", + vortex_ensure_eq!( valid_views.len(), - mask.true_count() + mask.true_count(), + "Corrupt zstd metadata: the decompressed frames must hold one value per valid row of \ + the slice" ); let views = match mask.bit_buffer() { @@ -961,39 +961,23 @@ impl ZstdData { self.slice_stop, self.unsliced_n_rows ); - vortex_ensure!( - self.slice_stop - self.slice_start == len, - "Slice length {} does not match array length {}", - self.slice_stop - self.slice_start, - len - ); + vortex_ensure_eq!(self.slice_stop - self.slice_start, len); if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == self.unsliced_n_rows, - "Validity length {} does not match unsliced row count {}", - validity_len, - self.unsliced_n_rows - ); + vortex_ensure_eq!(validity_len, self.unsliced_n_rows); } match &self.dictionary { - Some(dictionary) => vortex_ensure!( - usize::try_from(self.metadata.dictionary_size)? == dictionary.len(), - "Dictionary size metadata {} does not match buffer size {}", - self.metadata.dictionary_size, + Some(dictionary) => vortex_ensure_eq!( + usize::try_from(self.metadata.dictionary_size)?, dictionary.len() ), - None => vortex_ensure!( - self.metadata.dictionary_size == 0, + None => vortex_ensure_eq!( + self.metadata.dictionary_size, + 0, "Dictionary metadata present without dictionary buffer" ), } - vortex_ensure!( - self.frames.len() == self.metadata.frames.len(), - "Frame count {} does not match metadata frame count {}", - self.frames.len(), - self.metadata.frames.len() - ); + vortex_ensure_eq!(self.frames.len(), self.metadata.frames.len()); for (index, (frame, metadata)) in self.frames.iter().zip(&self.metadata.frames).enumerate() { validate_frame_content_size(frame.as_slice(), metadata.uncompressed_size, index)?; @@ -1359,8 +1343,9 @@ impl ZstdData { // The same fallback would read a byte count as a value count for variable-width // values, which misattributes values to frames. A single frame holds every stored // value, so that case is still recoverable; anything else is not. - vortex_ensure!( - self.frames.len() == 1, + vortex_ensure_eq!( + self.frames.len(), + 1, "Zstd frame metadata for a variable-width array is missing its value count" ); unsliced_mask.true_count() diff --git a/encodings/zstd/src/lib.rs b/encodings/zstd/src/lib.rs index 9280d99958c..1ac044ff7b8 100644 --- a/encodings/zstd/src/lib.rs +++ b/encodings/zstd/src/lib.rs @@ -27,7 +27,7 @@ use vortex_array::session::ArraySessionExt; use vortex_edition::EditionSessionExt; use vortex_error::VortexExpect; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::VortexSession; pub use zstd_buffers::*; @@ -68,9 +68,10 @@ pub(crate) fn validate_frame_content_size( let frame_content_size = zstd::zstd_safe::get_frame_content_size(frame) .map_err(|error| vortex_err!("Invalid zstd frame {index}: {error}"))? .ok_or_else(|| vortex_err!("Zstd frame {index} does not declare a content size"))?; - vortex_ensure!( - metadata_size == frame_content_size, - "Zstd frame {index} metadata declares {metadata_size} uncompressed bytes, but its header declares {frame_content_size}" + vortex_ensure_eq!( + metadata_size, + frame_content_size, + "Zstd frame {index} metadata declares a different uncompressed size than its header" ); Ok(()) } diff --git a/encodings/zstd/src/zstd_buffers.rs b/encodings/zstd/src/zstd_buffers.rs index 51d338777ca..4984a420a34 100644 --- a/encodings/zstd/src/zstd_buffers.rs +++ b/encodings/zstd/src/zstd_buffers.rs @@ -230,16 +230,12 @@ impl ZstdBuffersData { vortex_ensure_eq!( self.compressed_buffers.len(), self.uncompressed_sizes.len(), - "zstd_buffers metadata mismatch: {} compressed buffers vs {} sizes", - self.compressed_buffers.len(), - self.uncompressed_sizes.len() + "zstd_buffers metadata mismatch" ); vortex_ensure_eq!( self.compressed_buffers.len(), self.buffer_alignments.len(), - "zstd_buffers metadata mismatch: {} compressed buffers vs {} alignments", - self.compressed_buffers.len(), - self.buffer_alignments.len() + "zstd_buffers metadata mismatch" ); Ok(()) } From 803d5f0306ac7d549c72b8432b28a49029e125c2 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 19:12:26 +0000 Subject: [PATCH 4/8] Drop redundant vortex_ensure_eq! messages in vortex-array arrays Remove custom messages that only restated the compared values, and turn plain equality vortex_ensure! checks into vortex_ensure_eq!. Messages that add context are kept without the values. Claude-Session: https://claude.ai/code/session_01YUXDBd65US5mcKTxb2Xcer Signed-off-by: Claude --- vortex-array/src/arrays/bool/array.rs | 15 +++--- vortex-array/src/arrays/bool/compute/take.rs | 17 +++---- vortex-array/src/arrays/bool/vtable/mod.rs | 14 ++---- .../src/arrays/chunked/compute/take.rs | 9 ++-- .../src/arrays/chunked/vtable/canonical.rs | 10 ++-- vortex-array/src/arrays/chunked/vtable/mod.rs | 48 ++++++++----------- .../src/arrays/constant/vtable/mod.rs | 15 +++--- vortex-array/src/arrays/decimal/vtable/mod.rs | 17 +++---- vortex-array/src/arrays/dict/vtable/mod.rs | 12 ++--- .../src/arrays/extension/vtable/mod.rs | 5 +- vortex-array/src/arrays/filter/array.rs | 4 +- vortex-array/src/arrays/filter/vtable.rs | 22 ++++----- .../src/arrays/fixed_size_list/array.rs | 13 +++-- .../arrays/fixed_size_list/compute/take.rs | 8 ++-- .../src/arrays/fixed_size_list/vtable/mod.rs | 17 +++---- vortex-array/src/arrays/fixed_width/array.rs | 3 +- .../src/arrays/fixed_width/take/slices.rs | 23 +++++---- vortex-array/src/arrays/fixed_width/vtable.rs | 8 +--- .../src/arrays/interleave/execute/bool.rs | 9 ++-- .../arrays/interleave/execute/primitive.rs | 8 ++-- vortex-array/src/arrays/interleave/mod.rs | 29 +++++------ vortex-array/src/arrays/list/array.rs | 9 ++-- vortex-array/src/arrays/list/compute/take.rs | 16 ++++--- vortex-array/src/arrays/list/tests.rs | 2 +- vortex-array/src/arrays/list/vtable/mod.rs | 25 ++++------ vortex-array/src/arrays/listview/array.rs | 24 +++++----- .../src/arrays/listview/vtable/mod.rs | 17 +++---- vortex-array/src/arrays/map/array.rs | 17 +++---- vortex-array/src/arrays/map/vtable/mod.rs | 15 ++---- vortex-array/src/arrays/masked/vtable/mod.rs | 10 ++-- vortex-array/src/arrays/null/mod.rs | 3 +- vortex-array/src/arrays/patched/array.rs | 22 ++++----- .../src/arrays/piecewise_sequence/mod.rs | 15 +++--- .../src/arrays/piecewise_sequence/vtable.rs | 16 +++---- .../src/arrays/primitive/vtable/mod.rs | 15 +++--- vortex-array/src/arrays/scalar_fn/plugin.rs | 9 ++-- .../src/arrays/scalar_fn/vtable/mod.rs | 22 +++++---- .../src/arrays/scalar_fn/vtable/operations.rs | 2 +- vortex-array/src/arrays/shared/vtable.rs | 4 +- vortex-array/src/arrays/slice/vtable.rs | 15 +++--- vortex-array/src/arrays/union/vtable/mod.rs | 8 +--- .../src/arrays/union/vtable/validate.rs | 17 ++----- vortex-array/src/arrays/varbin/array.rs | 8 ++-- vortex-array/src/arrays/varbin/builder.rs | 32 +++++++------ .../src/arrays/varbin/compute/take.rs | 32 +++++++------ vortex-array/src/arrays/varbin/vtable/mod.rs | 21 +++----- vortex-array/src/arrays/varbinview/array.rs | 10 ++-- .../src/arrays/varbinview/compute/take.rs | 25 +++++----- .../src/arrays/varbinview/vtable/mod.rs | 15 ++---- vortex-array/src/arrays/variant/vtable/mod.rs | 36 +++++--------- 50 files changed, 346 insertions(+), 422 deletions(-) diff --git a/vortex-array/src/arrays/bool/array.rs b/vortex-array/src/arrays/bool/array.rs index 5b1083e7f88..f4f29eb7513 100644 --- a/vortex-array/src/arrays/bool/array.rs +++ b/vortex-array/src/arrays/bool/array.rs @@ -12,6 +12,7 @@ use vortex_buffer::BitBufferView; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_mask::Mask; use crate::ArrayRef; @@ -274,10 +275,10 @@ impl BoolData { ) -> VortexResult { vortex_ensure!(offset < 8, "BitBuffer offset must be <8, got {}", offset); if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == len, - "BoolArray of size {} cannot be built with validity of size {validity_len}", + vortex_ensure_eq!( + validity_len, len, + "BoolArray validity length does not match array length", ); } @@ -314,10 +315,10 @@ impl BoolData { ); if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == bits.len(), - "BoolArray of size {} cannot be built with validity of size {validity_len}", - bits.len() + vortex_ensure_eq!( + validity_len, + bits.len(), + "BoolArray validity length does not match array length", ); } diff --git a/vortex-array/src/arrays/bool/compute/take.rs b/vortex-array/src/arrays/bool/compute/take.rs index 529450f6639..d98355ff8f8 100644 --- a/vortex-array/src/arrays/bool/compute/take.rs +++ b/vortex-array/src/arrays/bool/compute/take.rs @@ -8,7 +8,7 @@ use vortex_buffer::BitBufferMut; use vortex_buffer::BitBufferView; use vortex_buffer::get_bit; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::Mask; @@ -153,9 +153,10 @@ where .len() .checked_mul(length) .ok_or_else(|| vortex_err!("PiecewiseSequenceArray output length overflows usize"))?; - vortex_ensure!( - computed_len == output_len, - "PiecewiseSequenceArray expanded length {computed_len} does not match declared length {output_len}" + vortex_ensure_eq!( + computed_len, + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); let mut values = BitBufferMut::with_capacity(output_len); @@ -184,10 +185,10 @@ where values.append_buffer(&source.slice(start..).slice(..length)); } - vortex_ensure!( - values.len() == output_len, - "PiecewiseSequenceArray expanded length {} does not match declared length {output_len}", - values.len() + vortex_ensure_eq!( + values.len(), + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); Ok(values.freeze()) } diff --git a/vortex-array/src/arrays/bool/vtable/mod.rs b/vortex-array/src/arrays/bool/vtable/mod.rs index 393414924b3..737b6f2f63d 100644 --- a/vortex-array/src/arrays/bool/vtable/mod.rs +++ b/vortex-array/src/arrays/bool/vtable/mod.rs @@ -9,6 +9,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -101,11 +102,7 @@ impl VTable for Bool { array: ArrayView<'_, Self>, buffers: &[BufferHandle], ) -> VortexResult> { - vortex_ensure!( - buffers.len() == 1, - "Expected 1 buffer, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 1); let mut data = array.data().clone(); data.bits = buffers[0].clone(); Ok( @@ -148,11 +145,10 @@ impl VTable for Bool { let validity = child_to_validity(slots[BoolSlots::VALIDITY].as_ref(), *nullability); if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == len, - "BoolArray validity len {} does not match outer length {}", + vortex_ensure_eq!( validity_len, - len + len, + "BoolArray validity len does not match outer length", ); } diff --git a/vortex-array/src/arrays/chunked/compute/take.rs b/vortex-array/src/arrays/chunked/compute/take.rs index 62bcda40c14..b974c650281 100644 --- a/vortex-array/src/arrays/chunked/compute/take.rs +++ b/vortex-array/src/arrays/chunked/compute/take.rs @@ -8,7 +8,7 @@ use vortex_buffer::BufferAllocatorRef; use vortex_buffer::BufferMut; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::Mask; @@ -478,9 +478,10 @@ fn take_piecewise_chunked( } } - vortex_ensure!( - total_len == output_len, - "PiecewiseSequenceArray expanded length {total_len} does not match declared length {output_len}" + vortex_ensure_eq!( + total_len, + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); // Chunks visited in order: the per-chunk gathers already concatenate into the result. diff --git a/vortex-array/src/arrays/chunked/vtable/canonical.rs b/vortex-array/src/arrays/chunked/vtable/canonical.rs index a521fd0e6cc..4eb8b95dd41 100644 --- a/vortex-array/src/arrays/chunked/vtable/canonical.rs +++ b/vortex-array/src/arrays/chunked/vtable/canonical.rs @@ -5,6 +5,7 @@ use itertools::Itertools as _; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::ArrayRef; @@ -129,11 +130,10 @@ fn pack_variant_chunks( "cannot canonicalize ChunkedArray: chunks disagree on shredded presence" ) })?; - vortex_ensure!( - shredded.dtype() == &shredded_dtype, - "cannot canonicalize ChunkedArray: shredded dtype mismatch ({} vs {})", - shredded_dtype, - shredded.dtype() + vortex_ensure_eq!( + shredded.dtype(), + &shredded_dtype, + "cannot canonicalize ChunkedArray: shredded dtype mismatch", ); shredded_chunks.push(shredded.clone()); } diff --git a/vortex-array/src/arrays/chunked/vtable/mod.rs b/vortex-array/src/arrays/chunked/vtable/mod.rs index 6f0462c6c29..2cc6ba469e6 100644 --- a/vortex-array/src/arrays/chunked/vtable/mod.rs +++ b/vortex-array/src/arrays/chunked/vtable/mod.rs @@ -9,6 +9,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -90,32 +91,28 @@ impl VTable for Chunked { let chunk_offsets = slots[ChunkedSlots::CHUNK_OFFSETS] .as_ref() .vortex_expect("validated chunk offsets slot"); - vortex_ensure!( - chunk_offsets.dtype() == &DType::Primitive(PType::U64, Nullability::NonNullable), - "ChunkedArray chunk offsets must be non-nullable u64, found {}", - chunk_offsets.dtype() + vortex_ensure_eq!( + chunk_offsets.dtype(), + &DType::Primitive(PType::U64, Nullability::NonNullable), + "ChunkedArray chunk offsets must be non-nullable u64", ); - vortex_ensure!( - chunk_offsets.len() == data.chunk_offsets.len(), - "ChunkedArray chunk offsets slot length {} does not match cached offsets length {}", + vortex_ensure_eq!( chunk_offsets.len(), - data.chunk_offsets.len() + data.chunk_offsets.len(), + "ChunkedArray chunk offsets slot length does not match cached offsets length", ); - vortex_ensure!( - data.chunk_offsets.len() == slots.len() - ChunkedSlots::CHUNKS_OFFSET + 1, - "ChunkedArray chunk offsets length {} does not match {} chunks", + vortex_ensure_eq!( data.chunk_offsets.len(), - slots.len() - ChunkedSlots::CHUNKS_OFFSET + slots.len() - ChunkedSlots::CHUNKS_OFFSET + 1, + "ChunkedArray must have one more chunk offset than chunks", ); - vortex_ensure!( + vortex_ensure_eq!( data.chunk_offsets .last() .copied() - .vortex_expect("chunked arrays always have a leading 0 offset") - == len, - "ChunkedArray length {} does not match outer length {}", - data.chunk_offsets.last().copied().unwrap_or_default(), - len + .vortex_expect("chunked arrays always have a leading 0 offset"), + len, + "ChunkedArray length does not match outer length", ); for (idx, (start, end)) in data .chunk_offsets @@ -127,18 +124,15 @@ impl VTable for Chunked { let chunk = slots[ChunkedSlots::CHUNKS_OFFSET + idx] .as_ref() .vortex_expect("validated chunk slot"); - vortex_ensure!( - chunk.dtype() == dtype, - "ChunkedArray chunk dtype {} does not match outer dtype {}", + vortex_ensure_eq!( chunk.dtype(), - dtype + dtype, + "ChunkedArray chunk dtype does not match outer dtype", ); - vortex_ensure!( - chunk.len() == end - start, - "ChunkedArray chunk {} len {} does not match offsets span {}", - idx, + vortex_ensure_eq!( chunk.len(), - end - start + end - start, + "ChunkedArray chunk {idx} len does not match offsets span", ); } Ok(()) diff --git a/vortex-array/src/arrays/constant/vtable/mod.rs b/vortex-array/src/arrays/constant/vtable/mod.rs index c0796a0e7d0..4525115d5c1 100644 --- a/vortex-array/src/arrays/constant/vtable/mod.rs +++ b/vortex-array/src/arrays/constant/vtable/mod.rs @@ -8,7 +8,7 @@ use std::hash::Hasher; use itertools::Itertools; use vortex_error::VortexExpect; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -92,9 +92,10 @@ impl VTable for Constant { _len: usize, _slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - data.scalar.dtype() == dtype, - "ConstantArray scalar dtype does not match outer dtype" + vortex_ensure_eq!( + data.scalar.dtype(), + dtype, + "ConstantArray scalar dtype does not match outer dtype", ); Ok(()) } @@ -150,11 +151,7 @@ impl VTable for Constant { _children: &dyn ArrayChildren, session: &VortexSession, ) -> VortexResult> { - vortex_ensure!( - buffers.len() == 1, - "Expected 1 buffer, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 1); let buffer = buffers[0].clone().try_to_host_sync()?; let bytes: &[u8] = buffer.as_ref(); diff --git a/vortex-array/src/arrays/decimal/vtable/mod.rs b/vortex-array/src/arrays/decimal/vtable/mod.rs index 5f2e087e983..612ed4b1ca7 100644 --- a/vortex-array/src/arrays/decimal/vtable/mod.rs +++ b/vortex-array/src/arrays/decimal/vtable/mod.rs @@ -8,6 +8,7 @@ use vortex_buffer::Alignment; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use crate::ArrayParts; @@ -126,22 +127,18 @@ impl VTable for Decimal { let DType::Decimal(_, nullability) = dtype else { vortex_bail!("Expected decimal dtype, got {dtype:?}"); }; - vortex_ensure!( - data.len() == len, - InvalidArgument: - "DecimalArray length {} does not match outer length {}", + vortex_ensure_eq!( data.len(), - len + len, + InvalidArgument: "DecimalArray length does not match outer length", ); let validity = crate::array::child_to_validity(slots[DecimalSlots::VALIDITY].as_ref(), *nullability); if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == len, - InvalidArgument: - "DecimalArray validity len {} does not match outer length {}", + vortex_ensure_eq!( validity_len, - len + len, + InvalidArgument: "DecimalArray validity len does not match outer length", ); } diff --git a/vortex-array/src/arrays/dict/vtable/mod.rs b/vortex-array/src/arrays/dict/vtable/mod.rs index 2eca82b5368..42555c2a158 100644 --- a/vortex-array/src/arrays/dict/vtable/mod.rs +++ b/vortex-array/src/arrays/dict/vtable/mod.rs @@ -8,7 +8,7 @@ use prost::Message; use smallvec::smallvec; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_mask::AllOr; @@ -104,13 +104,13 @@ impl VTable for Dict { let view = DictSlotsView::from_slots(slots); let codes = view.codes; let values = view.values; - vortex_ensure!(codes.len() == len, "DictArray codes length mismatch"); - vortex_ensure!( + vortex_ensure_eq!(codes.len(), len, "DictArray codes length mismatch"); + vortex_ensure_eq!( values .dtype() - .union_nullability(codes.dtype().nullability()) - == *dtype, - "DictArray dtype does not match codes/values dtype" + .union_nullability(codes.dtype().nullability()), + *dtype, + "DictArray dtype does not match codes/values dtype", ); Ok(()) } diff --git a/vortex-array/src/arrays/extension/vtable/mod.rs b/vortex-array/src/arrays/extension/vtable/mod.rs index 2937a2b98b9..debb8cfd07d 100644 --- a/vortex-array/src/arrays/extension/vtable/mod.rs +++ b/vortex-array/src/arrays/extension/vtable/mod.rs @@ -106,8 +106,7 @@ impl VTable for Extension { vortex_ensure_eq!( storage.len(), len, - "ExtensionArray length {} does not match outer length {len}", - storage.len(), + "ExtensionArray length does not match outer length", ); let ext_dtype = dtype @@ -118,7 +117,7 @@ impl VTable for Extension { vortex_ensure_eq!( &actual_dtype, dtype, - "ExtensionArray dtype {actual_dtype} does not match outer dtype {dtype}", + "ExtensionArray dtype does not match outer dtype", ); Ok(()) diff --git a/vortex-array/src/arrays/filter/array.rs b/vortex-array/src/arrays/filter/array.rs index 5370983c1a2..30863f860e7 100644 --- a/vortex-array/src/arrays/filter/array.rs +++ b/vortex-array/src/arrays/filter/array.rs @@ -51,9 +51,7 @@ impl FilterData { vortex_ensure_eq!( array_len, mask.len(), - "FilterArray length mismatch: array has length {} but mask has length {}", - array_len, - mask.len() + "FilterArray array and mask lengths must match", ); Ok(Self { mask }) diff --git a/vortex-array/src/arrays/filter/vtable.rs b/vortex-array/src/arrays/filter/vtable.rs index f5a61ba79d7..b7642784fce 100644 --- a/vortex-array/src/arrays/filter/vtable.rs +++ b/vortex-array/src/arrays/filter/vtable.rs @@ -7,6 +7,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_mask::Mask; use vortex_mask::MaskValuesRef; @@ -86,23 +87,20 @@ impl VTable for Filter { let child = slots[FilterSlots::CHILD] .as_ref() .vortex_expect("validated child slot"); - vortex_ensure!( - child.dtype() == dtype, - "FilterArray dtype {} does not match outer dtype {}", + vortex_ensure_eq!( child.dtype(), - dtype + dtype, + "FilterArray dtype does not match outer dtype", ); - vortex_ensure!( - data.len() == len, - "FilterArray length {} does not match outer length {}", + vortex_ensure_eq!( data.len(), - len + len, + "FilterArray length does not match outer length", ); - vortex_ensure!( - child.len() == data.mask.len(), - "FilterArray child length {} does not match mask length {}", + vortex_ensure_eq!( child.len(), - data.mask.len() + data.mask.len(), + "FilterArray child length does not match mask length", ); Ok(()) } diff --git a/vortex-array/src/arrays/fixed_size_list/array.rs b/vortex-array/src/arrays/fixed_size_list/array.rs index 98ba45d0307..fa954a7665f 100644 --- a/vortex-array/src/arrays/fixed_size_list/array.rs +++ b/vortex-array/src/arrays/fixed_size_list/array.rs @@ -8,6 +8,7 @@ use std::sync::Arc; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayRef; use crate::ArraySlots; @@ -184,9 +185,10 @@ impl FixedSizeListData { ) -> VortexResult<()> { // If a validity array is present, it must be the same length as the fixed-size list array. if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - len == validity_len, - InvalidArgument: "validity with size {validity_len} does not match fixed-size list array size {len}", + vortex_ensure_eq!( + len, + validity_len, + InvalidArgument: "validity length does not match fixed-size list array size", ); } @@ -200,8 +202,9 @@ impl FixedSizeListData { return Ok(()); } - vortex_ensure!( - len * list_size as usize == elements.len(), + vortex_ensure_eq!( + len * list_size as usize, + elements.len(), InvalidArgument: "the `elements` array has the incorrect number of elements to construct a \ `FixedSizeList[{list_size}] array of length {len}", ); diff --git a/vortex-array/src/arrays/fixed_size_list/compute/take.rs b/vortex-array/src/arrays/fixed_size_list/compute/take.rs index 48aa9ceea33..acc05cca73d 100644 --- a/vortex-array/src/arrays/fixed_size_list/compute/take.rs +++ b/vortex-array/src/arrays/fixed_size_list/compute/take.rs @@ -8,6 +8,7 @@ use vortex_buffer::BufferMut; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::ArrayRef; @@ -184,9 +185,10 @@ fn take_piecewise_fsl( element_starts.push(u64::try_from(start * list_size)?); element_lengths.push(u64::try_from(length * list_size)?); } - vortex_ensure!( - total_len == new_len, - "PiecewiseSequenceArray expanded length {total_len} does not match declared length {new_len}" + vortex_ensure_eq!( + total_len, + new_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); let new_elements = diff --git a/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs b/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs index 656a08b0f66..0c357879193 100644 --- a/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs +++ b/vortex-array/src/arrays/fixed_size_list/vtable/mod.rs @@ -9,6 +9,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -112,12 +113,7 @@ impl VTable for FixedSizeList { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == FixedSizeListSlots::COUNT, - "FixedSizeListArray expected {} slots, found {}", - FixedSizeListSlots::COUNT, - slots.len() - ); + vortex_ensure_eq!(slots.len(), FixedSizeListSlots::COUNT); let DType::FixedSizeList(_, list_size, nullability) = dtype else { vortex_bail!("Expected `DType::FixedSizeList`, got {dtype:?}"); }; @@ -137,11 +133,10 @@ impl VTable for FixedSizeList { let actual_dtype = DType::FixedSizeList(Arc::new(elements.dtype().clone()), *list_size, *nullability); - vortex_ensure!( - &actual_dtype == dtype, - "FixedSizeListArray dtype {} does not match outer dtype {}", - actual_dtype, - dtype + vortex_ensure_eq!( + &actual_dtype, + dtype, + "FixedSizeListArray dtype does not match outer dtype", ); Ok(()) diff --git a/vortex-array/src/arrays/fixed_width/array.rs b/vortex-array/src/arrays/fixed_width/array.rs index 96ee6e6255f..e6eac415664 100644 --- a/vortex-array/src/arrays/fixed_width/array.rs +++ b/vortex-array/src/arrays/fixed_width/array.rs @@ -55,8 +55,7 @@ pub(crate) fn with_values( vortex_ensure_eq!( values.len(), expected_len, - "Fixed-width values buffer length {} does not match expected length {expected_len}", - values.len(), + "Fixed-width values buffer length does not match expected length", ); V::with_values(array, values, len, validity) } diff --git a/vortex-array/src/arrays/fixed_width/take/slices.rs b/vortex-array/src/arrays/fixed_width/take/slices.rs index 3ebfc15b104..480e0096360 100644 --- a/vortex-array/src/arrays/fixed_width/take/slices.rs +++ b/vortex-array/src/arrays/fixed_width/take/slices.rs @@ -7,6 +7,7 @@ use vortex_buffer::BufferMut; use vortex_buffer::ByteBuffer; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::dtype::UnsignedPType; @@ -47,9 +48,10 @@ pub(super) fn take_slices_constant_length( .len() .checked_mul(length) .ok_or_else(|| vortex_err!("PiecewiseSequenceArray output length overflows usize"))?; - vortex_ensure!( - computed_len == output_len, - "PiecewiseSequenceArray expanded length {computed_len} does not match declared length {output_len}" + vortex_ensure_eq!( + computed_len, + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); copy_slices( values, @@ -72,9 +74,10 @@ fn copy_slices( let input_byte_len = record_count .checked_mul(byte_width) .ok_or_else(|| vortex_err!("Fixed-width values buffer length overflows usize"))?; - vortex_ensure!( - values.len() == input_byte_len, - "Fixed-width values buffer length does not match record count" + vortex_ensure_eq!( + values.len(), + input_byte_len, + "Fixed-width values buffer length does not match record count", ); let output_byte_len = output_len @@ -107,10 +110,10 @@ fn copy_slices( // SAFETY: The loop initialized the prefix `0..cursor` of the spare capacity. unsafe { result.set_len(cursor) }; - vortex_ensure!( - result.len() == output_byte_len, - "PiecewiseSequenceArray expanded length {} does not match declared length {output_byte_len}", - result.len() + vortex_ensure_eq!( + result.len(), + output_byte_len, + "PiecewiseSequenceArray expanded byte length does not match declared byte length", ); Ok(result.freeze().into_byte_buffer()) } diff --git a/vortex-array/src/arrays/fixed_width/vtable.rs b/vortex-array/src/arrays/fixed_width/vtable.rs index 79d6ed20072..b0994013a66 100644 --- a/vortex-array/src/arrays/fixed_width/vtable.rs +++ b/vortex-array/src/arrays/fixed_width/vtable.rs @@ -3,7 +3,7 @@ use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use crate::buffer::BufferHandle; @@ -26,11 +26,7 @@ pub(crate) fn buffer_name(idx: usize) -> Option { } pub(crate) fn single_buffer(buffers: &[BufferHandle]) -> VortexResult { - vortex_ensure!( - buffers.len() == 1, - "Expected 1 buffer, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 1); Ok(buffers[0].clone()) } diff --git a/vortex-array/src/arrays/interleave/execute/bool.rs b/vortex-array/src/arrays/interleave/execute/bool.rs index bf80ffdc88c..749a1883ea6 100644 --- a/vortex-array/src/arrays/interleave/execute/bool.rs +++ b/vortex-array/src/arrays/interleave/execute/bool.rs @@ -9,6 +9,7 @@ use vortex_buffer::BitBufferMut; use vortex_buffer::BufferAllocatorRef; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use super::super::Interleave; use super::super::InterleaveArrayExt; @@ -93,10 +94,10 @@ fn validate_selectors, R: AsPrimitive>( ) -> VortexResult { // The two selectors are validated to equal length at construction, which is the output length. let len = branches.len(); - vortex_ensure!( - rows.len() == len, - "interleave selectors differ in length: array_indices {len}, row_indices {}", - rows.len() + vortex_ensure_eq!( + rows.len(), + len, + "interleave row_indices length does not match array_indices length", ); for i in 0..len { diff --git a/vortex-array/src/arrays/interleave/execute/primitive.rs b/vortex-array/src/arrays/interleave/execute/primitive.rs index 3cd2b0a129b..e109398e1af 100644 --- a/vortex-array/src/arrays/interleave/execute/primitive.rs +++ b/vortex-array/src/arrays/interleave/execute/primitive.rs @@ -10,6 +10,7 @@ use vortex_buffer::BufferMut; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use super::super::Interleave; use super::super::InterleaveArrayExt; @@ -110,11 +111,10 @@ where R: AsPrimitive, { // `zip` truncates to the shorter input. - vortex_ensure!( - rows.len() == branches.len(), - "interleave selectors differ in length: array_indices {}, row_indices {}", + vortex_ensure_eq!( + rows.len(), branches.len(), - rows.len() + "interleave row_indices length does not match array_indices length", ); let mut output = BufferMut::with_capacity_in(branches.len(), allocator.clone()); diff --git a/vortex-array/src/arrays/interleave/mod.rs b/vortex-array/src/arrays/interleave/mod.rs index fb649cf6e19..ec0c1a09f11 100644 --- a/vortex-array/src/arrays/interleave/mod.rs +++ b/vortex-array/src/arrays/interleave/mod.rs @@ -49,6 +49,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -179,11 +180,10 @@ impl Interleave { } } - vortex_ensure!( - array_indices.len() == row_indices.len(), - "interleave selectors must have equal length, got array_indices {} and row_indices {}", + vortex_ensure_eq!( array_indices.len(), - row_indices.len() + row_indices.len(), + "interleave selectors must have equal length", ); let base_dtype = values[0].dtype(); @@ -298,11 +298,10 @@ impl VTable for Interleave { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == data.num_values + 2, - "InterleaveArray expected {} slots (values + array_indices + row_indices), got {}", + vortex_ensure_eq!( + slots.len(), data.num_values + 2, - slots.len() + "InterleaveArray expects values + array_indices + row_indices slots", ); vortex_ensure!( slots.iter().all(|s| s.is_some()), @@ -321,17 +320,15 @@ impl VTable for Interleave { // All semantic invariants live in `check`; here we only confirm the array's cached `dtype` // and `len` agree with what the children imply. let expected_dtype = Interleave::check(&values, &array_indices, &row_indices)?; - vortex_ensure!( - dtype == &expected_dtype, - "InterleaveArray dtype {} does not match the dtype implied by its children {}", + vortex_ensure_eq!( dtype, - expected_dtype + &expected_dtype, + "InterleaveArray dtype does not match the dtype implied by its children", ); - vortex_ensure!( - len == array_indices.len(), - "InterleaveArray length {} does not match array_indices length {}", + vortex_ensure_eq!( len, - array_indices.len() + array_indices.len(), + "InterleaveArray length does not match array_indices length", ); Ok(()) } diff --git a/vortex-array/src/arrays/list/array.rs b/vortex-array/src/arrays/list/array.rs index 419617c073c..7233fbade68 100644 --- a/vortex-array/src/arrays/list/array.rs +++ b/vortex-array/src/arrays/list/array.rs @@ -10,6 +10,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use crate::ArrayRef; @@ -261,10 +262,10 @@ impl ListData { // If a validity array is present, it must be the same length as the ListArray if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == offsets.len() - 1, - InvalidArgument: "validity with size {validity_len} does not match array size {}", - offsets.len() - 1 + vortex_ensure_eq!( + validity_len, + offsets.len() - 1, + InvalidArgument: "validity length does not match array size", ); } diff --git a/vortex-array/src/arrays/list/compute/take.rs b/vortex-array/src/arrays/list/compute/take.rs index c010b0d2732..4182b22689a 100644 --- a/vortex-array/src/arrays/list/compute/take.rs +++ b/vortex-array/src/arrays/list/compute/take.rs @@ -5,7 +5,7 @@ use itertools::Itertools as _; use vortex_buffer::BufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::Mask; @@ -328,9 +328,10 @@ where .len() .checked_mul(length) .ok_or_else(|| vortex_err!("PiecewiseSequenceArray output length overflows usize"))?; - vortex_ensure!( - computed_len == output_len, - "PiecewiseSequenceArray expanded length {computed_len} does not match declared length {output_len}" + vortex_ensure_eq!( + computed_len, + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); let all_valid = data_validity.all_true(); let total_elements = if all_valid { @@ -393,9 +394,10 @@ where .checked_add(length) .ok_or_else(|| vortex_err!("PiecewiseSequenceArray output length overflows usize"))?; } - vortex_ensure!( - computed_len == output_len, - "PiecewiseSequenceArray expanded length {computed_len} does not match declared length {output_len}" + vortex_ensure_eq!( + computed_len, + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); let all_valid = data_validity.all_true(); let total_elements = if all_valid { diff --git a/vortex-array/src/arrays/list/tests.rs b/vortex-array/src/arrays/list/tests.rs index 93daf3dc4a4..a7d5ba60d35 100644 --- a/vortex-array/src/arrays/list/tests.rs +++ b/vortex-array/src/arrays/list/tests.rs @@ -847,7 +847,7 @@ fn test_offset_exceeding_elements_length() { } #[test] -#[should_panic(expected = "validity with size 2 does not match array size 4")] +#[should_panic(expected = "validity length does not match array size")] fn test_validity_length_mismatch() { let elements = buffer![1i32, 2, 3, 4, 5].into_array(); let offsets = buffer![0u32, 2, 4, 5, 5].into_array(); diff --git a/vortex-array/src/arrays/list/vtable/mod.rs b/vortex-array/src/arrays/list/vtable/mod.rs index c55e7050351..88168c988a1 100644 --- a/vortex-array/src/arrays/list/vtable/mod.rs +++ b/vortex-array/src/arrays/list/vtable/mod.rs @@ -8,7 +8,7 @@ use prost::Message; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -120,31 +120,24 @@ impl VTable for List { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == ListSlots::COUNT, - "ListArray expected {} slots, found {}", - ListSlots::COUNT, - slots.len() - ); + vortex_ensure_eq!(slots.len(), ListSlots::COUNT); let elements = slots[ListSlots::ELEMENTS] .as_ref() .vortex_expect("ListArray elements slot"); let offsets = slots[ListSlots::OFFSETS] .as_ref() .vortex_expect("ListArray offsets slot"); - vortex_ensure!( - offsets.len().saturating_sub(1) == len, - "ListArray length {} does not match outer length {}", + vortex_ensure_eq!( offsets.len().saturating_sub(1), - len + len, + "ListArray length does not match outer length", ); let actual_dtype = DType::List(Arc::new(elements.dtype().clone()), dtype.nullability()); - vortex_ensure!( - &actual_dtype == dtype, - "ListArray dtype {} does not match outer dtype {}", - actual_dtype, - dtype + vortex_ensure_eq!( + &actual_dtype, + dtype, + "ListArray dtype does not match outer dtype", ); Ok(()) diff --git a/vortex-array/src/arrays/listview/array.rs b/vortex-array/src/arrays/listview/array.rs index 43f51971b8f..0948c382376 100644 --- a/vortex-array/src/arrays/listview/array.rs +++ b/vortex-array/src/arrays/listview/array.rs @@ -11,6 +11,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::Mask; @@ -245,19 +246,18 @@ impl ListViewData { ); // Check that they have the same length. - vortex_ensure!( - offsets.len() == sizes.len(), - "offsets and sizes must have the same length, got {} and {}", + vortex_ensure_eq!( offsets.len(), - sizes.len() + sizes.len(), + "offsets and sizes must have the same length", ); // If a validity array is present, it must be the same length as the `ListViewArray`. if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == offsets.len(), - "validity with size {validity_len} does not match array size {}", - offsets.len() + vortex_ensure_eq!( + validity_len, + offsets.len(), + "validity length does not match array size", ); } @@ -709,10 +709,10 @@ where })?; if offset_u64 == elements_len { - vortex_ensure!( - size_u64 == 0, - "views to the end of the elements array (length {elements_len}) must have size 0 \ - (had size {size_u64})" + vortex_ensure_eq!( + size_u64, + 0, + "views to the end of the elements array (length {elements_len}) must have size 0", ); } diff --git a/vortex-array/src/arrays/listview/vtable/mod.rs b/vortex-array/src/arrays/listview/vtable/mod.rs index 806e7a6563c..a93d01f6ab3 100644 --- a/vortex-array/src/arrays/listview/vtable/mod.rs +++ b/vortex-array/src/arrays/listview/vtable/mod.rs @@ -10,6 +10,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -124,12 +125,7 @@ impl VTable for ListView { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == ListViewSlots::COUNT, - "ListViewArray expected {} slots, found {}", - ListViewSlots::COUNT, - slots.len() - ); + vortex_ensure_eq!(slots.len(), ListViewSlots::COUNT); let elements = slots[ListViewSlots::ELEMENTS] .as_ref() .vortex_expect("ListViewArray elements slot"); @@ -147,11 +143,10 @@ impl VTable for ListView { ); let actual_dtype = DType::List(Arc::new(elements.dtype().clone()), dtype.nullability()); - vortex_ensure!( - &actual_dtype == dtype, - "ListViewArray dtype {} does not match outer dtype {}", - actual_dtype, - dtype + vortex_ensure_eq!( + &actual_dtype, + dtype, + "ListViewArray dtype does not match outer dtype", ); Ok(()) diff --git a/vortex-array/src/arrays/map/array.rs b/vortex-array/src/arrays/map/array.rs index 1cdc362b606..35e08f585ab 100644 --- a/vortex-array/src/arrays/map/array.rs +++ b/vortex-array/src/arrays/map/array.rs @@ -9,6 +9,7 @@ use std::sync::Arc; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayEq; use crate::ArrayHash; @@ -173,17 +174,17 @@ pub(super) fn validate_entries( "MapArray entries must use vortex.listview encoding, got {}", entries.encoding_id() ); - vortex_ensure!( - entries.len() == len, - "MapArray entries length {} does not match outer length {len}", - entries.len() + vortex_ensure_eq!( + entries.len(), + len, + "MapArray entries length does not match outer length", ); let expected_dtype = expected_entries_dtype(map_dtype, nullability); - vortex_ensure!( - entries.dtype() == &expected_dtype, - "MapArray entries dtype {} does not match expected {expected_dtype}", - entries.dtype() + vortex_ensure_eq!( + entries.dtype(), + &expected_dtype, + "MapArray entries dtype does not match expected dtype", ); Ok(()) diff --git a/vortex-array/src/arrays/map/vtable/mod.rs b/vortex-array/src/arrays/map/vtable/mod.rs index f11e3e72a89..1f766e2e1f7 100644 --- a/vortex-array/src/arrays/map/vtable/mod.rs +++ b/vortex-array/src/arrays/map/vtable/mod.rs @@ -4,6 +4,7 @@ use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -66,12 +67,7 @@ impl VTable for Map { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == MapSlots::COUNT, - "MapArray expected {} slot, found {}", - MapSlots::COUNT, - slots.len() - ); + vortex_ensure_eq!(slots.len(), MapSlots::COUNT); let DType::Map(map_dtype, nullability) = dtype else { vortex_bail!("Expected map dtype, got {dtype}"); @@ -127,12 +123,7 @@ impl VTable for Map { let DType::Map(map_dtype, nullability) = dtype else { vortex_bail!("Expected map dtype, got {dtype}"); }; - vortex_ensure!( - children.len() == MapSlots::COUNT, - "MapArray expected {} child, found {}", - MapSlots::COUNT, - children.len() - ); + vortex_ensure_eq!(children.len(), MapSlots::COUNT); let expected_entries_dtype = DType::List(std::sync::Arc::new(map_dtype.entries_dtype()), *nullability); diff --git a/vortex-array/src/arrays/masked/vtable/mod.rs b/vortex-array/src/arrays/masked/vtable/mod.rs index ccadee27e98..80c2ee9fd6b 100644 --- a/vortex-array/src/arrays/masked/vtable/mod.rs +++ b/vortex-array/src/arrays/masked/vtable/mod.rs @@ -11,6 +11,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -88,10 +89,11 @@ impl VTable for Masked { let child = slots[MaskedSlots::CHILD] .as_ref() .vortex_expect("validated child slot"); - vortex_ensure!(child.len() == len, "MaskedArray child length mismatch"); - vortex_ensure!( - child.dtype().as_nullable() == *dtype, - "MaskedArray dtype does not match child and validity" + vortex_ensure_eq!(child.len(), len, "MaskedArray child length mismatch"); + vortex_ensure_eq!( + child.dtype().as_nullable(), + *dtype, + "MaskedArray dtype does not match child and validity", ); vortex_ensure!( child.all_valid(&mut legacy_session().create_execution_ctx())?, diff --git a/vortex-array/src/arrays/null/mod.rs b/vortex-array/src/arrays/null/mod.rs index b4d4536c9cf..bd2aabc5a08 100644 --- a/vortex-array/src/arrays/null/mod.rs +++ b/vortex-array/src/arrays/null/mod.rs @@ -4,6 +4,7 @@ use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -52,7 +53,7 @@ impl VTable for Null { _len: usize, _slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!(*dtype == DType::Null, "NullArray dtype must be DType::Null"); + vortex_ensure_eq!(*dtype, DType::Null, "NullArray dtype must be DType::Null"); Ok(()) } diff --git a/vortex-array/src/arrays/patched/array.rs b/vortex-array/src/arrays/patched/array.rs index 4522c8223b8..8b2897c57c1 100644 --- a/vortex-array/src/arrays/patched/array.rs +++ b/vortex-array/src/arrays/patched/array.rs @@ -9,6 +9,7 @@ use vortex_buffer::Buffer; use vortex_buffer::BufferMut; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::ArrayRef; @@ -80,23 +81,20 @@ impl PatchedData { len: usize, slots: &PatchedSlotsView, ) -> VortexResult<()> { - vortex_ensure!( - slots.inner.dtype() == dtype, - "PatchedArray base dtype {} does not match outer dtype {}", + vortex_ensure_eq!( slots.inner.dtype(), - dtype + dtype, + "PatchedArray base dtype does not match outer dtype", ); - vortex_ensure!( - slots.inner.len() == len, - "PatchedArray base len {} does not match outer len {}", + vortex_ensure_eq!( slots.inner.len(), - len + len, + "PatchedArray base len does not match outer len", ); - vortex_ensure!( - slots.patch_indices.len() == slots.patch_values.len(), - "PatchedArray patch indices len {} does not match patch values len {}", + vortex_ensure_eq!( slots.patch_indices.len(), - slots.patch_values.len() + slots.patch_values.len(), + "PatchedArray patch indices len does not match patch values len", ); Ok(()) } diff --git a/vortex-array/src/arrays/piecewise_sequence/mod.rs b/vortex-array/src/arrays/piecewise_sequence/mod.rs index 05b7b13edf4..843fe7a01cc 100644 --- a/vortex-array/src/arrays/piecewise_sequence/mod.rs +++ b/vortex-array/src/arrays/piecewise_sequence/mod.rs @@ -15,6 +15,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::ArrayRef; @@ -44,17 +45,15 @@ pub(crate) fn check_index_arrays( check_index_array("starts", starts)?; check_index_array("lengths", lengths)?; check_index_array("multipliers", multipliers)?; - vortex_ensure!( - starts.len() == lengths.len(), - "PiecewiseSequenceArray starts length {} does not match lengths length {}", + vortex_ensure_eq!( starts.len(), - lengths.len() + lengths.len(), + "PiecewiseSequenceArray starts length does not match lengths length", ); - vortex_ensure!( - starts.len() == multipliers.len(), - "PiecewiseSequenceArray starts length {} does not match multipliers length {}", + vortex_ensure_eq!( starts.len(), - multipliers.len() + multipliers.len(), + "PiecewiseSequenceArray starts length does not match multipliers length", ); Ok(()) } diff --git a/vortex-array/src/arrays/piecewise_sequence/vtable.rs b/vortex-array/src/arrays/piecewise_sequence/vtable.rs index d39bd6eccac..db5b33a1081 100644 --- a/vortex-array/src/arrays/piecewise_sequence/vtable.rs +++ b/vortex-array/src/arrays/piecewise_sequence/vtable.rs @@ -4,7 +4,7 @@ use itertools::Itertools; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -61,16 +61,12 @@ impl VTable for PiecewiseSequence { _len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - dtype == &DType::from(PType::U64), - "PiecewiseSequenceArray dtype must be u64, got {dtype}" - ); - vortex_ensure!( - slots.len() == PiecewiseSequenceSlots::NAMES.len(), - "PiecewiseSequenceArray requires {} slots, got {}", - PiecewiseSequenceSlots::NAMES.len(), - slots.len() + vortex_ensure_eq!( + dtype, + &DType::from(PType::U64), + "PiecewiseSequenceArray dtype must be u64", ); + vortex_ensure_eq!(slots.len(), PiecewiseSequenceSlots::NAMES.len()); let starts = slots[PiecewiseSequenceSlots::STARTS] .as_ref() .ok_or_else(|| vortex_err!("PiecewiseSequenceArray starts slot must be present"))?; diff --git a/vortex-array/src/arrays/primitive/vtable/mod.rs b/vortex-array/src/arrays/primitive/vtable/mod.rs index 45256a7a498..4a9f1102fc5 100644 --- a/vortex-array/src/arrays/primitive/vtable/mod.rs +++ b/vortex-array/src/arrays/primitive/vtable/mod.rs @@ -4,6 +4,7 @@ use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrayParts; use crate::ArrayRef; @@ -110,20 +111,18 @@ impl VTable for Primitive { let DType::Primitive(_, nullability) = dtype else { vortex_bail!("Expected primitive dtype, got {dtype:?}"); }; - vortex_ensure!( - data.len() == len, - "PrimitiveArray length {} does not match outer length {}", + vortex_ensure_eq!( data.len(), - len + len, + "PrimitiveArray length does not match outer length", ); let validity = crate::array::child_to_validity(slots[PrimitiveSlots::VALIDITY].as_ref(), *nullability); if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == len, - "PrimitiveArray validity len {} does not match outer length {}", + vortex_ensure_eq!( validity_len, - len + len, + "PrimitiveArray validity len does not match outer length", ); } diff --git a/vortex-array/src/arrays/scalar_fn/plugin.rs b/vortex-array/src/arrays/scalar_fn/plugin.rs index 46c1a597f9a..4a4a7d3d5ab 100644 --- a/vortex-array/src/arrays/scalar_fn/plugin.rs +++ b/vortex-array/src/arrays/scalar_fn/plugin.rs @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: Copyright the Vortex contributors use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use crate::ArrayDeserialization; @@ -80,11 +80,10 @@ impl ArrayPlugin for ScalarFnArrayPlugi parts: ArrayDeserialization<'_>, session: &VortexSession, ) -> VortexResult { - vortex_ensure!( - parts.serialized_id == self.id(), - "scalar function array plugin {} does not recognize serialized ID {}", - self.id(), + vortex_ensure_eq!( parts.serialized_id, + self.id(), + "scalar function array plugin does not recognize serialized ID", ); let len = parts.len; let scalar_parts = ::deserialize( diff --git a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs index d2f45f19330..7f47deb05ad 100644 --- a/vortex-array/src/arrays/scalar_fn/vtable/mod.rs +++ b/vortex-array/src/arrays/scalar_fn/vtable/mod.rs @@ -13,6 +13,7 @@ use validity::ValidityArray; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -83,15 +84,17 @@ impl VTable for ScalarFn { slots: &[Option], ) -> VortexResult<()> { let scalar_fn = data.scalar_fn(); - vortex_ensure!( - scalar_fn.id() == self.id, - "ScalarFnArray data scalar_fn does not match vtable" + vortex_ensure_eq!( + scalar_fn.id(), + self.id, + "ScalarFnArray data scalar_fn does not match vtable", ); let missing_children = slots.iter().filter(|slot| slot.is_none()).count(); - vortex_ensure!( - missing_children == 0, - "ScalarFnArray requires every child slot to be present, got {missing_children} missing" + vortex_ensure_eq!( + missing_children, + 0, + "ScalarFnArray requires every child slot to be present", ); let arity = scalar_fn.signature().arity(); @@ -110,9 +113,10 @@ impl VTable for ScalarFn { .flatten() .map(|c| c.dtype().clone()) .collect_vec(); - vortex_ensure!( - scalar_fn.return_dtype(&child_dtypes)? == *dtype, - "ScalarFnArray dtype does not match scalar function return dtype" + vortex_ensure_eq!( + scalar_fn.return_dtype(&child_dtypes)?, + *dtype, + "ScalarFnArray dtype does not match scalar function return dtype", ); Ok(()) } diff --git a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs index e5b1e78a0e0..58dde01d257 100644 --- a/vortex-array/src/arrays/scalar_fn/vtable/operations.rs +++ b/vortex-array/src/arrays/scalar_fn/vtable/operations.rs @@ -168,7 +168,7 @@ mod tests { assert!( err.to_string() - .contains("ScalarFnArray requires every child slot to be present, got 1 missing") + .contains("ScalarFnArray requires every child slot to be present") ); } diff --git a/vortex-array/src/arrays/shared/vtable.rs b/vortex-array/src/arrays/shared/vtable.rs index 9df66667062..92c2f99e93e 100644 --- a/vortex-array/src/arrays/shared/vtable.rs +++ b/vortex-array/src/arrays/shared/vtable.rs @@ -71,8 +71,8 @@ impl VTable for Shared { let source = slots[SharedSlots::SOURCE] .as_ref() .vortex_expect("SharedArray source slot must be present"); - vortex_error::vortex_ensure!(source.dtype() == dtype, "SharedArray dtype mismatch"); - vortex_error::vortex_ensure!(source.len() == len, "SharedArray len mismatch"); + vortex_error::vortex_ensure_eq!(source.dtype(), dtype, "SharedArray dtype mismatch"); + vortex_error::vortex_ensure_eq!(source.len(), len, "SharedArray len mismatch"); Ok(()) } diff --git a/vortex-array/src/arrays/slice/vtable.rs b/vortex-array/src/arrays/slice/vtable.rs index de87931ab5f..ef5cac4027c 100644 --- a/vortex-array/src/arrays/slice/vtable.rs +++ b/vortex-array/src/arrays/slice/vtable.rs @@ -11,6 +11,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -85,17 +86,15 @@ impl VTable for Slice { let child = slots[SliceSlots::CHILD] .as_ref() .vortex_expect("validated child slot"); - vortex_ensure!( - child.dtype() == dtype, - "SliceArray dtype {} does not match outer dtype {}", + vortex_ensure_eq!( child.dtype(), - dtype + dtype, + "SliceArray dtype does not match outer dtype", ); - vortex_ensure!( - data.len() == len, - "SliceArray length {} does not match outer length {}", + vortex_ensure_eq!( data.len(), - len + len, + "SliceArray length does not match outer length", ); vortex_ensure!( data.range.end <= child.len(), diff --git a/vortex-array/src/arrays/union/vtable/mod.rs b/vortex-array/src/arrays/union/vtable/mod.rs index c34e16eeaab..7800f9430d2 100644 --- a/vortex-array/src/arrays/union/vtable/mod.rs +++ b/vortex-array/src/arrays/union/vtable/mod.rs @@ -121,13 +121,7 @@ impl VTable for Union { let DType::Union(variants, nullability) = dtype else { vortex_bail!("Expected union dtype, found {dtype}") }; - vortex_ensure_eq!( - children.len(), - UnionSlots::CHILDREN_OFFSET + variants.len(), - "UnionArray expected {} children, found {}", - UnionSlots::CHILDREN_OFFSET + variants.len(), - children.len() - ); + vortex_ensure_eq!(children.len(), UnionSlots::CHILDREN_OFFSET + variants.len()); let type_ids = children.get( UnionSlots::TYPE_IDS, diff --git a/vortex-array/src/arrays/union/vtable/validate.rs b/vortex-array/src/arrays/union/vtable/validate.rs index e01c5486a94..8e232600939 100644 --- a/vortex-array/src/arrays/union/vtable/validate.rs +++ b/vortex-array/src/arrays/union/vtable/validate.rs @@ -6,7 +6,6 @@ use vortex_error::vortex_bail; use vortex_error::vortex_ensure_eq; use crate::ArrayRef; -use crate::arrays::union::UnionSlots; use crate::arrays::union::union_type_ids_dtype; use crate::dtype::DType; @@ -22,23 +21,19 @@ pub(super) fn validate_union_components( vortex_ensure_eq!( variant_arrays.len(), variants.len(), - "UnionArray has {} slots but expected {}", - UnionSlots::CHILDREN_OFFSET + variant_arrays.len(), - UnionSlots::CHILDREN_OFFSET + variants.len() + "UnionArray variant slot count does not match variant count", ); let expected_union_type_ids_dtype = union_type_ids_dtype(*nullability); vortex_ensure_eq!( type_ids.dtype(), &expected_union_type_ids_dtype, - "UnionArray type_ids must have dtype {expected_union_type_ids_dtype}, got {}", - type_ids.dtype() + "UnionArray type_ids has unexpected dtype", ); vortex_ensure_eq!( type_ids.len(), len, - "UnionArray type_ids length {} does not match outer length {len}", - type_ids.len() + "UnionArray type_ids length does not match outer length", ); for (index, (variant_dtype, child)) in @@ -47,14 +42,12 @@ pub(super) fn validate_union_components( vortex_ensure_eq!( child.len(), len, - "UnionArray child {index} length {} does not match outer length {len}", - child.len() + "UnionArray child {index} length does not match outer length", ); vortex_ensure_eq!( child.dtype(), &variant_dtype, - "UnionArray child {index} has dtype {} but expected {variant_dtype}", - child.dtype() + "UnionArray child {index} has unexpected dtype", ); } diff --git a/vortex-array/src/arrays/varbin/array.rs b/vortex-array/src/arrays/varbin/array.rs index 82aa3251253..f809f49fb57 100644 --- a/vortex-array/src/arrays/varbin/array.rs +++ b/vortex-array/src/arrays/varbin/array.rs @@ -11,6 +11,7 @@ use vortex_buffer::ByteBuffer; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use crate::ArrayRef; @@ -223,11 +224,10 @@ impl VarBinData { // Check validity length if let Some(validity_len) = validity.maybe_len() { - vortex_ensure!( - validity_len == offsets.len() - 1, - "Validity length {} doesn't match array length {}", + vortex_ensure_eq!( validity_len, - offsets.len() - 1 + offsets.len() - 1, + "Validity length doesn't match array length", ); } diff --git a/vortex-array/src/arrays/varbin/builder.rs b/vortex-array/src/arrays/varbin/builder.rs index 39e694dd164..e14fdbc9f27 100644 --- a/vortex-array/src/arrays/varbin/builder.rs +++ b/vortex-array/src/arrays/varbin/builder.rs @@ -15,6 +15,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_mask::AllOr; use vortex_mask::Mask; @@ -197,11 +198,10 @@ impl VarBinBuilder { /// Returns an error if `scalar` has a different dtype than the builder, or if the resulting /// end offsets do not fit in `O`. pub fn append_scalar_repeated(&mut self, scalar: &Scalar, n: usize) -> VortexResult<()> { - vortex_ensure!( - scalar.dtype() == &self.dtype, - "VarBinBuilder expected scalar with dtype {}, got {}", - self.dtype, - scalar.dtype() + vortex_ensure_eq!( + scalar.dtype(), + &self.dtype, + "VarBinBuilder scalar dtype does not match builder dtype", ); match &self.dtype { DType::Utf8(_) => match scalar.as_utf8().value() { @@ -291,9 +291,10 @@ impl VarBinBuilder { let data_len = self.data.len(); let written = decode(self.data.spare_capacity_mut())?; - vortex_ensure!( - written == num_bytes, - "Decoded {written} bytes, expected {num_bytes}" + vortex_ensure_eq!( + written, + num_bytes, + "Decoded byte count does not match expected byte count", ); // The decoded bytes live in spare capacity until `set_len` below, so an invalid `lengths` @@ -515,9 +516,10 @@ impl VarBinBuilder { end_offsets.next().is_none(), "End offset count exceeds the validity length {count}" ); - vortex_ensure!( - previous == num_bytes, - "Final end offset {previous} does not match the value byte count {num_bytes}" + vortex_ensure_eq!( + previous, + num_bytes, + "Final end offset does not match the value byte count", ); // SAFETY: the loop initialized the first `count` spare slots. @@ -576,10 +578,10 @@ impl VarBinBuilder { // A caller whose slices overrun `num_bytes` only grows the byte buffer past the reservation, // so the overrun is caught here rather than per value. The offsets are still uncommitted, so // rejecting it now leaves them untouched. - vortex_ensure!( - data.len() == data_start + num_bytes, - "Value slices total {} bytes, expected {num_bytes}", - data.len() - data_start + vortex_ensure_eq!( + data.len(), + data_start + num_bytes, + "Value slices byte count does not match expected byte count", ); // SAFETY: every branch above initialized all `count` spare slots. diff --git a/vortex-array/src/arrays/varbin/compute/take.rs b/vortex-array/src/arrays/varbin/compute/take.rs index 46bc1ec5b33..8709a459298 100644 --- a/vortex-array/src/arrays/varbin/compute/take.rs +++ b/vortex-array/src/arrays/varbin/compute/take.rs @@ -13,6 +13,7 @@ use vortex_buffer::ByteBufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_mask::AllOr; @@ -588,9 +589,10 @@ where .len() .checked_mul(length) .ok_or_else(|| vortex_err!("PiecewiseSequenceArray output length overflows usize"))?; - vortex_ensure!( - computed_len == output_len, - "PiecewiseSequenceArray expanded length {computed_len} does not match declared length {output_len}" + vortex_ensure_eq!( + computed_len, + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); let mut new_offsets = Offsets::with_capacity(out_offset_ptype, output_len + 1); @@ -646,10 +648,10 @@ where } // SAFETY: the loop initialized the prefix `0..cursor` of the spare capacity. unsafe { new_data.set_len(cursor) }; - vortex_ensure!( - new_data.len() == output_bytes, - "PiecewiseSequenceArray gathered byte length {} does not match declared byte length {output_bytes}", - new_data.len() + vortex_ensure_eq!( + new_data.len(), + output_bytes, + "PiecewiseSequenceArray gathered byte length does not match declared byte length", ); let offsets = new_offsets.into_array(); @@ -707,10 +709,10 @@ where .checked_add(byte_end - byte_start) .ok_or_else(|| vortex_err!("PiecewiseSequence VarBin output byte length overflow"))?; } - vortex_ensure!( - new_offsets.len() == output_len + 1, - "PiecewiseSequenceArray expanded length {} does not match declared length {output_len}", - new_offsets.len() - 1 + vortex_ensure_eq!( + new_offsets.len(), + output_len + 1, + "PiecewiseSequenceArray expanded offsets length does not match declared length plus one", ); let mut new_data = ByteBufferMut::with_capacity(output_bytes); @@ -732,10 +734,10 @@ where } // SAFETY: the loop initialized the prefix `0..cursor` of the spare capacity. unsafe { new_data.set_len(cursor) }; - vortex_ensure!( - new_data.len() == output_bytes, - "PiecewiseSequenceArray gathered byte length {} does not match declared byte length {output_bytes}", - new_data.len() + vortex_ensure_eq!( + new_data.len(), + output_bytes, + "PiecewiseSequenceArray gathered byte length does not match declared byte length", ); let offsets = new_offsets.into_array(); diff --git a/vortex-array/src/arrays/varbin/vtable/mod.rs b/vortex-array/src/arrays/varbin/vtable/mod.rs index 397b0f8084b..6cb414ed70f 100644 --- a/vortex-array/src/arrays/varbin/vtable/mod.rs +++ b/vortex-array/src/arrays/varbin/vtable/mod.rs @@ -8,6 +8,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::registry::CachedId; @@ -94,20 +95,14 @@ impl VTable for VarBin { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == VarBinSlots::COUNT, - "VarBinArray expected {} slots, found {}", - VarBinSlots::COUNT, - slots.len() - ); + vortex_ensure_eq!(slots.len(), VarBinSlots::COUNT); let offsets = slots[VarBinSlots::OFFSETS] .as_ref() .vortex_expect("VarBinArray offsets slot"); - vortex_ensure!( - offsets.len().saturating_sub(1) == len, - "VarBinArray length {} does not match outer length {}", + vortex_ensure_eq!( offsets.len().saturating_sub(1), - len + len, + "VarBinArray length does not match outer length", ); vortex_ensure!( matches!(dtype, DType::Binary(_) | DType::Utf8(_)), @@ -135,11 +130,7 @@ impl VTable for VarBin { array: ArrayView<'_, Self>, buffers: &[BufferHandle], ) -> VortexResult> { - vortex_ensure!( - buffers.len() == 1, - "Expected 1 buffer, got {}", - buffers.len() - ); + vortex_ensure_eq!(buffers.len(), 1); let mut data = array.data().clone(); data.bytes = buffers[0].clone(); Ok( diff --git a/vortex-array/src/arrays/varbinview/array.rs b/vortex-array/src/arrays/varbinview/array.rs index b2db8f79b65..de1c4b20907 100644 --- a/vortex-array/src/arrays/varbinview/array.rs +++ b/vortex-array/src/arrays/varbinview/array.rs @@ -15,6 +15,7 @@ use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_mask::AllOr; @@ -402,11 +403,10 @@ impl VarBinViewData { fn check_nullability(dtype: &DType, validity: &Validity) -> VortexResult { let (is_utf8, nullability) = Self::dtype_parts(dtype)?; - vortex_ensure!( - validity.nullability() == nullability, - InvalidArgument: "validity {:?} incompatible with nullability {:?}", - validity, - nullability + vortex_ensure_eq!( + validity.nullability(), + nullability, + InvalidArgument: "validity nullability is incompatible with dtype nullability", ); Ok(is_utf8) } diff --git a/vortex-array/src/arrays/varbinview/compute/take.rs b/vortex-array/src/arrays/varbinview/compute/take.rs index 5e63f5359f1..56e599711eb 100644 --- a/vortex-array/src/arrays/varbinview/compute/take.rs +++ b/vortex-array/src/arrays/varbinview/compute/take.rs @@ -9,7 +9,7 @@ use num_traits::AsPrimitive; use vortex_buffer::Buffer; use vortex_buffer::BufferMut; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::AllOr; use vortex_mask::Mask; @@ -168,9 +168,10 @@ where .len() .checked_mul(length) .ok_or_else(|| vortex_err!("PiecewiseSequenceArray output length overflows usize"))?; - vortex_ensure!( - computed_len == output_len, - "PiecewiseSequenceArray expanded length {computed_len} does not match declared length {output_len}" + vortex_ensure_eq!( + computed_len, + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); let mut views = BufferMut::::with_capacity(output_len); @@ -184,10 +185,10 @@ where } // SAFETY: the loop initialized the prefix `0..cursor` of the spare capacity. unsafe { views.set_len(cursor) }; - vortex_ensure!( - views.len() == output_len, - "PiecewiseSequenceArray expanded length {} does not match declared length {output_len}", - views.len() + vortex_ensure_eq!( + views.len(), + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); Ok(views.freeze()) } @@ -214,10 +215,10 @@ where } // SAFETY: the loop initialized the prefix `0..cursor` of the spare capacity. unsafe { views.set_len(cursor) }; - vortex_ensure!( - views.len() == output_len, - "PiecewiseSequenceArray expanded length {} does not match declared length {output_len}", - views.len() + vortex_ensure_eq!( + views.len(), + output_len, + "PiecewiseSequenceArray expanded length does not match declared length", ); Ok(views.freeze()) } diff --git a/vortex-array/src/arrays/varbinview/vtable/mod.rs b/vortex-array/src/arrays/varbinview/vtable/mod.rs index 0d2963cd6b2..5459a2cb31f 100644 --- a/vortex-array/src/arrays/varbinview/vtable/mod.rs +++ b/vortex-array/src/arrays/varbinview/vtable/mod.rs @@ -9,6 +9,7 @@ use vortex_buffer::Buffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_error::vortex_panic; use vortex_session::VortexSession; @@ -93,17 +94,11 @@ impl VTable for VarBinView { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == VarBinViewSlots::COUNT, - "VarBinViewArray expected {} slots, found {}", - VarBinViewSlots::COUNT, - slots.len() - ); - vortex_ensure!( - data.len() == len, - "VarBinViewArray length {} does not match outer length {}", + vortex_ensure_eq!(slots.len(), VarBinViewSlots::COUNT); + vortex_ensure_eq!( data.len(), - len + len, + "VarBinViewArray length does not match outer length", ); vortex_ensure!( matches!(dtype, DType::Binary(_) | DType::Utf8(_)), diff --git a/vortex-array/src/arrays/variant/vtable/mod.rs b/vortex-array/src/arrays/variant/vtable/mod.rs index 837bd32a7bf..7fd97db0deb 100644 --- a/vortex-array/src/arrays/variant/vtable/mod.rs +++ b/vortex-array/src/arrays/variant/vtable/mod.rs @@ -9,6 +9,7 @@ use prost::Message; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -72,12 +73,7 @@ impl VTable for Variant { len: usize, slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!( - slots.len() == VariantSlots::COUNT, - "VariantArray expects {} slots, got {}", - VariantSlots::COUNT, - slots.len() - ); + vortex_ensure_eq!(slots.len(), VariantSlots::COUNT); vortex_ensure!( slots[VariantSlots::CORE_STORAGE].is_some(), "VariantArray core_storage slot must be present" @@ -89,24 +85,21 @@ impl VTable for Variant { matches!(dtype, DType::Variant(_)), "Expected Variant DType, got {dtype}" ); - vortex_ensure!( - core_storage.dtype() == dtype, - "VariantArray core_storage dtype {} does not match outer dtype {}", + vortex_ensure_eq!( core_storage.dtype(), - dtype + dtype, + "VariantArray core_storage dtype does not match outer dtype", ); - vortex_ensure!( - core_storage.len() == len, - "VariantArray core_storage length {} does not match outer length {}", + vortex_ensure_eq!( core_storage.len(), - len + len, + "VariantArray core_storage length does not match outer length", ); if let Some(shredded) = slots[VariantSlots::SHREDDED].as_ref() { - vortex_ensure!( - shredded.len() == len, - "VariantArray shredded length {} does not match outer length {}", + vortex_ensure_eq!( shredded.len(), - len + len, + "VariantArray shredded length does not match outer length", ); } Ok(()) @@ -167,12 +160,7 @@ impl VTable for Variant { .transpose()?; vortex_ensure!(matches!(dtype, DType::Variant(_)), "Expected Variant DType"); let expected_children = 1 + usize::from(shredded_dtype.is_some()); - vortex_ensure!( - children.len() == expected_children, - "Expected {} children, got {}", - expected_children, - children.len(), - ); + vortex_ensure_eq!(children.len(), expected_children); let core_storage = children.get(0, dtype, len)?; let shredded = shredded_dtype .map(|dtype| children.get(1, &dtype, len)) From 8929f7c4c7dc0620fbd6eb80de585705e6a1daf8 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 19:20:12 +0000 Subject: [PATCH 5/8] Drop redundant vortex_ensure_eq! messages in remaining crates Remove custom messages that only restated the compared values, and turn plain equality vortex_ensure! checks into vortex_ensure_eq!. Messages that add context are kept without the values. Claude-Session: https://claude.ai/code/session_01YUXDBd65US5mcKTxb2Xcer Signed-off-by: Claude --- vortex-arrow/src/convert.rs | 7 ++-- vortex-arrow/src/executor/list_view.rs | 9 ++--- vortex-arrow/src/executor/map.rs | 9 ++--- vortex-arrow/src/executor/mod.rs | 7 ++-- vortex-arrow/src/executor/struct_.rs | 8 ++--- vortex-arrow/src/run_end_import.rs | 9 +++-- vortex-arrow/src/session.rs | 18 +++++----- vortex-cuda/ffi/src/lib.rs | 3 +- vortex-cuda/src/arrow/canonical.rs | 16 +++++---- vortex-cuda/src/arrow/mod.rs | 24 +++++-------- vortex-cuda/src/executor.rs | 3 +- vortex-cuda/src/kernel/arrays/list.rs | 9 +++-- vortex-cuda/src/kernel/encodings/delta.rs | 6 ++-- vortex-cuda/src/kernel/encodings/onpair.rs | 27 +++++++------- vortex-cuda/src/kernel/encodings/zigzag.rs | 8 +++-- vortex-cuda/src/kernel/patches/mod.rs | 15 ++++---- vortex-cuda/src/pinned.rs | 8 ++--- vortex-cuda/src/pooled_read_at.rs | 6 ++-- vortex-duckdb/src/convert/expr.rs | 14 ++++---- vortex-duckdb/src/convert/scalar.rs | 4 +-- vortex-duckdb/src/exporter/uuid.rs | 9 +++-- vortex-ffi/src/array.rs | 3 +- vortex-ffi/src/sink.rs | 8 ++--- vortex-ffi/src/string.rs | 4 +-- vortex-io/src/object_store/read_at.rs | 6 ++-- vortex-layout/src/layouts/dict/mod.rs | 12 ++++--- vortex-layout/src/layouts/list/mod.rs | 10 +++--- vortex-layout/src/layouts/struct_/mod.rs | 12 +++---- .../zoned/aggregates/bloom_filter/mod.rs | 6 +--- .../aggregates/bloom_filter/scalar_fn.rs | 5 ++- vortex-layout/src/layouts/zoned/mod.rs | 8 ++--- vortex-layout/src/layouts/zoned/reader.rs | 9 ++--- vortex-layout/src/layouts/zoned/zone_map.rs | 9 +++-- vortex-layout/src/plan/optimizer/rules.rs | 29 +++++++-------- vortex-layout/src/plan/plans/row_idx.rs | 7 ++-- vortex-python-cuda/src/lib.rs | 35 +++++++++---------- vortex-python/src/arrays/py/vtable.rs | 8 ++--- vortex-spatial/src/scalar_fn/collect.rs | 10 +++--- vortex-spatial/src/scalar_fn/convex_hull.rs | 9 ++--- vortex-spatial/src/scalar_fn/envelope.rs | 9 ++--- vortex-spatial/src/scalar_fn/length.rs | 9 ++--- vortex-spatial/src/scalar_fn/make_line.rs | 17 ++++----- vortex-spatial/src/scalar_fn/row.rs | 7 ++-- vortex-tensor/src/scalar_fns/row.rs | 18 +++------- .../src/types/fixed_shape_tensor/metadata.rs | 16 ++------- .../src/types/fixed_shape_tensor/vtable.rs | 3 +- 46 files changed, 231 insertions(+), 257 deletions(-) diff --git a/vortex-arrow/src/convert.rs b/vortex-arrow/src/convert.rs index 3a8a51c6713..c19bfc8ba1f 100644 --- a/vortex-arrow/src/convert.rs +++ b/vortex-arrow/src/convert.rs @@ -607,8 +607,9 @@ pub(crate) fn map_from_arrow_parts( entries.dtype() ); }; - vortex_ensure!( - struct_dtype.nfields() == 2, + vortex_ensure_eq!( + struct_dtype.nfields(), + 2, "Arrow map entries struct must contain exactly two fields" ); @@ -725,7 +726,7 @@ pub fn nulls(nulls: Option<&NullBuffer>, nullable: bool) -> VortexResult( ); // The unchecked construction below needs the views in bounds of the *exported* elements, so // confirm the export preserved the length the Vortex invariant was checked against. - vortex_ensure!( - elements.len() == n_elements, - "Arrow export changed the elements length: {n_elements} became {}", - elements.len() + vortex_ensure_eq!( + elements.len(), + n_elements, + "Arrow export changed the elements length" ); let offsets = offsets diff --git a/vortex-arrow/src/executor/map.rs b/vortex-arrow/src/executor/map.rs index f8e0cefea19..c6da7206695 100644 --- a/vortex-arrow/src/executor/map.rs +++ b/vortex-arrow/src/executor/map.rs @@ -17,6 +17,7 @@ use vortex_array::arrays::map::MapArrayExt; use vortex_array::arrays::map::MapArraySlotsExt; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::executor::list::to_arrow_list; @@ -44,10 +45,10 @@ pub(super) fn to_arrow_map( let entries = array.entries().clone(); let entries_list_type = DataType::List(Arc::clone(entries_field)); let entries_list = to_arrow_list::(entries, entries_field, ctx)?; - vortex_ensure!( - entries_list.data_type() == &entries_list_type, - "Arrow Map entries converted to {}, expected {entries_list_type}", - entries_list.data_type() + vortex_ensure_eq!( + entries_list.data_type(), + &entries_list_type, + "Arrow Map entries converted to an unexpected type" ); let entries_list = entries_list.as_list::(); diff --git a/vortex-arrow/src/executor/mod.rs b/vortex-arrow/src/executor/mod.rs index 036954ffe66..37556b09ee1 100644 --- a/vortex-arrow/src/executor/mod.rs +++ b/vortex-arrow/src/executor/mod.rs @@ -41,7 +41,7 @@ use vortex_array::dtype::DType; use vortex_array::dtype::PType; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::executor::bool::to_arrow_bool; use crate::executor::byte::to_arrow_byte_array; @@ -203,8 +203,9 @@ pub(crate) fn execute_arrow_naive( } }?; - vortex_ensure!( - arrow.len() == len, + vortex_ensure_eq!( + arrow.len(), + len, "Arrow array length does not match Vortex array length after conversion to {:?}", arrow ); diff --git a/vortex-arrow/src/executor/struct_.rs b/vortex-arrow/src/executor/struct_.rs index a7553dde78b..1173f358b0a 100644 --- a/vortex-arrow/src/executor/struct_.rs +++ b/vortex-arrow/src/executor/struct_.rs @@ -25,6 +25,7 @@ use vortex_array::matcher::Matcher; use vortex_array::scalar_fn::fns::pack::Pack; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::ArrowArrayExecutor; use crate::executor::infer_nearest_arrow_field; @@ -142,11 +143,10 @@ fn create_from_fields( ) -> VortexResult { match fields { Ok(fields) => { - vortex_ensure!( - vortex_fields.len() == fields.len(), - "StructArray has {} fields, but target Arrow type has {} fields", + vortex_ensure_eq!( vortex_fields.len(), - fields.len() + fields.len(), + "StructArray field count must match the target Arrow type" ); let mut arrow_arrays = Vec::with_capacity(vortex_fields.len()); diff --git a/vortex-arrow/src/run_end_import.rs b/vortex-arrow/src/run_end_import.rs index 6a301298907..344d10fe03f 100644 --- a/vortex-arrow/src/run_end_import.rs +++ b/vortex-arrow/src/run_end_import.rs @@ -13,7 +13,7 @@ use vortex_array::dtype::NativePType; use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_runend::RunEnd; /// Build a Vortex run-end array from an Arrow [`RunArray`] and its already-converted `values`. @@ -33,11 +33,10 @@ where .reinterpret_cast(R::Native::PTYPE.to_unsigned()) .into_array(); - vortex_ensure!( - ends.len() == values.len(), - "Arrow run-end array has {} run ends but {} values", + vortex_ensure_eq!( ends.len(), - values.len() + values.len(), + "Arrow run-end array must have one value per run end" ); // Arrow slices a RunArray by adjusting the logical offset/length while keeping the full diff --git a/vortex-arrow/src/session.rs b/vortex-arrow/src/session.rs index 4375f89873a..9915f63a105 100644 --- a/vortex-arrow/src/session.rs +++ b/vortex-arrow/src/session.rs @@ -62,6 +62,7 @@ use vortex_array::validity::Validity; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::ArcSwapMap; use vortex_session::SessionExt; @@ -447,8 +448,9 @@ impl ArrowSession { entries.data_type() ); }; - vortex_ensure!( - fields.len() == 2, + vortex_ensure_eq!( + fields.len(), + 2, "Arrow map entries struct must contain exactly two fields" ); vortex_ensure!( @@ -507,12 +509,7 @@ impl ArrowSession { batch: RecordBatch, schema: &Schema, ) -> VortexResult { - vortex_ensure!( - batch.num_columns() == schema.fields().len(), - "RecordBatch has {} columns but schema has {} fields", - batch.num_columns(), - schema.fields().len() - ); + vortex_ensure_eq!(batch.num_columns(), schema.fields().len()); let length = batch.num_rows(); let names = FieldNames::from_iter( schema @@ -569,8 +566,9 @@ impl ArrowSession { match plugin.execute_arrow(current, target_field, ctx)? { ArrowExport::Exported(arrow) => { - vortex_ensure!( - arrow.len() == len, + vortex_ensure_eq!( + arrow.len(), + len, "Arrow array length does not match Vortex array length after conversion to {:?}", arrow ); diff --git a/vortex-cuda/ffi/src/lib.rs b/vortex-cuda/ffi/src/lib.rs index 7e61c476788..d86cadaccab 100644 --- a/vortex-cuda/ffi/src/lib.rs +++ b/vortex-cuda/ffi/src/lib.rs @@ -519,6 +519,7 @@ mod tests { use vortex::dtype::NativePType; use vortex::dtype::Nullability; use vortex::error::VortexResult; + use vortex::error::vortex_ensure_eq; use vortex::file::WriteOptionsSessionExt; use vortex::io::session::RuntimeSessionExt; use vortex::layout::LayoutStrategy; @@ -844,7 +845,7 @@ mod tests { let mut array = ArrowDeviceArray::empty(); // SAFETY: This live stream owns the callback; array is writable. let status = unsafe { get_next(stream, &raw mut array) }; - vortex_ensure!(status == 0, "get_next failed: {}", stream_error(stream)); + vortex_ensure_eq!(status, 0, "get_next failed: {}", stream_error(stream)); if array.array.release.is_none() { break; } diff --git a/vortex-cuda/src/arrow/canonical.rs b/vortex-cuda/src/arrow/canonical.rs index 12e19544615..fb06f4c48ab 100644 --- a/vortex-cuda/src/arrow/canonical.rs +++ b/vortex-cuda/src/arrow/canonical.rs @@ -60,6 +60,7 @@ use vortex::encodings::fsst::FSST; use vortex::error::VortexResult; use vortex::error::vortex_bail; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::extension::datetime::AnyTemporal; use vortex_onpair::OnPair; @@ -422,10 +423,10 @@ async fn export_dictionary_codes( }; let parts = codes.into_data_parts(); - vortex_ensure!( - parts.ptype == target_ptype, - "dictionary codes export produced {}", - parts.ptype + vortex_ensure_eq!( + parts.ptype, + target_ptype, + "dictionary codes export produced an unexpected ptype" ); Ok(parts) } @@ -1308,9 +1309,10 @@ async fn export_arrow_list_offsets( }; let PrimitiveDataParts { ptype, buffer, .. } = offsets.into_data_parts(); - vortex_ensure!( - ptype == PType::I32, - "list offsets cast to i32 produced {ptype}" + vortex_ensure_eq!( + ptype, + PType::I32, + "list offsets cast to i32 produced an unexpected ptype" ); ctx.ensure_on_device(buffer).await diff --git a/vortex-cuda/src/arrow/mod.rs b/vortex-cuda/src/arrow/mod.rs index 6bf5d96fc53..6f8f830730e 100644 --- a/vortex-cuda/src/arrow/mod.rs +++ b/vortex-cuda/src/arrow/mod.rs @@ -55,7 +55,7 @@ use vortex::dtype::DecimalType; use vortex::dtype::PType; use vortex::dtype::StructFields; use vortex::error::VortexResult; -use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::io::runtime::BlockingRuntime; use vortex::io::runtime::current::CurrentThreadRuntime; @@ -405,12 +405,7 @@ impl DeviceArrayStreamPrivateData { /// Export one array from the Vortex stream, validating it against the device stream. fn export_stream_array(&mut self, array: ArrayRef) -> VortexResult { - vortex_ensure!( - array.dtype() == &self.dtype, - "stream array dtype changed from {} to {}", - self.dtype, - array.dtype() - ); + vortex_ensure_eq!(array.dtype(), &self.dtype, "stream array dtype changed"); if self.ctx.cuda_session().dictionary_export() == DictionaryExport::Decode { self.get_or_init_schema()?; @@ -461,16 +456,15 @@ impl DeviceArrayStreamPrivateData { } fn check_device(&self, device_array: &ArrowDeviceArray) -> VortexResult<()> { - vortex_ensure!( - device_array.device_type == ARROW_DEVICE_CUDA, - "stream array exported on non-CUDA device type {}", - device_array.device_type + vortex_ensure_eq!( + device_array.device_type, + ARROW_DEVICE_CUDA, + "stream array exported on non-CUDA device type" ); - vortex_ensure!( - device_array.device_id == self.device_id, - "stream array moved from CUDA device {} to {}", + vortex_ensure_eq!( + device_array.device_id, self.device_id, - device_array.device_id + "stream array moved from CUDA device" ); Ok(()) } diff --git a/vortex-cuda/src/executor.rs b/vortex-cuda/src/executor.rs index 0d28b79c292..205b16f83a2 100644 --- a/vortex-cuda/src/executor.rs +++ b/vortex-cuda/src/executor.rs @@ -37,6 +37,7 @@ use vortex::dtype::PType; use vortex::error::VortexResult; use vortex::error::vortex_bail; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use crate::CudaSession; @@ -397,7 +398,7 @@ pub(crate) async fn execute_validity_cuda( return Ok(validity); }; - vortex_ensure!(array.len() == len, "validity array length mismatch"); + vortex_ensure_eq!(array.len(), len, "validity array length mismatch"); vortex_ensure!( matches!(array.dtype(), DType::Bool(Nullability::NonNullable)), "validity array must be non-nullable boolean, got {}", diff --git a/vortex-cuda/src/kernel/arrays/list.rs b/vortex-cuda/src/kernel/arrays/list.rs index d6aab480e4e..fad63ce776f 100644 --- a/vortex-cuda/src/kernel/arrays/list.rs +++ b/vortex-cuda/src/kernel/arrays/list.rs @@ -22,7 +22,7 @@ use vortex::array::validity::Validity; use vortex::dtype::NativePType; use vortex::dtype::Nullability; use vortex::error::VortexResult; -use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use crate::CudaBufferExt; @@ -77,11 +77,10 @@ impl CudaExecute for ListExecutor { .execute_cuda(ctx) .await? .into_primitive(); - vortex_ensure!( - offsets.len() == list_len + 1, - "ListArray must have {} offsets, got {}", + vortex_ensure_eq!( + offsets.len(), list_len + 1, - offsets.len() + "ListArray must have one more offset than lists" ); let offsets_ptype = offsets.ptype(); diff --git a/vortex-cuda/src/kernel/encodings/delta.rs b/vortex-cuda/src/kernel/encodings/delta.rs index 5dde85cfd65..e26ca8511a7 100644 --- a/vortex-cuda/src/kernel/encodings/delta.rs +++ b/vortex-cuda/src/kernel/encodings/delta.rs @@ -31,6 +31,7 @@ use vortex::encodings::fastlanes::DeltaArrayExt; use vortex::encodings::fastlanes::DeltaArraySlotsExt; use vortex::error::VortexResult; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use crate::CudaBufferExt; @@ -94,8 +95,9 @@ async fn decode_delta(array: DeltaArray, ctx: &mut CudaExecutionCtx) -> VortexRe let ptype = deltas.ptype(); let deltas_len = deltas.len(); let offset = array.offset(); - vortex_ensure!( - deltas_len % FL_CHUNK == 0, + vortex_ensure_eq!( + deltas_len % FL_CHUNK, + 0, "Delta deltas child must be padded to a multiple of {FL_CHUNK}, got {deltas_len}" ); vortex_ensure!( diff --git a/vortex-cuda/src/kernel/encodings/onpair.rs b/vortex-cuda/src/kernel/encodings/onpair.rs index 8298048b9d9..f338c45b69f 100644 --- a/vortex-cuda/src/kernel/encodings/onpair.rs +++ b/vortex-cuda/src/kernel/encodings/onpair.rs @@ -68,6 +68,7 @@ use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::error::vortex_bail; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex_array::ArrayView; use vortex_onpair::DictionaryView; @@ -149,9 +150,10 @@ async fn decode_onpair( total, } = i32_offsets_from_lengths(lengths, ctx).await?; let row_total = u64::try_from(total)?; - vortex_ensure!( - row_total == total_size as u64, - "OnPair codes decode to {total_size} bytes but uncompressed_lengths records {row_total}" + vortex_ensure_eq!( + row_total, + total_size as u64, + "OnPair uncompressed_lengths total does not match the decoded codes size" ); let row_offsets_view = row_offsets.cuda_view::()?; let bytes_view = bytes.cuda_view::()?; @@ -180,9 +182,10 @@ async fn decode_onpair( .await? .into_primitive(); let row_total = sum_lengths(&lengths)?; - vortex_ensure!( - row_total == total_size as u64, - "OnPair codes decode to {total_size} bytes but uncompressed_lengths records {row_total}" + vortex_ensure_eq!( + row_total, + total_size as u64, + "OnPair uncompressed_lengths total does not match the decoded codes size" ); let host_bytes = bytes.try_to_host()?.await?; @@ -232,9 +235,10 @@ pub(crate) async fn decode_onpair_varbin( total, } = i32_offsets_from_lengths(lengths, ctx).await?; let row_total = u64::try_from(total)?; - vortex_ensure!( - row_total == total_size as u64, - "OnPair codes decode to {total_size} bytes but uncompressed_lengths records {row_total}" + vortex_ensure_eq!( + row_total, + total_size as u64, + "OnPair uncompressed_lengths total does not match the decoded codes size" ); Ok(DecodedVarBin { @@ -634,10 +638,7 @@ async fn ensure_zero_lengths(lengths: PrimitiveArray) -> VortexResult<()> { .await? .into_primitive(); let total = sum_lengths(&lengths)?; - vortex_ensure!( - total == 0, - "OnPair records {total} decoded bytes but has no codes" - ); + vortex_ensure_eq!(total, 0, "OnPair records decoded bytes but has no codes"); Ok(()) } diff --git a/vortex-cuda/src/kernel/encodings/zigzag.rs b/vortex-cuda/src/kernel/encodings/zigzag.rs index 212e958ef9f..c87310dce73 100644 --- a/vortex-cuda/src/kernel/encodings/zigzag.rs +++ b/vortex-cuda/src/kernel/encodings/zigzag.rs @@ -21,6 +21,7 @@ use vortex::encodings::zigzag::ZigZagArray; use vortex::encodings::zigzag::ZigZagArraySlotsExt; use vortex::error::VortexResult; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use crate::CudaBufferExt; @@ -54,9 +55,10 @@ impl CudaExecute for ZigZagExecutor { // The encoded array is unsigned, we decode to signed of the same width. let encoded_ptype = array.encoded().dtype().as_ptype(); let output_ptype = PType::try_from(array.dtype())?; - vortex_ensure!( - output_ptype == encoded_ptype.to_signed(), - "ZigZag output type {output_ptype} must be the signed equivalent of {encoded_ptype}" + vortex_ensure_eq!( + output_ptype, + encoded_ptype.to_signed(), + "ZigZag output type must be the signed equivalent of the encoded type" ); match_each_unsigned_integer_ptype!(encoded_ptype, |U| { diff --git a/vortex-cuda/src/kernel/patches/mod.rs b/vortex-cuda/src/kernel/patches/mod.rs index 7c651b7e507..a813555278e 100644 --- a/vortex-cuda/src/kernel/patches/mod.rs +++ b/vortex-cuda/src/kernel/patches/mod.rs @@ -21,6 +21,7 @@ use vortex::dtype::PType; use vortex::error::VortexResult; use vortex::error::vortex_bail; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use crate::CudaBufferExt; @@ -126,18 +127,16 @@ pub(crate) async fn execute_patches< "Applying patches with null values not currently supported on the GPU" ); - vortex_ensure!( - indices.ptype() == IndicesT::PTYPE, - "expected PType {} for patch indices, was {}", + vortex_ensure_eq!( + indices.ptype(), IndicesT::PTYPE, - indices.ptype() + "unexpected PType for patch indices" ); - vortex_ensure!( - values.ptype() == ValuesT::PTYPE, - "expected PType {} for patch values, was {}", + vortex_ensure_eq!( + values.ptype(), ValuesT::PTYPE, - values.ptype() + "unexpected PType for patch values" ); let patches_len = indices.len(); diff --git a/vortex-cuda/src/pinned.rs b/vortex-cuda/src/pinned.rs index 3230ebe50e0..f1ff6701ac8 100644 --- a/vortex-cuda/src/pinned.rs +++ b/vortex-cuda/src/pinned.rs @@ -18,6 +18,7 @@ use parking_lot::Mutex; use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::utils::aliases::hash_map::HashMap; @@ -357,11 +358,10 @@ impl PooledPinnedBuffer { range, pinned.logical_len ); - vortex_ensure!( - range.len() == destination.len(), - "pinned host buffer range length {} does not match destination length {}", + vortex_ensure_eq!( range.len(), - destination.len() + destination.len(), + "pinned host buffer range length does not match destination length" ); let source = PinnedByteBufferView { diff --git a/vortex-cuda/src/pooled_read_at.rs b/vortex-cuda/src/pooled_read_at.rs index f5352a7c06a..ecaa8a332e2 100644 --- a/vortex-cuda/src/pooled_read_at.rs +++ b/vortex-cuda/src/pooled_read_at.rs @@ -19,6 +19,7 @@ use vortex::buffer::ByteBuffer; use vortex::error::VortexError; use vortex::error::VortexResult; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::io::CoalesceConfig; use vortex::io::VortexReadAt; @@ -177,11 +178,10 @@ impl VortexReadAt for PooledObjectStoreReadAt { filled = end; } - vortex_ensure!( - filled == length, - "Object store stream returned {} bytes but expected {} bytes (range: {:?})", + vortex_ensure_eq!( filled, length, + "Object store stream returned too few bytes (range: {:?})", range ); } diff --git a/vortex-duckdb/src/convert/expr.rs b/vortex-duckdb/src/convert/expr.rs index 51aeebebb6d..149d0b1c750 100644 --- a/vortex-duckdb/src/convert/expr.rs +++ b/vortex-duckdb/src/convert/expr.rs @@ -26,7 +26,7 @@ use vortex::error::VortexError; use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::error::vortex_bail; -use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::expr::Expression; use vortex::expr::and_collect; @@ -252,7 +252,7 @@ fn try_from_bound_function( let expr = match func.scalar_function.name() { "strlen" => { let children: Vec<_> = func.children().collect(); - vortex_ensure!(children.len() == 1); + vortex_ensure_eq!(children.len(), 1); let Some(col) = try_from_expression_inner(children[0], ctx)? else { return Ok(None); }; @@ -265,7 +265,7 @@ fn try_from_bound_function( } "struct_extract" => { let children: Vec<_> = func.children().collect(); - vortex_ensure!(children.len() == 2); + vortex_ensure_eq!(children.len(), 2); let Some(child) = try_from_expression_inner(children[0], ctx)? else { return Ok(None); }; @@ -274,7 +274,7 @@ fn try_from_bound_function( } like @ ("~~" | "!~~") => { let children: Vec<_> = func.children().collect(); - vortex_ensure!(children.len() == 2); + vortex_ensure_eq!(children.len(), 2); let Some(string) = try_from_expression_inner(children[0], ctx)? else { return Ok(None); }; @@ -289,7 +289,7 @@ fn try_from_bound_function( } matchers @ ("contains" | "prefix" | "suffix") => { let children: Vec<_> = func.children().collect(); - vortex_ensure!(children.len() == 2); + vortex_ensure_eq!(children.len(), 2); let Some(value) = try_from_expression_inner(children[0], ctx)? else { return Ok(None); }; @@ -318,7 +318,7 @@ fn try_from_bound_function( // len/length semantics depend on the return type of underlying expr. "len" | "length" => { let children: Vec<_> = func.children().collect(); - vortex_ensure!(children.len() == 1); + vortex_ensure_eq!(children.len(), 1); let child = children[0]; if returns_a_list(child) { @@ -649,7 +649,7 @@ fn try_from_expression_inner( | DUCKDB_VX_EXPR_TYPE::DUCKDB_VX_EXPR_TYPE_OPERATOR_IS_NULL | DUCKDB_VX_EXPR_TYPE::DUCKDB_VX_EXPR_TYPE_OPERATOR_IS_NOT_NULL => { let children: Vec<_> = operator.children().collect(); - vortex_ensure!(children.len() == 1); + vortex_ensure_eq!(children.len(), 1); let Some(child) = try_from_expression_inner(children[0], ctx)? else { return Ok(None); }; diff --git a/vortex-duckdb/src/convert/scalar.rs b/vortex-duckdb/src/convert/scalar.rs index 12c39a99175..687821a8a9d 100644 --- a/vortex-duckdb/src/convert/scalar.rs +++ b/vortex-duckdb/src/convert/scalar.rs @@ -32,7 +32,7 @@ use vortex::encodings::uuid::Uuid; use vortex::error::VortexError; use vortex::error::VortexResult; use vortex::error::vortex_bail; -use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::extension::datetime::AnyTemporal; use vortex::extension::datetime::Date; @@ -307,7 +307,7 @@ impl<'a> TryFrom<&'a ValueRef> for Scalar { Scalar::binary(b, Nullable), )), DType::Extension(ext) if ext.is::() => { - vortex_ensure!(b.len() == 16, "UUID blob must be 16 bytes, got {}", b.len()); + vortex_ensure_eq!(b.len(), 16, "UUID blob must be 16 bytes"); let children = b .iter() .map(|&byte| Scalar::primitive(byte, NonNullable)) diff --git a/vortex-duckdb/src/exporter/uuid.rs b/vortex-duckdb/src/exporter/uuid.rs index e5032980f3f..87f7d13ecd8 100644 --- a/vortex-duckdb/src/exporter/uuid.rs +++ b/vortex-duckdb/src/exporter/uuid.rs @@ -7,7 +7,7 @@ use vortex::array::arrays::ExtensionArray; use vortex::array::arrays::extension::ExtensionArrayExt; use vortex::buffer::Buffer; use vortex::error::VortexResult; -use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::mask::Mask; use crate::duckdb::VectorRef; @@ -44,11 +44,10 @@ pub(crate) fn new_exporter( .execute::(ctx)? .into_primitive() .to_buffer::(); - vortex_ensure!( - bytes.len() == len * UUID_BYTE_LEN, - "UUID storage has {} bytes, expected {}", + vortex_ensure_eq!( bytes.len(), - len * UUID_BYTE_LEN + len * UUID_BYTE_LEN, + "UUID storage byte length mismatch" ); Ok(validity::new_exporter( diff --git a/vortex-ffi/src/array.rs b/vortex-ffi/src/array.rs index e708795b927..df938879ba1 100644 --- a/vortex-ffi/src/array.rs +++ b/vortex-ffi/src/array.rs @@ -34,6 +34,7 @@ use vortex::error::VortexExpect; use vortex::error::VortexResult; use vortex::error::vortex_bail; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::error::vortex_panic; use vortex_arrow::ArrowSessionExt; @@ -455,7 +456,7 @@ pub extern "C-unwind" fn vx_array_new_bool( let byte_len = bits.len(); let slice = if bits.ptr.is_null() { - vortex_ensure!(byte_len == 0, "nonzero length but null pointer for view"); + vortex_ensure_eq!(byte_len, 0, "nonzero length but null pointer for view"); &[] } else { unsafe { std::slice::from_raw_parts(bits.ptr, byte_len) } diff --git a/vortex-ffi/src/sink.rs b/vortex-ffi/src/sink.rs index 2ac790bed85..a1be65da1a7 100644 --- a/vortex-ffi/src/sink.rs +++ b/vortex-ffi/src/sink.rs @@ -13,6 +13,7 @@ use vortex::dtype::DType; use vortex::error::VortexResult; use vortex::error::vortex_bail; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::file::WriteOptionsSessionExt; use vortex::file::WriteStrategyBuilder; @@ -128,12 +129,7 @@ pub unsafe extern "C-unwind" fn vx_array_sink_push( let array = vx_array::as_ref(array); let sink = unsafe { &mut *sink }; - vortex_ensure!( - *array.dtype() == sink.dtype, - "array dtype {} does not match sink dtype {}", - array.dtype(), - sink.dtype - ); + vortex_ensure_eq!(*array.dtype(), sink.dtype); RUNTIME .block_on(sink.sink.send(Ok(array.clone()))) .map_err(|e| vortex_err!("Send error: {e}")) diff --git a/vortex-ffi/src/string.rs b/vortex-ffi/src/string.rs index 8e0dfd71900..5585e7f0a5c 100644 --- a/vortex-ffi/src/string.rs +++ b/vortex-ffi/src/string.rs @@ -6,7 +6,7 @@ use std::ptr; use std::slice; use vortex::error::VortexResult; -use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; /// A non owning view over a byte range. @@ -51,7 +51,7 @@ impl vx_view { /// "ptr" must be valid for "len" reads or NULL with "len == 0". pub(crate) unsafe fn as_bytes<'a>(&self) -> VortexResult<&'a [u8]> { if self.ptr.is_null() { - vortex_ensure!(self.len == 0, "null vx_view pointer with non-zero length"); + vortex_ensure_eq!(self.len, 0, "null vx_view pointer with non-zero length"); return Ok(&[]); } Ok(unsafe { slice::from_raw_parts(self.ptr.cast(), self.len) }) diff --git a/vortex-io/src/object_store/read_at.rs b/vortex-io/src/object_store/read_at.rs index ed36c2a02a1..a36c4517817 100644 --- a/vortex-io/src/object_store/read_at.rs +++ b/vortex-io/src/object_store/read_at.rs @@ -22,6 +22,7 @@ use vortex_buffer::Alignment; use vortex_error::VortexError; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::CoalesceConfig; use crate::ReadAtRequest; @@ -144,11 +145,10 @@ async fn read_object_store_range( written = end; } - vortex_ensure!( - written == length, - "Object store stream returned {} bytes but expected {} bytes (range: {:?})", + vortex_ensure_eq!( written, length, + "Object store stream returned too few bytes (range: {:?})", range ); diff --git a/vortex-layout/src/layouts/dict/mod.rs b/vortex-layout/src/layouts/dict/mod.rs index 84771304690..eee88f916d3 100644 --- a/vortex-layout/src/layouts/dict/mod.rs +++ b/vortex-layout/src/layouts/dict/mod.rs @@ -14,7 +14,7 @@ use vortex_array::dtype::PType; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_panic; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -71,8 +71,9 @@ impl VTable for Dict { args: &LayoutDeserializeArgs<'_>, metadata: &DictLayoutMetadata, ) -> VortexResult { - vortex_ensure!( - args.children.nchildren() == 2, + vortex_ensure_eq!( + args.children.nchildren(), + 2, "DictLayout expects exactly 2 children" ); let codes_nullable = metadata @@ -82,8 +83,9 @@ impl VTable for Dict { let codes_dtype = DType::Primitive(metadata.codes_ptype(), codes_nullable); args.children.child(0, args.dtype)?; let codes = args.children.child(1, &codes_dtype)?; - vortex_ensure!( - codes.row_count() == args.row_count, + vortex_ensure_eq!( + codes.row_count(), + args.row_count, "Dictionary codes row count does not match parent" ); Ok(DictData { diff --git a/vortex-layout/src/layouts/list/mod.rs b/vortex-layout/src/layouts/list/mod.rs index 0ba5be17dbc..f5c8c618b15 100644 --- a/vortex-layout/src/layouts/list/mod.rs +++ b/vortex-layout/src/layouts/list/mod.rs @@ -86,16 +86,18 @@ impl VTable for List { args.children.child(ELEMENTS_CHILD_INDEX, elements_dtype)?; let offsets_dtype = DType::Primitive(metadata.offsets_ptype(), Nullability::NonNullable); let offsets = args.children.child(OFFSETS_CHILD_INDEX, &offsets_dtype)?; - vortex_error::vortex_ensure!( - offsets.row_count().saturating_sub(1) == args.row_count, + vortex_ensure_eq!( + offsets.row_count().saturating_sub(1), + args.row_count, "List offsets row count does not match parent" ); if args.dtype.is_nullable() { let validity = args .children .child(VALIDITY_CHILD_INDEX, &DType::Bool(Nullability::NonNullable))?; - vortex_error::vortex_ensure!( - validity.row_count() == args.row_count, + vortex_ensure_eq!( + validity.row_count(), + args.row_count, "List validity row count does not match parent" ); } diff --git a/vortex-layout/src/layouts/struct_/mod.rs b/vortex-layout/src/layouts/struct_/mod.rs index 862b789a349..4506a0b6e20 100644 --- a/vortex-layout/src/layouts/struct_/mod.rs +++ b/vortex-layout/src/layouts/struct_/mod.rs @@ -16,7 +16,7 @@ use vortex_array::dtype::StructFields; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::SessionExt; use vortex_session::VortexSession; @@ -67,8 +67,9 @@ impl VTable for Struct { for idx in 0..args.children.nchildren() { let child_row_count = args.children.child_row_count(idx); - vortex_ensure!( - child_row_count == args.row_count, + vortex_ensure_eq!( + child_row_count, + args.row_count, "Struct child {idx} row count does not match parent" ); } @@ -179,10 +180,7 @@ impl Layout { .as_struct_fields_opt() .ok_or_else(|| vortex_err!("Expected struct dtype"))?; let expected = fields.nfields() + usize::from(dtype.is_nullable()); - vortex_ensure!( - nchildren == expected, - "Struct layout has {nchildren} children, expected {expected}" - ); + vortex_ensure_eq!(nchildren, expected); Ok(()) } diff --git a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs index b5bd12ea191..a4b0ebd16b5 100644 --- a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs +++ b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/mod.rs @@ -325,11 +325,7 @@ impl AggregateFnVTable for BloomFilter { // `deserialize` validates the byte length, but it cannot know the options the filter was // built with, so compare the block count here. - vortex_ensure_eq!( - partial.len(), - args.options.blocks_count().get() as usize, - "expected equal blocks count" - ); + vortex_ensure_eq!(partial.len(), args.options.blocks_count().get() as usize); Ok(partial) } diff --git a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs index 76aee6e9633..9e2f8bb5730 100644 --- a/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs +++ b/vortex-layout/src/layouts/zoned/aggregates/bloom_filter/scalar_fn.rs @@ -180,8 +180,7 @@ impl ScalarFnVTable for BloomContains { // Bloom filter length is never larger than a `u32`. This is intentional // and a property of the implementation. u32::try_from(partial.len()).vortex_expect("valid u32 size"), - options.blocks_count().get(), - "expected equal blocks count" + options.blocks_count().get() ); partial.contains_scalar(&needle) }; @@ -447,7 +446,7 @@ mod tests { .execute(&options, &args, &mut ctx) .expect_err("the Bloom filter block count should not match the options"); assert!( - error.to_string().contains("expected equal blocks count"), + error.to_string().contains("options.blocks_count().get()"), "unexpected error: {error}" ); } diff --git a/vortex-layout/src/layouts/zoned/mod.rs b/vortex-layout/src/layouts/zoned/mod.rs index 611878a8ce6..07b25ddfe34 100644 --- a/vortex-layout/src/layouts/zoned/mod.rs +++ b/vortex-layout/src/layouts/zoned/mod.rs @@ -422,10 +422,10 @@ impl DeserializeMetadata for ZonedMetadata { vortex_bail!("Zoned metadata missing protobuf version"); }; - vortex_ensure!( - version == ZONED_METADATA_PROTO_VERSION, - "Unsupported zoned metadata version: {}", - version + vortex_ensure_eq!( + version, + ZONED_METADATA_PROTO_VERSION, + "Unsupported zoned metadata version" ); vortex_ensure!(!proto_bytes.is_empty(), "Zoned metadata missing protobuf"); diff --git a/vortex-layout/src/layouts/zoned/reader.rs b/vortex-layout/src/layouts/zoned/reader.rs index 1da056df617..f5f909af9a4 100644 --- a/vortex-layout/src/layouts/zoned/reader.rs +++ b/vortex-layout/src/layouts/zoned/reader.rs @@ -17,6 +17,7 @@ use vortex_buffer::BitBufferMut; use vortex_error::VortexError; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -73,10 +74,10 @@ impl ZonedReader { "zoned layout reader requires a non-zero zone length" ); let expected_zones = row_count.div_ceil(zone_len as u64); - vortex_ensure!( - zone_count as u64 == expected_zones, - "zoned layout declares {zone_count} zones, but {row_count} rows of {zone_len}-row \ - zones require {expected_zones}" + vortex_ensure_eq!( + zone_count as u64, + expected_zones, + "zoned layout zone count must cover {row_count} rows of {zone_len}-row zones" ); Ok(Self { diff --git a/vortex-layout/src/layouts/zoned/zone_map.rs b/vortex-layout/src/layouts/zoned/zone_map.rs index 5456aec0e5d..076131d6246 100644 --- a/vortex-layout/src/layouts/zoned/zone_map.rs +++ b/vortex-layout/src/layouts/zoned/zone_map.rs @@ -39,7 +39,7 @@ use vortex_array::validity::Validity; use vortex_buffer::buffer; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_mask::Mask; use vortex_runend::RunEnd; use vortex_session::VortexSession; @@ -179,11 +179,10 @@ impl StatBinder for ZoneMapStatsBinder<'_> { if !input.is_root() { return Ok(None); } - vortex_ensure!( - input.dtype() == &self.zone_map.column_dtype, - "Stats predicate root dtype {} does not match zone-map column dtype {}", + vortex_ensure_eq!( input.dtype(), - self.zone_map.column_dtype + &self.zone_map.column_dtype, + "Stats predicate root dtype does not match zone-map column dtype" ); if let Some(stat_expr) = self.zone_map.aggregate_field_expr(aggregate_fn) { diff --git a/vortex-layout/src/plan/optimizer/rules.rs b/vortex-layout/src/plan/optimizer/rules.rs index 3276aab22f6..1f09b68e713 100644 --- a/vortex-layout/src/plan/optimizer/rules.rs +++ b/vortex-layout/src/plan/optimizer/rules.rs @@ -8,6 +8,7 @@ use std::fmt::Debug; use std::marker::PhantomData; use vortex_error::VortexResult; +use vortex_error::vortex_ensure_eq; use crate::plan::Plan; use crate::plan::PlanRef; @@ -101,17 +102,15 @@ impl PlanRuleSet { #[cfg(debug_assertions)] { - vortex_error::vortex_ensure!( - reduced.row_count() == plan.row_count(), - "Plan rewrite from {rule:?} changed row count from {} to {}", + vortex_ensure_eq!( + reduced.row_count(), plan.row_count(), - reduced.row_count() + "Plan rewrite from {rule:?} changed row count" ); - vortex_error::vortex_ensure!( - reduced.dtype() == plan.dtype(), - "Plan rewrite from {rule:?} changed dtype from {} to {}", + vortex_ensure_eq!( + reduced.dtype(), plan.dtype(), - reduced.dtype() + "Plan rewrite from {rule:?} changed dtype" ); } @@ -236,17 +235,15 @@ impl PlanParentRuleSet { #[cfg(debug_assertions)] { - vortex_error::vortex_ensure!( - reduced.row_count() == parent.row_count(), - "Plan rewrite from {rule:?} changed row count from {} to {}", + vortex_ensure_eq!( + reduced.row_count(), parent.row_count(), - reduced.row_count() + "Plan rewrite from {rule:?} changed row count" ); - vortex_error::vortex_ensure!( - reduced.dtype() == parent.dtype(), - "Plan rewrite from {rule:?} changed dtype from {} to {}", + vortex_ensure_eq!( + reduced.dtype(), parent.dtype(), - reduced.dtype() + "Plan rewrite from {rule:?} changed dtype" ); } diff --git a/vortex-layout/src/plan/plans/row_idx.rs b/vortex-layout/src/plan/plans/row_idx.rs index 893980825d3..6b1edbbc433 100644 --- a/vortex-layout/src/plan/plans/row_idx.rs +++ b/vortex-layout/src/plan/plans/row_idx.rs @@ -17,7 +17,7 @@ use vortex_array::expr::traversal::Transformed; use vortex_array::expr::traversal::TraversalOrder; use vortex_array::scalar_fn::fns::pack::Pack as PackFn; use vortex_error::VortexResult; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::registry::CachedId; @@ -135,8 +135,9 @@ pub fn plan_row_idx_expression( }; } - vortex_ensure!( - partitioned.partition_annotations.len() == 2, + vortex_ensure_eq!( + partitioned.partition_annotations.len(), + 2, "Row-index expression produced more than two partitions" ); let row_idx_index = partitioned diff --git a/vortex-python-cuda/src/lib.rs b/vortex-python-cuda/src/lib.rs index 68f836be4e4..ce3cb45a517 100644 --- a/vortex-python-cuda/src/lib.rs +++ b/vortex-python-cuda/src/lib.rs @@ -37,6 +37,7 @@ use vortex::dtype::DType; use vortex::error::VortexError; use vortex::error::VortexResult; use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_err; use vortex::flatbuffers::FlatBuffer; use vortex::io::runtime::BlockingRuntime; @@ -218,15 +219,15 @@ impl ArrayChildren for MetadataChildren { .get(index) .ok_or_else(|| vortex_err!("array metadata child index {index} out of bounds"))? .clone(); - vortex_ensure!( - child.dtype() == dtype, - "array metadata child {index} has dtype {}, expected {dtype}", - child.dtype() + vortex_ensure_eq!( + child.dtype(), + dtype, + "array metadata child {index} dtype mismatch" ); - vortex_ensure!( - child.len() == len, - "array metadata child {index} has length {}, expected {len}", - child.len() + vortex_ensure_eq!( + child.len(), + len, + "array metadata child {index} length mismatch" ); Ok(child) } @@ -311,19 +312,17 @@ fn deserialize_metadata_tree( ), session, )?; - vortex_ensure!( - decoded.len() == metadata.len, - "Array decoded from {} has incorrect length {}, expected {}", - metadata.encoding_id, + vortex_ensure_eq!( decoded.len(), - metadata.len + metadata.len, + "Array decoded from {} has incorrect length", + metadata.encoding_id ); - vortex_ensure!( - decoded.dtype() == &dtype, - "Array decoded from {} has incorrect dtype {}, expected {}", - metadata.encoding_id, + vortex_ensure_eq!( decoded.dtype(), - dtype + &dtype, + "Array decoded from {} has incorrect dtype", + metadata.encoding_id ); vortex_ensure!( plugin.is_supported_encoding(&decoded.encoding_id()), diff --git a/vortex-python/src/arrays/py/vtable.rs b/vortex-python/src/arrays/py/vtable.rs index ad007e64b4e..686390fdddf 100644 --- a/vortex-python/src/arrays/py/vtable.rs +++ b/vortex-python/src/arrays/py/vtable.rs @@ -24,7 +24,7 @@ use vortex::array::with_empty_buffers; use vortex::dtype::DType; use vortex::error::VortexResult; use vortex::error::vortex_bail; -use vortex::error::vortex_ensure; +use vortex::error::vortex_ensure_eq; use vortex::error::vortex_panic; use vortex::scalar::Scalar; use vortex::session::VortexSession; @@ -66,9 +66,9 @@ impl VTable for PythonVTable { len: usize, _slots: &[Option], ) -> VortexResult<()> { - vortex_ensure!(data.vtable.id == self.id, "PythonArray vtable id mismatch"); - vortex_ensure!(&data.dtype == dtype, "PythonArray dtype mismatch"); - vortex_ensure!(data.len == len, "PythonArray len mismatch"); + vortex_ensure_eq!(data.vtable.id, self.id, "PythonArray vtable id mismatch"); + vortex_ensure_eq!(&data.dtype, dtype, "PythonArray dtype mismatch"); + vortex_ensure_eq!(data.len, len, "PythonArray len mismatch"); Ok(()) } diff --git a/vortex-spatial/src/scalar_fn/collect.rs b/vortex-spatial/src/scalar_fn/collect.rs index 5d133ef1f94..d41bd6c489c 100644 --- a/vortex-spatial/src/scalar_fn/collect.rs +++ b/vortex-spatial/src/scalar_fn/collect.rs @@ -39,7 +39,7 @@ use vortex_buffer::BufferMut; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_bail; -use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::AllOr; use vortex_mask::Mask; @@ -58,10 +58,10 @@ use crate::scalar_fn::execute::dispatch_unary; /// Resolve the strict homogeneous `ST_Collect` overload for one list operand. fn collect_dtype(dtypes: &[DType]) -> VortexResult { - vortex_ensure!( - dtypes.len() == 1, - "spatial: collect requires exactly one list operand, got {}", - dtypes.len() + vortex_ensure_eq!( + dtypes.len(), + 1, + "spatial: collect requires exactly one list operand" ); let DType::List(element_dtype, nullability) = &dtypes[0] else { vortex_bail!("spatial: collect operand {} is not a list", dtypes[0]); diff --git a/vortex-spatial/src/scalar_fn/convex_hull.rs b/vortex-spatial/src/scalar_fn/convex_hull.rs index f7bc47f891c..840a606e878 100644 --- a/vortex-spatial/src/scalar_fn/convex_hull.rs +++ b/vortex-spatial/src/scalar_fn/convex_hull.rs @@ -18,6 +18,7 @@ use vortex_array::scalar_fn::unstable::row::RowVisitor; use vortex_error::VortexResult; use vortex_error::vortex_bail; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -30,10 +31,10 @@ use crate::scalar_fn::row::PolygonSink; /// Resolve the strict native `MultiPoint -> Polygon` overload. fn convex_hull_dtype(dtypes: &[DType]) -> VortexResult { - vortex_ensure!( - dtypes.len() == 1, - "spatial: convex_hull requires exactly one MultiPoint operand, got {}", - dtypes.len() + vortex_ensure_eq!( + dtypes.len(), + 1, + "spatial: convex_hull requires exactly one MultiPoint operand" ); let Some(input) = dtypes[0].as_extension_opt() else { vortex_bail!( diff --git a/vortex-spatial/src/scalar_fn/envelope.rs b/vortex-spatial/src/scalar_fn/envelope.rs index 1056af8a337..37c99f4b1b9 100644 --- a/vortex-spatial/src/scalar_fn/envelope.rs +++ b/vortex-spatial/src/scalar_fn/envelope.rs @@ -33,6 +33,7 @@ use vortex_buffer::BitBuffer; use vortex_buffer::BufferMut; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -54,10 +55,10 @@ use crate::scalar_fn::execute::dispatch_unary; /// Validate the native geometry operand accepted by `envelope`. fn validate_envelope_operands(dtypes: &[DType]) -> VortexResult<()> { - vortex_ensure!( - dtypes.len() == 1, - "spatial: envelope requires exactly one geometry operand, got {}", - dtypes.len() + vortex_ensure_eq!( + dtypes.len(), + 1, + "spatial: envelope requires exactly one geometry operand" ); vortex_ensure!( is_native_geometry(&dtypes[0]), diff --git a/vortex-spatial/src/scalar_fn/length.rs b/vortex-spatial/src/scalar_fn/length.rs index 3e9938c02af..09b5a1bd274 100644 --- a/vortex-spatial/src/scalar_fn/length.rs +++ b/vortex-spatial/src/scalar_fn/length.rs @@ -31,6 +31,7 @@ use vortex_array::validity::Validity; use vortex_buffer::Buffer; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_session::VortexSession; use vortex_session::registry::CachedId; @@ -45,10 +46,10 @@ use crate::scalar_fn::execute::dispatch_unary; /// Validate the native lineal operand accepted by `ST_Length`. fn validate_length_operands(dtypes: &[DType]) -> VortexResult<()> { - vortex_ensure!( - dtypes.len() == 1, - "spatial: length requires exactly one lineal operand, got {}", - dtypes.len() + vortex_ensure_eq!( + dtypes.len(), + 1, + "spatial: length requires exactly one lineal operand" ); vortex_ensure!( dtypes[0].as_extension_opt().is_some_and(|extension| { diff --git a/vortex-spatial/src/scalar_fn/make_line.rs b/vortex-spatial/src/scalar_fn/make_line.rs index f860a4e5367..22b0bdf5947 100644 --- a/vortex-spatial/src/scalar_fn/make_line.rs +++ b/vortex-spatial/src/scalar_fn/make_line.rs @@ -22,6 +22,7 @@ use vortex_array::scalar_fn::TypedScalarFnInstance; use vortex_array::validity::Validity; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use vortex_error::vortex_err; use vortex_mask::Mask; use vortex_session::VortexSession; @@ -40,10 +41,10 @@ use crate::scalar_fn::execute::dispatch_binary; /// Validate the two point operands accepted by `ST_MakeLine`. fn validate_make_line_operands(dtypes: &[DType]) -> VortexResult<()> { - vortex_ensure!( - dtypes.len() == 2, - "spatial: make_line requires exactly two point operands, got {}", - dtypes.len() + vortex_ensure_eq!( + dtypes.len(), + 2, + "spatial: make_line requires exactly two point operands" ); for dtype in dtypes { vortex_ensure!( @@ -63,10 +64,10 @@ fn make_line_metadata( ) -> VortexResult { match (&left.crs, &right.crs) { (Some(left_crs), Some(right_crs)) => { - vortex_ensure!( - left_crs == right_crs, - "spatial: make_line operands have different coordinate reference systems: \ - {left_crs} and {right_crs}" + vortex_ensure_eq!( + left_crs, + right_crs, + "spatial: make_line operands have different coordinate reference systems" ); Ok(left.clone()) } diff --git a/vortex-spatial/src/scalar_fn/row.rs b/vortex-spatial/src/scalar_fn/row.rs index b3f1cf8d80b..4d3c1fe5977 100644 --- a/vortex-spatial/src/scalar_fn/row.rs +++ b/vortex-spatial/src/scalar_fn/row.rs @@ -19,6 +19,7 @@ use vortex_array::scalar_fn::unstable::row::RowVisitor; use vortex_error::VortexExpect; use vortex_error::VortexResult; use vortex_error::vortex_ensure; +use vortex_error::vortex_ensure_eq; use crate::extension::build_polygon_storage; use crate::extension::coordinate::Dimension; @@ -94,10 +95,10 @@ unsafe impl InputElement for GeometryRow { fn decode_constant(array: ArrayRef, ctx: &mut ExecutionCtx) -> VortexResult { let mut geometries = Self::decode(array.slice(0..1)?, ctx)?; - vortex_ensure!( - geometries.len() == 1, - "a geometry batch constant must decode to one value, got {}", + vortex_ensure_eq!( geometries.len(), + 1, + "a geometry batch constant must decode to one value", ); Ok(geometries diff --git a/vortex-tensor/src/scalar_fns/row.rs b/vortex-tensor/src/scalar_fns/row.rs index 00c7eee6089..cc079c21445 100644 --- a/vortex-tensor/src/scalar_fns/row.rs +++ b/vortex-tensor/src/scalar_fns/row.rs @@ -85,7 +85,7 @@ fn decode_tensor_storage( vortex_ensure_eq!( stride, row_width, - "per-row tensor stride must equal its width, got {stride}", + "per-row tensor stride must equal its width", ); let Some(expected_elements) = row_count.checked_mul(stride) else { vortex_bail!( @@ -94,12 +94,7 @@ fn decode_tensor_storage( }; expected_elements }; - vortex_ensure_eq!( - elements.len(), - expected_elements, - "tensor row storage must contain {expected_elements} elements, got {}", - elements.len(), - ); + vortex_ensure_eq!(elements.len(), expected_elements); Ok(TensorRows { elements, @@ -126,7 +121,7 @@ unsafe impl InputElement for TensorRow { vortex_ensure_eq!( tensor_match.element_ptype(), expected_element_ptype, - "tensor row input must use {expected_element_ptype} elements, got {dtype}", + "tensor row input {dtype} has the wrong element type", ); Ok(()) @@ -161,12 +156,7 @@ unsafe impl InputElement for TensorRow { }; let decoded = decode_tensor_storage::(&storage, 1, row_width, ctx)?; - vortex_ensure_eq!( - decoded.elements.len(), - row_width, - "decoded tensor constant must contain {row_width} elements, got {}", - decoded.elements.len(), - ); + vortex_ensure_eq!(decoded.elements.len(), row_width); Ok(decoded.elements) } diff --git a/vortex-tensor/src/types/fixed_shape_tensor/metadata.rs b/vortex-tensor/src/types/fixed_shape_tensor/metadata.rs index 757138d3e50..b52670b230f 100644 --- a/vortex-tensor/src/types/fixed_shape_tensor/metadata.rs +++ b/vortex-tensor/src/types/fixed_shape_tensor/metadata.rs @@ -54,13 +54,7 @@ impl FixedShapeTensorMetadata { /// The number of names must match the number of logical dimensions. pub fn with_dim_names(mut self, names: Vec) -> VortexResult { if !names.is_empty() { - vortex_ensure_eq!( - names.len(), - self.logical_shape.len(), - "dim_names length ({}) must match logical_shape length ({})", - names.len(), - self.logical_shape.len() - ); + vortex_ensure_eq!(names.len(), self.logical_shape.len()); self.dim_names = Some(names); } @@ -74,13 +68,7 @@ impl FixedShapeTensorMetadata { /// number of logical dimensions. pub fn with_permutation(mut self, permutation: Vec) -> VortexResult { if !permutation.is_empty() { - vortex_ensure_eq!( - permutation.len(), - self.logical_shape.len(), - "permutation length ({}) must match logical_shape length ({})", - permutation.len(), - self.logical_shape.len() - ); + vortex_ensure_eq!(permutation.len(), self.logical_shape.len()); // Verify this is actually a permutation of [0..N). let mut seen = vec![false; permutation.len()]; diff --git a/vortex-tensor/src/types/fixed_shape_tensor/vtable.rs b/vortex-tensor/src/types/fixed_shape_tensor/vtable.rs index c46625806be..b98e3dd0acf 100644 --- a/vortex-tensor/src/types/fixed_shape_tensor/vtable.rs +++ b/vortex-tensor/src/types/fixed_shape_tensor/vtable.rs @@ -58,8 +58,7 @@ impl ExtVTable for FixedShapeTensor { vortex_ensure_eq!( element_count, *list_size as usize, - "FixedShapeTensor logical shape product ({element_count}) does not match \ - FixedSizeList size ({list_size})" + "FixedShapeTensor logical shape product must match FixedSizeList size" ); Ok(()) From 00856e73254628f244f5f020abcd491193d4d3d0 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 19:39:07 +0000 Subject: [PATCH 6/8] Fix tests and keep context for messages they relied on Claude-Session: https://claude.ai/code/session_01YUXDBd65US5mcKTxb2Xcer Signed-off-by: Claude --- .../src/decimal_byte_parts/plugin/tests.rs | 4 ++-- .../src/decimal_byte_parts/plugin/v2.rs | 6 +++++- vortex-array/src/dtype/union.rs | 12 ++++++++++-- .../unstable/row/types/element/primitive.rs | 2 +- vortex-array/src/scalar_fn/unstable/row/vtable.rs | 4 +++- vortex-arrow/src/executor/struct_.rs | 2 +- vortex-layout/src/layouts/zoned/reader.rs | 2 +- 7 files changed, 23 insertions(+), 9 deletions(-) diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs index 92c9d1edbb7..e76476ac39e 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/tests.rs @@ -161,13 +161,13 @@ fn v1_metadata_is_unchanged() -> VortexResult<()> { decimal_byte_parts_v2_id(), v2_metadata(vec![PType::U64 as i32]), vec![msp()], - "expected 2 children, got 1" + "v2 expects the msp child plus one child per lower part" )] #[case::v2_extra_child( decimal_byte_parts_v2_id(), v2_metadata(vec![PType::U64 as i32]), vec![msp(), lower_part(), lower_part()], - "expected 2 children, got 3" + "v2 expects the msp child plus one child per lower part" )] #[case::v2_too_many_lower_parts( decimal_byte_parts_v2_id(), diff --git a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v2.rs b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v2.rs index 7d22b2061cf..a00ecee1a36 100644 --- a/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v2.rs +++ b/encodings/decimal-byte-parts/src/decimal_byte_parts/plugin/v2.rs @@ -74,7 +74,11 @@ pub(super) fn deserialize(parts: ArrayDeserialization<'_>) -> VortexResult VortexResult<()> { - vortex_ensure_eq!(names.len(), n_dtypes); - vortex_ensure_eq!(names.len(), type_ids.len()); + vortex_ensure_eq!( + names.len(), + n_dtypes, + "union names and dtypes length mismatch" + ); + vortex_ensure_eq!( + names.len(), + type_ids.len(), + "union names and type_ids length mismatch" + ); vortex_ensure!( !names.is_empty(), "union must have at least one variant (for now)" diff --git a/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs b/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs index 791397a8863..f20ad1410fa 100644 --- a/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs +++ b/vortex-array/src/scalar_fn/unstable/row/types/element/primitive.rs @@ -40,7 +40,7 @@ unsafe impl InputElement for T { let DType::Primitive(ptype, _) = dtype else { vortex_bail!("expected a {expected} column, got {dtype}"); }; - vortex_ensure_eq!(*ptype, expected); + vortex_ensure_eq!(*ptype, expected, "row input column has the wrong ptype"); Ok(()) } diff --git a/vortex-array/src/scalar_fn/unstable/row/vtable.rs b/vortex-array/src/scalar_fn/unstable/row/vtable.rs index 4726f5bae98..41950737f49 100644 --- a/vortex-array/src/scalar_fn/unstable/row/vtable.rs +++ b/vortex-array/src/scalar_fn/unstable/row/vtable.rs @@ -421,7 +421,9 @@ mod tests { }; assert!( - error.to_string().contains("expected a u64 column"), + error + .to_string() + .contains("row input column has the wrong ptype"), "unexpected error: {error}", ); Ok(()) diff --git a/vortex-arrow/src/executor/struct_.rs b/vortex-arrow/src/executor/struct_.rs index 1173f358b0a..11fcb24e56b 100644 --- a/vortex-arrow/src/executor/struct_.rs +++ b/vortex-arrow/src/executor/struct_.rs @@ -312,7 +312,7 @@ mod tests { .unwrap(); assert!( err.to_string() - .contains("StructArray has 1 fields, but target Arrow type has 2 fields") + .contains("StructArray field count must match the target Arrow type") ); Ok(()) } diff --git a/vortex-layout/src/layouts/zoned/reader.rs b/vortex-layout/src/layouts/zoned/reader.rs index f5f909af9a4..215ba3455ed 100644 --- a/vortex-layout/src/layouts/zoned/reader.rs +++ b/vortex-layout/src/layouts/zoned/reader.rs @@ -536,7 +536,7 @@ mod test { #[rstest] #[case::too_few_zones(2)] #[case::too_many_zones(5)] - #[should_panic(expected = "declares 3 zones")] + #[should_panic(expected = "zone count must cover 9 rows of")] fn new_reader_rejects_mismatched_zone_count( #[from(stats_layout)] (segments, layout): (Arc, LayoutRef), #[case] zone_len: usize, From d552a73341d785134aed1f9dd57a001c963a6477 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 2 Oct 2026 19:39:22 +0000 Subject: [PATCH 7/8] Document vortex_ensure_eq! usage in STYLE.md Claude-Session: https://claude.ai/code/session_01YUXDBd65US5mcKTxb2Xcer Signed-off-by: Claude --- STYLE.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/STYLE.md b/STYLE.md index 486d7288fe8..b75876e0e6e 100644 --- a/STYLE.md +++ b/STYLE.md @@ -52,6 +52,9 @@ - `vortex_err!` for creating errors - `vortex_bail!` for returning errors - `vortex_panic!` for handling invariant violations + - `vortex_ensure!` and `vortex_ensure_eq!` for checking conditions. Prefer + `vortex_ensure_eq!(a, b)` with no message: the error already shows both expressions and values. + Add a message only for context the expressions lack, and never repeat the values in it. - Add context to errors using `.with_context()` - Include backtraces for better debugging - Use `VortexExpect` trait when unwrapping is appropriate with proper error context. From 4681c2dd2a86b18e0d5ed8f86781c37ddbff8008 Mon Sep 17 00:00:00 2001 From: Connor Tsui Date: Mon, 5 Oct 2026 11:46:07 +0100 Subject: [PATCH 8/8] Fix ensure macro CI checks and cover evaluation semantics Signed-off-by: Connor Tsui --- vortex-error/src/lib.rs | 2 +- vortex-error/tests/ensure.rs | 114 ++++++++++++++++++++++ vortex-layout/src/plan/optimizer/rules.rs | 1 + 3 files changed, 116 insertions(+), 1 deletion(-) create mode 100644 vortex-error/tests/ensure.rs diff --git a/vortex-error/src/lib.rs b/vortex-error/src/lib.rs index 3e68c677308..f8ebd0ecec6 100644 --- a/vortex-error/src/lib.rs +++ b/vortex-error/src/lib.rs @@ -430,7 +430,7 @@ macro_rules! vortex_ensure { /// A macro that mirrors `assert_eq!` but instead of panicking when `left != right`, it will /// immediately return an erroneous `VortexResult` to the calling context. /// -/// Both values must implement [`PartialEq`] and [`Display`](std::fmt::Display), and each is +/// Both values must implement [`PartialEq`] and [`Display`], and each is /// evaluated exactly once. Use [`vortex_ensure!`] for values that do not implement `Display`. /// /// By default this returns an [`AssertionFailed`](VortexError::AssertionFailed) error that diff --git a/vortex-error/tests/ensure.rs b/vortex-error/tests/ensure.rs new file mode 100644 index 00000000000..ac13077be49 --- /dev/null +++ b/vortex-error/tests/ensure.rs @@ -0,0 +1,114 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: Copyright the Vortex contributors + +//! Checks error macro behavior from a caller outside the crate. + +#[cfg(test)] +mod tests { + use std::cell::Cell; + + use vortex_error::VortexError; + use vortex_error::VortexResult; + + fn check_default(left: &Cell, right: &Cell) -> VortexResult<()> { + vortex_error::vortex_ensure_eq!( + left.replace(left.get() + 1), + right.replace(right.get() + 1), + ); + Ok(()) + } + + #[test] + fn default_success_evaluates_each_operand_once() -> VortexResult<()> { + let left = Cell::new(1); + let right = Cell::new(1); + + check_default(&left, &right)?; + + assert_eq!(left.get(), 2); + assert_eq!(right.get(), 2); + Ok(()) + } + + #[test] + fn default_failure_reports_the_values_compared() { + let left = Cell::new(1); + let right = Cell::new(2); + + let error = check_default(&left, &right).unwrap_err(); + + assert_eq!(left.get(), 2); + assert_eq!(right.get(), 3); + let VortexError::AssertionFailed(message, _) = error else { + panic!("expected AssertionFailed, got {error}"); + }; + assert_eq!( + message.as_ref(), + "`left.replace(left.get() + 1) == right.replace(right.get() + 1)`\n left: 1\n right: 2" + ); + } + + #[test] + fn custom_message_is_lazy_and_operands_are_borrowed() -> VortexResult<()> { + let left = String::from("left"); + let right = String::from("right"); + let message_calls = Cell::new(0); + let context = "field"; + let check = |right: &String| -> VortexResult<()> { + vortex_error::vortex_ensure_eq!( + &left, + right, + "{context} mismatch {}", + message_calls.replace(message_calls.get() + 1), + ); + Ok(()) + }; + + check(&left)?; + assert_eq!(message_calls.get(), 0); + + let error = check(&right).unwrap_err(); + + assert_eq!(message_calls.get(), 1); + let VortexError::Other(message, _) = error else { + panic!("expected Other, got {error}"); + }; + assert_eq!( + message.as_ref(), + "field mismatch 0\n left: left\n right: right" + ); + assert_eq!(left, "left"); + assert_eq!(right, "right"); + Ok(()) + } + + #[test] + fn explicit_variant_keeps_context_and_values() { + let check = || -> VortexResult<()> { + vortex_error::vortex_ensure_eq!(1, 2, InvalidArgument: "expected {} fields", 2,); + Ok(()) + }; + + let error = check().unwrap_err(); + + let VortexError::InvalidArgument(message, _) = error else { + panic!("expected InvalidArgument, got {error}"); + }; + assert_eq!(message.as_ref(), "expected 2 fields\n left: 1\n right: 2"); + } + + #[test] + fn qualified_ensure_does_not_require_a_macro_import() { + let check = || -> VortexResult<()> { + vortex_error::vortex_ensure!(false); + Ok(()) + }; + + let error = check().unwrap_err(); + + let VortexError::AssertionFailed(message, _) = error else { + panic!("expected AssertionFailed, got {error}"); + }; + assert_eq!(message.as_ref(), "false"); + } +} diff --git a/vortex-layout/src/plan/optimizer/rules.rs b/vortex-layout/src/plan/optimizer/rules.rs index 1f09b68e713..12490201ee5 100644 --- a/vortex-layout/src/plan/optimizer/rules.rs +++ b/vortex-layout/src/plan/optimizer/rules.rs @@ -8,6 +8,7 @@ use std::fmt::Debug; use std::marker::PhantomData; use vortex_error::VortexResult; +#[cfg(debug_assertions)] use vortex_error::vortex_ensure_eq; use crate::plan::Plan;