From 23c77c8666b4b1ca285b0800b4a4f4327dc0635c Mon Sep 17 00:00:00 2001 From: Ally Heev Date: Thu, 21 May 2026 19:30:53 +0530 Subject: [PATCH 1/5] release 0.17.0 --- astro.config.mjs | 2 + .../cypher/expressions/aggregate-functions.md | 1 + src/content/docs/cypher/indexes.md | 40 +++++++++++++++ .../database-internal/index.md | 2 +- src/content/docs/import/graph-databases.md | 35 +------------ src/content/docs/import/icebug.md | 50 +++++++++++++++++++ 6 files changed, 95 insertions(+), 35 deletions(-) create mode 100644 src/content/docs/cypher/indexes.md create mode 100644 src/content/docs/import/icebug.md diff --git a/astro.config.mjs b/astro.config.mjs index c494157..e6aa56e 100644 --- a/astro.config.mjs +++ b/astro.config.mjs @@ -151,6 +151,7 @@ export default defineConfig({ { label: 'Functions, expressions, & operators', link: '/cypher/expressions' }, { label: 'Data definition language (DDL)', link: '/cypher/data-definition' }, { label: 'Data manipulation clauses', link: '/cypher/data-manipulation-clauses' }, + { label: 'Indexes', link: '/cypher/indexes' }, { label: 'Subqueries', link: '/cypher/subquery' }, { label: 'Macros', link: '/cypher/macro' }, { label: 'Transactions', link: '/cypher/transaction' }, @@ -195,6 +196,7 @@ export default defineConfig({ { label: 'Copy from DataFrame', link: '/import/copy-from-dataframe' }, { label: 'Copy from subquery', link: '/import/copy-from-subquery' }, { label: 'Copy from JSON', link: '/import/copy-from-json' }, + { label: 'Icebug', link: '/import/icebug' }, { label: 'Graph databases', link: '/import/graph-databases' }, ] }, diff --git a/src/content/docs/cypher/expressions/aggregate-functions.md b/src/content/docs/cypher/expressions/aggregate-functions.md index a6c95ef..e75cefd 100644 --- a/src/content/docs/cypher/expressions/aggregate-functions.md +++ b/src/content/docs/cypher/expressions/aggregate-functions.md @@ -13,5 +13,6 @@ description: Aggregate functions are used to compute a single result from a set | `max(arg)` | returns the maximum value of arg | `max(a.length)` | | `sum(arg)` | returns the sum value of all tuples in arg | `sum(a.length)` | | `collect(arg)` | returns a list of values returned by arg expression | `collect(a.age)` | +| `percentileDisc(arg, percentile)` | returns the value that corresponds to the given discrete percentile of the input values; `percentile` must be a literal between `0.0` and `1.0` | `percentileDisc(a.age, 0.5)` | \ No newline at end of file diff --git a/src/content/docs/cypher/indexes.md b/src/content/docs/cypher/indexes.md new file mode 100644 index 0000000..78c77ac --- /dev/null +++ b/src/content/docs/cypher/indexes.md @@ -0,0 +1,40 @@ +--- +title: Indexes +description: Create and manage primary key indexes on node tables using HASH or ART index types +--- + +Ladybug automatically creates a primary key index(hash) on every node table to enforce uniqueness +and accelerate primary-key lookups. Ladybug also supports ART indexes for faster range queries on primary keys + +## Default HASH index + +When you create a node table, Ladybug automatically builds a hash-based primary-key index. +No extra DDL is required + +If you want to disable the default HASH index to save space, you can do so by setting the `enable_default_hash_index` property to `false` before creating any node tables: + +```cypher +CALL enable_default_hash_index = false; +``` + +Note: The config resets on close, so you need to run this command every time you start a new session if you want to keep the default index disabled + +## Creating indexes manually + +If you want to create an index on a node table when the `enable_default_hash_index` config is set to false, you can run one of the index creation commands: + +To create the inbuilt HASH index: +```cypher +CREATE HASH INDEX FOR (:) ON (.); +``` + +```cypher +CREATE INDEX FOR (:) ON (.); +``` + +To create the ART index: +```cypher +CREATE ART INDEX FOR (:) ON (.); +``` + +Note: At a time, only one primary key index can be created per node table diff --git a/src/content/docs/developer-guide/database-internal/index.md b/src/content/docs/developer-guide/database-internal/index.md index 0b6c607..63e1037 100644 --- a/src/content/docs/developer-guide/database-internal/index.md +++ b/src/content/docs/developer-guide/database-internal/index.md @@ -48,7 +48,7 @@ The catalog module contains schema-level information that is generated through D The storage module contains data that needs to be persistent to disk. Specifically: - **BufferManager**: manages all memory being used in the system (except for small memory allocations from the OS); caches recently read pages in memory. -- **Index**: Hash index for primary keys. +- **Index**: Hash index and ART (Adaptive Radix Tree) index for primary keys. - **Column**: Vanilla column data structure. - **List**: CSR-like data structure. - **NodeTable**: A collection of multiple columns. diff --git a/src/content/docs/import/graph-databases.md b/src/content/docs/import/graph-databases.md index 3a737d6..edf443c 100644 --- a/src/content/docs/import/graph-databases.md +++ b/src/content/docs/import/graph-databases.md @@ -37,37 +37,4 @@ To use GraphAr data in Ladybug, convert it to Icebug format first: uvx icebug-format --graphar ``` -This generates a directory of Parquet files plus a Cypher schema file that can be loaded directly with `lbug -i`. See the [Icebug format](#icebug-format) section for details. - -## Icebug format - -[Icebug](https://github.com/Ladybug-Memory/icebug-format) is a Ladybug-native graph-aware Parquet format designed for ingestion-free graph analytics. Unlike general-purpose Parquet files, Icebug preserves graph structure (node and relationship tables) and enables direct querying without preprocessing. - -### Generating Icebug files - -Use the `icebug-format` tool to generate Icebug files from existing databases: - -```bash -# From a DuckDB database -uvx icebug-format --source-db demo-db.duckdb --schema schema.cypher - -# From a GraphAr archive -uvx icebug-format --graphar -``` - -This generates a directory of Parquet files (for nodes and relationships) plus a Cypher schema file. - -### Using Icebug files - -Start Ladybug with the generated schema file using the `-i` flag: - -```bash -lbug -i csr_graph/schema.cypher -``` - -Then query the graph directly: - -```cypher -MATCH (a:User)-[b:LivesIn]->(c:City) -RETURN a.*, b.*, c.*; -``` +This generates a directory of Parquet files plus a Cypher schema file that can be loaded directly with `lbug -i`. See the [Icebug format](/import/icebug) section for details. diff --git a/src/content/docs/import/icebug.md b/src/content/docs/import/icebug.md new file mode 100644 index 0000000..f29f25d --- /dev/null +++ b/src/content/docs/import/icebug.md @@ -0,0 +1,50 @@ +--- +title: "Icebug format" +description: Read data from Icebug format +--- + +Icebug format comes in two flavours: icebug-disk and icebug-memory + +## icebug-disk + +[icebug-disk](https://github.com/Ladybug-Memory/icebug-format) is a Ladybug-native graph-aware Parquet format designed for ingestion-free graph analytics. Unlike general-purpose Parquet files, Icebug preserves graph structure (node and relationship tables) and enables direct querying without preprocessing. + +### Generating Icebug files + +Use the `icebug-format` tool to generate icebug-disk files from existing databases: + +```bash +# From a DuckDB database +uvx icebug-format --source-db demo-db.duckdb --schema schema.cypher + +# From a GraphAr archive +uvx icebug-format --graphar +``` + +This generates a directory of Parquet files (for nodes and relationships) plus a Cypher schema file. + +schema.cypher example: + +```cypher +CREATE NODE TABLE city(id INT32, name STRING, population INT64, PRIMARY KEY(id)) WITH (storage = '', format = 'icebug-disk'); +CREATE NODE TABLE user(id INT32, name STRING, age INT64, PRIMARY KEY(id)) WITH (storage = '', format = 'icebug-disk'); +CREATE REL TABLE follows(FROM user TO user, since INT32) WITH (storage = '', format = 'icebug-disk'); +CREATE REL TABLE livesin(FROM user TO city) WITH (storage = '', format = 'icebug-disk'); +``` + +### Using Icebug files + +Start Ladybug with the generated schema file using the `-i` flag: + +```bash +lbug -i csr_graph/schema.cypher +``` + +or Run the DDL queries yourself in a Ladybug instance. We also support parquet files on remote storage (e.g. S3) + +Then query the graph directly: + +```cypher +MATCH (a:User)-[b:LivesIn]->(c:City) +RETURN a.*, b.*, c.*; +``` \ No newline at end of file From 1fbc9c41b9f717bf25c450116d40a147c4dad240 Mon Sep 17 00:00:00 2001 From: Ally Heev Date: Thu, 28 May 2026 19:23:43 +0530 Subject: [PATCH 2/5] add icebug-memory doc --- src/content/docs/import/icebug.md | 70 +++++++++++++++++++++++++++++-- 1 file changed, 66 insertions(+), 4 deletions(-) diff --git a/src/content/docs/import/icebug.md b/src/content/docs/import/icebug.md index f29f25d..62a5b19 100644 --- a/src/content/docs/import/icebug.md +++ b/src/content/docs/import/icebug.md @@ -3,7 +3,7 @@ title: "Icebug format" description: Read data from Icebug format --- -Icebug format comes in two flavours: icebug-disk and icebug-memory +[Icebug format](https://github.com/Ladybug-Memory/icebug-format) comes in two flavours: icebug-disk and icebug-memory. Both store graph data in CSR format. You can bring your own node and rel tables(with `from` and `to` columns) and generate icebug files with the [icebug-format](https://pypi.org/project/icebug-format/) tool ## icebug-disk @@ -15,7 +15,7 @@ Use the `icebug-format` tool to generate icebug-disk files from existing databas ```bash # From a DuckDB database -uvx icebug-format --source-db demo-db.duckdb --schema schema.cypher +uvx icebug-format --source-db demo-db.duckdb --schema input_schema.cypher # From a GraphAr archive uvx icebug-format --graphar @@ -23,7 +23,7 @@ uvx icebug-format --graphar This generates a directory of Parquet files (for nodes and relationships) plus a Cypher schema file. -schema.cypher example: +output schema.cypher: ```cypher CREATE NODE TABLE city(id INT32, name STRING, population INT64, PRIMARY KEY(id)) WITH (storage = '', format = 'icebug-disk'); @@ -32,6 +32,8 @@ CREATE REL TABLE follows(FROM user TO user, since INT32) WITH (storage = '(c:City) RETURN a.*, b.*, c.*; -``` \ No newline at end of file +``` + +If the ladybug instance is created backed by a file `graph.lbdb`, you can move it around or export it, along with the data, and query it without needing to re-create the graph. You can also attach the same db to another instance of ladybug using + +```cypher +ATTACH 'graph.lbdb' AS mygraph (dbtype lbug); +``` + +For more details about attaching databases, see the [attach documentation](/extensions/attach/lbug.md). + +## icebug-memory + +[icebug-memory](https://github.com/Ladybug-Memory/icebug-format) is a Ladybug-native graph-aware Arrow format designed for ingestion-free graph analytics. Unlike general-purpose Arrow tables, Icebug preserves graph structure (node and relationship tables) and enables direct querying without preprocessing. + +### Generating Icebug tables + +Use the `icebug-format` tool to generate icebug-memory tables from existing arrow tables: + +```python +from icebug_format import IcebugMemGraph + +graph: IcebugMemGraph = IcebugMemGraph.from_arrow_tables( + from_node_arrow_table=users, # pa.Table, first column is the primary key + rel_arrow_table=livesin, # pa.Table with 'source' / 'from' and 'target' / 'to' columns + to_node_arrow_table=cities, # pa.Table, first column is the primary key +) +``` + +Note: The convertion utility is only available in python for now. + +### Using Icebug tables + +Ladybug python, nodejs, rust, and C++ bindings expose create APIs for node and rel tables. For example, in python: + +```python +import ladybug as lb + +# get icebug graph from earlier step + +db = lb.Database() +conn = lb.Connection(db) + +# Create node table +conn.create_arrow_table( + table_name="users", # node table name to be used in ladybug + dataframe=graph.src # node table as a pa.Table +) + +# create rel table +conn.create_arrow_rel_table( + table_name="livesin", # rel table name to be used in ladybug + src_table_name="users", # src node table name from table creation earlier + dst_table_name="cities", # dst node table name from table creation earlier + layout="CSR", + dataframe=graph.indices, # rel table with 'source' and 'target' columns + dst_col_name="to", # dst col name in the indices table + indptr=graph.indptr, # row pointers for indices table +) + +conn.execute("MATCH (a:users)-[b:livesin]->(c:cities) RETURN a.*, b.*, c.*") +``` From c064f2101fbd8c7e8455b07bb7135a67ffd5f0f1 Mon Sep 17 00:00:00 2001 From: Ally Heev Date: Thu, 28 May 2026 19:36:08 +0530 Subject: [PATCH 3/5] add icebug doc in scan.mdx --- src/content/docs/get-started/scan.mdx | 75 ++++++++++++++++++++++++--- 1 file changed, 69 insertions(+), 6 deletions(-) diff --git a/src/content/docs/get-started/scan.mdx b/src/content/docs/get-started/scan.mdx index 2d273b3..f256878 100644 --- a/src/content/docs/get-started/scan.mdx +++ b/src/content/docs/get-started/scan.mdx @@ -115,7 +115,8 @@ Query data directly from external sources without importing. Unlike `LOAD FROM`, ### Supported sources -- Parquet files +- Icebug disk (CSR Parquet files with a Cypher schema) +- Icebug memory (CSR Arrow tables) - Arrow memory - DuckDB tables - PostgreSQL (coming soon) @@ -132,16 +133,78 @@ WITH (storage='path/to/employee.parquet'); ```cypher CREATE REL TABLE WorksIn (from Person, to Company, since INT32) -WITH (storage='path/to/works_in.parquet'); +WITH (storage='path/to/works_in.parquet', format='icebug-disk'); ``` -### Arrow memory - -You can query Arrow memory directly by registering it with the database. The `arrowId` is obtained when you register Arrow memory (e.g., via the Python API): +### Icebug disk +**NODE tables:** ```cypher CREATE NODE TABLE Employee (id INT64, name STRING, PRIMARY KEY (id)) -WITH (storage='arrow://my_arrow_table_id'); +WITH (storage='icebug-disk/', format='icebug-disk'); + +CREATE NODE TABLE Company (id INT64, name STRING, PRIMARY KEY (id)) +WITH (storage='icebug-disk/company.parquet', format='icebug-disk'); +``` + +**REL table:** +```cypher +CREATE REL TABLE WorksIn (from Employee, to Company, since INT32) +WITH (storage='icebug-disk/', format='icebug-disk'); +``` + +For more details about generating and using icebug-disk files, see the [icebug documentation](/import/icebug/). + +### Icebug memory + +```python +import ladybug as lb + +db = lb.Database() +conn = lb.Connection(db) + +# Create node table +conn.create_arrow_table( + table_name="employee", # node table name to be used in ladybug + dataframe=pa_employee # node table as a pa.Table +) + +# create rel table +conn.create_arrow_rel_table( + table_name="worksin", # rel table name to be used in ladybug + src_table_name="employee", # src node table name from table creation earlier + dst_table_name="company", # dst node table name from table creation earlier + layout="CSR", + dataframe=pa_company_indices, # rel table with 'source' and 'target' columns + dst_col_name="target", # dst col name in the indices table + indptr=pa_company_indptr, # row pointers for indices table +) +``` + +For more details about generating and using icebug-memory tables, see the [icebug documentation](/import/icebug/). + +### Arrow memory + +```python +import ladybug as lb + +db = lb.Database() +conn = lb.Connection(db) + +# Create node table +conn.create_arrow_table( + table_name="employee", # node table name to be used in ladybug + dataframe=pa_employee # node table as a pa.Table +) + +# create rel table +conn.create_arrow_rel_table( + table_name="worksin", # rel table name to be used in ladybug + src_table_name="employee", # src node table name from table creation earlier + dst_table_name="company", # dst node table name from table creation earlier + layout="FLAT", + dataframe=pa_company, # rel table with 'from' and 'to' columns +) ``` ### DuckDB From 4301c7b9cd22fe79427e81cfd50a7114a8a8a1df Mon Sep 17 00:00:00 2001 From: Ally Heev Date: Thu, 28 May 2026 20:18:56 +0530 Subject: [PATCH 4/5] add adbc driver doc --- src/content/docs/cypher/indexes.md | 20 ++- src/content/docs/extensions/attach/adbc.mdx | 130 +++++++++++++++++++ src/content/docs/extensions/attach/rdbms.mdx | 5 + src/content/docs/extensions/index.mdx | 1 + src/content/docs/import/icebug.md | 51 +++++++- 5 files changed, 202 insertions(+), 5 deletions(-) create mode 100644 src/content/docs/extensions/attach/adbc.mdx diff --git a/src/content/docs/cypher/indexes.md b/src/content/docs/cypher/indexes.md index 78c77ac..2d570ec 100644 --- a/src/content/docs/cypher/indexes.md +++ b/src/content/docs/cypher/indexes.md @@ -4,13 +4,31 @@ description: Create and manage primary key indexes on node tables using HASH or --- Ladybug automatically creates a primary key index(hash) on every node table to enforce uniqueness -and accelerate primary-key lookups. Ladybug also supports ART indexes for faster range queries on primary keys +and accelerate primary-key lookups. Ladybug also supports ART indexes for faster range queries on primary keys. Ladybug also maintains **zone maps** (min/max indexes) on all columns automatically — these are used to skip irrelevant node groups during scans and to answer `COUNT(*)` queries without reading column data. ## Default HASH index When you create a node table, Ladybug automatically builds a hash-based primary-key index. No extra DDL is required +### Space amplification + +The hash index stores one entry per node and adds roughly **15–25 bytes per row** on top of the column data, depending on the primary key type: + +| Primary key type | Index overhead | +|---|---| +| `INT32` | ~14 bytes/row | +| `INT64` | ~18 bytes/row | +| `STRING` | ~18 bytes/row + key length | + +The column data is stored with compression (Zstandard by default) and is typically similar in size to the source Parquet file. So the total on-disk footprint of a node table is roughly: + +``` +total size ≈ compressed column data + (num_rows × ~15–25 bytes) +``` + +**Example**: a 300 MB Parquet file resulted in a **1.2 GB** `.lbdb` database with the default hash index enabled. Disabling the hash index brought it down to **1 GB** — roughly 16% smaller. + If you want to disable the default HASH index to save space, you can do so by setting the `enable_default_hash_index` property to `false` before creating any node tables: ```cypher diff --git a/src/content/docs/extensions/attach/adbc.mdx b/src/content/docs/extensions/attach/adbc.mdx new file mode 100644 index 0000000..1fba0f1 --- /dev/null +++ b/src/content/docs/extensions/attach/adbc.mdx @@ -0,0 +1,130 @@ +--- +title: ADBC extension +description: Connect to any ADBC-compatible database (DuckDB, PostgreSQL, SQLite, Snowflake, etc.) using the Apache Arrow ADBC standard. +--- + +The `adbc` extension allows you to attach any database that exposes an [Apache Arrow Database Connectivity (ADBC)](https://arrow.apache.org/adbc/) driver. ADBC is a vendor-neutral standard for database connectivity, and drivers are available for PostgreSQL, DuckDB, SQLite, Snowflake, and more. + +Use ADBC when: +- You need to connect to a database that doesn't have its own dedicated Ladybug extension. +- You want to use a single, uniform interface across multiple backend databases. + +## Dependencies + +The `adbc` extension requires the ADBC driver for the database you want to connect to. You must have the driver library available on your system before using this extension. + +Common ADBC drivers can be installed via `pip`: + +```bash +# PostgreSQL +pip install adbc-driver-postgresql + +# DuckDB +pip install adbc-driver-duckdb + +# SQLite +pip install adbc-driver-sqlite + +# Snowflake +pip install adbc-driver-snowflake +``` + +Each package installs a shared library (e.g., `libadbc_driver_postgresql.so` on Linux) that ADBC can load by name. + +## Usage + +Please see [Install an extension](/extensions#install-an-extension) and [Load an extension](/extensions#load-an-extension) first before getting started. + +### Attach syntax + +```cypher +ATTACH [DB_PATH] [AS alias] + (dbtype adbc, driver = 'DRIVER_NAME', tables = 'TABLE1[,TABLE2,...]' [, schema = 'SCHEMA_NAME'] [, KEY = 'VALUE' ...]) +``` + +- **`DB_PATH`**: Path or URI to the database. Paths are passed to the driver as `path`; URIs containing `://` are passed as `uri`. +- **`alias`**: Optional name to reference this database in Ladybug queries. +- **`driver`** (required): ADBC driver name or path to its shared library. +- **`tables`** (required): Comma-separated list of table names to expose in Ladybug. +- **`schema`** (optional): Schema name to look up tables in. Defaults to `main`. +- Any additional key-value options are forwarded directly to the ADBC driver (e.g., connection credentials). + +:::note[Note] +Unlike other database extensions, the ADBC extension currently requires you to explicitly list the tables you want to attach via `tables = 'table1,table2,...'`. Automatic table discovery is not yet supported. +::: + +### Example: Attach a DuckDB database + +First, install and load the `adbc` extension: + +```cypher +INSTALL adbc; +LOAD adbc; +``` + +Then attach a local DuckDB file: + +```cypher +ATTACH 'games.duckdb' AS games_db (dbtype adbc, driver='duckdb', tables='games'); +``` + +Scan the table: + +```cypher +LOAD FROM games_db.games RETURN id, title, score ORDER BY id; +``` + +```table +┌────┬────────┬───────┐ +│ id │ title │ score │ +├────┼────────┼───────┤ +│ 1 │ Portal │ 95 │ +│ 2 │ Celeste│ 94 │ +│ 3 │ Hades │ 93 │ +└────┴────────┴───────┘ +``` + +### Example: Attach a PostgreSQL database + +```cypher +ATTACH 'postgresql://user:password@localhost:5432/mydb' AS pg + (dbtype adbc, driver='adbc_driver_postgresql', tables='orders,customers'); +``` + +### Example: Attach a Snowflake database + +```cypher +ATTACH '' AS sf ( + dbtype adbc, + driver = 'adbc_driver_snowflake', + tables = 'employees', + adbc.snowflake.sql.account = 'myaccount', + username = 'myuser', + password = 'mypassword' +); +``` + +### Detach a database + +```cypher +DETACH games_db; +``` + +## Copy data into Ladybug + +You can import data from an ADBC-attached table using `COPY FROM`: + +```cypher +CREATE NODE TABLE Game (id INT64 PRIMARY KEY, title STRING, score INT64); +COPY Game FROM games_db.games; +``` + +Or selectively with a subquery: + +```cypher +COPY Game FROM (LOAD FROM games_db.games WHERE score >= 94 RETURN id, title, score); +``` + +## Comparison to dedicated extensions + +The `adbc` extension trades per-database optimizations (e.g., push-down SQL queries via `SQL_QUERY`) for breadth: any ADBC driver works. Dedicated extensions such as [`duckdb`](/extensions/attach/duckdb) and [`postgres`](/extensions/attach/postgres) support features like `SQL_QUERY` that bypass Ladybug's query engine entirely for filtering, and may offer better type coverage. Prefer a dedicated extension when one is available. diff --git a/src/content/docs/extensions/attach/rdbms.mdx b/src/content/docs/extensions/attach/rdbms.mdx index c79819c..2a7323c 100644 --- a/src/content/docs/extensions/attach/rdbms.mdx +++ b/src/content/docs/extensions/attach/rdbms.mdx @@ -14,6 +14,11 @@ The currently available relational database extensions are shown below: Extension Name | Description | Minimum Version :---:|:---:|:---: +[`adbc`](/extensions/attach/adbc) | Scan from any ADBC-compatible database | – [`duckdb`](/extensions/attach/duckdb) | Scan from an attached DuckDB database | 0.10.0 [`postgres`](/extensions/attach/postgres) | Scan from an attached PostgreSQL database | 14.0 [`sqlite`](/extensions/attach/sqlite) | Scan from an attached SQLite database | 3.3.0 + +:::note[Note] +The `adbc` extension is a generic adapter that works with any database exposing an [ADBC driver](https://arrow.apache.org/adbc/). Prefer a dedicated extension (DuckDB, PostgreSQL, SQLite) when one is available, as dedicated extensions offer additional features such as arbitrary SQL pass-through via `SQL_QUERY`. +::: diff --git a/src/content/docs/extensions/index.mdx b/src/content/docs/extensions/index.mdx index b8ce1fd..e5b6ec9 100644 --- a/src/content/docs/extensions/index.mdx +++ b/src/content/docs/extensions/index.mdx @@ -13,6 +13,7 @@ The following extensions are currently implemented: | Extension | Description | |----------|----------| +| [adbc](/extensions/attach/adbc) | Scan data from any ADBC-compatible database (DuckDB, PostgreSQL, SQLite, Snowflake, etc.) | | [algo](/extensions/algo) | Graph algorithms | | [azure](/extensions/azure) | Scan from Azure Blob Storage and Azure Data Lake Storage (ADLS) | | [delta](/extensions/attach/delta) | Scan data from Delta Lake tables | diff --git a/src/content/docs/import/icebug.md b/src/content/docs/import/icebug.md index 62a5b19..d0030c2 100644 --- a/src/content/docs/import/icebug.md +++ b/src/content/docs/import/icebug.md @@ -32,7 +32,9 @@ CREATE REL TABLE follows(FROM user TO user, since INT32) WITH (storage = ' Date: Thu, 28 May 2026 20:48:34 +0530 Subject: [PATCH 5/5] fix misc --- astro.config.mjs | 1 + src/content/docs/extensions/{attach => }/adbc.mdx | 0 src/content/docs/extensions/attach/rdbms.mdx | 2 +- src/content/docs/extensions/index.mdx | 2 +- src/content/docs/get-started/scan.mdx | 2 +- src/content/docs/import/icebug.md | 2 +- 6 files changed, 5 insertions(+), 4 deletions(-) rename src/content/docs/extensions/{attach => }/adbc.mdx (100%) diff --git a/astro.config.mjs b/astro.config.mjs index e6aa56e..41a5640 100644 --- a/astro.config.mjs +++ b/astro.config.mjs @@ -301,6 +301,7 @@ export default defineConfig({ }, { label: 'LLM', link: '/extensions/llm', badge: { text: 'New' }}, { label: 'Neo4j', link: '/extensions/neo4j'}, + { label: 'ADBC', link: '/extensions/adbc' }, { label: 'Relational databases', collapsed: true, diff --git a/src/content/docs/extensions/attach/adbc.mdx b/src/content/docs/extensions/adbc.mdx similarity index 100% rename from src/content/docs/extensions/attach/adbc.mdx rename to src/content/docs/extensions/adbc.mdx diff --git a/src/content/docs/extensions/attach/rdbms.mdx b/src/content/docs/extensions/attach/rdbms.mdx index 2a7323c..257c745 100644 --- a/src/content/docs/extensions/attach/rdbms.mdx +++ b/src/content/docs/extensions/attach/rdbms.mdx @@ -14,7 +14,7 @@ The currently available relational database extensions are shown below: Extension Name | Description | Minimum Version :---:|:---:|:---: -[`adbc`](/extensions/attach/adbc) | Scan from any ADBC-compatible database | – +[`adbc`](/extensions/adbc) | Scan from any ADBC-compatible database | 1.10.0 [`duckdb`](/extensions/attach/duckdb) | Scan from an attached DuckDB database | 0.10.0 [`postgres`](/extensions/attach/postgres) | Scan from an attached PostgreSQL database | 14.0 [`sqlite`](/extensions/attach/sqlite) | Scan from an attached SQLite database | 3.3.0 diff --git a/src/content/docs/extensions/index.mdx b/src/content/docs/extensions/index.mdx index e5b6ec9..e64ad2e 100644 --- a/src/content/docs/extensions/index.mdx +++ b/src/content/docs/extensions/index.mdx @@ -13,7 +13,7 @@ The following extensions are currently implemented: | Extension | Description | |----------|----------| -| [adbc](/extensions/attach/adbc) | Scan data from any ADBC-compatible database (DuckDB, PostgreSQL, SQLite, Snowflake, etc.) | +| [adbc](/extensions/adbc) | Scan data from any ADBC-compatible database (DuckDB, PostgreSQL, SQLite, Snowflake, etc.) | | [algo](/extensions/algo) | Graph algorithms | | [azure](/extensions/azure) | Scan from Azure Blob Storage and Azure Data Lake Storage (ADLS) | | [delta](/extensions/attach/delta) | Scan data from Delta Lake tables | diff --git a/src/content/docs/get-started/scan.mdx b/src/content/docs/get-started/scan.mdx index f256878..dd0e994 100644 --- a/src/content/docs/get-started/scan.mdx +++ b/src/content/docs/get-started/scan.mdx @@ -176,7 +176,7 @@ conn.create_arrow_rel_table( dst_table_name="company", # dst node table name from table creation earlier layout="CSR", dataframe=pa_company_indices, # rel table with 'source' and 'target' columns - dst_col_name="target", # dst col name in the indices table + dst_col_name="target", # dst col name in the indices table indptr=pa_company_indptr, # row pointers for indices table ) ``` diff --git a/src/content/docs/import/icebug.md b/src/content/docs/import/icebug.md index d0030c2..6a0ed99 100644 --- a/src/content/docs/import/icebug.md +++ b/src/content/docs/import/icebug.md @@ -59,7 +59,7 @@ If the ladybug instance is created backed by a file `graph.lbdb`, you can move i ATTACH 'graph.lbdb' AS mygraph (dbtype lbug); ``` -For more details about attaching databases, see the [attach documentation](/extensions/attach/lbug.md). +For more details about attaching databases, see the [attach documentation](/extensions/attach/lbug). ### Remote storage