diff --git a/common/datavalues/src/types/serializations/array.rs b/common/datavalues/src/types/serializations/array.rs
index 417985d510cf1..d6043072eb32f 100644
--- a/common/datavalues/src/types/serializations/array.rs
+++ b/common/datavalues/src/types/serializations/array.rs
@@ -12,8 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use common_exception::ErrorCode;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use serde_json::Value;
 
 use crate::prelude::*;
@@ -25,7 +28,7 @@ pub struct ArraySerializer {
 }
 
 impl TypeSerializer for ArraySerializer {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, format: Arc<FormatSettings>) -> Result<String> {
         if let DataValue::Array(vals) = value {
             let mut res = String::new();
             res.push('[');
@@ -37,7 +40,7 @@ impl TypeSerializer for ArraySerializer {
                 }
                 first = false;
 
-                let s = self.inner.serialize_value(val)?;
+                let s = self.inner.serialize_value(val, format.clone())?;
                 if quoted {
                     res.push_str(&format!("'{}'", s));
                 } else {
@@ -51,24 +54,33 @@ impl TypeSerializer for ArraySerializer {
         }
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &ArrayColumn = Series::check_get(column)?;
         let mut result = Vec::with_capacity(column.len());
         for i in 0..column.len() {
             let val = column.get(i);
-            let s = self.serialize_value(&val)?;
+            let s = self.serialize_value(&val, format.clone())?;
             result.push(s);
         }
         Ok(result)
     }
 
-    fn serialize_json(&self, _column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        _column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         todo!()
     }
 
     fn serialize_clickhouse_format(
         &self,
         _column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         todo!()
     }
diff --git a/common/datavalues/src/types/serializations/boolean.rs b/common/datavalues/src/types/serializations/boolean.rs
index df4feae432927..846f78f245d64 100644
--- a/common/datavalues/src/types/serializations/boolean.rs
+++ b/common/datavalues/src/types/serializations/boolean.rs
@@ -12,9 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use common_arrow::arrow::bitmap::Bitmap;
 use common_exception::ErrorCode;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use opensrv_clickhouse::types::column::ArcColumnWrapper;
 use opensrv_clickhouse::types::column::ColumnFrom;
 use serde_json::Value;
@@ -28,7 +31,7 @@ const TRUE_STR: &str = "1";
 const FALSE_STR: &str = "0";
 
 impl TypeSerializer for BooleanSerializer {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, _format: Arc<FormatSettings>) -> Result<String> {
         if let DataValue::Boolean(x) = value {
             if *x {
                 Ok(TRUE_STR.to_owned())
@@ -40,7 +43,11 @@ impl TypeSerializer for BooleanSerializer {
         }
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let array: &BooleanColumn = Series::check_get(column)?;
 
         let result: Vec<String> = array
@@ -56,7 +63,11 @@ impl TypeSerializer for BooleanSerializer {
         Ok(result)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let array: &BooleanColumn = Series::check_get(column)?;
         let result: Vec<Value> = array
             .iter()
@@ -68,6 +79,7 @@ impl TypeSerializer for BooleanSerializer {
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let col: &BooleanColumn = Series::check_get(column)?;
         let values: Vec<u8> = col.iter().map(|c| c as u8).collect();
@@ -78,13 +90,15 @@ impl TypeSerializer for BooleanSerializer {
         &self,
         column: &ColumnRef,
         _valids: Option<&Bitmap>,
+        format: Arc<FormatSettings>,
     ) -> Result<Vec<Value>> {
-        self.serialize_json(column)
+        self.serialize_json(column, format)
     }
 
     fn serialize_json_object_suppress_error(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Option<Value>>> {
         let column: &BooleanColumn = Series::check_get(column)?;
         let result: Vec<Option<Value>> = column
diff --git a/common/datavalues/src/types/serializations/date.rs b/common/datavalues/src/types/serializations/date.rs
index b926cd679c6f3..be2f4fd8377a9 100644
--- a/common/datavalues/src/types/serializations/date.rs
+++ b/common/datavalues/src/types/serializations/date.rs
@@ -11,15 +11,16 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
 use std::marker::PhantomData;
 use std::ops::AddAssign;
+use std::sync::Arc;
 
 use chrono::Date;
 use chrono::Duration;
 use chrono::NaiveDate;
 use chrono_tz::Tz;
 use common_exception::*;
+use common_io::prelude::FormatSettings;
 use num::cast::AsPrimitive;
 use opensrv_clickhouse::types::column::ArcColumnWrapper;
 use opensrv_clickhouse::types::column::ColumnFrom;
@@ -43,14 +44,18 @@ impl<T: PrimitiveType + AsPrimitive<i64>> Default for DateSerializer<T> {
 const DATE_FMT: &str = "%Y-%m-%d";
 
 impl<T: PrimitiveType + AsPrimitive<i64>> TypeSerializer for DateSerializer<T> {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, _format: Arc<FormatSettings>) -> Result<String> {
         let mut date = NaiveDate::from_ymd(1970, 1, 1);
         let d = Duration::days(value.as_i64()?);
         date.add_assign(d);
         Ok(date.format(DATE_FMT).to_string())
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &PrimitiveColumn<T> = Series::check_get(column)?;
 
         let result: Vec<String> = column
@@ -65,7 +70,11 @@ impl<T: PrimitiveType + AsPrimitive<i64>> TypeSerializer for DateSerializer<T> {
         Ok(result)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let array: &PrimitiveColumn<T> = Series::check_get(column)?;
         let result: Vec<Value> = array
             .iter()
@@ -83,6 +92,7 @@ impl<T: PrimitiveType + AsPrimitive<i64>> TypeSerializer for DateSerializer<T> {
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let array: &PrimitiveColumn<T> = Series::check_get(column)?;
         let tz: Tz = "UTC".parse().unwrap();
diff --git a/common/datavalues/src/types/serializations/mod.rs b/common/datavalues/src/types/serializations/mod.rs
index aa52b456d8408..1bf813c57dfdb 100644
--- a/common/datavalues/src/types/serializations/mod.rs
+++ b/common/datavalues/src/types/serializations/mod.rs
@@ -12,9 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use common_arrow::arrow::bitmap::Bitmap;
 use common_exception::ErrorCode;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use enum_dispatch::enum_dispatch;
 use opensrv_clickhouse::types::column::ArcColumnData;
 use serde_json::Value;
@@ -44,15 +47,25 @@ pub use variant::*;
 
 #[enum_dispatch]
 pub trait TypeSerializer: Send + Sync {
-    fn serialize_value(&self, value: &DataValue) -> Result<String>;
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>>;
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>>;
-    fn serialize_clickhouse_format(&self, column: &ColumnRef) -> Result<ArcColumnData>;
+    fn serialize_value(&self, value: &DataValue, format: Arc<FormatSettings>) -> Result<String>;
+    fn serialize_json(&self, column: &ColumnRef, format: Arc<FormatSettings>)
+        -> Result<Vec<Value>>;
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>>;
+    fn serialize_clickhouse_format(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<ArcColumnData>;
 
     fn serialize_json_object(
         &self,
         _column: &ColumnRef,
         _valids: Option<&Bitmap>,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Value>> {
         Err(ErrorCode::BadDataValueType(
             "Error parsing JSON: unsupported data type",
@@ -62,6 +75,7 @@ pub trait TypeSerializer: Send + Sync {
     fn serialize_json_object_suppress_error(
         &self,
         _column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Option<Value>>> {
         Err(ErrorCode::BadDataValueType(
             "Error parsing JSON: unsupported data type",
diff --git a/common/datavalues/src/types/serializations/null.rs b/common/datavalues/src/types/serializations/null.rs
index c096b04ad5775..351516467c31e 100644
--- a/common/datavalues/src/types/serializations/null.rs
+++ b/common/datavalues/src/types/serializations/null.rs
@@ -15,6 +15,7 @@
 use std::sync::Arc;
 
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use opensrv_clickhouse::types::column::ArcColumnWrapper;
 use opensrv_clickhouse::types::column::ColumnFrom;
 use opensrv_clickhouse::types::column::NullableColumnData;
@@ -30,16 +31,24 @@ pub struct NullSerializer {}
 const NULL_STR: &str = "NULL";
 
 impl TypeSerializer for NullSerializer {
-    fn serialize_value(&self, _value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, _value: &DataValue, _format: Arc<FormatSettings>) -> Result<String> {
         Ok(NULL_STR.to_owned())
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let result: Vec<String> = vec![NULL_STR.to_owned(); column.len()];
         Ok(result)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let null = Value::Null;
         let result: Vec<Value> = vec![null; column.len()];
         Ok(result)
@@ -48,6 +57,7 @@ impl TypeSerializer for NullSerializer {
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let nulls = vec![1u8; column.len()];
         let inner = Vec::column_from::<ArcColumnWrapper>(vec![1u8; column.len()]);
diff --git a/common/datavalues/src/types/serializations/nullable.rs b/common/datavalues/src/types/serializations/nullable.rs
index bb7c0bdd5ea47..3545b7808cfa8 100644
--- a/common/datavalues/src/types/serializations/nullable.rs
+++ b/common/datavalues/src/types/serializations/nullable.rs
@@ -15,6 +15,7 @@
 use std::sync::Arc;
 
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use opensrv_clickhouse::types::column::NullableColumnData;
 use serde_json::Value;
 
@@ -32,18 +33,22 @@ pub struct NullableSerializer {
 }
 
 impl TypeSerializer for NullableSerializer {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, format: Arc<FormatSettings>) -> Result<String> {
         if value.is_null() {
             Ok("NULL".to_owned())
         } else {
-            self.inner.serialize_value(value)
+            self.inner.serialize_value(value, format)
         }
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &NullableColumn = Series::check_get(column)?;
         let rows = column.len();
-        let mut res = self.inner.serialize_column(column.inner())?;
+        let mut res = self.inner.serialize_column(column.inner(), format)?;
 
         (0..rows).for_each(|row| {
             if column.null_at(row) {
@@ -53,10 +58,14 @@ impl TypeSerializer for NullableSerializer {
         Ok(res)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let column: &NullableColumn = Series::check_get(column)?;
         let rows = column.len();
-        let mut res = self.inner.serialize_json(column.inner())?;
+        let mut res = self.inner.serialize_json(column.inner(), format)?;
 
         (0..rows).for_each(|row| {
             if column.null_at(row) {
@@ -69,9 +78,12 @@ impl TypeSerializer for NullableSerializer {
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let column: &NullableColumn = Series::check_get(column)?;
-        let inner = self.inner.serialize_clickhouse_format(column.inner())?;
+        let inner = self
+            .inner
+            .serialize_clickhouse_format(column.inner(), format)?;
         let nulls = column.ensure_validity().iter().map(|v| !v as u8).collect();
         let data = NullableColumnData { nulls, inner };
 
diff --git a/common/datavalues/src/types/serializations/number.rs b/common/datavalues/src/types/serializations/number.rs
index de37347f62d2c..e0a0a2bfa566c 100644
--- a/common/datavalues/src/types/serializations/number.rs
+++ b/common/datavalues/src/types/serializations/number.rs
@@ -13,9 +13,11 @@
 // limitations under the License.
 
 use std::marker::PhantomData;
+use std::sync::Arc;
 
 use common_arrow::arrow::bitmap::Bitmap;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use common_io::prelude::Marshal;
 use common_io::prelude::Unmarshal;
 use opensrv_clickhouse::types::column::ArcColumnWrapper;
@@ -49,17 +51,25 @@ where T: PrimitiveType
         + opensrv_clickhouse::io::Marshal
         + opensrv_clickhouse::io::Unmarshal<T>
 {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, _format: Arc<FormatSettings>) -> Result<String> {
         Ok(format!("{:?}", value))
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &PrimitiveColumn<T> = Series::check_get(column)?;
         let result: Vec<String> = column.iter().map(|x| format!("{}", x)).collect();
         Ok(result)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let column: &PrimitiveColumn<T> = Series::check_get(column)?;
         let result: Vec<Value> = column
             .iter()
@@ -71,6 +81,7 @@ where T: PrimitiveType
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let col: &PrimitiveColumn<T> = Series::check_get(column)?;
         let values: Vec<T> = col.iter().map(|c| c.to_owned()).collect();
@@ -81,13 +92,15 @@ where T: PrimitiveType
         &self,
         column: &ColumnRef,
         _valids: Option<&Bitmap>,
+        format: Arc<FormatSettings>,
     ) -> Result<Vec<Value>> {
-        self.serialize_json(column)
+        self.serialize_json(column, format)
     }
 
     fn serialize_json_object_suppress_error(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Option<Value>>> {
         let column: &PrimitiveColumn<T> = Series::check_get(column)?;
         let result: Vec<Option<Value>> = column
diff --git a/common/datavalues/src/types/serializations/string.rs b/common/datavalues/src/types/serializations/string.rs
index d16019d8a0d1b..e81102d1e100f 100644
--- a/common/datavalues/src/types/serializations/string.rs
+++ b/common/datavalues/src/types/serializations/string.rs
@@ -12,9 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use common_arrow::arrow::bitmap::Bitmap;
 use common_exception::ErrorCode;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use opensrv_clickhouse::types::column::ArcColumnWrapper;
 use opensrv_clickhouse::types::column::ColumnFrom;
 use serde_json::Value;
@@ -25,7 +28,7 @@ use crate::prelude::*;
 pub struct StringSerializer {}
 
 impl TypeSerializer for StringSerializer {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, _format: Arc<FormatSettings>) -> Result<String> {
         if let DataValue::String(x) = value {
             Ok(String::from_utf8_lossy(x).to_string())
         } else {
@@ -33,7 +36,11 @@ impl TypeSerializer for StringSerializer {
         }
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &StringColumn = Series::check_get(column)?;
         let result: Vec<String> = column
             .iter()
@@ -42,7 +49,11 @@ impl TypeSerializer for StringSerializer {
         Ok(result)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let column: &StringColumn = Series::check_get(column)?;
         let result: Vec<Value> = column
             .iter()
@@ -54,6 +65,7 @@ impl TypeSerializer for StringSerializer {
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let column: &StringColumn = Series::check_get(column)?;
         let values: Vec<&[u8]> = column.iter().collect();
@@ -64,6 +76,7 @@ impl TypeSerializer for StringSerializer {
         &self,
         column: &ColumnRef,
         valids: Option<&Bitmap>,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Value>> {
         let column: &StringColumn = Series::check_get(column)?;
         let mut result: Vec<Value> = Vec::new();
@@ -98,6 +111,7 @@ impl TypeSerializer for StringSerializer {
     fn serialize_json_object_suppress_error(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Option<Value>>> {
         let column: &StringColumn = Series::check_get(column)?;
         let result: Vec<Option<Value>> = column
diff --git a/common/datavalues/src/types/serializations/struct_.rs b/common/datavalues/src/types/serializations/struct_.rs
index fa71936801ceb..e30cc449a2a93 100644
--- a/common/datavalues/src/types/serializations/struct_.rs
+++ b/common/datavalues/src/types/serializations/struct_.rs
@@ -16,6 +16,7 @@ use std::sync::Arc;
 
 use common_exception::ErrorCode;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use itertools::izip;
 use opensrv_clickhouse::types::column::ArcColumnData;
 use opensrv_clickhouse::types::column::TupleColumnData;
@@ -31,7 +32,7 @@ pub struct StructSerializer {
 }
 
 impl TypeSerializer for StructSerializer {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, format: Arc<FormatSettings>) -> Result<String> {
         if let DataValue::Struct(vals) = value {
             let mut res = String::new();
             res.push('(');
@@ -43,7 +44,7 @@ impl TypeSerializer for StructSerializer {
                 }
                 first = false;
 
-                let s = inner.serialize_value(val)?;
+                let s = inner.serialize_value(val, format.clone())?;
                 if typ.data_type_id().is_quoted() {
                     res.push_str(&format!("'{}'", s));
                 } else {
@@ -57,36 +58,40 @@ impl TypeSerializer for StructSerializer {
         }
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &StructColumn = Series::check_get(column)?;
         let mut result = Vec::with_capacity(column.len());
         for i in 0..column.len() {
             let val = column.get(i);
-            let s = self.serialize_value(&val)?;
+            let s = self.serialize_value(&val, format.clone())?;
             result.push(s);
         }
         Ok(result)
     }
 
-    fn serialize_json(&self, _column: &ColumnRef) -> Result<Vec<Value>> {
-        // let column: &StructColumn = Series::check_get(column)?;
-        // let inner_columns = column.values();
-        // let result = self
-        //     .inners
-        //     .iter()
-        //     .zip(inner_columns.iter())
-        //     .map(|(inner, col)| inner.serialize_json(col))
-        //     .collect::<Result<Vec<Vec<Value>>>>()?;
+    fn serialize_json(
+        &self,
+        _column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         todo!()
     }
 
-    fn serialize_clickhouse_format(&self, column: &ColumnRef) -> Result<ArcColumnData> {
+    fn serialize_clickhouse_format(
+        &self,
+        column: &ColumnRef,
+        format: Arc<FormatSettings>,
+    ) -> Result<ArcColumnData> {
         let column: &StructColumn = Series::check_get(column)?;
         let result = self
             .inners
             .iter()
             .zip(column.values().iter())
-            .map(|(inner, col)| inner.serialize_clickhouse_format(col))
+            .map(|(inner, col)| inner.serialize_clickhouse_format(col, format.clone()))
             .collect::<Result<Vec<ArcColumnData>>>()?;
 
         let data = TupleColumnData { inner: result };
diff --git a/common/datavalues/src/types/serializations/timestamp.rs b/common/datavalues/src/types/serializations/timestamp.rs
index 2b132d00f3f2c..9a0c2a052a5c5 100644
--- a/common/datavalues/src/types/serializations/timestamp.rs
+++ b/common/datavalues/src/types/serializations/timestamp.rs
@@ -12,9 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use chrono::DateTime;
 use chrono_tz::Tz;
 use common_exception::*;
+use common_io::prelude::FormatSettings;
 use opensrv_clickhouse::types::column::ArcColumnWrapper;
 use opensrv_clickhouse::types::column::ColumnFrom;
 use serde_json::Value;
@@ -42,13 +45,17 @@ impl TimestampSerializer {
 const TIME_FMT: &str = "%Y-%m-%d %H:%M:%S";
 
 impl TypeSerializer for TimestampSerializer {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, _format: Arc<FormatSettings>) -> Result<String> {
         let value = DFTryFrom::try_from(value.clone())?;
         let dt = self.to_timestamp(&value);
         Ok(dt.format(TIME_FMT).to_string())
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &PrimitiveColumn<i64> = Series::check_get(column)?;
         let result: Vec<String> = column
             .iter()
@@ -60,7 +67,11 @@ impl TypeSerializer for TimestampSerializer {
         Ok(result)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let array: &PrimitiveColumn<i64> = Series::check_get(column)?;
         let result: Vec<Value> = array
             .iter()
@@ -75,6 +86,7 @@ impl TypeSerializer for TimestampSerializer {
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let array: &PrimitiveColumn<i64> = Series::check_get(column)?;
         let values: Vec<DateTime<Tz>> = array.iter().map(|v| self.to_timestamp(v)).collect();
diff --git a/common/datavalues/src/types/serializations/variant.rs b/common/datavalues/src/types/serializations/variant.rs
index aaa4be3ada9ec..bc900f7320439 100644
--- a/common/datavalues/src/types/serializations/variant.rs
+++ b/common/datavalues/src/types/serializations/variant.rs
@@ -12,9 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use common_arrow::arrow::bitmap::Bitmap;
 use common_exception::ErrorCode;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use opensrv_clickhouse::types::column::ArcColumnWrapper;
 use opensrv_clickhouse::types::column::ColumnFrom;
 use serde_json;
@@ -26,7 +29,7 @@ use crate::prelude::*;
 pub struct VariantSerializer {}
 
 impl TypeSerializer for VariantSerializer {
-    fn serialize_value(&self, value: &DataValue) -> Result<String> {
+    fn serialize_value(&self, value: &DataValue, _format: Arc<FormatSettings>) -> Result<String> {
         if let DataValue::Variant(v) = value {
             Ok(v.to_string())
         } else {
@@ -34,13 +37,21 @@ impl TypeSerializer for VariantSerializer {
         }
     }
 
-    fn serialize_column(&self, column: &ColumnRef) -> Result<Vec<String>> {
+    fn serialize_column(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<String>> {
         let column: &VariantColumn = Series::check_get(column)?;
         let result: Vec<String> = column.iter().map(|v| v.to_string()).collect();
         Ok(result)
     }
 
-    fn serialize_json(&self, column: &ColumnRef) -> Result<Vec<Value>> {
+    fn serialize_json(
+        &self,
+        column: &ColumnRef,
+        _format: Arc<FormatSettings>,
+    ) -> Result<Vec<Value>> {
         let column: &VariantColumn = Series::check_get(column)?;
         let result: Vec<Value> = column.iter().map(|v| v.as_ref().to_owned()).collect();
         Ok(result)
@@ -49,6 +60,7 @@ impl TypeSerializer for VariantSerializer {
     fn serialize_clickhouse_format(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<opensrv_clickhouse::types::column::ArcColumnData> {
         let column: &VariantColumn = Series::check_get(column)?;
         let values: Vec<String> = column.iter().map(|v| v.to_string()).collect();
@@ -60,6 +72,7 @@ impl TypeSerializer for VariantSerializer {
         &self,
         column: &ColumnRef,
         valids: Option<&Bitmap>,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Value>> {
         let column: &VariantColumn = Series::check_get(column)?;
         let mut result: Vec<Value> = Vec::new();
@@ -89,6 +102,7 @@ impl TypeSerializer for VariantSerializer {
     fn serialize_json_object_suppress_error(
         &self,
         column: &ColumnRef,
+        _format: Arc<FormatSettings>,
     ) -> Result<Vec<Option<Value>>> {
         let column: &VariantColumn = Series::check_get(column)?;
         let result: Vec<Option<Value>> = column
diff --git a/common/datavalues/tests/it/types/serializations.rs b/common/datavalues/tests/it/types/serializations.rs
index 23d8c04102e5c..bc0d54db7d771 100644
--- a/common/datavalues/tests/it/types/serializations.rs
+++ b/common/datavalues/tests/it/types/serializations.rs
@@ -16,6 +16,7 @@ use std::sync::Arc;
 
 use common_datavalues::prelude::*;
 use common_exception::Result;
+use common_io::prelude::FormatSettings;
 use pretty_assertions::assert_eq;
 use serde_json::json;
 
@@ -144,12 +145,13 @@ fn test_serializers() -> Result<()> {
         },
     ];
 
+    let format = Arc::new(FormatSettings::default());
     for test in tests {
         let serializer = test.data_type.create_serializer();
-        let val_res = serializer.serialize_value(&test.value)?;
+        let val_res = serializer.serialize_value(&test.value, format.clone())?;
         assert_eq!(&val_res, test.val_str, "case: {:#?}", test.name);
 
-        let col_res = serializer.serialize_column(&test.column)?;
+        let col_res = serializer.serialize_column(&test.column, format.clone())?;
         assert_eq!(col_res, test.col_str, "case: {:#?}", test.name);
     }
 
@@ -175,7 +177,7 @@ fn test_serializers() -> Result<()> {
             DataValue::Boolean(true),
             DataValue::UInt64(18869),
         ]);
-        let result = serializer.serialize_value(&value)?;
+        let result = serializer.serialize_value(&value, format.clone())?;
         let expect = "(1.2, 'hello', 1, '2021-08-30')";
         assert_eq!(&result, expect);
     }
diff --git a/common/io/src/format_settings.rs b/common/io/src/format_settings.rs
index 39d04a86d77d9..583651d9d9ae4 100644
--- a/common/io/src/format_settings.rs
+++ b/common/io/src/format_settings.rs
@@ -26,6 +26,7 @@ pub struct FormatSettings {
     pub empty_as_default: bool,
     pub skip_header: bool,
     pub compression: Compression,
+    pub timezone: Vec<u8>,
 }
 
 impl Default for FormatSettings {
@@ -36,6 +37,7 @@ impl Default for FormatSettings {
             empty_as_default: false,
             skip_header: false,
             compression: Compression::None,
+            timezone: vec![b'U', b'T', b'C'],
         }
     }
 }