instructure-pysqlsync 0.8.5.dev0__py3-none-any.whl

pysqlsync/dialect/delta/engine.py

@@ -0,0 +1,18 @@
+from pysqlsync.base import BaseConnection, BaseEngine, BaseGenerator, Explorer
+
+from .generator import DeltaGenerator
+
+
+class DeltaEngine(BaseEngine):
+    @property
+    def name(self) -> str:
+        return "delta"
+
+    def get_generator_type(self) -> type[BaseGenerator]:
+        return DeltaGenerator
+
+    def get_connection_type(self) -> type[BaseConnection]:
+        raise NotImplementedError()
+
+    def get_explorer_type(self) -> type[Explorer]:
+        raise NotImplementedError()

pysqlsync/dialect/delta/generator.py

@@ -0,0 +1,74 @@
+import datetime
+import ipaddress
+import uuid
+
+from strong_typing.auxiliary import float32, float64
+from strong_typing.core import JsonType
+
+from pysqlsync.base import BaseGenerator, GeneratorOptions
+from pysqlsync.formation.mutation import Mutator
+from pysqlsync.formation.py_to_sql import (
+    ArrayMode,
+    DataclassConverter,
+    DataclassConverterOptions,
+    EnumMode,
+    NamespaceMapping,
+    StructMode,
+)
+from pysqlsync.model.data_types import SqlVariableCharacterType
+from pysqlsync.util.typing import override
+
+from .data_types import (
+    DeltaDoubleType,
+    DeltaFixedBinaryType,
+    DeltaRealType,
+    DeltaTimestampType,
+    DeltaVariableCharacterType,
+)
+from .object_types import DeltaObjectFactory
+
+
+class DeltaGenerator(BaseGenerator):
+    "Generator for Delta Lake on Databricks."
+
+    converter: DataclassConverter
+
+    def __init__(self, options: GeneratorOptions) -> None:
+        super().__init__(
+            options,
+            DeltaObjectFactory(),
+            Mutator(options.synchronization),
+        )
+
+        self.check_enum_mode(matches=EnumMode.CHECK)
+        self.check_struct_mode(exclude=[StructMode.TYPE])
+
+        self.converter = DataclassConverter(
+            options=DataclassConverterOptions(
+                enum_mode=options.enum_mode or EnumMode.CHECK,
+                struct_mode=options.struct_mode or StructMode.INLINE,
+                array_mode=options.array_mode or ArrayMode.ARRAY,
+                namespaces=NamespaceMapping(options.namespaces),
+                check_constraints=False,
+                foreign_constraints=False,
+                initialize_tables=options.initialize_tables,
+                substitutions={
+                    datetime.datetime: DeltaTimestampType(),
+                    float: DeltaDoubleType(),
+                    float32: DeltaRealType(),
+                    float64: DeltaDoubleType(),
+                    str: DeltaVariableCharacterType(),
+                    uuid.UUID: DeltaFixedBinaryType(16),
+                    JsonType: SqlVariableCharacterType(),
+                    ipaddress.IPv4Address: DeltaFixedBinaryType(4),
+                    ipaddress.IPv6Address: DeltaFixedBinaryType(16),
+                },
+                factory=self.factory,
+                skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
+            )
+        )
+
+    @override
+    def placeholder(self, index: int) -> str:
+        return f":{index}"

pysqlsync/dialect/delta/object_types.py

@@ -0,0 +1,87 @@
+import re
+from typing import Optional
+
+from pysqlsync.formation.object_types import Column, Namespace, ObjectFactory, Table
+from pysqlsync.model.id_types import LocalId
+
+_sql_quoted_str_table = str.maketrans(
+    {
+        "\\": "\\\\",
+        "'": "\\'",
+        '"': '\\"',
+        "\0": "\\0",
+        "\b": "\\b",
+        "\n": "\\n",
+        "\r": "\\r",
+        "\t": "\\t",
+        "\u001a": "\\Z",
+    }
+)
+
+
+def sql_quoted_string(text: str) -> str:
+    if re.search(r"[\\'\"\0\b\n\r\t\u001A]", text):
+        text = text.translate(_sql_quoted_str_table)
+    return f"'{text}'"
+
+
+class DeltaTable(Table):
+    def create_stmt(self) -> str:
+        defs: list[str] = []
+        defs.extend(str(c) for c in self.columns.values())
+        defs.append(self.create_keys())
+        definition = ",\n".join(defs)
+        comment = f"\nCOMMENT {sql_quoted_string(self.description)}" if self.description else ""
+        return f"CREATE TABLE {self.name} (\n{definition}\n){comment};"
+
+    @property
+    def primary_key_constraint_id(self) -> LocalId:
+        return LocalId(f"pk_{self.name.local_id.replace('.', '_')}")
+
+
+class DeltaColumn(Column):
+    @property
+    def data_spec(self) -> str:
+        nullable = " NOT NULL" if not self.nullable and not self.identity else ""
+        identity = " GENERATED BY DEFAULT AS IDENTITY" if self.identity else ""
+        description = f" COMMENT {self.comment}" if self.description is not None else ""
+
+        # DEFAULT requires TBLPROPERTIES ('delta.feature.allowColumnDefaults' = 'enabled')
+        # default = f" DEFAULT {self.default}" if self.default is not None else ""
+
+        return f"{self.data_type}{nullable}{identity}{description}"
+
+    @property
+    def comment(self) -> Optional[str]:
+        if self.description is not None:
+            return sql_quoted_string(self.description)
+        else:
+            return None
+
+
+class DeltaNamespace(Namespace):
+    def create_schema_stmt(self) -> Optional[str]:
+        if self.name.local_id:
+            return f"CREATE SCHEMA IF NOT EXISTS {self.name};"
+        else:
+            return None
+
+    def drop_schema_stmt(self) -> Optional[str]:
+        if self.name.local_id:
+            return f"DROP SCHEMA IF EXISTS {self.name} CASCADE;"
+        else:
+            return None
+
+
+class DeltaObjectFactory(ObjectFactory):
+    @property
+    def column_class(self) -> type[Column]:
+        return DeltaColumn
+
+    @property
+    def table_class(self) -> type[Table]:
+        return DeltaTable
+
+    @property
+    def namespace_class(self) -> type[Namespace]:
+        return DeltaNamespace

pysqlsync/dialect/mssql/README.md

@@ -0,0 +1,23 @@
+# Microsoft SQL Server dialect for pysqlsync
+
+## Testing
+
+Follow the steps of [running a SQL Server Linux container image with Docker](https://learn.microsoft.com/en-us/sql/linux/quickstart-install-connect-docker?view=sql-server-ver16&pivots=cs1-bash) to start testing with Microsoft SQL Server in a Linux/MacOS environment.
+
+Specifically, pull the Docker image with the command:
+```sh
+docker pull mcr.microsoft.com/mssql/server:2022-latest
+```
+
+Next, start the Docker container with the command:
+
+```sh
+docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=<?YourStrong@Passw0rd>" -p 1433:1433 --name sql1 --hostname sql1 -d mcr.microsoft.com/mssql/server:2022-latest
+```
+
+In order to inspect database startup logs, run:
+```sh
+docker logs sql1
+```
+
+Finally, run unit and integration tests.

pysqlsync/dialect/mssql/connection.py

@@ -0,0 +1,146 @@
+import logging
+import typing
+from typing import Iterable, Optional, TypeVar
+
+import pyodbc
+from strong_typing.inspection import is_dataclass_type
+
+from pysqlsync.base import BaseConnection, BaseContext, DataSource, RecordType
+from pysqlsync.formation.object_types import Table
+from pysqlsync.model.data_types import quote
+from pysqlsync.model.id_types import LocalId, QualifiedId
+from pysqlsync.resultset import resultset_unwrap_object, resultset_unwrap_tuple
+from pysqlsync.util.dispatch import thread_dispatch
+from pysqlsync.util.typing import override
+
+from .data_types import sql_to_odbc_type
+
+T = TypeVar("T")
+
+LOGGER = logging.getLogger("pysqlsync.mssql")
+
+
+class MSSQLConnection(BaseConnection):
+    """
+    Represents a connection to a Microsoft SQL Server.
+    """
+
+    native: pyodbc.Connection
+
+    @override
+    @thread_dispatch
+    def open(self) -> BaseContext:
+        LOGGER.info("connecting to %s", self.params)
+        params: dict[str, Optional[str]] = {
+            "DRIVER": "{ODBC Driver 18 for SQL Server}",
+            "APP": "pysqlsync",
+            "SERVER": (f"{self.params.host},{self.params.port}" if self.params.port is not None else self.params.host),
+            "UID": self.params.username,
+            "PWD": self.params.password,
+            "LongAsMax": "yes",
+            "TrustServerCertificate": "yes",
+        }
+        if self.params.database is not None:
+            params["DATABASE"] = self.params.database
+        conn_string = ";".join(f"{key}={value}" for key, value in params.items() if value is not None)
+        conn = pyodbc.connect(conn_string)
+        with conn.cursor() as cur:
+            rows = cur.execute("SELECT @@VERSION").fetchall()
+            for row in rows:
+                LOGGER.info(row)
+
+        self.native = conn
+        return MSSQLContext(self)
+
+    @override
+    @thread_dispatch
+    def close(self) -> None:
+        self.native.close()
+
+
+class MSSQLContext(BaseContext):
+    def __init__(self, connection: MSSQLConnection) -> None:
+        super().__init__(connection)
+
+    @property
+    def native_connection(self) -> pyodbc.Connection:
+        return typing.cast(MSSQLConnection, self.connection).native
+
+    @override
+    @thread_dispatch
+    def _execute(self, statement: str) -> None:
+        with self.native_connection.cursor() as cur:
+            cur.execute(statement)
+
+    @override
+    async def _execute_all(self, statement: str, source: DataSource) -> None:
+        async for batch in source.batches():
+            await self._internal_execute_all(statement, batch)
+
+    @override
+    async def _execute_typed(
+        self,
+        statement: str,
+        source: DataSource,
+        table: Table,
+        order: Optional[tuple[str, ...]] = None,
+    ) -> None:
+        async for batch in source.batches():
+            await self._internal_execute_typed(statement, batch, table, order)
+
+    @thread_dispatch
+    def _internal_execute_all(self, statement: str, records: Iterable[RecordType]) -> None:
+        with self.native_connection.cursor() as cur:
+            cur.fast_executemany = True
+            cur.executemany(statement, records)
+
+    @thread_dispatch
+    def _internal_execute_typed(
+        self,
+        statement: str,
+        records: Iterable[RecordType],
+        table: Table,
+        order: Optional[tuple[str, ...]] = None,
+    ) -> None:
+        with self.native_connection.cursor() as cur:
+            cur.fast_executemany = True
+            cur.setinputsizes([sql_to_odbc_type(column.data_type) for column in table.get_columns(order)])
+            cur.executemany(statement, records)
+
+    @override
+    @thread_dispatch
+    def _query_all(self, signature: type[T], statement: str) -> list[T]:
+        with self.native_connection.cursor() as cur:
+            records = cur.execute(statement).fetchall()
+
+            if is_dataclass_type(signature):
+                return resultset_unwrap_object(signature, records)  # type: ignore
+            else:
+                return resultset_unwrap_tuple(signature, records)
+
+    @override
+    async def drop_schema(self, namespace: LocalId) -> None:
+        LOGGER.debug("drop schema: %s", namespace)
+
+        constraints = await self.query_all(
+            tuple[str, str],
+            "SELECT table_name, constraint_name\n"
+            "FROM information_schema.table_constraints\n"
+            f"WHERE constraint_type = 'FOREIGN KEY' AND table_schema = {quote(namespace.id)};",
+        )
+        if constraints:
+            stmts: list[str] = []
+            for constraint in constraints:
+                table_name, constraint_name = constraint
+                stmts.append(f"ALTER TABLE {QualifiedId(namespace.id, table_name)} DROP CONSTRAINT {LocalId(constraint_name)};")
+            await self.execute("\n".join(stmts))
+
+        tables = await self.query_all(
+            str,
+            f"SELECT table_name\nFROM information_schema.tables\nWHERE table_schema = {quote(namespace.id)};",
+        )
+        if tables:
+            table_list = ", ".join(str(QualifiedId(namespace.local_id, table)) for table in tables)
+            await self.execute(f"DROP TABLE IF EXISTS {table_list};")
+
+        await self.execute(f"DROP SCHEMA IF EXISTS {namespace};")

pysqlsync/dialect/mssql/data_types.py

@@ -0,0 +1,113 @@
+import enum
+from typing import Any, Optional
+
+import pyodbc
+
+from pysqlsync.model.data_types import (
+    SqlBooleanType,
+    SqlDataType,
+    SqlDateType,
+    SqlDecimalType,
+    SqlDoubleType,
+    SqlFixedBinaryType,
+    SqlFixedCharacterType,
+    SqlFloatType,
+    SqlIntegerType,
+    SqlRealType,
+    SqlTimestampType,
+    SqlTimeType,
+    SqlVariableBinaryType,
+    SqlVariableCharacterType,
+)
+
+
+class MSSQLBooleanType(SqlBooleanType):
+    def __str__(self) -> str:
+        return "bit"
+
+    def value_to_sql_literal(self, value: Any) -> str:
+        if not isinstance(value, bool):
+            raise TypeError(f"expected: value of type `bool`, got: {type(value)}")
+
+        return "1" if value else "0"
+
+
+class MSSQLEncoding(enum.Enum):
+    UTF8 = "utf-8"
+    UTF16 = "utf-16"
+
+
+class MSSQLVariableCharacterType(SqlVariableCharacterType):
+    encoding: Optional[MSSQLEncoding] = None
+
+    def __init__(self, limit: Optional[int] = None, encoding: Optional[MSSQLEncoding] = None) -> None:
+        super().__init__(limit)
+        self.encoding = encoding
+
+    def __str__(self) -> str:
+        if self.encoding is MSSQLEncoding.UTF16:
+            char_type = "nvarchar"
+        else:
+            char_type = "varchar"
+
+        if self.limit is not None and self.limit > 0 and self.limit != 2147483647:
+            return f"{char_type}({self.limit})"
+        else:
+            return f"{char_type}(max)"
+
+
+class MSSQLDateTimeType(SqlTimestampType):
+    def __init__(self) -> None:
+        self.precision = 7
+
+    def __str__(self) -> str:
+        return "datetime2"
+
+
+def sql_to_odbc_type(data_type: SqlDataType) -> tuple[int, int, int]:
+    """
+    Returns the ODBC data type associated with the SQL data type.
+
+    Passing the right data types to `setinputsizes` eliminates data-based guessing, and can speed up `executemany`
+    by a significant factor.
+    """
+
+    if isinstance(data_type, MSSQLBooleanType):
+        return pyodbc.SQL_BIT, 0, 0
+
+    elif isinstance(data_type, SqlIntegerType):
+        if data_type.width == 1:
+            return pyodbc.SQL_TINYINT, 0, 0
+        elif data_type.width == 2:
+            return pyodbc.SQL_SMALLINT, 0, 0
+        elif data_type.width == 4:
+            return pyodbc.SQL_INTEGER, 0, 0
+        else:
+            return pyodbc.SQL_BIGINT, 0, 0
+
+    elif isinstance(data_type, SqlRealType):
+        return pyodbc.SQL_REAL, 0, 0
+    elif isinstance(data_type, SqlDoubleType):
+        return pyodbc.SQL_DOUBLE, 0, 0
+    elif isinstance(data_type, SqlFloatType):
+        return pyodbc.SQL_FLOAT, data_type.precision or 53, 0
+    elif isinstance(data_type, SqlDecimalType):
+        return pyodbc.SQL_DECIMAL, data_type.precision or 15, data_type.scale or 0
+
+    elif isinstance(data_type, SqlTimestampType):
+        return pyodbc.SQL_TYPE_TIMESTAMP, data_type.precision or 6, 0
+    elif isinstance(data_type, SqlDateType):
+        return pyodbc.SQL_TYPE_DATE, 0, 0
+    elif isinstance(data_type, SqlTimeType):
+        return pyodbc.SQL_TYPE_TIME, data_type.precision or 6, 0
+
+    elif isinstance(data_type, SqlFixedCharacterType):
+        return pyodbc.SQL_CHAR, data_type.limit or 0, 0
+    elif isinstance(data_type, SqlVariableCharacterType):
+        return pyodbc.SQL_VARCHAR, data_type.limit or 0, 0
+    elif isinstance(data_type, SqlFixedBinaryType):
+        return pyodbc.SQL_BINARY, data_type.storage or 0, 0
+    elif isinstance(data_type, SqlVariableBinaryType):
+        return pyodbc.SQL_VARBINARY, data_type.storage or 0, 0
+
+    return pyodbc.SQL_UNKNOWN_TYPE, 0, 0

pysqlsync/dialect/mssql/dependency.py

@@ -0,0 +1,9 @@
+"""
+pysqlsync: Synchronize schema and large volumes of data.
+
+This module defines dependencies required for Microsoft SQL Server.
+
+:see: https://github.com/instructure-internal/pysqlsync
+"""
+
+import pyodbc  # pyright: ignore[reportUnusedImport] # noqa: F401

pysqlsync/dialect/mssql/discovery.py

@@ -0,0 +1,99 @@
+from typing import Optional, Sequence
+
+from pysqlsync.base import BaseContext
+from pysqlsync.formation.data_types import SqlDiscovery, SqlDiscoveryOptions
+from pysqlsync.formation.discovery import AnsiExplorer
+from pysqlsync.formation.object_types import Namespace, Table
+from pysqlsync.model.data_types import quote
+from pysqlsync.model.id_types import LocalId, SupportsQualifiedId
+
+from .data_types import MSSQLBooleanType, MSSQLDateTimeType, MSSQLEncoding, MSSQLVariableCharacterType
+from .object_types import MSSQLColumn, MSSQLDefault, MSSQLObjectFactory
+
+
+class MSSQLExplorer(AnsiExplorer):
+    def __init__(self, conn: BaseContext) -> None:
+        super().__init__(
+            conn,
+            SqlDiscovery(
+                SqlDiscoveryOptions(
+                    substitutions={
+                        "bit": MSSQLBooleanType(),
+                        "datetime": MSSQLDateTimeType(),
+                        "datetime2": MSSQLDateTimeType(),
+                        "nvarchar": MSSQLVariableCharacterType(encoding=MSSQLEncoding.UTF16),
+                        "varchar": MSSQLVariableCharacterType(),
+                        "text": MSSQLVariableCharacterType(),
+                    }
+                )
+            ),
+            MSSQLObjectFactory(),
+        )
+
+    async def get_columns(self, table_id: SupportsQualifiedId) -> Sequence[MSSQLColumn]:
+        plain_columns = await super().get_columns(table_id)
+        identity_columns = await self.conn.query_all(
+            str,
+            "SELECT c.name\n"
+            "FROM sys.schemas AS s\n"
+            "    INNER JOIN sys.tables AS t ON t.schema_id = s.schema_id\n"
+            "    INNER JOIN sys.columns AS c ON c.object_id = t.object_id\n"
+            f"WHERE s.name = {quote(table_id.scope_id or 'dbo')} AND t.name = {quote(table_id.local_id)} AND c.is_identity = 1;",
+        )
+        default_columns = await self.conn.query_all(
+            tuple[str, str, str],
+            "SELECT c.name, d.name, d.definition\n"
+            "FROM sys.schemas AS s\n"
+            "    INNER JOIN sys.tables AS t ON t.schema_id = s.schema_id\n"
+            "    INNER JOIN sys.columns AS c ON c.object_id = t.object_id\n"
+            "    INNER JOIN sys.default_constraints AS d ON d.object_id = c.default_object_id\n"
+            f"WHERE s.name = {quote(table_id.scope_id or 'dbo')} AND t.name = {quote(table_id.local_id)} AND c.default_object_id != 0;",
+        )
+        default_values = {col_name: MSSQLDefault(con_name, expr) for col_name, con_name, expr in default_columns}
+
+        columns: list[MSSQLColumn] = []
+        for col in plain_columns:
+            columns.append(
+                MSSQLColumn(
+                    name=col.name,
+                    data_type=col.data_type,
+                    nullable=col.nullable,
+                    default=default_values.get(col.name.id),
+                    identity=col.name.id in identity_columns,
+                    description=col.description,
+                )
+            )
+
+        return columns
+
+    async def get_namespace_current(self) -> Namespace:
+        return await self._get_namespace()
+
+    async def get_namespace(self, namespace_id: LocalId) -> Namespace:
+        return await self._get_namespace(namespace_id)
+
+    async def _get_namespace(self, namespace_id: Optional[LocalId] = None) -> Namespace:
+        tables: list[Table] = []
+
+        # create namespace using qualified IDs
+        if namespace_id is not None:
+            schema_id = f"SCHEMA_ID({quote(namespace_id.local_id)})"
+        else:
+            schema_id = "SCHEMA_ID()"
+        table_names = await self.conn.query_all(
+            str,
+            f"SELECT name\nFROM sys.tables\nWHERE schema_id = {schema_id} AND is_ms_shipped = 0\nORDER BY name ASC",
+        )
+        if table_names:
+            if namespace_id is not None:
+                scope_id = namespace_id.local_id
+            else:
+                scope_id = None
+
+            for table_name in table_names:
+                table = await self.get_table(self.get_qualified_id(scope_id, table_name))
+                tables.append(table)
+
+            return self.factory.namespace_class(name=LocalId(scope_id or ""), enums=[], structs=[], tables=tables)
+        else:
+            return self.factory.namespace_class()

pysqlsync/dialect/mssql/engine.py

@@ -0,0 +1,20 @@
+from pysqlsync.base import BaseConnection, BaseEngine, BaseGenerator, Explorer
+
+from .connection import MSSQLConnection
+from .discovery import MSSQLExplorer
+from .generator import MSSQLGenerator
+
+
+class MSSQLEngine(BaseEngine):
+    @property
+    def name(self) -> str:
+        return "mssql"
+
+    def get_generator_type(self) -> type[BaseGenerator]:
+        return MSSQLGenerator
+
+    def get_connection_type(self) -> type[BaseConnection]:
+        return MSSQLConnection
+
+    def get_explorer_type(self) -> type[Explorer]:
+        return MSSQLExplorer

pysqlsync/dialect/mssql/generator.py

@@ -0,0 +1,88 @@
+import datetime
+import ipaddress
+import uuid
+from typing import Any, Callable, Optional
+
+from strong_typing.core import JsonType
+
+from pysqlsync.base import BaseGenerator, GeneratorOptions
+from pysqlsync.formation.inspection import is_ip_address_type
+from pysqlsync.formation.object_types import Column
+from pysqlsync.formation.py_to_sql import (
+    ArrayMode,
+    DataclassConverter,
+    DataclassConverterOptions,
+    EnumMode,
+    NamespaceMapping,
+    StructMode,
+)
+from pysqlsync.model.data_types import SqlFixedBinaryType
+from pysqlsync.util.typing import override
+
+from .data_types import MSSQLBooleanType, MSSQLDateTimeType, MSSQLVariableCharacterType
+from .mutation import MSSQLMutator
+from .object_types import MSSQLObjectFactory
+
+
+class MSSQLGenerator(BaseGenerator):
+    """
+    Generator for Microsoft SQL Server (T-SQL).
+
+    Assumes a UTF-8 collation and `SET ANSI_DEFAULTS ON`. UTF-8 collation makes `varchar` store UTF-8 characters.
+    """
+
+    def __init__(self, options: GeneratorOptions) -> None:
+        super().__init__(options, MSSQLObjectFactory(), MSSQLMutator(options.synchronization))
+
+        self.check_enum_mode(exclude=[EnumMode.TYPE, EnumMode.INLINE])
+        self.check_struct_mode(matches=StructMode.JSON)
+        self.check_array_mode(include=[ArrayMode.JSON, ArrayMode.RELATION])
+
+        self.converter = DataclassConverter(
+            options=DataclassConverterOptions(
+                enum_mode=options.enum_mode or EnumMode.RELATION,
+                struct_mode=options.struct_mode or StructMode.JSON,
+                array_mode=options.array_mode or ArrayMode.JSON,
+                namespaces=NamespaceMapping(options.namespaces),
+                foreign_constraints=options.foreign_constraints,
+                initialize_tables=options.initialize_tables,
+                substitutions={
+                    bool: MSSQLBooleanType(),
+                    datetime.datetime: MSSQLDateTimeType(),
+                    str: MSSQLVariableCharacterType(),
+                    uuid.UUID: SqlFixedBinaryType(16),
+                    JsonType: MSSQLVariableCharacterType(),
+                    ipaddress.IPv4Address: SqlFixedBinaryType(4),
+                    ipaddress.IPv6Address: SqlFixedBinaryType(16),
+                },
+                factory=self.factory,
+                skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
+            )
+        )
+
+    @override
+    def get_current_schema_stmt(self) -> str:
+        return "SCHEMA_NAME()"
+
+    @override
+    def placeholder(self, index: int) -> str:
+        return "?"
+
+    @override
+    def get_field_extractor(self, column: Column, field_name: str, field_type: type) -> Callable[[Any], Any]:
+        if field_type is uuid.UUID:
+            return lambda obj: getattr(obj, field_name).bytes
+        elif is_ip_address_type(field_type):
+            return lambda obj: getattr(obj, field_name).packed
+
+        return super().get_field_extractor(column, field_name, field_type)
+
+    @override
+    def get_value_transformer(self, column: Column, field_type: type) -> Optional[Callable[[Any], Any]]:
+        if field_type is uuid.UUID:
+            return lambda field: field.bytes
+        elif is_ip_address_type(field_type):
+            return lambda field: field.packed
+
+        return super().get_value_transformer(column, field_type)