23 open-source integrations

    GizmoSQL Integrations & Adapters

    GizmoSQL speaks Apache Arrow Flight SQL, so the tools you already use connect to it natively: drivers for every language, AI agents over MCP, dbt and SQLMesh transformations, Python dataframe APIs, BI dashboards, desktop SQL clients, and Kubernetes operations. Ordered by how most teams adopt them, most important first.

    01Drivers🚀 New

    ADBC Driver 2.0

    The native driver every other integration runs on — Python, Go, R, Rust, C#, C/C++, and JavaScript.

    The GizmoSQL ADBC driver is a Go-native Arrow Database Connectivity driver compiled to a C shared library, so one codebase serves every ADBC language. Results stream from the server as Arrow record batches over gRPC with no row-by-row conversion, which is why the same driver sits underneath the dbt, SQLMesh, Ibis, SQLFrame, QGIS, Node.js, and MCP integrations on this page.

    Version 2.0 adds what a plain Flight SQL driver lacks: automatic DDL/DML detection so statements execute immediately on the server, RETURNING support, gizmosql:// connection URIs with TLS on by default, server-side query cancellation, and a browser-based OAuth/SSO sign-in flow for GizmoSQL Enterprise. The Python package keeps the 1.x API, so upgrading is a one-line pip command.

    What it provides

    • pip install adbc-driver-gizmosql, plus Go, R, and C/C++ bindings
    • OAuth/SSO via auth_type="external" against Enterprise servers
    • DDL/DML auto-detection and RETURNING support
    • Server-side cancellation on Ctrl+C or cursor.close()
    • TOML connection profiles with environment-variable substitution
    • OpenTelemetry tracing and logging
    Python
    1pip install adbc-driver-gizmosql
    2
    3from adbc_driver_gizmosql import dbapi as gizmosql
    4
    5with gizmosql.connect("gizmosql://localhost:31337",  # TLS by default
    6                      username="gizmosql_user",
    7                      password="gizmosql_password",
    8                      tls_skip_verify=True,
    9                      ) as conn:
    10    with conn.cursor() as cur:
    11        cur.execute("SELECT n_nationkey, n_name FROM nation LIMIT 5")
    12        print(cur.fetch_arrow_table())

    Go: go get github.com/gizmodata/gizmosql-adbc/go@latest. Apache-2.0.

    02Drivers🚀 New

    JDBC Driver

    Connect DataGrip, Tableau, and any Java application with a standard JDBC URL (DBeaver has it built in).

    The GizmoSQL JDBC driver is a fork of the Apache Arrow Flight SQL JDBC driver, packaged as a single JAR and published to Maven Central as com.gizmodata:gizmosql-jdbc-driver. Anything that speaks java.sql works: desktop SQL clients, BI servers, Spring and JPA applications, and JVM data tools. It is also the driver underneath the Metabase driver and the SQLLine command-line client.

    Connections use jdbc:gizmosql://host:port URLs (the older jdbc:arrow-flight-sql:// form still works) with username/password, bearer-token, or browser-based OAuth/SSO authentication. TLS and mutual TLS are configurable per connection, including custom trust stores and client certificates.

    What it provides

    • Single-JAR download or Maven Central dependency
    • Username/password, bearer token, and OAuth/SSO (authType=external)
    • TLS and mTLS with custom trust stores and client certificates
    • Works with DataGrip, Tableau, and any JDBC tool; built into DBeaver 26.1+
    Java
    // Maven: com.gizmodata:gizmosql-jdbc-driver:1.7.0
    String url = "jdbc:gizmosql://your-server.example.com:31337?useEncryption=true";
    
    try (Connection conn = DriverManager.getConnection(url, "user", "password");
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery("SELECT * FROM my_table")) {
        while (rs.next()) {
            System.out.println(rs.getString(1));
        }
    }

    Requires JDK 17 or newer as of v1.7.0 (the 1.6.x line supports JDK 11). Apache-2.0.

    03Tools🚀 New

    DBeaver (built-in driver)

    GizmoSQL ships inside DBeaver 26.1+. Pick it from the connection list; no manual JDBC setup.

    Since DBeaver 26.1.0, GizmoSQL is a native, built-in driver in DBeaver, contributed by GizmoData and merged upstream. Open New Database Connection, search for GizmoSQL, and DBeaver downloads the latest GizmoSQL JDBC driver from Maven Central on first use. There is no JAR to find, no driver class to type, and no URL template to remember.

    The built-in definition defaults to port 31337 with encryption on, lets you pick a catalog from the connection dialog or the URL, and includes a GizmoSQL metadata model so the schema browser shows view DDL straight from the server. It is the same GizmoSQL JDBC driver underneath, so its connection properties, including bearer tokens and OAuth/SSO, apply.

    What it provides

    • Native GizmoSQL entry in the DBeaver connection list (26.1.0 and later)
    • Automatic JDBC driver download from Maven Central
    • Sensible defaults: port 31337, TLS on, optional catalog selection
    • GizmoSQL metadata model with view DDL in the schema browser
    Connect
    Database → New Database Connection → search "GizmoSQL"
    Host:     gizmosql.example.com
    Port:     31337
    Username: analyst
    Password: ••••••••
    (DBeaver fetches com.gizmodata:gizmosql-jdbc-driver on first connect)

    On older DBeaver releases, register the JDBC JAR manually via Database → Driver Manager.

    04AI & Agents🚀 New

    MCP Server

    Let Claude Desktop, Claude Code, and any MCP client explore your schema and run SQL.

    The GizmoSQL MCP server is a Model Context Protocol server and one-click Claude Desktop extension. Once installed, Claude can list catalogs, schemas, and tables, describe columns, explain query plans, and run parameterised SQL against any GizmoSQL server you can reach from your machine, including private networks over VPN. It runs locally on the official Node.js client and the native ADBC driver, and sends no telemetry.

    It is built for pointing an LLM at production data. A SQL guard keeps it read-only unless you set GIZMOSQL_ALLOW_WRITES=true, row caps and per-query timeouts are enforced on the server, credentials never appear in tool output, and several servers can be configured side by side and switched mid-conversation. A Streamable HTTP transport with a bearer token serves remote MCP clients.

    What it provides

    • npx -y @gizmodata/gizmosql-mcp, or the .mcpb Claude Desktop extension
    • Read-only by default with server-enforced row caps and timeouts
    • Schema exploration, EXPLAIN plans, and parameterised run_query
    • Multiple GizmoSQL servers in one chat, plus login_sso for Enterprise
    Claude Code
    claude mcp add gizmosql \
      -e GIZMOSQL_HOST=gizmosql.internal.example.com \
      -e GIZMOSQL_PORT=31337 \
      -e GIZMOSQL_USERNAME=analyst \
      -e GIZMOSQL_PASSWORD='your-password' \
      -- npx -y @gizmodata/gizmosql-mcp

    Node.js 22 or newer when running through npx; the Claude Desktop bundle needs no Node install. Apache-2.0.

    05AI & Agents🚀 New

    PDF Loader

    Load PDF manuals into GizmoSQL so SQL clients and MCP agents can search the text and fetch the original files.

    gizmosql-pdf-loader is a command-line tool and Python library that loads PDF files into a GizmoSQL server over Arrow Flight SQL / ADBC. For every PDF it stores the file metadata (name, size, SHA-256, page count, title, author, dates) in a documents table, the file bytes as fixed-size chunks (8 MiB by default, so no Arrow Flight message exceeds the gRPC limit) in document_chunks, and one row per page of extracted text in document_pages. Image-only pages are OCR'd with the Tesseract engine that ships inside the PyMuPDF wheel, so there is nothing extra to install. It came out of a customer request to make a shelf of equipment manuals searchable from SQL and from an AI agent.

    Search helpers are created next to the tables: search_pages(term) does case-insensitive substring matching with a snippet, and search_pages_ranked(term, top_k) returns BM25-ranked, stemmed results from DuckDB's fts extension. Any SQL client, the GizmoSQL MCP server, or a retrieval pipeline can then query the text and stream the original file back chunk by chunk. It works with plain DuckDB catalogs and DuckLake catalogs, and re-runs are idempotent because documents are keyed on their SHA-256.

    What it provides

    • pip install gizmosql-pdf-loader: a CLI (load, list, search, index) and a Python API
    • documents, document_chunks, and document_pages tables plus search_pages() and search_pages_ranked() macros
    • OCR of image-only pages with no extra install (Tesseract ships in the PyMuPDF wheel)
    • BM25 full-text search via DuckDB fts, on DuckDB-file and DuckLake catalogs
    CLI
    pip install gizmosql-pdf-loader
    
    # .env: GIZMOSQL_HOSTNAME, GIZMOSQL_PORT, GIZMOSQL_USERNAME, GIZMOSQL_PASSWORD,
    #       GIZMOSQL_CATALOG (required), GIZMOSQL_SCHEMA (default: pdf_docs)
    gizmosql-pdf-loader load --source-dir source_pdf_files
    gizmosql-pdf-loader list
    gizmosql-pdf-loader search "hydraulic pump relief valves" --ranked --limit 5
    
    # Then from any SQL client:
    #   SELECT file_name, page_number, score, snippet
    #     FROM my_lake.pdf_docs.search_pages_ranked('hydraulic pump relief valves', top_k := 10);

    Python 3.10 or newer. Building the full-text index needs the GizmoSQL admin role; querying it does not. Apache-2.0.

    06Tools🚀 New

    GizmoSQL UI

    A free, browser-based SQL editor that ships as a single executable.

    GizmoSQL UI is the fastest way to look at a GizmoSQL server: a Monaco SQL editor with syntax highlighting and autocomplete, a schema browser for catalogs, schemas, tables, and columns, and a type-aware results grid with export to CSV, TSV, JSON, or Parquet. It talks Arrow Flight SQL directly with TLS and authentication support.

    It installs as one self-contained executable via Homebrew on macOS and Linux, a signed MSI on Windows, or a direct download, and opens in your browser on localhost:3000. Against a GizmoSQL Enterprise server it adds OAuth/SSO sign-in and a session-administration screen.

    What it provides

    • Monaco SQL editor with autocomplete and a schema browser
    • Type-aware results grid with CSV, TSV, JSON, and Parquet export
    • Homebrew, Windows MSI, or standalone executable installs
    • OAuth/SSO sign-in and session admin with Enterprise servers
    macOS / Linux
    brew tap gizmodata/tap
    brew trust gizmodata/tap  # required as of Homebrew 6.0
    brew install gizmosql-ui
    gizmosql-ui

    Windows: download GizmoSQL-UI-x64.msi or GizmoSQL-UI-arm64.msi from the GitHub releases page. Apache-2.0.

    07Transformation🚀 New

    dbt Adapter

    Run your dbt project on GizmoSQL with feature parity to dbt-duckdb.

    dbt-gizmosql turns a GizmoSQL server into a dbt warehouse target. It supports table and view materializations, incremental models with append, delete+insert, merge, and microbatch strategies, snapshots, schema-change handling, and constraint enforcement (CHECK, NOT NULL, UNIQUE, PRIMARY KEY, FOREIGN KEY). External file writes to Parquet, CSV, and JSON run on the server.

    Python models run client-side in local DuckDB and ship results to GizmoSQL via ADBC bulk ingest, with session.remote_sql() available for server-side pushdown. Since v1.12.0 the adapter runs on the native ADBC driver 2.0, so profiles can use browser-based OAuth/SSO with auth_type: external instead of a stored password.

    What it provides

    • Table, view, incremental (append, delete+insert, merge, microbatch), and snapshot materializations
    • Python models with ADBC bulk ingest and remote_sql() pushdown
    • OAuth/SSO profiles (auth_type: external) and TLS options
    • Constraint enforcement and server-side Parquet/CSV/JSON exports
    profiles.yml
    # python -m pip install dbt-core dbt-gizmosql
    my-gizmosql-db:
      target: dev
      outputs:
        dev:
          type: gizmosql
          host: gizmosql.example.com
          port: 31337
          auth_type: external   # browser-based OAuth/SSO
          use_encryption: True
          threads: 2

    Apache-2.0.

    08Transformation🚀 New

    SQLMesh Adapter

    Plan, apply, and run SQLMesh transformations against GizmoSQL.

    sqlmesh-gizmosql registers GizmoSQL as a SQLMesh engine. Import the package and SQLMesh can plan and run models on a GizmoSQL server with full catalog support (create, drop, and switch databases), transactions, and ADBC bulk ingestion, generating SQL in the DuckDB dialect.

    Connections use the native ADBC driver 2.0 with TLS on by default (use_encryption) and an option to skip certificate verification for self-signed servers. Browser-based OAuth/SSO with auth_type: external means no username or password has to live in the SQLMesh config.

    What it provides

    • SQLMesh engine adapter with full catalog and transaction support
    • ADBC bulk ingestion over Arrow Flight SQL
    • OAuth/SSO (auth_type: external) and TLS configuration
    • DuckDB SQL dialect generation
    Python
    1# pip install sqlmesh-gizmosql
    2import sqlmesh_gizmosql  # Registers GizmoSQL adapter
    3from sqlmesh import Context
    4
    5context = Context(paths="path/to/project")

    Apache-2.0.

    09Python🚀 New

    PySpark DataFrame API (SQLFrame)

    Run PySpark-style DataFrame code on GizmoSQL with no Spark cluster.

    sqlframe-gizmosql is the GizmoSQL backend for SQLFrame, which implements the PySpark DataFrame API on top of SQL engines. Existing PySpark transformations run against GizmoSQL by swapping the session builder, which is how teams port Databricks and Spark jobs to GizmoSQL without rewriting them.

    The session runs on the native ADBC driver 2.0 with gizmosql:// URIs, TLS by default, and OAuth/SSO via auth_type="external". It adds session.ingest() for ADBC bulk loads, client-side reading of local JSON, CSV, and Parquet files with Spark-compatible schema inference, and OpenTelemetry trace spans around every statement.

    What it provides

    • PySpark-compatible DataFrame API executed as DuckDB SQL
    • Native ADBC driver 2.0 with OAuth/SSO and TLS
    • session.ingest() bulk loading over ADBC
    • Local JSON/CSV/Parquet reads with Spark-style schema inference
    Python
    1# pip install sqlframe-gizmosql
    2from sqlframe_gizmosql import GizmoSQLSession
    3
    4session = GizmoSQLSession.builder \
    5    .config("gizmosql.uri", "gizmosql://localhost:31337") \
    6    .config("gizmosql.username", "gizmosql_user") \
    7    .config("gizmosql.password", "gizmosql_password") \
    8    .config("gizmosql.tls_skip_verify", True) \
    9    .getOrCreate()
    10
    11df = session.sql("SELECT 1 as id, 'hello' as message")
    12df.show()

    Apache-2.0.

    10Python🚀 New

    Python Library (embedded server)

    pip install gizmosql and start a real GizmoSQL server from Python.

    The gizmosql package runs a GizmoSQL Flight SQL server as a managed subprocess. On first use it downloads the matching server binary for your platform (macOS arm64, Linux amd64/arm64, Windows amd64/arm64) into a local cache, so there is no compile toolchain and no Docker requirement. The package has zero runtime dependencies.

    The Server() context manager picks a free port, blocks until the server accepts connections, and stops it cleanly on exit, which makes it ideal for pytest fixtures, notebooks, and multi-agent workflows that need a shared SQL server on demand. Versions ship in lock-step with GizmoSQL server tags, and the optional [adbc] extra adds Server.connect() through the native ADBC driver.

    What it provides

    • Zero-dependency server launcher with cached binaries
    • Context-manager lifecycle for tests and notebooks
    • Versioned in lock-step with GizmoSQL server releases
    • Optional [adbc] extra for an in-process connection
    Python
    1# pip install 'gizmosql[adbc]'
    2import gizmosql
    3
    4with gizmosql.Server(password="tiger") as srv:
    5    print(srv.url)            # grpc+tcp://127.0.0.1:42173
    6    print(srv.username, srv.password)
    7    # ... point any Flight SQL client at srv.url ...

    Apache-2.0.

    11Python

    SQLAlchemy Dialect

    SQLAlchemy ORM and Core on GizmoSQL, over ADBC.

    sqlalchemy-gizmosql-adbc-dialect registers a gizmosql dialect with SQLAlchemy, so declarative models, sessions, and Core queries run against a GizmoSQL server through ADBC. SQL is generated in the DuckDB dialect, and connections are built with URL.create(drivername="gizmosql", ...) plus useEncryption and disableCertificateVerification query options for TLS.

    It is the foundation for the Apache Superset driver below and for any Python framework that expects a SQLAlchemy engine. The server must run the default DuckDB backend.

    What it provides

    • SQLAlchemy ORM (declarative models, Session) and Core support
    • gizmosql:// engine URLs with TLS options
    • DuckDB SQL dialect generation
    • Base for the Apache Superset integration
    Python
    1# pip install sqlalchemy-gizmosql-adbc-dialect
    2url = URL.create(drivername="gizmosql",
    3                 host="localhost",
    4                 port=31337,
    5                 username=os.getenv("GIZMOSQL_USERNAME", "gizmosql_username"),
    6                 password=os.getenv("GIZMOSQL_PASSWORD", "gizmosql_password"),
    7                 query={"disableCertificateVerification": "True",
    8                        "useEncryption": "True"})
    9engine = create_engine(url=url)

    Apache-2.0.

    12BI & Dashboards

    Apache Superset Driver

    Dashboards and SQL Lab in Apache Superset, backed by GizmoSQL.

    superset-sqlalchemy-gizmosql-adbc-dialect is a Superset-compatible build of the SQLAlchemy dialect, pinned to the SQLAlchemy version Apache Superset 6.0 ships with. Install it into your Superset environment and add a database with a gizmosql:// connection URL; Superset charts, dashboards, and SQL Lab then query GizmoSQL directly over ADBC.

    The connection URL carries TLS options and an optional catalog parameter to target a non-default catalog. The server must run the default DuckDB backend.

    What it provides

    • Superset 6.0-compatible SQLAlchemy dialect
    • gizmosql:// connection URLs with TLS options
    • catalog= parameter for non-default catalogs
    • Charts, dashboards, and SQL Lab over ADBC
    Superset connection URL
    pip install superset-sqlalchemy-gizmosql-adbc-dialect
    
    # Superset → Settings → Database Connections → SQLAlchemy URI:
    gizmosql://gizmosql_username:gizmosql_password@localhost:31337?disableCertificateVerification=True&useEncryption=True

    Apache-2.0.

    13Python

    Ibis Backend

    Portable Python dataframe expressions compiled to GizmoSQL.

    ibis-gizmosql adds GizmoSQL as an Ibis backend. You write lazy, typed dataframe expressions in Python and Ibis compiles them to DuckDB SQL that runs on the GizmoSQL server, so the same analysis code can move between GizmoSQL, local DuckDB, and other Ibis backends.

    Connect with keyword arguments or an ibis.connect("gizmosql://...") URL. Since v1.1.0 the backend runs on the native ADBC driver 2.0, with TLS options and browser-based OAuth/SSO via auth_type="external".

    What it provides

    • Ibis dataframe API compiled to DuckDB SQL on the server
    • Keyword or gizmosql:// URL connections
    • OAuth/SSO (auth_type="external") and TLS options
    • Native ADBC driver 2.0 with immediate DDL/DML and RETURNING
    Python
    1# pip install ibis-gizmosql
    2import ibis
    3
    4con = ibis.gizmosql.connect(host="localhost",
    5                            user=os.getenv("GIZMOSQL_USERNAME", "gizmosql_user"),
    6                            password=os.getenv("GIZMOSQL_PASSWORD", "gizmosql_password"),
    7                            port=31337,
    8                            use_encryption=True,
    9                            disable_certificate_verification=True)
    10print(con.tables)
    11t = con.table('lineitem')

    Apache-2.0.

    14BI & Dashboards🚀 New

    Power BI Connector

    DirectQuery and Import mode in Power BI Desktop, over ADBC with query folding.

    The GizmoSQL Power BI connector is a Power Query custom connector that talks to GizmoSQL over ADBC and Arrow Flight SQL, with no ODBC layer in between. Version 2.0 is a rewrite on the native driver; the MSI installer sets up the driver DLL, the signed connector, and the trusted certificate in one step.

    It supports DirectQuery for live dashboards and Import mode for snapshots, and it folds filters, joins, and aggregations down to the server as DuckDB-native SQL. Authentication covers username/password, bearer tokens, and browser-based OAuth/SSO with GizmoSQL Enterprise.

    What it provides

    • One-step MSI installer (x64) with a signed .pqx connector
    • DirectQuery and Import mode
    • Query folding to DuckDB-native SQL
    • Basic, bearer-token, and OAuth/SSO authentication

    Requires GizmoSQL server v1.23.0 or newer. Apache-2.0.

    15Drivers🚀 New

    ODBC Driver

    Excel, Tableau, pyodbc, and every other ODBC 3.x application.

    The GizmoSQL ODBC driver, forked from the Dremio Flight SQL ODBC driver, gives ODBC-only tools a native Arrow Flight SQL path into GizmoSQL. It is fully ODBC 3.x compliant, ships as a Homebrew formula on macOS, an MSI on Windows, and a shared library on Linux, and discovers primary and foreign keys so modelling tools see real relationships.

    Connections support basic, token, and browser-based OAuth authentication (authType=basic|token|external), TLS with the system trust store, and HTTP/2 keepalive pings for long-running sessions. It also supports Power BI DirectQuery and Import for teams that prefer ODBC to the dedicated connector.

    What it provides

    • ODBC 3.x driver for macOS, Windows, and Linux
    • Basic, token, and OAuth (authType=external) authentication
    • Primary and foreign key discovery
    • TLS with system trust store and HTTP/2 keepalive
    Python (pyodbc)
    1# brew install gizmodata/tap/gizmosql-odbc
    2import pyodbc
    3conn = pyodbc.connect(
    4    "Driver=GizmoSQL ODBC Driver;"
    5    "host=localhost;"
    6    "port=31337;"
    7    "uid=gizmosql_user;"
    8    "pwd=gizmosql_password;"
    9    "useEncryption=true"
    10)
    11cursor = conn.cursor()
    12cursor.execute("SELECT * FROM my_table LIMIT 10")

    Windows: GizmoSQL-ODBC-Driver-x64.msi from the releases page. Apache-2.0.

    16BI & Dashboards🚀 New

    Metabase Driver

    Question builder, native SQL, and dashboards in Metabase on GizmoSQL.

    The GizmoSQL Metabase driver is a drop-in plugin JAR built on the GizmoSQL JDBC driver. Download the JAR that matches your Metabase line, put it in the plugins directory, add the documented JVM flags, and restart; GizmoSQL then appears as a database type with catalog selection and schema include/exclude filters during sync.

    It supports username/password, bearer-token/JWT, and OAuth2 authentication, TLS by default with custom CA and mutual-TLS client certificates, and the full Metabase feature set: field filters, MBQL, native SQL, pivot tables, dashboard parameters, and opt-in CSV uploads and table transforms.

    What it provides

    • Plugin JARs for Metabase 62 and 63+ release lines
    • Username/password, JWT, and OAuth2 authentication
    • TLS by default, custom CA, and mTLS support
    • MBQL, native SQL, pivot tables, and dashboard parameters

    Apache-2.0.

    17BI & Dashboards🚀 New

    Grafana Plugin

    Time-series panels straight from GizmoSQL with $__timeFilter macros.

    The GizmoSQL data source plugin (gizmodata-gizmosql-datasource) connects Grafana to GizmoSQL over native Arrow Flight SQL. Write SQL in the query editor and use the standard Grafana time-range macros ($__timeFrom, $__timeTo, $__timeFilter) and template variables to build dashboards over operational and analytical data.

    It supports TLS with optional certificate-verification skip and username/password or token authentication, and requires Grafana 10.0 or newer.

    What it provides

    • Native Arrow Flight SQL data source for Grafana 10+
    • Time-range macros and template variables
    • TLS with optional certificate-verification skip
    • Username/password and token authentication
    Time-series query
    SELECT
      order_date AS time,
      SUM(total_price) AS revenue
    FROM orders
    WHERE $__timeFilter
    GROUP BY order_date
    ORDER BY time

    Apache-2.0.

    18Operations🚀 New

    Kubernetes Operator

    Declare GizmoSQL servers as Kubernetes custom resources.

    The GizmoSQL Operator is a Kubernetes controller that manages the lifecycle of GizmoSQL instances. Install it with one Helm command, then create GizmoSQLServer custom resources; the operator provisions, configures, and reconciles each instance, so multiple isolated servers can be deployed declaratively alongside the rest of your cluster.

    It integrates with Kubernetes RBAC, networking, and storage. If you would rather not run Kubernetes yourself, GizmoData Cloud provisions and operates GizmoSQL clusters for you.

    What it provides

    • Helm-installed operator with a GizmoSQLServer CRD
    • Declarative configuration and automated lifecycle
    • Multiple isolated instances per cluster
    • Native RBAC, networking, and storage integration
    Helm + custom resource
    # helm install gizmosql-operator oci://registry-1.docker.io/gizmodata/gizmosql-operator-chart \
    #   --namespace gizmosql-system --create-namespace
    apiVersion: gizmodata.com/v1alpha1
    kind: GizmoSQLServer
    metadata:
      name: example-gizmosql
      namespace: default
    spec:
      resources:
        limits:
          cpu: "1"
          memory: "2Gi"

    Apache-2.0.

    19Drivers🚀 New

    Node.js Client

    GizmoSQL from TypeScript and JavaScript, returning Arrow tables.

    @gizmodata/gizmosql-client is the official TypeScript client for GizmoSQL and other Arrow Flight SQL servers. Version 2.0 runs on the native Go ADBC driver through the ADBC driver manager, so Node.js services, serverless functions, and CLI tools get the same streaming Arrow results as Python.

    Version 2.2 adds parameter binding: pass values for ? or $1 placeholders as a second argument and they travel to the server as typed Arrow data through a prepared statement, never interpolated into the SQL text. It also adds executeStream() for lazily pulled Arrow record batches and AbortSignal cancellation that interrupts the running statement on the server. TLS, username/password and bearer-token authentication, and OAuth/SSO URL discovery via the Flight handshake round it out. It is also the client under the MCP server.

    What it provides

    • npm install @gizmodata/gizmosql-client
    • Arrow-native results from execute(), streamed batches from executeStream()
    • Parameter binding (? / $1) as typed Arrow values, never string-interpolated
    • AbortSignal cancellation and client-side deadlines
    • TLS, basic, bearer-token, and OAuth/SSO URL discovery
    TypeScript
    // npm install @gizmodata/gizmosql-client
    import { FlightSQLClient } from "@gizmodata/gizmosql-client";
    
    const client = new FlightSQLClient({
      host: "localhost",
      port: 31337,
      tlsSkipVerify: true,
      username: "gizmosql",
      password: "your-password",
    });
    
    // Positional parameters, in placeholder order
    const table = await client.execute(
      "SELECT id, name FROM users WHERE id = ? AND name = ?",
      [42, "Alice"]
    );
    console.log(table.toArray());
    await client.close();

    Requires Node.js 22 or newer. Apache-2.0.

    20Tools🚀 New

    SQLLine Command-line Client

    A single-executable SQL shell for GizmoSQL, built on SQLLine and the JDBC driver.

    gizmosqlline packages SQLLine with the GizmoSQL JDBC driver into one executable with all dependencies included. Install it from the Homebrew tap or download the binary, then connect with a jdbc:gizmosql:// URL and run SQL interactively or from scripts.

    It supports TLS, the JDBC driver's authentication methods including OAuth/SSO via server-side authorization-code exchange, and both client-side and server-side query cancellation.

    What it provides

    • Homebrew tap or single-binary download
    • Interactive and scripted SQL over JDBC
    • TLS, password, token, and OAuth/SSO authentication
    • Client- and server-side query cancellation
    Install and connect
    brew install gizmodata/tap/gizmosqlline
    gizmosqlline -u "jdbc:gizmosql://localhost:31337" -n user -p password

    Apache-2.0; bundles SQLLine (BSD-3-Clause).

    21Operations

    Flight SQL over WebSocket Proxy

    Expose a GizmoSQL server to browser and WebSocket clients that cannot speak gRPC.

    flight-sql-websocket-proxy is a Python server and client pair that fronts an Arrow Flight SQL server such as GizmoSQL with a WebSocket endpoint. Web applications and environments that cannot open gRPC connections send SQL over the WebSocket and receive results back, while the proxy holds the Flight SQL connection to the database.

    The proxy runs with TLS, authenticates to the backend with a username and password, and can require Clerk-issued JWTs from its own clients. Client-side options control result-set row limits and autocommit. It is also available as a Docker image.

    What it provides

    • pip install flight-sql-websocket-proxy, or a Docker image
    • TLS on the WebSocket endpoint and to the backend
    • Clerk JWT authentication for proxy clients
    • Result-set row limits and autocommit controls
    Run the proxy
    pip install flight-sql-websocket-proxy
    flight-sql-websocket-proxy-server --help
    #   --port INTEGER              Run the websocket server on this port.
    #   --tls CERTFILE KEYFILE      Enable transport-level security (TLS/SSL).
    #   --database-server-uri TEXT  The URI of the Arrow Flight SQL server.

    Apache-2.0.

    22Operations🚀 New

    DuckDB ADBC Scanner Extension

    Query a remote GizmoSQL server from plain DuckDB, or from another GizmoSQL server, with the Query.Farm extension.

    The adbc_scanner DuckDB community extension, developed and maintained by Query.Farm, lets a local DuckDB session ATTACH any ADBC-compatible source and query it with plain SQL. With the GizmoSQL ADBC driver loaded, remote GizmoSQL tables behave like local ones: results are zero-copy streamed into DuckDB as Arrow, computation is pushed to the remote side where supported, and remote data joins against local files in one query.

    Because GizmoSQL runs DuckDB under the hood, the same extension works inside a GizmoSQL server, so one instance can federate queries across others. The -adbc variants of the GizmoSQL Docker image ship with the driver preinstalled.

    What it provides

    • INSTALL adbc_scanner FROM community; LOAD adbc_scanner;
    • ATTACH a GizmoSQL server with TYPE adbc and a gizmosql secret
    • Zero-copy Arrow streaming and remote pushdown
    • GizmoSQL-to-GizmoSQL federation with the -adbc images
    DuckDB SQL
    INSTALL adbc_scanner FROM community;
    LOAD adbc_scanner;
    
    CREATE SECRET gizmosql_secret (
         TYPE adbc,
         SCOPE 'gizmosql://gizmosql.example.com:31337',
         driver 'gizmosql',
         uri 'gizmosql://gizmosql.example.com:31337',
         username 'your-user',
         password 'your-password'
     );
    
    ATTACH 'gizmosql://gizmosql.example.com:31337' AS gizmosql_db (TYPE adbc);

    The adbc_scanner extension is a Query.Farm project (Apache-2.0); GizmoData provides the gizmosql ADBC driver it loads.

    23Tools🚀 New

    QGIS Plugin

    Add GizmoSQL spatial tables to QGIS as vector layers over Arrow Flight SQL.

    qgizmosql is a QGIS plugin that browses a GizmoSQL server and adds its spatial tables as QGIS vector layers. Unlike a local DuckDB file, the data stays on a shared, multi-user server reached over gRPC with TLS, so a GIS team works from one governed copy of the data.

    It runs on the native ADBC driver 2.0 with password or browser-based OAuth/SSO sign-in, integrates with the QGIS Auth Manager for stored credentials, and auto-detects GEOMETRY columns. Install it from the QGIS plugin repository (experimental) or from the release ZIP.

    What it provides

    • GizmoSQL tables as QGIS vector layers
    • Password or OAuth/SSO sign-in, with QGIS Auth Manager support
    • Automatic GEOMETRY column detection
    • Multi-user access to one shared spatial server

    Licensed GPLv2+ (inherited from QDuckDB).

    Which GizmoSQL integration should I start with?

    For code, start with the ADBC driver (pip install adbc-driver-gizmosql): it is the native driver every Python integration on this page runs on. DBeaver 26.1 and later has GizmoSQL built in, so just pick it from the connection list. For other desktop SQL tools such as DataGrip and Tableau, use the JDBC driver. For an interactive editor use GizmoSQL UI, and to let Claude Desktop or Claude Code query the server use the MCP server.

    Do these integrations work with the free GizmoSQL Core edition?

    Yes. Every integration on this page connects to GizmoSQL Core (Apache-2.0) as well as GizmoSQL Enterprise. Features that depend on the Enterprise layer, such as OAuth/SSO sign-in and per-catalog permissions, light up automatically when you point the integration at an Enterprise server.

    Which integrations support OAuth / SSO sign-in?

    The ADBC driver 2.0, the JDBC driver, the dbt adapter, the SQLMesh adapter, the Ibis backend, and GizmoSQL UI all support browser-based OAuth/SSO (auth_type: external) against a GizmoSQL Enterprise server. The others authenticate with a username and password or a GizmoSQL JWT bearer token.

    Are the integrations open source?

    Yes. The drivers, adapters, plugins, and clients listed here are published by GizmoData under the Apache-2.0 license on GitHub, PyPI, npm, Maven Central, the Grafana plugin catalog, and the QGIS plugin repository.

    How do I connect DBeaver, DataGrip, Tableau, or another JDBC tool?

    In DBeaver 26.1 or later, choose GizmoSQL from New Database Connection and DBeaver downloads the driver for you. For other tools, download the GizmoSQL JDBC driver JAR, register it in your tool, and connect with a URL of the form jdbc:gizmosql://host:31337?useEncryption=true. The driver supports username/password, bearer-token, and OAuth/SSO authentication and requires JDK 17 or newer.

    Can I load PDFs into GizmoSQL and search their text?

    Yes. The PDF Loader (pip install gizmosql-pdf-loader) stores each PDF in GizmoSQL as metadata, 8 MiB file chunks, and one row of extracted text per page, with OCR for image-only pages. It creates search_pages() for substring matches and search_pages_ranked() for BM25-ranked full-text search, so any SQL client or the MCP server can search the manuals and stream the original file back.

    Can I query GizmoSQL from plain DuckDB?

    Yes. The DuckDB ADBC Scanner extension lets a local DuckDB process query a remote GizmoSQL server over Arrow Flight SQL with a table function, so you can join remote GizmoSQL data against local files in one DuckDB query.

    Missing an integration?

    Anything that speaks Apache Arrow Flight SQL, ADBC, JDBC, or ODBC already works with GizmoSQL. If your tool is not listed, tell us and we will build or document it.