pyspiral 0.1.0__cp310-abi3-macosx_11_0_arm64.whl

pyspiral-0.1.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: pyspiral
+Version: 0.1.0
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: License :: Other/Proprietary License
+Requires-Dist: betterproto==2.0.0b7
+Requires-Dist: google-re2>=1.1.20240702
+Requires-Dist: grpclib>=0.4.7
+Requires-Dist: hishel>=0.0.30
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: numpy>=1.26.3
+Requires-Dist: opentelemetry-api>=1.27.0
+Requires-Dist: opentelemetry-sdk>=1.27.0
+Requires-Dist: polars>=1.6.0
+Requires-Dist: pyarrow>=17.0.0
+Requires-Dist: pydantic-settings>=2.3.4
+Requires-Dist: pydantic[email]>=2.5.3
+Requires-Dist: pyjwt[crypto]>=2.9.0
+Requires-Dist: pyroaring>=0.4.4
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: tqdm>=4.66.5
+Requires-Dist: typer>=0.12.3
+Requires-Dist: xxhash>=3.4.1
+Requires-Dist: nanoid>=2.0.0
+Requires-Dist: sqlglot[rs]>=25.25.1
+Requires-Dist: duckdb>=1.1.1
+Requires-Dist: pyperclip>=1.9.0
+Summary: Python implementation of Spiral table format.
+Keywords: vortex,spiraldb
+Home-Page: https://spiraldb.com
+Author: Spiral<hello@spiraldb.com>
+Author-email: SpiralDB <hello@spiraldb.com>
+License: Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source Code, https://github.com/spiraldb/spiraldb
+
+# PySpiral
+

pyspiral-0.1.0.dist-info/RECORD

@@ -0,0 +1,81 @@
+pyspiral-0.1.0.dist-info/METADATA,sha256=rPBsHTqcVDRoUPx9y63fXXLZ-7K1D_p6jQBjeRTM-t8,1699
+pyspiral-0.1.0.dist-info/WHEEL,sha256=j3ku1HwtRttgdyoybPiqmsz03FP6lDUkPQNFM63xZJo,103
+pyspiral-0.1.0.dist-info/entry_points.txt,sha256=uft7u-a6g40NLt4Q6BleWbK4NY0M8nZuYPpP8DV0EOk,45
+spiral/catalog.py,sha256=BtthmRApU1RSb6KbUfVTM2aYeLsnlO0nKDYHBYhdr9M,2496
+spiral/scan_.py,sha256=rbLl85yeOkRuLsbk6QKng0_U4gtGGsW6C-aJiJSxuv8,5946
+spiral/substrait_.py,sha256=5ZXnYcsXEdrBogECnoL6IMlsjsseYHEnVARgRpy2vt8,12671
+spiral/config.py,sha256=ovtE5D3r6_g90ZRDJhlJyWhOBlxLjagvomOyA-VZmdc,911
+spiral/core/core/__init__.pyi,sha256=-OCtTgqjUN7sACAmgrAA_TrqmuP7epNSyL9XjqnNTa4,1914
+spiral/core/spec/__init__.pyi,sha256=zwOPhpBS_iOrPkOdc4ySpgzICZNbteMZf4c2wdkWw1Y,7251
+spiral/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/core/manifests/__init__.pyi,sha256=DXr4Ab_Xo11AzrJlSj7FTSJc8qoO-SkL-_ik4kB855U,1516
+spiral/core/metastore/__init__.pyi,sha256=pdKED91GVJ9XWxTWc9gwkHvVHV_RKxvL43Ofs5ndmew,3145
+spiral/types_.py,sha256=W_jyO7F6rpPiH69jhgSgV7OxQZbOlb1Ho3InpKUP6Eo,155
+spiral/proto/scandal/__init__.py,sha256=wAAEkPN4S4XDpGQtw1MV5zFUeHM01XSAa5tgUgcALvg,777
+spiral/proto/util.py,sha256=smnvVo6nYH3FfDm9jqhNLaXz4bbTBaQezHQDCTvZyiQ,1486
+spiral/proto/spiral/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/spiral/table/__init__.py,sha256=_F1f52RMkZsXofPXpJb2KE8KR5l6zxCtrGrabR1uDxo,2816
+spiral/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/_/scandal/__init__.py,sha256=rQJdbN3UKDJ8vOJ5V7l3KumNHlRyY8iw25HCLsIDB4I,6582
+spiral/proto/_/arrow/flight/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/_/arrow/flight/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/_/arrow/flight/protocol/sql/__init__.py,sha256=_xhj9QkWEW1qZ-iVxcQ8k4EjYr7KJ5ofitJGqVUGQi4,79921
+spiral/proto/_/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/_/spiral/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/_/spiral/table/__init__.py,sha256=sjK2dmvB09PqV3lxKMEk5QoHjC37HMW0MnxR1QDuBg0,7387
+spiral/proto/_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/_/spiraldb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/proto/_/spiraldb/metastore/__init__.py,sha256=40Egtg8MRYTaTTYRKOHkwuiyXEkw3Yg7ETCQskIzpIg,16873
+spiral/proto/_/spfs/__init__.py,sha256=9WtIXr7HGslKWRHHieFDo8N_qnGL4QQyLOCWEkOKRvk,1017
+spiral/proto/substrait/__init__.py,sha256=pV4-T-lwAHKkfFrNYSUGY4IkbIvuKjSo_imzF7BLj_s,126526
+spiral/proto/substrait/extensions/__init__.py,sha256=yD7dg0TBqn-GK_L0qeVof1GKnwSLg_kPyQSV3kcSljs,3655
+spiral/arrow.py,sha256=LBPwZcGkP4kXb42_kl5IUwWW3DO84CV3QJDwCHjG5Dg,7225
+spiral/__init__.py,sha256=4EiQkY17qHT9dpxu41fdOV1kqGl_b-HXNRQg--ZwJbo,286
+spiral/cli/console.py,sha256=-OP0bB_efxhWh4lZ95KRdu-SRgSUMJ47Rbi9FHv1TlY,2577
+spiral/cli/org.py,sha256=ezWhoGUkJQQAwI1jKvDP8uZPNlnou_hXtRDa1us5cSE,2935
+spiral/cli/token.py,sha256=dv30aa745bbS-c3tyzQUTSxGG_N0kCt8G4bip9fP_EM,968
+spiral/cli/__init__.py,sha256=CoiAJ7FDgqjG_TrU-6SpP1hyZloIlEP4wcwnrF8flHM,2237
+spiral/cli/types.py,sha256=4cphJs-i0vfq_CcnHxT9FpHiZdGwxME5GnOmIGB6Thw,1436
+spiral/cli/workload.py,sha256=-XreFPJcX7kZvcYE3oQMeGkkYoXi25R5nuktJPg-PuY,2000
+spiral/cli/admin.py,sha256=3pIs6PxDugMtdgzfRpn_HfBDv-cwAYtF0cJP2INB01A,579
+spiral/cli/fs.py,sha256=8sQAgMahAq0gtXJqnuiKUkx4sO6vEEF4Iaq_-AF3wro,1524
+spiral/cli/app.py,sha256=2oZfDTgj_gZ-lFMMzzJJTnvVzQhp_iedvH-FJnaaMW0,1487
+spiral/cli/table.py,sha256=eh2NAk0GlfvthwRNeIbcZTsRWU3ypFx_uu9OaOLHPUo,628
+spiral/cli/login.py,sha256=C7VpqVyYO2daUeIWHoelWnSGN7cju8YEuqOy12ImH4c,381
+spiral/cli/printer.py,sha256=5HD3UcszFfPk-dK8U5akuvtXqMB7PMgOB1DFYMqspG8,1625
+spiral/cli/__main__.py,sha256=kNaKM2xgJo7GRogf83nYldLM-RGUR6vymdGwZxywQu0,71
+spiral/cli/project.py,sha256=aCxvw8UVwSmh_anArizIQ3_pLVT6QH9jYwMsGfpJUgM,4486
+spiral/cli/state.py,sha256=1quvei8TnDTT6mDRo58P8FUfy4w16Z9sggBz7cFgllY,70
+spiral/dataset.py,sha256=jUeXvE4B5nKh9VNmHxvROQbEkTUxqyYS8oS6EQyRbng,7555
+spiral/grpc_.py,sha256=f3czdP1Mxme42Y5--a5ogYq1TTiWn-J_MlGjwJ2mWwM,1015
+spiral/debug.py,sha256=t590eAUtNWwMTsSdkjVNN7J1iMqY2p4PRJ3BWR_ozho,8999
+spiral/expressions/tiff.py,sha256=k5GMzm4FmGBJMyja-D6u_kt_-vHYIdj4bnYYZut5lK4,7579
+spiral/expressions/io.py,sha256=gJ2a0FKMmdxarWKENulPRwH7KDvSJTIh_OUxX306xAM,3045
+spiral/expressions/__init__.py,sha256=T2POn0Z-mQj9PY8ukYWYn5A832Fz7Y6F8RRASo6Xl3A,5638
+spiral/expressions/list_.py,sha256=nbo4xQAuqBsQGajq_JgORaJl8_CDvOAv14zMbqmtZh4,1814
+spiral/expressions/http.py,sha256=begUydWoFHEqjeLkATvI_v66Ez6_rR-OQBWO5cHbb9c,2742
+spiral/expressions/refs.py,sha256=F3xr7wmrbAawMkLTWcvVwczbOMNOnIttSMRDuzjZHbo,1774
+spiral/expressions/udf.py,sha256=vOlrdxiVpt7vdSgiTKX_XR86YKyu02Fdwb9xlINCby4,1363
+spiral/expressions/str_.py,sha256=tY8RXW3JWvr1-bEfCZtk5FAf11wKJnXPuA9EoeJ9tA4,1265
+spiral/expressions/base.py,sha256=mTBwS6CwdDaV8uotjZUiKi7GHQzX2TRPpnseJJUDrR0,4776
+spiral/expressions/struct.py,sha256=MuxoBP6ESpwmjzusG-_HxHGYKvQQz6AZWzvw7vNUHJM,2007
+spiral/settings.py,sha256=e_F6GQea6ljXzCRgFxMBMecoGhFpEhePhMRQkYOoVO4,4555
+spiral/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/api/filesystems.py,sha256=NPf5PCyCQ7eEU723fOdKcuGPgn83pthkb_jJ9aB0fwM,3431
+spiral/api/workloads.py,sha256=4MWs2pp9AWvx6cZhgyW-ehyCRxpHc_NAQgHaoYOEBfg,1266
+spiral/api/__init__.py,sha256=Ub3IYeQUJ_z0-Y_SXmNasxb6uefKynQkuUZgRM1enyc,6660
+spiral/api/tokens.py,sha256=WaSRr_l3i81t5u2qi3kWW-fySbyKFm-PQK1ZlmoSByc,1464
+spiral/api/admin.py,sha256=HJBrRJScbcdDuFhF_06E0EyE-_Y0osfYPxVoRAyEoTc,837
+spiral/api/organizations.py,sha256=-PO93HTX02IxhXM6SJpAhnAXpVW1WjthFO4-AOzZAC4,2670
+spiral/api/tables.py,sha256=uPoWkkcW7lJUxU0fUgDK5Gy_DT8y7gJFXdgxQpqcc5w,2548
+spiral/api/projects.py,sha256=-VGlu5V3TJ3XLCGu85bPHRFiktIADnAxfLWIH8Rmxug,4986
+spiral/table.py,sha256=iJ-Lhu9ieSNg728cvUNRERcxKz7pj8hMCXPGBFHg7tI,4845
+spiral/authn/modal_.py,sha256=agcnR3dYTslkH2K_a2Eis_2JWn9Ps11FVrGG_jkOdGk,472
+spiral/authn/device.py,sha256=ohHSVLW3a-qLNYQGN-3kXxV_836xOe0UYBN8i63cqAQ,6796
+spiral/authn/authn.py,sha256=OCGJAUfoKLiXw9xAcAnX6i6mBRlvsl6qEFcimqQOu7g,2555
+spiral/authn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/authn/github_.py,sha256=K-0RUHDreINjnCDHyT9aeVDRk6WtNP7noBYEcwdz2W4,1313
+spiral/adbc.py,sha256=H_bzevPy5teyZKzjczh1gQ_zPcfk5sNASiJKQvyab9E,13830
+spiral/project.py,sha256=q9jHql7hz5OQzPfDfvE_hN3K9cZotD0cxkdug9EUTwM,4889
+spiral/_lib.abi3.so,sha256=x_LC6gshT81y-rCvIaOo1Tmznr6gFwgSguFISORTF4E,61021472
+pyspiral-0.1.0.dist-info/RECORD,,

pyspiral-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.2)
+Root-Is-Purelib: false
+Tag: cp310-abi3-macosx_11_0_arm64

pyspiral-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+spiral=spiral.cli.app:main

spiral/__init__.py

@@ -0,0 +1,11 @@
+"""Python client for the Spiral warehouse."""
+
+from spiral import _lib
+from spiral.catalog import Spiral
+from spiral.scan_ import Scan, scan
+from spiral.table import Table
+
+# Eagerly import the Spiral library
+assert _lib, "Spiral library"
+
+__all__ = ["scan", "Scan", "Table", "Spiral"]

spiral/adbc.py

@@ -0,0 +1,386 @@
+import abc
+import functools
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from urllib.parse import urlparse
+
+import duckdb
+import pyarrow as pa
+import pyarrow.compute as pc
+import sqlglot
+import sqlglot.expressions as exp
+from betterproto.lib.google.protobuf import Any
+from pyarrow.flight import (
+    Action,
+    FlightDescriptor,
+    FlightEndpoint,
+    FlightError,
+    FlightInfo,
+    FlightMetadataWriter,
+    FlightServerBase,
+    MetadataRecordBatchReader,
+    RecordBatchStream,
+    ServerCallContext,
+    Ticket,
+)
+
+from spiral import Spiral
+from spiral.proto._.arrow.flight.protocol import sql as rpc
+from spiral.proto._.arrow.flight.protocol.sql import (
+    CommandGetCatalogs,
+    CommandGetDbSchemas,
+    CommandGetSqlInfo,
+    CommandGetTables,
+    CommandStatementQuery,
+    SqlInfo,
+    SqlSupportedTransaction,
+)
+
+log = logging.getLogger(__name__)
+
+
+def debuggable(func):
+    """A decorator to enable GUI (i.e. PyCharm) debugging in the
+    decorated Arrow Flight RPC Server function.
+
+    See: https://github.com/apache/arrow/issues/36844
+    for more details...
+    """
+
+    @functools.wraps(func)
+    def wrapper_decorator(*args, **kwargs):
+        try:
+            import pydevd
+
+            pydevd.connected = True
+            pydevd.settrace(suspend=False)
+        except ImportError:
+            # Not running in debugger
+            pass
+        value = func(*args, **kwargs)
+        return value
+
+    return wrapper_decorator
+
+
+class ADBCServerBase:
+    def get_sql_info(self, _req: CommandGetSqlInfo) -> pa.RecordBatchReader:
+        """Default implementation that reports no support for any complex features."""
+        info = {
+            SqlInfo.FLIGHT_SQL_SERVER_NAME: "Spiral ADBC Server",
+            SqlInfo.FLIGHT_SQL_SERVER_VERSION: "0.0.1",
+            SqlInfo.FLIGHT_SQL_SERVER_ARROW_VERSION: pa.__version__,
+            SqlInfo.FLIGHT_SQL_SERVER_READ_ONLY: True,
+            SqlInfo.FLIGHT_SQL_SERVER_TRANSACTION: SqlSupportedTransaction.SQL_SUPPORTED_TRANSACTION_NONE.value,
+        }
+
+        # See https://github.com/apache/arrow-adbc/blob/38c21c2311a59803559cb0091b3f34180c28b25f/rust/core/src/schemas.rs#L35
+        union_fields = [
+            pa.field("string_value", pa.string()),
+            pa.field("bool_value", pa.bool_()),
+            pa.field("int64_value", pa.int64()),
+            pa.field("int32_bitmask", pa.int32()),
+            pa.field("string_list", pa.list_(pa.string())),
+            pa.field(
+                "int32_to_int32_list_map",
+                pa.map_(pa.int32(), pa.list_(pa.int32()), keys_sorted=False),
+            ),
+        ]
+        schema = pa.schema(
+            [
+                pa.field("info_name", pa.uint32(), nullable=False),
+                pa.field("info_value", pa.dense_union(union_fields), nullable=False),
+            ]
+        )
+
+        # PyArrow doesn't support creating a dense union for us :(
+        types = []
+        offsets = []
+        ints = []
+        bools = []
+        strs = []
+        for value in info.values():
+            if isinstance(value, str):
+                types.append(0)
+                offsets.append(len(strs))
+                strs.append(value)
+            elif isinstance(value, bool):
+                types.append(1)
+                offsets.append(len(bools))
+                bools.append(value)
+            else:
+                types.append(1)
+                offsets.append(len(ints))
+                ints.append(value)
+
+        values = pa.UnionArray.from_dense(
+            pa.array(types, type=pa.int8()),
+            pa.array(offsets, type=pa.int32()),
+            [pa.array(data, type=f.type) for data, f in zip([strs, bools, ints, [], [], []], union_fields)],
+            [f.name for f in union_fields],
+        )
+
+        return pa.table(data=[pa.array(list(info.keys()), type=pa.uint32()), values], schema=schema).to_reader()
+
+    @abc.abstractmethod
+    def get_catalogs(self, req: CommandGetCatalogs) -> pa.RecordBatchReader: ...
+
+    @abc.abstractmethod
+    def get_db_schemas(self, req: CommandGetDbSchemas) -> pa.RecordBatchReader: ...
+
+    @abc.abstractmethod
+    def get_tables(self, req: CommandGetTables) -> pa.RecordBatchReader: ...
+
+    @abc.abstractmethod
+    def statement_query(self, req: CommandStatementQuery, limit: int | None = None) -> pa.RecordBatchReader: ...
+
+
+class SpiralADBCServer(ADBCServerBase):
+    def __init__(self, spiral: Spiral):
+        self.sp = spiral
+
+        self.pool = ThreadPoolExecutor()
+
+    def get_catalogs(self, req: CommandGetCatalogs) -> pa.RecordBatchReader:
+        schema = pa.schema([pa.field("catalog_name", pa.string(), nullable=False)])
+
+        @debuggable
+        def batches():
+            yield pa.RecordBatch.from_arrays(
+                [list(self.sp.list_project_ids())],
+                schema=schema,
+            )
+
+        return pa.RecordBatchReader.from_batches(schema, batches())
+
+    def get_db_schemas(self, req: CommandGetDbSchemas) -> pa.RecordBatchReader:
+        """Get the schemas from the database."""
+
+        schema = pa.schema(
+            [
+                pa.field("catalog_name", pa.string()),
+                pa.field("db_schema_name", pa.string(), nullable=False),
+            ]
+        )
+
+        @debuggable
+        def batches():
+            if req.catalog == "":
+                # Empty string means databases _without_ a catalog, which we don't support
+                return
+
+            # Otherwise, catalog is either the project ID, or None.
+            if req.catalog is None:
+                projects = list(self.sp.list_projects())
+            else:
+                projects = [self.sp.project(req.catalog)]
+
+            for project in projects:
+                datasets = {dt[0] for dt in project.list_table_names()}
+                batch = pa.RecordBatch.from_arrays(
+                    [
+                        [project.id] * len(datasets),
+                        list(datasets),
+                    ],
+                    schema=schema,
+                )
+
+                if req.db_schema_filter_pattern:
+                    mask = pc.match_like(batch["db_schema_name"], req.db_schema_filter_pattern)
+                    batch = batch.filter(mask)
+
+                yield batch
+
+        return pa.RecordBatchReader.from_batches(schema, batches())
+
+    def get_tables(self, req: CommandGetTables) -> pa.RecordBatchReader:
+        schema = pa.schema(
+            [
+                pa.field("catalog_name", pa.string()),
+                pa.field("db_schema_name", pa.string()),
+                pa.field("table_name", pa.string(), nullable=False),
+                pa.field("table_type", pa.string(), nullable=False),
+            ]
+            + [pa.field("table_schema", pa.binary(), nullable=False)]
+            if req.include_schema
+            else []
+        )
+
+        @debuggable
+        def batches():
+            if req.catalog == "":
+                # Empty string means databases _without_ a catalog, which we don't support
+                return
+
+            if req.catalog is None:
+                projects = list(self.sp.list_projects())
+            else:
+                projects = [self.sp.project(req.catalog)]
+
+            def _process_project(project):
+                tables = project.list_tables()
+
+                rows = []
+                for table in tables:
+                    _project_id, dataset, name = str(table).split(".")
+
+                    row = {
+                        "catalog_name": project.id,
+                        "db_schema_name": dataset,
+                        "table_name": name,
+                        "table_type": "TABLE",
+                    }
+
+                    if req.include_schema:
+                        row["table_schema"] = table.to_dataset().schema.serialize().to_pybytes()
+
+                    rows.append(row)
+
+                return pa.RecordBatch.from_pylist(rows, schema=schema)
+
+            yield from self.pool.map(_process_project, projects)
+
+        return pa.RecordBatchReader.from_batches(schema, batches())
+
+    @debuggable
+    def statement_query(self, req: CommandStatementQuery, limit: int | None = None) -> pa.RecordBatchReader:
+        # Extract the tables from the query, and bring them into the Python locals scope.
+        expr = sqlglot.parse_one(req.query, dialect="duckdb")
+        for tbl in expr.find_all(exp.Table):
+            # We swap the three-part identifier out for a single identifier
+            # This lets us insert a PyArrow Dataset into Python locals such that
+            # DuckDB will pick up on it for the query.
+            name = exp.table_name(tbl)
+            locals()[name] = self.sp.project(tbl.catalog).table(f"{tbl.db}.{tbl.name}").to_dataset()
+            tbl.replace(exp.table_(table=name))
+
+        try:
+            sql = duckdb.sql(expr.sql(dialect="duckdb"))
+        except Exception as e:
+            raise FlightError(str(e))
+
+        if limit is not None:
+            sql = sql.limit(limit)
+
+        return sql.fetch_arrow_reader(batch_size=1_000)
+
+
+class ADBCFlightServer(FlightServerBase):
+    """An implementation of a FlightSQL ADBC server."""
+
+    def __init__(self, abdc: ADBCServerBase, *, location=None, **kwargs):
+        super().__init__(location=location, **kwargs)
+        self.location = location
+        self.adbc = abdc
+
+        self.host = "localhost"
+        self.tls = False
+        if location:
+            parts = urlparse(location)
+            self.host = parts.hostname
+            self.tls = parts.scheme.endswith("s")
+
+    @debuggable
+    def do_action(self, context: ServerCallContext, action: Action):
+        log.info("DoAction %s: %s", context.peer(), action)
+        super().do_action(context, action)
+
+    @debuggable
+    def do_exchange(self, context: ServerCallContext, descriptor: FlightDescriptor, reader, writer):
+        log.info("DoExchange %s: %s", context.peer(), descriptor)
+        super().do_exchange(context, descriptor, reader, writer)
+
+    @debuggable
+    def do_get(self, context: ServerCallContext, ticket: Ticket):
+        log.info("DoGet %s: %s", context.peer(), ticket)
+        req = self.parse_command(ticket.ticket)
+        match req:
+            case CommandGetSqlInfo():
+                return RecordBatchStream(self.adbc.get_sql_info(req))
+            case CommandGetCatalogs():
+                return RecordBatchStream(self.adbc.get_catalogs(req))
+            case CommandGetDbSchemas():
+                return RecordBatchStream(self.adbc.get_db_schemas(req))
+            case CommandGetTables():
+                return RecordBatchStream(self.adbc.get_tables(req))
+            case CommandStatementQuery():
+                return RecordBatchStream(self.adbc.statement_query(req))
+            case _:
+                raise NotImplementedError(f"Unsupported do_Get: {req}")
+
+    @debuggable
+    def do_put(
+        self,
+        context: ServerCallContext,
+        descriptor: FlightDescriptor,
+        reader: MetadataRecordBatchReader,
+        writer: FlightMetadataWriter,
+    ):
+        log.info("DoPut %s: %s", context.peer(), descriptor)
+        super().do_put(context, descriptor, reader, writer)
+
+    @debuggable
+    def get_flight_info(self, context: ServerCallContext, descriptor: FlightDescriptor) -> FlightInfo:
+        log.info("GetFlightInfo %s: %s", context.peer(), descriptor)
+        req = self.parse_command(descriptor.command)
+        match req:
+            case CommandGetSqlInfo():
+                # Each metadata type contributes to the schema.
+                schema = self.adbc.get_sql_info(req).schema
+            case CommandGetCatalogs():
+                schema = self.adbc.get_catalogs(req).schema
+            case CommandGetDbSchemas():
+                schema = self.adbc.get_db_schemas(req).schema
+            case CommandGetTables():
+                schema = self.adbc.get_tables(req).schema
+            case CommandStatementQuery():
+                schema = self.adbc.statement_query(req, limit=0).schema
+            case _:
+                raise NotImplementedError(f"Unsupported command: {req}")
+
+        return self._make_flight_info(self.descriptor_to_key(descriptor), descriptor, schema)
+
+    @staticmethod
+    def parse_command(command: bytes):
+        command = Any().parse(command)
+
+        if not command.type_url.startswith("type.googleapis.com/arrow.flight.protocol.sql."):
+            raise NotImplementedError(f"Unsupported command: {command.type_url}")
+
+        proto_cls_name = command.type_url[len("type.googleapis.com/arrow.flight.protocol.sql.") :]
+        proto_cls = getattr(rpc, proto_cls_name)
+        return proto_cls().parse(command.value)
+
+    @staticmethod
+    def descriptor_to_key(descriptor):
+        return descriptor.command
+
+    @debuggable
+    def get_schema(self, context: ServerCallContext, descriptor: FlightDescriptor):
+        log.info("GetSchema %s: %s", context.peer(), descriptor)
+        return super().get_schema(context, descriptor)
+
+    @debuggable
+    def list_actions(self, context: ServerCallContext):
+        log.info("ListActions %s", context.peer())
+        super().list_actions(context)
+
+    @debuggable
+    def list_flights(self, context: ServerCallContext, criteria):
+        log.info("ListFlights %s: %s", context.peer(), criteria)
+        super().list_flights(context, criteria)
+
+    def _make_flight_info(self, key, descriptor, schema: pa.Schema):
+        # If we pass zero locations, the FlightSQL client should attempt to use the original connection.
+        endpoints = [FlightEndpoint(key, [])]
+        return FlightInfo(schema, descriptor, endpoints, -1, -1)
+
+
+if __name__ == "__main__":
+    import logging
+
+    logging.basicConfig()
+    logging.getLogger("spiral").setLevel(logging.DEBUG)
+
+    server = ADBCFlightServer(SpiralADBCServer(Spiral()), location="grpc://localhost:5005")
+    server.serve()