kuzu 0.11.1.dev6__tar.gz → 0.11.1.dev8__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuzu
-Version: 0.11.1.dev6
+Version: 0.11.1.dev8
 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.11.1.6 LANGUAGES CXX C)
+project(Kuzu VERSION 0.11.1.8 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)

sdist/kuzu-source/src/c_api/value.cpp

@@ -856,6 +856,21 @@ kuzu_state kuzu_node_val_to_string(kuzu_value* node_val, char** out_result) {
     return KuzuSuccess;
 }
 
+kuzu_state kuzu_rel_val_get_id_val(kuzu_value* rel_val, kuzu_value* out_value) {
+    auto logical_type_id = static_cast<Value*>(rel_val->_value)->getDataType().getLogicalTypeID();
+    if (logical_type_id != LogicalTypeID::REL) {
+        return KuzuError;
+    }
+    try {
+        auto id_val = RelVal::getIDVal(static_cast<Value*>(rel_val->_value));
+        out_value->_value = id_val;
+        out_value->_is_owned_by_cpp = true;
+    } catch (Exception& e) {
+        return KuzuError;
+    }
+    return KuzuSuccess;
+}
+
 kuzu_state kuzu_rel_val_get_src_id_val(kuzu_value* rel_val, kuzu_value* out_value) {
     auto logical_type_id = static_cast<Value*>(rel_val->_value)->getDataType().getLogicalTypeID();
     if (logical_type_id != LogicalTypeID::REL) {

sdist/kuzu-source/src/graph/on_disk_graph.cpp

@@ -339,7 +339,7 @@ bool OnDiskGraphVertexScanState::next() {
     numNodesToScan = std::min(endOffset - currentOffset, DEFAULT_VECTOR_CAPACITY);
     auto result = tableScanState->scanNext(context.getTransaction(), currentOffset, numNodesToScan);
     currentOffset += result.numRows;
-    return result != NODE_GROUP_SCAN_EMMPTY_RESULT;
+    return result != NODE_GROUP_SCAN_EMPTY_RESULT;
 }
 
 } // namespace graph

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

@@ -1366,6 +1366,13 @@ KUZU_C_API kuzu_state kuzu_node_val_get_property_value_at(kuzu_value* node_val,
  * @return The state indicating the success or failure of the operation.
  */
 KUZU_C_API kuzu_state kuzu_node_val_to_string(kuzu_value* node_val, char** out_result);
+/**
+ * @brief Returns the internal id value of the rel value as a kuzu value.
+ * @param rel_val The rel value to return.
+ * @param[out] out_value The output parameter that will hold the internal id value.
+ * @return The state indicating the success or failure of the operation.
+ */
+KUZU_C_API kuzu_state kuzu_rel_val_get_id_val(kuzu_value* rel_val, kuzu_value* out_value);
 /**
  * @brief Returns the internal id value of the source node of the given rel value as a kuzu value.
  * @param rel_val The rel value to return.

sdist/kuzu-source/src/include/storage/local_storage/local_node_table.h

@@ -19,8 +19,7 @@ public:
     bool insert(transaction::Transaction* transaction, TableInsertState& insertState) override;
     bool update(transaction::Transaction* transaction, TableUpdateState& updateState) override;
     bool delete_(transaction::Transaction* transaction, TableDeleteState& deleteState) override;
-    bool addColumn(transaction::Transaction* transaction,
-        TableAddColumnState& addColumnState) override;
+    bool addColumn(TableAddColumnState& addColumnState) override;
     uint64_t getEstimatedMemUsage() override;
 
     common::offset_t validateUniquenessConstraint(const transaction::Transaction* transaction,

sdist/kuzu-source/src/include/storage/local_storage/local_rel_table.h

@@ -32,14 +32,14 @@ struct DirectedCSRIndex {
 
 class LocalRelTable final : public LocalTable {
 public:
-    LocalRelTable(const catalog::TableCatalogEntry* tableEntry, const Table& table);
+    LocalRelTable(const catalog::TableCatalogEntry* tableEntry, const Table& table,
+        MemoryManager& mm);
     DELETE_COPY_AND_MOVE(LocalRelTable);
 
     bool insert(transaction::Transaction* transaction, TableInsertState& state) override;
     bool update(transaction::Transaction* transaction, TableUpdateState& state) override;
     bool delete_(transaction::Transaction* transaction, TableDeleteState& state) override;
-    bool addColumn(transaction::Transaction* transaction,
-        TableAddColumnState& addColumnState) override;
+    bool addColumn(TableAddColumnState& addColumnState) override;
     uint64_t getEstimatedMemUsage() override;
 
     bool checkIfNodeHasRels(common::ValueVector* srcNodeIDVector,

sdist/kuzu-source/src/include/storage/local_storage/local_table.h

@@ -22,8 +22,7 @@ public:
     virtual bool insert(transaction::Transaction* transaction, TableInsertState& insertState) = 0;
     virtual bool update(transaction::Transaction* transaction, TableUpdateState& updateState) = 0;
     virtual bool delete_(transaction::Transaction* transaction, TableDeleteState& deleteState) = 0;
-    virtual bool addColumn(transaction::Transaction* transaction,
-        TableAddColumnState& addColumnState) = 0;
+    virtual bool addColumn(TableAddColumnState& addColumnState) = 0;
     virtual void clear(MemoryManager& mm) = 0;
     virtual common::TableType getTableType() const = 0;
     virtual uint64_t getEstimatedMemUsage() = 0;

sdist/kuzu-source/src/include/storage/table/chunked_node_group.h

@@ -121,9 +121,8 @@ public:
 
     bool delete_(const transaction::Transaction* transaction, common::row_idx_t rowIdxInChunk);
 
-    void addColumn(const transaction::Transaction* transaction,
-        const TableAddColumnState& addColumnState, bool enableCompression,
-        PageAllocator* pageAllocator, ColumnStats* newColumnStats);
+    void addColumn(MemoryManager& mm, const TableAddColumnState& addColumnState,
+        bool enableCompression, PageAllocator* pageAllocator, ColumnStats* newColumnStats);
 
     bool isDeleted(const transaction::Transaction* transaction, common::row_idx_t rowInChunk) const;
     bool isInserted(const transaction::Transaction* transaction,
@@ -144,7 +143,8 @@ public:
     }
 
     virtual std::unique_ptr<ChunkedNodeGroup> flushAsNewChunkedNodeGroup(
-        transaction::Transaction* transaction, PageAllocator& pageAllocator) const;
+        transaction::Transaction* transaction, MemoryManager& mm,
+        PageAllocator& pageAllocator) const;
     virtual void flush(PageAllocator& pageAllocator);
 
     void commitInsert(common::row_idx_t startRow, common::row_idx_t numRowsToCommit,

sdist/kuzu-source/src/include/storage/table/column_chunk.h

@@ -38,11 +38,11 @@ struct ColumnCheckpointState {
 
 class ColumnChunk {
 public:
-    ColumnChunk(MemoryManager& memoryManager, common::LogicalType&& dataType, uint64_t capacity,
+    ColumnChunk(MemoryManager& mm, common::LogicalType&& dataType, uint64_t capacity,
         bool enableCompression, ResidencyState residencyState, bool initializeToZero = true);
-    ColumnChunk(MemoryManager& memoryManager, common::LogicalType&& dataType,
-        bool enableCompression, ColumnChunkMetadata metadata);
-    ColumnChunk(bool enableCompression, std::unique_ptr<ColumnChunkData> data);
+    ColumnChunk(MemoryManager& mm, common::LogicalType&& dataType, bool enableCompression,
+        ColumnChunkMetadata metadata);
+    ColumnChunk(MemoryManager& mm, bool enableCompression, std::unique_ptr<ColumnChunkData> data);
 
     void initializeScanState(ChunkState& state, const Column* column) const;
     void scan(const transaction::Transaction* transaction, const ChunkState& state,
@@ -61,8 +61,7 @@ public:
         return getResidencyState() == ResidencyState::ON_DISK ? 0 : data->getEstimatedMemoryUsage();
     }
     void serialize(common::Serializer& serializer) const;
-    static std::unique_ptr<ColumnChunk> deserialize(MemoryManager& memoryManager,
-        common::Deserializer& deSer);
+    static std::unique_ptr<ColumnChunk> deserialize(MemoryManager& mm, common::Deserializer& deSer);
 
     uint64_t getNumValues() const { return data->getNumValues(); }
     void setNumValues(const uint64_t numValues) const { data->setNumValues(numValues); }
@@ -110,6 +109,7 @@ private:
         common::row_idx_t numRows) const;
 
 private:
+    MemoryManager& mm;
     // TODO(Guodong): This field should be removed. Ideally it shouldn't be cached anywhere in
     // storage structures, instead should be fed into functions needed from ClientContext dbConfig.
     bool enableCompression;

sdist/kuzu-source/src/include/storage/table/csr_chunked_node_group.h

@@ -66,7 +66,7 @@ struct KUZU_API ChunkedCSRHeader {
     common::offset_t getStartCSROffset(common::offset_t nodeOffset) const;
     common::offset_t getEndCSROffset(common::offset_t nodeOffset) const;
     common::length_t getCSRLength(common::offset_t nodeOffset) const;
-    common::length_t getGapSize(common::length_t length) const;
+    common::length_t getGapSize(common::length_t nodeOffset) const;
 
     bool sanityCheck() const;
     void copyFrom(const ChunkedCSRHeader& other) const;
@@ -127,7 +127,8 @@ public:
     void scanCSRHeader(MemoryManager& memoryManager, CSRNodeGroupCheckpointState& csrState) const;
 
     std::unique_ptr<ChunkedNodeGroup> flushAsNewChunkedNodeGroup(
-        transaction::Transaction* transaction, PageAllocator& pageAllocator) const override;
+        transaction::Transaction* transaction, MemoryManager& mm,
+        PageAllocator& pageAllocator) const override;
 
     void flush(PageAllocator& pageAllocator) override;
     void reclaimStorage(PageAllocator& pageAllocator) const override;

sdist/kuzu-source/src/include/storage/table/csr_node_group.h

@@ -169,18 +169,17 @@ static constexpr common::column_id_t REL_ID_COLUMN_ID = 1;
 // Transient data are organized similar to normal node groups. Tuples are always appended to the end
 // of `chunkedGroups`. We keep an extra csrIndex to track the vector of row indices for each bound
 // node.
-struct RelTableScanState;
 class CSRNodeGroup final : public NodeGroup {
 public:
     static constexpr PackedCSRInfo DEFAULT_PACKED_CSR_INFO{};
 
-    CSRNodeGroup(const common::node_group_idx_t nodeGroupIdx, const bool enableCompression,
-        std::vector<common::LogicalType> dataTypes)
-        : NodeGroup{nodeGroupIdx, enableCompression, std::move(dataTypes), common::INVALID_OFFSET,
-              NodeGroupDataFormat::CSR} {}
-    CSRNodeGroup(const common::node_group_idx_t nodeGroupIdx, const bool enableCompression,
-        std::unique_ptr<ChunkedNodeGroup> chunkedNodeGroup)
-        : NodeGroup{nodeGroupIdx, enableCompression, common::INVALID_OFFSET,
+    CSRNodeGroup(MemoryManager& mm, const common::node_group_idx_t nodeGroupIdx,
+        const bool enableCompression, std::vector<common::LogicalType> dataTypes)
+        : NodeGroup{mm, nodeGroupIdx, enableCompression, std::move(dataTypes),
+              common::INVALID_OFFSET, NodeGroupDataFormat::CSR} {}
+    CSRNodeGroup(MemoryManager& mm, const common::node_group_idx_t nodeGroupIdx,
+        const bool enableCompression, std::unique_ptr<ChunkedNodeGroup> chunkedNodeGroup)
+        : NodeGroup{mm, nodeGroupIdx, enableCompression, common::INVALID_OFFSET,
               NodeGroupDataFormat::CSR},
           persistentChunkGroup{std::move(chunkedNodeGroup)} {
         for (auto i = 0u; i < persistentChunkGroup->getNumColumns(); i++) {
@@ -206,8 +205,8 @@ public:
     bool delete_(const transaction::Transaction* transaction, CSRNodeGroupScanSource source,
         common::row_idx_t rowIdxInGroup);
 
-    void addColumn(transaction::Transaction* transaction, TableAddColumnState& addColumnState,
-        PageAllocator* pageAllocator, ColumnStats* newColumnStats) override;
+    void addColumn(TableAddColumnState& addColumnState, PageAllocator* pageAllocator,
+        ColumnStats* newColumnStats) override;
 
     void checkpoint(MemoryManager& memoryManager, NodeGroupCheckpointState& state) override;
     void reclaimStorage(PageAllocator& pageAllocator, const common::UniqLock& lock) const override;

sdist/kuzu-source/src/include/storage/table/node_group.h

@@ -79,22 +79,22 @@ struct NodeGroupScanResult {
     }
 };
 
-static auto NODE_GROUP_SCAN_EMMPTY_RESULT = NodeGroupScanResult{};
+static auto NODE_GROUP_SCAN_EMPTY_RESULT = NodeGroupScanResult{};
 
 struct TableScanState;
 class NodeGroup {
 public:
-    NodeGroup(const common::node_group_idx_t nodeGroupIdx, const bool enableCompression,
-        std::vector<common::LogicalType> dataTypes,
+    NodeGroup(MemoryManager& mm, const common::node_group_idx_t nodeGroupIdx,
+        const bool enableCompression, std::vector<common::LogicalType> dataTypes,
         common::row_idx_t capacity = common::StorageConfig::NODE_GROUP_SIZE,
         NodeGroupDataFormat format = NodeGroupDataFormat::REGULAR)
-        : nodeGroupIdx{nodeGroupIdx}, format{format}, enableCompression{enableCompression},
+        : mm{mm}, nodeGroupIdx{nodeGroupIdx}, format{format}, enableCompression{enableCompression},
           numRows{0}, nextRowToAppend{0}, capacity{capacity}, dataTypes{std::move(dataTypes)} {}
-    NodeGroup(const common::node_group_idx_t nodeGroupIdx, const bool enableCompression,
-        std::unique_ptr<ChunkedNodeGroup> chunkedNodeGroup,
+    NodeGroup(MemoryManager& mm, const common::node_group_idx_t nodeGroupIdx,
+        const bool enableCompression, std::unique_ptr<ChunkedNodeGroup> chunkedNodeGroup,
         common::row_idx_t capacity = common::StorageConfig::NODE_GROUP_SIZE,
         NodeGroupDataFormat format = NodeGroupDataFormat::REGULAR)
-        : nodeGroupIdx{nodeGroupIdx}, format{format}, enableCompression{enableCompression},
+        : mm{mm}, nodeGroupIdx{nodeGroupIdx}, format{format}, enableCompression{enableCompression},
           numRows{chunkedNodeGroup->getStartRowIdx() + chunkedNodeGroup->getNumRows()},
           nextRowToAppend{numRows}, capacity{capacity} {
         for (auto i = 0u; i < chunkedNodeGroup->getNumColumns(); i++) {
@@ -103,9 +103,9 @@ public:
         const auto lock = chunkedGroups.lock();
         chunkedGroups.appendGroup(lock, std::move(chunkedNodeGroup));
     }
-    NodeGroup(const common::node_group_idx_t nodeGroupIdx, const bool enableCompression,
-        common::row_idx_t capacity, NodeGroupDataFormat format)
-        : nodeGroupIdx{nodeGroupIdx}, format{format}, enableCompression{enableCompression},
+    NodeGroup(MemoryManager& mm, const common::node_group_idx_t nodeGroupIdx,
+        const bool enableCompression, common::row_idx_t capacity, NodeGroupDataFormat format)
+        : mm{mm}, nodeGroupIdx{nodeGroupIdx}, format{format}, enableCompression{enableCompression},
           numRows{0}, nextRowToAppend{0}, capacity{capacity} {}
     virtual ~NodeGroup() = default;
 
@@ -157,8 +157,7 @@ public:
     bool delete_(const transaction::Transaction* transaction, common::row_idx_t rowIdxInGroup);
 
     bool hasDeletions(const transaction::Transaction* transaction) const;
-    virtual void addColumn(transaction::Transaction* transaction,
-        TableAddColumnState& addColumnState, PageAllocator* pageAllocator,
+    virtual void addColumn(TableAddColumnState& addColumnState, PageAllocator* pageAllocator,
         ColumnStats* newColumnStats);
 
     void applyFuncToChunkedGroups(version_record_handler_op_t func, common::row_idx_t startRow,
@@ -172,8 +171,8 @@ public:
     uint64_t getEstimatedMemoryUsage() const;
 
     virtual void serialize(common::Serializer& serializer);
-    static std::unique_ptr<NodeGroup> deserialize(MemoryManager& memoryManager,
-        common::Deserializer& deSer, const std::vector<common::LogicalType>& columnTypes);
+    static std::unique_ptr<NodeGroup> deserialize(MemoryManager& mm, common::Deserializer& deSer,
+        const std::vector<common::LogicalType>& columnTypes);
 
     common::node_group_idx_t getNumChunkedGroups() const {
         const auto lock = chunkedGroups.lock();
@@ -188,9 +187,9 @@ public:
     TARGET& cast() {
         return common::ku_dynamic_cast<TARGET&>(*this);
     }
-    template<class TARGETT>
-    const TARGETT& cast() const {
-        return common::ku_dynamic_cast<const TARGETT&>(*this);
+    template<class TARGET>
+    const TARGET& cast() const {
+        return common::ku_dynamic_cast<const TARGET&>(*this);
     }
 
     bool isVisible(const transaction::Transaction* transaction,
@@ -240,6 +239,7 @@ private:
     common::row_idx_t getStartRowIdxInGroup(const common::UniqLock& lock) const;
 
 protected:
+    MemoryManager& mm;
     common::node_group_idx_t nodeGroupIdx;
     NodeGroupDataFormat format;
     bool enableCompression;

sdist/kuzu-source/src/include/storage/table/node_group_collection.h

@@ -13,8 +13,8 @@ class MemoryManager;
 
 class NodeGroupCollection {
 public:
-    NodeGroupCollection(const std::vector<common::LogicalType>& types, bool enableCompression,
-        ResidencyState residency = ResidencyState::IN_MEMORY,
+    NodeGroupCollection(MemoryManager& mm, const std::vector<common::LogicalType>& types,
+        bool enableCompression, ResidencyState residency = ResidencyState::IN_MEMORY,
         const VersionRecordHandler* versionRecordHandler = nullptr);
 
     void append(const transaction::Transaction* transaction,
@@ -73,8 +73,7 @@ public:
 
     common::column_id_t getNumColumns() const { return types.size(); }
 
-    void addColumn(transaction::Transaction* transaction, TableAddColumnState& addColumnState,
-        PageAllocator* pageAllocator = nullptr);
+    void addColumn(TableAddColumnState& addColumnState, PageAllocator* pageAllocator = nullptr);
 
     uint64_t getEstimatedMemoryUsage() const;
 
@@ -111,6 +110,8 @@ private:
     void pushInsertInfo(const transaction::Transaction* transaction, const NodeGroup* nodeGroup,
         common::row_idx_t numRows);
 
+private:
+    MemoryManager& mm;
     bool enableCompression;
     // Num rows in the collection regardless of deletions.
     std::atomic<common::row_idx_t> numTotalRows;

sdist/kuzu-source/src/include/storage/table/node_table.h

@@ -103,7 +103,7 @@ class StorageManager;
 class KUZU_API NodeTable final : public Table {
 public:
     NodeTable(const StorageManager* storageManager,
-        const catalog::NodeTableCatalogEntry* nodeTableEntry, MemoryManager* memoryManager);
+        const catalog::NodeTableCatalogEntry* nodeTableEntry, MemoryManager* mm);
 
     common::row_idx_t getNumTotalRows(const transaction::Transaction* transaction) override;
 

sdist/kuzu-source/src/include/storage/table/rel_table_data.h

@@ -16,6 +16,7 @@ namespace transaction {
 class Transaction;
 }
 namespace storage {
+class Table;
 class MemoryManager;
 class RelTableData;
 
@@ -55,7 +56,7 @@ private:
 class RelTableData {
 public:
     RelTableData(FileHandle* dataFH, MemoryManager* mm, ShadowFile* shadowFile,
-        const catalog::RelGroupCatalogEntry& relGroupEntry, common::table_id_t tableID,
+        const catalog::RelGroupCatalogEntry& relGroupEntry, Table& table,
         common::RelDataDirection direction, common::table_id_t nbrTableID, bool enableCompression);
 
     bool update(transaction::Transaction* transaction, common::ValueVector& boundNodeIDVector,
@@ -63,8 +64,7 @@ public:
         const common::ValueVector& dataVector) const;
     bool delete_(transaction::Transaction* transaction, common::ValueVector& boundNodeIDVector,
         const common::ValueVector& relIDVector);
-    void addColumn(transaction::Transaction* transaction, TableAddColumnState& addColumnState,
-        PageAllocator& pageAllocator);
+    void addColumn(TableAddColumnState& addColumnState, PageAllocator& pageAllocator);
 
     bool checkIfNodeHasRels(transaction::Transaction* transaction,
         common::ValueVector* srcNodeIDVector) const;
@@ -146,9 +146,8 @@ private:
     const VersionRecordHandler* getVersionRecordHandler(CSRNodeGroupScanSource source) const;
 
 private:
-    common::table_id_t tableID;
-    std::string tableName;
-    MemoryManager* memoryManager;
+    Table& table;
+    MemoryManager* mm;
     ShadowFile* shadowFile;
     bool enableCompression;
     PackedCSRInfo packedCSRInfo;

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

@@ -101,7 +101,6 @@ public:
     common::transaction_t getStartTS() const { return startTS; }
     common::transaction_t getCommitTS() const { return commitTS; }
     int64_t getCurrentTS() const { return currentTS; }
-    main::ClientContext* getClientContext() const { return clientContext; }
 
     void setForceCheckpoint() { forceCheckpoint = true; }
     bool shouldAppendToUndoBuffer() const {

sdist/kuzu-source/src/processor/operator/persistent/rel_batch_insert.cpp

@@ -135,7 +135,7 @@ static void appendNewChunkedGroup(MemoryManager& mm, transaction::Transaction* t
     relTable.pushInsertInfo(transaction, direction, nodeGroup, chunkedGroup.getNumRows(), source);
     if (isNewNodeGroup) {
         auto flushedChunkedGroup =
-            chunkedGroup.flushAsNewChunkedNodeGroup(transaction, pageAllocator);
+            chunkedGroup.flushAsNewChunkedNodeGroup(transaction, mm, pageAllocator);
 
         // If there are deleted columns that haven't been vacuumed yet
         // we need to add extra columns to the chunked group

sdist/kuzu-source/src/storage/local_storage/local_node_table.cpp

@@ -26,7 +26,7 @@ std::vector<LogicalType> LocalNodeTable::getNodeTableColumnTypes(
 LocalNodeTable::LocalNodeTable(const catalog::TableCatalogEntry* tableEntry, Table& table,
     MemoryManager& mm)
     : LocalTable{table}, overflowFileHandle(nullptr),
-      nodeGroups{getNodeTableColumnTypes(*tableEntry), false /*enableCompression*/} {
+      nodeGroups{mm, getNodeTableColumnTypes(*tableEntry), false /*enableCompression*/} {
     initLocalHashIndex(mm);
     startOffset = table.getNumTotalRows(nullptr /* transaction */);
 }
@@ -70,7 +70,7 @@ bool LocalNodeTable::insert(Transaction* transaction, TableInsertState& insertSt
     const auto nodeIDPos =
         nodeInsertState.nodeIDVector.state->getSelVector().getSelectedPositions()[0];
     nodeInsertState.nodeIDVector.setValue(nodeIDPos, internalID_t{nodeOffset, table.getTableID()});
-    nodeGroups.append(transaction, insertState.propertyVectors);
+    nodeGroups.append(&DUMMY_TRANSACTION, insertState.propertyVectors);
     return true;
 }
 
@@ -104,8 +104,8 @@ bool LocalNodeTable::delete_(Transaction* transaction, TableDeleteState& deleteS
     return nodeGroup->delete_(transaction, rowIdxInGroup);
 }
 
-bool LocalNodeTable::addColumn(Transaction* transaction, TableAddColumnState& addColumnState) {
-    nodeGroups.addColumn(transaction, addColumnState);
+bool LocalNodeTable::addColumn(TableAddColumnState& addColumnState) {
+    nodeGroups.addColumn(addColumnState);
     return true;
 }
 

sdist/kuzu-source/src/storage/local_storage/local_rel_table.cpp

@@ -25,17 +25,18 @@ static std::vector<LogicalType> getTypesForLocalRelTable(const catalog::TableCat
     return types;
 }
 
-LocalRelTable::LocalRelTable(const catalog::TableCatalogEntry* tableEntry, const Table& table)
+LocalRelTable::LocalRelTable(const catalog::TableCatalogEntry* tableEntry, const Table& table,
+    MemoryManager& mm)
     : LocalTable{table} {
-    localNodeGroup = std::make_unique<NodeGroup>(0, false, getTypesForLocalRelTable(*tableEntry),
-        INVALID_ROW_IDX);
+    localNodeGroup = std::make_unique<NodeGroup>(mm, 0, false,
+        getTypesForLocalRelTable(*tableEntry), INVALID_ROW_IDX);
     const auto& relTable = table.cast<RelTable>();
     for (auto relDirection : relTable.getStorageDirections()) {
         directedIndices.emplace_back(relDirection);
     }
 }
 
-bool LocalRelTable::insert(Transaction* transaction, TableInsertState& state) {
+bool LocalRelTable::insert(Transaction*, TableInsertState& state) {
     const auto& insertState = state.cast<RelTableInsertState>();
 
     std::vector<row_idx_vec_t*> rowIndicesToInsertTo;
@@ -64,7 +65,7 @@ bool LocalRelTable::insert(Transaction* transaction, TableInsertState& state) {
         insertVectors.push_back(insertState.propertyVectors[i]);
     }
     const auto numRowsToAppend = insertState.srcNodeIDVector.state->getSelVector().getSelSize();
-    localNodeGroup->append(transaction, insertVectors, 0, numRowsToAppend);
+    localNodeGroup->append(&DUMMY_TRANSACTION, insertVectors, 0, numRowsToAppend);
 
     for (auto* rowIndexToInsertTo : rowIndicesToInsertTo) {
         rowIndexToInsertTo->push_back(numRowsInLocalTable);
@@ -137,14 +138,14 @@ bool LocalRelTable::delete_(Transaction* transaction, TableDeleteState& state) {
     return true;
 }
 
-bool LocalRelTable::addColumn(Transaction* transaction, TableAddColumnState& addColumnState) {
-    localNodeGroup->addColumn(transaction, addColumnState, nullptr /* FileHandle */,
+bool LocalRelTable::addColumn(TableAddColumnState& addColumnState) {
+    localNodeGroup->addColumn(addColumnState, nullptr /* FileHandle */,
         nullptr /* newColumnStats */);
     return true;
 }
 
 uint64_t LocalRelTable::getEstimatedMemUsage() {
-    // Esimation of fwdIndex and bwdIndex is rough.
+    // Estimation of fwdIndex and bwdIndex is rough.
     if (!localNodeGroup) {
         return 0;
     }

sdist/kuzu-source/src/storage/local_storage/local_storage.cpp

@@ -18,18 +18,18 @@ LocalTable* LocalStorage::getOrCreateLocalTable(Table& table) {
     const auto tableID = table.getTableID();
     auto catalog = clientContext.getCatalog();
     auto transaction = clientContext.getTransaction();
+    auto& mm = *clientContext.getMemoryManager();
     if (!tables.contains(tableID)) {
         switch (table.getTableType()) {
         case TableType::NODE: {
             auto tableEntry = catalog->getTableCatalogEntry(transaction, table.getTableID());
-            tables[tableID] = std::make_unique<LocalNodeTable>(tableEntry, table,
-                *clientContext.getMemoryManager());
+            tables[tableID] = std::make_unique<LocalNodeTable>(tableEntry, table, mm);
         } break;
         case TableType::REL: {
             // We have to fetch the rel group entry from the catalog to based on the relGroupID.
             auto tableEntry =
                 catalog->getTableCatalogEntry(transaction, table.cast<RelTable>().getRelGroupID());
-            tables[tableID] = std::make_unique<LocalRelTable>(tableEntry, table);
+            tables[tableID] = std::make_unique<LocalRelTable>(tableEntry, table, mm);
         } break;
         default:
             KU_UNREACHABLE;

sdist/kuzu-source/src/storage/table/chunked_node_group.cpp

@@ -2,7 +2,6 @@
 
 #include "common/assert.h"
 #include "common/types/types.h"
-#include "main/client_context.h"
 #include "storage/buffer_manager/buffer_manager.h"
 #include "storage/buffer_manager/memory_manager.h"
 #include "storage/buffer_manager/spiller.h"
@@ -368,13 +367,11 @@ bool ChunkedNodeGroup::delete_(const Transaction* transaction, row_idx_t rowIdxI
     return versionInfo->delete_(transaction->getID(), rowIdxInChunk);
 }
 
-void ChunkedNodeGroup::addColumn(const Transaction* transaction,
-    const TableAddColumnState& addColumnState, bool enableCompression, PageAllocator* pageAllocator,
-    ColumnStats* newColumnStats) {
+void ChunkedNodeGroup::addColumn(MemoryManager& mm, const TableAddColumnState& addColumnState,
+    bool enableCompression, PageAllocator* pageAllocator, ColumnStats* newColumnStats) {
     auto& dataType = addColumnState.propertyDefinition.getType();
-    chunks.push_back(
-        std::make_unique<ColumnChunk>(*transaction->getClientContext()->getMemoryManager(),
-            dataType.copy(), capacity, enableCompression, ResidencyState::IN_MEMORY));
+    chunks.push_back(std::make_unique<ColumnChunk>(mm, dataType.copy(), capacity, enableCompression,
+        ResidencyState::IN_MEMORY));
     auto& chunkData = chunks.back()->getData();
     auto numExistingRows = getNumRows();
     chunkData.populateWithDefaultVal(addColumnState.defaultEvaluator, numExistingRows,
@@ -419,11 +416,12 @@ void ChunkedNodeGroup::finalize() const {
 }
 
 std::unique_ptr<ChunkedNodeGroup> ChunkedNodeGroup::flushAsNewChunkedNodeGroup(
-    Transaction* transaction, PageAllocator& pageAllocator) const {
+    Transaction* transaction, MemoryManager& mm, PageAllocator& pageAllocator) const {
     std::vector<std::unique_ptr<ColumnChunk>> flushedChunks(getNumColumns());
     for (auto i = 0u; i < getNumColumns(); i++) {
-        flushedChunks[i] = std::make_unique<ColumnChunk>(getColumnChunk(i).isCompressionEnabled(),
-            Column::flushChunkData(getColumnChunk(i).getData(), pageAllocator));
+        flushedChunks[i] =
+            std::make_unique<ColumnChunk>(mm, getColumnChunk(i).isCompressionEnabled(),
+                Column::flushChunkData(getColumnChunk(i).getData(), pageAllocator));
     }
     auto flushedChunkedGroup =
         std::make_unique<ChunkedNodeGroup>(std::move(flushedChunks), 0 /*startRowIdx*/);

sdist/kuzu-source/src/storage/table/column_chunk.cpp

@@ -5,7 +5,6 @@
 #include "common/serializer/deserializer.h"
 #include "common/serializer/serializer.h"
 #include "common/vector/value_vector.h"
-#include "main/client_context.h"
 #include "storage/storage_utils.h"
 #include "storage/table/column.h"
 #include "transaction/transaction.h"
@@ -16,23 +15,24 @@ using namespace kuzu::transaction;
 namespace kuzu {
 namespace storage {
 
-ColumnChunk::ColumnChunk(MemoryManager& memoryManager, LogicalType&& dataType, uint64_t capacity,
+ColumnChunk::ColumnChunk(MemoryManager& mm, LogicalType&& dataType, uint64_t capacity,
     bool enableCompression, ResidencyState residencyState, bool initializeToZero)
-    : enableCompression{enableCompression} {
-    data = ColumnChunkFactory::createColumnChunkData(memoryManager, std::move(dataType),
-        enableCompression, capacity, residencyState, true, initializeToZero);
+    : mm{mm}, enableCompression{enableCompression} {
+    data = ColumnChunkFactory::createColumnChunkData(mm, std::move(dataType), enableCompression,
+        capacity, residencyState, true, initializeToZero);
     KU_ASSERT(residencyState != ResidencyState::ON_DISK);
 }
 
-ColumnChunk::ColumnChunk(MemoryManager& memoryManager, LogicalType&& dataType,
-    bool enableCompression, ColumnChunkMetadata metadata)
-    : enableCompression{enableCompression} {
-    data = ColumnChunkFactory::createColumnChunkData(memoryManager, std::move(dataType),
-        enableCompression, metadata, true, true);
+ColumnChunk::ColumnChunk(MemoryManager& mm, LogicalType&& dataType, bool enableCompression,
+    ColumnChunkMetadata metadata)
+    : mm{mm}, enableCompression{enableCompression} {
+    data = ColumnChunkFactory::createColumnChunkData(mm, std::move(dataType), enableCompression,
+        metadata, true, true);
 }
 
-ColumnChunk::ColumnChunk(bool enableCompression, std::unique_ptr<ColumnChunkData> data)
-    : enableCompression{enableCompression}, data{std::move(data)} {}
+ColumnChunk::ColumnChunk(MemoryManager& mm, bool enableCompression,
+    std::unique_ptr<ColumnChunkData> data)
+    : mm{mm}, enableCompression{enableCompression}, data{std::move(data)} {}
 
 void ColumnChunk::initializeScanState(ChunkState& state, const Column* column) const {
     data->initializeScanState(state, column);
@@ -221,14 +221,13 @@ void ColumnChunk::serialize(Serializer& serializer) const {
     data->serialize(serializer);
 }
 
-std::unique_ptr<ColumnChunk> ColumnChunk::deserialize(MemoryManager& memoryManager,
-    Deserializer& deSer) {
+std::unique_ptr<ColumnChunk> ColumnChunk::deserialize(MemoryManager& mm, Deserializer& deSer) {
     std::string key;
     bool enableCompression = false;
     deSer.validateDebuggingInfo(key, "enable_compression");
     deSer.deserializeValue<bool>(enableCompression);
-    auto data = ColumnChunkData::deserialize(memoryManager, deSer);
-    return std::make_unique<ColumnChunk>(enableCompression, std::move(data));
+    auto data = ColumnChunkData::deserialize(mm, deSer);
+    return std::make_unique<ColumnChunk>(mm, enableCompression, std::move(data));
 }
 
 row_idx_t ColumnChunk::getNumUpdatedRows(const Transaction* transaction) const {
@@ -238,7 +237,6 @@ row_idx_t ColumnChunk::getNumUpdatedRows(const Transaction* transaction) const {
 std::pair<std::unique_ptr<ColumnChunk>, std::unique_ptr<ColumnChunk>> ColumnChunk::scanUpdates(
     const Transaction* transaction) const {
     auto numUpdatedRows = getNumUpdatedRows(transaction);
-    auto& mm = *transaction->getClientContext()->getMemoryManager();
     // TODO(Guodong): Actually for row idx in a column chunk, UINT32 should be enough.
     auto updatedRows = std::make_unique<ColumnChunk>(mm, LogicalType::UINT64(), numUpdatedRows,
         false, ResidencyState::IN_MEMORY);