@@ -45,7 +45,7 @@ impl ArrayPlugin for DecimalPlugin {
     ) -> VortexResult<Option<ArraySerialization>> {
         vortex_ensure!(
             array.is::<Decimal>(),
-            "Decimal plugin cannot serialize {}",
+            "Expected a decimal array, got {}",
             array.encoding_id()
         );
         let mut ctx = session.create_execution_ctx();
 
@@ -68,13 +68,15 @@ impl VTable for WideIntegerEncoding {
     ) -> VortexResult<()> {
         vortex_ensure!(
             matches!(data.values_type, DecimalType::I128 | DecimalType::I256),
-            "Expected wide integer storage"
+            "Expected i128 or i256 storage, got {}",
+            data.values_type
         );
         let alignment =
             match_each_decimal_value_type!(data.values_type, |T| { Alignment::of::<T>() });
         vortex_ensure!(
             data.values.is_aligned_to(alignment),
-            "Integer storage is not aligned to {alignment:?}"
+            "Expected integer storage alignment {alignment:?}, got {:?}",
+            data.values.alignment()
         );
         vortex_ensure_eq!(slots.len(), 1);
         let expected_dtype = integer_dtype(data.values_type, dtype.nullability());
@@ -83,7 +85,9 @@ impl VTable for WideIntegerEncoding {
             data.values
                 .len()
                 .is_multiple_of(data.values_type.byte_width()),
-            "Integer buffer must contain whole values"
+            "Expected whole {} values, got {} bytes",
+            data.values_type,
+            data.values.len()
         );
         vortex_ensure_eq!(data.values.len() / data.values_type.byte_width(), len);
         if let Some(validity) = &slots[0] {
 
@@ -179,7 +179,10 @@ pub(crate) fn from_buffer(buffer: IntegerBuffer) -> VortexResult<ArrayRef> {
 
 /// Reads a non-null signed integer scalar without applying a decimal scale.
 pub(crate) fn scalar_value(scalar: &Scalar) -> VortexResult<DecimalValue> {
-    vortex_ensure!(!scalar.is_null(), "Expected a non-null integer scalar");
+    vortex_ensure!(
+        !scalar.is_null(),
+        "Expected a non-null integer scalar, got {scalar}"
+    );
     if let Some(width) = WideInteger::width(scalar.dtype()) {
         return Ok(DecimalValue::I256(WideInteger::unpack_value(
             width,
@@ -262,7 +265,10 @@ pub(crate) fn scalar_from_integer(value: DecimalValue, dtype: &DType) -> VortexR
 /// Casts a signed integer scalar with checked width and nullability.
 pub(crate) fn cast_scalar(scalar: &Scalar, dtype: &DType) -> VortexResult<Scalar> {
     if scalar.is_null() {
-        vortex_ensure!(dtype.is_nullable(), "Cannot cast null to {dtype}");
+        vortex_ensure!(
+            dtype.is_nullable(),
+            "Expected a nullable integer dtype for a null scalar, got {dtype}"
+        );
         return Ok(Scalar::null(dtype.clone()));
     }
 
 
@@ -58,7 +58,7 @@ pub(super) fn compare_integer(
 ) -> VortexResult<ArrayRef> {
     vortex_ensure!(
         lhs.dtype().eq_ignore_nullability(rhs.dtype()),
-        "Cannot compare integer dtypes {} and {}",
+        "Expected integer dtypes matching apart from nullability, got {} and {}",
         lhs.dtype(),
         rhs.dtype()
     );