[rust 2021] migrate to rust 2021

common/allocators/Cargo.toml

@@ -1,10 +1,12 @@
+cargo-features = ["edition2021"]
+
 [package]
 name = "common-allocators"
 version = "0.1.0"
 authors = ["Datafuse Authors <opensource@datafuselabs.com>"]
 license = "Apache-2.0"
 publish = false
-edition = "2018"
+edition = "2021"
 
 [features]
 # Enable jemalloc for binaries

common/arrow/Cargo.toml

@@ -1,10 +1,12 @@
+cargo-features = ["edition2021"]
+
 [package]
 name = "common-arrow"
 version = "0.1.0"
 authors = ["Datafuse Authors <opensource@datafuselabs.com>"]
 license = "Apache-2.0"
 publish = false
-edition = "2018"
+edition = "2021"
 
 [features]
 simd = ["arrow/simd"]

common/building/Cargo.toml

@@ -1,10 +1,12 @@
+cargo-features = ["edition2021"]
+
 [package]
 name = "common-building"
 version = "0.1.0"
 authors = ["Datafuse Authors <opensource@datafuselabs.com>"]
 license = "Apache-2.0"
 publish = false
-edition = "2018"
+edition = "2021"
 
 [dependencies]
 vergen = "5.1.13"

common/datablocks/Cargo.toml

@@ -1,10 +1,12 @@
+cargo-features = ["edition2021"]
+
 [package]
 name = "common-datablocks"
 version = "0.1.0"
 authors = ["Datafuse Authors <opensource@datafuselabs.com>"]
 license = "Apache-2.0"
 publish = false
-edition = "2018"
+edition = "2021"
 
 [dependencies] # In alphabetical order
 # Workspace dependencies

common/datablocks/src/kernels/data_block_sort.rs

@@ -87,7 +87,10 @@ impl DataBlock {
             .columns()
             .iter()
             .zip(rhs.columns().iter())
-            .map(|(a, b)| DataColumnCommon::merge_columns(a, b, indices))
+            .map(|(a, b)| {
+                let _ = &indices;
+                DataColumnCommon::merge_columns(a, b, indices)
+            })
             .collect::<Result<Vec<_>>>()?;
 
         Ok(DataBlock::create(lhs.schema().clone(), arrays))

common/datablocks/src/kernels/data_block_take.rs

@@ -20,6 +20,7 @@ impl DataBlock {
         let columns = fields
             .iter()
             .map(|f| {
+                let _ = (&constant_columns, &indices);
                 let column = raw.try_column_by_name(f.name())?;
                 if constant_columns.contains(f.name()) {
                     let v = column.try_get(indices[0] as usize)?;

common/datavalues/Cargo.toml

@@ -1,10 +1,12 @@
+cargo-features = ["edition2021"]
+
 [package]
 name = "common-datavalues"
 version = "0.1.0"
 authors = ["Datafuse Authors <opensource@datafuselabs.com>"]
 license = "Apache-2.0"
 publish = false
-edition = "2018"
+edition = "2021"
 
 [dependencies] # In alphabetical order
 # Workspace dependencies

common/datavalues/src/arrays/arithmetic.rs

@@ -425,11 +425,19 @@ impl Add<&str> for &DFUtf8Array {
         Ok(match self.null_count() {
             0 => self
                 .into_no_null_iter()
-                .map(|l| concat_strings(l, rhs))
+                .map(|l| {
+                    let _ = &rhs;
+                    concat_strings(l, rhs)
+                })
                 .collect(),
             _ => self
                 .into_iter()
-                .map(|opt_l| opt_l.map(|l| concat_strings(l, rhs)))
+                .map(|opt_l| {
+                    opt_l.map(|l| {
+                        let _ = &rhs;
+                        concat_strings(l, rhs)
+                    })
+                })
                 .collect(),
         })
     }

common/datavalues/src/arrays/builders/builder.rs

@@ -361,6 +361,7 @@ where
             builder.append_slice(values);
         } else {
             values.iter().enumerate().for_each(|(idx, v)| {
+                let _ = &builder;
                 if array.is_valid(idx) {
                     builder.append_value(*v);
                 } else {

common/datavalues/src/arrays/kernels/take.rs

@@ -36,6 +36,7 @@ pub unsafe fn take_no_null_primitive<T: DFNumericType>(
     av.iter_mut()
         .zip(index_values.iter())
         .for_each(|(num, idx)| {
+            let _ = &array_values;
             *num = *array_values.get_unchecked(*idx as usize);
         });
 
@@ -62,6 +63,7 @@ pub unsafe fn take_no_null_primitive_iter_unchecked<
     let mut av = AlignedVec::<T::Native>::with_capacity_len_aligned(data_len);
 
     av.iter_mut().zip(indices_iter).for_each(|(num, idx)| {
+        let _ = &array_values;
         *num = *array_values.get_unchecked(idx);
     });
     let arr = av.into_primitive_array::<T>(None);
@@ -79,7 +81,10 @@ pub fn take_no_null_primitive_iter<T: DFNumericType, I: IntoIterator<Item = usiz
 
     let av = indices
         .into_iter()
-        .map(|idx| array_values[idx])
+        .map(|idx| {
+            let _ = &array_values;
+            array_values[idx]
+        })
         .collect::<AlignedVec<_>>();
     let arr = av.into_primitive_array(None);
 
@@ -96,6 +101,7 @@ pub unsafe fn take_primitive_iter_unchecked<T: DFNumericType, I: IntoIterator<It
     let array_values = arr.values();
 
     let iter = indices.into_iter().map(|idx| {
+        let _ = (&arr, &array_values);
         if arr.is_valid(idx) {
             Some(*array_values.get_unchecked(idx))
         } else {
@@ -117,6 +123,7 @@ pub fn take_primitive_iter<T: DFNumericType, I: IntoIterator<Item = usize>>(
     let arr = indices
         .into_iter()
         .map(|idx| {
+            let _ = (&arr, &array_values);
             if arr.is_valid(idx) {
                 Some(array_values[idx])
             } else {
@@ -141,9 +148,12 @@ pub unsafe fn take_no_null_primitive_opt_iter_unchecked<
 ) -> Arc<PrimitiveArray<T>> {
     let array_values = arr.values();
 
-    let iter = indices
-        .into_iter()
-        .map(|opt_idx| opt_idx.map(|idx| *array_values.get_unchecked(idx)));
+    let iter = indices.into_iter().map(|opt_idx| {
+        opt_idx.map(|idx| {
+            let _ = &array_values;
+            *array_values.get_unchecked(idx)
+        })
+    });
     let arr = PrimitiveArray::from_trusted_len_iter(iter);
 
     Arc::new(arr)
@@ -164,6 +174,7 @@ pub unsafe fn take_primitive_opt_iter_unchecked<
 
     let iter = indices.into_iter().map(|opt_idx| {
         opt_idx.and_then(|idx| {
+            let _ = (&arr, &array_values);
             if arr.is_valid(idx) {
                 Some(*array_values.get_unchecked(idx))
             } else {
@@ -205,7 +216,10 @@ pub fn take_no_null_bool_iter<I: IntoIterator<Item = usize>>(
 ) -> Arc<BooleanArray> {
     debug_assert_eq!(arr.null_count(), 0);
 
-    let iter = indices.into_iter().map(|idx| Some(arr.value(idx)));
+    let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
+        Some(arr.value(idx))
+    });
 
     Arc::new(iter.collect())
 }
@@ -218,9 +232,10 @@ pub unsafe fn take_no_null_bool_iter_unchecked<I: IntoIterator<Item = usize>>(
     indices: I,
 ) -> Arc<BooleanArray> {
     debug_assert_eq!(arr.null_count(), 0);
-    let iter = indices
-        .into_iter()
-        .map(|idx| Some(arr.value_unchecked(idx)));
+    let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
+        Some(arr.value_unchecked(idx))
+    });
 
     Arc::new(iter.collect())
 }
@@ -231,6 +246,7 @@ pub fn take_bool_iter<I: IntoIterator<Item = usize>>(
     indices: I,
 ) -> Arc<BooleanArray> {
     let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
         if arr.is_null(idx) {
             None
         } else {
@@ -249,6 +265,7 @@ pub unsafe fn take_bool_iter_unchecked<I: IntoIterator<Item = usize>>(
     indices: I,
 ) -> Arc<BooleanArray> {
     let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
         if arr.is_null(idx) {
             None
         } else {
@@ -268,6 +285,7 @@ pub unsafe fn take_bool_opt_iter_unchecked<I: IntoIterator<Item = Option<usize>>
 ) -> Arc<BooleanArray> {
     let iter = indices.into_iter().map(|opt_idx| {
         opt_idx.and_then(|idx| {
+            let _ = &arr;
             if arr.is_null(idx) {
                 None
             } else {
@@ -286,9 +304,12 @@ pub unsafe fn take_no_null_bool_opt_iter_unchecked<I: IntoIterator<Item = Option
     arr: &BooleanArray,
     indices: I,
 ) -> Arc<BooleanArray> {
-    let iter = indices
-        .into_iter()
-        .map(|opt_idx| opt_idx.map(|idx| arr.value_unchecked(idx)));
+    let iter = indices.into_iter().map(|opt_idx| {
+        opt_idx.map(|idx| {
+            let _ = &arr;
+            arr.value_unchecked(idx)
+        })
+    });
 
     Arc::new(iter.collect())
 }
@@ -299,9 +320,10 @@ pub unsafe fn take_no_null_utf8_iter_unchecked<I: IntoIterator<Item = usize>>(
     arr: &StringArray,
     indices: I,
 ) -> Arc<StringArray> {
-    let iter = indices
-        .into_iter()
-        .map(|idx| Some(arr.value_unchecked(idx)));
+    let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
+        Some(arr.value_unchecked(idx))
+    });
 
     Arc::new(iter.collect())
 }
@@ -313,6 +335,7 @@ pub unsafe fn take_utf8_iter_unchecked<I: IntoIterator<Item = usize>>(
     indices: I,
 ) -> Arc<StringArray> {
     let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
         if arr.is_null(idx) {
             None
         } else {
@@ -329,9 +352,12 @@ pub unsafe fn take_no_null_utf8_opt_iter_unchecked<I: IntoIterator<Item = Option
     arr: &StringArray,
     indices: I,
 ) -> Arc<StringArray> {
-    let iter = indices
-        .into_iter()
-        .map(|opt_idx| opt_idx.map(|idx| arr.value_unchecked(idx)));
+    let iter = indices.into_iter().map(|opt_idx| {
+        opt_idx.map(|idx| {
+            let _ = &arr;
+            arr.value_unchecked(idx)
+        })
+    });
 
     Arc::new(iter.collect())
 }
@@ -344,6 +370,7 @@ pub unsafe fn take_utf8_opt_iter_unchecked<I: IntoIterator<Item = Option<usize>>
 ) -> Arc<StringArray> {
     let iter = indices.into_iter().map(|opt_idx| {
         opt_idx.and_then(|idx| {
+            let _ = &arr;
             if arr.is_null(idx) {
                 None
             } else {
@@ -359,7 +386,10 @@ pub fn take_no_null_utf8_iter<I: IntoIterator<Item = usize>>(
     arr: &StringArray,
     indices: I,
 ) -> Arc<StringArray> {
-    let iter = indices.into_iter().map(|idx| Some(arr.value(idx)));
+    let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
+        Some(arr.value(idx))
+    });
 
     Arc::new(iter.collect())
 }
@@ -369,6 +399,7 @@ pub fn take_utf8_iter<I: IntoIterator<Item = usize>>(
     indices: I,
 ) -> Arc<StringArray> {
     let iter = indices.into_iter().map(|idx| {
+        let _ = &arr;
         if arr.is_null(idx) {
             None
         } else {
@@ -413,6 +444,7 @@ pub unsafe fn take_utf8(arr: &StringArray, indices: &UInt32Array) -> Arc<StringA
             .skip(1)
             .enumerate()
             .for_each(|(idx, offset)| {
+                let _ = (&indices, &arr);
                 let index = indices.value_unchecked(idx) as usize;
                 let s = arr.value_unchecked(index);
                 length_so_far += s.len() as i64;
@@ -432,6 +464,7 @@ pub unsafe fn take_utf8(arr: &StringArray, indices: &UInt32Array) -> Arc<StringA
             .skip(1)
             .enumerate()
             .for_each(|(idx, offset)| {
+                let _ = (&indices, &arr);
                 if indices.is_valid(idx) {
                     let index = indices.value_unchecked(idx) as usize;
                     let s = arr.value_unchecked(index);
@@ -452,6 +485,7 @@ pub unsafe fn take_utf8(arr: &StringArray, indices: &UInt32Array) -> Arc<StringA
 
         if indices.null_count() == 0 {
             (0..data_len).for_each(|idx| {
+                let _ = (&indices, &arr);
                 let index = indices.value_unchecked(idx) as usize;
                 if arr.is_valid(index) {
                     let s = arr.value_unchecked(index);
@@ -462,6 +496,7 @@ pub unsafe fn take_utf8(arr: &StringArray, indices: &UInt32Array) -> Arc<StringA
             });
         } else {
             (0..data_len).for_each(|idx| {
+                let _ = (&indices, &arr);
                 if indices.is_valid(idx) {
                     let index = indices.value_unchecked(idx) as usize;
 

common/datavalues/src/arrays/ops/apply.rs

@@ -163,7 +163,10 @@ impl<'a> ArrayApply<'a, bool, bool> for DFBooleanArray {
     {
         self.apply_kernel_cast(|array| {
             let av: AlignedVec<_> = (0..array.len())
-                .map(|idx| unsafe { f(array.value_unchecked(idx)) })
+                .map(|idx| {
+                    let _ = &array;
+                    unsafe { f(array.value_unchecked(idx)) }
+                })
                 .collect();
             let null_bit_buffer = array.data_ref().null_buffer().cloned();
             Arc::new(av.into_primitive_array::<S>(null_bit_buffer)) as ArrayRef
@@ -204,7 +207,10 @@ impl<'a> ArrayApply<'a, &'a str, Cow<'a, str>> for DFUtf8Array {
     {
         let arr = self.downcast_ref();
         let av: AlignedVec<_> = (0..arr.len())
-            .map(|idx| unsafe { f(arr.value_unchecked(idx)) })
+            .map(|idx| {
+                let _ = &arr;
+                unsafe { f(arr.value_unchecked(idx)) }
+            })
             .collect();
 
         let null_bit_buffer = self.array.data_ref().null_buffer().cloned();