ADBC Driver Manager for Python
raw JSON → 1.11.0 verified Sat Apr 25 auth: no python
The adbc-driver-manager package provides Python bindings for the Arrow Database Connectivity (ADBC) C API, serving as a generic entrypoint for ADBC drivers. It offers both low-level C API bindings and a higher-level, PEP 249 (DB-API 2.0) compatible interface. Currently at version 1.11.0, the library generally follows a monthly to bi-monthly release cadence, aligning with the broader Apache Arrow project.
pip install adbc-driver-manager Common errors
error ModuleNotFoundError: No module named 'adbc_driver_manager' ↓
cause The 'adbc_driver_manager' package is not installed in the Python environment.
fix
Install the package using pip: 'pip install adbc_driver_manager'.
error ImportError: cannot import name 'dbapi' from 'adbc_driver_manager' ↓
cause The 'dbapi' module is not available because the 'pyarrow' package is not installed.
fix
Install 'pyarrow' to enable the 'dbapi' module: 'pip install pyarrow'.
error adbc_driver_manager.DatabaseError: [Error message] ↓
cause An error occurred related to the database operation, possibly due to incorrect driver configuration or connection issues.
fix
Verify the driver path and connection parameters; ensure the driver shared library is correctly installed and accessible.
error AttributeError: module 'adbc_driver_manager' has no attribute 'AdbcDatabase' ↓
cause The 'AdbcDatabase' class is not found, possibly due to an outdated version of 'adbc_driver_manager'.
fix
Update the package to the latest version: 'pip install --upgrade adbc_driver_manager'.
error OSError: Could not load ADBC driver library at 'PATH/TO/libadbc_driver_sqlite.so' ↓
cause The specified driver library file does not exist or is not accessible at the given path.
fix
Ensure the driver library is correctly installed and the path is accurate; check file permissions.
Warnings
gotcha The `adbc-driver-manager` package itself is primarily a low-level interface to the ADBC C API. For most application development, it is strongly recommended to use the DB-API 2.0 interface provided by specific ADBC driver packages (e.g., `adbc_driver_sqlite.dbapi.connect()`) which abstract away the manual loading of driver shared libraries. ↓
fix Prefer `import adbc_driver_FOO.dbapi` and use `adbc_driver_FOO.dbapi.connect()` for convenience and correct driver loading.
breaking Connections (`adbc_driver_manager.AdbcConnection` or `dbapi.Connection`) and Cursors (`dbapi.Cursor`) *must* be explicitly closed to avoid resource leaks in the underlying C library. Python's garbage collection is not guaranteed to call `__del__` in a timely manner. ↓
fix Always use `with ... as` context managers for `Connection` and `Cursor` objects, or explicitly call `.close()` on them.
gotcha The `adbc-driver-manager` package requires a separately installed ADBC driver shared library (e.g., `libadbc_driver_sqlite.so`) to function. Unlike driver-specific packages (e.g., `adbc-driver-sqlite`) which bundle and load the driver transparently, when using `adbc-driver-manager` directly, you must manage the driver's availability (e.g., via `PATH` or `LD_LIBRARY_PATH`). ↓
fix Ensure the necessary ADBC driver shared library is installed and discoverable by the driver manager, or use a driver-specific Python package.
gotcha The DB-API 2.0 interface and functionality for working with Arrow data (e.g., `fetch_arrow_table`, `adbc_ingest`) requires the `pyarrow` library to be installed. Without `pyarrow`, such features will be unavailable or raise errors. ↓
fix Install `pyarrow` alongside `adbc-driver-manager` using `pip install adbc-driver-manager pyarrow`.
breaking Recent Python wheels for `adbc-driver-manager` (and other Apache Arrow libraries) have increased their minimum system requirements. Specifically, `manylinux_2_28` is now required for Linux wheels (up from `manylinux2010`), and macOS 12 is the minimum supported version for macOS wheels. ↓
fix Ensure your environment meets the updated `manylinux_2_28` or macOS 12+ requirements, or pin to an older `adbc-driver-manager` version if compatibility is needed.
Install
pip install adbc-driver-manager pyarrow Install compatibility last tested: 2026-04-25
runtime status import time mem disk
3.10-alpine — — —
3.10-alpine — — —
3.10-slim 0.02s 1.6MB 35M
3.10-slim 0.02s 1.6MB 186M
3.11-alpine — — —
3.11-alpine — — —
3.11-slim 0.04s 1.8MB 38M
3.11-slim 0.04s 1.8MB 191M
3.12-alpine — — —
3.12-alpine — — —
3.12-slim 0.04s 1.5MB 30M
3.12-slim 0.04s 1.5MB 182M
3.13-alpine — — —
3.13-alpine — — —
3.13-slim 0.04s 1.3MB 29M
3.13-slim 0.04s 1.3MB 182M
3.9-alpine — — —
3.9-alpine — — —
3.9-slim 0.02s 1.5MB 29M
3.9-slim 0.02s 1.5MB 168M
Imports
- adbc_driver_manager
import adbc_driver_manager - dbapi wrong
import adbc_driver_manager.dbapicorrectimport adbc_driver_sqlite.dbapi
Quickstart last tested: 2026-04-25
import adbc_driver_sqlite.dbapi
import pyarrow
# Ensure the SQLite ADBC driver is installed for this example.
# pip install adbc-driver-sqlite pyarrow
try:
# Connect to a SQLite database using the DB-API 2.0 interface
# Use a context manager to ensure proper resource cleanup
with adbc_driver_sqlite.dbapi.connect() as conn:
with conn.cursor() as cur:
# Execute a query
cur.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER, name TEXT)")
cur.execute("INSERT INTO test (id, name) VALUES (?, ?)", (1, 'Alice'))
cur.execute("INSERT INTO test (id, name) VALUES (?, ?)", (2, 'Bob'))
# Fetch results as an Arrow Table (an ADBC-specific extension)
cur.execute("SELECT id, name FROM test ORDER BY id")
table = cur.fetch_arrow_table()
print("Fetched Arrow Table:\n", table)
# Fetch results via standard DB-API row-oriented interface
cur.execute("SELECT id, name FROM test ORDER BY id")
row = cur.fetchone()
print(f"\nFetched one row: {row}")
rows = cur.fetchall()
print(f"Fetched remaining rows: {rows}")
# Bulk ingest data
new_data = pyarrow.table([[3, 4], ['Charlie', 'David']], names=['id', 'name'])
cur.adbc_ingest("test", new_data)
print(f"\nIngested {new_data.num_rows} rows.")
cur.execute("SELECT COUNT(*) FROM test")
count = cur.fetchone()[0]
print(f"Total rows after ingest: {count}")
except Exception as e:
print(f"An error occurred: {e}")