pyspiral 0.6.6__cp312-abi3-macosx_11_0_arm64.whl

pyspiral-0.6.6.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: pyspiral
+Version: 0.6.6
+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: betterproto2>=0.9.0
+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: nanoid>=2.0.0
+Requires-Dist: numpy>=2
+Requires-Dist: pyarrow>=21.0.0
+Requires-Dist: pydantic-settings>=2.3.4
+Requires-Dist: pydantic[email]>=2.5.3,<2.12
+Requires-Dist: pyjwt[crypto]>=2.9.0
+Requires-Dist: pyperclip>=1.9.0
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: sqlglot[rs]>=25.25.1
+Requires-Dist: tqdm>=4.66.5
+Requires-Dist: typer>=0.16
+Requires-Dist: xxhash>=3.4.1
+Requires-Dist: polars>=1.31.0 ; extra == 'polars'
+Requires-Dist: duckdb>=1.3.2 ; extra == 'duckdb'
+Requires-Dist: datasets>=4.0.0 ; extra == 'datasets'
+Requires-Dist: pyiceberg>=0.9.1 ; extra == 'pyiceberg'
+Requires-Dist: mosaicml-streaming>=0.13.0 ; extra == 'streaming'
+Requires-Dist: vortex-data>=0.52.1 ; extra == 'streaming'
+Provides-Extra: polars
+Provides-Extra: duckdb
+Provides-Extra: datasets
+Provides-Extra: pyiceberg
+Provides-Extra: streaming
+Summary: Python client for Spiral.
+Home-Page: https://spiraldb.com
+Author-email: SpiralDB <hello@spiraldb.com>
+License: Proprietary License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# PySpiral
+

pyspiral-0.6.6.dist-info/RECORD

@@ -0,0 +1,102 @@
+pyspiral-0.6.6.dist-info/METADATA,sha256=-bBD9kI1C6FKX2Q46LDuDSQH_Bbk8978BsBQ2dcKYEI,1842
+pyspiral-0.6.6.dist-info/WHEEL,sha256=KQvxBiy7GLcML6Ad3w_ZPrgSvER1uXd7aYb6wy6b44Y,103
+pyspiral-0.6.6.dist-info/entry_points.txt,sha256=uft7u-a6g40NLt4Q6BleWbK4NY0M8nZuYPpP8DV0EOk,45
+spiral/__init__.py,sha256=n4JNLrO3wyw_k_U_JKyNiGON0wEpfvqxDhDdB2P6dhM,1007
+spiral/_lib.abi3.so,sha256=T9mZhTpQ7lrdwPrzkQETZMUOfLlUtiP7nb2pDQo7XLg,66386256
+spiral/adbc.py,sha256=7IxfWIeQN-fh0W5OdN_PP2x3pzQYg6ZUOLsHg3jktqw,14842
+spiral/api/__init__.py,sha256=ULBlVq3PnfNOO6T5naE_ULmmii-83--qTuN2PpAUQN0,2241
+spiral/api/admin.py,sha256=A1iVR1XYJSObZivPAD5UzmPuMgupXc9kaHNYYa_kwfs,585
+spiral/api/client.py,sha256=wjxhjM2Li3UQZiWkihRKh5HHbWN4uURXXYaX_S1Bkew,4641
+spiral/api/filesystems.py,sha256=yEHgHfo7t1_becm0UFedc3nd49_G77hHjYwtYQ6P9XU,4240
+spiral/api/key_space_indexes.py,sha256=-38rZXTdkL4mLhp9h3CtqyIyutzzq88tV6bhK05MqYE,640
+spiral/api/organizations.py,sha256=B-8zZ7lFJANGK7dUNbo_aU-cgI959JBP9VcWb6wdgi0,1895
+spiral/api/projects.py,sha256=1JC7VjqZJfwR6zfhBZr3OCwaf6zb-MXMOBTE_NztmcE,6356
+spiral/api/telemetry.py,sha256=tfdA3E_EWJwFVxkQfkm8tiYGRubnx2LuE5nbfsk1oG4,474
+spiral/api/text_indexes.py,sha256=_zVlGBytl-9-Unbu2POfZgLh40H1YRcagFtplgIG428,1828
+spiral/api/types.py,sha256=lGdiKViRgIEJXD2ubwnyEIEwHkfRumlZjVEaHMV3Tm8,682
+spiral/api/workers.py,sha256=0wZNUHMioDT53P1OBJfpjyDfIodHwwT6858z2IlRIM4,636
+spiral/api/workloads.py,sha256=XAyXV7vgZcoyyoPoGvOT4jTpyFKFMvrrAfhL6d1h1kE,1748
+spiral/arrow_.py,sha256=fdSIfIs7UjDxXZlppvOW0zz86W_70Pa5pagJilH2kOE,7583
+spiral/cli/__init__.py,sha256=LutjpWZu5Rvmba8C8bPa5vOCv74JuAoE1kvz0nd48dE,2476
+spiral/cli/__main__.py,sha256=kNaKM2xgJo7GRogf83nYldLM-RGUR6vymdGwZxywQu0,71
+spiral/cli/admin.py,sha256=-ubYqs8nKjnQStbQ68jpWx_9xh0TsaxI0wM1Hfko8_U,319
+spiral/cli/app.py,sha256=smzGj5a2RwhM9RQChmlEeKZLN4Fk60-bP7Lm5_Is1Rw,2760
+spiral/cli/console.py,sha256=6JHbAQV6MFWz3P-VzqPOjhHpkIQagsCdzTMvmuDKMkU,2580
+spiral/cli/fs.py,sha256=vaPcSc2YghhHeipxNitIdsHaBhFwlwkvPFqYsFSN9P0,2927
+spiral/cli/iceberg.py,sha256=Q14tcGcn1LixbFCYP0GhfYwFFXTmmi8tqBPYwalJEyE,3248
+spiral/cli/key_spaces.py,sha256=x3IFRP5d47pKiAHeWExYMOBaT2TwxbWjVM01SUqKrwI,2943
+spiral/cli/login.py,sha256=2tw6uN5rEpiMMAmjQSB3-JUPf3C0Wc1eTGCDxhYtJps,731
+spiral/cli/orgs.py,sha256=fmOuLxpeIFfKqePRi292Gv9k-EF5pPn_tbKd2BLl2Ig,2869
+spiral/cli/printer.py,sha256=aosc763hDFgoXJGkiANmNyO3kAsecAS1JWgjEhn8GCM,1784
+spiral/cli/projects.py,sha256=1M1nGrBT-t0aY9RV5Cnmzy7YrhIvmHwdkpa3y9j8rG8,5756
+spiral/cli/state.py,sha256=10wTIVQ0SJkY67Z6-KQ1LFlt3aVIPmZhoHFdTwp4kNA,130
+spiral/cli/tables.py,sha256=fFte_wMNcB0V-fmfSXfSbtV4UlAi-Xw5nYDJ0b62CGk,6360
+spiral/cli/telemetry.py,sha256=Uxo1Q1FkKJ6n6QNGOUmL3j_pRRWRx0qWIhoP-U9BuR0,589
+spiral/cli/text.py,sha256=DlWGe4JrkdERAiqyITNpk91Wqb63Re99rNYlIFsIamc,4031
+spiral/cli/types.py,sha256=XYzo1GgX7dBBItoBSrHI4vO5C2lLmS2sktb-2GnGH3E,1362
+spiral/cli/workloads.py,sha256=2_SLfQTFN6y73R9H0i9dk8VIOVagKxSxOpHXC56yptY,2015
+spiral/client.py,sha256=N4sQLxtQ6GYCnj00hm4VX1vUVUqzQdHhl_KfQwp-1LQ,6345
+spiral/core/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/core/_tools/__init__.pyi,sha256=b2KLfTOQ67pjfbYt07o0IGiTu5o2bZw69lllV8v0Dps,143
+spiral/core/authn/__init__.pyi,sha256=z_GWyIS62fuiYQrYO8hzw4W8oGaiciqS1u5qtAt54VY,769
+spiral/core/client/__init__.pyi,sha256=1HK3SOMT1QKmD5Hai58ZFjiEZK0QzyYtP84hse8SBEI,6666
+spiral/core/table/__init__.pyi,sha256=QqG_pMlPhMtXG-56dXyQjOWVKMugPP0nnYnvYaY0Q10,3288
+spiral/core/table/manifests/__init__.pyi,sha256=eVfDpmhYSjafIvvALqAkZe5baN3Y1HpKpxYEbjwd4gQ,1043
+spiral/core/table/metastore/__init__.pyi,sha256=rc3u9MwEKRvL2kxOc8lBorddFRnM8o_o1frqtae86a4,1697
+spiral/core/table/spec/__init__.pyi,sha256=OFYJXPXix7gskYJIMog7IniZslEPJ0xvL-sUSFDPbXs,5643
+spiral/dataloader.py,sha256=FFZhIflQPEygXe-xBLifQnnxANi4CFooaHRm4i-EGHo,10335
+spiral/dataset.py,sha256=PMLoXnXuEUciP6-NXqTmQLXu0UIH7OcC4-iZtY_iuO8,7973
+spiral/datetime_.py,sha256=elXaUWtZuuLVcu9E0aXnvYRPB9XWqZbLDToozQYQYjU,950
+spiral/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/debug/manifests.py,sha256=7f1O3ba9mrA5nXpOF9cEIQuUAteP5wiBkFy_diQJ7No,3216
+spiral/debug/metrics.py,sha256=XdRDcjggtsLNGCAjam6IxG9072pz_d2C8iLApNRFUtk,2044
+spiral/debug/scan.py,sha256=UEm_aRnql5pwDPTpZgakMLNjlzkKL4RurBFFqH_BLAQ,9526
+spiral/expressions/__init__.py,sha256=KhwFjVKoFgx1S6hkVcE8aZjoHY_1N-BgQ2rGEZfPQvM,7957
+spiral/expressions/base.py,sha256=915gpvZZCTRCO5q93pwwmhf-R6C23LQsyDt4Q2dHk9s,5290
+spiral/expressions/http.py,sha256=begUydWoFHEqjeLkATvI_v66Ez6_rR-OQBWO5cHbb9c,2742
+spiral/expressions/io.py,sha256=gJ2a0FKMmdxarWKENulPRwH7KDvSJTIh_OUxX306xAM,3045
+spiral/expressions/list_.py,sha256=MMt5lf5H1M3O-x6N_PvqOLGq9NOk6Ukv0fPWwPC_uy4,1809
+spiral/expressions/mp4.py,sha256=_xGVnkygddzxP9a8OACJ8_KXnejuVbYCVKBCXBQ798Y,2151
+spiral/expressions/png.py,sha256=KO8X0OmMzUFwpg2I_j0JTyldPzVXDWIMzjWMWDV9vIY,506
+spiral/expressions/qoi.py,sha256=gvIbb6fXb_Bb080sn9wkpbGGrPs2UEcTXCfuv4-kcYQ,506
+spiral/expressions/refs.py,sha256=omeHBQ5o6N4xgZ3x5Xz7IRrWwYBBtQY8DYK0NNAxeGo,2109
+spiral/expressions/str_.py,sha256=tY8RXW3JWvr1-bEfCZtk5FAf11wKJnXPuA9EoeJ9tA4,1265
+spiral/expressions/struct.py,sha256=pGAnCDh6AK0BK1XfZ1qG4ce4ranIQEE1HQsgmzBcfwQ,2038
+spiral/expressions/text.py,sha256=-02gBWYoyNQ3qQ1--9HTa8IryUDojYQVIp8C7rgnOWQ,1893
+spiral/expressions/tiff.py,sha256=fQwIn0kLFBM2Y3YYIHmTgb_EIRHKT2fNc77nioDQQw4,8044
+spiral/expressions/udf.py,sha256=yb9MIcrFftpNDxgBF228cvdv6TY-hEFikYz2fq_nzWo,1353
+spiral/grpc_.py,sha256=f3czdP1Mxme42Y5--a5ogYq1TTiWn-J_MlGjwJ2mWwM,1015
+spiral/iceberg.py,sha256=JGq62Qnf296r9_hRAoH85GQq45-uSBjwXWw_CvPi6G4,930
+spiral/iterable_dataset.py,sha256=Eekg9ad8tcwXcloHWReBbvCSr5ZappRHn2ldKTvwqS0,4622
+spiral/key_space_index.py,sha256=NAB_nONEjpMYbse8suz42w7Qb5OPHuKN9h9CT2NJe08,1460
+spiral/project.py,sha256=CO_Pn6vPqaonNvRdCNRFcBWr4TqO2AsAUTH5xawIeCE,7283
+spiral/protogen/_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/protogen/_/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/protogen/_/arrow/flight/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/protogen/_/arrow/flight/protocol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/protogen/_/arrow/flight/protocol/sql/__init__.py,sha256=ooZZsDCRFpktUCH11OdxMRa_GLQYnY9w-1fBr5a7vBk,90023
+spiral/protogen/_/google/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/protogen/_/google/protobuf/__init__.py,sha256=H0FVEXusqww2j5dl7Ee05tR6qMG_hQioUp1qFfDgnco,80036
+spiral/protogen/_/message_pool.py,sha256=4-cRhhiM6bmfpUJZ8qxc8LEyqHBHpLCcotjbyZxl7JM,71
+spiral/protogen/_/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/protogen/_/scandal/__init__.py,sha256=liUQAICLd2sPccCmqo0_c1duSbNj_m8p_IgmdnHsB3E,4965
+spiral/protogen/_/spfs/__init__.py,sha256=zMMEDIfPXQNBkisLI-iMWbJABye-vK42Gf2BUQQYR_c,2028
+spiral/protogen/_/spql/__init__.py,sha256=PEC4bI-PHdJ4Zd8Jb1k6Xk2iFYoYqIUbTGlL2JVGnT0,1548
+spiral/protogen/_/substrait/__init__.py,sha256=-ngqHcYfio6s1B4M1_e1VsDymUcFK9qdM17ECA31qLw,209837
+spiral/protogen/_/substrait/extensions/__init__.py,sha256=nhnEnho70GAT8WPj2xtwJUzk5GJ6X2e-HTvyk7emGsk,5326
+spiral/protogen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/protogen/util.py,sha256=smnvVo6nYH3FfDm9jqhNLaXz4bbTBaQezHQDCTvZyiQ,1486
+spiral/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/scan.py,sha256=4PUlI_DHbO1WTttLia6DinhGtOWsCiqek4ZljoEiRZc,10523
+spiral/server.py,sha256=ztBmB5lBnUz-smQxR_tC8AI5SOhz17wH0MI3GuzDUdM,600
+spiral/settings.py,sha256=JRQSwjJyNaCqQdQLxiqB_O_LZRQXMLyshJBrI2LZHwM,3113
+spiral/snapshot.py,sha256=cTobi5jtiANxalGA-isokQHblNmXGtuUvgUGGNVybsI,1555
+spiral/streaming_/__init__.py,sha256=s7MlW2ERsuZmZGExLFL6RcZon2e0tNBocBg5ANgki7k,61
+spiral/streaming_/reader.py,sha256=tl_lC9xgh1-QFhsZn4xQT7It3PVTzHCEUT2BG2dWBRQ,4166
+spiral/streaming_/stream.py,sha256=nXnygiuCxi1D3PhaxV8Ujif4J9ly_OczA7CZ3W4WN2w,5913
+spiral/substrait_.py,sha256=AKeOD4KIXvz2J4TYxnIneOiHddtBIyOhuNxVO_uH0eg,12592
+spiral/table.py,sha256=G05b6M0uVmT5ew5GxuzsVB4rQzg25W3zGMTftL07pJU,11026
+spiral/text_index.py,sha256=FQ9rgIEGLSJryS9lFdMhKtPFey18BXoWbPXyvZPJJ04,442
+spiral/transaction.py,sha256=h6YdAwOYX6qq-tXYV4i9yhy1Nq1tIfRphY_fk7Q_yLQ,1854
+spiral/types_.py,sha256=W_jyO7F6rpPiH69jhgSgV7OxQZbOlb1Ho3InpKUP6Eo,155
+pyspiral-0.6.6.dist-info/RECORD,,

pyspiral-0.6.6.dist-info/WHEEL

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

pyspiral-0.6.6.dist-info/entry_points.txt

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

spiral/__init__.py

@@ -0,0 +1,35 @@
+"""Python client for Spiral"""
+
+# This is here to make sure we load the native extension first
+from spiral import _lib
+
+# Eagerly import the Spiral library
+assert _lib, "Spiral library"
+
+from spiral.client import Spiral  # noqa: E402
+from spiral.core.client import Shard, ShuffleConfig  # noqa: E402
+from spiral.dataloader import SpiralDataLoader, World  # noqa: E402
+from spiral.iceberg import Iceberg  # noqa: E402
+from spiral.key_space_index import KeySpaceIndex  # noqa: E402
+from spiral.project import Project  # noqa: E402
+from spiral.scan import Scan  # noqa: E402
+from spiral.snapshot import Snapshot  # noqa: E402
+from spiral.table import Table  # noqa: E402
+from spiral.text_index import TextIndex  # noqa: E402
+from spiral.transaction import Transaction  # noqa: E402
+
+__all__ = [
+    "Spiral",
+    "Project",
+    "Table",
+    "Snapshot",
+    "Transaction",
+    "Scan",
+    "Shard",
+    "ShuffleConfig",
+    "TextIndex",
+    "KeySpaceIndex",
+    "SpiralDataLoader",
+    "World",
+    "Iceberg",
+]

spiral/adbc.py

@@ -0,0 +1,411 @@
+import abc
+import functools
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from urllib.parse import urlparse
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import sqlglot
+import sqlglot.expressions as exp
+from pyarrow.flight import (
+    Action,
+    FlightDescriptor,
+    FlightEndpoint,
+    FlightError,
+    FlightInfo,
+    FlightMetadataWriter,
+    FlightServerBase,
+    MetadataRecordBatchReader,
+    RecordBatchStream,
+    ServerCallContext,
+    Ticket,
+)
+
+from spiral import Spiral
+from spiral.api.projects import TableResource
+from spiral.protogen._.arrow.flight.protocol import sql as rpc
+from spiral.protogen._.arrow.flight.protocol.sql import (
+    CommandGetCatalogs,
+    CommandGetDbSchemas,
+    CommandGetSqlInfo,
+    CommandGetTables,
+    CommandStatementQuery,
+    SqlInfo,
+    SqlSupportedTransaction,
+)
+from spiral.protogen._.google.protobuf import Any
+from spiral.snapshot import Snapshot
+
+log = logging.getLogger(__name__)
+logging.getLogger("sqlx").setLevel(logging.WARNING)
+
+
+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.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 open_snapshot(self, tbl) -> Snapshot:
+        """Open a table in the Spiral project and return it as a PyArrow Dataset."""
+        if tbl.catalog is None or tbl.catalog == "":
+            raise FlightError("Project (Data Catalog) must be specified to open a table.")
+
+        project = tbl.catalog
+        dataset = tbl.db or "default"
+        table = tbl.name
+
+        return self.sp.project(project).table(f"{dataset}.{table}").snapshot()
+
+    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(
+                [[p.id for p in self.sp.list_projects()]],
+                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
+            catalog = req.catalog
+
+            # Otherwise, catalog is either the project ID, or None.
+            if catalog is None:
+                projects = self.sp.list_projects()
+            else:
+                projects = [self.sp.project(req.catalog)]
+
+            for project in projects:
+                datasets = {tbl.dataset for tbl in project.list_tables()}
+
+                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)]
+            projects = sorted(projects, key=lambda p: p.id)
+
+            def _process_project(project):
+                tables: list[TableResource] = project.list_tables()
+
+                rows = []
+                for table in tables:
+                    row = {
+                        "catalog_name": project.id,
+                        "db_schema_name": table.dataset,
+                        "table_name": table.table,
+                        "table_type": "TABLE",
+                    }
+
+                    if req.include_schema:
+                        open_table = project.table(f"{table.dataset}.{table.table}")
+                        row["table_schema"] = open_table.snapshot().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")
+        datasets = {}
+        for tbl in expr.find_all(exp.Table):
+            # We swap the three-part identifier out for a single identifier
+            # This lets us register a PyArrow Dataset with DuckDB for the query.
+            snapshot = self.open_snapshot(tbl)
+            name = snapshot.table.table_id
+            datasets[name] = snapshot.to_dataset()
+            tbl.replace(exp.table_(table=name))
+
+        try:
+            import duckdb
+        except ImportError:
+            raise FlightError("DuckDB is required for SQL queries.")
+
+        try:
+            # Create a DuckDB connection and register the datasets
+            conn = duckdb.connect()
+            for name, dataset in datasets.items():
+                conn.register(name, dataset)
+            sql = conn.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()