kuzu 0.10.1.dev42__tar.gz → 0.10.2.dev1__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuzu
-Version: 0.10.1.dev42
+Version: 0.10.2.dev1
 Summary: Highly scalable, extremely fast, easy-to-use embeddable graph database
 Home-page: https://github.com/kuzudb/kuzu
 License: MIT License

sdist/kuzu-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Kuzu VERSION 0.10.1.42 LANGUAGES CXX C)
+project(Kuzu VERSION 0.10.2.1 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)

sdist/kuzu-source/scripts/antlr4/Cypher.g4

@@ -385,7 +385,8 @@ kU_AlterOptions
         | kU_DropProperty
         | kU_RenameTable
         | kU_RenameProperty
-        | kU_AddFromToConnection;
+        | kU_AddFromToConnection
+        | kU_DropFromToConnection;
 
 kU_AddProperty
     : ADD SP (kU_IfNotExists SP)? oC_PropertyKeyName SP kU_DataType ( SP kU_Default )? ;
@@ -403,7 +404,10 @@ kU_RenameProperty
     : RENAME SP oC_PropertyKeyName SP TO SP oC_PropertyKeyName ;
 
 kU_AddFromToConnection
-    : ADD SP kU_FromToConnection ;
+    : ADD SP (kU_IfNotExists SP)? kU_FromToConnection ;
+
+kU_DropFromToConnection
+    : DROP SP (kU_IfExists SP)? kU_FromToConnection ;
 
 kU_ColumnDefinitions: kU_ColumnDefinition ( SP? ',' SP? kU_ColumnDefinition )* ;
 

sdist/kuzu-source/scripts/antlr4/hash.md5

@@ -1 +1 @@
-567a0f306e010f245ff575499552caac
+8908fae875ccf47f64fa086eefd53a1a

sdist/kuzu-source/src/antlr4/Cypher.g4

@@ -148,7 +148,8 @@ kU_AlterOptions
         | kU_DropProperty
         | kU_RenameTable
         | kU_RenameProperty
-        | kU_AddFromToConnection;
+        | kU_AddFromToConnection
+        | kU_DropFromToConnection;
 
 kU_AddProperty
     : ADD SP (kU_IfNotExists SP)? oC_PropertyKeyName SP kU_DataType ( SP kU_Default )? ;
@@ -166,7 +167,10 @@ kU_RenameProperty
     : RENAME SP oC_PropertyKeyName SP TO SP oC_PropertyKeyName ;
 
 kU_AddFromToConnection
-    : ADD SP kU_FromToConnection ;
+    : ADD SP (kU_IfNotExists SP)? kU_FromToConnection ;
+
+kU_DropFromToConnection
+    : DROP SP (kU_IfExists SP)? kU_FromToConnection ;
 
 kU_ColumnDefinitions: kU_ColumnDefinition ( SP? ',' SP? kU_ColumnDefinition )* ;
 

sdist/kuzu-source/src/binder/bind/bind_ddl.cpp

@@ -8,7 +8,6 @@
 #include "catalog/catalog.h"
 #include "catalog/catalog_entry/index_catalog_entry.h"
 #include "catalog/catalog_entry/node_table_catalog_entry.h"
-#include "catalog/catalog_entry/rel_group_catalog_entry.h"
 #include "catalog/catalog_entry/sequence_catalog_entry.h"
 #include "common/enums/extend_direction_util.h"
 #include "common/exception/binder.h"
@@ -408,8 +407,9 @@ std::unique_ptr<BoundStatement> Binder::bindAlter(const Statement& statement) {
     case AlterType::COMMENT: {
         return bindCommentOn(statement);
     }
-    case AlterType::ADD_FROM_TO_CONNECTION: {
-        return bindAddFromToConnection(statement);
+    case AlterType::ADD_FROM_TO_CONNECTION:
+    case AlterType::DROP_FROM_TO_CONNECTION: {
+        return bindAlterFromToConnection(statement);
     }
     default: {
         KU_UNREACHABLE;
@@ -491,7 +491,8 @@ std::unique_ptr<BoundStatement> Binder::bindCommentOn(const Statement& statement
     return std::make_unique<BoundAlter>(std::move(boundInfo));
 }
 
-std::unique_ptr<BoundStatement> Binder::bindAddFromToConnection(const Statement& statement) const {
+std::unique_ptr<BoundStatement> Binder::bindAlterFromToConnection(
+    const Statement& statement) const {
     auto& alter = statement.constCast<Alter>();
     auto info = alter.getInfo();
     auto extraInfo = info->extraInfo->constPtrCast<ExtraAddFromToConnection>();
@@ -500,15 +501,9 @@ std::unique_ptr<BoundStatement> Binder::bindAddFromToConnection(const Statement&
     auto dstTableEntry = bindNodeTableEntry(extraInfo->dstTableName);
     auto srcTableID = srcTableEntry->getTableID();
     auto dstTableID = dstTableEntry->getTableID();
-    auto relGroupEntry = bindRelGroupEntries({tableName})[0]->constPtrCast<RelGroupCatalogEntry>();
-    if (relGroupEntry->hasRelEntryInfo(srcTableID, dstTableID)) {
-        throw BinderException{
-            common::stringFormat("Node table pair: {}->{} already exists in the {} table.",
-                srcTableEntry->getName(), dstTableEntry->getName(), tableName)};
-    }
-    auto boundExtraInfo = std::make_unique<BoundExtraAddFromToConnection>(srcTableID, dstTableID);
-    auto boundInfo = BoundAlterInfo(AlterType::ADD_FROM_TO_CONNECTION, tableName,
-        std::move(boundExtraInfo), info->onConflict);
+    auto boundExtraInfo = std::make_unique<BoundExtraAlterFromToConnection>(srcTableID, dstTableID);
+    auto boundInfo =
+        BoundAlterInfo(info->type, tableName, std::move(boundExtraInfo), info->onConflict);
     return std::make_unique<BoundAlter>(std::move(boundInfo));
 }
 

sdist/kuzu-source/src/catalog/catalog_entry/rel_group_catalog_entry.cpp

@@ -14,11 +14,23 @@ using namespace kuzu::main;
 namespace kuzu {
 namespace catalog {
 
-void RelGroupCatalogEntry::addFromToConnection(common::table_id_t srcTableID,
-    common::table_id_t dstTableID, common::oid_t oid) {
+void RelGroupCatalogEntry::addFromToConnection(table_id_t srcTableID, table_id_t dstTableID,
+    oid_t oid) {
     relTableInfos.emplace_back(NodeTableIDPair{srcTableID, dstTableID}, oid);
 }
 
+void RelGroupCatalogEntry::dropFromToConnection(table_id_t srcTableID, table_id_t dstTableID) {
+    auto tmpInfos = relTableInfos;
+    relTableInfos.clear();
+    for (auto& tmpInfo : tmpInfos) {
+        if (tmpInfo.nodePair.srcTableID == srcTableID &&
+            tmpInfo.nodePair.dstTableID == dstTableID) {
+            continue;
+        }
+        relTableInfos.emplace_back(tmpInfo);
+    }
+}
+
 void RelTableCatalogInfo::serialize(Serializer& ser) const {
     ser.writeDebuggingInfo("nodePair");
     ser.serializeValue(nodePair);

sdist/kuzu-source/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -38,11 +38,16 @@ std::unique_ptr<TableCatalogEntry> TableCatalogEntry::alter(transaction_t timest
         newEntry->setComment(commentInfo.comment);
     } break;
     case AlterType::ADD_FROM_TO_CONNECTION: {
-        auto& fromToConnectionInfo =
-            *alterInfo.extraInfo->constPtrCast<BoundExtraAddFromToConnection>();
-        newEntry->ptrCast<RelGroupCatalogEntry>()->addFromToConnection(
-            fromToConnectionInfo.srcTableID, fromToConnectionInfo.dstTableID,
-            tables->getNextOIDNoLock());
+        auto& connectionInfo =
+            *alterInfo.extraInfo->constPtrCast<BoundExtraAlterFromToConnection>();
+        newEntry->ptrCast<RelGroupCatalogEntry>()->addFromToConnection(connectionInfo.fromTableID,
+            connectionInfo.toTableID, tables->getNextOIDNoLock());
+    } break;
+    case AlterType::DROP_FROM_TO_CONNECTION: {
+        auto& connectionInfo =
+            *alterInfo.extraInfo->constPtrCast<BoundExtraAlterFromToConnection>();
+        newEntry->ptrCast<RelGroupCatalogEntry>()->dropFromToConnection(connectionInfo.fromTableID,
+            connectionInfo.toTableID);
     } break;
     default: {
         KU_UNREACHABLE;

sdist/kuzu-source/src/catalog/catalog_set.cpp

@@ -194,7 +194,8 @@ void CatalogSet::alterTableEntry(Transaction* transaction,
     case AlterType::ADD_PROPERTY:
     case AlterType::DROP_PROPERTY:
     case AlterType::RENAME_PROPERTY:
-    case AlterType::ADD_FROM_TO_CONNECTION: {
+    case AlterType::ADD_FROM_TO_CONNECTION:
+    case AlterType::DROP_FROM_TO_CONNECTION: {
         emplaceNoLock(std::move(newEntry));
         if (transaction->shouldAppendToUndoBuffer()) {
             transaction->pushAlterCatalogEntry(*this, *entry, alterInfo);

sdist/kuzu-source/src/common/copier_config/csv_reader_config.cpp

@@ -5,6 +5,7 @@
 #include "common/exception/binder.h"
 #include "common/exception/runtime.h"
 #include "common/string_utils.h"
+#include "common/types/value/nested.h"
 
 namespace kuzu {
 namespace common {
@@ -74,6 +75,15 @@ static void bindIntParsingOption(CSVReaderConfig& config, const std::string& opt
     }
 }
 
+static void bindListParsingOption(CSVReaderConfig& config, const std::string& optionName,
+    const std::vector<std::string>& optionValue) {
+    if (optionName == "NULL_STRINGS") {
+        config.option.nullStrings = optionValue;
+    } else {
+        KU_UNREACHABLE;
+    }
+}
+
 template<uint64_t size>
 static bool hasOption(const char* const (&arr)[size], const std::string& option) {
     return std::find(std::begin(arr), std::end(arr), option) != std::end(arr);
@@ -91,6 +101,10 @@ static bool validateIntParsingOptionName(const std::string& parsingOptionName) {
     return hasOption(CopyConstants::INT_CSV_PARSING_OPTIONS, parsingOptionName);
 }
 
+static bool validateListParsingOptionName(const std::string& parsingOptionName) {
+    return hasOption(CopyConstants::LIST_CSV_PARSING_OPTIONS, parsingOptionName);
+}
+
 static bool isValidBooleanOptionValue(const Value& value, const std::string& name) {
     // Normalize and check if the string is a valid Boolean representation
     auto strValue = value.toString();
@@ -115,6 +129,7 @@ CSVReaderConfig CSVReaderConfig::construct(const case_insensitive_map_t<Value>&
         auto isValidStringParsingOption = validateStringParsingOptionName(name);
         auto isValidBoolParsingOption = validateBoolParsingOptionName(name);
         auto isValidIntParsingOption = validateIntParsingOptionName(name);
+        auto isValidListParsingOption = validateListParsingOptionName(name);
         if (isValidBoolParsingOption) {
             bindBoolParsingOption(config, name, isValidBooleanOptionValue(op.second, name));
         } else if (isValidStringParsingOption) {
@@ -129,6 +144,17 @@ CSVReaderConfig CSVReaderConfig::construct(const case_insensitive_map_t<Value>&
                     stringFormat("The type of csv parsing option {} must be a INT64.", name));
             }
             bindIntParsingOption(config, name, op.second.getValue<int64_t>());
+        } else if (isValidListParsingOption) {
+            if (op.second.getDataType() != LogicalType::LIST(LogicalType::STRING())) {
+                throw BinderException(
+                    stringFormat("The type of csv parsing option {} must be a STRING[].", name));
+            }
+            std::vector<std::string> optionValues;
+            for (auto i = 0u; i < op.second.getChildrenSize(); i++) {
+                optionValues.push_back(
+                    NestedVal::getChildVal(&op.second, i)->getValue<std::string>());
+            }
+            bindListParsingOption(config, name, optionValues);
         } else {
             throw BinderException(stringFormat("Unrecognized csv parsing option: {}.", name));
         }

sdist/kuzu-source/src/common/data_chunk/data_chunk_collection.cpp

@@ -31,18 +31,7 @@ void DataChunkCollection::append(DataChunk& chunk) {
     }
 }
 
-void DataChunkCollection::merge(DataChunk chunk) {
-    if (chunks.empty()) {
-        initTypes(chunk);
-    }
-    KU_ASSERT(chunk.getNumValueVectors() == types.size());
-    for (auto vectorIdx = 0u; vectorIdx < chunk.getNumValueVectors(); vectorIdx++) {
-        KU_ASSERT(chunk.getValueVector(vectorIdx).dataType == types[vectorIdx]);
-    }
-    chunks.push_back(std::move(chunk));
-}
-
-void DataChunkCollection::initTypes(DataChunk& chunk) {
+void DataChunkCollection::initTypes(const DataChunk& chunk) {
     types.clear();
     types.reserve(chunk.getNumValueVectors());
     for (auto vectorIdx = 0u; vectorIdx < chunk.getNumValueVectors(); vectorIdx++) {
@@ -50,7 +39,7 @@ void DataChunkCollection::initTypes(DataChunk& chunk) {
     }
 }
 
-void DataChunkCollection::allocateChunk(DataChunk& chunk) {
+void DataChunkCollection::allocateChunk(const DataChunk& chunk) {
     if (chunks.empty()) {
         types.reserve(chunk.getNumValueVectors());
         for (auto vectorIdx = 0u; vectorIdx < chunk.getNumValueVectors(); vectorIdx++) {

sdist/kuzu-source/src/common/data_chunk/data_chunk_state.cpp

@@ -1,8 +1,6 @@
 #include "common/data_chunk/data_chunk_state.h"
 
-#include "common/data_chunk/sel_vector.h"
 #include "common/system_config.h"
-#include "common/types/types.h"
 
 namespace kuzu {
 namespace common {
@@ -16,16 +14,5 @@ std::shared_ptr<DataChunkState> DataChunkState::getSingleValueDataChunkState() {
     return state;
 }
 
-void DataChunkState::slice(offset_t offset) {
-    // NOTE: this operation has performance penalty. Ideally we should directly modify selVector
-    // instead of creating a new one.
-    auto slicedSelVector = std::make_shared<SelectionVector>(DEFAULT_VECTOR_CAPACITY);
-    for (auto i = 0u; i < selVector->getSelSize() - offset; i++) {
-        slicedSelVector->getMutableBuffer()[i] = selVector->operator[](i + offset);
-    }
-    slicedSelVector->setToFiltered(selVector->getSelSize() - offset);
-    selVector = std::move(slicedSelVector);
-}
-
 } // namespace common
 } // namespace kuzu

sdist/kuzu-source/src/common/data_chunk/sel_vector.cpp

@@ -18,8 +18,8 @@ static const std::array<sel_t, DEFAULT_VECTOR_CAPACITY> INCREMENTAL_SELECTED_POS
         return selectedPos;
     }();
 
-SelectionView::SelectionView(sel_t startPos, sel_t selectedSize)
-    : selectedPositions{INCREMENTAL_SELECTED_POS.data() + startPos}, selectedSize{selectedSize},
+SelectionView::SelectionView(sel_t selectedSize)
+    : selectedPositions{INCREMENTAL_SELECTED_POS.data()}, selectedSize{selectedSize},
       state{State::STATIC} {}
 
 SelectionVector::SelectionVector() : SelectionVector{DEFAULT_VECTOR_CAPACITY} {}

sdist/kuzu-source/src/common/serializer/metadata_writer.cpp

@@ -31,24 +31,34 @@ void MetaWriter::write(const uint8_t* data, uint64_t size) {
 
 storage::PageRange MetaWriter::flush(storage::FileHandle* fileHandle,
     storage::ShadowFile& shadowFile) const {
-    auto numPagesToFlush = pages.size();
+    auto numPagesToFlush = getNumPagesToFlush();
     auto pageManager = fileHandle->getPageManager();
-    auto numPages = fileHandle->getNumPages();
     auto pageRange = pageManager->allocatePageRange(numPagesToFlush);
-    for (auto i = 0u; i < pageRange.numPages; i++) {
-        auto pageIdx = pageRange.startPageIdx + i;
-        auto insertingNewPage = pageIdx >= numPages;
+    flush(pageRange, fileHandle, shadowFile);
+    return pageRange;
+}
+
+void MetaWriter::flush(storage::PageRange allocatedPageRange, storage::FileHandle* fileHandle,
+    storage::ShadowFile& shadowFile) const {
+    KU_ASSERT(allocatedPageRange.numPages >= getNumPagesToFlush());
+    auto numPagesBeforeAllocate = allocatedPageRange.startPageIdx;
+    for (auto i = 0u; i < getNumPagesToFlush(); i++) {
+        auto pageIdx = allocatedPageRange.startPageIdx + i;
+        auto insertingNewPage = pageIdx >= numPagesBeforeAllocate;
         auto shadowPageAndFrame = storage::ShadowUtils::createShadowVersionIfNecessaryAndPinPage(
             pageIdx, insertingNewPage, *fileHandle, shadowFile);
         memcpy(shadowPageAndFrame.frame, pages[i]->getData(), KUZU_PAGE_SIZE);
         shadowFile.getShadowingFH().unpinPage(shadowPageAndFrame.shadowPage);
     }
-    return pageRange;
 }
 
 bool MetaWriter::needNewBuffer(uint64_t size) const {
     return pages.empty() || pageOffset + size > KUZU_PAGE_SIZE;
 }
 
+uint64_t MetaWriter::getPageSize() {
+    return KUZU_PAGE_SIZE;
+}
+
 } // namespace common
 } // namespace kuzu

sdist/kuzu-source/src/common/utils.cpp

@@ -25,45 +25,5 @@ bool isLittleEndian() {
     return *(uint8_t*)&testNumber == 1;
 }
 
-template<>
-bool integerFitsIn<int64_t>(int64_t) {
-    return true;
-}
-
-template<>
-bool integerFitsIn<int32_t>(int64_t val) {
-    return val >= INT32_MIN && val <= INT32_MAX;
-}
-
-template<>
-bool integerFitsIn<int16_t>(int64_t val) {
-    return val >= INT16_MIN && val <= INT16_MAX;
-}
-
-template<>
-bool integerFitsIn<int8_t>(int64_t val) {
-    return val >= INT8_MIN && val <= INT8_MAX;
-}
-
-template<>
-bool integerFitsIn<uint64_t>(int64_t val) {
-    return val >= 0;
-}
-
-template<>
-bool integerFitsIn<uint32_t>(int64_t val) {
-    return val >= 0 && val <= UINT32_MAX;
-}
-
-template<>
-bool integerFitsIn<uint16_t>(int64_t val) {
-    return val >= 0 && val <= UINT16_MAX;
-}
-
-template<>
-bool integerFitsIn<uint8_t>(int64_t val) {
-    return val >= 0 && val <= UINT8_MAX;
-}
-
 } // namespace common
 } // namespace kuzu

sdist/kuzu-source/src/function/cast_from_string_functions.cpp

@@ -847,14 +847,34 @@ void CastString::operation(const ku_string_t& input, union_entry_t& result,
         resultVector, rowToAdd, CSVOption);
 }
 
+static void setVectorNull(ValueVector* vector, uint64_t vectorPos, std::string_view strVal,
+    const CSVOption* option) {
+    auto& type = vector->dataType;
+    switch (type.getLogicalTypeID()) {
+    case LogicalTypeID::STRING: {
+        if (std::any_of(option->nullStrings.begin(), option->nullStrings.end(),
+                [&](const std::string& nullStr) { return nullStr == strVal; })) {
+            vector->setNull(vectorPos, true /* isNull */);
+            return;
+        }
+    } break;
+    default: {
+        if (isNull(strVal)) {
+            vector->setNull(vectorPos, true /* isNull */);
+            return;
+        }
+    } break;
+    }
+    vector->setNull(vectorPos, false /* isNull */);
+}
+
 void CastString::copyStringToVector(ValueVector* vector, uint64_t vectorPos,
     std::string_view strVal, const CSVOption* option) {
     auto& type = vector->dataType;
-    if (strVal.empty() || isNull(strVal) || isAnyType(strVal)) {
-        vector->setNull(vectorPos, true /* isNull */);
+    setVectorNull(vector, vectorPos, strVal, option);
+    if (vector->isNull(vectorPos)) {
         return;
     }
-    vector->setNull(vectorPos, false /* isNull */);
     switch (type.getLogicalTypeID()) {
     case LogicalTypeID::INT128: {
         int128_t val = 0;

sdist/kuzu-source/src/function/gds/gds.cpp

@@ -2,6 +2,7 @@
 
 #include "binder/binder.h"
 #include "binder/query/reading_clause/bound_table_function_call.h"
+#include "catalog/catalog.h"
 #include "catalog/catalog_entry/rel_group_catalog_entry.h"
 #include "common/exception/binder.h"
 #include "graph/graph_entry_set.h"

sdist/kuzu-source/src/function/vector_hash_functions.cpp

@@ -1,5 +1,6 @@
 #include "function/hash/vector_hash_functions.h"
 
+#include "common/data_chunk/sel_vector.h"
 #include "common/system_config.h"
 #include "common/type_utils.h"
 #include "function/hash/hash_functions.h"
@@ -19,8 +20,8 @@ static void executeOnValue(const ValueVector& operand, sel_t operandPos, ValueVe
 
 template<typename OPERAND_TYPE, typename RESULT_TYPE>
 void UnaryHashFunctionExecutor::execute(const ValueVector& operand,
-    const SelectionVector& operandSelectVec, ValueVector& result,
-    const SelectionVector& resultSelectVec) {
+    const SelectionView& operandSelectVec, ValueVector& result,
+    const SelectionView& resultSelectVec) {
     auto resultValues = (RESULT_TYPE*)result.getData();
     if (operand.hasNoNullsGuarantee()) {
         if (operandSelectVec.isUnfiltered()) {
@@ -69,8 +70,8 @@ static void executeOnValue(const common::ValueVector& left, common::sel_t leftPo
         result.getValue<RESULT_TYPE>(resultPos));
 }
 
-static void validateSelState(const common::SelectionVector& leftSelVec,
-    const common::SelectionVector& rightSelVec, const common::SelectionVector& resultSelVec) {
+static void validateSelState(const SelectionView& leftSelVec, const SelectionView& rightSelVec,
+    const SelectionView& resultSelVec) {
     auto leftSelSize = leftSelVec.getSelSize();
     auto rightSelSize = rightSelVec.getSelSize();
     auto resultSelSize = resultSelVec.getSelSize();
@@ -87,9 +88,9 @@ static void validateSelState(const common::SelectionVector& leftSelVec,
 
 template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
 void BinaryHashFunctionExecutor::execute(const common::ValueVector& left,
-    const common::SelectionVector& leftSelVec, const common::ValueVector& right,
-    const common::SelectionVector& rightSelVec, common::ValueVector& result,
-    const common::SelectionVector& resultSelVec) {
+    const SelectionView& leftSelVec, const common::ValueVector& right,
+    const SelectionView& rightSelVec, common::ValueVector& result,
+    const SelectionView& resultSelVec) {
     validateSelState(leftSelVec, rightSelVec, resultSelVec);
     result.resetAuxiliaryBuffer();
     if (leftSelVec.getSelSize() != 1 && rightSelVec.getSelSize() != 1) {
@@ -143,8 +144,8 @@ static std::unique_ptr<ValueVector> computeDataVecHash(const ValueVector& operan
     return hashVector;
 }
 
-static void finalizeDataVecHash(const ValueVector& operand, const SelectionVector& operandSelVec,
-    ValueVector& result, const SelectionVector& resultSelVec, ValueVector& tmpHashVec) {
+static void finalizeDataVecHash(const ValueVector& operand, const SelectionView& operandSelVec,
+    ValueVector& result, const SelectionView& resultSelVec, ValueVector& tmpHashVec) {
     for (auto i = 0u; i < operandSelVec.getSelSize(); i++) {
         auto pos = operandSelVec[i];
         auto resultPos = resultSelVec[i];
@@ -162,15 +163,14 @@ static void finalizeDataVecHash(const ValueVector& operand, const SelectionVecto
     }
 }
 
-static void computeListVectorHash(const ValueVector& operand,
-    const SelectionVector& operandSelectVec, ValueVector& result,
-    const SelectionVector& resultSelectVec) {
+static void computeListVectorHash(const ValueVector& operand, const SelectionView& operandSelectVec,
+    ValueVector& result, const SelectionView& resultSelectVec) {
     auto dataVecHash = computeDataVecHash(operand);
     finalizeDataVecHash(operand, operandSelectVec, result, resultSelectVec, *dataVecHash);
 }
 
-static void computeStructVecHash(const ValueVector& operand, const SelectionVector& operandSelVec,
-    ValueVector& result, const SelectionVector& resultSelVec) {
+static void computeStructVecHash(const ValueVector& operand, const SelectionView& operandSelVec,
+    ValueVector& result, const SelectionView& resultSelVec) {
     switch (operand.dataType.getLogicalTypeID()) {
     case LogicalTypeID::NODE: {
         KU_ASSERT(0 == common::StructType::getFieldIdx(operand.dataType, InternalKeyword::ID));
@@ -188,12 +188,12 @@ static void computeStructVecHash(const ValueVector& operand, const SelectionVect
         VectorHashFunction::computeHash(*StructVector::getFieldVector(&operand, 0 /* idx */),
             operandSelVec, result, resultSelVec);
         auto tmpHashVector = std::make_unique<ValueVector>(LogicalType::HASH());
+        SelectionView tmpSel(resultSelVec.getSelSize());
         for (auto i = 1u; i < StructType::getNumFields(operand.dataType); i++) {
             auto fieldVector = StructVector::getFieldVector(&operand, i);
-            VectorHashFunction::computeHash(*fieldVector, operandSelVec, *tmpHashVector,
+            VectorHashFunction::computeHash(*fieldVector, operandSelVec, *tmpHashVector, tmpSel);
+            VectorHashFunction::combineHash(*tmpHashVector, tmpSel, result, resultSelVec, result,
                 resultSelVec);
-            VectorHashFunction::combineHash(*tmpHashVector, resultSelVec, result, resultSelVec,
-                result, resultSelVec);
         }
     } break;
     default:
@@ -202,8 +202,8 @@ static void computeStructVecHash(const ValueVector& operand, const SelectionVect
 }
 
 void VectorHashFunction::computeHash(const ValueVector& operand,
-    const SelectionVector& operandSelectVec, ValueVector& result,
-    const SelectionVector& resultSelectVec) {
+    const SelectionView& operandSelectVec, ValueVector& result,
+    const SelectionView& resultSelectVec) {
     result.state = operand.state;
     KU_ASSERT(result.dataType.getLogicalTypeID() == LogicalType::HASH().getLogicalTypeID());
     TypeUtils::visit(
@@ -225,9 +225,9 @@ void VectorHashFunction::computeHash(const ValueVector& operand,
         });
 }
 
-void VectorHashFunction::combineHash(const ValueVector& left, const SelectionVector& leftSelVec,
-    const ValueVector& right, const SelectionVector& rightSelVec, ValueVector& result,
-    const SelectionVector& resultSelVec) {
+void VectorHashFunction::combineHash(const ValueVector& left, const SelectionView& leftSelVec,
+    const ValueVector& right, const SelectionView& rightSelVec, ValueVector& result,
+    const SelectionView& resultSelVec) {
     KU_ASSERT(left.dataType.getLogicalTypeID() == LogicalType::HASH().getLogicalTypeID());
     KU_ASSERT(left.dataType.getLogicalTypeID() == right.dataType.getLogicalTypeID());
     KU_ASSERT(left.dataType.getLogicalTypeID() == result.dataType.getLogicalTypeID());

sdist/kuzu-source/src/include/binder/binder.h

@@ -111,7 +111,7 @@ public:
     std::unique_ptr<BoundStatement> bindDropProperty(const parser::Statement& statement) const;
     std::unique_ptr<BoundStatement> bindRenameProperty(const parser::Statement& statement) const;
     std::unique_ptr<BoundStatement> bindCommentOn(const parser::Statement& statement) const;
-    std::unique_ptr<BoundStatement> bindAddFromToConnection(
+    std::unique_ptr<BoundStatement> bindAlterFromToConnection(
         const parser::Statement& statement) const;
 
     std::vector<PropertyDefinition> bindPropertyDefinitions(

sdist/kuzu-source/src/include/binder/ddl/bound_alter_info.h

@@ -110,14 +110,14 @@ struct BoundExtraCommentInfo final : BoundExtraAlterInfo {
     }
 };
 
-struct BoundExtraAddFromToConnection final : BoundExtraAlterInfo {
-    common::table_id_t srcTableID;
-    common::table_id_t dstTableID;
+struct BoundExtraAlterFromToConnection final : BoundExtraAlterInfo {
+    common::table_id_t fromTableID;
+    common::table_id_t toTableID;
 
-    BoundExtraAddFromToConnection(common::table_id_t srcTableID, common::table_id_t dstTableID)
-        : srcTableID{srcTableID}, dstTableID{dstTableID} {}
+    BoundExtraAlterFromToConnection(common::table_id_t fromTableID, common::table_id_t toTableID)
+        : fromTableID{fromTableID}, toTableID{toTableID} {}
     std::unique_ptr<BoundExtraAlterInfo> copy() const override {
-        return std::make_unique<BoundExtraAddFromToConnection>(*this);
+        return std::make_unique<BoundExtraAlterFromToConnection>(*this);
     }
 };
 

sdist/kuzu-source/src/include/catalog/catalog_entry/rel_group_catalog_entry.h

@@ -80,6 +80,7 @@ public:
 
     void addFromToConnection(common::table_id_t srcTableID, common::table_id_t dstTableID,
         common::oid_t oid);
+    void dropFromToConnection(common::table_id_t srcTableID, common::table_id_t dstTableID);
     void serialize(common::Serializer& serializer) const override;
     static std::unique_ptr<RelGroupCatalogEntry> deserialize(common::Deserializer& deserializer);
     std::string toCypher(const ToCypherInfo& info) const override;

sdist/kuzu-source/src/include/common/constants.h

@@ -134,11 +134,14 @@ struct CopyConstants {
     static constexpr std::array DEFAULT_CSV_DELIMITER_SEARCH_SPACE = {',', ';', '\t', '|'};
     static constexpr std::array DEFAULT_CSV_QUOTE_SEARCH_SPACE = {'"', '\''};
     static constexpr std::array DEFAULT_CSV_ESCAPE_SEARCH_SPACE = {'"', '\\', '\''};
+    static constexpr std::array DEFAULT_CSV_NULL_STRINGS = {""};
 
     static constexpr const char* INT_CSV_PARSING_OPTIONS[] = {"SKIP", "SAMPLE_SIZE"};
     static constexpr uint64_t DEFAULT_CSV_SKIP_NUM = 0;
     static constexpr uint64_t DEFAULT_CSV_TYPE_DEDUCTION_SAMPLE_SIZE = 256;
 
+    static constexpr const char* LIST_CSV_PARSING_OPTIONS[] = {"NULL_STRINGS"};
+
     // metadata columns used to populate CSV warnings
     static constexpr std::array SHARED_WARNING_DATA_COLUMN_NAMES = {"blockIdx", "offsetInBlock",
         "startByteOffset", "endByteOffset"};

sdist/kuzu-source/src/include/common/copier_config/csv_reader_config.h

@@ -25,6 +25,7 @@ struct CSVOption {
     bool setDelim;
     bool setQuote;
     bool setHeader;
+    std::vector<std::string> nullStrings;
 
     CSVOption()
         : escapeChar{CopyConstants::DEFAULT_CSV_ESCAPE_CHAR},
@@ -39,7 +40,8 @@ struct CSVOption {
           setEscape{CopyConstants::DEFAULT_CSV_SET_DIALECT},
           setDelim{CopyConstants::DEFAULT_CSV_SET_DIALECT},
           setQuote{CopyConstants::DEFAULT_CSV_SET_DIALECT},
-          setHeader{CopyConstants::DEFAULT_CSV_SET_DIALECT} {}
+          setHeader{CopyConstants::DEFAULT_CSV_SET_DIALECT},
+          nullStrings{CopyConstants::DEFAULT_CSV_NULL_STRINGS[0]} {}
 
     EXPLICIT_COPY_DEFAULT_MOVE(CSVOption);
 
@@ -85,7 +87,7 @@ struct CSVOption {
                                             // sampleSize is 0
           allowUnbracedList{other.allowUnbracedList}, ignoreErrors{other.ignoreErrors},
           autoDetection{other.autoDetection}, setEscape{other.setEscape}, setDelim{other.setDelim},
-          setQuote{other.setQuote}, setHeader{other.setHeader} {}
+          setQuote{other.setQuote}, setHeader{other.setHeader}, nullStrings{other.nullStrings} {}
 };
 
 struct CSVReaderConfig {