fix: api crate (#708)

* fix: rename ConcreteDataType::timestamp_millis_type to ConcreteDataType::timestamp_millisecond_type. fix other warnings regarding timestamp * fix: revert changes in datatypes2 * fix: helper
2025-12-25 23:49:58 +00:00 · 2022-12-06 14:56:59 +08:00
parent 3c0adb00f3
commit b48ae21b71
31 changed files with 221 additions and 77 deletions
--- 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;
 }
--- 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;
--- 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,
        ),
    ];
--- 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()
        );

--- 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(
--- 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)
+        }
    }
 }

--- 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)
+        }
    }
 }

--- 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 {
--- 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),
        ];
--- 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(
--- 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")
--- 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();
--- 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!(
--- 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();
--- 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()
--- 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())
            }
--- 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.
--- 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)),
        );
    }
--- 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};
--- 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());
--- 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
--- 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,
        ),
    ];
--- 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),
--- 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()
        {
--- 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()
--- 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())
--- 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(),
        }
    }
 }
--- 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)
--- 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 {
--- 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)
--- 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();