Merge pull request #1457 from kuzudb/struct-type

Add struct data type front end
kuzudb · Apr 10, 2023 · 06181ac · 06181ac
2 parents c344c83 + 30fbde8
commit 06181ac
Show file tree

Hide file tree

Showing 49 changed files with 2,543 additions and 2,325 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.11)
 
-project(Kuzu VERSION 0.0.3 LANGUAGES CXX)
+project(Kuzu VERSION 0.0.3.1 LANGUAGES CXX)
 
 find_package(Threads REQUIRED)
 

diff --git a/src/antlr4/Cypher.g4 b/src/antlr4/Cypher.g4
@@ -109,7 +109,8 @@ TO: ( 'T' | 't' ) ( 'O' | 'o' ) ;
 
 kU_DataType
     : oC_SymbolicName
-        | ( oC_SymbolicName kU_ListIdentifiers ) ;
+        | ( oC_SymbolicName kU_ListIdentifiers )
+        | oC_SymbolicName SP? '(' SP? kU_PropertyDefinitions SP? ')' ;
 
 kU_ListIdentifiers : kU_ListIdentifier ( kU_ListIdentifier )* ;
 

diff --git a/src/binder/bind/bind_copy.cpp b/src/binder/bind/bind_copy.cpp
@@ -63,13 +63,13 @@ std::unordered_map<common::property_id_t, std::string> Binder::bindPropertyToNpy
             "Number of npy files is not equal to number of properties in table {}.",
             tableSchema->tableName));
     }
-    std::unordered_map<common::property_id_t, std::string> propertyIdxToNpyMap;
+    std::unordered_map<common::property_id_t, std::string> propertyIDToNpyMap;
     for (int i = 0; i < filePaths.size(); i++) {
         auto& filePath = filePaths[i];
         auto& propertyID = tableSchema->properties[i].propertyID;
-        propertyIdxToNpyMap[propertyID] = filePath;
+        propertyIDToNpyMap[propertyID] = filePath;
     }
-    return propertyIdxToNpyMap;
+    return propertyIDToNpyMap;
 }
 
 CSVReaderConfig Binder::bindParsingOptions(

diff --git a/src/binder/bind/bind_ddl.cpp b/src/binder/bind/bind_ddl.cpp
@@ -185,18 +185,19 @@ DataType Binder::bindDataType(const std::string& dataType) {
     auto boundType = Types::dataTypeFromString(dataType);
     if (boundType.typeID == common::FIXED_LIST) {
         auto validNumericTypes = common::DataType::getNumericalTypeIDs();
-        if (find(validNumericTypes.begin(), validNumericTypes.end(), boundType.childType->typeID) ==
-            validNumericTypes.end()) {
+        auto fixedListTypeInfo = reinterpret_cast<FixedListTypeInfo*>(boundType.getExtraTypeInfo());
+        if (find(validNumericTypes.begin(), validNumericTypes.end(),
+                boundType.getChildType()->typeID) == validNumericTypes.end()) {
             throw common::BinderException(
                 "The child type of a fixed list must be a numeric type. Given: " +
-                common::Types::dataTypeToString(*boundType.childType) + ".");
+                common::Types::dataTypeToString(*boundType.getChildType()) + ".");
         }
-        if (boundType.fixedNumElementsInList == 0) {
+        if (fixedListTypeInfo->getFixedNumElementsInList() == 0) {
             // Note: the parser already guarantees that the number of elements is a non-negative
             // number. However, we still need to check whether the number of elements is 0.
             throw common::BinderException(
                 "The number of elements in a fixed list must be greater than 0. Given: " +
-                std::to_string(boundType.fixedNumElementsInList) + ".");
+                std::to_string(fixedListTypeInfo->getFixedNumElementsInList()) + ".");
         }
         auto numElementsPerPage = storage::PageUtils::getNumElementsInAPage(
             Types::getDataTypeSize(boundType), true /* hasNull */);

diff --git a/src/binder/bind/bind_reading_clause.cpp b/src/binder/bind/bind_reading_clause.cpp
@@ -52,7 +52,7 @@ std::unique_ptr<BoundReadingClause> Binder::bindUnwindClause(const ReadingClause
     auto boundExpression = expressionBinder.bindExpression(*unwindClause.getExpression());
     boundExpression = ExpressionBinder::implicitCastIfNecessary(boundExpression, VAR_LIST);
     auto aliasExpression =
-        createVariable(unwindClause.getAlias(), *boundExpression->dataType.childType);
+        createVariable(unwindClause.getAlias(), *boundExpression->dataType.getChildType());
     return make_unique<BoundUnwindClause>(std::move(boundExpression), std::move(aliasExpression));
 }
 

diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp
@@ -35,30 +35,6 @@ uint64_t SerDeser::deserializeValue<std::string>(
     return offset + valueLength;
 }
 
-template<>
-uint64_t SerDeser::serializeValue<DataType>(
-    const DataType& value, FileInfo* fileInfo, uint64_t offset) {
-    offset = SerDeser::serializeValue<DataTypeID>(value.typeID, fileInfo, offset);
-    offset = SerDeser::serializeValue<uint64_t>(value.fixedNumElementsInList, fileInfo, offset);
-    if (value.typeID == VAR_LIST || value.typeID == FIXED_LIST) {
-        offset = SerDeser::serializeValue<DataType>(*value.childType, fileInfo, offset);
-    }
-    return offset;
-}
-
-template<>
-uint64_t SerDeser::deserializeValue<DataType>(
-    DataType& value, FileInfo* fileInfo, uint64_t offset) {
-    offset = SerDeser::deserializeValue<DataTypeID>(value.typeID, fileInfo, offset);
-    offset = SerDeser::deserializeValue<uint64_t>(value.fixedNumElementsInList, fileInfo, offset);
-    if (value.typeID == VAR_LIST || value.typeID == FIXED_LIST) {
-        auto childDataType = std::make_unique<DataType>();
-        offset = SerDeser::deserializeValue<DataType>(*childDataType, fileInfo, offset);
-        value.childType = std::move(childDataType);
-    }
-    return offset;
-}
-
 template<>
 uint64_t SerDeser::serializeValue<Property>(
     const Property& value, FileInfo* fileInfo, uint64_t offset) {

diff --git a/src/common/in_mem_overflow_buffer_utils.cpp b/src/common/in_mem_overflow_buffer_utils.cpp
@@ -15,42 +15,42 @@ void InMemOverflowBufferUtils::copyString(
     dest.set(src);
 }
 
-void InMemOverflowBufferUtils::copyListNonRecursive(const uint8_t* srcValues, ku_list_t& dest,
+void InMemOverflowBufferUtils::copyListNonRecursive(const uint8_t* srcValues, ku_list_t& dst,
     const DataType& dataType, InMemOverflowBuffer& inMemOverflowBuffer) {
     InMemOverflowBufferUtils::allocateSpaceForList(
-        dest, dest.size * Types::getDataTypeSize(*dataType.childType), inMemOverflowBuffer);
-    dest.set(srcValues, dataType);
+        dst, dst.size * Types::getDataTypeSize(*dataType.getChildType()), inMemOverflowBuffer);
+    dst.set(srcValues, dataType);
 }
 
-void InMemOverflowBufferUtils::copyListRecursiveIfNested(const ku_list_t& src, ku_list_t& dest,
+void InMemOverflowBufferUtils::copyListRecursiveIfNested(const ku_list_t& src, ku_list_t& dst,
     const DataType& dataType, InMemOverflowBuffer& inMemOverflowBuffer, uint32_t srcStartIdx,
     uint32_t srcEndIdx) {
     if (src.size == 0) {
-        dest.size = 0;
+        dst.size = 0;
         return;
     }
     if (srcEndIdx == UINT32_MAX) {
         srcEndIdx = src.size - 1;
     }
     assert(srcEndIdx < src.size);
     auto numElements = srcEndIdx - srcStartIdx + 1;
-    auto elementSize = Types::getDataTypeSize(*dataType.childType);
+    auto elementSize = Types::getDataTypeSize(*dataType.getChildType());
     InMemOverflowBufferUtils::allocateSpaceForList(
-        dest, numElements * elementSize, inMemOverflowBuffer);
-    memcpy((uint8_t*)dest.overflowPtr, (uint8_t*)src.overflowPtr + srcStartIdx * elementSize,
+        dst, numElements * elementSize, inMemOverflowBuffer);
+    memcpy((uint8_t*)dst.overflowPtr, (uint8_t*)src.overflowPtr + srcStartIdx * elementSize,
         numElements * elementSize);
-    dest.size = numElements;
-    if (dataType.childType->typeID == STRING) {
-        for (auto i = 0u; i < dest.size; i++) {
+    dst.size = numElements;
+    if (dataType.getChildType()->typeID == STRING) {
+        for (auto i = 0u; i < dst.size; i++) {
             InMemOverflowBufferUtils::copyString(((ku_string_t*)src.overflowPtr)[i + srcStartIdx],
-                ((ku_string_t*)dest.overflowPtr)[i], inMemOverflowBuffer);
+                ((ku_string_t*)dst.overflowPtr)[i], inMemOverflowBuffer);
         }
     }
-    if (dataType.childType->typeID == VAR_LIST) {
-        for (auto i = 0u; i < dest.size; i++) {
+    if (dataType.getChildType()->typeID == VAR_LIST) {
+        for (auto i = 0u; i < dst.size; i++) {
             InMemOverflowBufferUtils::copyListRecursiveIfNested(
-                ((ku_list_t*)src.overflowPtr)[i + srcStartIdx], ((ku_list_t*)dest.overflowPtr)[i],
-                *dataType.childType, inMemOverflowBuffer);
+                ((ku_list_t*)src.overflowPtr)[i + srcStartIdx], ((ku_list_t*)dst.overflowPtr)[i],
+                *dataType.getChildType(), inMemOverflowBuffer);
         }
     }
 }

diff --git a/src/common/type_utils.cpp b/src/common/type_utils.cpp
@@ -58,12 +58,12 @@ std::string TypeUtils::elementToString(
 std::string TypeUtils::toString(const ku_list_t& val, const DataType& dataType) {
     std::string result = "[";
     for (auto i = 0u; i < val.size - 1; ++i) {
-        result +=
-            elementToString(*dataType.childType, reinterpret_cast<uint8_t*>(val.overflowPtr), i) +
-            ",";
+        result += elementToString(
+                      *dataType.getChildType(), reinterpret_cast<uint8_t*>(val.overflowPtr), i) +
+                  ",";
     }
-    result += elementToString(
-                  *dataType.childType, reinterpret_cast<uint8_t*>(val.overflowPtr), val.size - 1) +
+    result += elementToString(*dataType.getChildType(), reinterpret_cast<uint8_t*>(val.overflowPtr),
+                  val.size - 1) +
               "]";
     return result;
 }

diff --git a/src/common/types/ku_list.cpp b/src/common/types/ku_list.cpp
@@ -7,7 +7,7 @@ namespace common {
 
 void ku_list_t::set(const uint8_t* values, const DataType& dataType) const {
     memcpy(reinterpret_cast<uint8_t*>(overflowPtr), values,
-        size * Types::getDataTypeSize(*dataType.childType));
+        size * Types::getDataTypeSize(*dataType.getChildType()));
 }
 
 void ku_list_t::set(const std::vector<uint8_t*>& parameters, DataTypeID childTypeId) {