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+)

• 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:

$ 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)

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

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.

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.

macOS

Using Conda (recommended):

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

Or with Homebrew + Conda:

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.

Linux (apt — amd64 only)

The Apache Arrow apt repository provides pre-built packages for amd64 (x86_64):

# 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

The libadbc-driver-manager apt package is only available for amd64. For arm64/aarch64, use conda-forge (see below).

Linux (conda — amd64 & arm64)

Conda-forge provides packages for both amd64 and arm64:

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/).

Windows

Using Conda:

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.

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:

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

Step 2: Install the Database Driver

Install the native ADBC driver for your target database using the dbc CLI tool:

# 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:

dbc install duckdb
dbc install postgresql
dbc install mysql
dbc install snowflake
dbc install trino
# ... 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:

# 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:

# 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:

macOS

# 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/

Linux

# 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

Windows

Download the appropriate .dll from the ADBC releases or install via Conda:

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

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

1. 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:

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

# 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 below.)

Variable	Purpose
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 above), or set the ADBC_DRIVER_MANAGER_LIB environment variable to the full path of the library.

# 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:

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:

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.

# 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:

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

Or specify the driver path directly in your connection:

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

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

MySQL with ADBC

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

ADBC URI format: user@tcp(host:port)/database

Official Documentation: Apache ADBC MySQL Driver

SQL Server with ADBC

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

Snowflake with ADBC

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

DuckDB with ADBC

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

SQLite with ADBC

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

BigQuery with ADBC

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

Trino with ADBC

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

Using sling conns

Here are examples of enabling ADBC on existing connections:

# 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

# 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"

Environment Variable

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 }'

Sling Env File YAML

See here to learn more about the sling env.yaml file.

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

  # 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"

Additional Resources

• Apache ADBC Project

• ADBC Driver Documentation

• dbc CLI Documentation

• Apache Arrow Documentation

If you are facing issues connecting, please reach out to us at [e-mail], on discord or open a Github Issue here.