feat(adapters): add sybase ase and sap sql anywhere dialects, data dictionaries, and adapters

docs/databases/index.md

@@ -20,6 +20,8 @@ SQLSpec supports synchronous and asynchronous **database adapters** spanning emb
 | [`oracledb`](oracledb.md) | `sqlspec[oracledb]` | Sync + Async | `:1` / `:name` | `ConnectionPool` / `AsyncConnectionPool` + DRCP | PyCapsule Batches | Oracle AQ (`DBMS_AQ`) + Table Queue | Sessions + Memory (Oracle 26ai `VECTOR` HNSW, Oracle Text, RRF) |
 | [`mssql_python`](mssql.md) | `sqlspec[mssql-python]` | Sync | `?` (`qmark`) | `MssqlPythonConnectionPool` | Native `BulkCopy` | Table Queue | Sessions + Memory (`LIKE`) |
 | [`pymssql`](mssql.md) | `sqlspec[pymssql]` | Sync | `%(name)s` / `%s` | `PymssqlConnectionPool` | Row | Table Queue | Sessions + Memory (`LIKE`) |
+| [`sybase`](sybase.md) | `sqlspec[sybase]` | Sync | `?` (`qmark`) / `%(name)s` | `SybaseConnectionPool` | Row / Stream | Table Queue | Sessions + Memory (`LIKE`) |
+| [`sqlanywhere`](sqlanywhere.md) | `sqlspec[sqlanywhere]` | Sync | `?` (`qmark`) | `SqlanywhereConnectionPool` | Row / Stream | Table Queue | Sessions + Memory (`LIKE`) |
 | [`db2`](db2.md) | `sqlspec[db2]` | Sync + Async | `?` (`qmark`) | `Db2SyncConnectionPool` / `Db2AsyncConnectionPool` | Schema-Guided Row | Table Queue (`SKIP LOCKED DATA`) | Sessions + Memory (`POSSTR`) |
 | [`duckdb`](duckdb.md) | `sqlspec[duckdb]` | Sync | `?` (`qmark`) | `DuckDBConnectionPool` | Native Zero-Copy | Table Queue | Sessions + Memory (`FTS`, `ARRAY` Cosine) |
 | [`bigquery`](bigquery.md) | `sqlspec[bigquery]` | Sync | `@name` (`named`) | Stateless HTTP/gRPC Client | Storage Read / Write API | Table Queue | Sessions + Memory (`SEARCH` / `LIKE`) |
@@ -35,6 +37,8 @@ SQLSpec supports synchronous and asynchronous **database adapters** spanning emb
 - **[MySQL and MariaDB](mysql.md)**: Side-by-side setup for `asyncmy`, `pymysql`, `aiomysql`, and `mysql-connector-python`, TLS verification, and `LOAD DATA LOCAL INFILE` bulk loading.
 - **[Oracle Database](oracledb.md)**: Thin and Thick modes, mTLS/PKCS#12 wallets, TNS topologies, Oracle 26ai `VECTOR` + Hybrid RRF search, PyCapsule Arrow streaming, and `DBMS_CLOUD.COPY_DATA`.
 - **[Microsoft SQL Server](mssql.md)**: Microsoft's official `mssql-python` driver with streaming Arrow `BulkCopy` alongside FreeTDS `pymssql`.
+- **[SAP Adaptive Server Enterprise](sybase.md)**: Sybase ASE 16.0+ via FreeTDS TDS 5.0 (`pymssql`), transactional DDL behavior, and catalog introspection.
+- **[SAP SQL Anywhere](sqlanywhere.md)**: Embedded and client-server SQL Anywhere 12+ via `sqlanydb`, recursive dependency analysis, and automatic rollback on context exit.
 - **[IBM Db2](db2.md)**: Sync and async DRDA pooling (`Db2SyncConfig` / `Db2AsyncConfig`), savepoint cursor retention, and lowercase column normalization.
 - **[DuckDB](duckdb.md)**: In-process OLAP queries over Parquet/S3, hybrid native/Arrow materialization, and JSON statement profiling.
 - **[Google Cloud BigQuery](bigquery.md)**: Interactive `query_and_wait` execution, Storage Read/Write APIs, reservation governance, and multi-statement script jobs.

docs/databases/sqlanywhere.md

@@ -0,0 +1,53 @@
+# SAP SQL Anywhere
+
+`sqlspec.adapters.sqlanywhere` provides synchronous database connectivity for SAP SQL Anywhere 12+ through the official `sqlanydb` driver (`>= 1.0.14`), offering connection pooling (`SqlanywhereConfig`), custom SQLGlot `sqlanywhere` dialect compilation, recursive foreign-key dependency analysis, and Litestar, Events, and Google ADK session/memory store extensions.
+
+## Install and When to Choose
+
+```bash
+uv add "sqlspec[sqlanywhere]"
+```
+
+- Choose **`SqlanywhereConfig`** for embedded, edge, and client-server applications interacting with SAP SQL Anywhere database engines.
+- `sqlanydb` wraps SAP's native client C library (`dbcapi`) via `ctypes`. Ensure `libdbcapi_r.so` (Linux), `libdbcapi_r.dylib` (macOS), or `dbcapi.dll` (Windows) is installed and available in the system library path.
+
+## Minimal Connection and Pool Setup
+
+```python
+from sqlspec import SQLSpec
+from sqlspec.adapters.sqlanywhere import SqlanywhereConfig
+
+spec = SQLSpec()
+config = spec.add_config(
+    SqlanywhereConfig(
+        connection_config={
+            "uid": "dba",
+            "pwd": "sql",
+            "eng": "demo_server",
+            "dbn": "demo",
+            "host": "localhost:2638",
+        }
+    )
+)
+```
+
+## Key Configuration Parameters
+
+| Setting | Location | Description |
+| --- | --- | --- |
+| `uid` / `user` | `connection_config` | Database user name (default DBA administrative principal). |
+| `pwd` / `password` | `connection_config` | Database user password. |
+| `eng` / `server` | `connection_config` | Running SQL Anywhere database engine name. |
+| `dbn` / `database` | `connection_config` | Target database catalog name. |
+| `host` | `connection_config` | Network host and port string (`host:port`, default port 2638). |
+| `dbf` | `connection_config` | Direct database file path for auto-starting engines. |
+| `pool_recycle_seconds` | `connection_config` | Maximum connection age in seconds before recycling. |
+| `health_check_interval` | `connection_config` | Idle duration in seconds before running ping probes. |
+| `json_serializer` / `json_deserializer` | `driver_features` | Custom JSON serialization/deserialization callables. |
+
+## Dialect and Catalog Notes
+
+- **Automatic Rollback on Context Exit**: SQL Anywhere connections maintain an implicit transaction upon statement execution. `SqlanywhereSessionContext` automatically rolls back uncommitted changes if a session exits with open work or an error, ensuring clean connection return to the pool.
+- **Pagination**: Supports standard suffix `SELECT ... LIMIT n OFFSET m` as well as SQL Anywhere `TOP n START AT (m + 1)` syntax.
+- **Identity Resync**: Fixture seeding supports primary key identity resetting via `CALL sa_reset_identity('<table>', '<schema>', <max_id>)`.
+- **System Catalogs**: Schema discovery queries `SYS.SYSTAB`, `SYS.SYSTABCOL`, `SYS.SYSIDX`, `SYS.SYSIDXCOL`, `SYS.SYSFKEY`, and `SYS.SYSDOMAIN`.

docs/databases/sybase.md

@@ -0,0 +1,82 @@
+# SAP Adaptive Server Enterprise (Sybase ASE)
+
+`sqlspec.adapters.sybase` provides first-class support for SAP Adaptive Server Enterprise (SAP ASE) 16.0+ via `pymssql` (`>= 2.4.4`) over FreeTDS TDS 5.0 wire protocol, featuring connection pooling (`SybaseConfig`), custom SQLGlot `sybase` dialect compilation, system catalog introspection, and Litestar, Events, and Google ADK session/memory store extensions.
+
+## Install and When to Choose
+
+```bash
+uv add "sqlspec[sybase]"
+```
+
+- Choose **`SybaseConfig`** for transactional OLTP applications communicating with SAP ASE database instances.
+- Prebuilt `pymssql` wheels ship statically linked FreeTDS with native TDS 5.0 wire support across Linux, macOS, and Windows.
+- Note: Neither Apache Arrow ADBC nor GizmoData provides native ADBC drivers for SAP ASE, so SQLSpec communicates with ASE directly via FreeTDS TDS 5.0 DB-API connections.
+
+## Connection Setup and Protocol Negotiation
+
+Sybase ASE requires TDS 5.0 protocol negotiation. FreeTDS negotiates TDS 5.0 either when an environment variable `TDSVER=5.0` is set before process start, or when a FreeTDS server section alias is defined in `freetds.conf`:
+
+=== "Environment Variable (`TDSVER=5.0`)"
+
+    ```bash
+    export TDSVER=5.0
+    ```
+
+    ```python
+    from sqlspec import SQLSpec
+    from sqlspec.adapters.sybase import SybaseConfig
+
+    spec = SQLSpec()
+    config = spec.add_config(
+        SybaseConfig(
+            connection_config={
+                "server": "ase.example.internal",
+                "port": 5000,
+                "user": "sa",
+                "password": "secret_password",
+                "database": "app_db",
+                "autocommit": True,
+            }
+        )
+    )
+    ```
+
+=== "FreeTDS Server Alias (`server_alias`)"
+
+    ```python
+    from sqlspec import SQLSpec
+    from sqlspec.adapters.sybase import SybaseConfig
+
+    spec = SQLSpec()
+    config = spec.add_config(
+        SybaseConfig(
+            connection_config={
+                "server_alias": "SYBASE_PROD",
+                "user": "sa",
+                "password": "secret_password",
+                "database": "app_db",
+            }
+        )
+    )
+    ```
+
+## Key Configuration Parameters
+
+| Setting | Location | Description |
+| --- | --- | --- |
+| `server` / `host` | `connection_config` | Database host name or IP address (default port `5000`). |
+| `server_alias` / `freetds_server` | `connection_config` | Section name in `freetds.conf` configured with `tds version = 5.0`. |
+| `database` / `db` | `connection_config` | Target database catalog name. |
+| `user` / `username` | `connection_config` | Authentication login principal. |
+| `password` | `connection_config` | Authentication password credentials. |
+| `autocommit` | `connection_config` | Defaults to `True` to allow DDL execution outside implicit transactions. |
+| `conn_properties` | `connection_config` | Sybase session initialization commands (defaults to quoted identifier and ANSINULL options). |
+| `pool_recycle_seconds` | `connection_config` | Maximum connection age in seconds before recycling (defaults to 24 hours). |
+| `health_check_interval` | `connection_config` | Minimum idle time in seconds before running liveness probes. |
+| `json_serializer` / `json_deserializer` | `driver_features` | Custom JSON text serialization/deserialization callables. |
+
+## Dialect and Catalog Notes
+
+- **Autocommit and DDL in Transactions**: In Sybase ASE, statements like `CREATE TABLE` and `CREATE INDEX` raise error 2762 inside multi-statement transactions unless database option `ddl in tran` is enabled. `SybaseConfig` defaults `autocommit=True` and begins explicit transactions on demand via `driver.begin()`.
+- **Pagination**: Supports both unparenthesized `SELECT TOP n ...` and ANSI SQL pagination `ROWS LIMIT n OFFSET m`.
+- **System Catalogs**: Reflection queries introspect `dbo.sysobjects`, `dbo.syscolumns`, `dbo.sysindexes`, `dbo.sysreferences`, and `dbo.systypes`.

pyproject.toml

@@ -73,7 +73,9 @@ pymssql = ["pymssql"]
 pymysql = ["pymysql"]
 sanic = ["sanic"]
 spanner = ["google-cloud-spanner>=3.64.0"]
+sqlanywhere = ["sqlanydb>=1.0.14"]
 starlette = ["starlette"]
+sybase = ["pymssql"]
 uuid = ["uuid-utils>=0.17.0"]
 
 [dependency-groups]
@@ -156,6 +158,8 @@ pg_textsearch = "sqlspec.dialects.postgres:PGTextSearch"
 pgvector = "sqlspec.dialects.postgres:PGVector"
 spangres = "sqlspec.dialects.spanner:Spangres"
 spanner = "sqlspec.dialects.spanner:Spanner"
+sqlanywhere = "sqlspec.dialects.sybase:SQLAnywhere"
+sybase = "sqlspec.dialects.sybase:Sybase"
 
 [tool.uv]
 exclude-newer = "7 days"
@@ -260,6 +264,9 @@ include = [
   "sqlspec/dialects/db2/_generators.py",           # Db2 custom dialect render hooks
   "sqlspec/dialects/db2/_parsers.py",              # Db2 custom dialect parser hooks
   "sqlspec/dialects/db2/_transforms.py",           # Db2 custom dialect transform helpers
+  "sqlspec/dialects/sybase/_generators.py",        # Sybase and SQL Anywhere custom dialect render hooks
+  "sqlspec/dialects/sybase/_parsers.py",           # Sybase and SQL Anywhere custom dialect parser hooks
+  "sqlspec/dialects/sybase/_transforms.py",        # Sybase and SQL Anywhere custom dialect transform helpers
   "sqlspec/storage/registry.py",                   # Safe storage registry/runtime routing
   "sqlspec/storage/errors.py",                     # Safe storage error normalization
   "sqlspec/storage/_paths.py",                     # Pure storage path handling
@@ -484,6 +491,8 @@ markers = [
   "mysql_connector: marks tests using mysql-connector",
   "pymysql: marks tests using pymysql",
   "psqlpy: marks tests using psqlpy",
+  "sqlanywhere: marks tests using the sqlanywhere adapter",
+  "sybase: marks tests using the sybase adapter",
 ]
 python_files = ["test_*.py"]
 testpaths = ["tests"]
@@ -539,6 +548,8 @@ module = [
   "ibm_db.*",
   "ibm_db_dbi",
   "ibm_db_dbi.*",
+  "sqlanydb",
+  "sqlanydb.*",
   "sqlglot",
   "sqlglot.*",
 ]

sqlspec/adapters/sqlanywhere/__init__.py

@@ -0,0 +1,40 @@
+"""SAP SQL Anywhere adapter for SQLSpec."""
+
+from sqlspec.adapters.sqlanywhere._typing import SqlanywhereConnection, SqlanywhereCursor
+from sqlspec.adapters.sqlanywhere.config import (
+    SqlanywhereConfig,
+    SqlanywhereConnectionParams,
+    SqlanywhereDriverFeatures,
+    SqlanywherePoolParams,
+)
+from sqlspec.adapters.sqlanywhere.core import (
+    DEFAULT_SQLANYWHERE_PORT,
+    build_connection_config,
+    create_mapped_exception,
+    default_statement_config,
+    driver_profile,
+)
+from sqlspec.adapters.sqlanywhere.data_dictionary import SqlanywhereDataDictionary, SqlanywhereSyncDataDictionary
+from sqlspec.adapters.sqlanywhere.driver import SqlanywhereDriver, SqlanywhereExceptionHandler
+from sqlspec.adapters.sqlanywhere.migrations import SqlanywhereSyncMigrationTracker
+from sqlspec.adapters.sqlanywhere.pool import SqlanywhereConnectionPool
+
+__all__ = (
+    "DEFAULT_SQLANYWHERE_PORT",
+    "SqlanywhereConfig",
+    "SqlanywhereConnection",
+    "SqlanywhereConnectionParams",
+    "SqlanywhereConnectionPool",
+    "SqlanywhereCursor",
+    "SqlanywhereDataDictionary",
+    "SqlanywhereDriver",
+    "SqlanywhereDriverFeatures",
+    "SqlanywhereExceptionHandler",
+    "SqlanywherePoolParams",
+    "SqlanywhereSyncDataDictionary",
+    "SqlanywhereSyncMigrationTracker",
+    "build_connection_config",
+    "create_mapped_exception",
+    "default_statement_config",
+    "driver_profile",
+)

sqlspec/adapters/sqlanywhere/_typing.py

@@ -0,0 +1,123 @@
+"""SAP SQL Anywhere adapter type definitions.
+
+This module contains type aliases and classes that are excluded from mypyc
+compilation to avoid ABI boundary issues.
+"""
+
+import contextlib
+from typing import TYPE_CHECKING, Any
+
+from mypy_extensions import mypyc_attr
+
+from sqlspec.utils.module_loader import import_optional_attr
+
+SQLANYDB_MODULE: Any = None
+_DRIVER_CLS: Any = None
+
+
+class SqlanywhereError(Exception):
+    """SAP SQL Anywhere driver exception base."""
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from types import TracebackType
+    from typing import TypeAlias
+
+    from sqlspec.adapters.sqlanywhere.driver import SqlanywhereDriver
+    from sqlspec.core import StatementConfig
+
+    SqlanywhereConnection: TypeAlias = Any
+    SqlanywhereRawCursor: TypeAlias = Any
+    SqlanywhereQueryParams: TypeAlias = Any
+
+if not TYPE_CHECKING:
+    SqlanywhereConnection = Any
+    SqlanywhereRawCursor = Any
+    SqlanywhereQueryParams = Any
+
+__all__ = (
+    "SQLANYDB_MODULE",
+    "SqlanywhereConnection",
+    "SqlanywhereCursor",
+    "SqlanywhereError",
+    "SqlanywhereQueryParams",
+    "SqlanywhereRawCursor",
+    "SqlanywhereSessionContext",
+)
+
+
+class SqlanywhereCursor:
+    """Context manager for SQL Anywhere sqlanydb cursor operations."""
+
+    __slots__ = ("connection", "cursor")
+
+    def __init__(self, connection: "SqlanywhereConnection") -> None:
+        self.connection = connection
+        self.cursor: SqlanywhereRawCursor | None = None
+
+    def __enter__(self) -> "SqlanywhereRawCursor":
+        self.cursor = self.connection.cursor()
+        assert self.cursor is not None
+        return self.cursor
+
+    def __exit__(self, *_: Any) -> None:
+        if self.cursor is not None and hasattr(self.cursor, "close"):
+            with contextlib.suppress(Exception):
+                self.cursor.close()
+
+
+@mypyc_attr(allow_interpreted_subclasses=True, native_class=False)
+class SqlanywhereSessionContext:
+    """Sync context manager for SAP SQL Anywhere sessions."""
+
+    __slots__ = (
+        "_acquire_connection",
+        "_connection",
+        "_driver",
+        "_driver_features",
+        "_prepare_driver",
+        "_release_connection",
+        "_statement_config",
+    )
+
+    def __init__(
+        self,
+        acquire_connection: "Callable[[], Any]",
+        release_connection: "Callable[..., Any]",
+        statement_config: "StatementConfig",
+        driver_features: "dict[str, Any]",
+        prepare_driver: "Callable[[SqlanywhereDriver], SqlanywhereDriver]",
+    ) -> None:
+        self._acquire_connection = acquire_connection
+        self._release_connection = release_connection
+        self._statement_config = statement_config
+        self._driver_features = driver_features
+        self._prepare_driver = prepare_driver
+        self._connection: Any = None
+        self._driver: SqlanywhereDriver | None = None
+
+    def __enter__(self) -> "SqlanywhereDriver":
+        global _DRIVER_CLS
+        if _DRIVER_CLS is None:
+            _DRIVER_CLS = import_optional_attr("sqlspec.adapters.sqlanywhere.driver", "SqlanywhereDriver")
+        self._connection = self._acquire_connection()
+        self._driver = _DRIVER_CLS(
+            connection=self._connection, statement_config=self._statement_config, driver_features=self._driver_features
+        )
+        assert self._driver is not None
+        return self._prepare_driver(self._driver)
+
+    def __exit__(
+        self, exc_type: "type[BaseException] | None", exc_val: "BaseException | None", exc_tb: "TracebackType | None"
+    ) -> "bool | None":
+        if self._connection is None:
+            return None
+        try:
+            if self._driver is not None:
+                self._driver._release_open_work()
+        finally:
+            self._release_connection(self._connection)
+            self._connection = None
+            self._driver = None
+        return None

sqlspec/adapters/sqlanywhere/adk/__init__.py

@@ -0,0 +1,5 @@
+"""SAP SQL Anywhere ADK store module."""
+
+from sqlspec.adapters.sqlanywhere.adk.store import SqlanywhereADKConfig, SqlanywhereADKMemoryStore, SqlanywhereADKStore
+
+__all__ = ("SqlanywhereADKConfig", "SqlanywhereADKMemoryStore", "SqlanywhereADKStore")