Add new option to auto-assign DEFAULT for NOT NULL columns

pysqlsync/base.py

@@ -140,6 +140,7 @@ class GeneratorOptions:
     :param initialize_tables: Whether to populate special tables (e.g. enumerations) with data.
     :param synchronization: Synchronization options.
     :param skip_annotations: Annotation classes to ignore on table column types.
+    :param auto_default: Automatically assign a default value to non-nullable types.
     """
 
     enum_mode: Optional[EnumMode] = None
@@ -152,6 +153,7 @@ class GeneratorOptions:
     initialize_tables: bool = False
     synchronization: MutatorOptions = dataclasses.field(default_factory=MutatorOptions)
     skip_annotations: tuple[type, ...] = ()
+    auto_default: bool = False
 
 
 class BaseGenerator(abc.ABC):

pysqlsync/dialect/delta/generator.py

@@ -63,8 +63,9 @@ def __init__(self, options: GeneratorOptions) -> None:
                     ipaddress.IPv4Address: DeltaFixedBinaryType(4),
                     ipaddress.IPv6Address: DeltaFixedBinaryType(16),
                 },
-                skip_annotations=options.skip_annotations,
                 factory=self.factory,
+                skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
             )
         )
 

pysqlsync/dialect/mssql/generator.py

@@ -59,6 +59,7 @@ def __init__(self, options: GeneratorOptions) -> None:
                 },
                 factory=self.factory,
                 skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
             )
         )
 

pysqlsync/dialect/oracle/generator.py

@@ -71,8 +71,9 @@ def __init__(self, options: GeneratorOptions) -> None:
                     ipaddress.IPv4Address: OracleVariableBinaryType(4),
                     ipaddress.IPv6Address: OracleVariableBinaryType(16),
                 },
-                skip_annotations=options.skip_annotations,
                 factory=self.factory,
+                skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
             )
         )
 

pysqlsync/dialect/postgresql/generator.py

@@ -46,8 +46,9 @@ def __init__(self, options: GeneratorOptions) -> None:
                 substitutions={
                     JsonType: PostgreSQLJsonType(),
                 },
-                skip_annotations=options.skip_annotations,
                 factory=self.factory,
+                skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
             )
         )
 

pysqlsync/dialect/redshift/generator.py

@@ -53,8 +53,9 @@ def __init__(self, options: GeneratorOptions) -> None:
                     ipaddress.IPv4Address: RedshiftVariableBinaryType(4),
                     ipaddress.IPv6Address: RedshiftVariableBinaryType(16),
                 },
-                skip_annotations=options.skip_annotations,
                 factory=self.factory,
+                skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
             )
         )
 

pysqlsync/dialect/snowflake/generator.py

@@ -53,8 +53,9 @@ def __init__(self, options: GeneratorOptions) -> None:
                     ipaddress.IPv4Address: SqlFixedBinaryType(4),
                     ipaddress.IPv6Address: SqlFixedBinaryType(16),
                 },
-                skip_annotations=options.skip_annotations,
                 factory=self.factory,
+                skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
             )
         )
 

pysqlsync/dialect/trino/generator.py

@@ -22,6 +22,7 @@ def __init__(self, options: GeneratorOptions) -> None:
                 foreign_constraints=options.foreign_constraints,
                 initialize_tables=options.initialize_tables,
                 skip_annotations=options.skip_annotations,
+                auto_default=options.auto_default,
             )
         )
 

pysqlsync/formation/inspection.py

@@ -92,6 +92,7 @@ def is_ip_address_type(field_type: type) -> bool:
 
 
 def dataclass_has_primary_key(typ: type[DataclassInstance]) -> bool:
+    typ = unwrap_annotated_type(typ)
     for field in dataclass_fields(typ):
         if is_primary_key_type(field.type):
             return True

pysqlsync/formation/py_to_sql.py

@@ -9,7 +9,7 @@
 import types
 import typing
 import uuid
-from typing import Annotated, Callable, Iterable, Optional, TypeVar
+from typing import Annotated, Any, Callable, Iterable, Optional, TypeVar
 
 from strong_typing.auxiliary import (
     MaxLength,
@@ -150,6 +150,7 @@ def is_extensible_enum_type(typ: TypeLike, cls: type) -> bool:
 
     if not is_type_union(typ):
         return False
+    typ = unwrap_annotated_type(typ)
     member_types = [evaluate_member_type(t, cls) for t in unwrap_union_types(typ)]
     for member_type in member_types:
         if member_type is None:
@@ -292,6 +293,7 @@ class DataclassConverterOptions:
     :param substitutions: SQL type to be substituted for a specific Python type.
     :param factory: Creates new column, table, struct and namespace instances.
     :param skip_annotations: Annotation classes to ignore on table column types.
+    :param auto_default: Automatically assign a default value to non-nullable types.
     """
 
     enum_mode: EnumMode = EnumMode.TYPE
@@ -307,6 +309,7 @@ class DataclassConverterOptions:
     substitutions: dict[TypeLike, SqlDataType] = dataclasses.field(default_factory=dict)
     factory: ObjectFactory = dataclasses.field(default_factory=ObjectFactory)
     skip_annotations: tuple[type, ...] = ()
+    auto_default: bool = False
 
 
 class DataclassConverter:
@@ -540,7 +543,7 @@ def member_to_sql_data_type(self, typ: TypeLike, cls: type) -> SqlDataType:
                 )
             elif self.options.struct_mode is StructMode.INLINE:
                 inline_types: list[SqlStructMember] = []
-                for field in dataclass_fields(typ):
+                for field in dataclass_fields(unwrap_annotated_type(typ)):
                     inline_props = get_field_properties(field.type)
                     inline_type = self.member_to_sql_data_type(
                         inline_props.field_type, typ
@@ -609,7 +612,8 @@ def member_to_sql_data_type(self, typ: TypeLike, cls: type) -> SqlDataType:
             return self._enumeration_key_type()
         if is_type_union(typ):
             member_types = [
-                evaluate_member_type(t, cls) for t in unwrap_union_types(typ)
+                evaluate_member_type(t, cls)
+                for t in unwrap_union_types(unwrap_annotated_type(typ))
             ]
             if all(is_entity_type(t) for t in member_types):
                 # discriminated union type
@@ -644,11 +648,30 @@ def member_to_column(
 
         props = get_field_properties(field.type)
         data_type = self.member_to_sql_data_type(props.field_type, cls)
-        default_value = (
-            constant(field.default)
-            if field.default is not dataclasses.MISSING and field.default is not None
-            else None
-        )
+        if field.default is not dataclasses.MISSING and field.default is not None:
+            default_value = constant(field.default)
+        elif (
+            not props.nullable
+            and self.options.auto_default
+            and not is_dataclass_type(props.plain_type)
+            and not is_generic_list(props.plain_type)
+            and not is_generic_set(props.plain_type)
+            and not is_type_union(props.plain_type)
+        ):
+            default_expr: Any
+            if props.plain_type is datetime.datetime:
+                default_expr = datetime.datetime.min
+            elif props.plain_type is datetime.date:
+                default_expr = datetime.date.min
+            elif props.plain_type is datetime.time:
+                default_expr = datetime.time.min
+            elif is_type_enum(props.plain_type):
+                default_expr = next(member.value for member in props.plain_type)
+            else:
+                default_expr = props.plain_type()  # type: ignore
+            default_value = constant(default_expr)
+        else:
+            default_value = None
         description = (
             doc.params[field.name].description if field.name in doc.params else None
         )
@@ -796,7 +819,7 @@ def dataclass_to_constraints(
                 if is_type_union(field.type):
                     member_types = [
                         evaluate_member_type(t, cls)
-                        for t in unwrap_union_types(field.type)
+                        for t in unwrap_union_types(unwrap_annotated_type(field.type))
                     ]
                     if all(is_entity_type(t) for t in member_types):
                         # discriminated keys

pysqlsync/model/data_types.py

@@ -1,4 +1,5 @@
 import datetime
+import decimal
 from dataclasses import dataclass
 from functools import reduce
 from typing import Any, Optional
@@ -31,9 +32,14 @@ def constant(v: Any) -> str:
         return str(v)
     elif isinstance(v, bool):
         return "TRUE" if v else "FALSE"
+    elif isinstance(v, decimal.Decimal):
+        return str(v)
     elif isinstance(v, datetime.datetime):
-        timestamp = v.astimezone(tz=datetime.timezone.utc).replace(tzinfo=None)
-        return quote(timestamp.isoformat(sep=" "))
+        if v.tzinfo is not None:
+            timestamp = v.astimezone(tz=datetime.timezone.utc).replace(tzinfo=None)
+        else:
+            timestamp = v
+        return f"TIMESTAMP {quote(timestamp.isoformat(sep=' '))}"
     elif isinstance(v, tuple):
         values = ", ".join(constant(value) for value in v)
         return f"({values})"
@@ -43,7 +49,9 @@ def constant(v: Any) -> str:
         )
         return f"({values})"
     else:
-        raise NotImplementedError(f"unknown constant representation for value: {v}")
+        raise NotImplementedError(
+            f"unknown constant representation for value (of type): {v} ({type(v)})"
+        )
 
 
 def escape_like(value: str, escape_char: str) -> str:

pysqlsync/model/entity_types.py

@@ -37,7 +37,7 @@ def make_entity(cls: type[DataclassInstance], key: str) -> type[DataclassInstanc
     Transforms a regular data-class type into an entity type.
 
     :param cls: The data-class type to transform.
-    :param key: The field to be come the primary key.
+    :param key: The field to become the primary key.
     """
 
     key_field, value_fields = key_value_fields(cls, key)