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

pysqlsync/connection.py

@@ -0,0 +1,101 @@
+"""
+pysqlsync: Synchronize schema and large volumes of data.
+
+This module helps create a secure sockets layer (SSL) context.
+
+:see: https://github.com/instructure-internal/pysqlsync
+"""
+
+import enum
+import ssl
+import sys
+from dataclasses import dataclass
+from typing import Optional
+from urllib.parse import quote
+
+if sys.version_info >= (3, 10):
+    import truststore
+else:
+    import certifi
+
+
+@enum.unique
+class ConnectionSSLMode(enum.Enum):
+    # SSL is disabled.
+    disable = "disable"
+
+    # Try SSL first, fallback to non-SSL connection if SSL connection fails.
+    prefer = "prefer"
+
+    # Try without SSL first, then retry with SSL if the first attempt fails.
+    allow = "allow"
+
+    # Force an SSL connection. Certificate verification errors are ignored.
+    require = "require"
+
+    # Force an SSL connection, and verify that the server certificate is issued by a trusted
+    # certificate authority (CA).
+    verify_ca = "verify-ca"
+
+    # Force an SSL connection, verify that the server certificate is issued by a trusted CA,
+    # and that the requested server host name matches that in the certificate.
+    verify_full = "verify-full"
+
+
+def create_context(ssl_mode: ConnectionSSLMode) -> Optional[ssl.SSLContext]:
+    "Creates an SSL context to pass to a database connection object."
+
+    if ssl_mode is ConnectionSSLMode.disable:
+        return None
+    elif ssl_mode is ConnectionSSLMode.prefer or ssl_mode is ConnectionSSLMode.allow or ssl_mode is ConnectionSSLMode.require:
+        ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        return ctx
+    elif ssl_mode is ConnectionSSLMode.verify_ca:
+        if sys.version_info >= (3, 10):
+            ctx = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        else:
+            ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=certifi.where())
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_REQUIRED
+        return ctx
+    elif ssl_mode is ConnectionSSLMode.verify_full:
+        if sys.version_info >= (3, 10):
+            ctx = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        else:
+            ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=certifi.where())
+        ctx.check_hostname = True
+        ctx.verify_mode = ssl.CERT_REQUIRED
+        return ctx
+    else:
+        raise ValueError(f"unsupported SSL mode: {ssl_mode}")
+
+
+@dataclass
+class ConnectionParameters:
+    """
+    Database connection parameters that would typically be encapsulated in a connection string.
+
+    :param host: Database server to connect to.
+    :param port: Port to use for the connection, `None` for default.
+    :param username: User identifier to log in with.
+    :param password: Password to log in with.
+    :param database: Database name to select as default (a.k.a. `USE`).
+    :param ssl: Connection mode for trusted connections.
+    """
+
+    host: Optional[str] = None
+    port: Optional[int] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+    database: Optional[str] = None
+    ssl: Optional[ConnectionSSLMode] = None
+
+    def __str__(self) -> str:
+        host = self.host or "localhost"
+        port = f":{self.port}" if self.port else ""
+        username = f"{quote(self.username, safe='')}@" if self.username else ""
+        database = f"/{quote(self.database, safe='')}" if self.database else ""
+        ssl = f"?ssl={self.ssl.value}" if self.ssl else ""
+        return f"{username}{host}{port}{database}{ssl}"

pysqlsync/data/exchange.py

@@ -0,0 +1,184 @@
+from typing import Any, AsyncIterator, BinaryIO, Callable, Generic, Iterable, Optional, Protocol, TypeVar
+
+from strong_typing.inspection import DataclassInstance, dataclass_fields
+from tsv.helper import AutoDetectParser, Generator
+
+from ..formation.inspection import reference_to_key
+from ..model.properties import get_field_properties
+
+D = TypeVar("D", bound=DataclassInstance)
+
+
+def _get_extractor_fn(field_name: str) -> Callable[[Any], Any]:
+    """
+    Gets the value of a data-class instance attribute.
+
+    Must be a separate function to seal context and avoid re-assignment of `field_name`.
+    """
+
+    return lambda entity: getattr(entity, field_name)
+
+
+class TextWriter(Generic[D]):
+    "Writes data to tab-separated values file."
+
+    generator: Generator
+    stream: BinaryIO
+
+    _extractors: list[Callable[[Any], Any]]
+
+    def __init__(
+        self,
+        stream: BinaryIO,
+        entity_type: type[D],
+        field_mapping: Optional[dict[str, str]] = None,
+    ) -> None:
+        """
+        Initializes a TSV writer.
+
+        :param stream: The file-like object to write to.
+        :param entity_type: The data-class type whose fields to persist.
+        :param field_mapping: A mapping from data-class field names to TSV field names. Defines field order.
+        """
+
+        self.stream = stream
+        self.generator = Generator()
+        self._extractors = []
+
+        if field_mapping is None:
+            field_mapping = {field.name: field.name for field in dataclass_fields(entity_type)}
+
+        for name in field_mapping.keys():
+            self._extractors.append(_get_extractor_fn(name))
+
+        stream.write(b"\t".join(name.encode("utf-8") for name in field_mapping.values()))
+        stream.write(b"\n")
+
+    def write_objects(self, entities: list[D]) -> None:
+        for entity in entities:
+            self.stream.write(self.generator.generate_line(tuple(extractor(entity) for extractor in self._extractors)))
+            self.stream.write(b"\n")
+
+
+def fields_to_types(
+    entity_type: type[DataclassInstance],
+    field_mapping: Optional[dict[str, str]] = None,
+) -> dict[str, type]:
+    """
+    Creates a mapping for a TSV reader.
+
+    :param entity_type: The data-class type whose fields to populate.
+    :param field_mapping: A mapping from data-class field names to TSV field names.
+    """
+
+    if field_mapping is None:
+        field_mapping = {field.name: field.name for field in dataclass_fields(entity_type)}
+
+    return {
+        field_mapping[field.name]: get_field_properties(reference_to_key(field.type, entity_type)).tsv_type
+        for field in dataclass_fields(entity_type)
+    }
+
+
+class TextReader:
+    "Reads data from tab-separated values file."
+
+    stream: BinaryIO
+    parser: AutoDetectParser
+    field_types: tuple[type, ...]
+
+    def __init__(self, stream: BinaryIO, names_to_types: dict[str, type]) -> None:
+        """
+        Initializes a TSV reader.
+
+        :param stream: The file-like object to read from.
+        :param names_to_types: A mapping from field names to TSV field types.
+        """
+
+        self.stream = stream
+        self.names_to_types = names_to_types
+
+        header = stream.readline().rstrip(b"\n")
+
+        self.parser = AutoDetectParser(names_to_types, header)
+        self.field_types = tuple(names_to_types[name] for name in self.parser.columns)
+
+    @property
+    def columns(self) -> tuple[str, ...]:
+        return self.parser.columns
+
+    def read_records(self) -> list[tuple[Any, ...]]:
+        "Reads all records from the file-like object."
+
+        rows: list[tuple[Any, ...]] = []
+        while True:
+            line = self.stream.readline().rstrip(b"\n")
+            if not line:
+                break
+            rows.append(self.parser.parse_line(line))
+        return rows
+
+    def records(self) -> Iterable[tuple[Any, ...]]:
+        "An iterator to records in a file-like object."
+
+        while True:
+            line = self.stream.readline().rstrip(b"\n")
+            if not line:
+                break
+            yield self.parser.parse_line(line)
+
+
+class AsyncBinaryIO(Protocol):
+    async def readline(self, limit: int = -1) -> bytes: ...
+
+
+class AsyncTextReader:
+    "Reads data from tab-separated values file."
+
+    stream: AsyncBinaryIO
+    parser: AutoDetectParser
+    names_to_types: dict[str, type]
+    field_types: tuple[type, ...]
+
+    def __init__(self, stream: AsyncBinaryIO, names_to_types: dict[str, type]) -> None:
+        """
+        Initializes a TSV reader.
+
+        :param stream: The asynchronous file-like object to read from.
+        :param names_to_types: A mapping from field names to TSV field types.
+        """
+
+        self.stream = stream
+        self.names_to_types = names_to_types
+
+    async def read_header(self) -> None:
+        line = await self.stream.readline()
+        header = line.rstrip(b"\n")
+        self.parser = AutoDetectParser(self.names_to_types, header)
+        self.field_types = tuple(self.names_to_types[name] for name in self.parser.columns)
+
+    @property
+    def columns(self) -> tuple[str, ...]:
+        return self.parser.columns
+
+    async def read_records(self) -> list[tuple[Any, ...]]:
+        "Reads all records from the file-like object."
+
+        rows: list[tuple[Any, ...]] = []
+        while True:
+            line = await self.stream.readline()
+            record = line.rstrip(b"\n")
+            if not record:
+                break
+            rows.append(self.parser.parse_line(record))
+        return rows
+
+    async def records(self) -> AsyncIterator[tuple[Any, ...]]:
+        "An asynchronous iterator to records in a file-like object."
+
+        while True:
+            line = await self.stream.readline()
+            record = line.rstrip(b"\n")
+            if not record:
+                break
+            yield self.parser.parse_line(record)

pysqlsync/data/generator.py

@@ -0,0 +1,305 @@
+import datetime
+import decimal
+import enum
+import random
+import string
+import typing
+import uuid
+from ipaddress import IPv4Address, IPv6Address, ip_address
+from socket import AF_INET, AF_INET6, inet_ntop
+from struct import pack
+from typing import Any, Callable, Optional, TypeVar
+
+from strong_typing.auxiliary import IntegerRange, MaxLength, MinLength, Precision
+from strong_typing.inspection import (
+    DataclassInstance,
+    dataclass_fields,
+    get_annotation,
+    is_type_enum,
+    is_type_literal,
+    is_type_union,
+    unwrap_literal_values,
+    unwrap_union_types,
+)
+from strong_typing.serialization import object_to_json
+
+from pysqlsync.formation.inspection import is_struct_type, reference_to_key
+from pysqlsync.model.properties import get_field_properties
+
+T = TypeVar("T")
+E = TypeVar("E", bound=enum.Enum)
+
+
+class DataGeneratorError(RuntimeError):
+    pass
+
+
+def random_bool() -> bool:
+    return random.uniform(0.0, 1.0) > 0.5
+
+
+def random_decimal(significant_digits: int, decimal_digits: int) -> decimal.Decimal:
+    integer_digits = significant_digits - decimal_digits
+    digits: list[str] = []
+    digits.extend(random.choices(string.digits, k=integer_digits))
+    digits.append(".")
+    digits.extend(random.choices(string.digits, k=decimal_digits))
+    return decimal.Decimal("".join(digits))
+
+
+def time_today(time_of_day: datetime.time) -> datetime.datetime:
+    return datetime.datetime.combine(datetime.datetime.today(), time_of_day, time_of_day.tzinfo)
+
+
+def random_datetime(start: datetime.datetime, end: datetime.datetime) -> datetime.datetime:
+    """
+    Returns a random datetime between two datetime objects.
+    """
+
+    delta = end - start
+    seconds = delta.days * 86400 + delta.seconds
+    return start + datetime.timedelta(seconds=random.randrange(seconds))
+
+
+def random_date(start: datetime.date, end: datetime.date) -> datetime.date:
+    """
+    Returns a random date between two date objects.
+    """
+
+    delta = end - start
+    days = delta.days
+    return start + datetime.timedelta(days=random.randrange(days))
+
+
+def random_time(start: Optional[datetime.time] = None, end: Optional[datetime.time] = None) -> datetime.time:
+    """
+    Returns a random time between two time objects.
+    """
+
+    if start is None:
+        start = datetime.time(0, 0, 0, tzinfo=datetime.timezone.utc)
+    if end is None:
+        end = datetime.time(23, 59, 59, tzinfo=datetime.timezone.utc)
+
+    ts_start = time_today(start)
+    ts_end = time_today(end)
+    delta = ts_end - ts_start
+    ts = ts_start + datetime.timedelta(seconds=random.randrange(delta.seconds))
+    return ts.timetz()
+
+
+def random_enum(enum_type: type[E]) -> E:
+    """
+    Chooses an enumeration value randomly out of the possible set of values.
+    """
+
+    values = [e for e in enum_type]
+    return random.choice(values)
+
+
+def shuffled(items: list[T]) -> list[T]:
+    items = items.copy()
+    random.shuffle(items)
+    return items
+
+
+def random_enum_generator(
+    enum_type: type[E],
+    *,
+    count: Optional[int] = None,
+    min_count: Optional[int] = None,
+    max_count: Optional[int] = None,
+) -> Callable[[], list[E]]:
+    values = [e for e in enum_type]
+    if count is not None:
+        if count >= len(values):
+            return lambda: shuffled(values)
+        else:
+            return lambda: shuffled(values)[:count]
+    elif min_count is not None or max_count is not None:
+        min_c = min_count or 0
+        max_c = max_count or 4
+        c = max_c - min_c
+        return lambda: shuffled(values)[: min(min_c + random.randint(0, c), len(values))]
+    else:
+        raise TypeError("invalid parameter combination")
+
+
+def random_ipv4addr() -> IPv4Address:
+    "Creates a random IPv4 address."
+
+    return typing.cast(
+        IPv4Address,
+        ip_address(inet_ntop(AF_INET, pack(">L", random.getrandbits(32)))),
+    )
+
+
+def random_ipv6addr() -> IPv6Address:
+    "Creates a random IPv6 address."
+
+    return typing.cast(
+        IPv6Address,
+        ip_address(inet_ntop(AF_INET6, pack(">QQ", random.getrandbits(64), random.getrandbits(64)))),
+    )
+
+
+def random_alphanumeric_str(min_len: int, max_len: int) -> str:
+    """
+    Creates a random string of alphanumeric characters.
+
+    :param min_len: The minimum number of characters the string should comprise of.
+    :param max_len: The maximum number of characters the string should comprise of.
+    """
+
+    return "".join(random.choices(string.ascii_letters + string.digits, k=random.randint(min_len, max_len)))
+
+
+P = TypeVar("P")
+R = TypeVar("R")
+
+
+def call_repeat(generator: Callable[[P], R], arg: P, max_count: int) -> list[R]:
+    count = random.randint(0, max_count)
+    return [generator(arg) for _ in range(count)]
+
+
+class RandomGenerator:
+    """
+    Generates a data-class instances with all their fields populated with random values recursively.
+    """
+
+    keys: list[int]
+
+    def __init__(self, count: int) -> None:
+        """
+        Initializes the generator to a sample size.
+
+        :param count: The total number of objects to generate.
+        """
+
+        self.keys = list(range(count))
+        random.shuffle(self.keys)
+
+    def create_json(self, cls: type) -> Callable[[int], dict[str, Any]]:
+        generators = {field.name: self.create(field.type, cls) for field in dataclass_fields(cls)}
+        return lambda k: {field_name: generator(k) for field_name, generator in generators.items()}
+
+    def create(self, typ: Any, cls: type[DataclassInstance]) -> Callable[[int], Any]:
+        """
+        Creates a generator for a random value.
+
+        :param typ: The type of the value to generate.
+        :param cls: The context in which the type occurs, used for evaluating forward reference types.
+        :returns: A callable object that takes a sequence index and returns a random value.
+        """
+
+        field_properties = get_field_properties(typ)
+        referenced_type = reference_to_key(field_properties.field_type, cls)
+
+        value_properties = get_field_properties(referenced_type)
+        plain_type = value_properties.plain_type
+        field_type = value_properties.field_type
+
+        if field_properties.is_primary:
+            if plain_type is int:
+                return lambda k: self.keys[k]
+            elif plain_type is uuid.UUID:
+                return lambda _: uuid.uuid4()
+
+            raise DataGeneratorError(f"unknown key type: {plain_type}")
+
+        if value_properties.nullable:
+            optional_generator = self.create(field_type, cls)
+            return lambda k: optional_generator(k) if random.uniform(0.0, 1.0) > 0.1 else None
+        elif plain_type is bool:
+            return lambda _: random_bool()
+        elif plain_type is int:
+            integer_range = get_annotation(field_type, IntegerRange)
+            if integer_range is not None:
+                minimum_value = integer_range.minimum
+                maximum_value = integer_range.maximum
+                return lambda _: random.randint(minimum_value, maximum_value)
+
+            return lambda _: random.randint(0, 1000000)
+        elif plain_type is float:
+            return lambda _: random.uniform(0.0, 1.0)
+        elif plain_type is datetime.datetime:
+            return lambda _: random_datetime(
+                datetime.datetime(1982, 10, 23, 2, 30, 0, tzinfo=datetime.timezone.utc),
+                datetime.datetime.now().replace(tzinfo=datetime.timezone.utc),
+            )
+        elif plain_type is datetime.date:
+            return lambda _: random_date(
+                datetime.date(1982, 10, 23),
+                datetime.date.today(),
+            )
+        elif plain_type is datetime.time:
+            return lambda _: random_time()
+        elif plain_type is str:
+            min_length_tag = get_annotation(field_type, MinLength)
+            # use a minimum length of at least 1; Oracle treats empty string as equivalent to NULL
+            min_length = min_length_tag.value if min_length_tag is not None else 1
+            max_length_tag = get_annotation(field_type, MaxLength)
+            max_length = max_length_tag.value if max_length_tag is not None else 255
+            return lambda _: random_alphanumeric_str(min_length, max_length)
+        elif plain_type is decimal.Decimal:
+            precision = get_annotation(field_type, Precision)
+            significant_digits = precision.significant_digits if precision else 10
+            decimal_digits = precision.decimal_digits if precision else 0
+            return lambda _: random_decimal(significant_digits, decimal_digits)
+        elif plain_type is uuid.UUID:
+            return lambda _: uuid.uuid4()
+        elif plain_type is IPv4Address:
+            return lambda _: random_ipv4addr()
+        elif plain_type is IPv6Address:
+            return lambda _: random_ipv6addr()
+        elif is_type_enum(plain_type):
+            return lambda _: random_enum(plain_type)
+        elif is_type_literal(plain_type):
+            literal_values = unwrap_literal_values(plain_type)
+            if len(literal_values) > 1:
+                return lambda _: random.choice(literal_values)
+            elif len(literal_values) > 0:
+                literal_value = literal_values[0]
+                return lambda _: literal_value
+            else:
+                raise TypeError("empty `typing.Literal`")
+        elif is_type_union(plain_type):
+            union_types = unwrap_union_types(plain_type)
+            union_generators = [self.create(union_type, cls) for union_type in union_types]
+            return lambda k: random.choice(union_generators)(k)
+        elif is_struct_type(plain_type):
+            json_generator = self.create_json(plain_type)
+            return lambda k: object_to_json(json_generator(k))
+
+        origin_type = typing.get_origin(plain_type)
+        if origin_type is list or origin_type is set:
+            (element_type,) = typing.get_args(plain_type)
+            if is_type_enum(element_type):
+                enum_generator = random_enum_generator(element_type, max_count=5)
+                return lambda _: object_to_json(enum_generator())
+            else:
+                element_generator = self.create(element_type, cls)
+                return lambda k: object_to_json(call_repeat(element_generator, k, 5))
+
+        raise DataGeneratorError(f"unknown value type: {plain_type}")
+
+
+D = TypeVar("D", bound=DataclassInstance)
+
+
+def random_objects(cls: type[D], count: int) -> list[D]:
+    """
+    Creates a list of data-class instances with all their fields populated with random values recursively.
+    """
+
+    random_generator = RandomGenerator(count)
+
+    generators = {field.name: random_generator.create(field.type, cls) for field in dataclass_fields(cls)}
+
+    items: list[D] = []
+    for k in range(0, count):
+        args = {field_name: generator(k) for field_name, generator in generators.items()}
+        items.append(cls(**args))
+
+    return items

pysqlsync/dialect/README.md

@@ -0,0 +1,35 @@
+# Dialects
+
+pysqlsync comes with several database dialects shipped with the library. However, it is possible to create and register new dialects that behave the same way as built-in dialects. In terms of capabilities, there are no differences between built-in and user-defined dialects.
+
+If you are about to write integration for a new database dialect, it is recommended that you take one of the existing dialects (e.g. PostgreSQL, Microsoft SQL Server or MySQL), and use it as a template.
+
+## Register a new dialect
+
+New dialects are added by calling the function `pysqlsync.factory.register_dialect`. The dialect has to derive from `BaseEngine`, which is a factory class for generator, connection and explorer objects. Each dialect has to provide its own implementation of `BaseEngine`, which returns the appropriate class types.
+
+## Generator
+
+The generator class is the most fundamental of the three base classes, and is responsible for generating SQL statements for creating or dropping database objects (e.g. tables, structs or enums), and inserting, updating or deleting data. The base class for a generator is `BaseGenerator`.
+
+A generator maintains a state, either created explicitly in code or discovered from a database. A state is a collection of Python objects that represent the set of namespaces (schemas), tables, structs, enums, constraints, etc. that exist in a database.
+
+A generator encapsulates a data-class converter (an instance of `DataclassConverter`), which takes a Python data-class type and returns a collection of Python objects that may in turn be used to generate SQL. The data-class converter is identical across dialects but each dialect passes different configuration to the converter to account for differences between dialects, e.g. PostgreSQL has a dedicated `enum` type, MySQL and Oracle have in-line enumeration types, and Microsoft SQL Server has no enumeration type at all. By passing the appropriate configuration options to the data-class converter, the dialect implementation can ensure that the appropriate Python objects are instantiated either for database objects or database data types. For example, the PostgreSQL dialect would use `PostgreSQLJsonType` instead of the basic `SqlJsonType` to represent the PostgreSQL-specific compact JSON type [jsonb](https://www.postgresql.org/docs/current/datatype-json.html).
+
+A generator also holds a reference to an object factory. The object factory ensures that the data-class converter or the explorer instantiate the dialect-specific Python object types. For example, the PostgreSQL dialect has `PostgreSQLTable`, which differs from the ANSI-compliant `Table` in that it can associate comments with table objects.
+
+Finally, the generator has a mutator, whose job is to emit SQL statements to transform a database source state into a target state. In general, the mutator is the same across dialects, inheritance helps specialize the implementation to account for dialect-specific differences. For example, PostgreSQL or MySQL have comments for database objects, and the mutator can help add/remove comments when a database object is modified.
+
+In writing a specialization for a generator, one would pass the appropriate configuration options to the data-class converter in the `__init__` method, override methods such as `get_table_insert_stmt` to tell what SQL statement is generated when data is about to be inserted/updated/deleted, and override methods such as `get_value_transformer` to define mappings between native Python types and the binding types the database driver (e.g. `asyncpg`) is expecting.
+
+## Connection and context
+
+The connection class represents an active connection to the database server. It holds a native connection object (e.g. `asyncpg.Connection`). When the connection is opened, it yields a context object. The dialect-specific context class may possibly override when happens on operations such as executing a SQL statement, running a query, or inserting data.
+
+pysqlsync runs in an asynchronous context. Many database drivers (e.g. `asyncpg` or `aiomysql`) support asynchronous operations natively. For database drivers that require sycnhronous calls, it is the responsibility of the connection implementation to dispatch the task to a worker thread. pysqlsync provides the decorator `thread_dispatch` for this purpose.
+
+## Explorer
+
+The role of the explorer class is to use `information_schema` (or its dialect-specific equivalent such as `pg_catalog` in PostgreSQL or `sys` in Microsoft SQL server) to create a hierarchy of Python objects that represent the database state. By comparing the source state with a target state, the generator can emit SQL statements that mutate the database, e.g. create/drop database objects, or modify existing objects.
+
+If the database dialect supports `information_schema`, the explorer implementation can simply inherit from `AnsiExplorer`, and override only those methods where the database dialect has additional features (e.g. identity columns in Microsoft SQL Server, or `auto_increment` or column comments in MySQL).

pysqlsync/dialect/delta/data_types.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+
+from pysqlsync.model.data_types import (
+    SqlDoubleType,
+    SqlFixedBinaryType,
+    SqlRealType,
+    SqlTimestampType,
+    SqlVariableBinaryType,
+    SqlVariableCharacterType,
+)
+
+
+@dataclass
+class DeltaRealType(SqlRealType):
+    def __str__(self) -> str:
+        return "float"
+
+
+@dataclass
+class DeltaDoubleType(SqlDoubleType):
+    def __str__(self) -> str:
+        return "double"
+
+
+@dataclass
+class DeltaFixedBinaryType(SqlFixedBinaryType):
+    def __str__(self) -> str:
+        return "binary"
+
+
+@dataclass
+class DeltaVariableBinaryType(SqlVariableBinaryType):
+    def __str__(self) -> str:
+        return "binary"
+
+
+@dataclass
+class DeltaVariableCharacterType(SqlVariableCharacterType):
+    def __str__(self) -> str:
+        return "string"
+
+
+@dataclass
+class DeltaTimestampType(SqlTimestampType):
+    "Timestamp without time zone."
+
+    def __init__(self) -> None:
+        self.precision = 9
+
+    def __str__(self) -> str:
+        return "timestamp_ntz"

pysqlsync/dialect/delta/dependency.py

@@ -0,0 +1,7 @@
+"""
+pysqlsync: Synchronize schema and large volumes of data.
+
+This module defines dependencies required for Delta Lake on Databricks.
+
+:see: https://github.com/instructure-internal/pysqlsync
+"""