refactor(array): deprecate the one-off scalar and validity accessors

encodings/alp/src/alp/array.rs

@@ -481,6 +481,7 @@ impl ValidityChild<ALP> for ALP {
 
 #[cfg(test)]
 mod tests {
+    #![expect(deprecated)]
     use std::f64::consts::PI;
     use std::sync::LazyLock;
 

encodings/alp/src/alp/ops.rs

@@ -15,6 +15,9 @@ use crate::ALPFloat;
 use crate::match_each_alp_float_ptype;
 
 impl OperationsVTable<ALP> for ALP {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, ALP>,
         index: usize,

encodings/alp/src/alp_rd/ops.rs

@@ -14,6 +14,9 @@ use crate::ALPRDArrayExt;
 use crate::ALPRDArraySlotsExt;
 
 impl OperationsVTable<ALPRD> for ALPRD {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, ALPRD>,
         index: usize,

encodings/bytebool/src/array.rs

@@ -312,6 +312,8 @@ impl ValidityVTable<ByteBool> for ByteBool {
 }
 
 impl OperationsVTable<ByteBool> for ByteBool {
+    type ProbeState = ();
+
     fn scalar_at(
         array: ArrayView<'_, ByteBool>,
         index: usize,
@@ -347,6 +349,7 @@ mod tests {
     });
 
     #[test]
+    #[expect(deprecated)]
     fn test_validity_construction() {
         let v = vec![true, false];
         let v_len = v.len();

encodings/datetime-parts/src/ops.rs

@@ -17,6 +17,9 @@ use crate::timestamp;
 use crate::timestamp::TimestampParts;
 
 impl OperationsVTable<DateTimeParts> for DateTimeParts {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, DateTimeParts>,
         index: usize,

encodings/decimal-byte-parts/src/decimal_byte_parts/mod.rs

@@ -289,6 +289,9 @@ fn to_canonical_decimal(
 }
 
 impl OperationsVTable<DecimalByteParts> for DecimalByteParts {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, DecimalByteParts>,
         index: usize,
@@ -334,6 +337,7 @@ mod tests {
     use crate::DecimalByteParts;
 
     #[test]
+    #[expect(deprecated)]
     fn test_scalar_at_decimal_parts() {
         let decimal_dtype = DecimalDType::new(8, 2);
         let dtype = DType::Decimal(decimal_dtype, Nullability::Nullable);

encodings/fastlanes/src/bitpacking/array/bitpack_decompress.rs

@@ -485,6 +485,7 @@ mod tests {
 
     /// This test ensures that the mask is properly appended to the range, not the builder.
     #[test]
+    #[expect(deprecated)]
     fn test_unpack_into_with_validity_mask() -> VortexResult<()> {
         // Create an array with some null values.
         let values = Buffer::from_iter([1u32, 0, 3, 4, 0]);
@@ -596,6 +597,7 @@ mod tests {
 
     /// Test unpacking with nullability and validity masks.
     #[test]
+    #[expect(deprecated)]
     fn test_unpack_to_primitive_nullability() {
         // Test with null values at various positions.
         let values = Buffer::from_iter([100u32, 0, 200, 0, 300, 0, 400]);

encodings/fastlanes/src/bitpacking/compute/take.rs

@@ -238,6 +238,7 @@ mod test {
 
     #[test]
     #[cfg_attr(miri, ignore)] // This test is too slow on miri
+    #[expect(deprecated)]
     fn take_random_indices() {
         let mut ctx = SESSION.create_execution_ctx();
         let num_patches: usize = 128;

encodings/fastlanes/src/bitpacking/vtable/operations.rs

@@ -11,6 +11,8 @@ use crate::BitPacked;
 use crate::bitpack_decompress;
 use crate::bitpacking::array::BitPackedArrayExt;
 impl OperationsVTable<BitPacked> for BitPacked {
+    type ProbeState = ();
+
     fn scalar_at(
         array: ArrayView<'_, BitPacked>,
         index: usize,
@@ -235,6 +237,7 @@ mod test {
     }
 
     #[test]
+    #[expect(deprecated)]
     fn scalar_at_invalid_patches() {
         let packed_array = BitPacked::try_new(
             BufferHandle::new_host(ByteBuffer::copy_from_aligned(
@@ -268,6 +271,7 @@ mod test {
     }
 
     #[test]
+    #[expect(deprecated)]
     fn scalar_at() {
         let mut ctx = SESSION.create_execution_ctx();
         let values = (0u32..257).collect::<Buffer<_>>();

encodings/fastlanes/src/delta/array/delta_compress.rs

@@ -127,6 +127,7 @@ where
 
 #[cfg(test)]
 mod tests {
+    #![expect(deprecated)]
     use std::iter;
     use std::sync::LazyLock;
 

encodings/fastlanes/src/delta/vtable/operations.rs

@@ -11,6 +11,9 @@ use vortex_error::VortexResult;
 
 use super::Delta;
 impl OperationsVTable<Delta> for Delta {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, Delta>,
         index: usize,
@@ -219,6 +222,7 @@ mod tests {
 
     #[test]
     #[should_panic]
+    #[expect(deprecated)]
     fn test_scalar_at_non_jagged_array_oob() {
         let delta = da(&(0u32..2048).collect()).into_array();
         delta
@@ -235,6 +239,7 @@ mod tests {
 
     #[test]
     #[should_panic]
+    #[expect(deprecated)]
     fn test_scalar_at_jagged_array_oob() {
         let delta = da(&(0u32..2000).collect()).into_array();
         delta

encodings/fastlanes/src/for/array/for_compress.rs

@@ -104,6 +104,7 @@ mod test {
     }
 
     #[test]
+    #[expect(deprecated)]
     fn test_zeros() {
         let mut ctx = SESSION.create_execution_ctx();
         let array = PrimitiveArray::new(buffer![0i32; 100], Validity::NonNullable);
@@ -153,6 +154,7 @@ mod test {
     }
 
     #[test]
+    #[expect(deprecated)]
     fn test_overflow() -> VortexResult<()> {
         let mut ctx = SESSION.create_execution_ctx();
         let array = PrimitiveArray::from_iter(i8::MIN..=i8::MAX);

encodings/fastlanes/src/for/vtable/operations.rs

@@ -13,6 +13,9 @@ use super::FoR;
 use crate::r#for::array::FoRArrayExt;
 use crate::r#for::array::FoRArraySlotsExt;
 impl OperationsVTable<FoR> for FoR {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, FoR>,
         index: usize,

encodings/fastlanes/src/rle/array/mod.rs

@@ -93,6 +93,7 @@ pub trait RLEArrayExt: RLEArraySlotsExt {
         clippy::expect_used,
         reason = "expect is safe here as scalar_at returns a valid primitive"
     )]
+    #[expect(deprecated)]
     fn values_idx_offset(&self, chunk_idx: usize, ctx: &mut ExecutionCtx) -> usize {
         self.values_idx_offsets()
             .execute_scalar(chunk_idx, ctx)
@@ -164,6 +165,7 @@ mod tests {
     }
 
     #[test]
+    #[expect(deprecated)]
     fn test_try_new_with_validity() {
         let values = PrimitiveArray::from_iter([10u32, 20]).into_array();
         let values_idx_offsets = PrimitiveArray::from_iter([0u64]).into_array();

encodings/fastlanes/src/rle/array/rle_compress.rs

@@ -442,6 +442,7 @@ mod tests {
     /// This simulates a compressor that doesn't preserve index values at null
     /// positions, which can happen when indices are further compressed and the
     /// compressor clobbers invalid entries with arbitrary data.
+    #[expect(deprecated)]
     fn with_random_invalid_indices(
         rle: &RLEArray,
         ctx: &mut ExecutionCtx,

encodings/fastlanes/src/rle/vtable/operations.rs

@@ -14,6 +14,9 @@ use crate::rle::RLEArrayExt;
 use crate::rle::RLEArraySlotsExt;
 
 impl OperationsVTable<RLE> for RLE {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, RLE>,
         index: usize,
@@ -185,6 +188,7 @@ mod tests {
     }
 
     #[test]
+    #[expect(deprecated)]
     fn test_scalar_at_multiple_chunks() {
         let mut ctx = SESSION.create_execution_ctx();
         // Test accessing elements around chunk boundaries
@@ -212,6 +216,7 @@ mod tests {
 
     #[test]
     #[should_panic]
+    #[expect(deprecated)]
     fn test_scalar_at_out_of_bounds() {
         let array = fixture::rle_array();
         array
@@ -221,6 +226,7 @@ mod tests {
 
     #[test]
     #[should_panic]
+    #[expect(deprecated)]
     fn test_scalar_at_slice_out_of_bounds() {
         let array = fixture::rle_array().slice(0..1).unwrap();
         array

encodings/fastlanes/src/transposed_bool.rs

@@ -256,6 +256,9 @@ impl VTable for TransposedBool {
 }
 
 impl OperationsVTable<TransposedBool> for TransposedBool {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, TransposedBool>,
         index: usize,
@@ -325,6 +328,7 @@ mod tests {
     }
 
     #[test]
+    #[expect(deprecated)]
     fn slice_stays_lazy_and_translates_scalars() -> VortexResult<()> {
         let expected = test_bits();
         let array = TransposedBool::try_new(transposed_bool_array(expected.clone()))?;

encodings/fsst/src/array.rs

@@ -791,6 +791,7 @@ impl FSSTData {
 
     /// Validate using the decomposed components (codes bytes + offsets + nullability).
     #[expect(clippy::too_many_arguments)]
+    #[expect(deprecated)]
     fn validate_parts(
         symbols: &[Symbol],
         symbol_lengths: &[u8],

encodings/fsst/src/ops.rs

@@ -14,6 +14,9 @@ use crate::FSST;
 use crate::FSSTArrayExt;
 
 impl OperationsVTable<FSST> for FSST {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, FSST>,
         index: usize,

encodings/onpair/src/decode.rs

@@ -32,6 +32,7 @@ pub(crate) fn collect_widened<T: NativePType>(
         .into_buffer::<T>())
 }
 
+#[expect(deprecated)]
 pub(crate) fn code_boundary_at(
     codes_offsets: &ArrayRef,
     index: usize,

encodings/onpair/src/ops.rs

@@ -18,6 +18,9 @@ use crate::decode::code_boundary_at;
 use crate::decode::collect_widened;
 
 impl OperationsVTable<OnPair> for OnPair {
+    type ProbeState = ();
+
+    #[expect(deprecated)]
     fn scalar_at(
         array: ArrayView<'_, OnPair>,
         index: usize,

encodings/onpair/src/tests.rs

@@ -108,6 +108,7 @@ fn test_onpair_rejects_100k_token_dictionary() -> vortex_error::VortexResult<()>
 /// decodes or searches through it, including on derived (sliced) arrays.
 #[cfg_attr(miri, ignore)]
 #[test]
+#[expect(deprecated)]
 fn test_corrupt_dictionary_rejected_on_first_use() -> vortex_error::VortexResult<()> {
     let mut ctx = SESSION.create_execution_ctx();
     let arr = compress_onpair(&sample_input().into_array(), &mut ctx)?;
@@ -267,6 +268,7 @@ fn test_onpair_nullable_canonicalize() -> vortex_error::VortexResult<()> {
 
 #[cfg_attr(miri, ignore)]
 #[test]
+#[expect(deprecated)]
 fn test_onpair_scalar_at() -> vortex_error::VortexResult<()> {
     let input = sample_input();
     let mut ctx = SESSION.create_execution_ctx();
@@ -285,6 +287,7 @@ fn test_onpair_scalar_at() -> vortex_error::VortexResult<()> {
 /// relative to the slice.
 #[cfg_attr(miri, ignore)]
 #[test]
+#[expect(deprecated)]
 fn test_onpair_scalar_at_window() -> vortex_error::VortexResult<()> {
     let n = 2_000usize;
     let strings: Vec<String> = (0..n)

encodings/parquet-variant/src/array.rs

@@ -809,6 +809,7 @@ mod tests {
     /// canonicalization performs: an object-shredded Parquet variant, once canonicalized and then
     /// rebuilt, must produce the same per-row values as the original.
     #[test]
+    #[expect(deprecated)]
     fn parquet_typed_value_inverse_roundtrips_object_shredding() -> VortexResult<()> {
         // Shred `$.a` as Int32 over conforming, non-conforming, and missing-field rows.
         let json: ArrowArrayRef = Arc::new(StringArray::from(vec![

encodings/parquet-variant/src/arrow.rs

@@ -353,6 +353,7 @@ mod tests {
         }
     }
 
+    #[expect(deprecated)]
     fn assert_variant_scalars_eq(
         actual: &vortex_array::ArrayRef,
         expected: &vortex_array::ArrayRef,

encodings/parquet-variant/src/json_to_variant_tests.rs

@@ -65,6 +65,7 @@ fn execute_json_to_variant(input: ArrayRef, shredding: ShreddingSpec) -> VortexR
         .execute::<ArrayRef>(&mut SESSION.create_execution_ctx())
 }
 
+#[expect(deprecated)]
 fn assert_variant_i64_rows(array: &ArrayRef, expected: &[Option<i64>]) -> VortexResult<()> {
     assert_eq!(array.len(), expected.len());
     let mut ctx = SESSION.create_execution_ctx();
@@ -97,6 +98,7 @@ fn rejects_bare_utf8_input() {
 }
 
 #[test]
+#[expect(deprecated)]
 fn converts_json_extension_rows() -> VortexResult<()> {
     let input = json_input(
         VarBinViewArray::from_iter_str([r#"{"a": 1}"#, "2", r#"{"a": 3}"#]).into_array(),
@@ -158,6 +160,7 @@ fn dict_encoded_input_converts_each_row() -> VortexResult<()> {
 }
 
 #[test]
+#[expect(deprecated)]
 fn null_rows_stay_null_and_json_null_becomes_variant_null() -> VortexResult<()> {
     let input = json_input(
         VarBinViewArray::from_iter_nullable_str([Some("1"), None, Some("null")]).into_array(),
@@ -186,6 +189,7 @@ fn invalid_json_errors() -> VortexResult<()> {
 }
 
 #[test]
+#[expect(deprecated)]
 fn shredding_produces_typed_value_child() -> VortexResult<()> {
     let input = json_input(
         VarBinViewArray::from_iter_str([
@@ -275,6 +279,7 @@ fn shredding_preserves_null_rows() -> VortexResult<()> {
 }
 
 #[test]
+#[expect(deprecated)]
 fn shredding_root_path_shreds_top_level_values() -> VortexResult<()> {
     let input =
         json_input(VarBinViewArray::from_iter_str(["1", "2", r#""not-a-number""#]).into_array())?;