cast string to list

dataset/load-from-test/bracket_fail.csv

@@ -0,0 +1 @@
+"(()"

dataset/load-from-test/change_config.csv

@@ -0,0 +1,4 @@
+list | str
+'(this | is a word | normal not escape | ~' ( ) | , ~~ ~' )'|'try escape ~~'
+'(escape | is escape success? ~~)'|' ~' ( ) do not need to escape sepeical | ()'
+'(~~ ~' not work also this "~'" )'|'nu'

dataset/load-from-test/conversion_fail.csv

@@ -0,0 +1 @@
+"[432412, 34234, 23424]"

dataset/load-from-test/delim_fail.csv

@@ -0,0 +1 @@
+"((hello),(bdfadf),)"

dataset/load-from-test/quote_fail.csv

@@ -0,0 +1 @@
+'[23, 432, 234]'

dataset/load-from-test/should_pass.csv

@@ -0,0 +1,7 @@
+"[[1,3,423,124,43242],[432]]"
+"      [   [   1   ,3,    423   ,   124,43242     ]  ,   [   432    ]]"
+"[   [   1   ,3,    423   ,   124,43242     ]      ,      [432]]      "
+"[,[], [1, 2, 3]]"
+"[null, NULL, Null, nUll, nuLl, nulL, nuLL, NUll, NuLl     , NulL, [1, 2, 3]]"
+"[[], [], []  ]"
+"[,      ,]"

dataset/load-from-test/single_quote.csv

@@ -0,0 +1 @@
+"['fdsfdsfe werw]"

dataset/load-from-test/single_quote2.csv

@@ -0,0 +1 @@
+"[[' this is a signle quote]]"

dataset/load-from-test/single_struct.csv

@@ -0,0 +1 @@
+"[{32, 32]"

src/binder/bind/bind_graph_pattern.cpp

@@ -11,6 +11,7 @@
 #include "catalog/rel_table_schema.h"
 #include "common/exception/binder.h"
 #include "common/string_utils.h"
+#include "function/cast/cast_utils.h"
 #include "main/client_context.h"
 
 using namespace kuzu::common;
@@ -424,10 +425,13 @@ std::shared_ptr<RelExpression> Binder::createRecursiveQueryRel(const parser::Rel
 std::pair<uint64_t, uint64_t> Binder::bindVariableLengthRelBound(
     const kuzu::parser::RelPattern& relPattern) {
     auto recursiveInfo = relPattern.getRecursiveInfo();
-    auto lowerBound = TypeUtils::convertToUint32(recursiveInfo->lowerBound.c_str());
+    uint32_t lowerBound;
+    function::simpleIntegerCast(
+        recursiveInfo->lowerBound.c_str(), recursiveInfo->lowerBound.length(), lowerBound);
     auto upperBound = clientContext->varLengthExtendMaxDepth;
     if (!recursiveInfo->upperBound.empty()) {
-        upperBound = TypeUtils::convertToUint32(recursiveInfo->upperBound.c_str());
+        function::simpleIntegerCast(
+            recursiveInfo->upperBound.c_str(), recursiveInfo->upperBound.length(), upperBound);
     }
     if (lowerBound > upperBound) {
         throw BinderException(

src/common/type_utils.cpp

@@ -8,16 +8,6 @@
 namespace kuzu {
 namespace common {
 
-uint32_t TypeUtils::convertToUint32(const char* data) {
-    std::istringstream iss(data);
-    uint32_t val;
-    if (!(iss >> val)) {
-        throw ConversionException(
-            StringUtils::string_format("Failed to convert {} to uint32_t", data));
-    }
-    return val;
-}
-
 std::string TypeUtils::castValueToString(
     const LogicalType& dataType, uint8_t* value, void* vector) {
     auto valueVector = reinterpret_cast<ValueVector*>(vector);

src/function/CMakeLists.txt

@@ -7,6 +7,7 @@ add_library(kuzu_function
         built_in_aggregate_functions.cpp
         built_in_vector_functions.cpp
         built_in_table_functions.cpp
+        cast_utils.cpp
         comparison_functions.cpp
         find_function.cpp
         scalar_macro_function.cpp

src/function/cast_utils.cpp

@@ -0,0 +1,57 @@
+#include "function/cast/cast_utils.h"
+
+namespace kuzu {
+namespace function {
+
+bool tryCastToBool(const char* input, uint64_t len, bool& result) {
+    common::StringUtils::removeCStringWhiteSpaces(input, len);
+
+    switch (len) {
+    case 1: {
+        char c = std::tolower(*input);
+        if (c == 't' || c == '1') {
+            result = true;
+            return true;
+        } else if (c == 'f' || c == '0') {
+            result = false;
+            return true;
+        }
+        return false;
+    }
+    case 4: {
+        auto t = std::tolower(input[0]);
+        auto r = std::tolower(input[1]);
+        auto u = std::tolower(input[2]);
+        auto e = std::tolower(input[3]);
+        if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
+            result = true;
+            return true;
+        }
+        return false;
+    }
+    case 5: {
+        auto f = std::tolower(input[0]);
+        auto a = std::tolower(input[1]);
+        auto l = std::tolower(input[2]);
+        auto s = std::tolower(input[3]);
+        auto e = std::tolower(input[4]);
+        if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
+            result = false;
+            return true;
+        }
+        return false;
+    }
+    default:
+        return false;
+    }
+}
+
+void castStringToBool(const char* input, uint64_t len, bool& result) {
+    if (!tryCastToBool(input, len, result)) {
+        throw common::ConversionException(
+            "Cast failed. " + std::string{input, len} + " is not in BOOL range.");
+    }
+}
+
+} // namespace function
+} // namespace kuzu

src/include/common/type_utils.h

@@ -15,7 +15,6 @@ namespace common {
 class TypeUtils {
 
 public:
-    static uint32_t convertToUint32(const char* data);
     template<typename T>
     static inline std::string toString(const T& val, void* valueVector = nullptr) {
         static_assert(std::is_same<T, int64_t>::value || std::is_same<T, int32_t>::value ||

src/include/function/cast/cast_functions.h

@@ -2,12 +2,12 @@
 
 #include <cassert>
 
+#include "cast_utils.h"
 #include "common/exception/runtime.h"
 #include "common/string_utils.h"
 #include "common/type_utils.h"
 #include "common/types/blob.h"
 #include "common/vector/value_vector.h"
-#include "numeric_cast.h"
 
 namespace kuzu {
 namespace function {

src/include/function/cast/numeric_cast.h → src/include/function/cast/cast_utils.h

@@ -6,55 +6,14 @@
 #include "common/string_utils.h"
 #include "common/type_utils.h"
 #include "common/types/ku_string.h"
+#include "common/vector/value_vector.h"
 #include "fast_float.h"
 #include "numeric_limits.h"
 
 namespace kuzu {
 namespace function {
 
-static bool tryCastToBool(const char* input, uint64_t len, bool& result) {
-    common::StringUtils::removeCStringWhiteSpaces(input, len);
-
-    switch (len) {
-    case 1: {
-        char c = std::tolower(*input);
-        if (c == 't' || c == '1') {
-            result = true;
-            return true;
-        } else if (c == 'f' || c == '0') {
-            result = false;
-            return true;
-        }
-        return false;
-    }
-    case 4: {
-        auto t = std::tolower(input[0]);
-        auto r = std::tolower(input[1]);
-        auto u = std::tolower(input[2]);
-        auto e = std::tolower(input[3]);
-        if (t == 't' && r == 'r' && u == 'u' && e == 'e') {
-            result = true;
-            return true;
-        }
-        return false;
-    }
-    case 5: {
-        auto f = std::tolower(input[0]);
-        auto a = std::tolower(input[1]);
-        auto l = std::tolower(input[2]);
-        auto s = std::tolower(input[3]);
-        auto e = std::tolower(input[4]);
-        if (f == 'f' && a == 'a' && l == 'l' && s == 's' && e == 'e') {
-            result = false;
-            return true;
-        }
-        return false;
-    }
-    default:
-        return false;
-    }
-}
-
+// cast string to numerical
 template<typename T>
 struct IntegerCastData {
     using Result = T;
@@ -86,6 +45,11 @@ struct IntegerCastOperation {
     }
 };
 
+// cast string to bool
+bool tryCastToBool(const char* input, uint64_t len, bool& result);
+void castStringToBool(const char* input, uint64_t len, bool& result);
+
+// cast to numerical values
 // TODO: support exponent + decimal
 template<class T, bool NEGATIVE, bool ALLOW_EXPONENT = false, class OP = IntegerCastOperation>
 static bool integerCastLoop(const char* input, uint64_t len, T& result) {
@@ -190,13 +154,6 @@ static void doubleCast(const char* input, uint64_t len, T& result,
     }
 }
 
-static void castStringToBool(const char* input, uint64_t len, bool& result) {
-    if (!tryCastToBool(input, len, result)) {
-        throw common::ConversionException(
-            "Cast failed. " + std::string{input, len} + " is not in BOOL range.");
-    }
-}
-
 template<typename T>
 static inline T castStringToNum(const char* input, uint64_t len,
     const common::LogicalType& type = common::LogicalType{common::LogicalTypeID::ANY}) {
@@ -213,21 +170,21 @@ inline uint64_t castStringToNum(const char* input, uint64_t len, const common::L
 }
 
 template<>
-inline uint32_t castStringToNum(const char* input, uint64_t len, const common::LogicalType& type) {
+uint32_t castStringToNum(const char* input, uint64_t len, const common::LogicalType& type) {
     uint32_t result;
     simpleIntegerCast<uint32_t, false>(input, len, result, type);
     return result;
 }
 
 template<>
-inline uint16_t castStringToNum(const char* input, uint64_t len, const common::LogicalType& type) {
+uint16_t castStringToNum(const char* input, uint64_t len, const common::LogicalType& type) {
     uint16_t result;
     simpleIntegerCast<uint16_t, false>(input, len, result, type);
     return result;
 }
 
 template<>
-inline uint8_t castStringToNum(const char* input, uint64_t len, const common::LogicalType& type) {
+uint8_t castStringToNum(const char* input, uint64_t len, const common::LogicalType& type) {
     uint8_t result;
     simpleIntegerCast<uint8_t, false>(input, len, result, type);
     return result;

src/include/function/cast/vector_cast_functions.h

@@ -125,6 +125,10 @@ struct CastToBlobVectorFunction : public VectorCastFunction {
     static vector_function_definitions getDefinitions();
 };
 
+struct CastToBoolVectorFunction : public VectorCastFunction {
+    static vector_function_definitions getDefinitions();
+};
+
 struct CastToDoubleVectorFunction : public VectorCastFunction {
     static vector_function_definitions getDefinitions();
 };
@@ -169,9 +173,5 @@ struct CastToUInt8VectorFunction : public VectorCastFunction {
     static vector_function_definitions getDefinitions();
 };
 
-struct CastToBoolVectorFunction : public VectorCastFunction {
-    static vector_function_definitions getDefinitions();
-};
-
 } // namespace function
 } // namespace kuzu

src/include/storage/in_mem_storage_structure/in_mem_column_chunk.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "common/types/types.h"
-#include "function/cast/numeric_cast.h"
+#include "function/cast/cast_utils.h"
 #include "storage/storage_structure/in_mem_file.h"
 #include "storage/store/table_copy_utils.h"
 #include <arrow/array/array_base.h>

src/include/storage/store/column_chunk.h

@@ -5,7 +5,7 @@
 #include "common/types/types.h"
 #include "common/vector/value_vector.h"
 #include "compression.h"
-#include "function/cast/numeric_cast.h"
+#include "function/cast/cast_utils.h"
 #include "storage/buffer_manager/bm_file_handle.h"
 #include "storage/wal/wal.h"
 #include "transaction/transaction.h"

src/parser/transform/transform_expression.cpp

@@ -1,5 +1,5 @@
 #include "common/string_utils.h"
-#include "function/cast/numeric_cast.h"
+#include "function/cast/cast_utils.h"
 #include "parser/expression/parsed_case_expression.h"
 #include "parser/expression/parsed_function_expression.h"
 #include "parser/expression/parsed_literal_expression.h"

src/processor/operator/persistent/reader/csv/base_csv_reader.cpp

@@ -347,7 +347,8 @@ add_row : {
         // escaped quote, return to quoted state and store escape position
         escapePositions.push_back(position - start);
         goto in_quotes;
-    } else if (buffer[position] == csvReaderConfig.delimiter) {
+    } else if (buffer[position] == csvReaderConfig.delimiter ||
+               buffer[position] == csvReaderConfig.listEndChar) {
         // delimiter, add value
         goto add_value;
     } else if (isNewLine(buffer[position])) {