pgdevkit 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

pgdevkit/backends/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from ..dialect import Dialect, resolve_dialect
+from .base import Backend
+from .mssql import MssqlBackend
+from .postgres import PostgresBackend
+
+_REGISTRY: dict[str, Backend] = {
+    "postgres": PostgresBackend(),
+    "mssql": MssqlBackend(),
+}
+
+
+def get_backend(dialect: str | Dialect = "postgres") -> Backend:
+    """Look up the `Backend` for a dialect name (or an already-resolved
+    `Dialect`). Defaults to postgres."""
+    resolved = resolve_dialect(dialect)
+    return _REGISTRY[resolved.name]
+
+
+__all__ = ["Backend", "MssqlBackend", "PostgresBackend", "get_backend"]

pgdevkit/backends/base.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Protocol
+
+from ..dialect import Dialect
+from ..models import DatabaseSchema
+
+
+class Backend(Protocol):
+    """Introspection + a couple of engine facts, behind one interface.
+
+    CRUD is deliberately NOT part of this protocol -- psycopg's
+    `AsyncConnection` and an MSSQL driver's connection type are unrelated,
+    so a unified `backend.retrieve()`/`backend.insert()` surface would force
+    existing Postgres callers to go through a new indirection just to keep
+    working. Callers that want CRUD import `pgdevkit.db.crud`'s `pg_*`
+    functions or `pgdevkit.db.mssql_crud`'s `mssql_*` functions directly,
+    exactly as `db/crud.py`'s functions are imported today."""
+
+    dialect: Dialect
+
+    def introspect(self, conninfo: str) -> DatabaseSchema: ...
+
+    def complex_helper_factory(self) -> Callable[..., Any] | None:
+        """A `ComplexHelper`-like factory for composite/enum/JSONB columns,
+        or None when the engine has no equivalent (MSSQL)."""
+        ...

pgdevkit/backends/mssql.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ..dialect import MSSQL, Dialect
+from ..models import DatabaseSchema
+
+
+class MssqlBackend:
+    dialect: Dialect = MSSQL
+
+    def introspect(self, conninfo: str) -> DatabaseSchema:
+        # Imported lazily so `import pgdevkit.backends` (and thus
+        # `pgdevkit.cli`) doesn't require mssql-python/the mssql extra to
+        # be installed unless a caller actually asks for the mssql backend.
+        from ..mssql_introspect import introspect_mssql_db
+
+        return introspect_mssql_db(conninfo)
+
+    def complex_helper_factory(self) -> Callable[..., Any] | None:
+        # MSSQL has no composite type, native enum, or first-class JSONB
+        # column type -- there is nothing for a ComplexHelper to adapt.
+        # Every `complex_helper` parameter in db/crud.py (and its
+        # db/mssql_crud.py counterpart) is already Optional, so callers on
+        # this backend simply pass/receive None and every complex-type
+        # branch takes its existing no-op path.
+        return None

pgdevkit/backends/postgres.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ..dialect import POSTGRES, Dialect
+from ..introspect import introspect_db
+from ..models import DatabaseSchema
+
+
+class PostgresBackend:
+    dialect: Dialect = POSTGRES
+
+    def introspect(self, conninfo: str) -> DatabaseSchema:
+        return introspect_db(conninfo)
+
+    def complex_helper_factory(self) -> Callable[..., Any] | None:
+        from ..db.complex_types import ComplexHelper
+
+        return ComplexHelper

pgdevkit/cli.py

@@ -10,10 +10,10 @@ from rich.table import Table
 from rich import box
 
 from . import testdb
+from .backends import get_backend
 from .connection import build_conninfo
 from .diff import DiffKind, compute_diff
 from .fetch_missing import SUBFOLDER, find_missing_objects, layer_folder_for, reconstruct_ddl
-from .introspect import introspect_db
 from .parser import parse_directory
 
 app = typer.Typer(name="pgdb", help="PostgreSQL database schema tools")
@@ -37,9 +37,10 @@ def compare(
         None, "--databricks-instance", help="Lakebase instance name (required for Lakebase hosts)"
     ),
     report_extra_db: bool = typer.Option(False, "--report-extra-db", help="Report objects in DB but not in scripts"),
+    dialect: str = typer.Option("postgres", "--dialect", help="postgres (default) or mssql"),
     scripts_dir: Path = typer.Argument(..., help="Directory containing SQL scripts"),
 ) -> None:
-    """Compare SQL scripts to a live PostgreSQL database and report differences."""
+    """Compare SQL scripts to a live database and report differences."""
     if not scripts_dir.is_dir():
         err_console.print(f"[red]Error:[/red] {scripts_dir} is not a directory")
         raise typer.Exit(2)
@@ -55,13 +56,19 @@ def compare(
         err_console.print(f"[red]Error:[/red] {e}")
         raise typer.Exit(2)
 
+    try:
+        backend = get_backend(dialect)
+    except ValueError as e:
+        err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(2)
+
     with console.status("Parsing SQL scripts..."):
-        scripts_schema = parse_directory(scripts_dir)
+        scripts_schema = parse_directory(scripts_dir, dialect=backend.dialect)
 
     with console.status("Introspecting database..."):
-        db_schema = introspect_db(conninfo)
+        db_schema = backend.introspect(conninfo)
 
-    diffs = compute_diff(scripts_schema, db_schema, report_extra_db=report_extra_db)
+    diffs = compute_diff(scripts_schema, db_schema, report_extra_db=report_extra_db, dialect=backend.dialect)
 
     if not diffs:
         console.print("[green]No differences found.[/green]")
@@ -204,8 +211,10 @@ def testdb_status() -> None:
 
 @testdb_app.command("shell")
 def testdb_shell() -> None:
-    """Drop into psql against this workspace's database."""
-    os.execvp("psql", ["psql", testdb.dsn_for()])
+    """Drop into an interactive shell (psql, or sqlcmd for MSSQL) against
+    this workspace's database."""
+    binary, argv = testdb.shell_argv()
+    os.execvp(binary, argv)
 
 
 @testdb_app.command("clean")

pgdevkit/db/__init__.py

@@ -17,13 +17,14 @@ from .crud import (
     pg_upsert_many_dict,
 )
 from .loader import SqlLoader
-from .model import PostgresTableModel
+from .model import PostgresTableModel, TableModel
 
 __all__ = [
     "ComplexHelper",
     "PgPool",
     "PostgresTableModel",
     "SqlLoader",
+    "TableModel",
     "pg_delete",
     "pg_delete_dict",
     "pg_insert",

pgdevkit/db/model.py

@@ -6,8 +6,10 @@ from typing import Sequence
 from pydantic import BaseModel
 
 
-class PostgresTableModel(BaseModel, ABC):
-    """Base class for models that map 1:1 to a database table/row.
+class TableModel(BaseModel, ABC):
+    """Base class for models that map 1:1 to a database table/row (any
+    engine -- schema/table naming is equally meaningful for Postgres and
+    MSSQL, this base class was never actually Postgres-specific).
 
     Models representing partial results (joins, aggregations, projections)
     should extend `pydantic.BaseModel` directly instead."""
@@ -21,3 +23,8 @@ class PostgresTableModel(BaseModel, ABC):
     @abstractmethod
     def get_primary_key() -> Sequence[str]:
         """Return the primary key column name(s)."""
+
+
+# Backward-compat alias -- this class was named PostgresTableModel before
+# MSSQL support existed; kept so existing imports keep working unchanged.
+PostgresTableModel = TableModel

pgdevkit/db/mssql_crud.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Callable, Mapping, Optional, Sequence, Type, TypeVar
+
+from .mssql_sql import ident, json_encode_values, qualified
+from .model import TableModel
+
+T = TypeVar("T", bound=TableModel)
+
+# `con` below is an mssql-python (github.com/microsoft/mssql-python)
+# connection, but typed as `Any` rather than `mssql_python.Connection` so
+# this module -- and, importantly, the pure `_build_*` query builders
+# below, which have no driver dependency at all -- stays importable (and
+# unit-testable) without the `mssql` extra installed. mssql-python bundles
+# its own ODBC driver, so unlike pyodbc it needs no system driver install;
+# its Connection/Cursor API otherwise mirrors pyodbc's (cursor(), execute(),
+# executemany(), fetchone()/fetchall(), qmark `?` placeholders via a
+# positional params list), which is what `_execute_returning`/`_execute_many`
+# below rely on. `complex_helper` is likewise typed loosely: MSSQL has no
+# ComplexHelper equivalent (see backends/mssql.py), so every caller on this
+# backend passes/receives None here -- the parameter exists purely for
+# signature symmetry with db/crud.py's `pg_*` functions.
+
+
+def _build_retrieve(table_name: tuple[str, str], pks: dict) -> tuple[str, list]:
+    where = " AND ".join(f"{ident(k)} = ?" for k in pks)
+    sql = f"SELECT * FROM {qualified(*table_name)} WHERE {where}"
+    return sql, list(pks.values())
+
+
+def _build_retrieve_many(table_name: tuple[str, str], filters: dict) -> tuple[str, list]:
+    if not filters:
+        return f"SELECT * FROM {qualified(*table_name)}", []
+    where = " AND ".join(f"{ident(k)} = ?" for k in filters)
+    sql = f"SELECT * FROM {qualified(*table_name)} WHERE {where}"
+    return sql, list(filters.values())
+
+
+def _build_insert(table_name: tuple[str, str], data: dict) -> tuple[str, list]:
+    fields = list(data)
+    cols = ", ".join(ident(k) for k in fields)
+    placeholders = ", ".join("?" for _ in fields)
+    sql = f"INSERT INTO {qualified(*table_name)} ({cols}) OUTPUT INSERTED.* VALUES ({placeholders})"
+    return sql, [data[k] for k in fields]
+
+
+def _build_insert_many(table_name: tuple[str, str], fields: Sequence[str]) -> str:
+    cols = ", ".join(ident(k) for k in fields)
+    placeholders = ", ".join("?" for _ in fields)
+    return f"INSERT INTO {qualified(*table_name)} ({cols}) VALUES ({placeholders})"
+
+
+def _build_update(table_name: tuple[str, str], data: dict, primary_keys: Sequence[str]) -> tuple[str, list]:
+    set_fields = [k for k in data if k not in primary_keys]
+    set_clause = ", ".join(f"{ident(k)} = ?" for k in set_fields)
+    where_clause = " AND ".join(f"{ident(pk)} = ?" for pk in primary_keys)
+    sql = f"UPDATE {qualified(*table_name)} SET {set_clause} OUTPUT INSERTED.* WHERE {where_clause}"
+    params = [data[k] for k in set_fields] + [data[pk] for pk in primary_keys]
+    return sql, params
+
+
+def _build_update_many(table_name: tuple[str, str], fields: Sequence[str], primary_keys: Sequence[str]) -> str:
+    set_clause = ", ".join(f"{ident(k)} = ?" for k in fields if k not in primary_keys)
+    where_clause = " AND ".join(f"t.{ident(pk)} = ?" for pk in primary_keys)
+    return f"UPDATE {qualified(*table_name)} SET {set_clause} WHERE {where_clause}"
+
+
+def _build_upsert_merge(table_name: tuple[str, str], data: dict, primary_keys: Sequence[str]) -> tuple[str, list]:
+    """MERGE INTO ... USING (SELECT ? AS col, ...) AS s ON pk = pk WHEN
+    MATCHED THEN UPDATE ... WHEN NOT MATCHED THEN INSERT ... OUTPUT
+    INSERTED.* -- the MSSQL replacement for Postgres's `INSERT ... ON
+    CONFLICT ... DO UPDATE ... EXCLUDED.col`. Structurally different from
+    an upsert-by-string-swap: MERGE is its own statement shape."""
+    fields = list(data)
+    src_cols = ", ".join(f"? AS {ident(k)}" for k in fields)
+    on_clause = " AND ".join(f"t.{ident(pk)} = s.{ident(pk)}" for pk in primary_keys)
+    update_fields = [k for k in fields if k not in primary_keys]
+    insert_cols = ", ".join(ident(k) for k in fields)
+    insert_vals = ", ".join(f"s.{ident(k)}" for k in fields)
+
+    sql = f"MERGE INTO {qualified(*table_name)} AS t USING (SELECT {src_cols}) AS s ON {on_clause} "
+    if update_fields:
+        update_clause = ", ".join(f"t.{ident(k)} = s.{ident(k)}" for k in update_fields)
+        sql += f"WHEN MATCHED THEN UPDATE SET {update_clause} "
+    sql += f"WHEN NOT MATCHED THEN INSERT ({insert_cols}) VALUES ({insert_vals}) OUTPUT INSERTED.*;"
+    return sql, [data[k] for k in fields]
+
+
+def _build_delete(table_name: tuple[str, str], data: dict) -> tuple[str, list]:
+    where_clause = " AND ".join(f"{ident(k)} = ?" for k in data)
+    sql = f"DELETE FROM {qualified(*table_name)} OUTPUT DELETED.* WHERE {where_clause}"
+    return sql, list(data.values())
+
+
+async def _execute_returning(con: Any, sql: str, params: list) -> dict | None:
+    def _run() -> dict | None:
+        cur = con.cursor()
+        try:
+            cur.execute(sql, params)
+            cols = [c[0] for c in cur.description]
+            row = cur.fetchone()
+            return dict(zip(cols, row)) if row is not None else None
+        finally:
+            cur.close()
+
+    return await asyncio.to_thread(_run)
+
+
+async def _execute_many(con: Any, sql: str, param_rows: Sequence[Sequence]) -> None:
+    def _run() -> None:
+        cur = con.cursor()
+        try:
+            cur.executemany(sql, list(param_rows))
+        finally:
+            cur.close()
+
+    await asyncio.to_thread(_run)
+
+
+async def mssql_retrieve(
+    con: Any,
+    data_type: Type[T],
+    pks: dict,
+    *,
+    complex_helper: Any | None = None,
+) -> T | None:
+    """Fetch a single row by primary key(s). MSSQL has no ComplexHelper
+    equivalent (see backends/mssql.py) -- `complex_helper` exists only for
+    signature symmetry with `db.crud.pg_retrieve` and is otherwise unused."""
+    sql, params = _build_retrieve(data_type.get_table_name(), pks)
+    row = await _execute_returning(con, sql, params)
+    return data_type(**row) if row else None
+
+
+async def mssql_retrieve_many(
+    con: Any,
+    data_type: Type[T],
+    filters: dict,
+    *,
+    from_dict: Optional[Callable[[Mapping], T]] = None,
+    complex_helper: Any | None = None,
+) -> Sequence[T]:
+    """Fetch multiple rows matching all filter key=value pairs."""
+    sql, params = _build_retrieve_many(data_type.get_table_name(), filters)
+
+    def _run() -> list[dict]:
+        cur = con.cursor()
+        try:
+            cur.execute(sql, params)
+            cols = [c[0] for c in cur.description]
+            return [dict(zip(cols, row)) for row in cur.fetchall()]
+        finally:
+            cur.close()
+
+    rows = await asyncio.to_thread(_run)
+    fn = from_dict or (lambda d: data_type(**d))
+    return [fn(r) for r in rows]
+
+
+async def mssql_insert(
+    con: Any,
+    table_name: tuple[str, str],
+    data: dict,
+    *,
+    complex_helper: Any | None = None,
+) -> dict[str, Any]:
+    """Insert one row and return the full row (`OUTPUT INSERTED.*`)."""
+    data = json_encode_values(data)
+    sql, params = _build_insert(table_name, data)
+    row = await _execute_returning(con, sql, params)
+    assert row is not None
+    return row
+
+
+async def mssql_insert_many(
+    con: Any,
+    table_name: tuple[str, str],
+    data: Sequence[dict],
+    *,
+    complex_helper: Any | None = None,
+) -> None:
+    """Batch insert -- no OUTPUT, one round-trip via executemany."""
+    if not data:
+        return
+    data = [json_encode_values(row) for row in data]
+    fields = list(data[0])
+    sql = _build_insert_many(table_name, fields)
+    await _execute_many(con, sql, [[row[k] for k in fields] for row in data])
+
+
+async def mssql_update_dict(
+    con: Any,
+    table_name: tuple[str, str],
+    data: dict,
+    primary_keys: Sequence[str],
+) -> dict | None:
+    """Update a row identified by primary_keys. Returns the updated row."""
+    data = json_encode_values(data)
+    sql, params = _build_update(table_name, data, primary_keys)
+    return await _execute_returning(con, sql, params)
+
+
+async def mssql_update(con: Any, data: T, data_type: type[T]) -> dict | None:
+    """Update a typed model instance."""
+    return await mssql_update_dict(con, data_type.get_table_name(), data.model_dump(), data_type.get_primary_key())
+
+
+async def mssql_upsert_dict(
+    con: Any,
+    table_name: tuple[str, str],
+    data: dict,
+    primary_keys: Sequence[str],
+    *,
+    complex_helper: Any | None = None,
+) -> dict:
+    """MERGE-based upsert, returns the row as a dict."""
+    data = json_encode_values(data)
+    sql, params = _build_upsert_merge(table_name, data, primary_keys)
+    row = await _execute_returning(con, sql, params)
+    assert row is not None
+    return row
+
+
+async def mssql_upsert(
+    con: Any, data: T, data_type: type[T], *, complex_helper: Any | None = None
+) -> dict:
+    """Upsert a typed model instance."""
+    return await mssql_upsert_dict(con, data_type.get_table_name(), data.model_dump(), data_type.get_primary_key())
+
+
+async def mssql_upsert_many_dict(
+    con: Any,
+    table_name: tuple[str, str],
+    data: Sequence[dict],
+    primary_keys: Sequence[str],
+    *,
+    must_exist: bool = False,
+    complex_helper: Any | None = None,
+) -> None:
+    """Batch upsert.
+
+    `must_exist=True` switches to a plain UPDATE (no INSERT) matched on
+    `primary_keys` -- for callers that only ever update pre-existing rows
+    and want a missing row to be a silent no-op rather than create one."""
+    if not data:
+        return
+    data = [json_encode_values(row) for row in data]
+    fields = list(data[0])
+    if must_exist:
+        sql = _build_update_many(table_name, fields, primary_keys)
+        non_pk = [k for k in fields if k not in primary_keys]
+        rows = [[row[k] for k in non_pk] + [row[pk] for pk in primary_keys] for row in data]
+        await _execute_many(con, sql, rows)
+    else:
+        # MERGE's USING clause is per-row here (first cut) -- a set-based
+        # multi-row MERGE ... USING (VALUES (...), (...)) is more efficient
+        # but adds real complexity (a dynamic column-count VALUES list);
+        # row-by-row via executemany matches how the must_exist branch above
+        # already works.
+        for row in data:
+            sql, params = _build_upsert_merge(table_name, row, primary_keys)
+
+            def _run() -> None:
+                cur = con.cursor()
+                try:
+                    cur.execute(sql, params)
+                finally:
+                    cur.close()
+
+            await asyncio.to_thread(_run)
+
+
+async def mssql_upsert_many(
+    con: Any, data: Sequence[T], data_type: type[T], *, complex_helper: Any | None = None
+) -> None:
+    await mssql_upsert_many_dict(con, data_type.get_table_name(), [d.model_dump() for d in data], data_type.get_primary_key())
+
+
+async def mssql_delete_dict(con: Any, table_name: tuple[str, str], data: dict) -> dict | None:
+    """Delete by arbitrary key dict, returns the deleted row."""
+    sql, params = _build_delete(table_name, data)
+    return await _execute_returning(con, sql, params)
+
+
+async def mssql_delete(con: Any, data: T, data_type: type[T]) -> T | None:
+    """Delete a typed model instance by its primary key(s)."""
+    pk_dict = {pk: getattr(data, pk) for pk in data_type.get_primary_key()}
+    row = await mssql_delete_dict(con, data_type.get_table_name(), pk_dict)
+    return data_type.model_validate(row) if row else None

pgdevkit/db/mssql_sql.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def ident(name: str) -> str:
+    """Bracket-quote a single identifier, doubling any embedded `]`
+    (T-SQL's escaping rule) -- the mssql-python driver has no
+    `psycopg.sql.Identifier` equivalent, so this is the composable-SQL
+    builder Postgres gets for free, hand-rolled for the one thing it's
+    actually needed for here."""
+    return f"[{name.replace(']', ']]')}]"
+
+
+def qualified(schema: str, table: str) -> str:
+    return f"{ident(schema)}.{ident(table)}"
+
+
+def json_encode_value(value: Any) -> Any:
+    """Serialize a value destined for a `json`-typed (or legacy
+    `nvarchar(max)`-storing-JSON) column to text.
+
+    mssql-python has no auto-serialization for dict/list parameter values --
+    binding one directly raises `TypeError: Unsupported parameter type`
+    (confirmed against mssql-python 1.12.0: its `_map_sql_type` has explicit
+    branches for every scalar Python type but none for dict/list, and SQL
+    Server's native `json` type -- a genuine first-class type in current
+    Azure SQL/SQL Server, unlike the old NVARCHAR(MAX)-plus-OPENJSON()
+    convention -- has no dedicated ODBC type code in this driver either, so
+    it's fetched back as plain `str`, indistinguishable from any other text
+    column). Unlike Postgres, there's no type-registration ambiguity to
+    resolve here (composite type vs jsonb vs plain array all need different
+    handling there): MSSQL has no composite types, so a Python dict/list
+    passed to any MSSQL CRUD call can only sensibly mean "serialize me as
+    JSON text" -- no per-column-type lookup needed on the write side.
+
+    There is deliberately no read-side counterpart: the driver can't tell
+    us which columns are `json`-typed (it reports the same opaque `str` for
+    those as for a plain `nvarchar`), so auto-parsing fetched values back
+    into dict/list would need its own catalog lookup -- a ComplexHelper-like
+    mechanism this backend intentionally doesn't have. Callers that know a
+    column is JSON deserialize it themselves with `json.loads()`."""
+    return json.dumps(value) if isinstance(value, (dict, list)) else value
+
+
+def json_encode_values(data: dict) -> dict:
+    return {k: json_encode_value(v) for k, v in data.items()}

pgdevkit/dialect.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+# Postgres type-name synonyms so scripts-vs-db type comparisons in diff.py
+# are spelling-insensitive (e.g. a script written as "int4" matching a
+# catalog-reported "integer"). Moved here (unchanged) from diff.py so both
+# dialects' tables live next to the Dialect they belong to.
+_POSTGRES_TYPE_SYNONYMS = {
+    "int": "integer", "int4": "integer",
+    "int2": "smallint",
+    "int8": "bigint",
+    "float4": "real",
+    "float8": "double precision",
+    "bool": "boolean",
+    "decimal": "numeric",
+    "varchar": "character varying",
+    "char": "character", "bpchar": "character",
+    "timestamptz": "timestamp with time zone",
+    "timestamp": "timestamp without time zone",
+    "timetz": "time with time zone",
+    "time": "time without time zone",
+    "varbit": "bit varying",
+    "serial": "integer", "serial4": "integer",
+    "smallserial": "smallint", "serial2": "smallint",
+    "bigserial": "bigint", "serial8": "bigint",
+}
+
+# T-SQL's ISO/ODBC synonyms (per Microsoft's documented list) plus the one
+# genuinely deprecated pair (timestamp/rowversion) that scripts still use.
+_MSSQL_TYPE_SYNONYMS = {
+    "integer": "int",
+    "double precision": "float",
+    "national character": "nchar",
+    "national char": "nchar",
+    "national character varying": "nvarchar",
+    "national char varying": "nvarchar",
+    "char varying": "varchar",
+    "binary varying": "varbinary",
+    "numeric": "decimal",
+    "timestamp": "rowversion",
+}
+
+
+@dataclass(frozen=True)
+class Dialect:
+    """A thin wrapper around a sqlglot dialect name plus the handful of
+    other facts that vary between engines and were previously hardcoded
+    throughout parser.py/diff.py/schema.py (default schema, type-name
+    synonyms, enum/composite-type support). Intentionally NOT a
+    reimplementation of anything sqlglot already does — `sqlglot_name` is
+    passed straight through to `sqlglot.parse()`/`.sql(dialect=...)`."""
+
+    name: str
+    sqlglot_name: str
+    default_schema: str
+    type_synonyms: dict[str, str] = field(default_factory=dict)
+    supports_enums: bool = True
+    supports_composites: bool = True
+
+
+POSTGRES = Dialect(
+    name="postgres",
+    sqlglot_name="postgres",
+    default_schema="public",
+    type_synonyms=_POSTGRES_TYPE_SYNONYMS,
+    supports_enums=True,
+    supports_composites=True,
+)
+
+MSSQL = Dialect(
+    name="mssql",
+    sqlglot_name="tsql",
+    default_schema="dbo",
+    type_synonyms=_MSSQL_TYPE_SYNONYMS,
+    supports_enums=False,
+    supports_composites=False,
+)
+
+_REGISTRY = {"postgres": POSTGRES, "mssql": MSSQL}
+
+
+def resolve_dialect(dialect: str | Dialect = "postgres") -> Dialect:
+    """Resolve a dialect name (or an already-resolved `Dialect`) to a
+    `Dialect` instance. Defaults to postgres, matching every caller's
+    default before this module existed."""
+    if isinstance(dialect, Dialect):
+        return dialect
+    try:
+        return _REGISTRY[dialect]
+    except KeyError:
+        raise ValueError(f"Unknown dialect {dialect!r}; expected one of {sorted(_REGISTRY)}") from None