Merge pull request #1759 from kuzudb/struct-field-name

Struct-field-name printing

src/binder/bind/bind_ddl.cpp

@@ -151,7 +151,6 @@ std::vector<Property> Binder::bindProperties(
                 StringUtils::string_format("PropertyName: {} is an internal reserved propertyName.",
                     propertyNameDataType.first));
         }
-        StringUtils::toUpper(propertyNameDataType.second);
         auto dataType = bindDataType(propertyNameDataType.second);
         boundPropertyNameDataTypes.emplace_back(propertyNameDataType.first, dataType);
         boundPropertyNames.emplace(propertyNameDataType.first);

src/binder/bound_statement_result.cpp

@@ -5,9 +5,9 @@
 namespace kuzu {
 namespace binder {
 
-std::unique_ptr<BoundStatementResult> BoundStatementResult::createSingleStringColumnResult() {
+std::unique_ptr<BoundStatementResult> BoundStatementResult::createSingleStringColumnResult(
+    std::string columnName) {
     auto result = std::make_unique<BoundStatementResult>();
-    auto columnName = std::string("result");
     auto value = std::make_unique<common::Value>(
         common::LogicalType{common::LogicalTypeID::STRING}, columnName);
     auto stringColumn = std::make_shared<LiteralExpression>(std::move(value), columnName);

src/common/types/types.cpp

@@ -81,12 +81,6 @@ std::unique_ptr<ExtraTypeInfo> FixedListTypeInfo::copy() const {
     return std::make_unique<FixedListTypeInfo>(childType->copy(), fixedNumElementsInList);
 }
 
-StructField::StructField(std::string name, std::unique_ptr<LogicalType> type)
-    : name{std::move(name)}, type{std::move(type)} {
-    // Note: struct field name is case-insensitive.
-    StringUtils::toUpper(this->name);
-}
-
 bool StructField::operator==(const kuzu::common::StructField& other) const {
     return *type == *other.type;
 }
@@ -98,7 +92,9 @@ std::unique_ptr<StructField> StructField::copy() const {
 StructTypeInfo::StructTypeInfo(std::vector<std::unique_ptr<StructField>> fields)
     : fields{std::move(fields)} {
     for (auto i = 0u; i < this->fields.size(); i++) {
-        fieldNameToIdxMap.emplace(this->fields[i]->getName(), i);
+        auto fieldName = this->fields[i]->getName();
+        StringUtils::toUpper(fieldName);
+        fieldNameToIdxMap.emplace(std::move(fieldName), i);
     }
 }
 
@@ -281,11 +277,12 @@ void LogicalType::setPhysicalType() {
 
 LogicalType LogicalTypeUtils::dataTypeFromString(const std::string& dataTypeString) {
     LogicalType dataType;
-    if (dataTypeString.ends_with("[]")) {
+    auto upperDataTypeString = StringUtils::toUpperCase(dataTypeString);
+    if (upperDataTypeString.ends_with("[]")) {
         dataType.typeID = LogicalTypeID::VAR_LIST;
         dataType.extraTypeInfo = std::make_unique<VarListTypeInfo>(std::make_unique<LogicalType>(
             dataTypeFromString(dataTypeString.substr(0, dataTypeString.size() - 2))));
-    } else if (dataTypeString.ends_with("]")) {
+    } else if (upperDataTypeString.ends_with("]")) {
         dataType.typeID = LogicalTypeID::FIXED_LIST;
         auto leftBracketPos = dataTypeString.find('[');
         auto rightBracketPos = dataTypeString.find(']');
@@ -296,7 +293,7 @@ LogicalType LogicalTypeUtils::dataTypeFromString(const std::string& dataTypeStri
             nullptr, 0 /* base */);
         dataType.extraTypeInfo =
             std::make_unique<FixedListTypeInfo>(std::move(childType), fixedNumElementsInList);
-    } else if (dataTypeString.starts_with("STRUCT")) {
+    } else if (upperDataTypeString.starts_with("STRUCT")) {
         dataType.typeID = LogicalTypeID::STRUCT;
         auto leftBracketPos = dataTypeString.find('(');
         auto rightBracketPos = dataTypeString.find_last_of(')');
@@ -324,33 +321,34 @@ LogicalType LogicalTypeUtils::dataTypeFromString(const std::string& dataTypeStri
 }
 
 LogicalTypeID LogicalTypeUtils::dataTypeIDFromString(const std::string& dataTypeIDString) {
-    if ("INTERNAL_ID" == dataTypeIDString) {
+    auto upperDataTypeIDString = StringUtils::toUpperCase(dataTypeIDString);
+    if ("INTERNAL_ID" == upperDataTypeIDString) {
         return LogicalTypeID::INTERNAL_ID;
-    } else if ("INT64" == dataTypeIDString) {
+    } else if ("INT64" == upperDataTypeIDString) {
         return LogicalTypeID::INT64;
-    } else if ("INT32" == dataTypeIDString) {
+    } else if ("INT32" == upperDataTypeIDString) {
         return LogicalTypeID::INT32;
-    } else if ("INT16" == dataTypeIDString) {
+    } else if ("INT16" == upperDataTypeIDString) {
         return LogicalTypeID::INT16;
-    } else if ("INT" == dataTypeIDString) {
+    } else if ("INT" == upperDataTypeIDString) {
         return LogicalTypeID::INT32;
-    } else if ("DOUBLE" == dataTypeIDString) {
+    } else if ("DOUBLE" == upperDataTypeIDString) {
         return LogicalTypeID::DOUBLE;
-    } else if ("FLOAT" == dataTypeIDString) {
+    } else if ("FLOAT" == upperDataTypeIDString) {
         return LogicalTypeID::FLOAT;
-    } else if ("BOOLEAN" == dataTypeIDString) {
+    } else if ("BOOLEAN" == upperDataTypeIDString) {
         return LogicalTypeID::BOOL;
-    } else if ("BYTEA" == dataTypeIDString || "BLOB" == dataTypeIDString) {
+    } else if ("BYTEA" == upperDataTypeIDString || "BLOB" == upperDataTypeIDString) {
         return LogicalTypeID::BLOB;
-    } else if ("STRING" == dataTypeIDString) {
+    } else if ("STRING" == upperDataTypeIDString) {
         return LogicalTypeID::STRING;
-    } else if ("DATE" == dataTypeIDString) {
+    } else if ("DATE" == upperDataTypeIDString) {
         return LogicalTypeID::DATE;
-    } else if ("TIMESTAMP" == dataTypeIDString) {
+    } else if ("TIMESTAMP" == upperDataTypeIDString) {
         return LogicalTypeID::TIMESTAMP;
-    } else if ("INTERVAL" == dataTypeIDString) {
+    } else if ("INTERVAL" == upperDataTypeIDString) {
         return LogicalTypeID::INTERVAL;
-    } else if ("SERIAL" == dataTypeIDString) {
+    } else if ("SERIAL" == upperDataTypeIDString) {
         return LogicalTypeID::SERIAL;
     } else {
         throw NotImplementedException("Cannot parse dataTypeID: " + dataTypeIDString);

src/include/binder/bound_explain.h

@@ -11,7 +11,8 @@ class BoundExplain : public BoundStatement {
     explicit BoundExplain(
         std::unique_ptr<BoundStatement> statementToExplain, common::ExplainType explainType)
         : BoundStatement{common::StatementType::EXPLAIN,
-              BoundStatementResult::createSingleStringColumnResult()},
+              BoundStatementResult::createSingleStringColumnResult(
+                  "explain result" /* columnName */)},
           statementToExplain{std::move(statementToExplain)}, explainType{explainType} {}
 
     inline BoundStatement* getStatementToExplain() const { return statementToExplain.get(); }

src/include/binder/bound_statement_result.h

@@ -17,7 +17,8 @@ class BoundStatementResult {
         return std::make_unique<BoundStatementResult>();
     }
 
-    static std::unique_ptr<BoundStatementResult> createSingleStringColumnResult();
+    static std::unique_ptr<BoundStatementResult> createSingleStringColumnResult(
+        std::string columnName = "result");
 
     inline void addColumn(
         std::shared_ptr<Expression> column, expression_vector expressionToCollect) {

src/include/common/string_utils.h

@@ -29,6 +29,12 @@ class StringUtils {
         std::transform(input.begin(), input.end(), input.begin(), ::toupper);
     }
 
+    static std::string toUpperCase(const std::string& input) {
+        auto result = input;
+        toUpper(result);
+        return result;
+    }
+
     static void toLower(std::string& input) {
         std::transform(input.begin(), input.end(), input.begin(), ::tolower);
     }

src/include/common/types/types.h

@@ -157,7 +157,8 @@ class StructField {
 
 public:
     StructField() : type{std::make_unique<LogicalType>()} {}
-    StructField(std::string name, std::unique_ptr<LogicalType> type);
+    StructField(std::string name, std::unique_ptr<LogicalType> type)
+        : name{std::move(name)}, type{std::move(type)} {};
 
     inline bool operator!=(const StructField& other) const { return !(*this == other); }
     inline std::string getName() const { return name; }

src/include/function/list/operations/base_list_sort_operation.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "common/string_utils.h"
 #include "common/vector/value_vector.h"
 
 namespace kuzu {
@@ -9,7 +10,7 @@ namespace operation {
 struct BaseListSortOperation {
 public:
     static inline bool isAscOrder(const std::string& sortOrder) {
-        std::string upperSortOrder = toUpperCase(sortOrder);
+        std::string upperSortOrder = common::StringUtils::toUpperCase(sortOrder);
         if (upperSortOrder == "ASC") {
             return true;
         } else if (upperSortOrder == "DESC") {
@@ -20,7 +21,7 @@ struct BaseListSortOperation {
     }
 
     static inline bool isNullFirst(const std::string& nullOrder) {
-        std::string upperNullOrder = toUpperCase(nullOrder);
+        std::string upperNullOrder = common::StringUtils::toUpperCase(nullOrder);
         if (upperNullOrder == "NULLS FIRST") {
             return true;
         } else if (upperNullOrder == "NULLS LAST") {
@@ -30,12 +31,6 @@ struct BaseListSortOperation {
         }
     }
 
-    static inline std::string toUpperCase(const std::string& str) {
-        std::string upperStr = str;
-        std::transform(upperStr.begin(), upperStr.end(), upperStr.begin(), ::toupper);
-        return upperStr;
-    }
-
     template<typename T>
     static void sortValues(common::list_entry_t& input, common::list_entry_t& result,
         common::ValueVector& inputVector, common::ValueVector& resultVector, bool ascOrder,

src/processor/mapper/map_path_property_probe.cpp

@@ -23,7 +23,8 @@ static std::vector<ft_col_idx_t> getColIdxToScan(
     std::vector<ft_col_idx_t> colIndicesToScan;
     for (auto i = 1u; i < nodeStructFields.size(); ++i) {
         auto field = nodeStructFields[i];
-        colIndicesToScan.push_back(propertyNameToColumnIdx.at(field->getName()));
+        auto upperFieldName = common::StringUtils::toUpperCase(field->getName());
+        colIndicesToScan.push_back(propertyNameToColumnIdx.at(upperFieldName));
     }
     return colIndicesToScan;
 }

test/c_api/connection_test.cpp

@@ -173,7 +173,7 @@ TEST_F(CApiConnectionTest, GetNodePropertyNames) {
         "\tname STRING(PRIMARY KEY)\n"
         "\tlength INT32\n"
         "\tnote STRING\n"
-        "\tdescription STRUCT(RATING:DOUBLE, VIEWS:INT64, RELEASE:TIMESTAMP, FILM:DATE)\n"
+        "\tdescription STRUCT(rating:DOUBLE, views:INT64, release:TIMESTAMP, film:DATE)\n"
         "\tcontent BLOB\n");
     free(result);
 }

test/c_api/value_test.cpp

@@ -322,19 +322,19 @@ TEST_F(CApiValueTest, GetStructFieldName) {
     auto flatTuple = kuzu_query_result_get_next(result);
     auto value = kuzu_flat_tuple_get_value(flatTuple, 0);
     auto fieldName = kuzu_value_get_struct_field_name(value, 0);
-    ASSERT_STREQ(fieldName, "RATING");
+    ASSERT_STREQ(fieldName, "rating");
     free(fieldName);
 
     fieldName = kuzu_value_get_struct_field_name(value, 1);
-    ASSERT_STREQ(fieldName, "VIEWS");
+    ASSERT_STREQ(fieldName, "views");
     free(fieldName);
 
     fieldName = kuzu_value_get_struct_field_name(value, 2);
-    ASSERT_STREQ(fieldName, "RELEASE");
+    ASSERT_STREQ(fieldName, "release");
     free(fieldName);
 
     fieldName = kuzu_value_get_struct_field_name(value, 3);
-    ASSERT_STREQ(fieldName, "FILM");
+    ASSERT_STREQ(fieldName, "film");
     free(fieldName);
 
     kuzu_value_destroy(value);

test/runner/e2e_ddl_test.cpp

@@ -831,5 +831,9 @@ TEST_F(TinySnbDDLTest, RenamePropertyRecovery) {
     renameProperty(TransactionTestType::RECOVERY);
 }
 
+TEST_F(TinySnbDDLTest, dasd) {
+    conn->query(" Profile create node table npytable1 (id INT64,i32 INT32, PRIMARY KEY(id));");
+}
+
 } // namespace testing
 } // namespace kuzu

test/test_files/copy/copy_node_parquet.test

@@ -8,11 +8,11 @@
 -LOG SubsetTest
 -STATEMENT MATCH (row:tableOfTypes) WHERE row.id >= 20 AND row.id <= 24 RETURN row.id, row.int64Column, row.doubleColumn, row.booleanColumn, row.dateColumn, row.timestampColumn, row.stringColumn, row.listOfInt64, row.listOfString, row.listOfListOfInt64, row.fixedSizeList, row.listOfFixedSizeList, row.structColumn;
 ---- 5
-20|0|57.579280|True|2094-08-19|1731-09-26 03:30:08|OdM|[85,11,98,6]|[wl7evae,lLtQIMJI,vNvYnjt27]|[[131,129]]|[297,283,26]|[[36,165,199],[182,108,165],[17,120,181],[193,171,93]]|{ID: 717, NAME: 3oOf}
-21|7|64.630960|False|2090-07-13|1307-01-26 03:31:08|AjbxHQThEtDDlOjbzMjCQSXlvGQEjcFLykESrnFHwPKX|[53,44,76,78]|[V0yNTz60W2i4J,LN3F2erCELm]|[[191,62],[64,259,183,130,116],[49,29,222,249,128],[222,169,22,80],[206,59]]|[114,108,207]|[[53,135,64],[173,101,155],[173,161,11],[140,113,18]]|{ID: 956, NAME: GNX5sv9V}
-22|71|37.963386|True|2048-04-24|1455-07-26 03:07:03|dRvHHdyNXYfSUcicaxBoQEKQUfgex|[74]|[GOLV1]|[[139,156,218],[148,187,62],[158,118],[297,151]]|[258,1,50]|[[34,123,13],[84,122,133]]|{ID: 838, NAME: gRdEkZSI8qQ7dIH}
-23|58|42.774957|False|2043-08-19|1181-10-16 18:19:43|ISImRVpUjynGMFRQyYmeIUVjM|[16,38,98,61,2]|[EzPWolZ2iCsga46o,lbhcKq7DDPeiX,yaxsyrbzolAyVWlxj,5Rlse62CKuIitVf4,yKOx0P]|[[95,209,75,7],[197],[69,244],[164,160,153,125]]|[55,59,114]|[[80,52,187],[64,175,142],[148,141,185],[90,51,49]]|{ID: 682, NAME: 06SBnT}
-24|75|53.813224|False|1971-12-05|1942-10-24 09:30:16|naDlQ|[94,17,22]|[gVYovI30hQyC,b6OpP]|[[81,66],[255,44],[37]]|[262,288,66]|[[34,178,128]]|{ID: 185, NAME: 7xymBThq}
+20|0|57.579280|True|2094-08-19|1731-09-26 03:30:08|OdM|[85,11,98,6]|[wl7evae,lLtQIMJI,vNvYnjt27]|[[131,129]]|[297,283,26]|[[36,165,199],[182,108,165],[17,120,181],[193,171,93]]|{ID: 717, name: 3oOf}
+21|7|64.630960|False|2090-07-13|1307-01-26 03:31:08|AjbxHQThEtDDlOjbzMjCQSXlvGQEjcFLykESrnFHwPKX|[53,44,76,78]|[V0yNTz60W2i4J,LN3F2erCELm]|[[191,62],[64,259,183,130,116],[49,29,222,249,128],[222,169,22,80],[206,59]]|[114,108,207]|[[53,135,64],[173,101,155],[173,161,11],[140,113,18]]|{ID: 956, name: GNX5sv9V}
+22|71|37.963386|True|2048-04-24|1455-07-26 03:07:03|dRvHHdyNXYfSUcicaxBoQEKQUfgex|[74]|[GOLV1]|[[139,156,218],[148,187,62],[158,118],[297,151]]|[258,1,50]|[[34,123,13],[84,122,133]]|{ID: 838, name: gRdEkZSI8qQ7dIH}
+23|58|42.774957|False|2043-08-19|1181-10-16 18:19:43|ISImRVpUjynGMFRQyYmeIUVjM|[16,38,98,61,2]|[EzPWolZ2iCsga46o,lbhcKq7DDPeiX,yaxsyrbzolAyVWlxj,5Rlse62CKuIitVf4,yKOx0P]|[[95,209,75,7],[197],[69,244],[164,160,153,125]]|[55,59,114]|[[80,52,187],[64,175,142],[148,141,185],[90,51,49]]|{ID: 682, name: 06SBnT}
+24|75|53.813224|False|1971-12-05|1942-10-24 09:30:16|naDlQ|[94,17,22]|[gVYovI30hQyC,b6OpP]|[[81,66],[255,44],[37]]|[262,288,66]|[[34,178,128]]|{ID: 185, name: 7xymBThq}
 
 -LOG CheckNumLinesTest
 -STATEMENT MATCH (row:tableOfTypes) RETURN count(*)

test/test_files/demo_db/demo_db.test

@@ -114,10 +114,10 @@ Kitchener|2
 -LOG ReturnVarLen
 -STATEMENT MATCH (a:User)-[e:Follows*1..2]->(b:User) WHERE a.name = 'Adam' RETURN b.name, e;
 ---- 4
-Karissa|{_NODES: [{_ID: 0:0, NAME: Adam, AGE: 30},{_ID: 0:1, NAME: Karissa, AGE: 40}], _RELS: [{_ID: 2:0, SINCE: 2020}]}
-Noura|{_NODES: [{_ID: 0:0, NAME: Adam, AGE: 30},{_ID: 0:2, NAME: Zhang, AGE: 50},{_ID: 0:3, NAME: Noura, AGE: 25}], _RELS: [{_ID: 2:1, SINCE: 2020},{_ID: 2:3, SINCE: 2022}]}
-Zhang|{_NODES: [{_ID: 0:0, NAME: Adam, AGE: 30},{_ID: 0:1, NAME: Karissa, AGE: 40},{_ID: 0:2, NAME: Zhang, AGE: 50}], _RELS: [{_ID: 2:0, SINCE: 2020},{_ID: 2:2, SINCE: 2021}]}
-Zhang|{_NODES: [{_ID: 0:0, NAME: Adam, AGE: 30},{_ID: 0:2, NAME: Zhang, AGE: 50}], _RELS: [{_ID: 2:1, SINCE: 2020}]}
+Karissa|{_nodes: [{_id: 0:0, name: Adam, age: 30},{_id: 0:1, name: Karissa, age: 40}], _rels: [{_id: 2:0, since: 2020}]}
+Noura|{_nodes: [{_id: 0:0, name: Adam, age: 30},{_id: 0:2, name: Zhang, age: 50},{_id: 0:3, name: Noura, age: 25}], _rels: [{_id: 2:1, since: 2020},{_id: 2:3, since: 2022}]}
+Zhang|{_nodes: [{_id: 0:0, name: Adam, age: 30},{_id: 0:1, name: Karissa, age: 40},{_id: 0:2, name: Zhang, age: 50}], _rels: [{_id: 2:0, since: 2020},{_id: 2:2, since: 2021}]}
+Zhang|{_nodes: [{_id: 0:0, name: Adam, age: 30},{_id: 0:2, name: Zhang, age: 50}], _rels: [{_id: 2:1, since: 2020}]}
 
 -LOG ShortestPath
 -STATEMENT MATCH (a:User)-[e* SHORTEST 1..4]->(b:City) WHERE a.name = 'Adam' RETURN b.name, length(e) AS length;