Add Other Datetime Functions (#2477)

### What problem does this PR solve?

_Add date_part,  century, epoch, era, quarter, weekday, weekofyear._

Issue link: (#2033)

### Type of change

- [x] New Feature (non-breaking change which adds functionality)
- [x] Test cases

Author: kche0169

python/test_pysdk/test_select.py

@@ -1251,4 +1251,146 @@ def test_select_day_of_week(self, suffix):
         assert res['dayofweek(c3)'][0] == 4, "The value of day_of_week(c3) should be 4"
 
         res = db_obj.drop_table("test_select_day_of_week" + suffix)
-        assert res.error_code == ErrorCode.OK
+        assert res.error_code == ErrorCode.OK
+
+    def test_select_weekday(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_weekday" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_weekday" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_weekday" + suffix)
+        table_obj.insert(
+            [{"c1":"2025-01-16", "c2":  "2025-01-31 21:44:33", "c3":"2025-01-26 20:45:11"}])
+
+        res, extra_res = table_obj.output(["weekday(c1)", "weekday(c2)", "weekday(c3)"]).to_pl()
+        print(res)
+        assert res['weekday(c1)'][0] == 4, "The value of weekday(c1) should be 4"
+        assert res['weekday(c2)'][0] == 5, "The value of weekday(c2) should be 5"
+        assert res['weekday(c3)'][0] == 0, "The value of weekday(c3) should be 0"
+
+        res = db_obj.drop_table("test_select_weekday" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+    def test_select_era(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_era" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_era" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_era" + suffix)
+        table_obj.insert(
+            [{"c1":"2025-01-16", "c2":  "44-01-16 21:44:33", "c3":"-25-01-16 20:45:11"}])
+
+        res, extra_res = table_obj.output(["era(c1)", "era(c2)", "era(c3)"]).to_pl()
+        print(res)
+        assert res['era(c1)'][0] == 1, "The value of era(c1) should be 1"
+        assert res['era(c2)'][0] == 1, "The value of era(c2) should be 1"
+        assert res['era(c3)'][0] == 0, "The value of era(c3) should be 0"
+
+        res = db_obj.drop_table("test_select_era" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+    def test_select_epoch(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_epoch" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_epoch" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_epoch" + suffix)
+        table_obj.insert(
+            [{"c1":"1970-01-01", "c2":  "1970-01-01 21:44:33", "c3":"1970-01-01 20:45:11"}])
+
+        res, extra_res = table_obj.output(["epoch(c1)", "epoch(c2)", "epoch(c3)"]).to_pl()
+        print(res)
+        assert res['epoch(c1)'][0] == 0, "The value of epoch(c1) should be 0"
+        assert res['epoch(c2)'][0] == 78273, "The value of epoch(c2) should be 78273"
+        assert res['epoch(c3)'][0] == 74711 , "The value of epoch(c3) should be 74711"
+
+        res = db_obj.drop_table("test_select_epoch" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+    def test_select_quarter(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_quarter" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_quarter" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_quarter" + suffix)
+        table_obj.insert(
+            [{"c1":"2025-01-16", "c2":  "2025-04-16 21:44:33", "c3":"2025-09-16 20:45:11"}])
+
+        res, extra_res = table_obj.output(["quarter(c1)", "quarter(c2)", "quarter(c3)"]).to_pl()
+        print(res)
+        assert res['quarter(c1)'][0] == 1, "The value of quarter(c1) should be 1"
+        assert res['quarter(c2)'][0] == 2, "The value of quarter(c2) should be 2"
+        assert res['quarter(c3)'][0] == 3, "The value of quarter(c3) should be 3"
+
+        res = db_obj.drop_table("test_select_quarter" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+    def test_select_century(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_century" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_century" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_century" + suffix)
+        table_obj.insert(
+            [{"c1":"2025-01-16", "c2":  "1925-01-16 21:44:33", "c3":"25-01-16 20:45:11"}])
+
+        res, extra_res = table_obj.output(["century(c1)", "century(c2)", "century(c3)"]).to_pl()
+        print(res)
+        assert res['century(c1)'][0] == 21, "The value of century(c1) should be 21"
+        assert res['century(c2)'][0] == 20, "The value of century(c2) should be 20"
+        assert res['century(c3)'][0] == 1, "The value of century(c3) should be 1"
+
+        res = db_obj.drop_table("test_select_century" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+    def test_select_week_of_year(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_week_of_year" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_week_of_year" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_week_of_year" + suffix)
+        table_obj.insert(
+            [{"c1":"2025-01-16", "c2":  "2025-01-01 21:44:33", "c3":"2017-12-16 20:45:11"}])
+
+        res, extra_res = table_obj.output(["weekofyear(c1)", "weekofyear(c2)", "weekofyear(c3)"]).to_pl()
+        print(res)
+        assert res['weekofyear(c1)'][0] == 3, "The value of weekofyear(c1) should be 3"
+        assert res['weekofyear(c2)'][0] == 1, "The value of weekofyear(c2) should be 1"
+        assert res['weekofyear(c3)'][0] == 50, "The value of weekofyear(c3) should be 50"
+
+        res = db_obj.drop_table("test_select_week_of_year" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+    def test_select_date_part(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_date_part" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_date_part" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"},
+                             "c4": {"type": "varchar", "constraints": ["primary key", "not null"]},
+                             "c5": {"type": "varchar", "constraints": ["not null"]}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_date_part" + suffix)
+        table_obj.insert(
+            [{"c1":"2025-01-16", "c2":  "2025-01-16 21:44:33", "c3":"2025-01-16 20:45:11", "c4":"year", "c5":"month"}])
+
+        res, extra_res = table_obj.output(["datepart(c4, c1)", "datepart(c4, c2)", "datepart(c5, c3)"]).to_pl()
+        print(res)
+        assert res['(c4 datepart c1)'][0] == 2025, "The value of c4 datepart c1 should be 2025"
+        assert res['(c4 datepart c2)'][0] == 2025, "The value of c4 datepart c2 should be 2025"
+        assert res['(c5 datepart c3)'][0] == 1, "The value of c5 datepart c3 should be 1"
+
+        res = db_obj.drop_table("test_select_date_part" + suffix)
+        assert res.error_code == ErrorCode.OK

src/function/builtin_functions.cpp

@@ -48,15 +48,22 @@ import like;
 import minus;
 import modulo;
 import multiply;
+import century;
 import year;
 import month;
 import day;
 import hour;
 import minute;
 import second;
+import date_part;
 import day_of_month;
 import day_of_week;
 import day_of_year;
+import era;
+import epoch;
+import weekday;
+import week_of_year;
+import quarter;
 import not_func;
 import or_func;
 import plus;
@@ -159,15 +166,22 @@ void BuiltinFunctions::RegisterScalarFunction() {
     RegisterPositionFunction(catalog_ptr_);
 
     // date and time functions
+    RegisterCenturyFunction(catalog_ptr_);
     RegisterYearFunction(catalog_ptr_);
     RegisterMonthFunction(catalog_ptr_);
     RegisterDayFunction(catalog_ptr_);
     RegisterHourFunction(catalog_ptr_);
     RegisterMinuteFunction(catalog_ptr_);
     RegisterSecondFunction(catalog_ptr_);
+    RegisterDatePartFunction(catalog_ptr_);
     RegisterDayOfYearFunction(catalog_ptr_);
     RegisterDayOfMonthFunction(catalog_ptr_);
     RegisterDayOfWeekFunction(catalog_ptr_);
+    RegisterEraFunction(catalog_ptr_);
+    RegisterEpochFunction(catalog_ptr_);
+    RegisterQuarterFunction(catalog_ptr_);
+    RegisterWeekdayFunction(catalog_ptr_);
+    RegisterWeekOfYearFunction(catalog_ptr_);
 }
 
 void BuiltinFunctions::RegisterTableFunction() {}

src/function/scalar/century.cpp

@@ -0,0 +1,115 @@
+// Copyright(C) 2025 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+
+module;
+#include <cmath>
+module century;
+
+import stl;
+import catalog;
+import status;
+import logical_type;
+import infinity_exception;
+import scalar_function;
+import scalar_function_set;
+import third_party;
+import internal_types;
+import data_type;
+import column_vector;
+
+namespace infinity {
+
+struct CenturyFunction {
+    template <typename TA, typename TB>
+    static inline bool Run(TA left, TB &result) {
+        Status status = Status::NotSupport("Not implemented");
+        RecoverableError(status);
+        return false;
+    }
+
+};
+
+template <>
+inline bool CenturyFunction::Run(DateT left, BigIntT &result) {
+    auto year = DateT::GetDatePart(left, TimeUnit::kYear);
+    if (year > 0) {
+        result = static_cast<i64>(ceil(year / 100.0));
+    } else if (year < 0) {
+        result = static_cast<i64>(floor(year / 100.0));
+    } else {
+        Status status = Status::InvalidParameterValue("Date", "0", "There is no year 0 in the AD/BC dating system.");
+        RecoverableError(status);
+        return false;
+    }
+    return true;
+}
+
+template <>
+inline bool CenturyFunction::Run(DateTimeT left, BigIntT &result) {
+    auto year = DateTimeT::GetDateTimePart(left, TimeUnit::kYear);
+    if (year > 0) {
+        result = static_cast<i64>(ceil(year / 100.0));
+    } else if (year < 0) {
+        result = static_cast<i64>(floor(year / 100.0));
+    } else {
+        Status status = Status::InvalidParameterValue("DateTime", "0", "There is no year 0 in the AD/BC dating system.");
+        RecoverableError(status);
+        return false;
+    }
+    
+    return true;
+}
+
+template <>
+inline bool CenturyFunction::Run(TimestampT left, BigIntT &result) {
+    auto year = TimestampT::GetDateTimePart(left, TimeUnit::kYear);
+    if (year > 0) {
+        result = static_cast<i64>(ceil(year / 100.0));
+    } else if (year < 0) {
+        result = static_cast<i64>(floor(year / 100.0));
+    } else {
+        Status status = Status::InvalidParameterValue("TimeStamp", "0", "There is no year 0 in the AD/BC dating system.");
+        RecoverableError(status);
+        return false;
+    }
+    return true;
+}
+
+void RegisterCenturyFunction(const UniquePtr<Catalog> &catalog_ptr) {
+    String func_name = "century";
+
+    SharedPtr<ScalarFunctionSet> function_set_ptr = MakeShared<ScalarFunctionSet>(func_name);
+
+    ScalarFunction century_date_function(func_name,
+                                  {DataType(LogicalType::kDate)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<DateT, BigIntT, CenturyFunction>);
+    function_set_ptr->AddFunction(century_date_function);
+
+    ScalarFunction century_datetime_function(func_name,
+                                  {DataType(LogicalType::kDateTime)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<DateTimeT, BigIntT, CenturyFunction>);
+    function_set_ptr->AddFunction(century_datetime_function);
+
+    ScalarFunction century_timestamp_function(func_name,
+                                  {DataType(LogicalType::kTimestamp)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<TimestampT, BigIntT, CenturyFunction>);
+    function_set_ptr->AddFunction(century_timestamp_function);
+
+    Catalog::AddFunctionSet(catalog_ptr.get(), function_set_ptr);
+}
+
+} // namespace infinity

src/function/scalar/century.cppm

@@ -0,0 +1,25 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.
+
+module;
+
+export module century;
+
+import stl;
+
+namespace infinity {
+
+class Catalog;
+
+export void RegisterCenturyFunction(const UniquePtr<Catalog> &catalog_ptr);
+
+} // namespace infinity