diff --git a/dbms/src/Functions/tests/gtest_arithmetic_functions.cpp b/dbms/src/Functions/tests/gtest_arithmetic_functions.cpp
index 1a542c908ee..1d548a4c2d2 100644
--- a/dbms/src/Functions/tests/gtest_arithmetic_functions.cpp
+++ b/dbms/src/Functions/tests/gtest_arithmetic_functions.cpp
@@ -128,6 +128,10 @@ try
     null_or_zero_field.push_back(Field(DecimalField<Decimal128>(0, 0)));
 
     std::vector<Int64> values{10, 2, 20, 8, 10, 0, 30, 8, 16, 4};
+    /// The precision of a non-zero DecimalField<Decimal128> must not less than minDecimalPrecision<Decimal128>
+    /// the decimal_128_factor is used to make sure the precision is big enough
+    Int128 decimal_128_factor = 10000000000;
+    decimal_128_factor *= 1000000000;
 
     const size_t size = 10;
 
@@ -172,7 +176,7 @@ try
             if (col2_type->onlyNull())
                 continue;
             auto c1 = nullable_decimal_type_1->createColumnConst(size, Null());
-            auto c2 = col2_type->createColumnConst(size, Field(DecimalField<Decimal128>(2, 0)));
+            auto c2 = col2_type->createColumnConst(size, Field(DecimalField<Decimal128>(2 * decimal_128_factor, 0)));
             auto col1 = ColumnWithTypeAndName(std::move(c1), nullable_decimal_type_1, "col1");
             auto col2 = ColumnWithTypeAndName(std::move(c2), col2_type, "col2");
             auto result = executeFunction(func_name, {col1, col2});
@@ -193,7 +197,7 @@ try
                     continue;
                 if (!col2_value.isNull() && col2_type->onlyNull())
                     continue;
-                auto c1 = col1_type->createColumnConst(size, Field(DecimalField<Decimal128>(100, 2)));
+                auto c1 = col1_type->createColumnConst(size, Field(DecimalField<Decimal128>(100 * decimal_128_factor, 2)));
                 auto c2 = col2_type->createColumnConst(size, col2_value);
                 auto col1 = ColumnWithTypeAndName(std::move(c1), col1_type, "col1");
                 auto col2 = ColumnWithTypeAndName(std::move(c2), col2_type, "col2");
@@ -211,11 +215,11 @@ try
         {
             if (col1_type->onlyNull() || col2_type->onlyNull())
                 continue;
-            auto c1 = col1_type->createColumnConst(size, Field(DecimalField<Decimal128>(1000, 2)));
-            auto c2 = col2_type->createColumnConst(size, Field(DecimalField<Decimal128>(2, 0)));
+            auto c1 = col1_type->createColumnConst(size, Field(DecimalField<Decimal128>(1000 * decimal_128_factor, 2)));
+            auto c2 = col2_type->createColumnConst(size, Field(DecimalField<Decimal128>(2 * decimal_128_factor, 0)));
             auto col1 = ColumnWithTypeAndName(std::move(c1), col1_type, "col1");
             auto col2 = ColumnWithTypeAndName(std::move(c2), col2_type, "col2");
-            auto res_col = executeFunction(func_name, {col1, col2}).column;
+            auto res_col = executeFunction(func_name, {col1, col2}, nullptr, false).column;
             ASSERT_TRUE(size == res_col->size());
             Field res_field;
             for (size_t i = 0; i < size; i++)
@@ -246,7 +250,7 @@ try
                     if (col1_type->isNullable() && col1_null_map[i])
                         c1_mutable->insert(Null());
                     else
-                        c1_mutable->insert(Field(DecimalField<Decimal128>(values[i], 2)));
+                        c1_mutable->insert(Field(DecimalField<Decimal128>(values[i] * decimal_128_factor, 2)));
                 }
                 auto c2 = col2_type->createColumnConst(values.size(), col2_value);
 
@@ -271,9 +275,9 @@ try
                 if (col1_type->isNullable() && col1_null_map[i])
                     c1_mutable->insert(Null());
                 else
-                    c1_mutable->insert(Field(DecimalField<Decimal128>(values[i], 2)));
+                    c1_mutable->insert(Field(DecimalField<Decimal128>(values[i] * decimal_128_factor, 2)));
             }
-            auto c2 = col2_type->createColumnConst(values.size(), Field(DecimalField<Decimal128>(2, 0)));
+            auto c2 = col2_type->createColumnConst(values.size(), Field(DecimalField<Decimal128>(2 * decimal_128_factor, 0)));
 
             auto col1 = ColumnWithTypeAndName(std::move(c1_mutable), col1_type, "col1");
             auto col2 = ColumnWithTypeAndName(std::move(c2), col2_type, "col2");
@@ -312,7 +316,7 @@ try
                 if (col2_type->isNullable() && col2_null_map[i])
                     c2->insert(Null());
                 else
-                    c2->insert(Field(DecimalField<Decimal128>(values[i], 2)));
+                    c2->insert(Field(DecimalField<Decimal128>(values[i] * decimal_128_factor, 2)));
             }
             auto col1 = ColumnWithTypeAndName(std::move(c1), col1_type, "col1");
             auto col2 = ColumnWithTypeAndName(std::move(c2), col2_type, "col2");
@@ -334,14 +338,14 @@ try
                 if (values[i] != 0)
                     value *= values[i];
             }
-            auto c1 = col1_type->createColumnConst(size, Field(DecimalField<Decimal128>(value, 2)));
+            auto c1 = col1_type->createColumnConst(size, Field(DecimalField<Decimal128>(value * decimal_128_factor, 2)));
             auto c2 = col2_type->createColumn();
             for (size_t i = 0; i < values.size(); i++)
             {
                 if (col2_type->isNullable() && col2_null_map[i])
                     c2->insert(Null());
                 else
-                    c2->insert(Field(DecimalField<Decimal128>(values[i], 0)));
+                    c2->insert(Field(DecimalField<Decimal128>(values[i] * decimal_128_factor, 0)));
             }
             auto col1 = ColumnWithTypeAndName(std::move(c1), col1_type, "col1");
             auto col2 = ColumnWithTypeAndName(std::move(c2), col2_type, "col2");
@@ -377,11 +381,11 @@ try
                 if (col1_type->isNullable() && col1_null_map[i])
                     c1->insert(Null());
                 else
-                    c1->insert(Field(DecimalField<Decimal128>(values[i], 2)));
+                    c1->insert(Field(DecimalField<Decimal128>(values[i] * decimal_128_factor, 2)));
                 if (col2_type->isNullable() && col2_null_map[i])
                     c2->insert(Null());
                 else
-                    c2->insert(Field(DecimalField<Decimal128>(values[i], 0)));
+                    c2->insert(Field(DecimalField<Decimal128>(values[i] * decimal_128_factor, 0)));
             }
             auto col1 = ColumnWithTypeAndName(std::move(c1), col1_type, "col1");
             auto col2 = ColumnWithTypeAndName(std::move(c2), col2_type, "col2");
diff --git a/dbms/src/Functions/tests/gtest_bitand.cpp b/dbms/src/Functions/tests/gtest_bitand.cpp
index b77bc5e8547..88c70847d98 100644
--- a/dbms/src/Functions/tests/gtest_bitand.cpp
+++ b/dbms/src/Functions/tests/gtest_bitand.cpp
@@ -40,7 +40,7 @@ class TestFunctionBitAnd : public DB::tests::FunctionTest
 TEST_F(TestFunctionBitAnd, Simple)
 try
 {
-    ASSERT_BITAND(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<Int64>>({0, 0}), createColumn<Nullable<Int64>>({0, 0}));
+    ASSERT_BITAND(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<Int64>>({0, 0}), createColumn<Nullable<UInt64>>({0, 0}));
 }
 CATCH
 
@@ -49,21 +49,21 @@ TEST_F(TestFunctionBitAnd, TypePromotion)
 try
 {
     // Type Promotion
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int16>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({0}));
 
-    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt16>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt32>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({0}));
     ASSERT_BITAND(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({0}));
     ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({0}));
 
     // Type Promotion across signed/unsigned
-    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<Int64>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({0}));
 }
 CATCH
 
@@ -71,51 +71,51 @@ TEST_F(TestFunctionBitAnd, Nullable)
 try
 {
     // Non Nullable
-    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Int16>({0}), createColumn<Int16>({0}));
-    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<Int32>({0}), createColumn<Int32>({0}));
-    ASSERT_BITAND(createColumn<Int32>({1}), createColumn<Int64>({0}), createColumn<Int64>({0}));
-    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Int64>({0}), createColumn<Int64>({0}));
+    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Int16>({0}), createColumn<UInt64>({0}));
+    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<Int32>({0}), createColumn<UInt64>({0}));
+    ASSERT_BITAND(createColumn<Int32>({1}), createColumn<Int64>({0}), createColumn<UInt64>({0}));
+    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Int64>({0}), createColumn<UInt64>({0}));
 
-    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<UInt16>({0}), createColumn<UInt16>({0}));
-    ASSERT_BITAND(createColumn<UInt16>({1}), createColumn<UInt32>({0}), createColumn<UInt32>({0}));
+    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<UInt16>({0}), createColumn<UInt64>({0}));
+    ASSERT_BITAND(createColumn<UInt16>({1}), createColumn<UInt32>({0}), createColumn<UInt64>({0}));
     ASSERT_BITAND(createColumn<UInt32>({1}), createColumn<UInt64>({0}), createColumn<UInt64>({0}));
     ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<UInt64>({0}), createColumn<UInt64>({0}));
 
-    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<UInt32>({0}), createColumn<Int32>({0}));
-    ASSERT_BITAND(createColumn<Int64>({1}), createColumn<UInt8>({0}), createColumn<Int64>({0}));
-    ASSERT_BITAND(createColumn<UInt32>({1}), createColumn<Int16>({0}), createColumn<Int32>({0}));
-    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<Int64>({0}), createColumn<Int64>({0}));
+    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<UInt32>({0}), createColumn<UInt64>({0}));
+    ASSERT_BITAND(createColumn<Int64>({1}), createColumn<UInt8>({0}), createColumn<UInt64>({0}));
+    ASSERT_BITAND(createColumn<UInt32>({1}), createColumn<Int16>({0}), createColumn<UInt64>({0}));
+    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<Int64>({0}), createColumn<UInt64>({0}));
 
     // Across Nullable and non-Nullable
-    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int16>>({0}));
-    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Int32>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({0}));
-    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({0}));
+    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Int32>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Int8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({0}));
 
-    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt16>>({0}));
-    ASSERT_BITAND(createColumn<UInt16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt32>>({0}));
+    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<UInt16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({0}));
     ASSERT_BITAND(createColumn<UInt32>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({0}));
     ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({0}));
 
-    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Int64>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<Int64>>({0}));
-    ASSERT_BITAND(createColumn<UInt32>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({0}));
+    ASSERT_BITAND(createColumn<Int16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Int64>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<UInt32>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<UInt8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({0}));
 
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Int16>({0}), createColumn<Nullable<Int16>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<Int32>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int32>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Int16>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<Int32>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int32>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({0}));
 
-    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<UInt16>({0}), createColumn<Nullable<UInt16>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<UInt16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt32>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<UInt16>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt64>>({0}));
     ASSERT_BITAND(createColumn<Nullable<UInt32>>({1}), createColumn<UInt64>({0}), createColumn<Nullable<UInt64>>({0}));
     ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<UInt64>({0}), createColumn<Nullable<UInt64>>({0}));
 
-    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<Int64>>({1}), createColumn<UInt8>({0}), createColumn<Nullable<Int64>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<UInt32>>({1}), createColumn<Int16>({0}), createColumn<Nullable<Int32>>({0}));
-    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<Int64>>({1}), createColumn<UInt8>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt32>>({1}), createColumn<Int16>({0}), createColumn<Nullable<UInt64>>({0}));
+    ASSERT_BITAND(createColumn<Nullable<UInt8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({0}));
 }
 CATCH
 
@@ -129,48 +129,48 @@ try
     /// 4. ColumnConst<Nullable>, value != null
     /// 5. ColumnConst<Nullable>, value = null
 
-    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Int64>({0, 0, 0, 1}));
-    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 0, std::nullopt, std::nullopt}));
-    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<UInt64>(4, 0), createColumn<Int64>({0, 0, 0, 0}));
-    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<Nullable<Int64>>({0, 0, 0, 0}));
-    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt)); // become const in wrapInNullable
-
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<Int64>>({0, 0, std::nullopt, std::nullopt}));
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<Nullable<Int64>>({0, 0, std::nullopt, std::nullopt}));
-    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Int64>({0, 0, 0, 0}));
-    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 0, std::nullopt, std::nullopt}));
-    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<Int64>(4, 0));
-    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<Int64>>({0, 0, 0, 0}));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 0, std::nullopt, std::nullopt}));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<UInt64>({0, 1, 0, 1}), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
+    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 0, 0, 1}));
+    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 0, std::nullopt, std::nullopt}));
+    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<UInt64>(4, 0), createColumn<UInt64>({0, 0, 0, 0}));
+    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<UInt64>({0, 0, 0, 0}));
+    ASSERT_BITAND(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt)); // become const in wrapInNullable
+
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<UInt64>>({0, 0, std::nullopt, std::nullopt}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<Nullable<UInt64>>({0, 0, std::nullopt, std::nullopt}));
+    ASSERT_BITAND(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 0, 0, 0}));
+    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 0, std::nullopt, std::nullopt}));
+    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITAND(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 0, 0, 0}));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 0, std::nullopt, std::nullopt}));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<UInt64>({0, 1, 0, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITAND(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
 }
 CATCH
 
 TEST_F(TestFunctionBitAnd, Boundary)
 try
 {
-    ASSERT_BITAND(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<Int8>({0, 127, 0, -128}));
-    ASSERT_BITAND(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt16>({0, 65535, 0, 65535}), createColumn<Int16>({0, 127, 0, -128}));
-    ASSERT_BITAND(createColumn<Int16>({32767, 32767, -32768, -32768}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<Int16>({0, 255, 0, 0}));
+    ASSERT_BITAND(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<UInt64>({0, 127, 0, 128}));
+    ASSERT_BITAND(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt16>({0, 65535, 0, 65535}), createColumn<UInt64>({0, 127, 0, 65408}));
+    ASSERT_BITAND(createColumn<Int16>({32767, 32767, -32768, -32768}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<UInt64>({0, 255, 0, 0}));
 
     ASSERT_BITAND(createColumn<Int64>({0, 0, 1, 1, -1, -1, INT64_MAX, INT64_MAX, INT64_MIN, INT64_MIN}),
                   createColumn<UInt64>({0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX}),
-                  createColumn<Int64>({0, 0, 0, 1, 0, -1, 0, INT64_MAX, 0, INT64_MIN}));
+                  createColumn<UInt64>({0, 0, 0, 1, 0, UINT64_MAX, 0, INT64_MAX, 0, 9223372036854775808ull}));
 }
 CATCH
 
diff --git a/dbms/src/Functions/tests/gtest_bitnot.cpp b/dbms/src/Functions/tests/gtest_bitnot.cpp
index 6b96e59718e..0b542d87961 100644
--- a/dbms/src/Functions/tests/gtest_bitnot.cpp
+++ b/dbms/src/Functions/tests/gtest_bitnot.cpp
@@ -41,7 +41,7 @@ class TestFunctionBitNot : public DB::tests::FunctionTest
 TEST_F(TestFunctionBitNot, Simple)
 try
 {
-    ASSERT_BITNOT(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<Int64>>({0, -2}));
+    ASSERT_BITNOT(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<UInt64>>({0, UINT64_MAX - 1}));
 }
 CATCH
 
@@ -49,21 +49,21 @@ CATCH
 TEST_F(TestFunctionBitNot, TypeTest)
 try
 {
-    ASSERT_BITNOT(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int8>>({-2}));
-    ASSERT_BITNOT(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<Int16>>({-2}));
-    ASSERT_BITNOT(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<Int32>>({-2}));
-    ASSERT_BITNOT(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<Int64>>({-2}));
-
-    ASSERT_BITNOT(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt8>>({UINT8_MAX - 1}));
-    ASSERT_BITNOT(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt16>>({UINT16_MAX - 1}));
-    ASSERT_BITNOT(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<UInt32>>({UINT32_MAX - 1}));
+    ASSERT_BITNOT(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
+    ASSERT_BITNOT(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
+    ASSERT_BITNOT(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
+    ASSERT_BITNOT(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
+
+    ASSERT_BITNOT(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
+    ASSERT_BITNOT(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
+    ASSERT_BITNOT(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
     ASSERT_BITNOT(createColumn<Nullable<UInt64>>({1}), createColumn<Nullable<UInt64>>({UINT64_MAX - 1}));
 
-    ASSERT_BITNOT(createColumn<Int8>({0, 0, 1, 1}), createColumn<Int8>({-1, -1, -2, -2}));
-    ASSERT_BITNOT(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int8>>({-1, -2, std::nullopt, std::nullopt}));
-    ASSERT_BITNOT(createConstColumn<Int8>(4, 0), createConstColumn<Int8>(4, -1));
-    ASSERT_BITNOT(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<Int8>>(4, -1));
-    ASSERT_BITNOT(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<Int8>>(4, std::nullopt));
+    ASSERT_BITNOT(createColumn<Int8>({0, 0, 1, 1}), createColumn<UInt64>({UINT64_MAX, UINT64_MAX, UINT64_MAX - 1, UINT64_MAX - 1}));
+    ASSERT_BITNOT(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({UINT64_MAX, UINT64_MAX - 1, std::nullopt, std::nullopt}));
+    ASSERT_BITNOT(createConstColumn<Int8>(4, 0), createConstColumn<UInt64>(4, UINT64_MAX));
+    ASSERT_BITNOT(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<UInt64>(4, UINT64_MAX));
+    ASSERT_BITNOT(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
 }
 CATCH
 
@@ -71,7 +71,7 @@ TEST_F(TestFunctionBitNot, Boundary)
 try
 {
     ASSERT_BITNOT(createColumn<Int64>({0, 1, -1, INT64_MAX, INT64_MIN}),
-                  createColumn<Int64>({-1, -2, 0, INT64_MIN, INT64_MAX}));
+                  createColumn<UInt64>({UINT64_MAX, UINT64_MAX - 1, 0, static_cast<UInt64>(INT64_MAX) + 1, INT64_MAX}));
 
     ASSERT_BITNOT(createColumn<UInt64>({0, 1, UINT64_MAX}),
                   createColumn<UInt64>({UINT64_MAX, UINT64_MAX - 1, 0}));
diff --git a/dbms/src/Functions/tests/gtest_bitor.cpp b/dbms/src/Functions/tests/gtest_bitor.cpp
index a1611659913..fb4794c31b2 100644
--- a/dbms/src/Functions/tests/gtest_bitor.cpp
+++ b/dbms/src/Functions/tests/gtest_bitor.cpp
@@ -40,7 +40,7 @@ class TestFunctionBitOr : public DB::tests::FunctionTest
 TEST_F(TestFunctionBitOr, Simple)
 try
 {
-    ASSERT_BITOR(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<Int64>>({0, 0}), createColumn<Nullable<Int64>>({-1, 1}));
+    ASSERT_BITOR(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<Int64>>({0, 0}), createColumn<Nullable<UInt64>>({UINT64_MAX, 1}));
 }
 CATCH
 
@@ -49,21 +49,21 @@ TEST_F(TestFunctionBitOr, TypePromotion)
 try
 {
     // Type Promotion
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int16>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt16>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt32>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITOR(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
     // Type Promotion across signed/unsigned
-    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 }
 CATCH
 
@@ -71,51 +71,51 @@ TEST_F(TestFunctionBitOr, Nullable)
 try
 {
     // Non Nullable
-    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Int16>({0}), createColumn<Int16>({1}));
-    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<Int32>({0}), createColumn<Int32>({1}));
-    ASSERT_BITOR(createColumn<Int32>({1}), createColumn<Int64>({0}), createColumn<Int64>({1}));
-    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Int64>({0}), createColumn<Int64>({1}));
+    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Int16>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<Int32>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITOR(createColumn<Int32>({1}), createColumn<Int64>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Int64>({0}), createColumn<UInt64>({1}));
 
-    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<UInt16>({0}), createColumn<UInt16>({1}));
-    ASSERT_BITOR(createColumn<UInt16>({1}), createColumn<UInt32>({0}), createColumn<UInt32>({1}));
+    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<UInt16>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITOR(createColumn<UInt16>({1}), createColumn<UInt32>({0}), createColumn<UInt64>({1}));
     ASSERT_BITOR(createColumn<UInt32>({1}), createColumn<UInt64>({0}), createColumn<UInt64>({1}));
     ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<UInt64>({0}), createColumn<UInt64>({1}));
 
-    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<UInt32>({0}), createColumn<Int32>({1}));
-    ASSERT_BITOR(createColumn<Int64>({1}), createColumn<UInt8>({0}), createColumn<Int64>({1}));
-    ASSERT_BITOR(createColumn<UInt32>({1}), createColumn<Int16>({0}), createColumn<Int32>({1}));
-    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<Int64>({0}), createColumn<Int64>({1}));
+    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<UInt32>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITOR(createColumn<Int64>({1}), createColumn<UInt8>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITOR(createColumn<UInt32>({1}), createColumn<Int16>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<Int64>({0}), createColumn<UInt64>({1}));
 
     // Across Nullable and non-Nullable
-    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int16>>({1}));
-    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Int32>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Int32>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Int8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt16>>({1}));
-    ASSERT_BITOR(createColumn<UInt16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt32>>({1}));
+    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<UInt16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITOR(createColumn<UInt32>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Int64>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITOR(createColumn<UInt32>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITOR(createColumn<Int16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Int64>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<UInt32>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<UInt8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Int16>({0}), createColumn<Nullable<Int16>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<Int32>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int32>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Int16>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<Int32>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int32>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<UInt16>({0}), createColumn<Nullable<UInt16>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<UInt16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt32>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<UInt16>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITOR(createColumn<Nullable<UInt32>>({1}), createColumn<UInt64>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<UInt64>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<Int64>>({1}), createColumn<UInt8>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<UInt32>>({1}), createColumn<Int16>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<Int64>>({1}), createColumn<UInt8>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt32>>({1}), createColumn<Int16>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITOR(createColumn<Nullable<UInt8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({1}));
 }
 CATCH
 
@@ -129,48 +129,48 @@ try
     /// 4. ColumnConst<Nullable>, value != null
     /// 5. ColumnConst<Nullable>, value = null
 
-    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Int64>({0, 1, 1, 1}));
-    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<UInt64>(4, 0), createColumn<Int64>({0, 0, 1, 1}));
-    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<Nullable<Int64>>({0, 0, 1, 1}));
-    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt)); // become const in wrapInNullable
-
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Int64>({0, 1, 0, 1}));
-    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<Int64>(4, 0));
-    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<Int64>>({0, 1, 0, 1}));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<UInt64>({0, 1, 0, 1}), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
+    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 1, 1, 1}));
+    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<UInt64>(4, 0), createColumn<UInt64>({0, 0, 1, 1}));
+    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<UInt64>({0, 0, 1, 1}));
+    ASSERT_BITOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt)); // become const in wrapInNullable
+
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 1, 0, 1}));
+    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 1, 0, 1}));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<UInt64>({0, 1, 0, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
 }
 CATCH
 
 TEST_F(TestFunctionBitOr, Boundary)
 try
 {
-    ASSERT_BITOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<Int8>({127, -1, -128, -1}));
-    ASSERT_BITOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt16>({0, 65535, 0, 65535}), createColumn<Int16>({127, -1, -128, -1}));
-    ASSERT_BITOR(createColumn<Int16>({32767, 32767, -32768, -32768}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<Int16>({32767, 32767, -32768, -32513}));
+    ASSERT_BITOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<UInt64>({127, 255, 18446744073709551488ull, UINT64_MAX}));
+    ASSERT_BITOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt16>({0, 65535, 0, 65535}), createColumn<UInt64>({127, 65535, 18446744073709551488ull, UINT64_MAX}));
+    ASSERT_BITOR(createColumn<Int16>({32767, 32767, -32768, -32768}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<UInt64>({32767, 32767, 18446744073709518848ull, 18446744073709519103ull}));
 
     ASSERT_BITOR(createColumn<Int64>({0, 0, 1, 1, -1, -1, INT64_MAX, INT64_MAX, INT64_MIN, INT64_MIN}),
                  createColumn<UInt64>({0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX}),
-                 createColumn<Int64>({0, -1, 1, -1, -1, -1, INT64_MAX, -1, INT64_MIN, -1}));
+                 createColumn<UInt64>({0, UINT64_MAX, 1, UINT64_MAX, UINT64_MAX, UINT64_MAX, INT64_MAX, UINT64_MAX, 9223372036854775808ull, UINT64_MAX}));
 }
 CATCH
 
diff --git a/dbms/src/Functions/tests/gtest_bitxor.cpp b/dbms/src/Functions/tests/gtest_bitxor.cpp
index 60f3027d2b5..85cc51a8a49 100644
--- a/dbms/src/Functions/tests/gtest_bitxor.cpp
+++ b/dbms/src/Functions/tests/gtest_bitxor.cpp
@@ -40,7 +40,7 @@ class TestFunctionBitXor : public DB::tests::FunctionTest
 TEST_F(TestFunctionBitXor, Simple)
 try
 {
-    ASSERT_BITXOR(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<Int64>>({0, 0}), createColumn<Nullable<Int64>>({-1, 1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int64>>({-1, 1}), createColumn<Nullable<Int64>>({0, 0}), createColumn<Nullable<UInt64>>({UINT64_MAX, 1}));
 }
 CATCH
 
@@ -49,21 +49,21 @@ TEST_F(TestFunctionBitXor, TypePromotion)
 try
 {
     // Type Promotion
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int16>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int32>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt16>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt32>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITXOR(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
     // Type Promotion across signed/unsigned
-    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int64>>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt32>>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 }
 CATCH
 
@@ -71,51 +71,51 @@ TEST_F(TestFunctionBitXor, Nullable)
 try
 {
     // Non Nullable
-    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Int16>({0}), createColumn<Int16>({1}));
-    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<Int32>({0}), createColumn<Int32>({1}));
-    ASSERT_BITXOR(createColumn<Int32>({1}), createColumn<Int64>({0}), createColumn<Int64>({1}));
-    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Int64>({0}), createColumn<Int64>({1}));
+    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Int16>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<Int32>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITXOR(createColumn<Int32>({1}), createColumn<Int64>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Int64>({0}), createColumn<UInt64>({1}));
 
-    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<UInt16>({0}), createColumn<UInt16>({1}));
-    ASSERT_BITXOR(createColumn<UInt16>({1}), createColumn<UInt32>({0}), createColumn<UInt32>({1}));
+    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<UInt16>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITXOR(createColumn<UInt16>({1}), createColumn<UInt32>({0}), createColumn<UInt64>({1}));
     ASSERT_BITXOR(createColumn<UInt32>({1}), createColumn<UInt64>({0}), createColumn<UInt64>({1}));
     ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<UInt64>({0}), createColumn<UInt64>({1}));
 
-    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<UInt32>({0}), createColumn<Int32>({1}));
-    ASSERT_BITXOR(createColumn<Int64>({1}), createColumn<UInt8>({0}), createColumn<Int64>({1}));
-    ASSERT_BITXOR(createColumn<UInt32>({1}), createColumn<Int16>({0}), createColumn<Int32>({1}));
-    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<Int64>({0}), createColumn<Int64>({1}));
+    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<UInt32>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITXOR(createColumn<Int64>({1}), createColumn<UInt8>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITXOR(createColumn<UInt32>({1}), createColumn<Int16>({0}), createColumn<UInt64>({1}));
+    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<Int64>({0}), createColumn<UInt64>({1}));
 
     // Across Nullable and non-Nullable
-    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int16>>({1}));
-    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Int32>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<Nullable<Int32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Int32>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Int8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt16>>({1}));
-    ASSERT_BITXOR(createColumn<UInt16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt32>>({1}));
+    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<Nullable<UInt16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<UInt16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITXOR(createColumn<UInt32>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<Nullable<UInt64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Int64>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITXOR(createColumn<UInt32>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITXOR(createColumn<Int16>({1}), createColumn<Nullable<UInt32>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Int64>({1}), createColumn<Nullable<UInt8>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<UInt32>({1}), createColumn<Nullable<Int16>>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<UInt8>({1}), createColumn<Nullable<Int64>>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Int16>({0}), createColumn<Nullable<Int16>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<Int32>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int32>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Int16>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<Int32>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int32>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<UInt16>({0}), createColumn<Nullable<UInt16>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<UInt16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt32>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<UInt16>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITXOR(createColumn<Nullable<UInt32>>({1}), createColumn<UInt64>({0}), createColumn<Nullable<UInt64>>({1}));
     ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<UInt64>({0}), createColumn<Nullable<UInt64>>({1}));
 
-    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<Int64>>({1}), createColumn<UInt8>({0}), createColumn<Nullable<Int64>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<UInt32>>({1}), createColumn<Int16>({0}), createColumn<Nullable<Int32>>({1}));
-    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<Int64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int16>>({1}), createColumn<UInt32>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<Int64>>({1}), createColumn<UInt8>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt32>>({1}), createColumn<Int16>({0}), createColumn<Nullable<UInt64>>({1}));
+    ASSERT_BITXOR(createColumn<Nullable<UInt8>>({1}), createColumn<Int64>({0}), createColumn<Nullable<UInt64>>({1}));
 }
 CATCH
 
@@ -129,48 +129,48 @@ try
     /// 4. ColumnConst<Nullable>, value != null
     /// 5. ColumnConst<Nullable>, value = null
 
-    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Int64>({0, 1, 1, 0}));
-    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<UInt64>(4, 0), createColumn<Int64>({0, 0, 1, 1}));
-    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<Nullable<Int64>>({0, 0, 1, 1}));
-    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt)); // become const in wrapInNullable
-
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<Int64>>({0, 0, std::nullopt, std::nullopt}));
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 0, std::nullopt, std::nullopt}));
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Int64>({0, 1, 0, 1}));
-    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<Int64>(4, 0));
-    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<Int64>>({0, 1, 0, 1}));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<Int64>>({0, 1, std::nullopt, std::nullopt}));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, 0));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<UInt64>({0, 1, 0, 1}), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<Nullable<Int64>>(4, std::nullopt));
-    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<Int64>>(4, std::nullopt));
+    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 1, 1, 0}));
+    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<UInt64>(4, 0), createColumn<UInt64>({0, 0, 1, 1}));
+    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, 0), createColumn<UInt64>({0, 0, 1, 1}));
+    ASSERT_BITXOR(createColumn<Int8>({0, 0, 1, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt)); // become const in wrapInNullable
+
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<UInt64>({0, 1, 0, 1}), createColumn<Nullable<UInt64>>({0, 0, std::nullopt, std::nullopt}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 0, std::nullopt, std::nullopt}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<UInt64>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITXOR(createColumn<Nullable<Int8>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 1, 0, 1}));
+    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITXOR(createConstColumn<Int8>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<UInt64>({0, 1, 0, 1}), createColumn<UInt64>({0, 1, 0, 1}));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<UInt64>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, 0), createConstColumn<UInt64>(4, 0));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<UInt64>({0, 1, 0, 1}), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createColumn<Nullable<UInt64>>({0, 1, std::nullopt, std::nullopt}), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<UInt64>(4, 0), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
+    ASSERT_BITXOR(createConstColumn<Nullable<Int8>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt), createConstColumn<Nullable<UInt64>>(4, std::nullopt));
 }
 CATCH
 
 TEST_F(TestFunctionBitXor, Boundary)
 try
 {
-    ASSERT_BITXOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<Int8>({127, -128, -128, 127}));
-    ASSERT_BITXOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt16>({0, 65535, 0, 65535}), createColumn<Int16>({127, -128, -128, 127}));
-    ASSERT_BITXOR(createColumn<Int16>({32767, 32767, -32768, -32768}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<Int16>({32767, 32512, -32768, -32513}));
+    ASSERT_BITXOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<UInt64>({127, 128, 18446744073709551488ull, 18446744073709551487ull}));
+    ASSERT_BITXOR(createColumn<Int8>({127, 127, -128, -128}), createColumn<UInt16>({0, 65535, 0, 65535}), createColumn<UInt64>({127, 65408, 18446744073709551488ull, 18446744073709486207ull}));
+    ASSERT_BITXOR(createColumn<Int16>({32767, 32767, -32768, -32768}), createColumn<UInt8>({0, 255, 0, 255}), createColumn<UInt64>({32767, 32512, 18446744073709518848ull, 18446744073709519103ull}));
 
     ASSERT_BITXOR(createColumn<Int64>({0, 0, 1, 1, -1, -1, INT64_MAX, INT64_MAX, INT64_MIN, INT64_MIN}),
                   createColumn<UInt64>({0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX, 0, UINT64_MAX}),
-                  createColumn<Int64>({0, -1, 1, -2, -1, 0, INT64_MAX, INT64_MIN, INT64_MIN, INT64_MAX}));
+                  createColumn<UInt64>({0, UINT64_MAX, 1, UINT64_MAX - 1, UINT64_MAX, 0, INT64_MAX, 9223372036854775808ull, 9223372036854775808ull, INT64_MAX}));
 }
 CATCH
 
diff --git a/dbms/src/Functions/tests/gtest_date_add.cpp b/dbms/src/Functions/tests/gtest_date_add.cpp
index 19effb11fb6..d87209c0805 100644
--- a/dbms/src/Functions/tests/gtest_date_add.cpp
+++ b/dbms/src/Functions/tests/gtest_date_add.cpp
@@ -114,58 +114,58 @@ TEST_F(Dateadd, dateAddStringRealUnitTest)
 {
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-14", "2012-12-14 12:12:12", "2012-12-14", "2012-12-14 12:12:12"}),
-        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.6))));
+        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-13", "2012-12-13 12:12:12", "2012-12-13", "2012-12-13 12:12:12"}),
-        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.4))));
+        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.4))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-14", "2012-12-14 12:12:12", "2012-12-14", "2012-12-14 12:12:12"}),
-        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toFloatVec({1.6, 1.6, 1.6, 1.6}))));
+        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toFloatVec({1.6, 1.6, 1.6, 1.6}))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-13", "2012-12-13 12:12:12", "2012-12-13", "2012-12-13 12:12:12"}),
-        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toFloatVec({1.4, 1.4, 1.4, 1.4}))));
+        executeFunction("addDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toFloatVec({1.4, 1.4, 1.4, 1.4}))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-26", "2012-12-26 12:12:12", "2012-12-26", "2012-12-26 12:12:12"}),
-        executeFunction("addWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.6))));
+        executeFunction("addWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-19", "2012-12-19 12:12:12", "2012-12-19", "2012-12-19 12:12:12"}),
-        executeFunction("addWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.4))));
+        executeFunction("addWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2013-02-12", "2013-02-12 12:12:12", "2013-02-12", "2013-02-12 12:12:12"}),
-        executeFunction("addMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.6))));
+        executeFunction("addMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2013-01-12", "2013-01-12 12:12:12", "2013-01-12", "2013-01-12 12:12:12"}),
-        executeFunction("addMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.4))));
+        executeFunction("addMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2014-12-12", "2014-12-12 12:12:12", "2014-12-12", "2014-12-12 12:12:12"}),
-        executeFunction("addYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.6))));
+        executeFunction("addYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2013-12-12", "2013-12-12 12:12:12", "2013-12-12", "2013-12-12 12:12:12"}),
-        executeFunction("addYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.4))));
+        executeFunction("addYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 02:00:00", "2012-12-12 14:12:12", "2012-12-12 02:00:00", "2012-12-12 14:12:12"}),
-        executeFunction("addHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.6))));
+        executeFunction("addHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 01:00:00", "2012-12-12 13:12:12", "2012-12-12 01:00:00", "2012-12-12 13:12:12"}),
-        executeFunction("addHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.4))));
+        executeFunction("addHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:02:00", "2012-12-12 12:14:12", "2012-12-12 00:02:00", "2012-12-12 12:14:12"}),
-        executeFunction("addMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.6))));
+        executeFunction("addMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:01:00", "2012-12-12 12:13:12", "2012-12-12 00:01:00", "2012-12-12 12:13:12"}),
-        executeFunction("addMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.4))));
+        executeFunction("addMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:00:02", "2012-12-12 12:12:14", "2012-12-12 00:00:02", "2012-12-12 12:12:14"}),
-        executeFunction("addSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.6))));
+        executeFunction("addSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:00:01", "2012-12-12 12:12:13", "2012-12-12 00:00:01", "2012-12-12 12:12:13"}),
-        executeFunction("addSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(1.4))));
+        executeFunction("addSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(1.4))));
 }
 
 } // namespace DB::tests
diff --git a/dbms/src/Functions/tests/gtest_date_or_datetime_to_something.cpp b/dbms/src/Functions/tests/gtest_date_or_datetime_to_something.cpp
index 115218e5550..206c13b1ef6 100644
--- a/dbms/src/Functions/tests/gtest_date_or_datetime_to_something.cpp
+++ b/dbms/src/Functions/tests/gtest_date_or_datetime_to_something.cpp
@@ -66,7 +66,7 @@ try
                        MyDateTime(2020, 10, 10, 0, 0, 0, 0).toPackedUInt())
                        .column;
     input_col = ColumnWithTypeAndName(data_col_ptr, data_type_ptr, "input");
-    output_col = createConstColumn<Nullable<UInt8>>(4, 4);
+    output_col = createConstColumn<UInt8>(4, 4);
     ASSERT_COLUMN_EQ(output_col, executeFunction(func_name, input_col));
 
     // ColumnConst(null)
diff --git a/dbms/src/Functions/tests/gtest_date_sub.cpp b/dbms/src/Functions/tests/gtest_date_sub.cpp
index ad6751bac09..ee45e4e212b 100644
--- a/dbms/src/Functions/tests/gtest_date_sub.cpp
+++ b/dbms/src/Functions/tests/gtest_date_sub.cpp
@@ -114,58 +114,58 @@ TEST_F(Datesub, dateSubStringRealUnitTest)
 {
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-14", "2012-12-14 12:12:12", "2012-12-14", "2012-12-14 12:12:12"}),
-        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.6))));
+        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-13", "2012-12-13 12:12:12", "2012-12-13", "2012-12-13 12:12:12"}),
-        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.4))));
+        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.4))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-14", "2012-12-14 12:12:12", "2012-12-14", "2012-12-14 12:12:12"}),
-        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toFloatVec({-1.6, -1.6, -1.6, -1.6}))));
+        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toFloatVec({-1.6, -1.6, -1.6, -1.6}))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-13", "2012-12-13 12:12:12", "2012-12-13", "2012-12-13 12:12:12"}),
-        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toFloatVec({-1.4, -1.4, -1.4, -1.4}))));
+        executeFunction("subtractDays", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toFloatVec({-1.4, -1.4, -1.4, -1.4}))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-26", "2012-12-26 12:12:12", "2012-12-26", "2012-12-26 12:12:12"}),
-        executeFunction("subtractWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.6))));
+        executeFunction("subtractWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-19", "2012-12-19 12:12:12", "2012-12-19", "2012-12-19 12:12:12"}),
-        executeFunction("subtractWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.4))));
+        executeFunction("subtractWeeks", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2013-02-12", "2013-02-12 12:12:12", "2013-02-12", "2013-02-12 12:12:12"}),
-        executeFunction("subtractMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.6))));
+        executeFunction("subtractMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2013-01-12", "2013-01-12 12:12:12", "2013-01-12", "2013-01-12 12:12:12"}),
-        executeFunction("subtractMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.4))));
+        executeFunction("subtractMonths", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2014-12-12", "2014-12-12 12:12:12", "2014-12-12", "2014-12-12 12:12:12"}),
-        executeFunction("subtractYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.6))));
+        executeFunction("subtractYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2013-12-12", "2013-12-12 12:12:12", "2013-12-12", "2013-12-12 12:12:12"}),
-        executeFunction("subtractYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.4))));
+        executeFunction("subtractYears", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 02:00:00", "2012-12-12 14:12:12", "2012-12-12 02:00:00", "2012-12-12 14:12:12"}),
-        executeFunction("subtractHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.6))));
+        executeFunction("subtractHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 01:00:00", "2012-12-12 13:12:12", "2012-12-12 01:00:00", "2012-12-12 13:12:12"}),
-        executeFunction("subtractHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.4))));
+        executeFunction("subtractHours", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:02:00", "2012-12-12 12:14:12", "2012-12-12 00:02:00", "2012-12-12 12:14:12"}),
-        executeFunction("subtractMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.6))));
+        executeFunction("subtractMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:01:00", "2012-12-12 12:13:12", "2012-12-12 00:01:00", "2012-12-12 12:13:12"}),
-        executeFunction("subtractMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.4))));
+        executeFunction("subtractMinutes", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.4))));
 
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:00:02", "2012-12-12 12:12:14", "2012-12-12 00:00:02", "2012-12-12 12:12:14"}),
-        executeFunction("subtractSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.6))));
+        executeFunction("subtractSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.6))));
     ASSERT_COLUMN_EQ(
         toNullableVec({"2012-12-12 00:00:01", "2012-12-12 12:12:13", "2012-12-12 00:00:01", "2012-12-12 12:12:13"}),
-        executeFunction("subtractSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("round", toConst(-1.4))));
+        executeFunction("subtractSeconds", toNullableVec({"20121212", "20121212121212", "2012-12-12", "2012-12-12 12:12:12"}), executeFunction("tidbRound", toConst(-1.4))));
 }
 
 } // namespace DB::tests
diff --git a/dbms/src/Functions/tests/gtest_datetime_daymonthyear.cpp b/dbms/src/Functions/tests/gtest_datetime_daymonthyear.cpp
index 99254821062..1cc7d799014 100644
--- a/dbms/src/Functions/tests/gtest_datetime_daymonthyear.cpp
+++ b/dbms/src/Functions/tests/gtest_datetime_daymonthyear.cpp
@@ -82,9 +82,9 @@ class TestDateTimeDayMonthYear : public DB::tests::FunctionTest
                         .column,
                     makeNullable(std::make_shared<DT>()),
                     "result");
-                result_day = createConstColumn<Nullable<UInt8>>(1, {day});
-                result_month = createConstColumn<Nullable<UInt8>>(1, {month});
-                result_year = createConstColumn<Nullable<UInt16>>(1, {year});
+                result_day = createConstColumn<UInt8>(1, {day});
+                result_month = createConstColumn<UInt8>(1, {month});
+                result_year = createConstColumn<UInt16>(1, {year});
             }
             else
             {
diff --git a/dbms/src/Functions/tests/gtest_duration_pushdown.cpp b/dbms/src/Functions/tests/gtest_duration_pushdown.cpp
index bd6fddaeb84..4501a4c9fae 100644
--- a/dbms/src/Functions/tests/gtest_duration_pushdown.cpp
+++ b/dbms/src/Functions/tests/gtest_duration_pushdown.cpp
@@ -43,8 +43,10 @@ try
         result_col,
         executeFunction(
             "FunctionConvertDurationFromNanos",
-            createColumn<Nullable<Int64>>({-1, 0, 1, {}, INT64_MAX, INT64_MIN, (838 * 3600 + 59 * 60 + 59) * 1000000000L, -(838 * 3600 + 59 * 60 + 59) * 1000000000L}),
-            createConstColumn<Int64>(8, 1)));
+            {createColumn<Nullable<Int64>>({-1, 0, 1, {}, INT64_MAX, INT64_MIN, (838 * 3600 + 59 * 60 + 59) * 1000000000L, -(838 * 3600 + 59 * 60 + 59) * 1000000000L}),
+             createConstColumn<Int64>(8, 1)},
+            nullptr,
+            true));
 
     ColumnWithTypeAndName result_col2(
         createConstColumn<DataTypeMyDuration::FieldType>(3, 3).column,
@@ -54,8 +56,10 @@ try
         result_col2,
         executeFunction(
             "FunctionConvertDurationFromNanos",
-            createConstColumn<Int64>(3, 3),
-            createConstColumn<Int64>(3, 2)));
+            {createConstColumn<Int64>(3, 3),
+             createConstColumn<Int64>(3, 2)},
+            nullptr,
+            true));
 }
 CATCH
 
diff --git a/dbms/src/Functions/tests/gtest_functions_round_with_frac.cpp b/dbms/src/Functions/tests/gtest_functions_round_with_frac.cpp
index 0c85285029e..403b88259a4 100644
--- a/dbms/src/Functions/tests/gtest_functions_round_with_frac.cpp
+++ b/dbms/src/Functions/tests/gtest_functions_round_with_frac.cpp
@@ -312,9 +312,10 @@ TEST_F(TestFunctionsRoundWithFrac, IntConstInput)
         // const signed - const frac
         for (size_t i = 0; i < size; ++i)
         {
-            ASSERT_COLUMN_EQ(createConstColumn<Nullable<Int64>>(1, int32_result[i]),
+            bool frac_data_null = !frac_data[i].has_value();
+            ASSERT_COLUMN_EQ(frac_data_null ? createConstColumn<Nullable<Int64>>(1, int32_result[i]) : createConstColumn<Int64>(1, int32_result[i].value()),
                              execute(createConstColumn<Int32>(1, int32_input), createConstColumn<Nullable<Int64>>(1, frac_data[i])));
-            ASSERT_COLUMN_EQ(createConstColumn<Nullable<UInt64>>(1, uint32_result[i]),
+            ASSERT_COLUMN_EQ(frac_data_null ? createConstColumn<Nullable<UInt64>>(1, uint32_result[i]) : createConstColumn<UInt64>(1, uint32_result[i].value()),
                              execute(createConstColumn<UInt32>(1, uint32_input), createConstColumn<Nullable<Int64>>(1, frac_data[i])));
             ASSERT_COLUMN_EQ(createConstColumn<Nullable<Int64>>(1, {}),
                              execute(createConstColumn<Nullable<Int64>>(1, {}), createConstColumn<Nullable<Int64>>(1, frac_data[i])));
@@ -441,22 +442,22 @@ try
     {
         auto frac = createColumn<Nullable<Int64>>({3, 2, 1, 0, -1, -2, -3, -4, -5, -6, {}});
 
-        ASSERT_COLUMN_EQ(column({max_prec, 3},
-                                {"98765.432", "98765.430", "98765.400", "98765.000", "98770.000", "98800.000", "99000.000", "100000.000", "100000.000", "0.000", {}}),
+        ASSERT_COLUMN_EQ(createColumn<Nullable<Decimal32>>(std::make_tuple(9, 3),
+                                                           {"98765.432", "98765.430", "98765.400", "98765.000", "98770.000", "98800.000", "99000.000", "100000.000", "100000.000", "0.000", {}}),
                          this->execute(constColumn({max_prec - 1, 3}, 11, "98765.432"), frac));
         ASSERT_COLUMN_EQ(constColumn({max_prec, 3}, 11, {}), this->execute(constColumn({max_prec - 1, 3}, 11, {}), frac));
     }
 
     // const input & frac
 
-    ASSERT_COLUMN_EQ(constColumn({max_prec - 1, 2}, 1, "0.03"),
+    ASSERT_COLUMN_EQ(createConstColumn<Decimal32>(std::make_tuple(3, 2), 1, "0.03"),
                      this->execute(constColumn({max_prec - 1, 3}, 1, "0.025"), createConstColumn<Int64>(1, 2)));
     ASSERT_COLUMN_EQ(
         constColumn({max_prec - 1, 2}, 1, {}),
         this->execute(constColumn({max_prec - 1, 3}, 1, {}), createConstColumn<Int64>(1, 2)));
-    ASSERT_COLUMN_EQ(constColumn({max_prec - 3, 0}, 1, {}),
+    ASSERT_COLUMN_EQ(createConstColumn<Nullable<Decimal32>>(std::make_tuple(1, 0), 1, {}, "", 0),
                      this->execute(constColumn({max_prec - 1, 3}, 1, "0.025"), createConstColumn<Nullable<Int64>>(1, {})));
-    ASSERT_COLUMN_EQ(createConstColumn<Decimal>(std::make_tuple(max_prec, 5), 100, "1." + String(5, '0')),
+    ASSERT_COLUMN_EQ(createConstColumn<Decimal32>(std::make_tuple(6, 5), 100, "1." + String(5, '0')),
                      this->execute(createConstColumn<Decimal>(std::make_tuple(max_prec - 5, 0), 100, "1"), createConstColumn<Int64>(100, 5)));
 }
 CATCH
diff --git a/dbms/src/Functions/tests/gtest_ifnull.cpp b/dbms/src/Functions/tests/gtest_ifnull.cpp
index 6d4bd17089a..bd319b59d92 100644
--- a/dbms/src/Functions/tests/gtest_ifnull.cpp
+++ b/dbms/src/Functions/tests/gtest_ifnull.cpp
@@ -34,19 +34,15 @@ class TestIfNull : public DB::tests::FunctionTest
 protected:
     ColumnWithTypeAndName executeIfNull(const ColumnWithTypeAndName & first_column, const ColumnWithTypeAndName & second_column)
     {
-        auto is_null_column = executeFunction("isNull", first_column);
-        auto not_null_column = executeFunction("assumeNotNull", first_column);
-        return executeFunction("multiIf", is_null_column, second_column, not_null_column);
+        return executeFunction("ifNull", first_column, second_column);
     }
     DataTypePtr getReturnTypeForIfNull(const DataTypePtr & type_1, const DataTypePtr & type_2)
     {
-        const static auto cond_type = std::make_shared<DataTypeUInt8>();
         ColumnsWithTypeAndName input_columns{
-            {nullptr, cond_type, ""},
-            {nullptr, removeNullable(type_1), ""},
+            {nullptr, type_1, ""},
             {nullptr, type_2, ""},
         };
-        return getReturnTypeForFunction(context, "multiIf", input_columns);
+        return getReturnTypeForFunction(context, "ifNull", input_columns);
     }
     template <class IntegerType>
     ColumnWithTypeAndName createIntegerColumnInternal(const std::vector<Int64> & signed_input, const std::vector<UInt64> unsigned_input, const std::vector<Int32> & null_map)
@@ -150,12 +146,12 @@ try
                 }
                 else
                 {
-                    ASSERT_COLUMN_EQ(col_2.type->isNullable() ? expr_data_2_nullable_vector : expr_data_2_vector, executeIfNull(col_1, col_2));
+                    ASSERT_COLUMN_EQ(expr_data_2_vector, executeIfNull(col_1, col_2));
                 }
             }
             else
             {
-                if (col_2.type->isNullable())
+                if (col_2.column->isNullAt(0))
                 {
                     ASSERT_COLUMN_EQ(expr_data_1_nullable_vector, executeIfNull(col_1, col_2));
                 }
@@ -185,14 +181,7 @@ try
             }
             else
             {
-                if (col_2.type->isNullable())
-                {
-                    ASSERT_COLUMN_EQ(createNullableColumn<Int64>(vector_const_result, {0, 0, 0, 0, 0}), executeIfNull(col_1, col_2));
-                }
-                else
-                {
-                    ASSERT_COLUMN_EQ(createColumn<Int64>(vector_const_result), executeIfNull(col_1, col_2));
-                }
+                ASSERT_COLUMN_EQ(createColumn<Int64>(vector_const_result), executeIfNull(col_1, col_2));
             }
         }
     }
diff --git a/dbms/src/Functions/tests/gtest_inet_aton_ntoa.cpp b/dbms/src/Functions/tests/gtest_inet_aton_ntoa.cpp
index 756dc7e610a..cb37252d17e 100644
--- a/dbms/src/Functions/tests/gtest_inet_aton_ntoa.cpp
+++ b/dbms/src/Functions/tests/gtest_inet_aton_ntoa.cpp
@@ -142,7 +142,7 @@ try
 
     // const non-null column
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(1, "0.0.0.1"),
+        createConstColumn<String>(1, "0.0.0.1"),
         executeFunction(func_name, createConstColumn<Nullable<UInt32>>(1, 1)));
 
     // normal cases
diff --git a/dbms/src/Functions/tests/gtest_is_true_false.cpp b/dbms/src/Functions/tests/gtest_is_true_false.cpp
index 520728b4380..400166c685e 100644
--- a/dbms/src/Functions/tests/gtest_is_true_false.cpp
+++ b/dbms/src/Functions/tests/gtest_is_true_false.cpp
@@ -124,10 +124,10 @@ CATCH
             createColumn<Nullable<Int64>>({0, 1, 1, std::nullopt}),                                                        \
             executeFunction("isTrueWithNull", createColumn<Nullable<TYPE>>({0, 1, static_cast<TYPE>(-1), std::nullopt}))); \
         ASSERT_COLUMN_EQ(                                                                                                  \
-            createConstColumn<Nullable<Int64>>(5, 0),                                                                      \
+            createConstColumn<Int64>(5, 0),                                                                                \
             executeFunction("isTrueWithNull", createConstColumn<Nullable<TYPE>>(5, 0)));                                   \
         ASSERT_COLUMN_EQ(                                                                                                  \
-            createConstColumn<Nullable<Int64>>(5, 1),                                                                      \
+            createConstColumn<Int64>(5, 1),                                                                                \
             executeFunction("isTrueWithNull", createConstColumn<Nullable<TYPE>>(5, 2)));                                   \
         ASSERT_COLUMN_EQ(                                                                                                  \
             createConstColumn<Nullable<Int64>>(5, std::nullopt),                                                           \
@@ -194,10 +194,10 @@ CATCH
             createColumn<Nullable<Int64>>({1, 0, 0, std::nullopt}),                                                         \
             executeFunction("isFalseWithNull", createColumn<Nullable<TYPE>>({0, 1, static_cast<TYPE>(-1), std::nullopt}))); \
         ASSERT_COLUMN_EQ(                                                                                                   \
-            createConstColumn<Nullable<Int64>>(5, 1),                                                                       \
+            createConstColumn<Int64>(5, 1),                                                                                 \
             executeFunction("isFalseWithNull", createConstColumn<Nullable<TYPE>>(5, 0)));                                   \
         ASSERT_COLUMN_EQ(                                                                                                   \
-            createConstColumn<Nullable<Int64>>(5, 0),                                                                       \
+            createConstColumn<Int64>(5, 0),                                                                                 \
             executeFunction("isFalseWithNull", createConstColumn<Nullable<TYPE>>(5, 2)));                                   \
         ASSERT_COLUMN_EQ(                                                                                                   \
             createConstColumn<Nullable<Int64>>(5, std::nullopt),                                                            \
diff --git a/dbms/src/Functions/tests/gtest_least_greatest.cpp b/dbms/src/Functions/tests/gtest_least_greatest.cpp
index bc57cc531a1..cbf7552fdc1 100644
--- a/dbms/src/Functions/tests/gtest_least_greatest.cpp
+++ b/dbms/src/Functions/tests/gtest_least_greatest.cpp
@@ -154,7 +154,7 @@ try
 
     // const-const least
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<Int64>>(1, -3),
+        createConstColumn<Int64>(1, -3),
         executeFunction(
             func_name,
             createConstColumn<Nullable<Int64>>(1, 5),
@@ -323,7 +323,7 @@ try
 
     // const-const greatest
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<Int64>>(1, 5),
+        createConstColumn<Int64>(1, 5),
         executeFunction(
             func_name,
             createConstColumn<Nullable<Int64>>(1, 5),
diff --git a/dbms/src/Functions/tests/gtest_logical.cpp b/dbms/src/Functions/tests/gtest_logical.cpp
index 7988989cc88..29fd4d6e133 100644
--- a/dbms/src/Functions/tests/gtest_logical.cpp
+++ b/dbms/src/Functions/tests/gtest_logical.cpp
@@ -46,7 +46,7 @@ try
             createColumn<Nullable<UInt8>>({1, 0})));
     // const, const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<UInt8>>(1, 1),
+        createConstColumn<UInt8>(1, 1),
         executeFunction(
             func_name,
             createConstColumn<Nullable<UInt8>>(1, 1),
@@ -82,7 +82,7 @@ try
             createColumn<Nullable<UInt8>>({1, 0})));
     // const, const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<UInt8>>(1, 1),
+        createConstColumn<UInt8>(1, 1),
         executeFunction(
             func_name,
             createConstColumn<Nullable<UInt8>>(1, 1),
@@ -118,7 +118,7 @@ try
             createColumn<Nullable<UInt8>>({1, 0})));
     // const, const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<UInt8>>(1, 0),
+        createConstColumn<UInt8>(1, 0),
         executeFunction(
             func_name,
             createConstColumn<Nullable<UInt8>>(1, 1),
@@ -146,7 +146,7 @@ try
             createColumn<Nullable<UInt8>>({0, 1, {}})));
     // const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<UInt8>>(1, 0),
+        createConstColumn<UInt8>(1, 0),
         executeFunction(
             func_name,
             createConstColumn<Nullable<UInt8>>(1, 1)));
diff --git a/dbms/src/Functions/tests/gtest_regexp.cpp b/dbms/src/Functions/tests/gtest_regexp.cpp
index 25314e9f5e7..d3eb93a0790 100644
--- a/dbms/src/Functions/tests/gtest_regexp.cpp
+++ b/dbms/src/Functions/tests/gtest_regexp.cpp
@@ -1828,15 +1828,15 @@ TEST_F(Regexp, testRegexp)
     for (size_t i = 0; i < row_size; i++)
     {
         /// test regexp(const, const)
-        ASSERT_COLUMN_EQ(input_string_nulls[i] || pattern_nulls[i] ? const_uint8_null_column : createConstColumn<Nullable<UInt8>>(row_size, results[i]),
+        ASSERT_COLUMN_EQ(input_string_nulls[i] || pattern_nulls[i] ? const_uint8_null_column : createConstColumn<UInt8>(row_size, results[i]),
                          executeFunction("regexp", input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i])));
 
         /// test regexp(const, const, const)
-        ASSERT_COLUMN_EQ(input_string_nulls[i] || pattern_nulls[i] || match_type_nulls[i] ? const_uint8_null_column : createConstColumn<Nullable<UInt8>>(row_size, results_with_match_type[i]),
+        ASSERT_COLUMN_EQ(input_string_nulls[i] || pattern_nulls[i] || match_type_nulls[i] ? const_uint8_null_column : createConstColumn<UInt8>(row_size, results_with_match_type[i]),
                          executeFunction("regexp", input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), match_type_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, match_types[i])));
 
         /// test regexp(const, const, const) with binary collator
-        ASSERT_COLUMN_EQ(input_string_nulls[i] || pattern_nulls[i] || match_type_nulls[i] ? const_uint8_null_column : createConstColumn<Nullable<UInt8>>(row_size, results_with_match_type_collator[i]),
+        ASSERT_COLUMN_EQ(input_string_nulls[i] || pattern_nulls[i] || match_type_nulls[i] ? const_uint8_null_column : createConstColumn<UInt8>(row_size, results_with_match_type_collator[i]),
                          executeFunction("regexp", {input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), match_type_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, match_types[i])}, binary_collator));
     }
     /// case 3 regexp(vector, const[, const])
@@ -1920,20 +1920,13 @@ TEST_F(Regexp, testRegexpCustomerCases)
             }
             else if (isColumnConstNotNull(input_column) && isColumnConstNotNull(pattern_column))
             {
-                if (input_column.type->isNullable() || pattern_column.type->isNullable())
-                {
-                    ASSERT_COLUMN_EQ(createConstColumn<Nullable<UInt8>>(5, 1),
-                                     executeFunction("regexp", input_column, pattern_column));
-                }
-                else
-                {
-                    ASSERT_COLUMN_EQ(createConstColumn<UInt8>(5, 1),
-                                     executeFunction("regexp", input_column, pattern_column));
-                }
+                ASSERT_COLUMN_EQ(createConstColumn<UInt8>(5, 1),
+                                 executeFunction("regexp", input_column, pattern_column));
             }
             else
             {
-                bool result_nullable = input_column.type->isNullable() || pattern_column.type->isNullable();
+                bool result_nullable = (input_column.type->isNullable() && !isColumnConstNotNull(input_column))
+                    || (pattern_column.type->isNullable() && !isColumnConstNotNull(pattern_column));
                 if (!result_nullable)
                 {
                     ASSERT_COLUMN_EQ(createColumn<UInt8>({1, 1, 1, 1, 1}),
@@ -2067,28 +2060,29 @@ TEST_F(Regexp, testRegexpReplace)
     auto const_string_null_column = createConstColumn<Nullable<String>>(row_size, {});
     auto const_int64_null_column = createConstColumn<Nullable<Int64>>(row_size, {});
 
+    /// regexp_replace is not supported in TiDB yet, so use raw function test
     /// case 1. regexp_replace(const, const, const [, const, const ,const])
     for (size_t i = 0; i < match_types.size(); i++)
     {
         /// test regexp_replace(str, pattern, replacement)
         ASSERT_COLUMN_EQ(createConstColumn<String>(row_size, results[i]),
-                         executeFunction("replaceRegexpAll", createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i])));
+                         executeFunction("replaceRegexpAll", {createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos)
         ASSERT_COLUMN_EQ(createConstColumn<String>(row_size, results_with_pos[i]),
-                         executeFunction("replaceRegexpAll", createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i])));
+                         executeFunction("replaceRegexpAll", {createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ)
         ASSERT_COLUMN_EQ(createConstColumn<String>(row_size, results_with_pos_occ[i]),
-                         executeFunction("replaceRegexpAll", createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i]), createConstColumn<Int64>(row_size, occ[i])));
+                         executeFunction("replaceRegexpAll", {createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i]), createConstColumn<Int64>(row_size, occ[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type)
         ASSERT_COLUMN_EQ(createConstColumn<String>(row_size, results_with_pos_occ_match_type[i]),
-                         executeFunction("replaceRegexpAll", createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i]), createConstColumn<Int64>(row_size, occ[i]), createConstColumn<String>(row_size, match_types[i])));
+                         executeFunction("replaceRegexpAll", {createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i]), createConstColumn<Int64>(row_size, occ[i]), createConstColumn<String>(row_size, match_types[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type) with binary collator
         ASSERT_COLUMN_EQ(createConstColumn<String>(row_size, results_with_pos_occ_match_type_binary[i]),
-                         executeFunction("replaceRegexpAll", {createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i]), createConstColumn<Int64>(row_size, occ[i]), createConstColumn<String>(row_size, match_types[i])}, binary_collator));
+                         executeFunction("replaceRegexpAll", {createConstColumn<String>(row_size, input_strings[i]), createConstColumn<String>(row_size, patterns[i]), createConstColumn<String>(row_size, replacements[i]), createConstColumn<Int64>(row_size, pos[i]), createConstColumn<Int64>(row_size, occ[i]), createConstColumn<String>(row_size, match_types[i])}, binary_collator, true));
     }
 
     /// case 2. regexp_replace(const, const, const [, const, const ,const]) with null value
@@ -2097,74 +2091,74 @@ TEST_F(Regexp, testRegexpReplace)
         /// test regexp_replace(str, pattern, replacement)
         bool null_result = input_string_nulls[i] || pattern_nulls[i] || replacement_nulls[i];
         ASSERT_COLUMN_EQ(null_result ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, results[i]),
-                         executeFunction("replaceRegexpAll", input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i])));
+                         executeFunction("replaceRegexpAll", {input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos)
         null_result = null_result || pos_nulls[i];
         ASSERT_COLUMN_EQ(null_result ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, results_with_pos[i]),
-                         executeFunction("replaceRegexpAll", input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i])));
+                         executeFunction("replaceRegexpAll", {input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ)
         null_result = null_result || occ_nulls[i];
         ASSERT_COLUMN_EQ(null_result ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, results_with_pos_occ[i]),
-                         executeFunction("replaceRegexpAll", input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i]), occ_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, occ[i])));
+                         executeFunction("replaceRegexpAll", {input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i]), occ_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, occ[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type)
         null_result = null_result || match_type_nulls[i];
         ASSERT_COLUMN_EQ(null_result ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, results_with_pos_occ_match_type[i]),
-                         executeFunction("replaceRegexpAll", input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i]), occ_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, occ[i]), match_type_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, match_types[i])));
+                         executeFunction("replaceRegexpAll", {input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i]), occ_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, occ[i]), match_type_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, match_types[i])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type) with binary collator
         ASSERT_COLUMN_EQ(null_result ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, results_with_pos_occ_match_type_binary[i]),
-                         executeFunction("replaceRegexpAll", {input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i]), occ_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, occ[i]), match_type_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, match_types[i])}, binary_collator));
+                         executeFunction("replaceRegexpAll", {input_string_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, input_strings[i]), pattern_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, patterns[i]), replacement_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, replacements[i]), pos_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, pos[i]), occ_nulls[i] ? const_int64_null_column : createConstColumn<Nullable<Int64>>(row_size, occ[i]), match_type_nulls[i] ? const_string_null_column : createConstColumn<Nullable<String>>(row_size, match_types[i])}, binary_collator, true));
     }
 
     /// case 3 regexp_replace(vector, const, const[, const, const, const])
     {
         /// test regexp_replace(str, pattern, replacement)
         ASSERT_COLUMN_EQ(createColumn<String>(vec_results),
-                         executeFunction("replaceRegexpAll", createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0])));
+                         executeFunction("replaceRegexpAll", {createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos)
         ASSERT_COLUMN_EQ(createColumn<String>(vec_results_with_pos),
-                         executeFunction("replaceRegexpAll", createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0])));
+                         executeFunction("replaceRegexpAll", {createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ)
         ASSERT_COLUMN_EQ(createColumn<String>(vec_results_with_pos_occ),
-                         executeFunction("replaceRegexpAll", createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0])));
+                         executeFunction("replaceRegexpAll", {createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type)
         ASSERT_COLUMN_EQ(createColumn<String>(vec_results_with_pos_occ_match_type),
-                         executeFunction("replaceRegexpAll", createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])));
+                         executeFunction("replaceRegexpAll", {createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type) with binary collator
         ASSERT_COLUMN_EQ(createColumn<String>(vec_results_with_pos_occ_match_type_binary),
-                         executeFunction("replaceRegexpAll", {createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])}, binary_collator));
+                         executeFunction("replaceRegexpAll", {createColumn<String>(input_strings), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])}, binary_collator, true));
     }
 
     /// case 4 regexp_replace(vector, const, const[, const, const, const]) with null value
     {
         /// test regexp_replace(str, pattern, replacement)
         ASSERT_COLUMN_EQ(createNullableVectorColumn<String>(vec_results, input_string_nulls),
-                         executeFunction("replaceRegexpAll", createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0])));
+                         executeFunction("replaceRegexpAll", {createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos)
         ASSERT_COLUMN_EQ(createNullableVectorColumn<String>(vec_results_with_pos, input_string_nulls),
-                         executeFunction("replaceRegexpAll", createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0])));
+                         executeFunction("replaceRegexpAll", {createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0])}, nullptr, true));
 
         /// test regexp_replace(str, pattern, replacement, pos, occ)
         ASSERT_COLUMN_EQ(createNullableVectorColumn<String>(vec_results_with_pos_occ, input_string_nulls),
-                         executeFunction("replaceRegexpAll", createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0])));
+                         executeFunction("replaceRegexpAll", {createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0])}, nullptr, true));
 
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type)
         ASSERT_COLUMN_EQ(createNullableVectorColumn<String>(vec_results_with_pos_occ_match_type, input_string_nulls),
-                         executeFunction("replaceRegexpAll", createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])));
+                         executeFunction("replaceRegexpAll", {createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])}, nullptr, true));
 
 
         /// test regexp_replace(str, pattern, replacement, pos, occ, match_type) with binary collator
         ASSERT_COLUMN_EQ(createNullableVectorColumn<String>(vec_results_with_pos_occ_match_type_binary, input_string_nulls),
-                         executeFunction("replaceRegexpAll", {createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])}, binary_collator));
+                         executeFunction("replaceRegexpAll", {createNullableVectorColumn<String>(input_strings, input_string_nulls), createConstColumn<String>(row_size, patterns[0]), createConstColumn<String>(row_size, replacements[0]), createConstColumn<Int64>(row_size, pos[0]), createConstColumn<Int64>(row_size, occ[0]), createConstColumn<String>(row_size, match_types[0])}, binary_collator, true));
     }
 }
 } // namespace tests
diff --git a/dbms/src/Functions/tests/gtest_string_left.cpp b/dbms/src/Functions/tests/gtest_string_left.cpp
index ca491bfe6fa..42a16ee6fff 100644
--- a/dbms/src/Functions/tests/gtest_string_left.cpp
+++ b/dbms/src/Functions/tests/gtest_string_left.cpp
@@ -27,8 +27,7 @@ namespace tests
 class StringLeftTest : public DB::tests::FunctionTest
 {
 public:
-    // leftUTF8(str,len) = substrUTF8(str,const 1,len)
-    static constexpr auto func_name = "substringUTF8";
+    static constexpr auto func_name = "leftUTF8";
 
     template <typename Integer>
     void testBoundary()
@@ -53,14 +52,14 @@ class StringLeftTest : public DB::tests::FunctionTest
     template <typename Integer>
     void test(const std::optional<String> & str, const std::optional<Integer> & length, const std::optional<String> & result)
     {
-        const auto start_column = createConstColumn<Int64>(1, 1);
         auto inner_test = [&](bool is_str_const, bool is_length_const) {
             bool is_one_of_args_null_const = (is_str_const && !str.has_value()) || (is_length_const && !length.has_value());
             bool is_result_const = (is_str_const && is_length_const) || is_one_of_args_null_const;
-            auto expected_res_column = is_result_const ? createConstColumn<Nullable<String>>(1, result) : createColumn<Nullable<String>>({result});
+            auto expected_res_column = is_result_const ? (is_one_of_args_null_const ? createConstColumn<Nullable<String>>(1, result) : createConstColumn<String>(1, result.value()))
+                                                       : createColumn<Nullable<String>>({result});
             auto str_column = is_str_const ? createConstColumn<Nullable<String>>(1, str) : createColumn<Nullable<String>>({str});
             auto length_column = is_length_const ? createConstColumn<Nullable<Integer>>(1, length) : createColumn<Nullable<Integer>>({length});
-            auto actual_res_column = executeFunction(func_name, str_column, start_column, length_column);
+            auto actual_res_column = executeFunction(func_name, str_column, length_column);
             ASSERT_COLUMN_EQ(expected_res_column, actual_res_column);
         };
         std::vector<bool> is_consts = {true, false};
@@ -78,7 +77,6 @@ class StringLeftTest : public DB::tests::FunctionTest
                 executeFunction(
                     func_name,
                     is_str_const ? createConstColumn<Nullable<String>>(1, "") : createColumn<Nullable<String>>({""}),
-                    createConstColumn<Int64>(1, 1),
                     is_length_const ? createConstColumn<Nullable<Integer>>(1, 0) : createColumn<Nullable<Integer>>({0})),
                 Exception);
         };
@@ -132,7 +130,6 @@ try
         executeFunction(
             func_name,
             createColumn<Nullable<String>>({big_string, origin_str, origin_str, mixed_language_str}),
-            createConstColumn<Int64>(8, 1),
             createColumn<Nullable<Int64>>({22, 12, 22, english_str.size()})));
     // case 2
     String second_case_string = "abc";
@@ -141,14 +138,12 @@ try
         executeFunction(
             func_name,
             createColumn<Nullable<String>>({second_case_string, second_case_string, second_case_string, second_case_string, second_case_string, second_case_string, second_case_string, second_case_string}),
-            createConstColumn<Int64>(8, 1),
             createColumn<Nullable<Int64>>({0, 1, 0, 1, 0, 0, 1, 1})));
     ASSERT_COLUMN_EQ(
         createColumn<Nullable<String>>({"", "a", "", "a", "", "", "a", "a"}),
         executeFunction(
             func_name,
             createConstColumn<Nullable<String>>(8, second_case_string),
-            createConstColumn<Int64>(8, 1),
             createColumn<Nullable<Int64>>({0, 1, 0, 1, 0, 0, 1, 1})));
 }
 CATCH
diff --git a/dbms/src/Functions/tests/gtest_string_lrtrim.cpp b/dbms/src/Functions/tests/gtest_string_lrtrim.cpp
index 409c8ed715b..df52257613d 100644
--- a/dbms/src/Functions/tests/gtest_string_lrtrim.cpp
+++ b/dbms/src/Functions/tests/gtest_string_lrtrim.cpp
@@ -39,16 +39,16 @@ try
 {
     // ltrim(const)
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "x "),
+        createConstColumn<String>(5, "x "),
         executeFunction("tidbLTrim", createConstColumn<Nullable<String>>(5, " x ")));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "测试 "),
+        createConstColumn<String>(5, "测试 "),
         executeFunction("tidbLTrim", createConstColumn<Nullable<String>>(5, " 测试 ")));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "x x x"),
+        createConstColumn<String>(5, "x x x"),
         executeFunction("tidbLTrim", createConstColumn<Nullable<String>>(5, "x x x")));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "测 试 "),
+        createConstColumn<String>(5, "测 试 "),
         executeFunction("tidbLTrim", createConstColumn<Nullable<String>>(5, "测 试 ")));
     ASSERT_COLUMN_EQ(
         createConstColumn<String>(5, "x "),
@@ -83,16 +83,16 @@ try
 
     // rtrim(const)
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, " x"),
+        createConstColumn<String>(5, " x"),
         executeFunction("tidbRTrim", createConstColumn<Nullable<String>>(5, " x ")));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, " 测试"),
+        createConstColumn<String>(5, " 测试"),
         executeFunction("tidbRTrim", createConstColumn<Nullable<String>>(5, " 测试 ")));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "x x x"),
+        createConstColumn<String>(5, "x x x"),
         executeFunction("tidbRTrim", createConstColumn<Nullable<String>>(5, "x x x")));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "测 试"),
+        createConstColumn<String>(5, "测 试"),
         executeFunction("tidbRTrim", createConstColumn<Nullable<String>>(5, "测 试 ")));
     ASSERT_COLUMN_EQ(
         createConstColumn<String>(5, " x"),
@@ -225,10 +225,10 @@ try
              input_iter++, lres_iter++, rres_iter++)
         {
             ASSERT_COLUMN_EQ(
-                createConstColumn<Nullable<String>>(5, *lres_iter),
+                createConstColumn<String>(5, *lres_iter),
                 executeFunction("tidbLTrim", createConstColumn<Nullable<String>>(5, *input_iter)));
             ASSERT_COLUMN_EQ(
-                createConstColumn<Nullable<String>>(5, *rres_iter),
+                createConstColumn<String>(5, *rres_iter),
                 executeFunction("tidbRTrim", createConstColumn<Nullable<String>>(5, *input_iter)));
             ASSERT_COLUMN_EQ(
                 createConstColumn<String>(5, *lres_iter),
diff --git a/dbms/src/Functions/tests/gtest_strings_cmp.cpp b/dbms/src/Functions/tests/gtest_strings_cmp.cpp
index ca9ae6562c7..7e94a7ed30e 100644
--- a/dbms/src/Functions/tests/gtest_strings_cmp.cpp
+++ b/dbms/src/Functions/tests/gtest_strings_cmp.cpp
@@ -43,7 +43,7 @@ try
         ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({1, 0, -1, std::nullopt}), executeFunction("strcmp", {createConstColumn<Nullable<String>>(4, "b"), createColumn<Nullable<String>>({"a", "b", "c", std::nullopt})}));
 
         // constant with constant
-        ASSERT_COLUMN_EQ(createConstColumn<Nullable<Int8>>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "a"), createConstColumn<Nullable<String>>(1, "b")}));
+        ASSERT_COLUMN_EQ(createConstColumn<Int8>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "a"), createConstColumn<Nullable<String>>(1, "b")}));
 
         // constant with nullable
         ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({-1}), executeFunction("strcmp", {createColumn<String>({"a"}), createColumn<Nullable<String>>({"b"})}));
@@ -65,10 +65,10 @@ try
         ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({-1, 1, 0, std::nullopt, std::nullopt}), executeFunction("strcmp", {createColumn<Nullable<String>>({"", "123", "", "", std::nullopt}), createColumn<Nullable<String>>({"123", "", "", std::nullopt, ""})}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
 
         // column with constant
-        ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({-1}), executeFunction("strcmp", {createColumn<String>({"a"}), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
-        ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({-1}), executeFunction("strcmp", {createColumn<String>({"A"}), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
-        ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({-1}), executeFunction("strcmp", {createColumn<String>({"A"}), createConstColumn<Nullable<String>>(1, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
-        ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({-1, 0, 1, 1}), executeFunction("strcmp", {createColumn<String>({"A", "B", "C", "D"}), createConstColumn<Nullable<String>>(4, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createColumn<Int8>({-1}), executeFunction("strcmp", {createColumn<String>({"a"}), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createColumn<Int8>({-1}), executeFunction("strcmp", {createColumn<String>({"A"}), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createColumn<Int8>({-1}), executeFunction("strcmp", {createColumn<String>({"A"}), createConstColumn<Nullable<String>>(1, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createColumn<Int8>({-1, 0, 1, 1}), executeFunction("strcmp", {createColumn<String>({"A", "B", "C", "D"}), createConstColumn<Nullable<String>>(4, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
 
         // constant with column
         ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({1, 0, -1, std::nullopt}), executeFunction("strcmp", {createConstColumn<Nullable<String>>(4, "b"), createColumn<Nullable<String>>({"a", "b", "c", std::nullopt})}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
@@ -76,10 +76,10 @@ try
         ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({1, 0, -1, std::nullopt}), executeFunction("strcmp", {createConstColumn<Nullable<String>>(4, "b"), createColumn<Nullable<String>>({"A", "B", "C", std::nullopt})}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
 
         // constant with constant
-        ASSERT_COLUMN_EQ(createConstColumn<Nullable<Int8>>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "a"), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
-        ASSERT_COLUMN_EQ(createConstColumn<Nullable<Int8>>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "A"), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
-        ASSERT_COLUMN_EQ(createConstColumn<Nullable<Int8>>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "a"), createConstColumn<Nullable<String>>(1, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
-        ASSERT_COLUMN_EQ(createConstColumn<Nullable<Int8>>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "A"), createConstColumn<Nullable<String>>(1, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createConstColumn<Int8>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "a"), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createConstColumn<Int8>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "A"), createConstColumn<Nullable<String>>(1, "b")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createConstColumn<Int8>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "a"), createConstColumn<Nullable<String>>(1, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
+        ASSERT_COLUMN_EQ(createConstColumn<Int8>(1, -1), executeFunction("strcmp", {createConstColumn<Nullable<String>>(1, "A"), createConstColumn<Nullable<String>>(1, "B")}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
 
         // constant with nullable
         ASSERT_COLUMN_EQ(createColumn<Nullable<Int8>>({-1}), executeFunction("strcmp", {createColumn<String>({"a"}), createColumn<Nullable<String>>({"b"})}, TiDB::ITiDBCollator::getCollator(TiDB::ITiDBCollator::UTF8MB4_GENERAL_CI)));
diff --git a/dbms/src/Functions/tests/gtest_strings_format.cpp b/dbms/src/Functions/tests/gtest_strings_format.cpp
index 2adc17afb93..2d571a9bb1b 100644
--- a/dbms/src/Functions/tests/gtest_strings_format.cpp
+++ b/dbms/src/Functions/tests/gtest_strings_format.cpp
@@ -62,6 +62,8 @@ class StringFormat : public DB::tests::FunctionTest
                      FieldType(static_cast<Native>(-9999999), 4),
                      FieldType(static_cast<Native>(-3333330), 4)}),
                 createConstColumn<Nullable<Int16>>(4, 3)));
+        /// known issue https://github.com/pingcap/tiflash/issues/4891
+        /*
         ASSERT_COLUMN_EQ(
             createColumn<Nullable<String>>({"-999.9999", "-1,000", "-1,000", "-999.999900000000000000000000000000", "-999.99990", "-1,000.0", "-1,000.00"}),
             executeFunction(
@@ -80,6 +82,7 @@ class StringFormat : public DB::tests::FunctionTest
                     1,
                     FieldType(static_cast<Native>(-9999999), 4)),
                 createConstColumn<Nullable<Int8>>(1, 3)));
+                */
         ASSERT_COLUMN_EQ(
             createColumn<Nullable<String>>({"12,332.1000", "12,332", "12,332.300000000000000000000000000000", "-12,332.30000", "-1,000.0", "-333.33", {}}),
             executeFunction(
@@ -105,6 +108,8 @@ class StringFormat : public DB::tests::FunctionTest
                      FieldType(static_cast<Native>(-9999999), 4),
                      FieldType(static_cast<Native>(-3333330), 4)}),
                 createConstColumn<Nullable<UInt16>>(4, 3)));
+        /// known issue https://github.com/pingcap/tiflash/issues/4891
+        /*
         ASSERT_COLUMN_EQ(
             createColumn<Nullable<String>>({"-999.9999", "-1,000", "-999.999900000000000000000000000000", "-999.99990", "-1,000.0", "-1,000.00"}),
             executeFunction(
@@ -123,6 +128,7 @@ class StringFormat : public DB::tests::FunctionTest
                     1,
                     FieldType(static_cast<Native>(-9999999), 4)),
                 createConstColumn<Nullable<UInt8>>(1, 3)));
+         */
     }
 
     template <typename Integer>
@@ -226,7 +232,7 @@ try
             createColumn<Nullable<Int32>>({4, 0, -1, 31, 5, 1, 2})));
     /// const, const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(1, "-1,000.000"),
+        createConstColumn<String>(1, "-1,000.000"),
         executeFunction(
             func_name,
             createConstColumn<Nullable<Float64>>(1, -999.9999),
@@ -256,7 +262,7 @@ try
             createColumn<Nullable<UInt32>>({4, 0, 31, 5, 1, 2})));
     /// const, const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(1, "-1,000.000"),
+        createConstColumn<String>(1, "-1,000.000"),
         executeFunction(
             func_name,
             createConstColumn<Nullable<Float64>>(1, -999.9999),
@@ -265,7 +271,7 @@ try
     /// float32, int
     /// const, const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(1, "12.123"),
+        createConstColumn<String>(1, "12.123"),
         executeFunction(
             func_name,
             createConstColumn<Nullable<Float32>>(1, 12.1235),
diff --git a/dbms/src/Functions/tests/gtest_strings_right.cpp b/dbms/src/Functions/tests/gtest_strings_right.cpp
index 1dbe8c7d5e3..210cb651ec6 100644
--- a/dbms/src/Functions/tests/gtest_strings_right.cpp
+++ b/dbms/src/Functions/tests/gtest_strings_right.cpp
@@ -54,7 +54,8 @@ class StringRightTest : public DB::tests::FunctionTest
         auto inner_test = [&](bool is_str_const, bool is_length_const) {
             bool is_one_of_args_null_const = (is_str_const && !str.has_value()) || (is_length_const && !length.has_value());
             bool is_result_const = (is_str_const && is_length_const) || is_one_of_args_null_const;
-            auto expected_res_column = is_result_const ? createConstColumn<Nullable<String>>(1, result) : createColumn<Nullable<String>>({result});
+            auto expected_res_column = is_result_const ? (is_one_of_args_null_const ? createConstColumn<Nullable<String>>(1, result) : createConstColumn<String>(1, result.value()))
+                                                       : createColumn<Nullable<String>>({result});
             auto str_column = is_str_const ? createConstColumn<Nullable<String>>(1, str) : createColumn<Nullable<String>>({str});
             auto length_column = is_length_const ? createConstColumn<Nullable<Integer>>(1, length) : createColumn<Nullable<Integer>>({length});
             auto actual_res_column = executeFunction(func_name, str_column, length_column);
diff --git a/dbms/src/Functions/tests/gtest_strings_search.cpp b/dbms/src/Functions/tests/gtest_strings_search.cpp
index 58bf1b34487..544ebc34df6 100644
--- a/dbms/src/Functions/tests/gtest_strings_search.cpp
+++ b/dbms/src/Functions/tests/gtest_strings_search.cpp
@@ -24,6 +24,7 @@ namespace tests
 class StringMatch : public FunctionTest
 {
 protected:
+    const String func_name = "like3Args";
     const String long_str = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzab"
                             "cdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdef"
                             "ghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl"
@@ -33,6 +34,8 @@ class StringMatch : public FunctionTest
 
     const String long_pattern = "abcdefghijklmnopqrstuvwxyz_bcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz%abcdefghijklmnopqrstuvwxyz";
 
+    ColumnWithTypeAndName escape = createConstColumn<Int32>(1, static_cast<Int32>('\\'));
+
     static ColumnWithTypeAndName toNullableVec(const std::vector<std::optional<String>> & v)
     {
         return createColumn<Nullable<String>>(v);
@@ -122,10 +125,9 @@ try
 
     auto haystack = createColumn<String>(haystack_raw, "haystack");
     auto needle = createColumn<String>(needle_raw, "needle");
-    auto escape = createConstColumn<Int32>(1, static_cast<Int32>('\\'));
     auto expected = createColumn<UInt8>(result_raw, "result");
 
-    auto result = executeFunction("like3Args", {haystack, needle, escape});
+    auto result = executeFunction(func_name, {haystack, needle, escape});
 
     ASSERT_COLUMN_EQ(expected, result);
 
@@ -155,10 +157,9 @@ try
 
     auto nullable_haystack = createColumn<Nullable<String>>(nullable_haystack_raw, "haystack");
     auto nullable_needle = createColumn<Nullable<String>>(nullable_needle_raw, "needle");
-    auto nullable_escape = createConstColumn<Nullable<Int32>>(1, static_cast<Int32>('\\'));
     auto nullable_expected = createColumn<Nullable<UInt8>>(nullable_result_raw, "result");
 
-    auto nullable_result = executeFunction("like3Args", {nullable_haystack, nullable_needle, nullable_escape});
+    auto nullable_result = executeFunction(func_name, {nullable_haystack, nullable_needle, escape});
 
     ASSERT_COLUMN_EQ(nullable_expected, nullable_result);
 }
@@ -196,10 +197,9 @@ try
 
         auto haystack = createConstColumn<Nullable<String>>(1, cas.src);
         auto needle = createColumn<Nullable<String>>(needle_raw);
-        auto escape = createConstColumn<Nullable<Int32>>(1, static_cast<Int32>('\\'));
         auto expected = createColumn<Nullable<UInt8>>(result_raw);
 
-        auto result = executeFunction("like3Args", {haystack, needle, escape});
+        auto result = executeFunction(func_name, {haystack, needle, escape});
         ASSERT_COLUMN_EQ(expected, result);
     }
 }
@@ -213,16 +213,18 @@ TEST_F(StringMatch, LikeVectorWithVector)
     ASSERT_COLUMN_EQ(
         toNullableVec(expect),
         executeFunction(
-            "like",
+            func_name,
             toNullableVec(haystack),
-            toNullableVec(needle)));
+            toNullableVec(needle),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toVec(expect),
         executeFunction(
-            "like",
+            func_name,
             toVec(haystack),
-            toVec(needle)));
+            toVec(needle),
+            escape));
 
     std::vector<std::optional<String>> haystack_null = {{}, "a"};
     std::vector<std::optional<String>> needle_null = {"我_tif%", {}};
@@ -230,9 +232,10 @@ TEST_F(StringMatch, LikeVectorWithVector)
     ASSERT_COLUMN_EQ(
         toNullableVec(expect_null),
         executeFunction(
-            "like",
+            func_name,
             toNullableVec(haystack_null),
-            toNullableVec(needle_null)));
+            toNullableVec(needle_null),
+            escape));
 }
 
 TEST_F(StringMatch, LikeConstWithVector)
@@ -243,32 +246,36 @@ TEST_F(StringMatch, LikeConstWithVector)
     ASSERT_COLUMN_EQ(
         toNullableVec(expect),
         executeFunction(
-            "like",
+            func_name,
             toConst("abcaba"),
-            toNullableVec(needle)));
+            toNullableVec(needle),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toVec(expect),
         executeFunction(
-            "like",
+            func_name,
             toConst("abcaba"),
-            toVec(needle)));
+            toVec(needle),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toVec(expect1),
         executeFunction(
-            "like",
+            func_name,
             toConst(long_str),
-            toVec(needle)));
+            toVec(needle),
+            escape));
 
     std::vector<std::optional<String>> needle_null = {{}};
     std::vector<std::optional<UInt64>> expect_null = {{}};
     ASSERT_COLUMN_EQ(
         toNullableVec(expect_null),
         executeFunction(
-            "like",
+            func_name,
             toConst("abc"),
-            toNullableVec(needle_null)));
+            toNullableVec(needle_null),
+            escape));
 }
 
 TEST_F(StringMatch, LikeVectorWithConst)
@@ -281,46 +288,52 @@ TEST_F(StringMatch, LikeVectorWithConst)
     ASSERT_COLUMN_EQ(
         toNullableVec(expect),
         executeFunction(
-            "like",
+            func_name,
             toNullableVec(haystack),
-            toConst("%aa%")));
+            toConst("%aa%"),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toVec(expect),
         executeFunction(
-            "like",
+            func_name,
             toVec(haystack),
-            toConst("%aa%")));
+            toConst("%aa%"),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toVec(expect1),
         executeFunction(
-            "like",
+            func_name,
             toVec(haystack),
-            toConst("%爱tif%")));
+            toConst("%爱tif%"),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toVec(expect2),
         executeFunction(
-            "like",
+            func_name,
             toVec(haystack),
-            toConst("%不爱tif%")));
+            toConst("%不爱tif%"),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toVec(expect3),
         executeFunction(
-            "like",
+            func_name,
             toVec(haystack),
-            toConst(long_pattern)));
+            toConst(long_pattern),
+            escape));
 
     std::vector<std::optional<String>> haystack_null = {{}};
     std::vector<std::optional<UInt64>> expect_null = {{}};
     ASSERT_COLUMN_EQ(
         toNullableVec(expect_null),
         executeFunction(
-            "like",
+            func_name,
             toNullableVec(haystack_null),
-            toConst("abc")));
+            toConst("abc"),
+            escape));
 }
 
 TEST_F(StringMatch, LikeConstWithConst)
@@ -328,30 +341,34 @@ TEST_F(StringMatch, LikeConstWithConst)
     ASSERT_COLUMN_EQ(
         toConst(1),
         executeFunction(
-            "like",
+            func_name,
             toConst("resaasfe"),
-            toConst("%aa%")));
+            toConst("%aa%"),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toConst(0),
         executeFunction(
-            "like",
+            func_name,
             toConst("abcde"),
-            toConst("%aa%")));
+            toConst("%aa%"),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toConst(1),
         executeFunction(
-            "like",
+            func_name,
             toConst("我爱tiflash"),
-            toConst("%爱tif%")));
+            toConst("%爱tif%"),
+            escape));
 
     ASSERT_COLUMN_EQ(
         toConst(0),
         executeFunction(
-            "like",
+            func_name,
             toConst("我爱tiflash"),
-            toConst("%不爱tif%")));
+            toConst("%不爱tif%"),
+            escape));
 }
 
 } // namespace tests
diff --git a/dbms/src/Functions/tests/gtest_strings_tidb_concat.cpp b/dbms/src/Functions/tests/gtest_strings_tidb_concat.cpp
index a0c06a5d6a8..24295bc079b 100644
--- a/dbms/src/Functions/tests/gtest_strings_tidb_concat.cpp
+++ b/dbms/src/Functions/tests/gtest_strings_tidb_concat.cpp
@@ -28,6 +28,7 @@ class StringTidbConcat : public DB::tests::FunctionTest
     static constexpr auto func_name = "tidbConcat";
 
     using Type = Nullable<String>;
+    using NotNullType = String;
 
     InferredDataVector<Type> test_strings = {"", "www.pingcap", "中文.测.试。。。", {}};
 };
@@ -45,7 +46,7 @@ try
                 createColumn<Type>({value})));
         // const
         ASSERT_COLUMN_EQ(
-            createConstColumn<Type>(1, value),
+            value.has_value() ? createConstColumn<NotNullType>(1, value.value()) : createConstColumn<Type>(1, value),
             executeFunction(
                 StringTidbConcat::func_name,
                 createConstColumn<Type>(1, value)));
@@ -64,7 +65,7 @@ try
             // all args is const or has only null const
             auto is_result_const = (is_value1_const && is_value2_const) || (!value1.has_value() && is_value1_const) || (!value2.has_value() && is_value2_const);
             ASSERT_COLUMN_EQ(
-                is_result_const ? createConstColumn<Type>(1, result) : createColumn<Type>({result}),
+                is_result_const ? (is_result_not_null ? createConstColumn<NotNullType>(1, result.value()) : createConstColumn<Type>(1, result)) : createColumn<Type>({result}),
                 executeFunction(
                     StringTidbConcat::func_name,
                     is_value1_const ? createConstColumn<Type>(1, value1) : createColumn<Type>({value1}),
diff --git a/dbms/src/Functions/tests/gtest_strings_trim.cpp b/dbms/src/Functions/tests/gtest_strings_trim.cpp
index be2616c4818..55c4063abb5 100644
--- a/dbms/src/Functions/tests/gtest_strings_trim.cpp
+++ b/dbms/src/Functions/tests/gtest_strings_trim.cpp
@@ -600,37 +600,37 @@ try
 {
     // trim(const)
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "x"),
+        createConstColumn<String>(5, "x"),
         executeFunction("tidbTrim", createConstColumn<Nullable<String>>(5, " x ")));
 
     // trim(const from const)
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "a"),
+        createConstColumn<String>(5, "a"),
         executeFunction("tidbTrim",
                         createConstColumn<Nullable<String>>(5, "xax"),
                         createConstColumn<Nullable<String>>(5, "x")));
 
     // trim(leading|trailing|both const from const)
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "a"),
+        createConstColumn<String>(5, "a"),
         executeFunction("tidbTrim",
                         createConstColumn<Nullable<String>>(5, "xax"),
                         createConstColumn<Nullable<String>>(5, "x"),
                         createConstColumn<Nullable<Int8>>(5, 0)));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "a"),
+        createConstColumn<String>(5, "a"),
         executeFunction("tidbTrim",
                         createConstColumn<Nullable<String>>(5, "xax"),
                         createConstColumn<Nullable<String>>(5, "x"),
                         createConstColumn<Nullable<Int8>>(5, 1)));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "ax"),
+        createConstColumn<String>(5, "ax"),
         executeFunction("tidbTrim",
                         createConstColumn<Nullable<String>>(5, "xax"),
                         createConstColumn<Nullable<String>>(5, "x"),
                         createConstColumn<Nullable<Int8>>(5, 2)));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(5, "xa"),
+        createConstColumn<String>(5, "xa"),
         executeFunction("tidbTrim",
                         createConstColumn<Nullable<String>>(5, "xax"),
                         createConstColumn<Nullable<String>>(5, "x"),
@@ -955,7 +955,7 @@ try
                  res_itr++, input_itr++)
             {
                 ASSERT_COLUMN_EQ(
-                    createConstColumn<Nullable<String>>(5, *res_itr),
+                    input_itr->has_value() ? createConstColumn<String>(5, res_itr->value()) : createConstColumn<Nullable<String>>(5, *res_itr),
                     executeFunction("tidbTrim",
                                     createConstColumn<Nullable<String>>(5, *input_itr),
                                     createConstColumn<Nullable<String>>(5, "啊啊"),
diff --git a/dbms/src/Functions/tests/gtest_substring.cpp b/dbms/src/Functions/tests/gtest_substring.cpp
index 1506b3340a6..374e38970f1 100644
--- a/dbms/src/Functions/tests/gtest_substring.cpp
+++ b/dbms/src/Functions/tests/gtest_substring.cpp
@@ -41,7 +41,7 @@ try
             createConstColumn<Nullable<Int64>>(4, 4)));
     // const, const, const
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<String>>(1, "www."),
+        createConstColumn<String>(1, "www."),
         executeFunction(
             "substringUTF8",
             createConstColumn<Nullable<String>>(1, "www.pingcap.com"),
diff --git a/dbms/src/Functions/tests/gtest_substring_index.cpp b/dbms/src/Functions/tests/gtest_substring_index.cpp
index a8208b45042..9bb4675c329 100644
--- a/dbms/src/Functions/tests/gtest_substring_index.cpp
+++ b/dbms/src/Functions/tests/gtest_substring_index.cpp
@@ -75,7 +75,9 @@ class SubstringIndexTest : public DB::tests::FunctionTest
         auto inner_test = [&](bool is_str_const, bool is_delim_const, bool is_count_const) {
             bool is_one_of_args_null_const = (is_str_const && !str.has_value()) || (is_delim_const && !delim.has_value()) || (is_count_const && !count.has_value());
             bool is_result_const = (is_str_const && is_delim_const && is_count_const) || is_one_of_args_null_const;
-            auto expected_res_column = is_result_const ? createConstColumn<Nullable<String>>(1, result) : createColumn<Nullable<String>>({result});
+            if (is_result_const && !is_one_of_args_null_const && !result.has_value())
+                throw Exception("Should not reach here");
+            auto expected_res_column = is_result_const ? (is_one_of_args_null_const ? createConstColumn<Nullable<String>>(1, result) : createConstColumn<String>(1, result.value())) : createColumn<Nullable<String>>({result});
             auto str_column = is_str_const ? createConstColumn<Nullable<String>>(1, str) : createColumn<Nullable<String>>({str});
             auto delim_column = is_delim_const ? createConstColumn<Nullable<String>>(1, delim) : createColumn<Nullable<String>>({delim});
             auto count_column = is_count_const ? createConstColumn<Nullable<Integer>>(1, count) : createColumn<Nullable<Integer>>({count});
diff --git a/dbms/src/Functions/tests/gtest_unix_timestamp.cpp b/dbms/src/Functions/tests/gtest_unix_timestamp.cpp
index 1fa02141c4c..15909a90af9 100644
--- a/dbms/src/Functions/tests/gtest_unix_timestamp.cpp
+++ b/dbms/src/Functions/tests/gtest_unix_timestamp.cpp
@@ -86,16 +86,16 @@ try
         executeFunction(func_name_dec, createConstColumn<MyDateTime>(std::make_tuple(6), 10, date_time_with_fsp_data[0])));
     /// case 2, func(nullable(not null const))
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<UInt64>>(10, date_result[0]),
+        createConstColumn<UInt64>(10, date_result[0]),
         executeFunction(func_name_int, createConstColumn<Nullable<MyDate>>(10, date_data[0])));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<UInt64>>(10, date_time_int_result[0]),
+        createConstColumn<UInt64>(10, date_time_int_result[0]),
         executeFunction(func_name_int, createConstColumn<Nullable<MyDateTime>>(std::make_tuple(0), 10, date_time_data[0])));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<Decimal64>>(std::make_tuple(12, 0), 10, date_time_decimal_result[0]),
+        createConstColumn<Decimal64>(std::make_tuple(12, 0), 10, date_time_decimal_result[0]),
         executeFunction(func_name_dec, createConstColumn<Nullable<MyDateTime>>(std::make_tuple(0), 10, date_time_data[0])));
     ASSERT_COLUMN_EQ(
-        createConstColumn<Nullable<Decimal64>>(std::make_tuple(18, 6), 10, date_time_with_fsp_result[0]),
+        createConstColumn<Decimal64>(std::make_tuple(18, 6), 10, date_time_with_fsp_result[0]),
         executeFunction(func_name_dec, createConstColumn<Nullable<MyDateTime>>(std::make_tuple(6), 10, date_time_with_fsp_data[0])));
     /// case 3, func(nullable(null const))
     ASSERT_COLUMN_EQ(
diff --git a/dbms/src/TestUtils/FunctionTestUtils.h b/dbms/src/TestUtils/FunctionTestUtils.h
index 615a58ebda5..7704c69a89f 100644
--- a/dbms/src/TestUtils/FunctionTestUtils.h
+++ b/dbms/src/TestUtils/FunctionTestUtils.h
@@ -536,7 +536,7 @@ ColumnWithTypeAndName executeFunction(
     const String & func_name,
     const ColumnsWithTypeAndName & columns,
     const TiDB::TiDBCollatorPtr & collator = nullptr,
-    bool raw_function_test = true);
+    bool raw_function_test = false);
 
 ColumnWithTypeAndName executeFunction(
     Context & context,
@@ -544,7 +544,7 @@ ColumnWithTypeAndName executeFunction(
     const ColumnNumbers & argument_column_numbers,
     const ColumnsWithTypeAndName & columns,
     const TiDB::TiDBCollatorPtr & collator = nullptr,
-    bool raw_function_test = true);
+    bool raw_function_test = false);
 
 template <typename... Args>
 ColumnWithTypeAndName executeFunction(
@@ -562,7 +562,7 @@ DataTypePtr getReturnTypeForFunction(
     const String & func_name,
     const ColumnsWithTypeAndName & columns,
     const TiDB::TiDBCollatorPtr & collator = nullptr,
-    bool raw_function_test = true);
+    bool raw_function_test = false);
 
 template <typename T>
 ColumnWithTypeAndName createNullableColumn(InferredDataVector<T> init_vec, const std::vector<Int32> & null_map, const String name = "")
@@ -687,7 +687,7 @@ class FunctionTest : public ::testing::Test
         const String & func_name,
         const ColumnsWithTypeAndName & columns,
         const TiDB::TiDBCollatorPtr & collator = nullptr,
-        bool raw_function_test = true)
+        bool raw_function_test = false)
     {
         return DB::tests::executeFunction(context, func_name, columns, collator, raw_function_test);
     }
@@ -704,7 +704,7 @@ class FunctionTest : public ::testing::Test
         const ColumnNumbers & argument_column_numbers,
         const ColumnsWithTypeAndName & columns,
         const TiDB::TiDBCollatorPtr & collator = nullptr,
-        bool raw_function_test = true)
+        bool raw_function_test = false)
     {
         return DB::tests::executeFunction(context, func_name, argument_column_numbers, columns, collator, raw_function_test);
     }