pyspiral 0.8.9__cp311-abi3-macosx_11_0_arm64.whl

pyspiral-0.8.9.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: pyspiral
+Version: 0.8.9
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+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: pyarrow>=21.0.0
+Requires-Dist: pydantic-settings>=2.3.4
+Requires-Dist: pydantic[email]>=2.12.4,<2.13
+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: pyiceberg[s3fs]>=0.9.1 ; extra == 'iceberg'
+Requires-Dist: datasets>=4.0.0 ; extra == 'huggingface'
+Requires-Dist: mosaicml-streaming>=0.13.0 ; extra == 'streaming'
+Requires-Dist: vortex-data>=0.52.1 ; extra == 'streaming'
+Requires-Dist: dask>=2025.10.0 ; extra == 'dask'
+Requires-Dist: distributed>=2025.10.0 ; extra == 'dask'
+Provides-Extra: polars
+Provides-Extra: duckdb
+Provides-Extra: iceberg
+Provides-Extra: huggingface
+Provides-Extra: streaming
+Provides-Extra: dask
+Summary: Python client for Spiral.
+Home-Page: https://spiraldb.com
+Author-email: SpiralDB <hello@spiraldb.com>
+License: Proprietary License
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# PySpiral
+

pyspiral-0.8.9.dist-info/RECORD

@@ -0,0 +1,114 @@
+pyspiral-0.8.9.dist-info/METADATA,sha256=Ti8e0-xOdp5VUMbJ8X30eLyH-tkaPi-9MdG0DDWLZuI,1953
+pyspiral-0.8.9.dist-info/WHEEL,sha256=wLM-4-OuCEmDufFmMnL4mT6DsF8lSbFPkcIGjsPxDb0,104
+pyspiral-0.8.9.dist-info/entry_points.txt,sha256=R96Y3FpYX6XbQu9qMPfUTgiCcf4qM9OBQQZTDdBkZwA,74
+spiral/__init__.py,sha256=PwaYBWFBtB7cYi7peMmhk_Lm5XzjRoLwOtLbUhc1ZDo,1449
+spiral/_lib.abi3.so,sha256=EA4kgWe6pzgxACe8OELMyZfscv2wOE8ADrPk0CikrZ0,80996768
+spiral/adbc.py,sha256=Mc2wdC_fqvE4jqlgHqCI7M9Y-jRH4SaAjxJMibmIvbc,14854
+spiral/api/__init__.py,sha256=XlDdWLyEfnK3FRyYaA02JN91890QYpcPnyvilz9XcTk,2140
+spiral/api/admin.py,sha256=A1iVR1XYJSObZivPAD5UzmPuMgupXc9kaHNYYa_kwfs,585
+spiral/api/client.py,sha256=v1_FD46Hy4XMAUGfoNBcbnqwRX10WfkTpPQfVsLkozM,4665
+spiral/api/filesystems.py,sha256=8g_YdFjFFZLybQqV1xSH91SxVvOer4O6sGECexWXRnw,4548
+spiral/api/key_space_indexes.py,sha256=-38rZXTdkL4mLhp9h3CtqyIyutzzq88tV6bhK05MqYE,640
+spiral/api/organizations.py,sha256=eXAzxrKPmd3IVFfEaEbqbhqG0AjBM4IDz3O-ZoxJI5w,1928
+spiral/api/projects.py,sha256=j2sYhhh_Q3Pk9MBukb8pQgKN2JP00RKyDYdAcgLbmtw,6357
+spiral/api/telemetry.py,sha256=tfdA3E_EWJwFVxkQfkm8tiYGRubnx2LuE5nbfsk1oG4,474
+spiral/api/text_indexes.py,sha256=_zVlGBytl-9-Unbu2POfZgLh40H1YRcagFtplgIG428,1828
+spiral/api/types.py,sha256=HpHsoBuf7IdlXb7Dw-BkBkEvxBVIhkI8JviqhuoP9pY,696
+spiral/api/workers.py,sha256=0wZNUHMioDT53P1OBJfpjyDfIodHwwT6858z2IlRIM4,636
+spiral/api/workloads.py,sha256=GBZ4tLa_-NtZvV-P5GTJgPSxBQ_YiLyWaOpr9ELojOo,1764
+spiral/arrow_.py,sha256=fUpXmjUjG-rGfqMhKR332QzC7zrfIU2yjLaWKYzefwU,6778
+spiral/cli/__init__.py,sha256=GdTQZVArIw19zSKi92ZtwD8pXQExuubnaN854XLTSzY,2505
+spiral/cli/__main__.py,sha256=kNaKM2xgJo7GRogf83nYldLM-RGUR6vymdGwZxywQu0,71
+spiral/cli/admin.py,sha256=sC_XUZvi7t91qHMR5vea_KD3lXUcygil1MUw7zVFmpE,945
+spiral/cli/app.py,sha256=nNDoMxnGCJIiaD8PMDqSL2rK_QErmtZGOGHT4V29CRA,2825
+spiral/cli/console.py,sha256=6JHbAQV6MFWz3P-VzqPOjhHpkIQagsCdzTMvmuDKMkU,2580
+spiral/cli/fs.py,sha256=Swawf9oPQjL0NOE-sB96xtK7G6hhfTu8q9XxSwflSQw,4173
+spiral/cli/iceberg.py,sha256=wdMyl0j821MLnXNZ6Kwm65ogh98C-pjMJm3Y6YqlnTI,3249
+spiral/cli/key_spaces.py,sha256=84MibTdjI5bFK7lhL0w1WOlw-uBZtFnPPlTQuI2PPGw,3524
+spiral/cli/login.py,sha256=2l2i38XNHGKtV4DP6PZPN4LHxceCn3AdHDE5nM2iK5M,760
+spiral/cli/orgs.py,sha256=QHvpUQrKqaNC99efa8v0l-bg38aJCE6m7N9LU6VmMlc,2537
+spiral/cli/printer.py,sha256=HcvSUpaMItzmhBUfIHROK1Z3SL8J8wDopS3Qo8H00uw,1781
+spiral/cli/projects.py,sha256=2d-um9qlX9TK7ehvDUq5hUTsqvj-4S9DoL_h5U111-Y,5802
+spiral/cli/state.py,sha256=3sKQuFtV2vCn3E1Dv7Sw9-IK5jiXCVBEQ9Ze17NZXDs,129
+spiral/cli/tables.py,sha256=JnTJbHzUC48SOeb8sgzj8dfpR67y4eTTdg7T5fEZzAs,7914
+spiral/cli/telemetry.py,sha256=9kp7lmimShsGoLRUic5aOEQ4hti-pPFMBFc4cdlPDmk,587
+spiral/cli/text.py,sha256=DlWGe4JrkdERAiqyITNpk91Wqb63Re99rNYlIFsIamc,4031
+spiral/cli/types.py,sha256=0Zau84chh3XGIdFYqzC3LvgRtY8Ljw7WnKpzvjQ45SA,1360
+spiral/cli/workloads.py,sha256=r6f5y_MTPW460wpd50hC4BkFrg7WM4NOqUkgEI4Vg-U,2997
+spiral/client.py,sha256=UGFYteCv02_8vt46N3dC_nGNxHeJ6feUhKPLvuidg-4,9918
+spiral/core/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/core/_tools/__init__.pyi,sha256=b2KLfTOQ67pjfbYt07o0IGiTu5o2bZw69lllV8v0Dps,143
+spiral/core/authn/__init__.pyi,sha256=deZvPlCyiPC6PpXxpEZVglxL5mUJ1Qqg20ieEQgU6ik,582
+spiral/core/client/__init__.pyi,sha256=CxoshdsdmaEff7eoBf1eWMNMqNw6PfQKgy0QVzjSwKg,7395
+spiral/core/config/__init__.pyi,sha256=1BaB7fTGly_fW-qTSQtxbGrYErzkqxuJokDFPupP7d0,955
+spiral/core/expr/__init__.pyi,sha256=3HSKjkotiEkxBvGBALXEBIie0JiyI9bCpehwA3nMQkU,571
+spiral/core/expr/images/__init__.pyi,sha256=wnE_wZXq7a4iqTg3SVm-ssxGw1WQZyk5dGOPaP4Btko,73
+spiral/core/expr/list_/__init__.pyi,sha256=Q_9c87eIQfZbqlaw_rq3fvs93YEsW7K5VYk6VZ4g6mU,126
+spiral/core/expr/pushdown/__init__.pyi,sha256=zcpBHFz-uriK0WccBUrPOuR8Mi8jPzEzpv9kGpp_PRw,60
+spiral/core/expr/refs/__init__.pyi,sha256=nZZP3l_Z6bLx6V8lTcH3Jgo--xwfADOU2XdTAvM5IMk,127
+spiral/core/expr/s3/__init__.pyi,sha256=GlgT6HtRqNbf31enHhkoM6HXHHxlgic7mApob_R3tOQ,76
+spiral/core/expr/str_/__init__.pyi,sha256=Bm6fZK-d4fNbJuuBhVoWMACXUbQQ2SjlhgrOpdOHIPM,86
+spiral/core/expr/struct_/__init__.pyi,sha256=MXckd98eV_x3X0RhEWvlkA3DcDXRtLs5pNnTQkc09nE,296
+spiral/core/expr/text/__init__.pyi,sha256=ed83n1xcsGY7_QDhMmJGnSQ20UrJFXcdv1AveSEcS1c,175
+spiral/core/expr/udf/__init__.pyi,sha256=zsZs081KVhY3-1JidqTkWMW81Qd_ScoTGZvasIhIK-4,358
+spiral/core/expr/video/__init__.pyi,sha256=nQJEcSsigZuRpMjkI_O4EEtMK_n2zRvorcL_KEeD5vU,95
+spiral/core/table/__init__.pyi,sha256=_BvwxwaTxILYTh2O5nDGpx23gqv3rxh-awNbDWsPKU0,4600
+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=839FNXvUS1PD-jYx2pXIIlTEjKszZUGfVD7WKSpflIQ,5659
+spiral/dataloader.py,sha256=FAaV_B3HTH_gz2FQDDG_5gLjQYR3jScgyHaOa8fSoQk,10766
+spiral/dataset.py,sha256=xse0evrNDKPXNrqaS5ZklyvPsrTPaFov5A2uwwMd9sU,8429
+spiral/datetime_.py,sha256=elXaUWtZuuLVcu9E0aXnvYRPB9XWqZbLDToozQYQYjU,950
+spiral/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spiral/debug/manifests.py,sha256=IJjF5mqpTUeTLpSQ10PBn0DnkkNvPl0c1ghN-7s3PMI,3999
+spiral/debug/metrics.py,sha256=_B1LoHejOQk7sfKX1dhVmHrcB3HNZzhr2M4iQfsyOUQ,2058
+spiral/debug/scan.py,sha256=bYLY4nZNdo0cv7Ldcy3hkXix3aFClHOCG6QbOtn8954,9549
+spiral/demo.py,sha256=YXjKAlxetzpZ9g3rEP0E9fa1bngWtaVicrECZa7IdTg,3173
+spiral/enrichment.py,sha256=DpnCtKcdqwvogCu3ReR1iDktSQqA_GOXXLTzvHKb64w,10713
+spiral/expressions/__init__.py,sha256=ZsD8g7vB0G7xy19GUiH4m79kw7KEkTQRwJl5Gn1cgtw,8049
+spiral/expressions/base.py,sha256=ooTtXy5QkCmPNMYa7lJuFAguFpBrd59UWIxOGxhQ5h0,6261
+spiral/expressions/file.py,sha256=7D9jIENJcoT0KFharBLkzK9dZgO4DYn5K_KCt0twefg,518
+spiral/expressions/http.py,sha256=OOHh0WBxg3vwza_m74-rkoQWSclRMI60aPAbQ6yKZi0,486
+spiral/expressions/list_.py,sha256=-OHzTkTYvTY_Q2IuATfK5QNx7KEyic3DzZLEYn8otIk,2050
+spiral/expressions/pushdown.py,sha256=6ZHke34_YLFYiqp14tXIRWH3K2yVHADeNiRDY_tF5N8,371
+spiral/expressions/s3.py,sha256=PhQhMP-d8PLsSRtGCZbytnm7lI9VbDAbuSs2LBM4G7Q,505
+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=B1N6ck1-CcIPSU9_Vnol7fXNnTbhV1CnMxvtAG5wmx0,7979
+spiral/expressions/udf.py,sha256=XhePtyzrMgX0SQ5mOmf2XrdkhN7BSyyZpLZtF862B1U,2046
+spiral/grpc_.py,sha256=f3czdP1Mxme42Y5--a5ogYq1TTiWn-J_MlGjwJ2mWwM,1015
+spiral/iceberg.py,sha256=02OkA348eFxkEbgreeTuVlzavVvZmM4hldrZI76PZ9I,914
+spiral/iterable_dataset.py,sha256=Eekg9ad8tcwXcloHWReBbvCSr5ZappRHn2ldKTvwqS0,4622
+spiral/key_space_index.py,sha256=NAB_nONEjpMYbse8suz42w7Qb5OPHuKN9h9CT2NJe08,1460
+spiral/project.py,sha256=bUqfROIouk_2WSZXc8DPbFwJuzPac8ucxOM7qHpw6gE,8796
+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=PNjoY_GpjbdAQxXFXLNsB-P8Q1d_GLgQ_1whXvgpC_k,14268
+spiral/server.py,sha256=Q1FcOAV0EsDespdBJI25R5K2mihP_i1xNRe99SYUhsY,1401
+spiral/settings.py,sha256=zeiEhWC2H94r3o5-jsOqSIHu-hthRYO48ShWnXvGrQ8,895
+spiral/snapshot.py,sha256=nf0ywmFy1Z2v6NCDBKBzfwmht5nGqWv2V_BifP_Q6Ag,1995
+spiral/streaming_/__init__.py,sha256=s7MlW2ERsuZmZGExLFL6RcZon2e0tNBocBg5ANgki7k,61
+spiral/streaming_/reader.py,sha256=tl_lC9xgh1-QFhsZn4xQT7It3PVTzHCEUT2BG2dWBRQ,4166
+spiral/streaming_/stream.py,sha256=efqhExky4YgI1f3Me5ctfayFbTExoyS3TRMkrPIjvv0,5918
+spiral/substrait_.py,sha256=AKeOD4KIXvz2J4TYxnIneOiHddtBIyOhuNxVO_uH0eg,12592
+spiral/table.py,sha256=vRgNRvKld1kdCTpHgHNcb1VcRXyWZ-2O-3iRUGFIGkU,8031
+spiral/text_index.py,sha256=FQ9rgIEGLSJryS9lFdMhKtPFey18BXoWbPXyvZPJJ04,442
+spiral/transaction.py,sha256=rifPjzGsLl2hdoQmFMSGI049EWr7yNh1PnTvvohZU6Y,5418
+spiral/types_.py,sha256=W_jyO7F6rpPiH69jhgSgV7OxQZbOlb1Ho3InpKUP6Eo,155
+pyspiral-0.8.9.dist-info/RECORD,,

pyspiral-0.8.9.dist-info/WHEEL

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

pyspiral-0.8.9.dist-info/entry_points.txt

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

spiral/__init__.py

@@ -0,0 +1,55 @@
+"""Python client for Spiral"""
+
+import importlib
+import os
+import warnings
+
+# 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.enrichment import Enrichment  # 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",
+    "Enrichment",
+    "Scan",
+    "Shard",
+    "ShuffleConfig",
+    "TextIndex",
+    "KeySpaceIndex",
+    "SpiralDataLoader",
+    "World",
+    "Iceberg",
+]
+
+__version__ = importlib.metadata.version("pyspiral")
+
+
+def _warn_msg():
+    warnings.warn(
+        "Spiral does not support forking, and it may cause undefined behavior. \
+            Please use `spawn` or `forkserver` multiprocessing."
+    )
+
+
+if hasattr(os, "register_at_fork"):
+    os.register_at_fork(before=_warn_msg)

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_arrow_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_arrow_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()