diff --git a/src/api/greptime/v1/column.proto b/src/api/greptime/v1/column.proto
index ec6993abe9..6f5692747e 100644
--- a/src/api/greptime/v1/column.proto
+++ b/src/api/greptime/v1/column.proto
@@ -32,7 +32,10 @@ message Column {
 
     repeated int32 date_values = 14;
     repeated int64 datetime_values = 15;
-    repeated int64 ts_millis_values = 16;
+    repeated int64 ts_second_values = 16;
+    repeated int64 ts_millisecond_values = 17;
+    repeated int64 ts_microsecond_values = 18;
+    repeated int64 ts_nanosecond_values = 19;
   }
   // The array of non-null values in this column.
   //
@@ -75,5 +78,8 @@ enum ColumnDataType {
   STRING = 12;
   DATE = 13;
   DATETIME = 14;
-  TIMESTAMP = 15;
+  TIMESTAMP_SECOND = 15;
+  TIMESTAMP_MILLISECOND = 16;
+  TIMESTAMP_MICROSECOND = 17;
+  TIMESTAMP_NANOSECOND = 18;
 }
diff --git a/src/api/src/helper.rs b/src/api/src/helper.rs
index cdcf704c8d..54ead5a6f7 100644
--- a/src/api/src/helper.rs
+++ b/src/api/src/helper.rs
@@ -15,6 +15,7 @@
 use common_base::BitVec;
 use common_time::timestamp::TimeUnit;
 use datatypes::prelude::ConcreteDataType;
+use datatypes::types::TimestampType;
 use datatypes::value::Value;
 use datatypes::vectors::VectorRef;
 use snafu::prelude::*;
@@ -56,7 +57,16 @@ impl From<ColumnDataTypeWrapper> for ConcreteDataType {
             ColumnDataType::String => ConcreteDataType::string_datatype(),
             ColumnDataType::Date => ConcreteDataType::date_datatype(),
             ColumnDataType::Datetime => ConcreteDataType::datetime_datatype(),
-            ColumnDataType::Timestamp => ConcreteDataType::timestamp_millis_datatype(),
+            ColumnDataType::TimestampSecond => ConcreteDataType::timestamp_second_datatype(),
+            ColumnDataType::TimestampMillisecond => {
+                ConcreteDataType::timestamp_millisecond_datatype()
+            }
+            ColumnDataType::TimestampMicrosecond => {
+                ConcreteDataType::timestamp_microsecond_datatype()
+            }
+            ColumnDataType::TimestampNanosecond => {
+                ConcreteDataType::timestamp_nanosecond_datatype()
+            }
         }
     }
 }
@@ -81,7 +91,12 @@ impl TryFrom<ConcreteDataType> for ColumnDataTypeWrapper {
             ConcreteDataType::String(_) => ColumnDataType::String,
             ConcreteDataType::Date(_) => ColumnDataType::Date,
             ConcreteDataType::DateTime(_) => ColumnDataType::Datetime,
-            ConcreteDataType::Timestamp(_) => ColumnDataType::Timestamp,
+            ConcreteDataType::Timestamp(unit) => match unit {
+                TimestampType::Second(_) => ColumnDataType::TimestampSecond,
+                TimestampType::Millisecond(_) => ColumnDataType::TimestampMillisecond,
+                TimestampType::Microsecond(_) => ColumnDataType::TimestampMicrosecond,
+                TimestampType::Nanosecond(_) => ColumnDataType::TimestampNanosecond,
+            },
             ConcreteDataType::Null(_) | ConcreteDataType::List(_) => {
                 return error::IntoColumnDataTypeSnafu { from: datatype }.fail()
             }
@@ -153,8 +168,20 @@ impl Values {
                 datetime_values: Vec::with_capacity(capacity),
                 ..Default::default()
             },
-            ColumnDataType::Timestamp => Values {
-                ts_millis_values: Vec::with_capacity(capacity),
+            ColumnDataType::TimestampSecond => Values {
+                ts_second_values: Vec::with_capacity(capacity),
+                ..Default::default()
+            },
+            ColumnDataType::TimestampMillisecond => Values {
+                ts_millisecond_values: Vec::with_capacity(capacity),
+                ..Default::default()
+            },
+            ColumnDataType::TimestampMicrosecond => Values {
+                ts_microsecond_values: Vec::with_capacity(capacity),
+                ..Default::default()
+            },
+            ColumnDataType::TimestampNanosecond => Values {
+                ts_nanosecond_values: Vec::with_capacity(capacity),
                 ..Default::default()
             },
         }
@@ -187,9 +214,12 @@ impl Column {
             Value::Binary(val) => values.binary_values.push(val.to_vec()),
             Value::Date(val) => values.date_values.push(val.val()),
             Value::DateTime(val) => values.datetime_values.push(val.val()),
-            Value::Timestamp(val) => values
-                .ts_millis_values
-                .push(val.convert_to(TimeUnit::Millisecond)),
+            Value::Timestamp(val) => match val.unit() {
+                TimeUnit::Second => values.ts_second_values.push(val.value()),
+                TimeUnit::Millisecond => values.ts_millisecond_values.push(val.value()),
+                TimeUnit::Microsecond => values.ts_microsecond_values.push(val.value()),
+                TimeUnit::Nanosecond => values.ts_nanosecond_values.push(val.value()),
+            },
             Value::List(_) => unreachable!(),
         });
         self.null_mask = null_mask.into_vec();
@@ -200,7 +230,10 @@ impl Column {
 mod tests {
     use std::sync::Arc;
 
-    use datatypes::vectors::BooleanVector;
+    use datatypes::vectors::{
+        BooleanVector, TimestampMicrosecondVector, TimestampMillisecondVector,
+        TimestampNanosecondVector, TimestampSecondVector,
+    };
 
     use super::*;
 
@@ -258,8 +291,8 @@ mod tests {
         let values = values.datetime_values;
         assert_eq!(2, values.capacity());
 
-        let values = Values::with_capacity(ColumnDataType::Timestamp, 2);
-        let values = values.ts_millis_values;
+        let values = Values::with_capacity(ColumnDataType::TimestampMillisecond, 2);
+        let values = values.ts_millisecond_values;
         assert_eq!(2, values.capacity());
     }
 
@@ -326,8 +359,8 @@ mod tests {
             ColumnDataTypeWrapper(ColumnDataType::Datetime).into()
         );
         assert_eq!(
-            ConcreteDataType::timestamp_millis_datatype(),
-            ColumnDataTypeWrapper(ColumnDataType::Timestamp).into()
+            ConcreteDataType::timestamp_millisecond_datatype(),
+            ColumnDataTypeWrapper(ColumnDataType::TimestampMillisecond).into()
         );
     }
 
@@ -394,8 +427,8 @@ mod tests {
             ConcreteDataType::datetime_datatype().try_into().unwrap()
         );
         assert_eq!(
-            ColumnDataTypeWrapper(ColumnDataType::Timestamp),
-            ConcreteDataType::timestamp_millis_datatype()
+            ColumnDataTypeWrapper(ColumnDataType::TimestampMillisecond),
+            ConcreteDataType::timestamp_millisecond_datatype()
                 .try_into()
                 .unwrap()
         );
@@ -416,6 +449,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_column_put_timestamp_values() {
+        let mut column = Column {
+            column_name: "test".to_string(),
+            semantic_type: 0,
+            values: Some(Values {
+                ..Default::default()
+            }),
+            null_mask: vec![],
+            datatype: 0,
+        };
+
+        let vector = Arc::new(TimestampNanosecondVector::from_vec(vec![1, 2, 3]));
+        column.push_vals(3, vector);
+        assert_eq!(
+            vec![1, 2, 3],
+            column.values.as_ref().unwrap().ts_nanosecond_values
+        );
+
+        let vector = Arc::new(TimestampMillisecondVector::from_vec(vec![4, 5, 6]));
+        column.push_vals(3, vector);
+        assert_eq!(
+            vec![4, 5, 6],
+            column.values.as_ref().unwrap().ts_millisecond_values
+        );
+
+        let vector = Arc::new(TimestampMicrosecondVector::from_vec(vec![7, 8, 9]));
+        column.push_vals(3, vector);
+        assert_eq!(
+            vec![7, 8, 9],
+            column.values.as_ref().unwrap().ts_microsecond_values
+        );
+
+        let vector = Arc::new(TimestampSecondVector::from_vec(vec![10, 11, 12]));
+        column.push_vals(3, vector);
+        assert_eq!(
+            vec![10, 11, 12],
+            column.values.as_ref().unwrap().ts_second_values
+        );
+    }
+
     #[test]
     fn test_column_put_vector() {
         use crate::v1::column::SemanticType;
diff --git a/src/catalog/src/system.rs b/src/catalog/src/system.rs
index b6555b9353..fa02e5f58b 100644
--- a/src/catalog/src/system.rs
+++ b/src/catalog/src/system.rs
@@ -161,7 +161,7 @@ fn build_system_catalog_schema() -> Schema {
         ),
         ColumnSchema::new(
             "timestamp".to_string(),
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             false,
         )
         .with_time_index(true),
@@ -172,12 +172,12 @@ fn build_system_catalog_schema() -> Schema {
         ),
         ColumnSchema::new(
             "gmt_created".to_string(),
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             false,
         ),
         ColumnSchema::new(
             "gmt_modified".to_string(),
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             false,
         ),
     ];
diff --git a/src/common/function/src/scalars/timestamp/from_unixtime.rs b/src/common/function/src/scalars/timestamp/from_unixtime.rs
index 4462672c8c..ab8197d61b 100644
--- a/src/common/function/src/scalars/timestamp/from_unixtime.rs
+++ b/src/common/function/src/scalars/timestamp/from_unixtime.rs
@@ -40,7 +40,7 @@ impl Function for FromUnixtimeFunction {
     }
 
     fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
-        Ok(ConcreteDataType::timestamp_millis_datatype())
+        Ok(ConcreteDataType::timestamp_millisecond_datatype())
     }
 
     fn signature(&self) -> Signature {
@@ -96,7 +96,7 @@ mod tests {
         let f = FromUnixtimeFunction::default();
         assert_eq!("from_unixtime", f.name());
         assert_eq!(
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             f.return_type(&[]).unwrap()
         );
 
diff --git a/src/common/grpc-expr/src/insert.rs b/src/common/grpc-expr/src/insert.rs
index d7687d0789..3f67b192e6 100644
--- a/src/common/grpc-expr/src/insert.rs
+++ b/src/common/grpc-expr/src/insert.rs
@@ -543,7 +543,7 @@ mod tests {
         );
 
         assert_eq!(
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             ConcreteDataType::from(
                 ColumnDataTypeWrapper::try_new(
                     column_defs
@@ -675,8 +675,12 @@ mod tests {
                 ColumnSchema::new("host", ConcreteDataType::string_datatype(), false),
                 ColumnSchema::new("cpu", ConcreteDataType::float64_datatype(), true),
                 ColumnSchema::new("memory", ConcreteDataType::float64_datatype(), true),
-                ColumnSchema::new("ts", ConcreteDataType::timestamp_millis_datatype(), true)
-                    .with_time_index(true),
+                ColumnSchema::new(
+                    "ts",
+                    ConcreteDataType::timestamp_millisecond_datatype(),
+                    true,
+                )
+                .with_time_index(true),
             ];
 
             Arc::new(
diff --git a/src/common/time/src/date.rs b/src/common/time/src/date.rs
index 30e4529063..09c53ef3df 100644
--- a/src/common/time/src/date.rs
+++ b/src/common/time/src/date.rs
@@ -55,8 +55,11 @@ impl From<i32> for Date {
 impl Display for Date {
     /// [Date] is formatted according to ISO-8601 standard.
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let abs_date = NaiveDate::from_num_days_from_ce(UNIX_EPOCH_FROM_CE + self.0);
-        f.write_str(&abs_date.format("%F").to_string())
+        if let Some(abs_date) = NaiveDate::from_num_days_from_ce_opt(UNIX_EPOCH_FROM_CE + self.0) {
+            write!(f, "{}", abs_date.format("%F").to_string())
+        } else {
+            write!(f, "Date({})", self.0)
+        }
     }
 }
 
diff --git a/src/common/time/src/datetime.rs b/src/common/time/src/datetime.rs
index 4055a07429..73d465babe 100644
--- a/src/common/time/src/datetime.rs
+++ b/src/common/time/src/datetime.rs
@@ -31,8 +31,11 @@ pub struct DateTime(i64);
 
 impl Display for DateTime {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let abs_time = NaiveDateTime::from_timestamp(self.0, 0);
-        write!(f, "{}", abs_time.format(DATETIME_FORMAT))
+        if let Some(abs_time) = NaiveDateTime::from_timestamp_opt(self.0, 0) {
+            write!(f, "{}", abs_time.format(DATETIME_FORMAT))
+        } else {
+            write!(f, "DateTime({})", self.0)
+        }
     }
 }
 
diff --git a/src/common/time/src/timestamp.rs b/src/common/time/src/timestamp.rs
index 5ff20f702b..991b07e2ea 100644
--- a/src/common/time/src/timestamp.rs
+++ b/src/common/time/src/timestamp.rs
@@ -14,6 +14,7 @@
 
 use core::default::Default;
 use std::cmp::Ordering;
+use std::fmt::{Display, Formatter};
 use std::hash::{Hash, Hasher};
 use std::str::FromStr;
 
@@ -54,6 +55,8 @@ impl Timestamp {
         self.value * self.unit.factor() / unit.factor()
     }
 
+    /// Format timestamp to ISO8601 string. If the timestamp exceeds what chrono timestamp can
+    /// represent, this function simply print the timestamp unit and value in plain string.
     pub fn to_iso8601_string(&self) -> String {
         let nano_factor = TimeUnit::Second.factor() / TimeUnit::Nanosecond.factor();
 
@@ -65,8 +68,11 @@ impl Timestamp {
             nsecs += nano_factor;
         }
 
-        let datetime = Utc.timestamp(secs, nsecs as u32);
-        format!("{}", datetime.format("%Y-%m-%d %H:%M:%S%.f%z"))
+        if let LocalResult::Single(datetime) = Utc.timestamp_opt(secs, nsecs as u32) {
+            format!("{}", datetime.format("%Y-%m-%d %H:%M:%S%.f%z"))
+        } else {
+            format!("[Timestamp{}: {}]", self.unit, self.value)
+        }
     }
 }
 
@@ -168,6 +174,25 @@ pub enum TimeUnit {
     Nanosecond,
 }
 
+impl Display for TimeUnit {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TimeUnit::Second => {
+                write!(f, "Second")
+            }
+            TimeUnit::Millisecond => {
+                write!(f, "Millisecond")
+            }
+            TimeUnit::Microsecond => {
+                write!(f, "Microsecond")
+            }
+            TimeUnit::Nanosecond => {
+                write!(f, "Nanosecond")
+            }
+        }
+    }
+}
+
 impl TimeUnit {
     pub fn factor(&self) -> i64 {
         match self {
diff --git a/src/datanode/src/server/grpc/ddl.rs b/src/datanode/src/server/grpc/ddl.rs
index 26108eb020..34add925a3 100644
--- a/src/datanode/src/server/grpc/ddl.rs
+++ b/src/datanode/src/server/grpc/ddl.rs
@@ -295,8 +295,12 @@ mod tests {
     fn expected_table_schema() -> SchemaRef {
         let column_schemas = vec![
             ColumnSchema::new("host", ConcreteDataType::string_datatype(), false),
-            ColumnSchema::new("ts", ConcreteDataType::timestamp_millis_datatype(), false)
-                .with_time_index(true),
+            ColumnSchema::new(
+                "ts",
+                ConcreteDataType::timestamp_millisecond_datatype(),
+                false,
+            )
+            .with_time_index(true),
             ColumnSchema::new("cpu", ConcreteDataType::float32_datatype(), true),
             ColumnSchema::new("memory", ConcreteDataType::float64_datatype(), true),
         ];
diff --git a/src/datanode/src/sql.rs b/src/datanode/src/sql.rs
index 0a3b4a999e..cef3d38b49 100644
--- a/src/datanode/src/sql.rs
+++ b/src/datanode/src/sql.rs
@@ -154,8 +154,12 @@ mod tests {
                 ColumnSchema::new("host", ConcreteDataType::string_datatype(), false),
                 ColumnSchema::new("cpu", ConcreteDataType::float64_datatype(), true),
                 ColumnSchema::new("memory", ConcreteDataType::float64_datatype(), true),
-                ColumnSchema::new("ts", ConcreteDataType::timestamp_millis_datatype(), true)
-                    .with_time_index(true),
+                ColumnSchema::new(
+                    "ts",
+                    ConcreteDataType::timestamp_millisecond_datatype(),
+                    true,
+                )
+                .with_time_index(true),
             ];
 
             Arc::new(
diff --git a/src/datanode/src/sql/create.rs b/src/datanode/src/sql/create.rs
index 8b75bdef3f..ac80338aa8 100644
--- a/src/datanode/src/sql/create.rs
+++ b/src/datanode/src/sql/create.rs
@@ -375,7 +375,7 @@ mod tests {
                 .data_type
         );
         assert_eq!(
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             request
                 .schema
                 .column_schema_by_name("ts")
diff --git a/src/datanode/src/tests/instance_test.rs b/src/datanode/src/tests/instance_test.rs
index b93759b3c7..9112433201 100644
--- a/src/datanode/src/tests/instance_test.rs
+++ b/src/datanode/src/tests/instance_test.rs
@@ -183,7 +183,7 @@ async fn setup_test_instance() -> Instance {
     test_util::create_test_table(
         instance.catalog_manager(),
         instance.sql_handler(),
-        ConcreteDataType::timestamp_millis_datatype(),
+        ConcreteDataType::timestamp_millisecond_datatype(),
     )
     .await
     .unwrap();
@@ -337,7 +337,7 @@ async fn test_execute_show_databases_tables() {
     test_util::create_test_table(
         instance.catalog_manager(),
         instance.sql_handler(),
-        ConcreteDataType::timestamp_millis_datatype(),
+        ConcreteDataType::timestamp_millisecond_datatype(),
     )
     .await
     .unwrap();
@@ -417,7 +417,7 @@ async fn test_alter_table() {
     test_util::create_test_table(
         instance.catalog_manager(),
         instance.sql_handler(),
-        ConcreteDataType::timestamp_millis_datatype(),
+        ConcreteDataType::timestamp_millisecond_datatype(),
     )
     .await
     .unwrap();
diff --git a/src/datatypes2/src/data_type.rs b/src/datatypes2/src/data_type.rs
index e14a3d8e84..e35c3f288f 100644
--- a/src/datatypes2/src/data_type.rs
+++ b/src/datatypes2/src/data_type.rs
@@ -345,7 +345,7 @@ mod tests {
     #[test]
     fn test_from_arrow_timestamp() {
         assert_eq!(
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             ConcreteDataType::from_arrow_time_unit(&arrow::datatypes::TimeUnit::Millisecond)
         );
         assert_eq!(
diff --git a/src/datatypes2/src/schema/constraint.rs b/src/datatypes2/src/schema/constraint.rs
index 3750fcebcf..3a86c6dc6e 100644
--- a/src/datatypes2/src/schema/constraint.rs
+++ b/src/datatypes2/src/schema/constraint.rs
@@ -217,7 +217,7 @@ mod tests {
     fn test_validate_function_constraint() {
         let constraint = ColumnDefaultConstraint::Function(CURRENT_TIMESTAMP.to_string());
         constraint
-            .validate(&ConcreteDataType::timestamp_millis_datatype(), false)
+            .validate(&ConcreteDataType::timestamp_millisecond_datatype(), false)
             .unwrap();
         constraint
             .validate(&ConcreteDataType::boolean_datatype(), false)
@@ -225,7 +225,7 @@ mod tests {
 
         let constraint = ColumnDefaultConstraint::Function("hello()".to_string());
         constraint
-            .validate(&ConcreteDataType::timestamp_millis_datatype(), false)
+            .validate(&ConcreteDataType::timestamp_millisecond_datatype(), false)
             .unwrap_err();
     }
 
@@ -262,7 +262,7 @@ mod tests {
     fn test_create_default_vector_by_func() {
         let constraint = ColumnDefaultConstraint::Function(CURRENT_TIMESTAMP.to_string());
         // Timestamp type.
-        let data_type = ConcreteDataType::timestamp_millis_datatype();
+        let data_type = ConcreteDataType::timestamp_millisecond_datatype();
         let v = constraint
             .create_default_vector(&data_type, false, 4)
             .unwrap();
@@ -286,7 +286,7 @@ mod tests {
         );
 
         let constraint = ColumnDefaultConstraint::Function("no".to_string());
-        let data_type = ConcreteDataType::timestamp_millis_datatype();
+        let data_type = ConcreteDataType::timestamp_millisecond_datatype();
         constraint
             .create_default_vector(&data_type, false, 4)
             .unwrap_err();
diff --git a/src/datatypes2/src/schema/raw.rs b/src/datatypes2/src/schema/raw.rs
index f415a1ab85..7c68d9be07 100644
--- a/src/datatypes2/src/schema/raw.rs
+++ b/src/datatypes2/src/schema/raw.rs
@@ -56,8 +56,12 @@ mod tests {
     fn test_raw_convert() {
         let column_schemas = vec![
             ColumnSchema::new("col1", ConcreteDataType::int32_datatype(), true),
-            ColumnSchema::new("ts", ConcreteDataType::timestamp_millis_datatype(), false)
-                .with_time_index(true),
+            ColumnSchema::new(
+                "ts",
+                ConcreteDataType::timestamp_millisecond_datatype(),
+                false,
+            )
+            .with_time_index(true),
         ];
         let schema = SchemaBuilder::try_from(column_schemas)
             .unwrap()
diff --git a/src/datatypes2/src/type_id.rs b/src/datatypes2/src/type_id.rs
index fa11430dec..6f9ee88f78 100644
--- a/src/datatypes2/src/type_id.rs
+++ b/src/datatypes2/src/type_id.rs
@@ -74,7 +74,7 @@ impl LogicalTypeId {
             LogicalTypeId::Binary => ConcreteDataType::binary_datatype(),
             LogicalTypeId::Date => ConcreteDataType::date_datatype(),
             LogicalTypeId::DateTime => ConcreteDataType::datetime_datatype(),
-            LogicalTypeId::Timestamp => ConcreteDataType::timestamp_millis_datatype(), // to timestamp type with default time unit
+            LogicalTypeId::Timestamp => ConcreteDataType::timestamp_millisecond_datatype(), // to timestamp type with default time unit
             LogicalTypeId::List => {
                 ConcreteDataType::list_datatype(ConcreteDataType::null_datatype())
             }
diff --git a/src/datatypes2/src/types/timestamp.rs b/src/datatypes2/src/types/timestamp.rs
index b80d16a64f..23024ca57a 100644
--- a/src/datatypes2/src/types/timestamp.rs
+++ b/src/datatypes2/src/types/timestamp.rs
@@ -116,7 +116,10 @@ mod tests {
             .push_value_ref(ValueRef::Timestamp(Timestamp::new(96, TimeUnit::Second)))
             .unwrap();
         let v = builder.to_vector();
-        assert_eq!(ConcreteDataType::timestamp_millis_datatype(), v.data_type());
+        assert_eq!(
+            ConcreteDataType::timestamp_millisecond_datatype(),
+            v.data_type()
+        );
         assert_eq!(Value::Timestamp(Timestamp::from_millis(42)), v.get(0));
         assert_eq!(Value::Null, v.get(1));
         // Push a timestamp with different unit will convert the value to value with time unit millisecond.
diff --git a/src/datatypes2/src/value.rs b/src/datatypes2/src/value.rs
index d5e0ae3e9f..2c5494b73a 100644
--- a/src/datatypes2/src/value.rs
+++ b/src/datatypes2/src/value.rs
@@ -989,7 +989,7 @@ mod tests {
             &Value::DateTime(DateTime::new(1)),
         );
         check_type_and_value(
-            &ConcreteDataType::timestamp_millis_datatype(),
+            &ConcreteDataType::timestamp_millisecond_datatype(),
             &Value::Timestamp(Timestamp::from_millis(1)),
         );
     }
diff --git a/src/datatypes2/src/vectors/binary.rs b/src/datatypes2/src/vectors/binary.rs
index 7be3dc6a8e..c9b4df625c 100644
--- a/src/datatypes2/src/vectors/binary.rs
+++ b/src/datatypes2/src/vectors/binary.rs
@@ -15,8 +15,7 @@
 use std::any::Any;
 use std::sync::Arc;
 
-use arrow::array::{Array, ArrayRef};
-use arrow::array::{ArrayIter, GenericByteArray};
+use arrow::array::{Array, ArrayIter, ArrayRef, GenericByteArray};
 use snafu::{OptionExt, ResultExt};
 
 use crate::arrow_array::{BinaryArray, MutableBinaryArray};
diff --git a/src/datatypes2/src/vectors/timestamp.rs b/src/datatypes2/src/vectors/timestamp.rs
index 62b8332c89..0ac3dd0f97 100644
--- a/src/datatypes2/src/vectors/timestamp.rs
+++ b/src/datatypes2/src/vectors/timestamp.rs
@@ -192,7 +192,7 @@ pub struct TimestampVectorBuilder {
 
 impl MutableVector for TimestampVectorBuilder {
     fn data_type(&self) -> ConcreteDataType {
-        ConcreteDataType::timestamp_millis_datatype()
+        ConcreteDataType::timestamp_millisecond_datatype()
     }
 
     fn len(&self) -> usize {
@@ -283,7 +283,7 @@ mod tests {
 
         let vector = builder.finish();
         assert_eq!(
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             vector.data_type()
         );
         assert_eq!(3, vector.len());
diff --git a/src/frontend/src/table/insert.rs b/src/frontend/src/table/insert.rs
index 409632474f..f656776db5 100644
--- a/src/frontend/src/table/insert.rs
+++ b/src/frontend/src/table/insert.rs
@@ -107,7 +107,7 @@ pub fn insert_request_to_insert_batch(insert: &InsertRequest) -> Result<(Vec<Col
 
             // TODO(hl): need refactor
             let semantic_type =
-                if vector.data_type() == ConcreteDataType::timestamp_millis_datatype() {
+                if vector.data_type() == ConcreteDataType::timestamp_millisecond_datatype() {
                     SemanticType::Timestamp
                 } else {
                     SemanticType::Field
diff --git a/src/script/src/table.rs b/src/script/src/table.rs
index abc0279a3f..1504d737ae 100644
--- a/src/script/src/table.rs
+++ b/src/script/src/table.rs
@@ -216,18 +216,18 @@ fn build_scripts_schema() -> Schema {
         ),
         ColumnSchema::new(
             "timestamp".to_string(),
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             false,
         )
         .with_time_index(true),
         ColumnSchema::new(
             "gmt_created".to_string(),
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             false,
         ),
         ColumnSchema::new(
             "gmt_modified".to_string(),
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
             false,
         ),
     ];
diff --git a/src/servers/src/postgres/handler.rs b/src/servers/src/postgres/handler.rs
index 6cf82465a0..4417461dca 100644
--- a/src/servers/src/postgres/handler.rs
+++ b/src/servers/src/postgres/handler.rs
@@ -239,7 +239,7 @@ mod test {
             ColumnSchema::new("strings", ConcreteDataType::string_datatype(), true),
             ColumnSchema::new(
                 "timestamps",
-                ConcreteDataType::timestamp_millis_datatype(),
+                ConcreteDataType::timestamp_millisecond_datatype(),
                 true,
             ),
             ColumnSchema::new("dates", ConcreteDataType::date_datatype(), true),
diff --git a/src/sql/src/statements.rs b/src/sql/src/statements.rs
index bcdc099265..183bafb671 100644
--- a/src/sql/src/statements.rs
+++ b/src/sql/src/statements.rs
@@ -315,7 +315,7 @@ pub fn sql_data_type_to_concrete_data_type(data_type: &SqlDataType) -> Result<Co
             }
             .fail(),
         },
-        SqlDataType::Timestamp => Ok(ConcreteDataType::timestamp_millis_datatype()),
+        SqlDataType::Timestamp => Ok(ConcreteDataType::timestamp_millisecond_datatype()),
         _ => error::SqlTypeNotSupportedSnafu {
             t: data_type.clone(),
         }
@@ -374,7 +374,7 @@ mod tests {
         );
         check_type(
             SqlDataType::Timestamp,
-            ConcreteDataType::timestamp_millis_datatype(),
+            ConcreteDataType::timestamp_millisecond_datatype(),
         );
     }
 
@@ -471,7 +471,7 @@ mod tests {
         match parse_string_to_value(
             "timestamp_col",
             "2022-02-22T00:01:01+08:00".to_string(),
-            &ConcreteDataType::timestamp_millis_datatype(),
+            &ConcreteDataType::timestamp_millisecond_datatype(),
         )
         .unwrap()
         {
diff --git a/src/storage/benches/memtable/util/regiondesc_util.rs b/src/storage/benches/memtable/util/regiondesc_util.rs
index 51dcb8795a..e8f71c71bd 100644
--- a/src/storage/benches/memtable/util/regiondesc_util.rs
+++ b/src/storage/benches/memtable/util/regiondesc_util.rs
@@ -34,7 +34,7 @@ impl RegionDescBuilder {
             ColumnDescriptorBuilder::new(
                 1,
                 TIMESTAMP_NAME,
-                ConcreteDataType::timestamp_millis_datatype(),
+                ConcreteDataType::timestamp_millisecond_datatype(),
             )
             .is_nullable(false)
             .build()
diff --git a/src/storage/src/metadata.rs b/src/storage/src/metadata.rs
index 3808f4f14f..d03940662f 100644
--- a/src/storage/src/metadata.rs
+++ b/src/storage/src/metadata.rs
@@ -1036,12 +1036,15 @@ mod tests {
     }
 
     fn new_metadata(enable_version_column: bool) -> RegionMetadata {
-        let timestamp =
-            ColumnDescriptorBuilder::new(2, "ts", ConcreteDataType::timestamp_millis_datatype())
-                .is_nullable(false)
-                .is_time_index(true)
-                .build()
-                .unwrap();
+        let timestamp = ColumnDescriptorBuilder::new(
+            2,
+            "ts",
+            ConcreteDataType::timestamp_millisecond_datatype(),
+        )
+        .is_nullable(false)
+        .is_time_index(true)
+        .build()
+        .unwrap();
         let row_key = RowKeyDescriptorBuilder::new(timestamp)
             .push_column(
                 ColumnDescriptorBuilder::new(3, "k1", ConcreteDataType::int64_datatype())
diff --git a/src/storage/src/proto/write_batch.rs b/src/storage/src/proto/write_batch.rs
index 7d5ef21aed..3dee810b96 100644
--- a/src/storage/src/proto/write_batch.rs
+++ b/src/storage/src/proto/write_batch.rs
@@ -176,7 +176,7 @@ impl From<DataType> for ConcreteDataType {
             DataType::String => ConcreteDataType::string_datatype(),
             DataType::Binary => ConcreteDataType::binary_datatype(),
             DataType::Null => ConcreteDataType::null_datatype(),
-            DataType::Timestamp => ConcreteDataType::timestamp_millis_datatype(),
+            DataType::Timestamp => ConcreteDataType::timestamp_millisecond_datatype(),
         }
     }
 }
diff --git a/src/storage/src/test_util/descriptor_util.rs b/src/storage/src/test_util/descriptor_util.rs
index 50c8c2613e..10d682745b 100644
--- a/src/storage/src/test_util/descriptor_util.rs
+++ b/src/storage/src/test_util/descriptor_util.rs
@@ -37,7 +37,7 @@ impl RegionDescBuilder {
             ColumnDescriptorBuilder::new(
                 1,
                 test_util::TIMESTAMP_NAME,
-                ConcreteDataType::timestamp_millis_datatype(),
+                ConcreteDataType::timestamp_millisecond_datatype(),
             )
             .is_nullable(false)
             .is_time_index(true)
diff --git a/src/storage/src/write_batch/compat.rs b/src/storage/src/write_batch/compat.rs
index dcd9d155c3..e72ece66e8 100644
--- a/src/storage/src/write_batch/compat.rs
+++ b/src/storage/src/write_batch/compat.rs
@@ -110,8 +110,12 @@ mod tests {
     ) -> SchemaBuilder {
         let mut column_schemas = vec![
             ColumnSchema::new("k0", ConcreteDataType::int32_datatype(), false),
-            ColumnSchema::new("ts", ConcreteDataType::timestamp_millis_datatype(), false)
-                .with_time_index(true),
+            ColumnSchema::new(
+                "ts",
+                ConcreteDataType::timestamp_millisecond_datatype(),
+                false,
+            )
+            .with_time_index(true),
         ];
 
         if let Some(v0_constraint) = v0_constraint {
diff --git a/src/table/src/metadata.rs b/src/table/src/metadata.rs
index 3fb367589e..ea77e39199 100644
--- a/src/table/src/metadata.rs
+++ b/src/table/src/metadata.rs
@@ -482,8 +482,12 @@ mod tests {
     fn new_test_schema() -> Schema {
         let column_schemas = vec![
             ColumnSchema::new("col1", ConcreteDataType::int32_datatype(), true),
-            ColumnSchema::new("ts", ConcreteDataType::timestamp_millis_datatype(), false)
-                .with_time_index(true),
+            ColumnSchema::new(
+                "ts",
+                ConcreteDataType::timestamp_millisecond_datatype(),
+                false,
+            )
+            .with_time_index(true),
             ColumnSchema::new("col2", ConcreteDataType::int32_datatype(), true),
         ];
         SchemaBuilder::try_from(column_schemas)
@@ -606,8 +610,12 @@ mod tests {
             ColumnSchema::new("col1", ConcreteDataType::int32_datatype(), true),
             ColumnSchema::new("col2", ConcreteDataType::int32_datatype(), true),
             ColumnSchema::new("col3", ConcreteDataType::int32_datatype(), true),
-            ColumnSchema::new("ts", ConcreteDataType::timestamp_millis_datatype(), false)
-                .with_time_index(true),
+            ColumnSchema::new(
+                "ts",
+                ConcreteDataType::timestamp_millisecond_datatype(),
+                false,
+            )
+            .with_time_index(true),
         ];
         let schema = Arc::new(
             SchemaBuilder::try_from(column_schemas)
diff --git a/tests-integration/src/test_util.rs b/tests-integration/src/test_util.rs
index 70a3355f3d..fb26682082 100644
--- a/tests-integration/src/test_util.rs
+++ b/tests-integration/src/test_util.rs
@@ -229,7 +229,7 @@ pub async fn setup_test_app(store_type: StorageType, name: &str) -> (Router, Tes
     create_test_table(
         instance.catalog_manager(),
         instance.sql_handler(),
-        ConcreteDataType::timestamp_millis_datatype(),
+        ConcreteDataType::timestamp_millisecond_datatype(),
     )
     .await
     .unwrap();
@@ -248,7 +248,7 @@ pub async fn setup_test_app_with_frontend(
     create_test_table(
         frontend.catalog_manager().as_ref().unwrap(),
         instance.sql_handler(),
-        ConcreteDataType::timestamp_millis_datatype(),
+        ConcreteDataType::timestamp_millisecond_datatype(),
     )
     .await
     .unwrap();