feat: add mssql support (#34)

Author: cofin

.github/workflows/ci.yaml

@@ -35,14 +35,17 @@ jobs:
       fail-fast: true
       matrix:
         python-version: ["3.8", "3.9", "3.10", "3.11"]
-    timeout-minutes: 15
+    timeout-minutes: 30
     defaults:
       run:
         shell: bash
     steps:
       - name: Check out repository
         uses: actions/checkout@v4
 
+      - name: Install Microsoft ODBC Drivers
+        run: sudo ACCEPT_EULA=Y apt-get install msodbcsql18 -y
+
       - uses: pdm-project/setup-pdm@v3
         name: Set up PDM
         with:
@@ -65,6 +68,9 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@v4
 
+      - name: Install Microsoft ODBC
+        run: sudo ACCEPT_EULA=Y apt-get install msodbcsql18 -y
+
       - name: Set up Python
         uses: actions/setup-python@v4
         with:

Makefile

@@ -112,6 +112,10 @@ test-duckdb:
 test-spanner:
 	$(ENV_PREFIX)pytest tests -m='integration and spanner'
 
+.PHONY: test-mssql
+test-mssql:
+	$(ENV_PREFIX)pytest tests -m='integration and mssql'
+
 .PHONY: test-all-databases
 test-all-databases:
 	$(ENV_PREFIX)pytest tests -m='integration and integration'

README.md

@@ -37,9 +37,10 @@ offering features such as:
   - SQLite via [aiosqlite](https://aiosqlite.omnilib.dev/en/stable/) or [sqlite](https://docs.python.org/3/library/sqlite3.html)
   - Postgres via [asyncpg](https://magicstack.github.io/asyncpg/current/) or [psycopg3 (async or sync)](https://www.psycopg.org/psycopg3/)
   - MySQL via [asyncmy](https://github.com/long2ice/asyncmy)
-  - Oracle via [oracledb](https://oracle.github.io/python-oracledb/)
+  - Oracle via [oracledb](https://oracle.github.io/python-oracledb/) (tested on 18c and 23c)
   - Google Spanner via [spanner-sqlalchemy](https://github.com/googleapis/python-spanner-sqlalchemy/)
   - DuckDB via [duckdb_engine](https://github.com/Mause/duckdb_engine>)
+  - Microsoft SQL Server via [pyodbc](https://github.com/mkleehammer/pyodbc>)
 
 ## Usage
 

pdm.lock

@@ -41,7 +41,7 @@ license = {text = "MIT"}
 name = "advanced_alchemy"
 readme = "README.md"
 requires-python = ">=3.8"
-version = "0.1.1"
+version = "0.2.0"
 
 [project.urls]
 Changelog = "https://docs.advanced-alchemy.jolt.rs/latest/changelog"
@@ -71,6 +71,7 @@ dev = [
   "fastapi>=0.103.1",
   "msgspec>=0.18.2",
   "orjson>=3.9.7",
+  "pyodbc>=4.0.39",
 ]
 docs = [
   "sphinx>=7.1.2",
@@ -107,6 +108,32 @@ test = [
   "httpx>=0.24.1",
 ]
 
+[tool.pytest.ini_options]
+addopts = "-m='not integration' --dist=loadgroup"
+asyncio_mode = "auto"
+
+markers = [
+  "integration: SQLAlchemy integration tests",
+  "asyncmy: SQLAlchemy MySQL (asyncmy) Tests",
+  "asyncpg: SQLAlchemy Postgres (asyncpg) Tests",
+  "psycopg_async: SQLAlchemy Postgres (psycopg async) Tests",
+  "psycopg_sync: SQLAlchemy Postgres (psycopg sync) Tests",
+  "aiosqlite: SQLAlchemy SQLite (aiosqlite) Tests",
+  "sqlite: SQLAlchemy SQLite (sqlite) Tests",
+  "oracledb: SQLAlchemy Oracle (oracledb) Tests",
+  "spanner: SQLAlchemy Google Cloud Spanner (sqlalchemy-spanner) Tests",
+  "duckdb: SQLAlchemy DuckDB (duckdb-engine) Tests",
+  "mssql: SQLAlchemy Microsoft SQL Server (pyodbc) Tests",
+]
+
+filterwarnings = [
+  "ignore::DeprecationWarning:pkg_resources.*",
+  "ignore::DeprecationWarning:google.rpc",
+  "ignore::DeprecationWarning:google.gcloud",
+  "ignore::DeprecationWarning:google.iam",
+  "ignore::DeprecationWarning:google",
+]
+
 [tool.black]
 line-length = 120
 
@@ -229,31 +256,6 @@ ruff_fix = true
 SQLAlchemyAsyncRepository = "SQLAlchemySyncRepository"
 "sqlalchemy.ext.asyncio.AsyncSession" = "sqlalchemy.orm.Session"
 
-[tool.pytest.ini_options]
-addopts = "-m='not integration' --dist=loadgroup"
-asyncio_mode = "auto"
-
-markers = [
-  "integration: SQLAlchemy integration tests",
-  "asyncmy: SQLAlchemy MySQL (asyncmy) Tests",
-  "asyncpg: SQLAlchemy Postgres (asyncpg) Tests",
-  "psycopg_async: SQLAlchemy Postgres (psycopg async) Tests",
-  "psycopg_sync: SQLAlchemy Postgres (psycopg sync) Tests",
-  "aiosqlite: SQLAlchemy SQLite (aiosqlite) Tests",
-  "sqlite: SQLAlchemy SQLite (sqlite) Tests",
-  "oracledb: SQLAlchemy Oracle (oracledb) Tests",
-  "spanner: SQLAlchemy Google Cloud Spanner (sqlalchemy-spanner) Tests",
-  "duckdb: SQLAlchemy Duckdb (duckdb-engine) Tests",
-]
-
-filterwarnings = [
-  "ignore::DeprecationWarning:pkg_resources.*",
-  "ignore::DeprecationWarning:google.rpc",
-  "ignore::DeprecationWarning:google.gcloud",
-  "ignore::DeprecationWarning:google.iam",
-  "ignore::DeprecationWarning:google",
-]
-
 [tool.codespell]
 ignore-words-list = "selectin"
 skip = 'pdm.lock, examples/us_state_lookup.json'

pyproject.toml

@@ -59,3 +59,12 @@ services:
       DATABASE_NAME: test-database
     depends_on:
       - spanner
+  mssql:
+    image: mcr.microsoft.com/mssql/server:2022-latest
+    ports:
+      - "1344:1433" # use a non-standard port here
+    environment:
+      SA_PASSWORD: Super-secret1
+      MSSQL_PID: Developer
+      ACCEPT_EULA: Accepted
+      MSSQL_TCP_PORT: 1433

tests/docker-compose.yml

@@ -13,6 +13,7 @@
 import asyncmy
 import asyncpg
 import oracledb
+import pyodbc
 import pytest
 from google.auth.credentials import AnonymousCredentials
 from google.cloud import spanner
@@ -141,7 +142,7 @@ async def mysql_responsive(host: str) -> bool:
 
 @pytest.fixture()
 async def mysql_service(docker_services: DockerServiceRegistry) -> None:
-    await docker_services.start("mysql", check=mysql_responsive)
+    await docker_services.start("mysql", timeout=45, pause=1, check=mysql_responsive)
 
 
 async def postgres_responsive(host: str) -> bool:
@@ -258,3 +259,26 @@ def spanner_responsive(host: str) -> bool:
 async def spanner_service(docker_services: DockerServiceRegistry) -> None:
     os.environ["SPANNER_EMULATOR_HOST"] = "localhost:9010"
     await docker_services.start("spanner", timeout=60, check=spanner_responsive)
+
+
+async def mssql_responsive(host: str) -> bool:
+    await asyncio.sleep(1)
+    try:
+        port = 1344
+        user = "sa"
+        database = "master"
+        conn = pyodbc.connect(
+            connstring=f"encrypt=no; TrustServerCertificate=yes; driver={{ODBC Driver 18 for SQL Server}}; server={host},{port}; database={database}; UID={user}; PWD=Super-secret1",
+            timeout=2,
+        )
+        with conn.cursor() as cursor:
+            cursor.execute("select 1 as is_available")
+            resp = cursor.fetchone()
+            return resp[0] == 1  # type: ignore
+    except Exception:
+        return False
+
+
+@pytest.fixture()
+async def mssql_service(docker_services: DockerServiceRegistry) -> None:
+    await docker_services.start("mssql", timeout=60, pause=1, check=mssql_responsive)

tests/docker_service_fixtures.py

@@ -128,6 +128,27 @@ def psycopg_engine(docker_ip: str, postgres_service: None) -> Engine:
     )
 
 
+@pytest.fixture()
+def mssql_engine(docker_ip: str, mssql_service: None) -> Engine:
+    """MS SQL instance for end-to-end testing."""
+    return create_engine(
+        URL(
+            drivername="mssql+pyodbc",
+            username="sa",
+            password="Super-secret1",
+            host=docker_ip,
+            port=1344,
+            database="master",
+            query={
+                "driver": "ODBC Driver 18 for SQL Server",
+                "encrypt": "no",
+                "TrustServerCertificate": "yes",
+            },  # type:ignore[arg-type]
+        ),
+        poolclass=NullPool,
+    )
+
+
 @pytest.fixture()
 def sqlite_engine(tmp_path: Path) -> Generator[Engine, None, None]:
     """SQLite engine for end-to-end testing.
@@ -188,6 +209,14 @@ def spanner_engine(docker_ip: str, spanner_service: None, monkeypatch: MonkeyPat
                 pytest.mark.xdist_group("postgres"),
             ],
         ),
+        pytest.param(
+            "mssql_engine",
+            marks=[
+                pytest.mark.mssql,
+                pytest.mark.integration,
+                pytest.mark.xdist_group("mssql"),
+            ],
+        ),
         pytest.param(
             "sqlite_engine",
             marks=[

tests/integration/conftest.py

@@ -24,25 +24,25 @@
 
 
 @pytest.fixture()
-async def sync_sqlalchemy_config(engine: Engine, session_maker: sessionmaker[Session]) -> SQLAlchemySyncConfig:
+def sync_sqlalchemy_config(engine: Engine, session_maker: sessionmaker[Session]) -> SQLAlchemySyncConfig:
     return SQLAlchemySyncConfig(engine_instance=engine, session_maker=session_maker)
 
 
 @pytest.fixture()
-async def async_sqlalchemy_config(
+def async_sqlalchemy_config(
     async_engine: AsyncEngine,
     async_session_maker: async_sessionmaker[AsyncSession],
 ) -> SQLAlchemyAsyncConfig:
     return SQLAlchemyAsyncConfig(engine_instance=async_engine, session_maker=async_session_maker)
 
 
 @pytest.fixture(params=[lazy_fixture("sync_sqlalchemy_config"), lazy_fixture("async_sqlalchemy_config")])
-async def alembic_commands(request: FixtureRequest) -> commands.AlembicCommands:
+def alembic_commands(request: FixtureRequest) -> commands.AlembicCommands:
     return commands.AlembicCommands(sqlalchemy_config=request.param)
 
 
 @pytest.fixture
-async def tmp_project_dir(monkeypatch: MonkeyPatch, tmp_path: Path) -> Path:
+def tmp_project_dir(monkeypatch: MonkeyPatch, tmp_path: Path) -> Path:
     path = tmp_path / "project_dir"
     path.mkdir(exist_ok=True)
     monkeypatch.chdir(path)

tests/integration/test_alembic_commands.py

@@ -321,6 +321,14 @@ def first_author_id(raw_authors: RawRecordData) -> Any:
                 pytest.mark.xdist_group("spanner"),
             ],
         ),
+        pytest.param(
+            "mssql_engine",
+            marks=[
+                pytest.mark.mssql,
+                pytest.mark.integration,
+                pytest.mark.xdist_group("mssql"),
+            ],
+        ),
     ],
 )
 def engine(request: FixtureRequest, repository_pk_type: RepositoryPKType) -> Engine:
@@ -926,7 +934,7 @@ async def test_repo_filter_search(author_repo: AuthorRepository) -> None:
     existing_obj = await maybe_async(author_repo.list(SearchFilter(field_name="name", value="GATH", ignore_case=False)))
     # sqlite & mysql are case insensitive by default with a `LIKE`
     dialect = author_repo.session.bind.dialect.name if author_repo.session.bind else "default"
-    expected_objs = 1 if dialect in {"sqlite", "mysql"} else 0
+    expected_objs = 1 if dialect in {"sqlite", "mysql", "mssql"} else 0
     assert len(existing_obj) == expected_objs
     existing_obj = await maybe_async(author_repo.list(SearchFilter(field_name="name", value="GATH", ignore_case=True)))
     assert existing_obj[0].name == "Agatha Christie"
@@ -942,7 +950,7 @@ async def test_repo_filter_not_in_search(author_repo: AuthorRepository) -> None:
     )
     # sqlite & mysql are case insensitive by default with a `LIKE`
     dialect = author_repo.session.bind.dialect.name if author_repo.session.bind else "default"
-    expected_objs = 1 if dialect in {"sqlite", "mysql"} else 2
+    expected_objs = 1 if dialect in {"sqlite", "mysql", "mssql"} else 2
     assert len(existing_obj) == expected_objs
     existing_obj = await maybe_async(
         author_repo.list(NotInSearchFilter(field_name="name", value="GATH", ignore_case=True)),