kuzu 0.10.1.dev42__tar.gz → 0.10.1.dev43__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuzu
-Version: 0.10.1.dev42
+Version: 0.10.1.dev43
 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.1.43 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/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/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/data_chunk/data_chunk_collection.h

@@ -12,28 +12,22 @@ public:
     DELETE_COPY_DEFAULT_MOVE(DataChunkCollection);
 
     void append(DataChunk& chunk);
-    inline const std::vector<common::DataChunk>& getChunks() const { return chunks; }
-    inline std::vector<common::DataChunk>& getChunksUnsafe() { return chunks; }
-    inline uint64_t getNumChunks() const { return chunks.size(); }
-    inline const DataChunk& getChunk(uint64_t idx) const {
+    const std::vector<DataChunk>& getChunks() const { return chunks; }
+    std::vector<DataChunk>& getChunksUnsafe() { return chunks; }
+    uint64_t getNumChunks() const { return chunks.size(); }
+    const DataChunk& getChunk(uint64_t idx) const {
         KU_ASSERT(idx < chunks.size());
         return chunks[idx];
     }
-    inline DataChunk& getChunkUnsafe(uint64_t idx) {
+    DataChunk& getChunkUnsafe(uint64_t idx) {
         KU_ASSERT(idx < chunks.size());
         return chunks[idx];
     }
-    inline void merge(DataChunkCollection* other) {
-        for (auto& chunk : other->chunks) {
-            merge(std::move(chunk));
-        }
-    }
-    void merge(DataChunk chunk);
 
 private:
-    void allocateChunk(DataChunk& chunk);
+    void allocateChunk(const DataChunk& chunk);
 
-    void initTypes(DataChunk& chunk);
+    void initTypes(const DataChunk& chunk);
 
 private:
     storage::MemoryManager* mm;

sdist/kuzu-source/src/include/common/data_chunk/data_chunk_state.h

@@ -34,8 +34,6 @@ public:
         this->selVector = std::move(selVector_);
     }
 
-    void slice(offset_t offset);
-
 private:
     std::shared_ptr<SelectionVector> selVector;
     // TODO: We should get rid of `fStateType` and merge DataChunkState with SelectionVector.

sdist/kuzu-source/src/include/common/data_chunk/sel_vector.h

@@ -29,9 +29,7 @@ protected:
 
 public:
     // STATIC selectionView over 0..selectedSize
-    explicit SelectionView(sel_t selectedSize) : SelectionView{0, selectedSize} {}
-    // STATIC selectionView over startPos..selectedSize
-    explicit SelectionView(sel_t startPos, sel_t selectedSize);
+    explicit SelectionView(sel_t selectedSize);
 
     template<class Func>
     void forEach(Func&& func) const {

sdist/kuzu-source/src/include/common/enums/alter_type.h

@@ -12,6 +12,8 @@ enum class AlterType : uint8_t {
     DROP_PROPERTY = 11,
     RENAME_PROPERTY = 12,
     ADD_FROM_TO_CONNECTION = 13,
+    DROP_FROM_TO_CONNECTION = 14,
+
     COMMENT = 201,
     INVALID = 255
 };

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <concepts>
+
+namespace kuzu::common {
+// RAII wrapper that calls an enclosed function when this class goes out of scope
+// Should be used for any cleanup code that must be executed even if exceptions occur
+template<std::invocable Func>
+struct FinallyWrapper {
+    explicit FinallyWrapper(Func&& func) : func(func) {}
+    ~FinallyWrapper() { func(); }
+    Func func;
+};
+} // namespace kuzu::common

sdist/kuzu-source/src/include/common/serializer/metadata_writer.h

@@ -26,6 +26,12 @@ public:
 
     storage::PageRange flush(storage::FileHandle* fileHandle,
         storage::ShadowFile& shadowFile) const;
+    void flush(storage::PageRange allocatedPages, storage::FileHandle* fileHandle,
+        storage::ShadowFile& shadowFile) const;
+
+    page_idx_t getNumPagesToFlush() const { return pages.size(); }
+
+    static uint64_t getPageSize();
 
 private:
     bool needNewBuffer(uint64_t size) const;

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

@@ -42,9 +42,6 @@ uint64_t prevPowerOfTwo(uint64_t v);
 
 bool isLittleEndian();
 
-template<typename T>
-bool integerFitsIn(int64_t val);
-
 template<numeric_utils::IsIntegral T>
 constexpr T ceilDiv(T a, T b) {
     return (a / b) + (a % b != 0);

sdist/kuzu-source/src/include/function/hash/vector_hash_functions.h

@@ -9,26 +9,26 @@ namespace function {
 struct UnaryHashFunctionExecutor {
     template<typename OPERAND_TYPE, typename RESULT_TYPE>
     static void execute(const common::ValueVector& operand,
-        const common::SelectionVector& operandSelectVec, common::ValueVector& result,
-        const common::SelectionVector& resultSelectVec);
+        const common::SelectionView& operandSelectVec, common::ValueVector& result,
+        const common::SelectionView& resultSelectVec);
 };
 
 struct BinaryHashFunctionExecutor {
     template<typename LEFT_TYPE, typename RIGHT_TYPE, typename RESULT_TYPE, typename FUNC>
-    static void execute(const common::ValueVector& left, const common::SelectionVector& leftSelVec,
-        const common::ValueVector& right, const common::SelectionVector& rightSelVec,
-        common::ValueVector& result, const common::SelectionVector& resultSelVec);
+    static void execute(const common::ValueVector& left, const common::SelectionView& leftSelVec,
+        const common::ValueVector& right, const common::SelectionView& rightSelVec,
+        common::ValueVector& result, const common::SelectionView& resultSelVec);
 };
 
 struct VectorHashFunction {
     static void computeHash(const common::ValueVector& operand,
-        const common::SelectionVector& operandSelectVec, common::ValueVector& result,
-        const common::SelectionVector& resultSelectVec);
+        const common::SelectionView& operandSelectVec, common::ValueVector& result,
+        const common::SelectionView& resultSelectVec);
 
     static void combineHash(const common::ValueVector& left,
-        const common::SelectionVector& leftSelVec, const common::ValueVector& right,
-        const common::SelectionVector& rightSelVec, common::ValueVector& result,
-        const common::SelectionVector& resultSelVec);
+        const common::SelectionView& leftSelVec, const common::ValueVector& right,
+        const common::SelectionView& rightSelVec, common::ValueVector& result,
+        const common::SelectionView& resultSelVec);
 };
 
 struct MD5Function {