Every data team has the same problem eventually: the data you need is in a database you'd rather not build a heavyweight client stack around. It's in Oracle behind the Instant Client. It's in an IBM Db2 or Db2 for i system behind the CLI and a JDBC/JCC jar. And you just want it in a fast, open, columnar engine — like GizmoSQL — without a day of native-driver plumbing.
So we built a suite of ADBC drivers that make that trivial. They're written in Go, they install with a single pip install, and because they all speak Apache Arrow natively, moving data between them is a few lines of code — in either direction.
First, what is ADBC?
ADBC — Arrow Database Connectivity — is a vendor-neutral API for moving data between databases and applications as Apache Arrow columnar batches. Like JDBC or ODBC, one API spans many databases. Unlike them, ADBC speaks Arrow natively, so bulk reads and writes stream columnar data with no row-by-row serialization or repeated type conversion.
The consequence is the important part: any ADBC driver's output is another ADBC driver's input. A reader from one database can be handed straight to another database's bulk-ingest call, and the rows stream from source to target as Arrow batches — never materialised into a dataframe or a file on the way. That's what makes "Oracle to GizmoSQL" a five-line program instead of an ETL project.
The suite
- GizmoSQL — our flagship driver for Apache Arrow Flight SQL. A Go-powered native core with OAuth/SSO, automatic DDL/DML detection, and connection profiles, reaching Python, Go, R, Rust, C#, C/C++, and JavaScript.
pip install adbc-driver-gizmosql - Oracle — speaks the native Oracle TNS/TTC wire protocol directly. No Oracle Instant Client, no environment variables, no native tarballs.
pip install adbc-driver-oracle - IBM Db2 — implements the DRDA wire protocol itself. No IBM CLI, no JCC.
pip install adbc-driver-db2 - DuckDB Quack — a pure-Go driver for DuckDB's native client-server protocol, bridging Quack data into the rest of the suite.
pip install adbc-driver-quack
The Oracle and Db2 drivers are the ones that turn heads: they are independent, from-scratch reimplementations of the database wire protocols in Go, so there is genuinely nothing to install but the Python wheel. (They contain no Oracle or IBM source code and are not affiliated with or endorsed by Oracle or IBM — DRDA is an open standard published by The Open Group, and the Oracle protocol was implemented from publicly available, openly-licensed references.)
Oracle → GizmoSQL, in Python
Here's the whole thing. Open an Oracle connection and a GizmoSQL connection, and hand the Oracle cursor's Arrow reader to GizmoSQL's adbc_ingest. The rows stream from Oracle into GizmoSQL without ever landing on the client — no pandas, no ODBC, no Oracle Client:
1import adbc_driver_oracle.dbapi as oracle
2import adbc_driver_gizmosql.dbapi as gizmosql
3
4with oracle.connect(uri=oracle_uri) as src, \
5 gizmosql.connect(gizmosql_uri, username="token", password=token) as dst:
6 with src.cursor() as s, dst.cursor() as d:
7 s.execute("SELECT * FROM sales.orders")
8 rows = d.adbc_ingest(table_name="orders",
9 data=s.fetch_record_batch(), # streamed, not buffered
10 mode="replace")
11 dst.commit()
12 print(f"Loaded {rows:,} rows")Swap adbc_driver_oracle for adbc_driver_db2 and it's the same five lines for Db2. Reverse the two connections and you're pushing GizmoSQL data back into Oracle or Db2. That's the whole point of Arrow-native drivers: the direction is just which connection you call adbc_ingest on.
And GizmoSQL is only the example here. Because the reader is standard Apache Arrow, the same code streams Oracle or Db2 into any ADBC-enabled target — another warehouse, DuckDB, Postgres, SQLite, or another database entirely. These drivers don't just connect your data to GizmoSQL; they connect it to the whole ADBC ecosystem.
...or entirely in SQL, from DuckDB and GizmoSQL
Because each driver is a standard ADBC c-shared library, DuckDB's adbc_scanner community extension can attach the source database and query it live — with projection and filter pushdown. And since GizmoSQL embeds DuckDB, the same works from a GizmoSQL server. Store the credentials in a secret once, then read and write in plain SQL:
INSTALL adbc_scanner FROM community;
LOAD adbc_scanner;
CREATE SECRET ora_secret (
TYPE adbc,
SCOPE 'oracle://db.example.com:1521/PROD',
driver 'oracle',
uri 'oracle://db.example.com:1521/PROD',
username 'app',
password 's3cret'
);
-- PULL: attach Oracle as a catalog and query it live
ATTACH 'oracle://db.example.com:1521/PROD' AS ora (TYPE adbc);
SELECT * FROM ora.SALES.ORDERS WHERE AMT > 100;
-- PUSH: write straight back with plain SQL — no special function needed
USE ora.SALES;
CREATE TABLE ORDERS_COPY AS SELECT * FROM local_orders;Read with a plain SELECT, write with a plain CREATE TABLE — both directions, one self-contained secret. That's Query.farm's adbc_scanner extension. Prefer credentials out of your SQL? adbc_scanner also resolves ADBC connection profiles (as does Columnar's adbc extension). Either way, every one of these paths is covered by an integration test in the driver's own repository, run in CI against a live database — so the promises here aren't aspirational, they're asserted on every commit.
Why pure Go, why Arrow
Writing the drivers in Go and exposing them through ADBC's c-shared library gets us two things at once. First, zero native client dependencies: the wire protocol lives in the driver, so a wheel is all you ship. Second, one core, every language: the same driver is callable from Python, Go, R, Rust, C#, C/C++, and JavaScript, and it plugs straight into DuckDB. And because the whole path is Arrow, types survive the trip — Oracle NUMBER stays exact, timestamps keep their zones, decimals don't round through a float.
Get started
Install GizmoSQL Core for free, then pip install whichever driver you need and stream your first table. Each driver has its own page with copy-paste snippets and the bidirectional recipes:
- Browse the full ADBC driver suite
- Oracle ADBC driver — pure Go, no Instant Client
- Db2 ADBC driver — pure Go, no CLI/JCC
- GizmoSQL ADBC driver — Arrow Flight SQL, OAuth/SSO
- DuckDB Quack ADBC driver
Your data doesn't have to stay locked behind a vendor's client stack. With ADBC, it's just Arrow — and Arrow moves anywhere.