ladybug 0.20.2__tar.gz → 0.20.2.dev20260908__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ladybug
-Version: 0.20.2
+Version: 0.20.2.dev20260908
 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 LANGUAGES CXX C)
+project(Lbug VERSION 0.20.2.20260908 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="0.20.0")
+add_definitions(-DLBUG_EXTENSION_VERSION="dev")
 
 if(BUILD_LBUG OR LBUG_API_USE_PRECOMPILED_LIB)
 include_directories(

sdist/ladybug-source/docs/multi_parent_lifetime.md

@@ -1,5 +1,17 @@
 # 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;
+    : IMPORT SP DATABASE SP StringLiteral ( SP? '(' SP? iC_Options SP? ')' )? ;
 
 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 @@
-c6ef6ea298ca84a5c080bae09a29c9db
+6fc9fc9085d4f1028a4fb2b319152cb5

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

@@ -91,16 +91,27 @@ 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=-DBUILD_LBUG=FALSE -DBUILD_SHELL=FALSE '
+                'EXTRA_CMAKE_FLAGS=%s -DBUILD_LBUG=FALSE -DBUILD_SHELL=FALSE '
                 '-DLBUG_API_USE_PRECOMPILED_LIB=TRUE '
-                '-DLBUG_API_PRECOMPILED_LIB_PATH=%s' % precompiled_lib_path
+                '-DLBUG_API_PRECOMPILED_LIB_PATH=%s' % (no_split_flag, 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/scripts/pip-package/split_debug_symbols.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""Split debug symbols out of built Python wheels and repack stripped wheels.
+
+Used by .github/workflows/python-wheel-workflow.yml after cibuildwheel finishes:
+
+  Linux:   objcopy --only-keep-debug / --strip-debug / --add-gnu-debuglink
+           (mirrors the CMake POST_BUILD recipe in tools/python_api/CMakeLists.txt,
+           but runs on the final repaired wheel so auditwheel/delocate edits are
+           already baked in). If the wheel already ships a .debug file produced by
+           the in-build split and the .so is already stripped, that file is reused.
+  macOS:   dsymutil into a .dSYM bundle + strip -S, regenerated from the final
+           wheel binary so it matches the shipped (delocated) .so.
+  Windows: move *.pdb (plus *.exp/*.lib byproducts) out of the wheel; the .pyd
+           itself carries no debug data when linked with /DEBUG.
+
+Every repacked wheel gets a correct RECORD (hashes/sizes recomputed), and all
+extracted symbol files land in --symbols-dir for upload as separate artifacts.
+"""
+
+import argparse
+import base64
+import hashlib
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+
+
+def _has_debug_sections(shared_obj: Path) -> bool:
+    """Best-effort check for DWARF debug sections (False if unknown)."""
+    readelf = shutil.which("readelf")
+    if readelf is None:
+        return True  # Unknown: assume symbols present so we attempt a split.
+    try:
+        out = subprocess.run(
+            [readelf, "-S", str(shared_obj)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return ".debug_info" in out.stdout
+    except OSError:
+        return True
+
+
+def _run(cmd: list[str], cwd: Path | None = None) -> None:
+    print(f"+ {' '.join(cmd)}" + (f" (cwd={cwd})" if cwd else ""), flush=True)
+    subprocess.run(cmd, check=True, cwd=cwd)
+
+
+def _hash_record_entry(data: bytes) -> str:
+    digest = base64.urlsafe_b64encode(hashlib.sha256(data).digest()).rstrip(b"=")
+    return f"sha256={digest.decode()}"
+
+
+def _repack_wheel(unpacked_dir: Path, wheel_path: Path) -> None:
+    """Rewrite wheel zip from unpacked_dir, dropping stale RECORD entries and
+    recomputing hashes for every file (required after stripping binaries)."""
+    record_file = None
+    for dist_info in unpacked_dir.glob("*.dist-info"):
+        candidate = dist_info / "RECORD"
+        if candidate.is_file():
+            record_file = candidate
+            break
+    if record_file is None:
+        raise FileNotFoundError(f"No RECORD found in unpacked wheel at {unpacked_dir}")
+
+    record_rel = record_file.relative_to(unpacked_dir).as_posix()
+    rows: list[str] = []
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".whl") as tmp:
+        tmp_path = Path(tmp.name)
+    try:
+        with zipfile.ZipFile(tmp_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for root, _, files in os.walk(unpacked_dir):
+                for name in sorted(files):
+                    full = Path(root) / name
+                    rel = full.relative_to(unpacked_dir).as_posix()
+                    if rel == record_rel:
+                        continue
+                    data = full.read_bytes()
+                    zf.writestr(rel, data)
+                    rows.append(f"{rel},{_hash_record_entry(data)},{len(data)}")
+            rows.append(f"{record_rel},,")
+            zf.writestr(record_rel, "\n".join(rows) + "\n")
+        shutil.move(str(tmp_path), str(wheel_path))
+    finally:
+        if tmp_path.exists():
+            tmp_path.unlink()
+
+
+def _find_extensions(tree: Path, suffixes: tuple[str, ...]) -> list[Path]:
+    hits = []
+    for suffix in suffixes:
+        hits.extend(tree.rglob(f"_lbug*{suffix}"))
+    # Skip files that live inside symbol bundles/dirs themselves. NOTE: a
+    # dSYM bundle dir is named "<binary>.dSYM", so ".dSYM" is a suffix of
+    # a path part, not a standalone part -- check endswith, not membership.
+    return [
+        p
+        for p in hits
+        if p.is_file()
+        and not any(part.endswith(".dSYM") for part in p.parts)
+        and not p.name.endswith(".debug")
+    ]
+
+
+def _mach_o_has_dwarf(shared_obj: Path) -> bool:
+    """Best-effort check for a __DWARF segment (False if unknown is unsafe).
+    Returns True when unsure so callers attempt a split rather than reuse."""
+    otool = shutil.which("otool")
+    if otool is None:
+        return True
+    try:
+        out = subprocess.run(
+            [otool, "-l", str(shared_obj)],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return "__DWARF" in out.stdout
+    except OSError:
+        return True
+
+
+def _split_linux(wheel_path: Path, tree: Path, symbols_dir: Path) -> None:
+    objcopy = shutil.which("objcopy")
+    if objcopy is None:
+        print("objcopy not found; leaving Linux wheel unstripped.", flush=True)
+        return
+    for so in _find_extensions(tree, (".so",)):
+        stem = f"{wheel_path.stem}-{so.name}"
+        shipped = list(tree.rglob("*.debug"))
+        if shipped and not _has_debug_sections(so):
+            # In-build CMake split already stripped this binary; reuse it.
+            for dbg in shipped:
+                dest = symbols_dir / f"{stem}.debug"
+                print(f"Reusing shipped debug file {dbg} -> {dest}", flush=True)
+                shutil.move(str(dbg), str(dest))
+            continue
+        # Regenerate from the final (repaired) binary.
+        for dbg in shipped:
+            dbg.unlink()
+        dbg_out = so.parent / f"{so.name}.debug"
+        _run([objcopy, "--only-keep-debug", str(so), str(dbg_out)])
+        _run([objcopy, "--strip-debug", str(so)])
+        # --strip-debug leaves a pre-existing .gnu_debuglink behind, and
+        # --add-gnu-debuglink refuses to overwrite it, so drop it first.
+        subprocess.run(
+            [objcopy, "-R", ".gnu_debuglink", str(so)],
+            capture_output=True,
+            check=False,
+        )
+        # NOTE: --add-gnu-debuglink resolves a relative filename against the
+        # process CWD (not the binary's dir), so run from so.parent so the
+        # stored link stays a bare filename while objcopy can read the file.
+        _run([objcopy, f"--add-gnu-debuglink={dbg_out.name}", str(so)], cwd=so.parent)
+        dest = symbols_dir / f"{stem}.debug"
+        print(f"Moving {dbg_out} -> {dest}", flush=True)
+        shutil.move(str(dbg_out), str(dest))
+
+
+def _split_macos(wheel_path: Path, tree: Path, symbols_dir: Path) -> None:
+    dsymutil = shutil.which("dsymutil")
+    strip = shutil.which("strip")
+    if dsymutil is None or strip is None:
+        print("dsymutil/strip not found; leaving macOS wheel unstripped.", flush=True)
+        return
+    for so in _find_extensions(tree, (".so",)):
+        stem = f"{wheel_path.stem}-{so.name}"
+        shipped = [d for d in tree.rglob("*.dSYM")]
+        if shipped and not _mach_o_has_dwarf(so):
+            # In-build split already stripped this binary; reuse its bundle.
+            for dsym in shipped:
+                dest = symbols_dir / f"{stem}.dSYM"
+                if dest.exists():
+                    shutil.rmtree(dest) if dest.is_dir() else dest.unlink()
+                print(f"Reusing shipped dSYM {dsym} -> {dest}", flush=True)
+                shutil.move(str(dsym), str(dest))
+            continue
+        # Otherwise drop any stale pre-repair bundle and regenerate below so
+        # the dSYM matches the final delocated binary.
+        for stale in shipped:
+            if stale.is_dir():
+                shutil.rmtree(stale)
+            elif stale.is_file():
+                stale.unlink()
+        dsym_out = Path(tempfile.mkdtemp()) / f"{so.name}.dSYM"
+        _run([dsymutil, str(so), "-o", str(dsym_out)])
+        _run([strip, "-S", str(so)])
+        dest = symbols_dir / f"{stem}.dSYM"
+        if dest.exists():
+            shutil.rmtree(dest)
+        print(f"Moving {dsym_out} -> {dest}", flush=True)
+        shutil.move(str(dsym_out), str(dest))
+
+
+def _split_windows(wheel_path: Path, tree: Path, symbols_dir: Path) -> None:
+    stem = wheel_path.stem
+    for pattern in ("*.pdb", "*.exp", "*.lib"):
+        for artifact in tree.rglob(pattern):
+            if not artifact.is_file():
+                continue
+            if pattern == "*.pdb":
+                dest = symbols_dir / f"{stem}-{artifact.name}"
+                print(f"Moving {artifact} -> {dest}", flush=True)
+                shutil.move(str(artifact), str(dest))
+            else:
+                # Linker byproducts: never ship in the wheel.
+                print(f"Removing linker byproduct {artifact}", flush=True)
+                artifact.unlink()
+    # The .pyd linked with /DEBUG already carries no debug data; nothing to strip.
+
+
+def process_wheel(wheel_path: Path, symbols_dir: Path, os_name: str) -> None:
+    print(f"=== {wheel_path.name} ({os_name}) ===", flush=True)
+    with tempfile.TemporaryDirectory() as tmp:
+        tree = Path(tmp) / "wheel"
+        with zipfile.ZipFile(wheel_path, "r") as zf:
+            zf.extractall(tree)
+        if os_name == "linux":
+            _split_linux(wheel_path, tree, symbols_dir)
+        elif os_name == "macos":
+            _split_macos(wheel_path, tree, symbols_dir)
+        elif os_name == "windows":
+            _split_windows(wheel_path, tree, symbols_dir)
+        else:
+            raise ValueError(f"Unknown os: {os_name}")
+        _repack_wheel(tree, wheel_path)
+    print(f"Repacked stripped wheel: {wheel_path.name}", flush=True)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--wheel-dir", required=True, help="Directory with *.whl files")
+    parser.add_argument("--symbols-dir", required=True, help="Output dir for symbols")
+    parser.add_argument("--os", required=True, choices=["linux", "macos", "windows"])
+    args = parser.parse_args()
+
+    wheel_dir = Path(args.wheel_dir)
+    symbols_dir = Path(args.symbols_dir)
+    symbols_dir.mkdir(parents=True, exist_ok=True)
+
+    wheels = sorted(wheel_dir.glob("*.whl"))
+    if not wheels:
+        print(f"No wheels found in {wheel_dir}; nothing to do.", flush=True)
+        return 0
+    for wheel in wheels:
+        process_wheel(wheel, symbols_dir, args.os)
+
+    produced = sorted(p.name for p in symbols_dir.iterdir())
+    print(f"Symbol files produced ({len(produced)}):", flush=True)
+    for name in produced:
+        print(f"  {name}", flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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;
+    : IMPORT SP DATABASE SP StringLiteral ( SP? '(' SP? iC_Options SP? ')' )? ;
 
 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,6 +11,7 @@
 #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>
 
@@ -35,6 +36,10 @@ 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;
@@ -57,66 +62,134 @@ 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) {
-    return std::format("match (a:{}) return a.*", StringUtils::quoteIdentifier(entry.getName()));
+    // 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);
 }
 
-static std::string getExportRelTableDataQuery(const TableCatalogEntry& relGroupEntry,
+static std::string getExportRelIndicesQuery(const TableCatalogEntry& relGroupEntry,
     const NodeTableCatalogEntry& srcEntry, const NodeTableCatalogEntry& dstEntry) {
-    return std::format("match (a:{})-[r:{}]->(b:{}) return a.{},b.{},r.*;",
+    // 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));",
         StringUtils::quoteIdentifier(srcEntry.getName()),
         StringUtils::quoteIdentifier(relGroupEntry.getName()),
         StringUtils::quoteIdentifier(dstEntry.getName()),
-        StringUtils::quoteIdentifier(srcEntry.getPrimaryKeyName()),
-        StringUtils::quoteIdentifier(dstEntry.getPrimaryKeyName()));
+        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"));
 }
 
 static std::vector<ExportedTableData> getExportInfo(const Catalog& catalog,
-    main::ClientContext* context, Binder* binder, FileTypeInfo& fileTypeInfo) {
+    main::ClientContext* context, Binder* binder, [[maybe_unused]] 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 =
-            entry->getName() + "." + StringUtils::getLower(fileTypeInfo.fileTypeStr);
+        tableData.fileName = std::format("nodes_{}.parquet", entry->getName());
         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>();
-            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));
+            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));
         }
     }
 
+    // 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)) {
-        // Export
-        ExportedTableData tableData;
-        auto entry = indexEntry->getTableEntryToExport(context);
-        if (entry == nullptr) {
+        auto auxEntry = indexEntry->getTableEntryToExport(context);
+        if (auxEntry == nullptr) {
             continue;
         }
-        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);
+        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);
         exportData.push_back(std::move(tableData));
     }
     return exportData;
@@ -158,10 +231,17 @@ std::unique_ptr<BoundStatement> Binder::bindExportDatabaseClause(const Statement
     }
     auto exportSchemaOnly = schemaOnly(parsedOptions, exportDB);
     if (!exportSchemaOnly && fileTypeInfo.fileType != FileType::CSV && parsedOptions.size() != 0) {
-        throw BinderException{"Only export to csv can have options."};
+        throw BinderException{"Export database does not support copy options with the parquet "
+                              "(icebug-disk CSR) format."};
     }
     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),