regression-io · ruze00 · Apr 7, 2024 · Mar 4, 2024 · Mar 4, 2024 · Mar 4, 2024
diff --git a/src/binder/bind/bind_query.cpp b/src/binder/bind/bind_query.cpp
@@ -36,7 +36,7 @@ void validateIsAllUnionOrUnionAll(const BoundRegularQuery& regularQuery) {
     }
     if ((0 < unionAllExpressionCounter) &&
         (unionAllExpressionCounter < regularQuery.getNumSingleQueries() - 1)) {
-        throw BinderException("Union and union all can't be used together.");
+        throw BinderException("Union and union all can not be used together.");
     }
 }
 

diff --git a/src/binder/bind_expression/bind_function_expression.cpp b/src/binder/bind_expression/bind_function_expression.cpp
@@ -1,7 +1,6 @@
 #include "binder/binder.h"
 #include "binder/expression/expression_util.h"
 #include "binder/expression/function_expression.h"
-#include "binder/expression/literal_expression.h"
 #include "binder/expression/property_expression.h"
 #include "binder/expression_binder.h"
 #include "common/exception/binder.h"
@@ -13,6 +12,7 @@
 
 using namespace kuzu::common;
 using namespace kuzu::parser;
+using namespace kuzu::function;
 
 namespace kuzu {
 namespace binder {
@@ -58,24 +58,21 @@ std::shared_ptr<Expression> ExpressionBinder::bindScalarFunctionExpression(
         childrenTypes.push_back(child->dataType);
     }
     auto functions = context->getCatalog()->getFunctions(context->getTx());
-    auto function = ku_dynamic_cast<function::Function*, function::ScalarFunction*>(
+    auto function = ku_dynamic_cast<Function*, function::ScalarFunction*>(
         function::BuiltInFunctionsUtils::matchFunction(functionName, childrenTypes, functions));
     expression_vector childrenAfterCast;
     std::unique_ptr<function::FunctionBindData> bindData;
     if (functionName == CAST_FUNC_NAME) {
-        // If the expression to cast already has the same type as the target type, skip casting.
-        if (children.size() == 2) {
-            auto targetTypeStr = (ku_dynamic_cast<Expression&, LiteralExpression&>(*children[1]))
-                                     .getValue()
-                                     ->getValue<std::string>();
-            auto outputType = binder::Binder::bindDataType(targetTypeStr);
-            if (*outputType == children[0]->dataType) {
-                return children[0];
-            }
-        }
         bindData = function->bindFunc(children, function);
-        childrenAfterCast.push_back(
-            implicitCastIfNecessary(children[0], function->parameterTypeIDs[0]));
+        if (bindData == nullptr) {
+            return children[0];
+        }
+        auto childAfterCast = children[0];
+        // See castBindFunc for explanation.
+        if (children[0]->getDataType().getLogicalTypeID() == LogicalTypeID::ANY) {
+            childAfterCast = implicitCastIfNecessary(children[0], LogicalTypeID::STRING);
+        }
+        childrenAfterCast.push_back(std::move(childAfterCast));
     } else {
         for (auto i = 0u; i < children.size(); ++i) {
             auto targetType = function->isVarLength ? function->parameterTypeIDs[0] :

diff --git a/src/function/built_in_function_utils.cpp b/src/function/built_in_function_utils.cpp
@@ -92,9 +92,6 @@ Function* BuiltInFunctionsUtils::matchFunction(const std::string& name,
     uint32_t minCost = UINT32_MAX;
     for (auto& function : functionSet) {
         auto func = reinterpret_cast<Function*>(function.get());
-        if (name == CAST_FUNC_NAME) {
-            return func;
-        }
         auto cost = getFunctionCost(inputTypes, func, isOverload);
         if (cost == UINT32_MAX) {
             continue;

diff --git a/src/function/cast/cast_fixed_list.cpp b/src/function/cast/cast_fixed_list.cpp
@@ -155,7 +155,7 @@ void CastFixedList::stringtoFixedListCastExecFunction<UnaryFunctionExecutor>(
     const std::vector<std::shared_ptr<ValueVector>>& params, ValueVector& result, void* dataPtr) {
     KU_ASSERT(params.size() == 1);
     const auto& param = params[0];
-    auto option = &reinterpret_cast<CastFunctionBindData*>(dataPtr)->csvConfig.option;
+    auto option = &reinterpret_cast<CastFunctionBindData*>(dataPtr)->option;
     if (param->state->isFlat()) {
         auto inputPos = param->state->selVector->selectedPositions[0];
         auto resultPos = result.state->selVector->selectedPositions[0];
@@ -197,7 +197,7 @@ void CastFixedList::stringtoFixedListCastExecFunction<CastChildFunctionExecutor>
     const std::vector<std::shared_ptr<ValueVector>>& params, ValueVector& result, void* dataPtr) {
     KU_ASSERT(params.size() == 1);
     auto numOfEntries = reinterpret_cast<CastFunctionBindData*>(dataPtr)->numOfEntries;
-    auto option = &reinterpret_cast<CastFunctionBindData*>(dataPtr)->csvConfig.option;
+    auto option = &reinterpret_cast<CastFunctionBindData*>(dataPtr)->option;
     auto inputVector = params[0].get();
     for (auto i = 0u; i < numOfEntries; i++) {
         result.setNull(i, inputVector->isNull(i));

diff --git a/src/function/cast_from_string_functions.cpp b/src/function/cast_from_string_functions.cpp
@@ -823,144 +823,143 @@ void CastString::operation(const ku_string_t& input, union_entry_t& result,
 }
 
 void CastString::copyStringToVector(
-    ValueVector* vector, uint64_t rowToAdd, std::string_view strVal, const CSVOption* option) {
+    ValueVector* vector, uint64_t vectorPos, std::string_view strVal, const CSVOption* option) {
     auto& type = vector->dataType;
-
     if (strVal.empty() || isNull(strVal)) {
-        vector->setNull(rowToAdd, true /* isNull */);
+        vector->setNull(vectorPos, true /* isNull */);
         return;
-    } else {
-        vector->setNull(rowToAdd, false /* isNull */);
     }
+    vector->setNull(vectorPos, false /* isNull */);
     switch (type.getLogicalTypeID()) {
     case LogicalTypeID::INT128: {
         int128_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::INT64: {
         int64_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::INT32: {
         int32_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::INT16: {
         int16_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::INT8: {
         int8_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::UINT64: {
         uint64_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::UINT32: {
         uint32_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::UINT16: {
         uint16_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::UINT8: {
         uint8_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::FLOAT: {
         float val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::DOUBLE: {
         double val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::BOOL: {
         bool val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::BLOB: {
         blob_t val;
-        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, rowToAdd, option);
+        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, vectorPos, option);
     } break;
     case LogicalTypeID::UUID: {
         ku_uuid_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val.value);
+        vector->setValue(vectorPos, val.value);
     } break;
     case LogicalTypeID::STRING: {
         if (!utf8proc::Utf8Proc::isValid(strVal.data(), strVal.length())) {
             throw CopyException{"Invalid UTF8-encoded string."};
         }
-        StringVector::addString(vector, rowToAdd, strVal.data(), strVal.length());
+        StringVector::addString(vector, vectorPos, strVal.data(), strVal.length());
     } break;
     case LogicalTypeID::DATE: {
         date_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::TIMESTAMP_NS: {
         timestamp_ns_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::TIMESTAMP_MS: {
         timestamp_ms_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::TIMESTAMP_SEC: {
         timestamp_sec_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::TIMESTAMP_TZ: {
         timestamp_tz_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::TIMESTAMP: {
         timestamp_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::INTERVAL: {
         interval_t val;
         CastStringHelper::cast(strVal.data(), strVal.length(), val);
-        vector->setValue(rowToAdd, val);
+        vector->setValue(vectorPos, val);
     } break;
     case LogicalTypeID::MAP: {
         map_entry_t val;
-        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, rowToAdd, option);
+        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, vectorPos, option);
     } break;
     case LogicalTypeID::VAR_LIST: {
         list_entry_t val;
-        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, rowToAdd, option);
+        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, vectorPos, option);
     } break;
     case LogicalTypeID::FIXED_LIST: {
-        CastStringHelper::castToFixedList(strVal.data(), strVal.length(), vector, rowToAdd, option);
+        CastStringHelper::castToFixedList(
+            strVal.data(), strVal.length(), vector, vectorPos, option);
     } break;
     case LogicalTypeID::STRUCT: {
         struct_entry_t val;
-        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, rowToAdd, option);
+        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, vectorPos, option);
     } break;
     case LogicalTypeID::UNION: {
         union_entry_t val;
-        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, rowToAdd, option);
+        CastStringHelper::cast(strVal.data(), strVal.length(), val, vector, vectorPos, option);
     } break;
     default: {
         KU_UNREACHABLE;

diff --git a/src/function/vector_cast_functions.cpp b/src/function/vector_cast_functions.cpp
@@ -10,6 +10,7 @@
 #include "function/cast/functions/cast_rdf_variant.h"
 
 using namespace kuzu::common;
+using namespace kuzu::binder;
 
 namespace kuzu {
 namespace function {
@@ -1003,35 +1004,38 @@ function_set CastToUInt8Function::getFunctionSet() {
     return result;
 }
 
-std::unique_ptr<FunctionBindData> CastAnyFunction::bindFunc(
+static std::unique_ptr<FunctionBindData> castBindFunc(
     const binder::expression_vector& arguments, Function* function) {
-    // check the size of the arguments
-    if (arguments.size() != 2) {
-        throw BinderException(stringFormat(
-            "Invalid number of arguments for given function CAST. Expected: 2, Actual: {}.",
-            arguments.size()));
+    KU_ASSERT(arguments.size() == 2);
+    // Bind target type.
+    if (arguments[1]->expressionType != ExpressionType::LITERAL) {
+        throw BinderException(
+            stringFormat("Second parameter of CAST function must be an literal."));
     }
-
+    auto literalExpr = ku_dynamic_cast<Expression*, LiteralExpression*>(arguments[1].get());
+    auto targetTypeStr = literalExpr->getValue()->getValue<std::string>();
+    auto targetType = binder::Binder::bindDataType(targetTypeStr);
+    if (*targetType == arguments[0]->getDataType()) { // No need to cast.
+        return nullptr;
+    }
+    // Assign default type if input is ANY type, e.g. NULL
     auto inputTypeID = arguments[0]->dataType.getLogicalTypeID();
     if (inputTypeID == LogicalTypeID::ANY) {
         inputTypeID = LogicalTypeID::STRING;
     }
-    auto str = ((binder::LiteralExpression&)*arguments[1]).getValue()->getValue<std::string>();
-    auto outputType = binder::Binder::bindDataType(str);
     auto func = ku_dynamic_cast<Function*, ScalarFunction*>(function);
-    func->name = "CAST_TO_" + str;
-    func->parameterTypeIDs[0] = inputTypeID;
+    func->name = "CAST_TO_" + targetTypeStr;
     func->execFunc =
-        CastFunction::bindCastFunction(func->name, inputTypeID, outputType->getLogicalTypeID())
+        CastFunction::bindCastFunction(func->name, inputTypeID, targetType->getLogicalTypeID())
             ->execFunc;
-    return std::make_unique<function::CastFunctionBindData>(std::move(outputType));
+    return std::make_unique<function::CastFunctionBindData>(std::move(targetType));
 }
 
 function_set CastAnyFunction::getFunctionSet() {
     function_set result;
     result.push_back(std::make_unique<ScalarFunction>(CAST_FUNC_NAME,
-        std::vector<LogicalTypeID>{LogicalTypeID::ANY}, LogicalTypeID::ANY, nullptr, nullptr,
-        bindFunc, false));
+        std::vector<LogicalTypeID>{LogicalTypeID::ANY, LogicalTypeID::STRING}, LogicalTypeID::ANY,
+        nullptr, nullptr, castBindFunc, false));
     return result;
 }
 

diff --git a/src/include/function/cast/cast_function_bind_data.h b/src/include/function/cast/cast_function_bind_data.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "common/copier_config/csv_reader_config.h"
+#include "function/function.h"
+
+namespace kuzu {
+namespace function {
+
+struct CastFunctionBindData : public FunctionBindData {
+    // We don't allow configuring delimiters, ... in CAST function.
+    // For performance purpose, we generate a default option object during binding time.
+    common::CSVOption option;
+    // TODO(Mahn): the following field should be removed once we refactor fixed list.
+    uint64_t numOfEntries;
+
+    explicit CastFunctionBindData(std::unique_ptr<common::LogicalType> dataType)
+        : FunctionBindData{std::move(dataType)} {}
+};
+
+} // namespace function
+} // namespace kuzu
diff --git a/src/include/function/cast/functions/cast_from_string_functions.h b/src/include/function/cast/functions/cast_from_string_functions.h
@@ -14,7 +14,7 @@ namespace function {
 
 struct CastString {
     static void copyStringToVector(
-        ValueVector* vector, uint64_t rowToAdd, std::string_view strVal, const CSVOption* option);
+        ValueVector* vector, uint64_t vectorPos, std::string_view strVal, const CSVOption* option);
 
     template<typename T>
     static inline bool tryCast(const ku_string_t& input, T& result) {

diff --git a/src/include/function/cast/vector_cast_functions.h b/src/include/function/cast/vector_cast_functions.h
@@ -98,8 +98,6 @@ struct CastToUInt8Function {
 };
 
 struct CastAnyFunction {
-    static std::unique_ptr<FunctionBindData> bindFunc(
-        const binder::expression_vector& arguments, Function* function);
     static function_set getFunctionSet();
 };
 

diff --git a/src/include/function/function.h b/src/include/function/function.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "binder/expression/expression.h"
-#include "common/copier_config/csv_reader_config.h"
 
 namespace kuzu {
 namespace function {
@@ -15,14 +14,6 @@ struct FunctionBindData {
     virtual ~FunctionBindData() = default;
 };
 
-struct CastFunctionBindData : public FunctionBindData {
-    common::CSVReaderConfig csvConfig;
-    uint64_t numOfEntries;
-
-    explicit CastFunctionBindData(std::unique_ptr<common::LogicalType> dataType)
-        : FunctionBindData{std::move(dataType)} {}
-};
-
 struct Function;
 using scalar_bind_func = std::function<std::unique_ptr<FunctionBindData>(
     const binder::expression_vector&, Function* definition)>;