Refactor.

CodeBlanch · CodeBlanch · commit b57807376daa · 2026-07-14T11:03:57.000-07:00
diff --git a/rust/experimental/query_engine/engine-columnar-otap-bridge/src/arrow_helpers.rs b/rust/experimental/query_engine/engine-columnar-otap-bridge/src/arrow_helpers.rs
@@ -152,11 +152,11 @@ where
 
     Some(match transformed_values.len() {
         v if v < u8::MAX as usize => Arc::new(DictionaryArray::<UInt8Type>::new(
-            keys.transform_into_key_array(lookup),
+            keys.into_key_array(lookup),
             Arc::new(transformed_values),
         )),
         _ => Arc::new(DictionaryArray::<UInt16Type>::new(
-            keys.transform_into_key_array(lookup),
+            keys.into_key_array(lookup),
             Arc::new(transformed_values),
         )),
     })
diff --git a/rust/experimental/query_engine/engine-columnar-otap-bridge/src/logs.rs b/rust/experimental/query_engine/engine-columnar-otap-bridge/src/logs.rs
@@ -1415,59 +1415,51 @@ impl OtapLogRecordField {
                 primitive_array_writer(
                     keys,
                     values,
-                    DictionaryValueArray::transform_into_timestamp_nanoseconds_array,
+                    DictionaryValueArray::into_timestamp_nanoseconds_array,
                 )
             }),
             OtapLogRecordField::ObservedTimeUnixNano => {
                 (consts::OBSERVED_TIME_UNIX_NANO, |keys, values| {
                     primitive_array_writer(
                         keys,
                         values,
-                        DictionaryValueArray::transform_into_timestamp_nanoseconds_array,
+                        DictionaryValueArray::into_timestamp_nanoseconds_array,
                     )
                 })
             }
             OtapLogRecordField::SeverityNumber => (consts::SEVERITY_NUMBER, |keys, values| {
                 adaptive_dictionary_writer(
                     keys,
                     values,
-                    DictionaryValueArray::transform_into_int_array::<Int32Type>,
+                    DictionaryValueArray::into_int_array::<Int32Type>,
                 )
             }),
             OtapLogRecordField::SeverityText => (consts::SEVERITY_TEXT, |keys, values| {
-                adaptive_dictionary_writer(
-                    keys,
-                    values,
-                    DictionaryValueArray::transform_into_string_array,
-                )
+                adaptive_dictionary_writer(keys, values, DictionaryValueArray::into_string_array)
             }),
             OtapLogRecordField::TraceId => (consts::TRACE_ID, |keys, values| {
                 adaptive_dictionary_writer(
                     keys,
                     values,
-                    DictionaryValueArray::transform_into_fixed_sized_binary_array::<16>,
+                    DictionaryValueArray::into_fixed_sized_binary_array::<16>,
                 )
             }),
             OtapLogRecordField::SpanId => (consts::SPAN_ID, |keys, values| {
                 adaptive_dictionary_writer(
                     keys,
                     values,
-                    DictionaryValueArray::transform_into_fixed_sized_binary_array::<8>,
+                    DictionaryValueArray::into_fixed_sized_binary_array::<8>,
                 )
             }),
             OtapLogRecordField::Flags => (consts::FLAGS, |keys, values| {
                 primitive_array_writer(
                     keys,
                     values,
-                    DictionaryValueArray::transform_into_int_array::<UInt32Type>,
+                    DictionaryValueArray::into_int_array::<UInt32Type>,
                 )
             }),
             OtapLogRecordField::EventName => (consts::EVENT_NAME, |keys, values| {
-                adaptive_dictionary_writer(
-                    keys,
-                    values,
-                    DictionaryValueArray::transform_into_string_array,
-                )
+                adaptive_dictionary_writer(keys, values, DictionaryValueArray::into_string_array)
             }),
             OtapLogRecordField::Body => (consts::BODY, body_writer),
         }
diff --git a/rust/experimental/query_engine/engine-columnar/src/primitives/dictionary/dictionary_keys.rs b/rust/experimental/query_engine/engine-columnar/src/primitives/dictionary/dictionary_keys.rs
@@ -162,49 +162,48 @@ impl DictionaryKeyArray {
         }
     }
 
-    pub fn transform_into_key_array<KOutput: ArrowDictionaryKeyType>(
+    pub fn into_key_array<KOutput: ArrowDictionaryKeyType>(
         self,
         value_index_lookup: IndexLookup,
     ) -> PrimitiveArray<KOutput> {
-        self.transform_into_key_builder(value_index_lookup).finish()
+        self.into_key_builder(value_index_lookup).finish()
     }
 
-    pub(crate) fn transform_into_key_builder<KOutput: ArrowDictionaryKeyType>(
+    pub(crate) fn into_key_builder<KOutput: ArrowDictionaryKeyType>(
         self,
         value_index_lookup: IndexLookup,
     ) -> DictionaryKeyArrayBuilder<KOutput> {
         match self {
             DictionaryKeyArray::KeyArray(array) => match array.data_type() {
-                DataType::UInt8 => transform_key_array_into_key_builder(
+                DataType::UInt8 => key_array_into_key_builder(
                     array.as_primitive::<UInt8Type>(),
                     value_index_lookup,
                 ),
-                DataType::UInt16 => transform_key_array_into_key_builder(
+                DataType::UInt16 => key_array_into_key_builder(
                     array.as_primitive::<UInt16Type>(),
                     value_index_lookup,
                 ),
-                DataType::UInt32 => transform_key_array_into_key_builder(
+                DataType::UInt32 => key_array_into_key_builder(
                     array.as_primitive::<UInt32Type>(),
                     value_index_lookup,
                 ),
-                DataType::UInt64 => transform_key_array_into_key_builder(
+                DataType::UInt64 => key_array_into_key_builder(
                     array.as_primitive::<UInt64Type>(),
                     value_index_lookup,
                 ),
 
-                DataType::Int8 => transform_key_array_into_key_builder(
-                    array.as_primitive::<Int8Type>(),
-                    value_index_lookup,
-                ),
-                DataType::Int16 => transform_key_array_into_key_builder(
+                DataType::Int8 => {
+                    key_array_into_key_builder(array.as_primitive::<Int8Type>(), value_index_lookup)
+                }
+                DataType::Int16 => key_array_into_key_builder(
                     array.as_primitive::<Int16Type>(),
                     value_index_lookup,
                 ),
-                DataType::Int32 => transform_key_array_into_key_builder(
+                DataType::Int32 => key_array_into_key_builder(
                     array.as_primitive::<Int32Type>(),
                     value_index_lookup,
                 ),
-                DataType::Int64 => transform_key_array_into_key_builder(
+                DataType::Int64 => key_array_into_key_builder(
                     array.as_primitive::<Int64Type>(),
                     value_index_lookup,
                 ),
@@ -330,10 +329,7 @@ impl DictionaryKeyArray {
     }
 }
 
-fn transform_key_array_into_key_builder<
-    KInput: ArrowDictionaryKeyType,
-    KOutput: ArrowDictionaryKeyType,
->(
+fn key_array_into_key_builder<KInput: ArrowDictionaryKeyType, KOutput: ArrowDictionaryKeyType>(
     keys: &PrimitiveArray<KInput>,
     value_index_lookup: IndexLookup,
 ) -> DictionaryKeyArrayBuilder<KOutput> {
diff --git a/rust/experimental/query_engine/engine-columnar/src/primitives/dictionary/dictionary_root.rs b/rust/experimental/query_engine/engine-columnar/src/primitives/dictionary/dictionary_root.rs
@@ -278,7 +278,7 @@ fn with_values_typed<'a, K: ArrowDictionaryKeyType>(
 
     let (mut source_values, lookup) = source_values.into_set();
 
-    let mut source_key_builder = source_keys.transform_into_key_builder::<K>(lookup);
+    let mut source_key_builder = source_keys.into_key_builder::<K>(lookup);
 
     let key_length = source_key_builder.get_key_length();
     let mut source_key_writer = source_key_builder.get_writer();
diff --git a/rust/experimental/query_engine/engine-columnar/src/primitives/dictionary/dictionary_values.rs b/rust/experimental/query_engine/engine-columnar/src/primitives/dictionary/dictionary_values.rs
@@ -109,15 +109,15 @@ impl DictionaryValueArray<'_> {
         }
     }
 
-    pub fn transform_into_string_array(self) -> (StringArray, IndexLookup) {
+    pub fn into_string_array(self) -> (StringArray, IndexLookup) {
         self.transform_into_array(
             ArrayRef::as_string_opt,
             |v| Some(v.to_string()),
             StringArray::from_iter_values,
         )
     }
 
-    pub fn transform_into_int_array<T: ArrowPrimitiveType>(self) -> (PrimitiveArray<T>, IndexLookup)
+    pub fn into_int_array<T: ArrowPrimitiveType>(self) -> (PrimitiveArray<T>, IndexLookup)
     where
         T::Native: Hash + Eq + TryFrom<i64>,
     {
@@ -128,7 +128,7 @@ impl DictionaryValueArray<'_> {
         )
     }
 
-    pub fn transform_into_timestamp_nanoseconds_array(
+    pub fn into_timestamp_nanoseconds_array(
         self,
     ) -> (PrimitiveArray<TimestampNanosecondType>, IndexLookup) {
         self.transform_into_array(
@@ -142,7 +142,7 @@ impl DictionaryValueArray<'_> {
         )
     }
 
-    pub fn transform_into_fixed_sized_binary_array<const SIZE: usize>(
+    pub fn into_fixed_sized_binary_array<const SIZE: usize>(
         self,
     ) -> (FixedSizeBinaryArray, IndexLookup) {
         self.transform_into_array(
@@ -277,40 +277,40 @@ impl<'a> DictionaryValueArray<'a> {
         }
     }
 
-    pub fn transform_into_array<TArray: Array + Clone, T: Hash + Eq, FAsArray, FConvert, FBuild>(
+    pub fn transform_into_array<TArray: Array + Clone, T: Hash + Eq, FAsArray, FTransform, FBuild>(
         self,
         as_array: FAsArray,
-        convert: FConvert,
+        transform: FTransform,
         build: FBuild,
     ) -> (TArray, IndexLookup)
     where
         FAsArray: Fn(&Arc<dyn Array>) -> Option<&TArray>,
-        FConvert: Fn(&ValueOrRef<'a>) -> Option<T>,
+        FTransform: Fn(&ValueOrRef<'a>) -> Option<T>,
         FBuild: Fn(indexmap::set::IntoIter<T>) -> TArray,
     {
         match self {
             DictionaryValueArray::Array(a) => {
                 if let Some(s) = as_array(&a) {
                     (s.clone(), None)
                 } else {
-                    let (values, lookup) = transform_array_into_set(|v| convert(&v), a);
+                    let (values, lookup) = transform_array_into_set(|v| transform(&v), a);
 
                     (build(values.into_iter()), lookup)
                 }
             }
             DictionaryValueArray::Vec(a) => {
-                let null_value = convert(&ValueOrRef::Null);
+                let null_value = transform(&ValueOrRef::Null);
 
-                iter_into_array(a.iter().map(convert), null_value, build)
+                iter_into_array(a.iter().map(transform), null_value, build)
             }
             DictionaryValueArray::Set(a) => {
-                let null_value = convert(&ValueOrRef::Null);
+                let null_value = transform(&ValueOrRef::Null);
 
-                iter_into_array(a.iter().map(convert), null_value, build)
+                iter_into_array(a.iter().map(transform), null_value, build)
             }
             DictionaryValueArray::Boolean => {
                 let values = [ValueOrRef::Boolean(false), ValueOrRef::Boolean(true)];
-                iter_into_array(values.iter().map(convert), None, build)
+                iter_into_array(values.iter().map(transform), None, build)
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -109,15 +109,15 @@ impl DictionaryValueArray<'_> {`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`
`112`		`- pub fn transform_into_string_array(self) -> (StringArray, IndexLookup) {`
	`112`	`+ pub fn into_string_array(self) -> (StringArray, IndexLookup) {`
`113`	`113`	`self.transform_into_array(`
`114`	`114`	`ArrayRef::as_string_opt,`
`115`	`115`	`\|v\| Some(v.to_string()),`
`116`	`116`	`StringArray::from_iter_values,`
`117`	`117`	`)`
`118`	`118`	`}`
`119`	`119`
`120`		`- pub fn transform_into_int_array<T: ArrowPrimitiveType>(self) -> (PrimitiveArray<T>, IndexLookup)`
	`120`	`+ pub fn into_int_array<T: ArrowPrimitiveType>(self) -> (PrimitiveArray<T>, IndexLookup)`
`121`	`121`	`where`
`122`	`122`	`T::Native: Hash + Eq + TryFrom<i64>,`
`123`	`123`	`{`
`@@ -128,7 +128,7 @@ impl DictionaryValueArray<'_> {`
`128`	`128`	`)`
`129`	`129`	`}`
`130`	`130`
`131`		`- pub fn transform_into_timestamp_nanoseconds_array(`
	`131`	`+ pub fn into_timestamp_nanoseconds_array(`
`132`	`132`	`self,`
`133`	`133`	`) -> (PrimitiveArray<TimestampNanosecondType>, IndexLookup) {`
`134`	`134`	`self.transform_into_array(`
`@@ -142,7 +142,7 @@ impl DictionaryValueArray<'_> {`
`142`	`142`	`)`
`143`	`143`	`}`
`144`	`144`
`145`		`- pub fn transform_into_fixed_sized_binary_array<const SIZE: usize>(`
	`145`	`+ pub fn into_fixed_sized_binary_array<const SIZE: usize>(`
`146`	`146`	`self,`
`147`	`147`	`) -> (FixedSizeBinaryArray, IndexLookup) {`
`148`	`148`	`self.transform_into_array(`
`@@ -277,40 +277,40 @@ impl<'a> DictionaryValueArray<'a> {`
`277`	`277`	`}`
`278`	`278`	`}`
`279`	`279`
`280`		`- pub fn transform_into_array<TArray: Array + Clone, T: Hash + Eq, FAsArray, FConvert, FBuild>(`
	`280`	`+ pub fn transform_into_array<TArray: Array + Clone, T: Hash + Eq, FAsArray, FTransform, FBuild>(`
`281`	`281`	`self,`
`282`	`282`	`as_array: FAsArray,`
`283`		`- convert: FConvert,`
	`283`	`+ transform: FTransform,`
`284`	`284`	`build: FBuild,`
`285`	`285`	`) -> (TArray, IndexLookup)`
`286`	`286`	`where`
`287`	`287`	`FAsArray: Fn(&Arc<dyn Array>) -> Option<&TArray>,`
`288`		`- FConvert: Fn(&ValueOrRef<'a>) -> Option<T>,`
	`288`	`+ FTransform: Fn(&ValueOrRef<'a>) -> Option<T>,`
`289`	`289`	`FBuild: Fn(indexmap::set::IntoIter<T>) -> TArray,`
`290`	`290`	`{`
`291`	`291`	`match self {`
`292`	`292`	`DictionaryValueArray::Array(a) => {`
`293`	`293`	`if let Some(s) = as_array(&a) {`
`294`	`294`	`(s.clone(), None)`
`295`	`295`	`} else {`
`296`		`- let (values, lookup) = transform_array_into_set(\|v\| convert(&v), a);`
	`296`	`+ let (values, lookup) = transform_array_into_set(\|v\| transform(&v), a);`
`297`	`297`
`298`	`298`	`(build(values.into_iter()), lookup)`
`299`	`299`	`}`
`300`	`300`	`}`
`301`	`301`	`DictionaryValueArray::Vec(a) => {`
`302`		`- let null_value = convert(&ValueOrRef::Null);`
	`302`	`+ let null_value = transform(&ValueOrRef::Null);`
`303`	`303`
`304`		`- iter_into_array(a.iter().map(convert), null_value, build)`
	`304`	`+ iter_into_array(a.iter().map(transform), null_value, build)`
`305`	`305`	`}`
`306`	`306`	`DictionaryValueArray::Set(a) => {`
`307`		`- let null_value = convert(&ValueOrRef::Null);`
	`307`	`+ let null_value = transform(&ValueOrRef::Null);`
`308`	`308`
`309`		`- iter_into_array(a.iter().map(convert), null_value, build)`
	`309`	`+ iter_into_array(a.iter().map(transform), null_value, build)`
`310`	`310`	`}`
`311`	`311`	`DictionaryValueArray::Boolean => {`
`312`	`312`	`let values = [ValueOrRef::Boolean(false), ValueOrRef::Boolean(true)];`
`313`		`- iter_into_array(values.iter().map(convert), None, build)`
	`313`	`+ iter_into_array(values.iter().map(transform), None, build)`
`314`	`314`	`}`
`315`	`315`	`}`
`316`	`316`	`}`