Add some Datetime Function (#2458)

### What problem does this PR solve?

_Add some Datetime Function such year, month, day, hour, minute, second_

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

@@ -1038,7 +1038,6 @@ def test_select_truncate(self, suffix):
 
         res, extra_res = table_obj.output(["trunc(c1, 14)",  "trunc(c2, 2)", "trunc(c3, 2)"]).to_df()
         print(res)
-        print(res.dtypes)
         pd.testing.assert_frame_equal(res, pd.DataFrame({'(c1 trunc 14)': ("2.12300000000000", "-2.12300000000000", "2.00000000000000", "2.10000000000000"),
                                                          '(c2 trunc 2)': ("2.12", "-2.12", "2.00", "2.10"),
                                                          '(c3 trunc 2)': ("2.12", "-2.12", "2.00", "2.10")
@@ -1062,10 +1061,134 @@ def test_select_reverse(self, suffix):
 
         res, extra_res = table_obj.output(["reverse(c1)", "reverse(c2)"]).to_df()
         print(res)
-        print(res.dtypes)
         pd.testing.assert_frame_equal(res, pd.DataFrame({'reverse(c1)': ('cba', '321a', 'c', 'nmlkjihgfedcba'),
                                                          'reverse(c2)': ('CBA', '321a', 'C', 'NMLKJIHGFEDCBA')})
                                       .astype({'reverse(c1)': dtype('str_'), 'reverse(c2)': dtype('str_')}))
 
         res = db_obj.drop_table("test_select_reverse" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+
+    def test_select_year(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_year" + suffix, ConflictType.Ignore)
+        table_obj = db_obj.create_table(
+            "test_select_year" + suffix, {
+                "c1": {"type": "date"},
+                "c2": {"type": "datetime"},
+                "c3": {"type": "timestamp"}},
+            ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_year" + suffix)
+        table_obj.insert(
+            [{"c1": "2024-09-23", "c2":  "2022-05-26 21:44:33", "c3":"2024-09-23 20:45:11"}])
+
+        res, extra_res = table_obj.output(["year(c1)", "year(c2)", "year(c3)"]).to_pl()
+        print(res)
+        assert res['year(c1)'][0] == 2024, "The value of year(c1) should be 2024"
+        assert res['year(c2)'][0] == 2022, "The value of year(c2) should be 2022"
+        assert res['year(c3)'][0] == 2024, "The value of year(c3) should be 2024"
+
+        res = db_obj.drop_table("test_select_year" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+
+    def test_select_month(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_month" + suffix, ConflictType.Ignore)
+        table_obj = db_obj.create_table(
+            "test_select_month" + suffix, {
+                "c1": {"type": "date"},
+                "c2": {"type": "datetime"},
+                "c3": {"type": "timestamp"}},
+            ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_month" + suffix)
+        table_obj.insert(
+            [{"c1": "2024-09-23", "c2":  "2022-05-26 21:44:33", "c3":"2024-09-23 20:45:11"}])
+
+        res, extra_res = table_obj.output(["month(c1)", "month(c2)", "month(c3)"]).to_pl()
+        print(res)
+        assert res['month(c1)'][0] == 9, "The value of month(c1) should be 9"
+        assert res['month(c2)'][0] == 5, "The value of month(c2) should be 5"
+        assert res['month(c3)'][0] == 9, "The value of month(c3) should be 9"
+        res = db_obj.drop_table("test_select_month" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+
+    def test_select_day(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_day" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_day" + suffix,
+                            {"c1": {"type": "date"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_day" + suffix)
+        table_obj.insert(
+            [{"c1": "2024-09-23", "c2":  "2022-05-26 21:44:33", "c3":"2024-09-23 20:45:11"}])
+
+        res, extra_res = table_obj.output(["day(c1)", "day(c2)", "day(c3)"]).to_pl()
+        print(res)
+        assert res['day(c1)'][0] == 23, "The value of day(c1) should be 23"
+        assert res['day(c2)'][0] == 26, "The value of day(c2) should be 26"
+        assert res['day(c3)'][0] == 23, "The value of day(c3) should be 23"
+        res = db_obj.drop_table("test_select_day" + suffix)
+        assert res.error_code == ErrorCode.OK
+
+    
+    def test_select_hour(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_hour" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_hour" + suffix,
+                            {"c1": {"type": "time"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_hour" + suffix)
+        table_obj.insert(
+            [{"c1":"0:0:0", "c2":  "2022-05-26 21:44:33", "c3":"2024-09-23 20:45:11"}])
+
+        res, extra_res = table_obj.output(["hour(c1)" ,"hour(c2)", "hour(c3)"]).to_pl()
+        print(res)
+        assert res['hour(c1)'][0] == 0, "The value of hour(c1) should be 0"
+        assert res['hour(c2)'][0] == 21, "The value of hour(c2) should be 21"
+        assert res['hour(c3)'][0] == 20, "The value of hour(c3) should be 20"
+
+        res = db_obj.drop_table("test_select_hour" + suffix)
+        assert res.error_code == ErrorCode.OK
+    
+    def test_select_minute(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_minute" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_minute" + suffix,
+                            {"c1": {"type": "time"},
+                             "c2": {"type": "datetime"},"c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_minute" + suffix)
+        table_obj.insert(
+            [{"c1":"0:0:0", "c2":  "2022-05-26 21:44:33", "c3":"2024-09-23 20:45:11"}])
+
+        res, extra_res = table_obj.output(["minute(c1)", "minute(c2)", "minute(c3)"]).to_pl()
+        print(res)
+        assert res['minute(c1)'][0] == 0, "The value of minute(c1) should be 0"
+        assert res['minute(c2)'][0] == 44, "The value of minute(c2) should be 44"
+        assert res['minute(c3)'][0] == 45, "The value of minute(c3) should be 45"
+        
+        res = db_obj.drop_table("test_select_minute" + suffix)
+        assert res.error_code == ErrorCode.OK
+    
+    def test_select_second(self, suffix):
+        db_obj = self.infinity_obj.get_database("default_db")
+        db_obj.drop_table("test_select_second" + suffix, ConflictType.Ignore)
+        db_obj.create_table("test_select_second" + suffix,
+                            {"c1": {"type": "time"},
+                             "c2": {"type": "datetime"},
+                             "c3": {"type": "timestamp"}}, ConflictType.Error)
+        table_obj = db_obj.get_table("test_select_second" + suffix)
+        table_obj.insert(
+            [{"c1":"0:0:0", "c2":  "2022-05-26 21:44:33", "c3":"2024-09-23 20:45:11"}])
+
+        res, extra_res = table_obj.output(["second(c1)", "second(c2)", "second(c3)"]).to_pl()
+        print(res)
+        assert res['second(c1)'][0] == 0, "The value of second(c1) should be 0"
+        assert res['second(c2)'][0] == 33, "The value of second(c2) should be 33"
+        assert res['second(c3)'][0] == 11, "The value of second(c3) should be 11"
+
+        res = db_obj.drop_table("test_select_second" + suffix)
         assert res.error_code == ErrorCode.OK

src/function/builtin_functions.cpp

@@ -48,6 +48,12 @@ import like;
 import minus;
 import modulo;
 import multiply;
+import year;
+import month;
+import day;
+import hour;
+import minute;
+import second;
 import not_func;
 import or_func;
 import plus;
@@ -148,6 +154,14 @@ void BuiltinFunctions::RegisterScalarFunction() {
     RegisterRtrimFunction(catalog_ptr_);
     RegisterTrimFunction(catalog_ptr_);
     RegisterPositionFunction(catalog_ptr_);
+
+    // date and time functions
+    RegisterYearFunction(catalog_ptr_);
+    RegisterMonthFunction(catalog_ptr_);
+    RegisterDayFunction(catalog_ptr_);
+    RegisterHourFunction(catalog_ptr_);
+    RegisterMinuteFunction(catalog_ptr_);
+    RegisterSecondFunction(catalog_ptr_);
 }
 
 void BuiltinFunctions::RegisterTableFunction() {}

src/function/scalar/day.cpp

@@ -0,0 +1,84 @@
+// 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;
+module day;
+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 DayFunction {
+    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 DayFunction::Run(DateT left, BigIntT &result) {
+    result = DateT::GetDatePart(left, TimeUnit::kDay);
+    return true;
+}
+
+template <>
+inline bool DayFunction::Run(DateTimeT left, BigIntT &result) {
+    result = DateTimeT::GetDateTimePart(left, TimeUnit::kDay);
+    return true;
+}
+
+template <>
+inline bool DayFunction::Run(TimestampT left, BigIntT &result) {
+    result = TimestampT::GetDateTimePart(left, TimeUnit::kDay);
+    return true;
+}
+
+void RegisterDayFunction(const UniquePtr<Catalog> &catalog_ptr) {
+    String func_name = "day";
+
+    SharedPtr<ScalarFunctionSet> function_set_ptr = MakeShared<ScalarFunctionSet>(func_name);
+
+    ScalarFunction day_date_function(func_name,
+                                  {DataType(LogicalType::kDate)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<DateT, BigIntT, DayFunction>);
+    function_set_ptr->AddFunction(day_date_function);
+
+    ScalarFunction day_datetime_function(func_name,
+                                  {DataType(LogicalType::kDateTime)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<DateTimeT, BigIntT, DayFunction>);
+    function_set_ptr->AddFunction(day_datetime_function);
+
+    ScalarFunction day_timestamp_function(func_name,
+                                  {DataType(LogicalType::kTimestamp)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<TimestampT, BigIntT, DayFunction>);
+    function_set_ptr->AddFunction(day_timestamp_function);
+
+    Catalog::AddFunctionSet(catalog_ptr.get(), function_set_ptr);
+}
+
+} // namespace infinity

src/function/scalar/day.cppm

@@ -0,0 +1,27 @@
+// 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;
+
+import stl;
+
+export module day;
+
+namespace infinity {
+
+class Catalog;
+
+export void RegisterDayFunction(const UniquePtr<Catalog> &catalog_ptr);
+
+} // namespace infinity

src/function/scalar/hour.cpp

@@ -0,0 +1,85 @@
+// 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;
+module hour;
+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 HourFunction {
+    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 HourFunction::Run(DateTimeT left, BigIntT &result) {
+    result = DateTimeT::GetDateTimePart(left, TimeUnit::kHour);
+    return true;
+}
+
+template <>
+inline bool HourFunction::Run(TimeT left, BigIntT &result) {
+    result = TimeT::GetTimePart(left, TimeUnit::kHour);
+    return true;
+}
+
+template <>
+inline bool HourFunction::Run(TimestampT left, BigIntT &result) {
+    result = TimestampT::GetDateTimePart(left, TimeUnit::kHour);
+    return true;
+}
+
+void RegisterHourFunction(const UniquePtr<Catalog> &catalog_ptr) {
+    String func_name = "hour";
+
+    SharedPtr<ScalarFunctionSet> function_set_ptr = MakeShared<ScalarFunctionSet>(func_name);
+
+    ScalarFunction hour_datetime_function(func_name,
+                                  {DataType(LogicalType::kDateTime)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<DateTimeT, BigIntT, HourFunction>);
+    function_set_ptr->AddFunction(hour_datetime_function);
+
+    ScalarFunction hour_time_function(func_name,
+                                  {DataType(LogicalType::kTime)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<TimeT, BigIntT, HourFunction>);
+    function_set_ptr->AddFunction(hour_time_function);
+
+    ScalarFunction hour_timestamp_function(func_name,
+                                  {DataType(LogicalType::kTimestamp)},
+                                  {DataType(LogicalType::kBigInt)},
+                                  &ScalarFunction::UnaryFunctionWithFailure<TimestampT, BigIntT, HourFunction>);
+    function_set_ptr->AddFunction(hour_timestamp_function);
+
+
+    Catalog::AddFunctionSet(catalog_ptr.get(), function_set_ptr);
+}
+
+} // namespace infinity