Wire Protocols

SecurityProtocolspgwireArrow Flight

Stable On by default · production-ready

What it is

AetheriusDB separates the engine from the protocol you use to talk to it. The same query, planner, and storage sit behind three listeners that the server runs concurrently — you do not pick one and lose the others. Your client picks the protocol that fits its ecosystem.

Protocol	Default port	Best for	Driver
Native (Aether-Sync)	5679	Lowest-overhead application services	pip install aetherius
PostgreSQL pgwire	5678	psql, Tableau, JDBC, ORMs — anything that speaks Postgres	psycopg, JDBC, ODBC
Apache Arrow Flight SQL	8815	pandas, Polars, Spark, dbt — dataframe-first clients	adbc-driver-flightsql

flowchart LR
  classDef a fill:#1f2640,stroke:#7c5cff,color:#e8eaf0
  classDef b fill:#1f2640,stroke:#00d4ff,color:#e8eaf0
  classDef g fill:#1f2640,stroke:#4ade80,color:#4ade80

  N[Native app]:::a --> S[Aether-Sync]:::b
  P[psql / Tableau<br/>JDBC / Prisma]:::a --> W[pgwire]:::b
  D[pandas / Polars<br/>Spark / ADBC]:::a --> F[Arrow Flight SQL]:::b
  S --> E[Engine]:::g
  W --> E
  F --> E

Why it matters

• Drop-in for Postgres tools — Tableau, Looker, Prisma, Hibernate, and psql just point at the pgwire port; existing workflows run unchanged.
• Typed columns for ML pipelines — Arrow Flight SQL delivers typed columnar data straight into pandas / Polars without a per-row re-parse.
• Lowest overhead for native apps — the native protocol returns typed binary results with the least per-query work, ideal for hot-path services.

How you use it

Each protocol speaks the same SQL. The choice changes how the bytes move, not what your query looks like.

# Native binary protocol — lowest overhead.
import aetherius
with aetherius.connect("127.0.0.1", 5679) as conn:
    rows = conn.execute_binary("SELECT * FROM trades").rows

# PostgreSQL-compatible — works with the whole Postgres ecosystem.
import psycopg
with psycopg.connect(host="127.0.0.1", port=5678,
                     user="aether", dbname="aetherius", password="") as conn:
    with conn.cursor() as cur:
        cur.execute("SELECT * FROM trades")
        rows = cur.fetchall()

# Apache Arrow Flight SQL — typed Arrow batches for analytics.
from adbc_driver_flightsql import dbapi
conn = dbapi.connect("grpc://127.0.0.1:8815")
table = conn.cursor().execute("SELECT * FROM trades").fetch_arrow_table()

The query SELECT * FROM trades returns the same rows through any of the three paths. Choose the protocol your client library already speaks; the engine will satisfy it.

Key concepts

Term	Meaning
Native (Aether-Sync)	The native binary protocol. Typed binary results with the lowest per-query overhead.
pgwire	PostgreSQL v3 wire compatibility. Drop-in for the Postgres ecosystem.
Arrow Flight SQL	gRPC + Arrow. Typed columnar streaming for analytical clients.
Single engine	All three protocols dispatch to the same planner, executor, and storage.

Notes & caveats

Tip

Mixed workloads thrive: keep BI tools on pgwire, point your Python notebooks at Flight SQL, and run hot-path application services on the native protocol. The engine does not duplicate state across listeners.

pgwire pays a translation cost on wide results

The PostgreSQL-compatible listener reshapes results into Postgres row format. For analytical queries returning millions of rows, prefer Flight SQL or the native protocol — the translation cost is real, even though it is isolated to the pgwire listener.

Aether-Sync (Native Protocol) →

The native binary protocol in more depth.

Connect a Client →

Driver matrix and connection recipes for every client.

Remote Connectivity Security →

TLS and auth tokens that wrap every protocol.