Merge pull request #2506 from kuzudb/timestamp

finish adding timestamp_ns/ms/sec/tz datatypes
kuzudb · Dec 2, 2023 · 7e3890b · 7e3890b
2 parents 9b69690 + 6155fd7
commit 7e3890b
Show file tree

Hide file tree

Showing 75 changed files with 2,785 additions and 523 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Kuzu VERSION 0.1.0 LANGUAGES CXX C)
+project(Kuzu VERSION 0.1.0.1 LANGUAGES CXX C)
 
 find_package(Threads REQUIRED)
 

diff --git a/dataset/load-from-test/timestamp/timestamp.csv b/dataset/load-from-test/timestamp/timestamp.csv
@@ -0,0 +1,3 @@
+"1972-07-31 13:22:30.342312432","1972-07-31 13:22:30.342312432","1972-07-31 13:22:30.342312432","1972-07-31 13:22:30.342312432","1972-07-31 13:22:30.342312432", 1972-07-31 13:22:30.342312432,1972-07-31 13:22:30.342312432,1972-07-31 13:22:30.342312432
+NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL
+"1972-07-31 13:22:30","1972-07-31 13:22:30","1972-07-31 13:22:30","1972-07-31 13:22:30","1972-07-31 13:22:30","1972-07-31 13:22:30","1972-07-31 13:22:30","1972-07-31 13:22:30"
diff --git a/dataset/tinysnb/schema.cypher b/dataset/tinysnb/schema.cypher
@@ -1,6 +1,6 @@
 create node table person (ID INt64, fName StRING, gender INT64, isStudent BoOLEAN, isWorker BOOLEAN, age INT64, eyeSight DOUBLE, birthdate DATE, registerTime TIMESTAMP, lastJobDuration interval, workedHours INT64[], usedNames STRING[], courseScoresPerTerm INT64[][], grades INT64[4], height float, PRIMARY KEY (ID));
 create node table organisation (ID INT64, name STRING, orgCode INT64, mark DOUBLE, score INT64, history STRING, licenseValidInterval INTERVAL, rating DOUBLE, state STRUCT(revenue INT16, location STRING[], stock STRUCT(price INT64[], volume INT64)), info UNION(price FLOAT, movein DATE, note STRING),PRIMARY KEY (ID));
-create node table movies (name STRING, length INT32, note STRING, description STRUCT(rating DOUBLE, stars INT8, views INT64, release TIMESTAMP, film DATE, u8 UINT8, u16 UINT16, u32 UINT32, u64 UINT64, hugedata INT128), content BYTEA, audience MAP(STRING, INT64), grade union(credit boolean, grade1 double, grade2 int64), PRIMARY KEY (name));
+create node table movies (name STRING, length INT32, note STRING, description STRUCT(rating DOUBLE, stars INT8, views INT64, release TIMESTAMP, release_ns TIMESTAMP_NS, release_ms TIMESTAMP_MS, release_sec TIMESTAMP_SEC, release_tz TIMESTAMP_TZ, film DATE, u8 UINT8, u16 UINT16, u32 UINT32, u64 UINT64, hugedata INT128), content BYTEA, audience MAP(STRING, INT64), grade union(credit boolean, grade1 double, grade2 int64), PRIMARY KEY (name));
 create rel table knows (FROM person TO person, date DATE, meetTime TIMESTAMP, validInterval INTERVAL, comments STRING[], summary STRUCT(locations STRING[], transfer STRUCT(day DATE, amount INT64[])), notes UNION(firstmet DATE, type INT16, comment STRING), MANY_MANY);
 create rel table studyAt (FROM person TO organisation, year INT64, places STRING[], length INT16, level INT8, code UINT64, temprature UINT32, ulength UINT16, ulevel UINT8, hugedata INT128, MANY_ONE);
 create rel table workAt (FROM person TO organisation, year INT64, grading DOUBLE[2], rating float, MANY_ONE);

diff --git a/dataset/tinysnb/vMovies.csv b/dataset/tinysnb/vMovies.csv
@@ -1,3 +1,3 @@
-Sóló cón tu párejâ,126, this is a very very good movie,"{rating: 5.3, stars:2, views: 152, release: 2011-08-20 11:25:30, film: 2012-05-11, u8: 220, u16: 20, u32: 1, u64: 180, hugedata: 1844674407370955161811111111}","\\xAA\\xABinteresting\\x0B","{audience1= 52,audience53= 42}",true
-The 😂😃🧘🏻‍♂️🌍🌦️🍞🚗 movie,2544, the movie is very very good,"{rating: 7, stars:10, views: 982, release: 2018-11-13 13:33:11, film: 2014-09-12, u8: 12, u16: 120, u32: 55, u64: 1, hugedata: -1844674407370955161511}","\\xAB\\xCD",{audience1= 33},8.989
-Roma,298,the movie is very interesting and funny,"{rating: 1223, stars:100, views: 10003, release: 2011-02-11 16:44:22, film: 2013-02-22, u8: 1, u16: 15, u32: 200, u64: 4, hugedata: -15}","pure ascii characters","{}",254
+Sóló cón tu párejâ,126, this is a very very good movie,"{rating: 5.3, stars:2, views: 152, release: 2011-08-20 11:25:30, release_ns: 2011-08-20 11:25:30.1234567, release_ms: 2011-08-20 11:25:30.1234567, release_sec: 2011-08-20 11:25:30.1234567, release_tz: 2011-08-20 11:25:30.1234567, film: 2012-05-11, u8: 220, u16: 20, u32: 1, u64: 180, hugedata: 1844674407370955161811111111}","\\xAA\\xABinteresting\\x0B","{audience1= 52,audience53= 42}",true
+The 😂😃🧘🏻‍♂️🌍🌦️🍞🚗 movie,2544, the movie is very very good,"{rating: 7, stars:10, views: 982, release: 2018-11-13 13:33:11, release_ns: 2018-11-13 13:33:11.1234567, release_ms: 2018-11-13 13:33:11.1234567, release_sec: 2018-11-13 13:33:11.1234567, release_tz: 2018-11-13 11:33:11.1234567-02, film: 2014-09-12, u8: 12, u16: 120, u32: 55, u64: 1, hugedata: -1844674407370955161511}","\\xAB\\xCD",{audience1= 33},8.989
+Roma,298,the movie is very interesting and funny,"{rating: 1223, stars:100, views: 10003, release: 2011-02-11 16:44:22, release_ns: 2011-02-11 16:44:22.1234567, release_ms: 2011-02-11 16:44:22.1234567, release_sec: 2011-02-11 16:44:22.1234567, release_tz: 2011-02-11 16:44:22.1234567, film: 2013-02-22, u8: 1, u16: 15, u32: 200, u64: 4, hugedata: -15}","pure ascii characters","{}",254
diff --git a/src/binder/bind_expression/bind_subquery_expression.cpp b/src/binder/bind_expression/bind_subquery_expression.cpp
@@ -2,6 +2,7 @@
 #include "binder/expression/function_expression.h"
 #include "binder/expression/subquery_expression.h"
 #include "binder/expression_binder.h"
+#include "common/types/value/value.h"
 #include "parser/expression/parsed_subquery_expression.h"
 
 using namespace kuzu::parser;

diff --git a/src/c_api/prepared_statement.cpp b/src/c_api/prepared_statement.cpp
@@ -118,6 +118,30 @@ void kuzu_prepared_statement_bind_date(
     kuzu_prepared_statement_bind_cpp_value(prepared_statement, param_name, std::move(value_ptr));
 }
 
+void kuzu_prepared_statement_bind_timestamp_ns(kuzu_prepared_statement* prepared_statement,
+    const char* param_name, kuzu_timestamp_ns_t value) {
+    auto value_ptr = std::make_unique<Value>(timestamp_ns_t(value.value));
+    kuzu_prepared_statement_bind_cpp_value(prepared_statement, param_name, std::move(value_ptr));
+}
+
+void kuzu_prepared_statement_bind_timestamp_ms(kuzu_prepared_statement* prepared_statement,
+    const char* param_name, kuzu_timestamp_ms_t value) {
+    auto value_ptr = std::make_unique<Value>(timestamp_ms_t(value.value));
+    kuzu_prepared_statement_bind_cpp_value(prepared_statement, param_name, std::move(value_ptr));
+}
+
+void kuzu_prepared_statement_bind_timestamp_sec(kuzu_prepared_statement* prepared_statement,
+    const char* param_name, kuzu_timestamp_sec_t value) {
+    auto value_ptr = std::make_unique<Value>(timestamp_sec_t(value.value));
+    kuzu_prepared_statement_bind_cpp_value(prepared_statement, param_name, std::move(value_ptr));
+}
+
+void kuzu_prepared_statement_bind_timestamp_tz(kuzu_prepared_statement* prepared_statement,
+    const char* param_name, kuzu_timestamp_tz_t value) {
+    auto value_ptr = std::make_unique<Value>(timestamp_tz_t(value.value));
+    kuzu_prepared_statement_bind_cpp_value(prepared_statement, param_name, std::move(value_ptr));
+}
+
 void kuzu_prepared_statement_bind_timestamp(
     kuzu_prepared_statement* prepared_statement, const char* param_name, kuzu_timestamp_t value) {
     auto value_ptr = std::make_unique<Value>(timestamp_t(value.value));

diff --git a/src/c_api/value.cpp b/src/c_api/value.cpp
@@ -127,6 +127,34 @@ kuzu_value* kuzu_value_create_date(kuzu_date_t val_) {
     return c_value;
 }
 
+kuzu_value* kuzu_value_create_timestamp_ns(kuzu_timestamp_ns_t val_) {
+    auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
+    auto timestamp_ns = timestamp_ns_t(val_.value);
+    c_value->_value = new Value(timestamp_ns);
+    return c_value;
+}
+
+kuzu_value* kuzu_value_create_timestamp_ms(kuzu_timestamp_ms_t val_) {
+    auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
+    auto timestamp_ms = timestamp_ms_t(val_.value);
+    c_value->_value = new Value(timestamp_ms);
+    return c_value;
+}
+
+kuzu_value* kuzu_value_create_timestamp_sec(kuzu_timestamp_sec_t val_) {
+    auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
+    auto timestamp_sec = timestamp_sec_t(val_.value);
+    c_value->_value = new Value(timestamp_sec);
+    return c_value;
+}
+
+kuzu_value* kuzu_value_create_timestamp_tz(kuzu_timestamp_tz_t val_) {
+    auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
+    auto timestamp_tz = timestamp_tz_t(val_.value);
+    c_value->_value = new Value(timestamp_tz);
+    return c_value;
+}
+
 kuzu_value* kuzu_value_create_timestamp(kuzu_timestamp_t val_) {
     auto* c_value = (kuzu_value*)calloc(1, sizeof(kuzu_value));
     auto timestamp = timestamp_t(val_.value);
@@ -315,6 +343,34 @@ kuzu_timestamp_t kuzu_value_get_timestamp(kuzu_value* value) {
     return c_timestamp;
 }
 
+kuzu_timestamp_ns_t kuzu_value_get_timestamp_ns(kuzu_value* value) {
+    auto timestamp_val = static_cast<Value*>(value->_value)->getValue<timestamp_ns_t>();
+    kuzu_timestamp_ns_t c_timestamp;
+    c_timestamp.value = timestamp_val.value;
+    return c_timestamp;
+}
+
+kuzu_timestamp_ms_t kuzu_value_get_timestamp_ms(kuzu_value* value) {
+    auto timestamp_val = static_cast<Value*>(value->_value)->getValue<timestamp_ms_t>();
+    kuzu_timestamp_ms_t c_timestamp;
+    c_timestamp.value = timestamp_val.value;
+    return c_timestamp;
+}
+
+kuzu_timestamp_sec_t kuzu_value_get_timestamp_sec(kuzu_value* value) {
+    auto timestamp_val = static_cast<Value*>(value->_value)->getValue<timestamp_sec_t>();
+    kuzu_timestamp_sec_t c_timestamp;
+    c_timestamp.value = timestamp_val.value;
+    return c_timestamp;
+}
+
+kuzu_timestamp_tz_t kuzu_value_get_timestamp_tz(kuzu_value* value) {
+    auto timestamp_val = static_cast<Value*>(value->_value)->getValue<timestamp_tz_t>();
+    kuzu_timestamp_tz_t c_timestamp;
+    c_timestamp.value = timestamp_val.value;
+    return c_timestamp;
+}
+
 kuzu_interval_t kuzu_value_get_interval(kuzu_value* value) {
     auto interval_val = static_cast<Value*>(value->_value)->getValue<interval_t>();
     kuzu_interval_t c_interval;

diff --git a/src/common/arrow/arrow_converter.cpp b/src/common/arrow/arrow_converter.cpp
@@ -104,6 +104,19 @@ void ArrowConverter::setArrowFormat(
     case LogicalTypeID::DATE: {
         child.format = "tdD";
     } break;
+    case LogicalTypeID::TIMESTAMP_MS: {
+        child.format = "tsm:";
+    } break;
+    case LogicalTypeID::TIMESTAMP_NS: {
+        child.format = "tsn:";
+    } break;
+    case LogicalTypeID::TIMESTAMP_SEC: {
+        child.format = "tss:";
+    } break;
+    case LogicalTypeID::TIMESTAMP_TZ: {
+        auto format = "tsu:UTC";
+        child.format = copyName(rootHolder, format);
+    } break;
     case LogicalTypeID::TIMESTAMP: {
         child.format = "tsu:";
     } break;

diff --git a/src/common/arrow/arrow_row_batch.cpp b/src/common/arrow/arrow_row_batch.cpp
@@ -144,6 +144,18 @@ std::unique_ptr<ArrowVector> ArrowRowBatch::createVector(
     case LogicalTypeID::DATE: {
         templateInitializeVector<LogicalTypeID::DATE>(result.get(), typeInfo, capacity);
     } break;
+    case LogicalTypeID::TIMESTAMP_MS: {
+        templateInitializeVector<LogicalTypeID::TIMESTAMP_MS>(result.get(), typeInfo, capacity);
+    } break;
+    case LogicalTypeID::TIMESTAMP_NS: {
+        templateInitializeVector<LogicalTypeID::TIMESTAMP_NS>(result.get(), typeInfo, capacity);
+    } break;
+    case LogicalTypeID::TIMESTAMP_SEC: {
+        templateInitializeVector<LogicalTypeID::TIMESTAMP_SEC>(result.get(), typeInfo, capacity);
+    } break;
+    case LogicalTypeID::TIMESTAMP_TZ: {
+        templateInitializeVector<LogicalTypeID::TIMESTAMP_TZ>(result.get(), typeInfo, capacity);
+    } break;
     case LogicalTypeID::TIMESTAMP: {
         templateInitializeVector<LogicalTypeID::TIMESTAMP>(result.get(), typeInfo, capacity);
     } break;
@@ -379,6 +391,18 @@ void ArrowRowBatch::copyNonNullValue(
     case LogicalTypeID::TIMESTAMP: {
         templateCopyNonNullValue<LogicalTypeID::TIMESTAMP>(vector, typeInfo, value, pos);
     } break;
+    case LogicalTypeID::TIMESTAMP_TZ: {
+        templateCopyNonNullValue<LogicalTypeID::TIMESTAMP_TZ>(vector, typeInfo, value, pos);
+    } break;
+    case LogicalTypeID::TIMESTAMP_NS: {
+        templateCopyNonNullValue<LogicalTypeID::TIMESTAMP_NS>(vector, typeInfo, value, pos);
+    } break;
+    case LogicalTypeID::TIMESTAMP_MS: {
+        templateCopyNonNullValue<LogicalTypeID::TIMESTAMP_MS>(vector, typeInfo, value, pos);
+    } break;
+    case LogicalTypeID::TIMESTAMP_SEC: {
+        templateCopyNonNullValue<LogicalTypeID::TIMESTAMP_SEC>(vector, typeInfo, value, pos);
+    } break;
     case LogicalTypeID::INTERVAL: {
         templateCopyNonNullValue<LogicalTypeID::INTERVAL>(vector, typeInfo, value, pos);
     } break;
@@ -489,6 +513,18 @@ void ArrowRowBatch::copyNullValue(ArrowVector* vector, Value* value, std::int64_
     case LogicalTypeID::DATE: {
         templateCopyNullValue<LogicalTypeID::DATE>(vector, pos);
     } break;
+    case LogicalTypeID::TIMESTAMP_MS: {
+        templateCopyNullValue<LogicalTypeID::TIMESTAMP_MS>(vector, pos);
+    } break;
+    case LogicalTypeID::TIMESTAMP_NS: {
+        templateCopyNullValue<LogicalTypeID::TIMESTAMP_NS>(vector, pos);
+    } break;
+    case LogicalTypeID::TIMESTAMP_SEC: {
+        templateCopyNullValue<LogicalTypeID::TIMESTAMP_SEC>(vector, pos);
+    } break;
+    case LogicalTypeID::TIMESTAMP_TZ: {
+        templateCopyNullValue<LogicalTypeID::TIMESTAMP_TZ>(vector, pos);
+    } break;
     case LogicalTypeID::TIMESTAMP: {
         templateCopyNullValue<LogicalTypeID::TIMESTAMP>(vector, pos);
     } break;
@@ -673,6 +709,18 @@ ArrowArray* ArrowRowBatch::convertVectorToArray(
     case LogicalTypeID::DATE: {
         return templateCreateArray<LogicalTypeID::DATE>(vector, typeInfo);
     }
+    case LogicalTypeID::TIMESTAMP_MS: {
+        return templateCreateArray<LogicalTypeID::TIMESTAMP_MS>(vector, typeInfo);
+    }
+    case LogicalTypeID::TIMESTAMP_NS: {
+        return templateCreateArray<LogicalTypeID::TIMESTAMP_NS>(vector, typeInfo);
+    }
+    case LogicalTypeID::TIMESTAMP_SEC: {
+        return templateCreateArray<LogicalTypeID::TIMESTAMP_SEC>(vector, typeInfo);
+    }
+    case LogicalTypeID::TIMESTAMP_TZ: {
+        return templateCreateArray<LogicalTypeID::TIMESTAMP_TZ>(vector, typeInfo);
+    }
     case LogicalTypeID::TIMESTAMP: {
         return templateCreateArray<LogicalTypeID::TIMESTAMP>(vector, typeInfo);
     }

diff --git a/src/common/type_utils.cpp b/src/common/type_utils.cpp
@@ -36,6 +36,14 @@ std::string TypeUtils::castValueToString(
         return TypeUtils::toString(*reinterpret_cast<const float_t*>(value));
     case LogicalTypeID::DATE:
         return TypeUtils::toString(*reinterpret_cast<const date_t*>(value));
+    case LogicalTypeID::TIMESTAMP_NS:
+        return TypeUtils::toString(*reinterpret_cast<const timestamp_ns_t*>(value));
+    case LogicalTypeID::TIMESTAMP_MS:
+        return TypeUtils::toString(*reinterpret_cast<const timestamp_ms_t*>(value));
+    case LogicalTypeID::TIMESTAMP_SEC:
+        return TypeUtils::toString(*reinterpret_cast<const timestamp_sec_t*>(value));
+    case LogicalTypeID::TIMESTAMP_TZ:
+        return TypeUtils::toString(*reinterpret_cast<const timestamp_tz_t*>(value));
     case LogicalTypeID::TIMESTAMP:
         return TypeUtils::toString(*reinterpret_cast<const timestamp_t*>(value));
     case LogicalTypeID::INTERVAL:
@@ -73,6 +81,26 @@ std::string TypeUtils::toString(const date_t& val, void* /*valueVector*/) {
     return Date::toString(val);
 }
 
+template<>
+std::string TypeUtils::toString(const timestamp_ns_t& val, void* /*valueVector*/) {
+    return toString(Timestamp::fromEpochNanoSeconds(val.value));
+}
+
+template<>
+std::string TypeUtils::toString(const timestamp_ms_t& val, void* /*valueVector*/) {
+    return toString(Timestamp::fromEpochMilliSeconds(val.value));
+}
+
+template<>
+std::string TypeUtils::toString(const timestamp_sec_t& val, void* /*valueVector*/) {
+    return toString(Timestamp::fromEpochSeconds(val.value));
+}
+
+template<>
+std::string TypeUtils::toString(const timestamp_tz_t& val, void* /*valueVector*/) {
+    return toString(static_cast<timestamp_t>(val)) + "+00";
+}
+
 template<>
 std::string TypeUtils::toString(const timestamp_t& val, void* /*valueVector*/) {
     return Timestamp::toString(val);

diff --git a/src/common/types/timestamp_t.cpp b/src/common/types/timestamp_t.cpp
@@ -333,5 +333,13 @@ int64_t Timestamp::getEpochNanoSeconds(const timestamp_t& timestamp) {
     return result;
 }
 
+int64_t Timestamp::getEpochMilliSeconds(const timestamp_t& timestamp) {
+    return timestamp.value / Interval::MICROS_PER_MSEC;
+}
+
+int64_t Timestamp::getEpochSeconds(const timestamp_t& timestamp) {
+    return timestamp.value / Interval::MICROS_PER_SEC;
+}
+
 } // namespace common
 } // namespace kuzu
diff --git a/src/common/types/types.cpp b/src/common/types/types.cpp
@@ -363,6 +363,10 @@ std::string LogicalType::toString() const {
     case LogicalTypeID::DOUBLE:
     case LogicalTypeID::FLOAT:
     case LogicalTypeID::DATE:
+    case LogicalTypeID::TIMESTAMP_NS:
+    case LogicalTypeID::TIMESTAMP_MS:
+    case LogicalTypeID::TIMESTAMP_SEC:
+    case LogicalTypeID::TIMESTAMP_TZ:
     case LogicalTypeID::TIMESTAMP:
     case LogicalTypeID::INTERVAL:
     case LogicalTypeID::BLOB:
@@ -440,6 +444,10 @@ void LogicalType::setPhysicalType() {
     case LogicalTypeID::BOOL: {
         physicalType = PhysicalTypeID::BOOL;
     } break;
+    case LogicalTypeID::TIMESTAMP_MS:
+    case LogicalTypeID::TIMESTAMP_NS:
+    case LogicalTypeID::TIMESTAMP_TZ:
+    case LogicalTypeID::TIMESTAMP_SEC:
     case LogicalTypeID::TIMESTAMP:
     case LogicalTypeID::SERIAL:
     case LogicalTypeID::INT64: {
@@ -566,6 +574,14 @@ LogicalTypeID LogicalTypeUtils::dataTypeIDFromString(const std::string& dataType
         return LogicalTypeID::DATE;
     } else if ("TIMESTAMP" == upperDataTypeIDString) {
         return LogicalTypeID::TIMESTAMP;
+    } else if ("TIMESTAMP_NS" == upperDataTypeIDString) {
+        return LogicalTypeID::TIMESTAMP_NS;
+    } else if ("TIMESTAMP_MS" == upperDataTypeIDString) {
+        return LogicalTypeID::TIMESTAMP_MS;
+    } else if ("TIMESTAMP_SEC" == upperDataTypeIDString || "TIMESTAMP_S" == upperDataTypeIDString) {
+        return LogicalTypeID::TIMESTAMP_SEC;
+    } else if ("TIMESTAMP_TZ" == upperDataTypeIDString) {
+        return LogicalTypeID::TIMESTAMP_TZ;
     } else if ("INTERVAL" == upperDataTypeIDString) {
         return LogicalTypeID::INTERVAL;
     } else if ("SERIAL" == upperDataTypeIDString) {
@@ -614,6 +630,14 @@ std::string LogicalTypeUtils::toString(LogicalTypeID dataTypeID) {
         return "FLOAT";
     case LogicalTypeID::DATE:
         return "DATE";
+    case LogicalTypeID::TIMESTAMP_NS:
+        return "TIMESTAMP_NS";
+    case LogicalTypeID::TIMESTAMP_MS:
+        return "TIMESTAMP_MS";
+    case LogicalTypeID::TIMESTAMP_SEC:
+        return "TIMESTAMP_SEC";
+    case LogicalTypeID::TIMESTAMP_TZ:
+        return "TIMESTAMP_TZ";
     case LogicalTypeID::TIMESTAMP:
         return "TIMESTAMP";
     case LogicalTypeID::INTERVAL:
@@ -740,7 +764,9 @@ std::vector<LogicalType> LogicalTypeUtils::getAllValidComparableLogicalTypes() {
         LogicalType{LogicalTypeID::UINT16}, LogicalType{LogicalTypeID::UINT8},
         LogicalType{LogicalTypeID::INT128}, LogicalType{LogicalTypeID::DOUBLE},
         LogicalType{LogicalTypeID::FLOAT}, LogicalType{LogicalTypeID::DATE},
-        LogicalType{LogicalTypeID::TIMESTAMP}, LogicalType{LogicalTypeID::INTERVAL},
+        LogicalType{LogicalTypeID::TIMESTAMP}, LogicalType{LogicalTypeID::TIMESTAMP_NS},
+        LogicalType{LogicalTypeID::TIMESTAMP_MS}, LogicalType{LogicalTypeID::TIMESTAMP_SEC},
+        LogicalType{LogicalTypeID::TIMESTAMP_TZ}, LogicalType{LogicalTypeID::INTERVAL},
         LogicalType{LogicalTypeID::BLOB}, LogicalType{LogicalTypeID::STRING},
         LogicalType{LogicalTypeID::SERIAL}};
 }
@@ -766,7 +792,9 @@ std::vector<LogicalType> LogicalTypeUtils::getAllValidLogicTypes() {
         LogicalType{LogicalTypeID::UINT8}, LogicalType{LogicalTypeID::INT128},
         LogicalType{LogicalTypeID::DOUBLE}, LogicalType{LogicalTypeID::STRING},
         LogicalType{LogicalTypeID::BLOB}, LogicalType{LogicalTypeID::DATE},
-        LogicalType{LogicalTypeID::TIMESTAMP}, LogicalType{LogicalTypeID::INTERVAL},
+        LogicalType{LogicalTypeID::TIMESTAMP}, LogicalType{LogicalTypeID::TIMESTAMP_NS},
+        LogicalType{LogicalTypeID::TIMESTAMP_MS}, LogicalType{LogicalTypeID::TIMESTAMP_SEC},
+        LogicalType{LogicalTypeID::TIMESTAMP_TZ}, LogicalType{LogicalTypeID::INTERVAL},
         LogicalType{LogicalTypeID::VAR_LIST}, LogicalType{LogicalTypeID::FIXED_LIST},
         LogicalType{LogicalTypeID::MAP}, LogicalType{LogicalTypeID::FLOAT},
         LogicalType{LogicalTypeID::SERIAL}, LogicalType{LogicalTypeID::NODE},