ladybug 0.20.2.dev20260907__tar.gz → 0.20.3__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ladybug
-Version: 0.20.2.dev20260907
+Version: 0.20.3
 Summary: Highly scalable, extremely fast, easy-to-use embeddable graph database
 Home-page: https://github.com/LadybugDB/ladybug
 License: MIT

sdist/ladybug-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Lbug VERSION 0.20.2.20260907 LANGUAGES CXX C)
+project(Lbug VERSION 0.20.3 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)
@@ -522,7 +522,7 @@ unset(LBUG_LINK_LIBRARIES)
 
 add_definitions(-DLBUG_ROOT_DIRECTORY="${PROJECT_SOURCE_DIR}")
 add_definitions(-DLBUG_CMAKE_VERSION="${CMAKE_PROJECT_VERSION}")
-add_definitions(-DLBUG_EXTENSION_VERSION="dev")
+add_definitions(-DLBUG_EXTENSION_VERSION="0.20.0")
 
 if(BUILD_LBUG OR LBUG_API_USE_PRECOMPILED_LIB)
 include_directories(

sdist/ladybug-source/docs/multi_parent_lifetime.md

@@ -1,17 +1,5 @@
 # Multi-parent packed child slices: lifetime & representation
 
-> **Status update (multi-parent scan implemented):** the deferred change described below has
-> been implemented. `PackedChildSlices` now holds a `shared_ptr<SelectionVector>` aliasing the
-> bound (parent) chunk state's selection vector plus a prefix-sum `offsets` over ALL served
-> parents (zeros allowed, zero-length ranges skipped by consumers). The CSR scan packs children
-> of multiple parents per output batch in `CSRNodeGroupScanState::tryScanCachedTuplesPacked`
-> (persistent with-cache path only). Multi-parent batches are enabled per-consumer:
-> `ScanRelTable::setMultiParentPackedScanEnabled(true)` is set by the plan mapper only when the
-> packed-aware `PackedFilteredCount` consumes the scan output directly. Plans that materialize
-> the scan output across a `FactorizedTable` (e.g. when the filter predicate touches an nbr
-> node property, which routes the property fetch through a hash join) keep the
-> one-parent-per-batch contract — exactly the materialization hazard described below.
-
 Context: the `enable_packed_path_extend` path reuses the adjacency-list (CSR)
 rel scan to implement a physical packed extend. `ScanRelTable` attaches a
 `PackedChildSlices` descriptor to the **output** `DataChunkState`

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

@@ -326,7 +326,7 @@ iC_ExportDatabase
     : EXPORT SP DATABASE SP StringLiteral ( SP? '(' SP? iC_Options SP? ')' )? ;
 
 iC_ImportDatabase
-    : IMPORT SP DATABASE SP StringLiteral ( SP? '(' SP? iC_Options SP? ')' )? ;
+    : IMPORT SP DATABASE SP StringLiteral;
 
 iC_AttachDatabase
     : ATTACH SP StringLiteral (SP AS SP oC_SchemaName)? SP '(' SP? DBTYPE SP oC_SymbolicName (SP? ',' SP? iC_Options)? SP? ')' ;

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

@@ -1 +1 @@
-6fc9fc9085d4f1028a4fb2b319152cb5
+c6ef6ea298ca84a5c080bae09a29c9db

sdist/ladybug-source/scripts/pip-package/setup.py

@@ -91,27 +91,16 @@ class CMakeBuild(build_ext):
             if os.path.exists(flags_file):
                 with open(flags_file) as f:
                     extra_cmake_flags = f.read().strip()
-        # Wheel builds must not split symbols at build time: raw .debug/dSYM
-        # artifacts packaged inside the wheel break auditwheel/delocate
-        # repair. The split happens on the final repaired wheel instead (see
-        # split_debug_symbols.py), which needs the debug info to still be
-        # present in the shipped binary.
-        no_split_flag = '-DLBUG_SPLIT_DEBUG_SYMBOLS=OFF'
         if precompiled_lib_path:
             self.announce("Using precompiled liblbug from %s." % precompiled_lib_path)
             flags = (
-                'EXTRA_CMAKE_FLAGS=%s -DBUILD_LBUG=FALSE -DBUILD_SHELL=FALSE '
+                'EXTRA_CMAKE_FLAGS=-DBUILD_LBUG=FALSE -DBUILD_SHELL=FALSE '
                 '-DLBUG_API_USE_PRECOMPILED_LIB=TRUE '
-                '-DLBUG_API_PRECOMPILED_LIB_PATH=%s' % (no_split_flag, precompiled_lib_path)
+                '-DLBUG_API_PRECOMPILED_LIB_PATH=%s' % precompiled_lib_path
             )
             if extra_cmake_flags:
                 flags += ' ' + extra_cmake_flags
             full_cmd.append(flags)
-        else:
-            flags = 'EXTRA_CMAKE_FLAGS=%s' % no_split_flag
-            if extra_cmake_flags:
-                flags += ' ' + extra_cmake_flags
-            full_cmd.append(flags)
         subprocess.run(full_cmd, cwd=build_dir, check=True, env=env_vars)
         self.announce("Done building native extension.")
         self.announce("Copying native extension...")

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

@@ -57,7 +57,7 @@ iC_ExportDatabase
     : EXPORT SP DATABASE SP StringLiteral ( SP? '(' SP? iC_Options SP? ')' )? ;
 
 iC_ImportDatabase
-    : IMPORT SP DATABASE SP StringLiteral ( SP? '(' SP? iC_Options SP? ')' )? ;
+    : IMPORT SP DATABASE SP StringLiteral;
 
 iC_AttachDatabase
     : ATTACH SP StringLiteral (SP AS SP oC_SchemaName)? SP '(' SP? DBTYPE SP oC_SymbolicName (SP? ',' SP? iC_Options)? SP? ')' ;

sdist/ladybug-source/src/binder/bind/bind_export_database.cpp

@@ -11,7 +11,6 @@
 #include "parser/parser.h"
 #include "parser/port_db.h"
 #include "parser/query/regular_query.h"
-#include "storage/table/ice_disk_constants.h"
 #include "transaction/transaction.h"
 #include <format>
 
@@ -36,10 +35,6 @@ FileTypeInfo getFileType(case_insensitive_map_t<Value>& options) {
         auto valueStr = value.getValue<std::string>();
         StringUtils::toUpper(valueStr);
         fileTypeInfo = FileTypeInfo{FileTypeUtils::fromString(valueStr), valueStr};
-        if (fileTypeInfo.fileType != FileType::PARQUET) {
-            throw BinderException(
-                "Export database only supports the parquet (icebug-disk CSR) format.");
-        }
         options.erase(PortDBConstants::EXPORT_FORMAT_OPTION);
     }
     return fileTypeInfo;
@@ -62,134 +57,66 @@ void bindExportTableData(ExportedTableData& tableData, const std::string& query,
     tableData.regularQuery = std::move(boundQuery);
 }
 
-static std::string getPropertyReturnList(const TableCatalogEntry& entry, const std::string& var) {
-    std::string props;
-    for (auto& property : entry.getProperties()) {
-        if (property.getType() == LogicalType::INTERNAL_ID()) {
-            continue;
-        }
-        props += std::format(",{}.{} as {}", var, StringUtils::quoteIdentifier(property.getName()),
-            StringUtils::quoteIdentifier(property.getName()));
-    }
-    return props;
-}
-
 static std::string getExportNodeTableDataQuery(const TableCatalogEntry& entry) {
-    // Order by storage offset so that row i in nodes_<table>.parquet holds the node
-    // with dense offset i, matching the CSR target/ptr values in the rel tables.
-    // Properties are aliased explicitly so parquet columns carry clean names.
-    auto props = getPropertyReturnList(entry, "a");
-    auto returns = props.empty() ? "a.*" : props.substr(1);
-    return std::format("match (a:{}) return {} order by offset(id(a))",
-        StringUtils::quoteIdentifier(entry.getName()), returns);
+    return std::format("match (a:{}) return a.*", StringUtils::quoteIdentifier(entry.getName()));
 }
 
-static std::string getExportRelIndicesQuery(const TableCatalogEntry& relGroupEntry,
+static std::string getExportRelTableDataQuery(const TableCatalogEntry& relGroupEntry,
     const NodeTableCatalogEntry& srcEntry, const NodeTableCatalogEntry& dstEntry) {
-    // CSR indices table: dense target offsets (+ edge properties), ordered by
-    // (source offset, target offset). The source offset is encoded by indptr.
-    return std::format("match (a:{})-[r:{}]->(b:{}) return offset(id(b)) as target{} "
-                       "order by offset(id(a)), offset(id(b));",
+    return std::format("match (a:{})-[r:{}]->(b:{}) return a.{},b.{},r.*;",
         StringUtils::quoteIdentifier(srcEntry.getName()),
         StringUtils::quoteIdentifier(relGroupEntry.getName()),
         StringUtils::quoteIdentifier(dstEntry.getName()),
-        getPropertyReturnList(relGroupEntry, "r"));
-}
-
-static std::string getExportRelIndptrQuery(const TableCatalogEntry& relGroupEntry,
-    const NodeTableCatalogEntry& srcEntry, const NodeTableCatalogEntry& dstEntry) {
-    // One row per source node (OPTIONAL MATCH keeps zero-degree nodes), consumed by
-    // the indptr export function which sorts by src and prefix-sums the degrees.
-    return std::format(
-        "match (a:{}) optional match (a)-[r:{}]->(b:{}) return offset(id(a)) as src, "
-        "count(r) as degree;",
-        StringUtils::quoteIdentifier(srcEntry.getName()),
-        StringUtils::quoteIdentifier(relGroupEntry.getName()),
-        StringUtils::quoteIdentifier(dstEntry.getName()));
-}
-
-static std::string getExportRelFlatQuery(const TableCatalogEntry& relGroupEntry,
-    const NodeTableCatalogEntry& srcEntry, const NodeTableCatalogEntry& dstEntry) {
-    // Flat relationship file for native re-import: source/target primary-key values
-    // (COPY FROM resolves them back to node offsets) followed by edge properties.
-    return std::format("match (a:{})-[r:{}]->(b:{}) return {}.{} as {}, {}.{} as {}{};",
-        StringUtils::quoteIdentifier(srcEntry.getName()),
-        StringUtils::quoteIdentifier(relGroupEntry.getName()),
-        StringUtils::quoteIdentifier(dstEntry.getName()), "a",
-        StringUtils::quoteIdentifier(srcEntry.getPrimaryKeyDefinition().getName()),
-        StringUtils::quoteIdentifier("from"), "b",
-        StringUtils::quoteIdentifier(dstEntry.getPrimaryKeyDefinition().getName()),
-        StringUtils::quoteIdentifier("to"), getPropertyReturnList(relGroupEntry, "r"));
+        StringUtils::quoteIdentifier(srcEntry.getPrimaryKeyName()),
+        StringUtils::quoteIdentifier(dstEntry.getPrimaryKeyName()));
 }
 
 static std::vector<ExportedTableData> getExportInfo(const Catalog& catalog,
-    main::ClientContext* context, Binder* binder, [[maybe_unused]] FileTypeInfo& fileTypeInfo) {
+    main::ClientContext* context, Binder* binder, FileTypeInfo& fileTypeInfo) {
     auto transaction = Transaction::Get(*context);
     std::vector<ExportedTableData> exportData;
     for (auto entry : catalog.getNodeTableEntries(transaction, false /*useInternal*/)) {
         ExportedTableData tableData;
         tableData.tableName = entry->getName();
-        tableData.fileName = std::format("nodes_{}.parquet", entry->getName());
+        tableData.fileName =
+            entry->getName() + "." + StringUtils::getLower(fileTypeInfo.fileTypeStr);
         auto query = getExportNodeTableDataQuery(*entry);
         bindExportTableData(tableData, query, context, binder);
         exportData.push_back(std::move(tableData));
     }
     for (auto entry : catalog.getRelGroupEntries(transaction, false /* useInternal */)) {
         auto& relGroupEntry = entry->constCast<RelGroupCatalogEntry>();
-        if (relGroupEntry.getRelEntryInfos().size() != 1) {
-            throw BinderException(std::format(
-                "Export database: rel table {} connects multiple node pairs, which is not "
-                "supported for icebug-disk CSR export yet.",
-                relGroupEntry.getName()));
-        }
         for (auto& info : relGroupEntry.getRelEntryInfos()) {
+            ExportedTableData tableData;
             auto srcTableID = info.nodePair.srcTableID;
             auto dstTableID = info.nodePair.dstTableID;
             auto& srcEntry = catalog.getTableCatalogEntry(transaction, srcTableID)
                                  ->constCast<NodeTableCatalogEntry>();
             auto& dstEntry = catalog.getTableCatalogEntry(transaction, dstTableID)
                                  ->constCast<NodeTableCatalogEntry>();
-            ExportedTableData indicesData;
-            indicesData.tableName = entry->getName();
-            indicesData.fileName = std::format("indices_{}.parquet", relGroupEntry.getName());
-            bindExportTableData(indicesData,
-                getExportRelIndicesQuery(relGroupEntry, srcEntry, dstEntry), context, binder);
-            exportData.push_back(std::move(indicesData));
-            ExportedTableData indptrData;
-            indptrData.tableName = entry->getName();
-            indptrData.fileName = std::format("indptr_{}.parquet", relGroupEntry.getName());
-            indptrData.isIndptr = true;
-            bindExportTableData(indptrData,
-                getExportRelIndptrQuery(relGroupEntry, srcEntry, dstEntry), context, binder);
-            exportData.push_back(std::move(indptrData));
-            // Flat relationship file (from/to primary-key values + properties), used by
-            // IMPORT DATABASE to ingest the relationship table into native storage. It is
-            // ignored when the export is mounted as icebug-disk (which uses the CSR files).
-            ExportedTableData flatRelData;
-            flatRelData.tableName = entry->getName();
-            flatRelData.fileName = std::format("rels_{}.parquet", relGroupEntry.getName());
-            bindExportTableData(flatRelData,
-                getExportRelFlatQuery(relGroupEntry, srcEntry, dstEntry), context, binder);
-            exportData.push_back(std::move(flatRelData));
+            tableData.tableName = entry->getName();
+            tableData.fileName =
+                std::format("{}_{}_{}.{}", relGroupEntry.getName(), srcEntry.getName(),
+                    dstEntry.getName(), StringUtils::getLower(fileTypeInfo.fileTypeStr));
+            auto query = getExportRelTableDataQuery(relGroupEntry, srcEntry, dstEntry);
+            bindExportTableData(tableData, query, context, binder);
+            exportData.push_back(std::move(tableData));
         }
     }
 
-    // Index aux tables (e.g. the FTS internal stopwords table) are not part of the CSR
-    // layout, but index.cypher needs them on import when the original stopwords source
-    // table no longer exists. Export them as <tableName>.parquet; the FTS index's
-    // toCypher references the file path in that case.
     for (auto indexEntry : catalog.getIndexEntries(transaction)) {
-        auto auxEntry = indexEntry->getTableEntryToExport(context);
-        if (auxEntry == nullptr) {
+        // Export
+        ExportedTableData tableData;
+        auto entry = indexEntry->getTableEntryToExport(context);
+        if (entry == nullptr) {
             continue;
         }
-        ExportedTableData tableData;
-        tableData.tableName = auxEntry->getName();
-        tableData.fileName = std::format("{}.parquet", auxEntry->getName());
-        bindExportTableData(tableData,
-            std::format("match (a:{}) return a.*",
-                StringUtils::quoteIdentifier(auxEntry->getName())),
-            context, binder);
+        DASSERT(entry->getTableType() == TableType::NODE);
+        tableData.tableName = entry->getName();
+        tableData.fileName =
+            entry->getName() + "." + StringUtils::getLower(fileTypeInfo.fileTypeStr);
+        auto query = getExportNodeTableDataQuery(*entry);
+        bindExportTableData(tableData, query, context, binder);
         exportData.push_back(std::move(tableData));
     }
     return exportData;
@@ -231,17 +158,10 @@ std::unique_ptr<BoundStatement> Binder::bindExportDatabaseClause(const Statement
     }
     auto exportSchemaOnly = schemaOnly(parsedOptions, exportDB);
     if (!exportSchemaOnly && fileTypeInfo.fileType != FileType::CSV && parsedOptions.size() != 0) {
-        throw BinderException{"Export database does not support copy options with the parquet "
-                              "(icebug-disk CSR) format."};
+        throw BinderException{"Only export to csv can have options."};
     }
     auto exportData =
         getExportInfo(*Catalog::Get(*clientContext), clientContext, this, fileTypeInfo);
-    // Stamp every exported parquet file with the icebug-disk format version so that
-    // IceDiskUtils::checkVersionCompatibility can validate it when the export is mounted.
-    if (fileTypeInfo.fileType == FileType::PARQUET && !exportSchemaOnly) {
-        parsedOptions.insert_or_assign(PortDBConstants::ICEBUG_DISK_VERSION_OPTION,
-            Value{std::string{storage::IceDiskConstants::CURRENT_VERSION}});
-    }
     auto boundFilePath = VirtualFileSystem::GetUnsafe(*clientContext)
                              ->expandPath(clientContext, exportDB.getFilePath());
     return std::make_unique<BoundExportDatabase>(boundFilePath, fileTypeInfo, std::move(exportData),

sdist/ladybug-source/src/binder/bind/bind_import_database.cpp

@@ -6,7 +6,6 @@
 #include "common/string_utils.h"
 #include "main/client_context.h"
 #include "parser/copy.h"
-#include "parser/ddl/create_table.h"
 #include "parser/parser.h"
 #include "parser/port_db.h"
 #include <format>
@@ -84,73 +83,6 @@ static std::string getCopyFilePath(const std::string& boundFilePath, const std::
     return path;
 }
 
-// Removes the `WITH (storage = '<dir>', format = 'icebug-disk')` clauses that EXPORT DATABASE
-// attaches to CREATE TABLE statements in schema.cypher, so that IMPORT DATABASE (without an
-// explicit `storage_format = 'icebug-disk'` override) creates native tables instead of mounting
-// the exported parquet files in place.
-static std::string stripIcebugStorageClauses(const std::string& schema) {
-    std::string result = schema;
-    size_t searchFrom = 0;
-    size_t pos;
-    while ((pos = result.find(" WITH (", searchFrom)) != std::string::npos) {
-        auto end = result.find(')', pos);
-        if (end == std::string::npos) {
-            break;
-        }
-        auto clause = result.substr(pos, end - pos);
-        if (clause.find("format = 'icebug-disk'") != std::string::npos &&
-            clause.find("storage = '") != std::string::npos) {
-            result.erase(pos, end - pos + 1);
-            searchFrom = pos;
-        } else {
-            searchFrom = end;
-        }
-    }
-    return result;
-}
-
-// Generates COPY statements that ingest the exported parquet data files into the native
-// tables created by the (stripped) schema.cypher statements. The exported layout is
-// nodes_<table>.parquet for node tables and rels_<rel>.parquet (from/to primary-key
-// columns + edge properties) for relationship tables.
-static std::string getNativeCopyStatements(VirtualFileSystem* vfs, const std::string& boundFilePath,
-    const std::string& schemaQuery, main::ClientContext* context) {
-    std::string copies;
-    if (schemaQuery.empty()) {
-        return copies;
-    }
-    for (auto& parsedStatement : Parser::parseQuery(schemaQuery)) {
-        if (parsedStatement->getStatementType() != StatementType::CREATE_TABLE) {
-            continue;
-        }
-        auto& createTable = parsedStatement->constCast<CreateTable>();
-        const auto& info = *createTable.getInfo();
-        auto isRel = info.type == TableType::REL;
-        auto dataFile = isRel ? std::format("rels_{}.parquet", info.tableName) :
-                                std::format("nodes_{}.parquet", info.tableName);
-        auto filePath = getCopyFilePath(boundFilePath, dataFile);
-        if (!vfs->fileOrPathExists(vfs->joinPath(boundFilePath, dataFile), context)) {
-            continue;
-        }
-        // Explicit column list for node tables (covers SERIAL pk values, which COPY FROM
-        // would otherwise auto-generate). Rel tables rely on positional binding: the flat
-        // file already stores from/to key columns followed by properties in schema order.
-        std::string columns;
-        if (!isRel) {
-            std::vector<std::string> columnList;
-            for (auto& property : info.propertyDefinitions) {
-                columnList.push_back(StringUtils::quoteIdentifier(property.getName()));
-            }
-            if (!columnList.empty()) {
-                columns = std::format(" ({})", StringUtils::join(columnList, ", "));
-            }
-        }
-        copies += std::format("COPY {}{} FROM \"{}\";\n",
-            StringUtils::quoteIdentifier(info.tableName), columns, filePath);
-    }
-    return copies;
-}
-
 std::unique_ptr<BoundStatement> Binder::bindImportDatabaseClause(const Statement& statement) {
     auto& importDB = statement.constCast<ImportDB>();
     auto fs = VirtualFileSystem::GetUnsafe(*clientContext);
@@ -158,40 +90,9 @@ std::unique_ptr<BoundStatement> Binder::bindImportDatabaseClause(const Statement
     if (!fs->fileOrPathExists(boundFilePath, clientContext)) {
         throw BinderException(std::format("Directory {} does not exist.", boundFilePath));
     }
-    // By default the exported icebug-disk data files are ingested into native tables.
-    // An explicit `storage_format = 'icebug-disk'` override mounts the parquet files in
-    // place (i.e. the database is opened directly against the exported directory).
-    bool mountIcebug = false;
-    auto parsingOptions = bindParsingOptions(importDB.getParsingOptionsRef());
-    if (parsingOptions.contains(PortDBConstants::IMPORT_STORAGE_FORMAT_OPTION)) {
-        auto& value = parsingOptions.at(PortDBConstants::IMPORT_STORAGE_FORMAT_OPTION);
-        if (value.getDataType().getLogicalTypeID() != LogicalTypeID::STRING) {
-            throw BinderException("The type of storage_format option must be a string.");
-        }
-        auto valueStr = StringUtils::getUpper(value.getValue<std::string>());
-        if (valueStr != "ICEBUG-DISK") {
-            throw BinderException(std::format(
-                "Unsupported import database storage format '{}'. Valid options are: icebug-disk.",
-                value.getValue<std::string>()));
-        }
-        mountIcebug = true;
-        parsingOptions.erase(PortDBConstants::IMPORT_STORAGE_FORMAT_OPTION);
-    }
-    if (!parsingOptions.empty()) {
-        throw BinderException(
-            std::format("Unrecognized import database option: {}.", parsingOptions.begin()->first));
-    }
     std::string finalQueryStatements;
-    auto schemaQuery =
+    finalQueryStatements +=
         getQueryFromFile(fs, boundFilePath, PortDBConstants::SCHEMA_FILE_NAME, clientContext);
-    if (!mountIcebug) {
-        schemaQuery = stripIcebugStorageClauses(schemaQuery);
-        finalQueryStatements += schemaQuery;
-        finalQueryStatements +=
-            getNativeCopyStatements(fs, boundFilePath, schemaQuery, clientContext);
-    } else {
-        finalQueryStatements += schemaQuery;
-    }
     // replace the path in copy from statements with the bound path
     auto copyQuery =
         getQueryFromFile(fs, boundFilePath, PortDBConstants::COPY_FILE_NAME, clientContext);

sdist/ladybug-source/src/binder/query/query_graph.cpp

@@ -47,13 +47,6 @@ std::unordered_set<uint32_t> SubqueryGraph::getNodeNbrPositions() const {
 
 std::unordered_set<uint32_t> SubqueryGraph::getRelNbrPositions() const {
     std::unordered_set<uint32_t> result;
-    // Nodes in the subgraph: explicitly selected nodes plus endpoints of selected rels
-    // (rel-implied nodes). A neighboring rel is any unselected rel touching any of them.
-    // Considering rel-implied nodes allows the join enumerator to attach a rel to a
-    // subgraph through the node bound by a previous extend (e.g. planning
-    // (a)-[e1]->(b)-[e2]->(c) as scan(a) -> extend(e1) -> extend(e2)), instead of
-    // requiring an explicit node-table scan join first.
-    const auto nodePosSet = getNodePositionsIgnoringNodeSelector();
     for (auto relPos = 0u; relPos < queryGraph.getNumQueryRels(); ++relPos) {
         if (queryRelsSelector[relPos]) { // rel already in subgraph, cannot be rel neighbour
             continue;
@@ -61,7 +54,7 @@ std::unordered_set<uint32_t> SubqueryGraph::getRelNbrPositions() const {
         auto rel = queryGraph.getQueryRel(relPos);
         auto srcNodePos = queryGraph.getQueryNodeIdx(*rel->getSrcNode());
         auto dstNodePos = queryGraph.getQueryNodeIdx(*rel->getDstNode());
-        if (nodePosSet.contains(srcNodePos) || nodePosSet.contains(dstNodePos)) {
+        if (queryNodesSelector[srcNodePos] || queryNodesSelector[dstNodePos]) {
             result.insert(relPos);
         }
     }
@@ -84,13 +77,13 @@ subquery_graph_set_t SubqueryGraph::getNbrSubgraphs(uint32_t size) const {
 
 std::vector<uint32_t> SubqueryGraph::getConnectedNodePos(const SubqueryGraph& nbr) const {
     std::vector<uint32_t> result;
-    // Join nodes are the intersection of the full node sets (selected nodes plus
-    // rel-implied nodes), so joins through nodes that are only bound by a previous
-    // extend (not explicitly scanned) are discovered as well.
-    const auto thisNodePos = getNodePositionsIgnoringNodeSelector();
-    const auto nbrNodePos = nbr.getNodePositionsIgnoringNodeSelector();
-    for (auto& nodePos : thisNodePos) {
-        if (nbrNodePos.contains(nodePos)) {
+    for (auto& nodePos : getNodeNbrPositions()) {
+        if (nbr.queryNodesSelector[nodePos]) {
+            result.push_back(nodePos);
+        }
+    }
+    for (auto& nodePos : nbr.getNodeNbrPositions()) {
+        if (queryNodesSelector[nodePos]) {
             result.push_back(nodePos);
         }
     }

sdist/ladybug-source/src/c_api/version.cpp

@@ -7,7 +7,7 @@ char* lbug_get_version() {
     LBUG_C_API_GUARD_BEGIN
     auto version = lbug::main::Version::getVersion();
     if (version == nullptr || version[0] == '\0') {
-        version = "0.20.2";
+        version = "0.20.3";
     }
     return convertToOwnedCString(version);
     LBUG_C_API_GUARD_END(nullptr)

sdist/ladybug-source/src/catalog/catalog_entry/node_table_catalog_entry.cpp

@@ -202,9 +202,6 @@ std::string NodeTableCatalogEntry::toCypher(const ToCypherInfo& /*info*/) const
         base += std::format(" PARTITION BY {}({}) PARTITIONS {}", method,
             common::StringUtils::quoteIdentifier(partitionColumnName), numPartitions);
     }
-    if (storageFormat == common::StorageFormat::ICEBUG_DISK) {
-        base += std::format(" WITH (storage = '{}', format = 'icebug-disk')", storage);
-    }
     return base + ";";
 }
 

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

@@ -248,11 +248,7 @@ std::string RelGroupCatalogEntry::toCypher(const ToCypherInfo& info) const {
         }
     }
     ss << ", " << propertyCollection.toCypher()
-       << getMultiplicityStr(srcMultiplicity, dstMultiplicity);
-    if (storageFormat == common::StorageFormat::ICEBUG_DISK) {
-        ss << std::format(" WITH (storage = '{}', format = 'icebug-disk')", storage);
-    }
-    ss << ");";
+       << getMultiplicityStr(srcMultiplicity, dstMultiplicity) << ");";
     return ss.str();
 }
 

sdist/ladybug-source/src/function/export/CMakeLists.txt

@@ -1,8 +1,7 @@
 add_library(lbug_function_export
         OBJECT
         export_csv_function.cpp
-        export_parquet_function.cpp
-        export_indptr_function.cpp)
+        export_parquet_function.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:lbug_function_export>

sdist/ladybug-source/src/function/export/export_parquet_function.cpp

@@ -7,7 +7,6 @@
 #include "processor/operator/persistent/writer/parquet/parquet_writer.h"
 #include "processor/result/factorized_table.h"
 #include "storage/buffer_manager/memory_manager.h"
-#include "storage/table/ice_disk_constants.h"
 #include <format>
 
 namespace lbug {
@@ -19,14 +18,11 @@ using namespace processor;
 struct ParquetOptions {
     lbug_parquet::format::CompressionCodec::type codec =
         lbug_parquet::format::CompressionCodec::SNAPPY;
-    std::vector<lbug_parquet::format::KeyValue> keyValueMetadata;
 
     explicit ParquetOptions(case_insensitive_map_t<common::Value> parsingOptions) {
         for (auto& [name, value] : parsingOptions) {
             if (name == "COMPRESSION") {
                 setCompression(value);
-            } else if (name == storage::IceDiskConstants::VERSION_METADATA_KEY) {
-                setVersionMetadata(value);
             } else {
                 throw common::RuntimeException{
                     std::format("Unrecognized parquet option: {}.", name)};
@@ -34,18 +30,6 @@ struct ParquetOptions {
         }
     }
 
-    void setVersionMetadata(common::Value& value) {
-        if (value.getDataType().getLogicalTypeID() != LogicalTypeID::STRING) {
-            throw common::RuntimeException{std::format(
-                "Parquet {} option expects a string value, got: {}.",
-                storage::IceDiskConstants::VERSION_METADATA_KEY, value.getDataType().toString())};
-        }
-        lbug_parquet::format::KeyValue kv;
-        kv.__set_key(std::string(storage::IceDiskConstants::VERSION_METADATA_KEY));
-        kv.__set_value(value.getValue<std::string>());
-        keyValueMetadata.push_back(std::move(kv));
-    }
-
     void setCompression(common::Value& value) {
         if (value.getDataType().getLogicalTypeID() != LogicalTypeID::STRING) {
             throw common::RuntimeException{
@@ -117,8 +101,8 @@ struct ExportParquetSharedState : public ExportFuncSharedState {
         auto& exportParquetBindData = bindData.constCast<ExportParquetBindData>();
         writer = std::make_unique<ParquetWriter>(exportParquetBindData.fileName,
             common::LogicalType::copy(exportParquetBindData.types),
-            exportParquetBindData.columnNames, exportParquetBindData.parquetOptions.codec, &context,
-            exportParquetBindData.parquetOptions.keyValueMetadata);
+            exportParquetBindData.columnNames, exportParquetBindData.parquetOptions.codec,
+            &context);
     }
 };
 

sdist/ladybug-source/src/include/binder/bound_export_database.h

@@ -10,9 +10,6 @@ namespace binder {
 struct ExportedTableData {
     std::string tableName;
     std::string fileName;
-    // True for CSR indptr tables, which are computed (prefix-summed) rather than
-    // plain-copied, and need the dedicated indptr export function in the planner.
-    bool isIndptr = false;
     std::unique_ptr<BoundRegularQuery> regularQuery;
     std::vector<std::string> columnNames;
     std::vector<common::LogicalType> columnTypes;

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

@@ -213,11 +213,6 @@ struct PortDBConstants {
     static constexpr const char* SCHEMA_ONLY_OPTION = "SCHEMA_ONLY";
     static constexpr const char* EXPORT_FORMAT_OPTION = "FORMAT";
     static constexpr const char* DEFAULT_EXPORT_FORMAT_OPTION = "PARQUET";
-    // IMPORT DATABASE option: when set to 'icebug-disk', the exported icedisk files are
-    // mounted in place instead of being ingested into native tables (the default).
-    static constexpr const char* IMPORT_STORAGE_FORMAT_OPTION = "STORAGE_FORMAT";
-    // Parquet key-value metadata key written on every EXPORT DATABASE data file.
-    static constexpr const char* ICEBUG_DISK_VERSION_OPTION = "icebug_disk_version";
 };
 
 struct WarningConstants {