refactor: optimize sst filter build to consume less CPU (#967)

## Rationale
When doing benchmark, xor filter build cost too much CPU.

## Detailed Changes
- Remove datum to_vec

## Test Plan

---------

Co-authored-by: jiacai2050 <dev@liujiacai.net>

analytic_engine/src/sst/parquet/writer.rs

@@ -153,8 +153,9 @@ impl RecordBatchGroupWriter {
             for (col_idx, column) in partial_batch.columns().iter().enumerate() {
                 for row in 0..column.num_rows() {
                     let datum = column.datum(row);
-                    let bytes = datum.to_bytes();
-                    builder.add_key(col_idx, &bytes);
+                    datum.do_with_bytes(|bytes| {
+                        builder.add_key(col_idx, bytes);
+                    });
                 }
             }
         }

common_types/src/datum.rs

@@ -562,6 +562,76 @@ impl Datum {
         }
     }
 
+    pub fn do_with_bytes<F>(&self, mut f: F)
+    where
+        F: FnMut(&[u8]),
+    {
+        match self {
+            Datum::Double(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Float(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::UInt64(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::UInt32(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::UInt16(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::UInt8(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Int64(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Int32(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Int16(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Int8(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Boolean(v) => {
+                if *v {
+                    f(&[1])
+                } else {
+                    f(&[0])
+                }
+            }
+            Datum::Null => f(&[0]),
+            Datum::Timestamp(v) => {
+                let arr = v.as_i64().to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Varbinary(v) => f(v.as_ref()),
+            Datum::String(v) => f(v.as_bytes()),
+            Datum::Date(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+            Datum::Time(v) => {
+                let arr = v.to_le_bytes();
+                f(arr.as_slice())
+            }
+        }
+    }
+
     pub fn to_bytes(&self) -> Vec<u8> {
         match self {
             Datum::Double(v) => v.to_le_bytes().to_vec(),