> For the complete documentation index, see [llms.txt](https://docs.slingdata.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.slingdata.io/connections/database-connections/adbc.md).

# ADBC (Arrow)

Connect & Ingest data from / to multiple databases via Arrow Database Connectivity (ADBC)

Arrow Database Connectivity (ADBC) provides a standardized interface for accessing various databases using the Apache Arrow columnar format. ADBC enables efficient, high-performance data movement with zero-copy semantics and native Arrow support (*v1.5.2+*)

## Supported Database Types

Sling supports the following databases via ADBC drivers:

* **PostgreSQL** - Full support via ADBC PostgreSQL driver
* **MySQL** - Support via ADBC MySQL driver (v9.4+)
* **ClickHouse** - Support via ADBC ClickHouse driver (*v1.6.4+*)
* **SQL Server** - Full support via ADBC SQL Server driver
* **Snowflake** - Full support via ADBC Snowflake driver
* **SQLite** - Support via ADBC SQLite driver
* **DuckDB** - Full support via ADBC DuckDB driver
* **BigQuery** - Full support via ADBC BigQuery driver
* **Trino** - Support via ADBC Trino driver (v4.0+)

## Setup

Using ADBC requires two components:

1. **ADBC Driver Manager** — a shared library (`libadbc_driver_manager.so` / `.dylib` / `.dll`) that loads and manages drivers
2. **Database Driver** — the native ADBC driver for your specific database (e.g., DuckDB, PostgreSQL)

**Sling downloads both automatically the first time you use an ADBC connection** (*v1.5.24+*), so in most cases no setup is needed — just add `use_adbc: true` to your connection and run it:

```bash
$ sling conns test POSTGRES
INF downloading dbc 0.3.0 for linux/amd64
INF installing ADBC driver postgresql via dbc
INF downloading ADBC driver manager 1.12.0 for linux/amd64
INF success!
```

Downloads happen once and are cached under `~/.sling/bin/`:

| Component        | Location                                                                     |
| ---------------- | ---------------------------------------------------------------------------- |
| `dbc` CLI        | `~/.sling/bin/dbc/<version>/`                                                |
| Driver manager   | `~/.sling/bin/adbc/<version>/`                                               |
| Database drivers | standard `dbc` locations (see [Step 2](#step-2-install-the-database-driver)) |

Anything already installed on the system is preferred over downloading. Sling only fetches what is missing.

{% hint style="info" %}
To disable automatic downloads (e.g. in an air-gapped environment), set `SLING_DISABLE_DBC_AUTO_INSTALL=true` and install the components manually using the instructions below.
{% endhint %}

The rest of this section covers **manual installation**, which you need only if you have disabled auto-install, are offline, or want to pin a specific build.

### Step 1: Install the ADBC Driver Manager

The driver manager is a shared library that Sling loads at runtime.

{% tabs %}
{% tab title="macOS" %}
Using Conda (recommended):

```bash
conda install -c conda-forge libadbc-driver-manager
```

Or with Homebrew + Conda:

```bash
brew install --cask mambaforge
mamba install -c conda-forge libadbc-driver-manager
```

The library is installed to your conda environment's `lib/` directory (e.g., `~/mambaforge/lib/libadbc_driver_manager.dylib`). Sling auto-detects common conda paths.
{% endtab %}

{% tab title="Linux (apt — amd64 only)" %}
The Apache Arrow apt repository provides pre-built packages for **amd64** (x86\_64):

```bash
# Add Apache Arrow apt repository
sudo apt update
sudo apt install -y ca-certificates lsb-release wget
wget -q https://apache.jfrog.io/artifactory/arrow/$(lsb_release --id --short | tr 'A-Z' 'a-z')/apache-arrow-apt-source-latest-$(lsb_release --codename --short).deb -O /tmp/arrow.deb
sudo apt install -y /tmp/arrow.deb && rm /tmp/arrow.deb
sudo apt update

# Install the driver manager
sudo apt install -y libadbc-driver-manager110
```

{% hint style="warning" %}
The `libadbc-driver-manager` apt package is only available for **amd64**. For arm64/aarch64, use conda-forge (see below).
{% endhint %}
{% endtab %}

{% tab title="Linux (conda — amd64 & arm64)" %}
Conda-forge provides packages for both amd64 and arm64:

```bash
conda install -c conda-forge libadbc-driver-manager
```

The library is installed to your conda environment's `lib/` directory. Sling auto-detects common conda paths (`~/mambaforge/lib/`, `~/miniforge3/lib/`, `~/miniconda3/lib/`).
{% endtab %}

{% tab title="Windows" %}
Using Conda:

```powershell
conda install -c conda-forge libadbc-driver-manager
```

If Sling cannot find the library, set the `ADBC_DRIVER_MANAGER_LIB` environment variable to the full path of `adbc_driver_manager.dll`.
{% endtab %}
{% endtabs %}

{% hint style="info" %}
Sling auto-detects the driver manager from common installation paths. If it cannot find the library, you can set the `ADBC_DRIVER_MANAGER_LIB` environment variable to the full path:

```bash
export ADBC_DRIVER_MANAGER_LIB=/path/to/libadbc_driver_manager.so    # Linux
export ADBC_DRIVER_MANAGER_LIB=/path/to/libadbc_driver_manager.dylib  # macOS
```

{% endhint %}

### Step 2: Install the Database Driver

Install the native ADBC driver for your target database using the [`dbc` CLI tool](https://docs.columnar.tech/dbc/):

```bash
# Install dbc
# macOS (Homebrew)
brew install columnar-tech/tap/dbc

# Linux/macOS (shell script)
curl -LsSf https://dbc.columnar.tech/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://dbc.columnar.tech/install.ps1 | iex"
```

Then install drivers for your target databases:

```bash
dbc install duckdb
dbc install postgresql
dbc install mysql
dbc install snowflake
dbc install trino
dbc install clickhouse
# ... etc
```

Drivers are installed to:

* **macOS**: `~/Library/Application Support/ADBC/Drivers/`
* **Linux**: `~/.config/adbc/drivers/`
* **Windows**: `%APPDATA%\adbc\drivers\`

Sling auto-discovers installed drivers from these locations.

### Quick Start Example (DuckDB)

With auto-install, the complete setup on any platform is:

```bash
# 1. Set up connection
sling conns set DUCKDB type=duckdb instance=/tmp/test.db use_adbc=true

# 2. Test it — the driver manager and DuckDB driver download on first use
sling conns test DUCKDB
```

If you have disabled auto-install, install the components first:

```bash
# 1. Install driver manager
conda install -c conda-forge libadbc-driver-manager

# 2. Install DuckDB driver
curl -LsSf https://dbc.columnar.tech/install.sh | sh   # macOS/Linux
dbc install duckdb

# 3. Set up connection and test
sling conns set DUCKDB type=duckdb instance=/tmp/test.db use_adbc=true
sling conns test DUCKDB
```

### Manual Driver Installation

If you prefer not to use `dbc`, you can install ADBC driver libraries manually:

{% tabs %}
{% tab title="macOS" %}

```bash
# Install via Conda
conda install conda-forge::libadbc-driver-postgresql

# Or download .dylib from ADBC releases and place in a known location
cp libadbc_driver_postgresql.dylib ~/Library/Application\ Support/ADBC/Drivers/
```

{% endtab %}

{% tab title="Linux" %}

```bash
# Ubuntu/Debian amd64 (after adding Apache Arrow APT repository)
sudo apt install libadbc-driver-postgresql-dev

# Or via Conda (amd64 and arm64)
conda install conda-forge::libadbc-driver-postgresql
```

{% endtab %}

{% tab title="Windows" %}
Download the appropriate `.dll` from the [ADBC releases](https://github.com/apache/arrow-adbc/releases) or install via Conda:

```powershell
conda install conda-forge::libadbc-driver-postgresql
```

{% endtab %}
{% endtabs %}

### Driver Discovery

Sling searches for ADBC driver libraries automatically in the following order:

1. **Explicit `driver` property** in the connection configuration
2. **`ADBC_DRIVER_PATH` environment variable** — additional directories to search (colon-separated on Unix, semicolon-separated on Windows)
3. **Standard installation paths:**

| Platform | Paths                                                                                                                          |
| -------- | ------------------------------------------------------------------------------------------------------------------------------ |
| macOS    | `~/Library/Application Support/ADBC/Drivers`, `~/.dbc/drivers`, `/usr/local/lib`, `/opt/homebrew/lib`                          |
| Linux    | `~/.local/share/ADBC/Drivers`, `~/.config/adbc/drivers`, `~/.dbc/drivers`, `/usr/lib`, `/usr/local/lib`                        |
| Windows  | `%APPDATA%\adbc\drivers`, `%LOCALAPPDATA%\ADBC\Drivers`, `~/.config/adbc/drivers`, `~/.dbc/drivers`, `%ProgramFiles%\ADBC\lib` |

4. **Automatic install** — if the driver is still not found, Sling installs it with `dbc` (downloading `dbc` itself if needed)

Sling looks for driver files matching `*{driver_name}*` (e.g., `libduckdb.so`, `libadbc_driver_postgresql.dylib`).

If the driver is in a non-standard location, you can either set `ADBC_DRIVER_PATH` or specify the full path directly in your connection:

```bash
# Add custom search paths
export ADBC_DRIVER_PATH="/opt/custom/lib:/another/path"
```

```yaml
# Or specify the driver path directly in the connection
connections:
  POSTGRES:
    type: postgres
    host: localhost
    use_adbc: true
    driver: /opt/custom/lib/libadbc_driver_postgresql.dylib
```

## Enabling ADBC on Connections

To use ADBC with your existing database connections, simply add `use_adbc: true` to your connection configuration. This allows you to keep your original connection properties and format while enabling ADBC's high-performance data transfer.

### Connection Properties

The following ADBC-specific properties can be added to any supported database connection:

* `use_adbc` (optional) -> Enable ADBC driver for this connection (`true` or `false`). Default is `false`.
* `adbc_uri` (optional) -> Override the automatically constructed ADBC URI. Sling automatically builds the ADBC URI from your connection properties, but you can specify a custom URI if needed.
* `driver` (optional) -> Explicit path to the ADBC driver library file (e.g., `/usr/local/lib/libadbc_driver_postgresql.dylib`). If not set, Sling auto-discovers the driver.

## ADBC Environment Variables

These control how Sling locates and downloads the ADBC components. (To define a *connection* with an environment variable, see [Environment Variable](#environment-variable) below.)

| Variable                         | Purpose                                                                                                                                              |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| `SLING_USE_ADBC`                 | Set to `true` to route every supported connection through ADBC, without adding `use_adbc` to each one. A `use_adbc` set on a connection always wins. |
| `ADBC_DRIVER_MANAGER_LIB`        | Full path to the driver manager library. Overrides auto-detection and auto-download.                                                                 |
| `ADBC_DRIVER_PATH`               | Extra directories to search for database drivers (`:`-separated on Unix, `;` on Windows).                                                            |
| `ADBC_DRIVER_MANAGER_VERSION`    | Driver manager version to download. Defaults to `1.12.0`.                                                                                            |
| `DBC_PATH`                       | Full path to an existing `dbc` binary, instead of downloading one.                                                                                   |
| `DBC_VERSION`                    | `dbc` version to download. Defaults to `0.3.0`.                                                                                                      |
| `SLING_DISABLE_DBC_AUTO_INSTALL` | Set to `true` to disable all automatic downloads.                                                                                                    |

## Troubleshooting

### "failed to load ADBC driver manager library"

This means the driver manager shared library could not be loaded. Sling normally downloads it automatically, so this usually indicates auto-install is disabled, the machine is offline, or the library is present but incompatible with the system (see the next two sections).

**Fix:** Install the driver manager (see [Step 1](#step-1-install-the-adbc-driver-manager) above), or set the `ADBC_DRIVER_MANAGER_LIB` environment variable to the full path of the library.

```bash
# Find the library
find / -name "libadbc_driver_manager*" 2>/dev/null

# Set the path
export ADBC_DRIVER_MANAGER_LIB=/path/to/libadbc_driver_manager.so
```

### Linux: "version \`GLIBCXX\_3.4.29' not found"

The prebuilt driver manager is built with GCC 11 and needs `GLIBCXX_3.4.29`. Older distributions ship an older C++ runtime — Ubuntu 20.04 and Debian 11 provide `GLIBCXX_3.4.28`, one version short.

Distributions from 2021 onward (Ubuntu 22.04+, Debian 12+, RHEL/Rocky 9+, Amazon Linux 2023) are unaffected and need nothing here.

Sling cannot fix this from inside a running process: the dynamic loader binds the driver manager's dependency to whichever `libstdc++.so.6` is already loaded, and by then the system copy is in place. So Sling downloads a compatible library and prints the command to use it:

```
The ADBC driver manager needs a newer C++ runtime (libstdc++) than this system
provides (requires GLIBCXX_3.4.29). A compatible libstdc++ has been downloaded
to ~/.sling/bin/adbc/1.12.0/libstdc++.so.6 — re-run with it preloaded:

    LD_PRELOAD=~/.sling/bin/adbc/1.12.0/libstdc++.so.6 sling conns test POSTGRES
```

**Fix:** re-run with `LD_PRELOAD` as shown. To make it permanent, export it in your shell profile:

```bash
export LD_PRELOAD="$HOME/.sling/bin/adbc/1.12.0/libstdc++.so.6"
```

Alternatively, install a newer system `libstdc++` (`conda install -c conda-forge libstdcxx`), or point `ADBC_DRIVER_MANAGER_LIB` at a build compatible with your system.

You can check what your system provides with:

```bash
strings /usr/lib/x86_64-linux-gnu/libstdc++.so.6 | grep -o 'GLIBCXX_3\.4\.[0-9]*' | sort -V | tail -1
```

### Linux: "version \`GLIBC\_2.xx' not found"

The C runtime (glibc) itself is older than the driver manager requires. Unlike the `libstdc++` case above, this cannot be worked around with a downloaded library — glibc cannot be preloaded safely.

**Fix:** run Sling on a newer distribution, or set `ADBC_DRIVER_MANAGER_LIB` to a driver manager built for your system.

### "Must provide 'driver' parameter"

This means Sling could not find or install the database-specific ADBC driver (e.g., the DuckDB or PostgreSQL driver). Sling normally installs it automatically with `dbc`, so this usually means auto-install is disabled or the machine is offline.

**Fix:** Install the driver with `dbc install <driver_name>`, or set `ADBC_DRIVER_PATH` to the directory containing the driver, or set the `driver` property in your connection config.

```bash
# Install the driver
dbc install duckdb

# Or point Sling to the driver location
export ADBC_DRIVER_PATH=/path/to/drivers
```

### Windows: driver not found after dbc install

Sling searches both `%APPDATA%\adbc\drivers` (Roaming, where `dbc` installs) and `%LOCALAPPDATA%\ADBC\Drivers` (Local). If your driver is somewhere else, set `ADBC_DRIVER_PATH`:

```powershell
$env:ADBC_DRIVER_PATH = "C:\path\to\drivers"
```

Or specify the driver path directly in your connection:

```yaml
connections:
  DUCKDB:
    type: duckdb
    instance: C:/path/to/file.db
    use_adbc: true
    driver: C:/Users/me/AppData/Roaming/adbc/drivers/duckdb_windows_amd64_v1.4.4/duckdb.dll
```

## Database-Specific Examples

### PostgreSQL with ADBC

```yaml
connections:
  POSTGRES:
    type: postgres
    host: localhost
    user: myuser
    password: mypass
    database: mydatabase
    port: 5432
    use_adbc: true
    # adbc_uri: "postgresql://myuser:mypass@localhost:5432/mydatabase"  # optional override
```

ADBC URI format: `postgresql://user:password@host:port/database`

**Official Documentation:** [Apache ADBC PostgreSQL Driver](https://arrow.apache.org/adbc/current/driver/postgresql.html)

### MySQL with ADBC

```yaml
connections:
  MYSQL:
    type: mysql
    host: localhost
    user: root
    password: mypass
    database: mydb
    port: 3306
    use_adbc: true
    # adbc_uri: "mysql://root:mypass@localhost:3306/mydb"  # optional override
```

ADBC URI format: `mysql://user:password@host:port/database` (*v1.6.4+*). The Go DSN format (`user:password@tcp(host:port)/database`) also works with `adbc_uri`.

{% hint style="info" %}
The MySQL ADBC driver loads data with batched `INSERT` statements. For large loads, the native MySQL connection (without `use_adbc`) is often faster, because it uses `LOAD DATA LOCAL INFILE`. Use version 0.6.1 or later of the driver (`dbc install mysql`).
{% endhint %}

**Official Documentation:** [Apache ADBC MySQL Driver](https://docs.adbc-drivers.org/drivers/mysql/index.html)

### ClickHouse with ADBC

The ClickHouse ADBC driver connects through the ClickHouse HTTP interface, not the native protocol. Sling builds the HTTP URL from `http_url`, or from `host`, `http_port` and `database`. The user and password go to the driver as separate options.

```yaml
connections:
  CLICKHOUSE:
    type: clickhouse
    http_url: http://myuser:mypass@localhost:8123/mydb
    use_adbc: true

  # or with the native properties (the HTTP port defaults to 8123, or 8443 with secure=true)
  CLICKHOUSE_2:
    type: clickhouse
    host: localhost
    user: myuser
    password: mypass
    database: mydb
    http_port: 8123
    use_adbc: true
    # adbc_uri: "http://localhost:8123?database=mydb"  # optional override
```

ADBC URI format: `http://host:port?database=database` (or `https://`)

Notes:

* Sling uses the ADBC driver to load data into ClickHouse. Sling creates the target table, and the driver appends the rows to it. Queries use the native driver.
* The driver requires a recent ClickHouse server (it is tested with ClickHouse 25.x and later). Older servers can fail with `Unknown setting` errors.
* The driver does not support JSON columns, nor the ClickHouse `Time` type.
* To read with the driver, define a connection with `type: adbc` and `driver_name: clickhouse`:

```yaml
connections:
  CLICKHOUSE_ADBC:
    type: adbc
    driver_name: clickhouse
    uri: http://localhost:8123?database=mydb
    username: myuser
    password: mypass
```

**Official Documentation:** [ClickHouse ADBC Driver](https://adbc-drivers.org/drivers/clickhouse/)

### SQL Server with ADBC

```yaml
connections:
  MSSQL:
    type: sqlserver
    host: localhost
    user: sa
    password: mypass
    database: master
    port: 1433
    use_adbc: true
    # adbc_uri: "mssql://sa:mypass@localhost:1433/master"  # optional override
```

ADBC URI format: `mssql://user:password@host:port/database`

**Official Documentation:** [Apache ADBC SQL Server Driver](https://docs.adbc-drivers.org/drivers/mssql/index.html)

### Snowflake with ADBC

```yaml
connections:
  SNOWFLAKE:
    type: snowflake
    account: myaccount.us-east-1
    user: myuser
    password: mypass
    database: mydb
    schema: myschema
    use_adbc: true
    # adbc_uri: "snowflake://myuser:mypass@myaccount/mydb/myschema"  # optional override
```

ADBC URI format: `snowflake://user:password@account/database/schema`

**Official Documentation:** [Apache ADBC Snowflake Driver](https://arrow.apache.org/adbc/current/driver/snowflake.html)

### DuckDB with ADBC

```yaml
connections:
  DUCKDB:
    type: duckdb
    instance: /path/to/file.db
    use_adbc: true
    # adbc_uri: "duckdb:///path/to/file.db"  # optional override
```

ADBC URI format: `duckdb:///path/to/file.db` or `duckdb://:memory:`

**Official Documentation:** [Apache ADBC DuckDB Driver](https://arrow.apache.org/adbc/current/driver/duckdb.html)

### SQLite with ADBC

```yaml
connections:
  SQLITE:
    type: sqlite
    instance: /path/to/file.db
    use_adbc: true
    # adbc_uri: "sqlite:///path/to/file.db"  # optional override
```

ADBC URI format: `sqlite:///path/to/file.db`

**Official Documentation:** [Apache ADBC SQLite Driver](https://arrow.apache.org/adbc/current/driver/sqlite.html)

### BigQuery with ADBC

```yaml
connections:
  BIGQUERY:
    type: bigquery
    project: myproject
    dataset: mydataset
    key_file: /path/to/service.account.json
    use_adbc: true
    # adbc_uri: "bigquery://myproject"  # optional override
```

ADBC URI format: `bigquery://project`

**Official Documentation:** [Apache ADBC BigQuery Driver](https://docs.adbc-drivers.org/drivers/bigquery/index.html)

### Trino with ADBC

```yaml
connections:
  TRINO:
    type: trino
    http_url: "http://myuser@localhost:8080?catalog=hive&schema=default"
    use_adbc: true
    # adbc_uri: "http://myuser@localhost:8080?catalog=hive&schema=default"  # optional override
```

ADBC URI format: `http://user@host:port?catalog=catalog&schema=schema`

**Official Documentation:** [Apache ADBC Trino Driver](https://docs.adbc-drivers.org/drivers/trino/index.html)

## Using `sling conns`

Here are examples of enabling ADBC on existing connections:

{% code overflow="wrap" %}

```bash
# PostgreSQL with ADBC
$ sling conns set POSTGRES type=postgres host=localhost user=myuser password=mypass database=mydb use_adbc=true

# MySQL with ADBC
$ sling conns set MYSQL type=mysql host=localhost user=root password=mypass database=mydb use_adbc=true

# ClickHouse with ADBC
$ sling conns set CLICKHOUSE type=clickhouse http_url="http://myuser:mypass@localhost:8123/mydb" use_adbc=true

# SQL Server with ADBC
$ sling conns set MSSQL type=sqlserver host=localhost user=sa password=mypass database=master use_adbc=true

# Snowflake with ADBC
$ sling conns set SNOWFLAKE type=snowflake account=myaccount user=myuser password=mypass database=mydb use_adbc=true

# With custom ADBC URI override
$ sling conns set POSTGRES type=postgres host=localhost user=myuser password=mypass database=mydb use_adbc=true adbc_uri="postgresql://myuser:mypass@localhost:5432/mydb"
```

{% endcode %}

## Environment Variable

{% code overflow="wrap" %}

```bash
export POSTGRES='{ type: postgres, host: localhost, user: myuser, password: mypass, database: mydb, use_adbc: true }'

export MYSQL='{ type: mysql, host: localhost, user: root, password: mypass, database: mydb, use_adbc: true }'

export SNOWFLAKE='{ type: snowflake, account: myaccount, user: myuser, password: mypass, database: mydb, use_adbc: true }'
```

{% endcode %}

## Sling Env File YAML

See [here](https://docs.slingdata.io/connections/database-connections/pages/eAdVs2BHCgdr6RS8GoJC#sling-env-file-env.yaml) to learn more about the sling `env.yaml` file.

```yaml
connections:
  # PostgreSQL with ADBC
  POSTGRES:
    type: postgres
    host: localhost
    user: myuser
    password: mypass
    database: mydatabase
    use_adbc: true

  # MySQL with ADBC
  MYSQL:
    type: mysql
    host: localhost
    user: root
    password: mypass
    database: mydb
    use_adbc: true

  # ClickHouse with ADBC
  CLICKHOUSE:
    type: clickhouse
    http_url: http://myuser:mypass@localhost:8123/mydb
    use_adbc: true

  # SQL Server with ADBC
  MSSQL:
    type: sqlserver
    host: localhost
    user: sa
    password: mypass
    database: master
    use_adbc: true

  # Snowflake with ADBC
  SNOWFLAKE:
    type: snowflake
    account: myaccount
    user: myuser
    password: mypass
    database: mydb
    schema: myschema
    use_adbc: true

  # DuckDB with ADBC
  DUCKDB:
    type: duckdb
    instance: /path/to/file.db
    use_adbc: true

  # With custom ADBC URI override
  POSTGRES_CUSTOM:
    type: postgres
    host: localhost
    user: myuser
    password: mypass
    database: mydatabase
    use_adbc: true
    adbc_uri: "postgresql://myuser:mypass@localhost:5432/mydatabase?sslmode=require"
```

## Arrow Lane

The Arrow Lane moves a stream end to end as Apache Arrow record batches: the source reader hands records to the writer, and no row is ever built, cast or re-serialized on the way. It needs a **CLI Pro** or **Platform** plan (the engine is part of the official release), and it is on by default when the conditions below hold.

```yaml
source: MY_POSTGRES_ADBC
target: MY_SNOWFLAKE

defaults:
  mode: full-refresh
  object: public.{stream_table}

env:
  SLING_ARROW_LANE: auto   # auto (default) | false | force
```

### When it engages

Sling picks the lane per stream, before the first record is read, and only when every condition holds:

* **Source**: an ADBC connection (Postgres, DuckDB, SQLite, Snowflake, BigQuery), a Parquet or Arrow file, or the change-cache file of a CDC stream.
* **Target**: an ADBC connection (Postgres, DuckDB, SQLite, Snowflake), a staged load (Snowflake internal stage, Databricks volume, Redshift S3), or a Parquet / Arrow file.
* **Options**: no `columns`, `transforms` or `constraint`; no `direct_insert`, `column_typing`, row checksum or schema migration; `use_bulk` is not disabled. A chunked read (`chunk_size`, `chunk_count`, `chunk_expr`) runs each chunk as its own stream on the lane, since the chunk range is part of the source SQL.
* **Shape**: an `update_key` of a numeric, date, timestamp or string type when incremental state is tracked; the watermark is taken from the records, so no extra query runs.
* **Types**: every column of the reader's Arrow schema must reach the type Sling derives for it without loss (the cast allow-list). A single column that cannot declines the whole stream.

### What disables it

`SLING_ARROW_LANE=false` turns it off for the whole run. Any condition above falls back to the row path, which is the default behavior and not an error: run Sling with `-d` (debug) to see the reason line, for example `arrow lane: not used for stream "public.t1". Reason: transforms are set`.

Set `SLING_ARROW_LANE=force` to make a fallback an error instead. This is what Sling's own test suite uses, so a decline cannot hide a regression.

### Notes

* The target table is created from the same columns the records carry, so the DDL and the data cannot drift apart.
* On the lane, Snowflake, Databricks and Redshift staged loads upload Parquet (see [Redshift](/connections/database-connections/redshift.md#parquet-copy-on-the-arrow-lane)).
* Transforms run on the lane when every stage names an existing column and does not read `record.`. A stage that creates a column, or reads another column, falls back to the row path.
* The audit columns (`_sling_loaded_at`, `_sling_synced_at`, `_sling_synced_op`, `_sling_synced_seq`, `_sling_stream_url`, `_sling_row_id`, `_sling_exec_id`, `_sling_row_num`) are appended by the lane as record arrays, one value per row, before the transforms run. They carry the same names, order, types and values as on the row path, so a query cannot tell which path wrote the rows.
* `SLING_ARROW_LANE_BUFFER` (default `8`) sets how many record batches stay in flight between the reader and the writer. See [Global Variables](/sling-cli/variables.md).

## Additional Resources

* [Apache ADBC Project](https://arrow.apache.org/adbc/)
* [ADBC Driver Documentation](https://docs.adbc-drivers.org/)
* [dbc CLI Documentation](https://docs.columnar.tech/dbc/)
* [Apache Arrow Documentation](https://arrow.apache.org/)

If you are facing issues connecting, give [`sling assist`](/sling-cli/ai/assist.md) a try, or reach out to us at <support@slingdata.io>, on [discord](https://discord.gg/q5xtaSNDvp) or open a Github Issue [here](https://github.com/slingdata-io/sling-cli/issues).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.slingdata.io/connections/database-connections/adbc.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.