sqlacodegen 4.0.0rc3__tar.gz → 4.0.2__tar.gz

{sqlacodegen-4.0.0rc3 → sqlacodegen-4.0.2}/CHANGES.rst

@@ -1,6 +1,38 @@
 Version history
 ===============
 
+**4.0.2**
+
+- Fixed rendering of inherited keyword arguments for dialect-specific types that use
+  ``**kwargs`` in their initializers (such as MySQL ``CHAR`` with ``collation``) while
+  preserving existing ``*args`` rendering behavior (PR by @hyoj0942)
+- Fixed missing metadata argument when rendering plain tables with the SQLModel
+- Added support for self-referential tables in the SQLModel generator (PR by @sheinbergon)
+- Fixed empty dialect kwargs (e.g. ``postgresql_include=[]``) being included in
+  rendered indexes, tables, and columns (PR by @sheinbergon)
+
+**4.0.1**
+
+- Fix enum column definitions to explicitly include schema and name if reflected
+  via SQLAlchemy's Metadata (pr by @sheinbergon)
+
+**4.0.0**
+
+- **BACKWARD INCOMPATIBLE** API changes (for those who customize code generation by
+  subclassing the existing generators):
+
+  * Added new optional keyword argument, ``explicit_foreign_keys`` to
+    ``DeclarativeGenerator``, to force foreign keys to be rendered as
+    ``ClassName.attribute_name`` string references
+  * Removed the ``render_relationship_args()`` method from the SQLModel generator
+  * Added two new methods for customizing relationship rendering in
+    ``DeclarativeGenerator``:
+
+    * ``render_relationship_annotation()``: returns the appropriate type annotation
+      (without the ``Mapped`` wrapper) for the relationship
+    * ``render_relationship_arguments()``: returns a dictionary of keyword arguments to
+      ``sqlalchemy.orm.relationship()``
+
 **4.0.0rc3**
 
 - **BACKWARD INCOMPATIBLE** Relationship names changed when multiple FKs or junction tables
@@ -14,6 +46,8 @@ Version history
   ``students_enrollments``). Use ``--options nofknames`` to revert to old behavior. (PR by @sheinbergon)
 - Fixed ``Index`` kwargs (e.g. ``mysql_length``) being ignored during code generation
   (PR by @luliangce)
+- Fixed the SQLModel generator not adding the ``foreign_keys`` parameters when
+  generating multiple relationships between the same two tables
 
 **4.0.0rc2**
 

{sqlacodegen-4.0.0rc3 → sqlacodegen-4.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 4.0.0rc3
+Version: 4.0.2
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>

{sqlacodegen-4.0.0rc3 → sqlacodegen-4.0.2}/src/sqlacodegen/generators.py

@@ -5,7 +5,7 @@ import re
 import sys
 from abc import ABCMeta, abstractmethod
 from collections import defaultdict
-from collections.abc import Collection, Iterable, Sequence
+from collections.abc import Collection, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from importlib import import_module
 from inspect import Parameter
@@ -427,6 +427,7 @@ class TablesGenerator(CodeGenerator):
         kwargs = {
             key: repr(value) if isinstance(value, str) else value
             for key, value in sorted(index.kwargs.items(), key=lambda item: item[0])
+            if value not in ([], {})
         }
         if index.unique:
             kwargs["unique"] = True
@@ -541,6 +542,77 @@ class TablesGenerator(CodeGenerator):
         else:
             return render_callable("mapped_column", *args, kwargs=kwargs)
 
+    def _render_column_type_value(self, value: Any) -> str:
+        if isinstance(value, (JSONB, JSON)):
+            # Remove astext_type if it's the default
+            if isinstance(value.astext_type, Text) and value.astext_type.length is None:
+                value.astext_type = None  # type: ignore[assignment]
+            else:
+                self.add_import(Text)
+
+        if isinstance(value, TextClause):
+            self.add_literal_import("sqlalchemy", "text")
+            return render_callable("text", repr(value.text))
+
+        return repr(value)
+
+    def _collect_inherited_init_kwargs(
+        self,
+        column_type: Any,
+        init_sig: inspect.Signature,
+        seen_param_names: set[str],
+        missing: object,
+    ) -> dict[str, str]:
+        has_var_keyword = any(
+            param.kind is Parameter.VAR_KEYWORD
+            for param in init_sig.parameters.values()
+        )
+        has_var_positional = any(
+            param.kind is Parameter.VAR_POSITIONAL
+            for param in init_sig.parameters.values()
+        )
+        if not has_var_keyword or has_var_positional:
+            return {}
+
+        inherited_kwargs: dict[str, str] = {}
+        for supercls in column_type.__class__.__mro__[1:]:
+            if supercls is object:
+                break
+
+            try:
+                super_sig = inspect.signature(supercls.__init__)
+            except (TypeError, ValueError):
+                continue
+
+            for super_param in list(super_sig.parameters.values())[1:]:
+                if super_param.name.startswith("_"):
+                    continue
+
+                if super_param.kind in (
+                    Parameter.POSITIONAL_ONLY,
+                    Parameter.VAR_POSITIONAL,
+                    Parameter.VAR_KEYWORD,
+                ):
+                    continue
+
+                if super_param.name in seen_param_names:
+                    continue
+
+                seen_param_names.add(super_param.name)
+                value = getattr(column_type, super_param.name, missing)
+                if value is missing:
+                    continue
+
+                default = super_param.default
+                if default is not Parameter.empty and value == default:
+                    continue
+
+                inherited_kwargs[super_param.name] = self._render_column_type_value(
+                    value
+                )
+
+        return inherited_kwargs
+
     def render_column_type(self, column: Column[Any]) -> str:
         column_type = column.type
         # Check if this is an enum column with a Python enum class
@@ -550,7 +622,14 @@ class TablesGenerator(CodeGenerator):
             ):
                 # Import SQLAlchemy Enum (will be handled in collect_imports)
                 self.add_import(Enum)
-                return f"Enum({enum_class_name}, values_callable=lambda cls: [member.value for member in cls])"
+                extra_kwargs = ""
+                if column_type.name is not None:
+                    extra_kwargs += f", name={column_type.name!r}"
+
+                if column_type.schema is not None:
+                    extra_kwargs += f", schema={column_type.schema!r}"
+
+                return f"Enum({enum_class_name}, values_callable=lambda cls: [member.value for member in cls]{extra_kwargs})"
 
         args = []
         kwargs: dict[str, Any] = {}
@@ -562,7 +641,14 @@ class TablesGenerator(CodeGenerator):
             ):
                 self.add_import(ARRAY)
                 self.add_import(Enum)
-                rendered_enum = f"Enum({enum_class_name}, values_callable=lambda cls: [member.value for member in cls])"
+                extra_kwargs = ""
+                if column_type.item_type.name is not None:
+                    extra_kwargs += f", name={column_type.item_type.name!r}"
+
+                if column_type.item_type.schema is not None:
+                    extra_kwargs += f", schema={column_type.item_type.schema!r}"
+
+                rendered_enum = f"Enum({enum_class_name}, values_callable=lambda cls: [member.value for member in cls]{extra_kwargs})"
                 if column_type.dimensions is not None:
                     kwargs["dimensions"] = repr(column_type.dimensions)
 
@@ -572,6 +658,8 @@ class TablesGenerator(CodeGenerator):
         defaults = {param.name: param.default for param in sig.parameters.values()}
         missing = object()
         use_kwargs = False
+        seen_param_names: set[str] = set()
+
         for param in list(sig.parameters.values())[1:]:
             # Remove annoyances like _warn_on_bytestring
             if param.name.startswith("_"):
@@ -580,32 +668,25 @@ class TablesGenerator(CodeGenerator):
                 use_kwargs = True
                 continue
 
+            seen_param_names.add(param.name)
             value = getattr(column_type, param.name, missing)
-
-            if isinstance(value, (JSONB, JSON)):
-                # Remove astext_type if it's the default
-                if (
-                    isinstance(value.astext_type, Text)
-                    and value.astext_type.length is None
-                ):
-                    value.astext_type = None  # type: ignore[assignment]
-                else:
-                    self.add_import(Text)
-
             default = defaults.get(param.name, missing)
-            if isinstance(value, TextClause):
-                self.add_literal_import("sqlalchemy", "text")
-                rendered_value = render_callable("text", repr(value.text))
-            else:
-                rendered_value = repr(value)
-
             if value is missing or value == default:
                 use_kwargs = True
-            elif use_kwargs:
+                continue
+
+            rendered_value = self._render_column_type_value(value)
+            if use_kwargs:
                 kwargs[param.name] = rendered_value
             else:
                 args.append(rendered_value)
 
+        kwargs.update(
+            self._collect_inherited_init_kwargs(
+                column_type, sig, seen_param_names, missing
+            )
+        )
+
         vararg = next(
             (
                 param.name
@@ -698,6 +779,9 @@ class TablesGenerator(CodeGenerator):
             except Exception:
                 continue
 
+            if isinstance(value, list | dict) and not value:
+                continue
+
             # Render values:
             # - callable context (values_for_dict=False): produce a string expression.
             #   primitives use repr(value); custom objects stringify then repr().
@@ -1001,10 +1085,12 @@ class DeclarativeGenerator(TablesGenerator):
         *,
         indentation: str = "    ",
         base_class_name: str = "Base",
+        explicit_foreign_keys: bool = False,
     ):
         super().__init__(metadata, bind, options, indentation=indentation)
         self.base_class_name: str = base_class_name
         self.inflect_engine = inflect.engine()
+        self.explicit_foreign_keys = explicit_foreign_keys
 
     def generate_base(self) -> None:
         self.base = Base(
@@ -1626,22 +1712,52 @@ class DeclarativeGenerator(TablesGenerator):
         return f"{column_attr.name}: Mapped[{rendered_column_python_type}] = {rendered_column}"
 
     def render_relationship(self, relationship: RelationshipAttribute) -> str:
+        kwargs = self.render_relationship_arguments(relationship)
+        annotation = self.render_relationship_annotation(relationship)
+        rendered_relationship = render_callable(
+            "relationship", repr(relationship.target.name), kwargs=kwargs
+        )
+        return f"{relationship.name}: Mapped[{annotation}] = {rendered_relationship}"
+
+    def render_relationship_annotation(
+        self, relationship: RelationshipAttribute
+    ) -> str:
+        match relationship.type:
+            case RelationshipType.ONE_TO_MANY:
+                return f"list[{relationship.target.name!r}]"
+            case RelationshipType.ONE_TO_ONE | RelationshipType.MANY_TO_ONE:
+                if relationship.constraint and any(
+                    col.nullable for col in relationship.constraint.columns
+                ):
+                    self.add_literal_import("typing", "Optional")
+                    return f"Optional[{relationship.target.name!r}]"
+                else:
+                    return f"'{relationship.target.name}'"
+            case RelationshipType.MANY_TO_MANY:
+                return f"list[{relationship.target.name!r}]"
+
+    def render_relationship_arguments(
+        self, relationship: RelationshipAttribute
+    ) -> Mapping[str, Any]:
         def render_column_attrs(column_attrs: list[ColumnAttribute]) -> str:
             rendered = []
+            render_as_string = False
             for attr in column_attrs:
-                if attr.model is relationship.source:
+                if not self.explicit_foreign_keys and attr.model is relationship.source:
                     rendered.append(attr.name)
                 else:
-                    rendered.append(repr(f"{attr.model.name}.{attr.name}"))
+                    rendered.append(f"{attr.model.name}.{attr.name}")
+                    render_as_string = True
 
-            return "[" + ", ".join(rendered) + "]"
+            joined = "[" + ", ".join(rendered) + "]"
+            return repr(joined) if render_as_string else joined
 
         def render_foreign_keys(column_attrs: list[ColumnAttribute]) -> str:
             rendered = []
             render_as_string = False
             # Assume that column_attrs are all in relationship.source or none
             for attr in column_attrs:
-                if attr.model is relationship.source:
+                if not self.explicit_foreign_keys and attr.model is relationship.source:
                     rendered.append(attr.name)
                 else:
                     rendered.append(f"{attr.model.name}.{attr.name}")
@@ -1697,33 +1813,7 @@ class DeclarativeGenerator(TablesGenerator):
         if relationship.backref:
             kwargs["back_populates"] = repr(relationship.backref.name)
 
-        rendered_relationship = render_callable(
-            "relationship", repr(relationship.target.name), kwargs=kwargs
-        )
-
-        relationship_type: str
-        if relationship.type == RelationshipType.ONE_TO_MANY:
-            relationship_type = f"list['{relationship.target.name}']"
-        elif relationship.type in (
-            RelationshipType.ONE_TO_ONE,
-            RelationshipType.MANY_TO_ONE,
-        ):
-            relationship_type = f"'{relationship.target.name}'"
-            if relationship.constraint and any(
-                col.nullable for col in relationship.constraint.columns
-            ):
-                self.add_literal_import("typing", "Optional")
-                relationship_type = f"Optional[{relationship_type}]"
-        elif relationship.type == RelationshipType.MANY_TO_MANY:
-            relationship_type = f"list['{relationship.target.name}']"
-        else:
-            self.add_literal_import("typing", "Any")
-            relationship_type = "Any"
-
-        return (
-            f"{relationship.name}: Mapped[{relationship_type}] "
-            f"= {rendered_relationship}"
-        )
+        return kwargs
 
 
 class DataclassGenerator(DeclarativeGenerator):
@@ -1778,6 +1868,7 @@ class SQLModelGenerator(DeclarativeGenerator):
             options,
             indentation=indentation,
             base_class_name=base_class_name,
+            explicit_foreign_keys=True,
         )
 
     @property
@@ -1788,19 +1879,27 @@ class SQLModelGenerator(DeclarativeGenerator):
         self.add_import(Column)
         return render_callable("Column", *args, kwargs=kwargs)
 
+    def render_table(self, table: Table) -> str:
+        # Hack to fix #465 without breaking backwards compatibility
+        self.base.metadata_ref = "SQLModel.metadata"
+
+        return super().render_table(table)
+
     def generate_base(self) -> None:
         self.base = Base(
             literal_imports=[],
             declarations=[],
-            metadata_ref="",
+            metadata_ref="SQLModel.metadata",
         )
 
     def collect_imports(self, models: Iterable[Model]) -> None:
         super(DeclarativeGenerator, self).collect_imports(models)
         if any(isinstance(model, ModelClass) for model in models):
+            self.add_literal_import("sqlmodel", "Field")
+
+        if models:
             self.remove_literal_import("sqlalchemy", "MetaData")
             self.add_literal_import("sqlmodel", "SQLModel")
-            self.add_literal_import("sqlmodel", "Field")
 
     def collect_imports_for_model(self, model: Model) -> None:
         super(DeclarativeGenerator, self).collect_imports_for_model(model)
@@ -1858,34 +1957,26 @@ class SQLModelGenerator(DeclarativeGenerator):
         return f"{column_attr.name}: {rendered_column_python_type} = {rendered_field}"
 
     def render_relationship(self, relationship: RelationshipAttribute) -> str:
-        rendered = super().render_relationship(relationship).partition(" = ")[2]
-        args = self.render_relationship_args(rendered)
-        kwargs: dict[str, Any] = {}
-        annotation = repr(relationship.target.name)
+        kwargs = self.render_relationship_arguments(relationship)
+        annotation = self.render_relationship_annotation(relationship)
+
+        native_kwargs: dict[str, Any] = {}
+        non_native_kwargs: dict[str, Any] = {}
+        for key, value in kwargs.items():
+            # The following keyword arguments are natively supported in Relationship
+            if key in ("back_populates", "cascade_delete", "passive_deletes"):
+                native_kwargs[key] = value
+            else:
+                non_native_kwargs[key] = value
 
-        if relationship.type in (
-            RelationshipType.ONE_TO_MANY,
-            RelationshipType.MANY_TO_MANY,
-        ):
-            annotation = f"list[{annotation}]"
-        else:
-            self.add_literal_import("typing", "Optional")
-            annotation = f"Optional[{annotation}]"
+        if non_native_kwargs:
+            native_kwargs["sa_relationship_kwargs"] = (
+                "{"
+                + ", ".join(
+                    f"{key!r}: {value}" for key, value in non_native_kwargs.items()
+                )
+                + "}"
+            )
 
-        rendered_field = render_callable("Relationship", *args, kwargs=kwargs)
+        rendered_field = render_callable("Relationship", kwargs=native_kwargs)
         return f"{relationship.name}: {annotation} = {rendered_field}"
-
-    def render_relationship_args(self, arguments: str) -> list[str]:
-        argument_list = arguments.split(",")
-        # delete ')' and ' ' from args
-        argument_list[-1] = argument_list[-1][:-1]
-        argument_list = [argument[1:] for argument in argument_list]
-
-        rendered_args: list[str] = []
-        for arg in argument_list:
-            if "back_populates" in arg:
-                rendered_args.append(arg)
-            if "uselist=False" in arg:
-                rendered_args.append("sa_relationship_kwargs={'uselist': False}")
-
-        return rendered_args

{sqlacodegen-4.0.0rc3 → sqlacodegen-4.0.2}/src/sqlacodegen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlacodegen
-Version: 4.0.0rc3
+Version: 4.0.2
 Summary: Automatic model code generator for SQLAlchemy
 Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
 Maintainer-email: Idan Sheinberg <ishinberg0@gmail.com>

{sqlacodegen-4.0.0rc3 → sqlacodegen-4.0.2}/tests/test_generator_declarative.py

@@ -321,6 +321,40 @@ class Num2(Base):
     )
 
 
+@pytest.mark.parametrize("engine", ["mysql"], indirect=["engine"])
+@pytest.mark.parametrize("generator", [["keep_dialect_types"]], indirect=True)
+def test_keep_dialect_types_keeps_mysql_char_collation(
+    generator: CodeGenerator,
+) -> None:
+    from sqlalchemy.dialects.mysql import CHAR as MYSQL_CHAR
+    from sqlalchemy.dialects.mysql import INTEGER as MYSQL_INTEGER
+
+    Table(
+        "result_logs",
+        generator.metadata,
+        Column("id", MYSQL_INTEGER, primary_key=True),
+        Column("result_code", MYSQL_CHAR(1, collation="utf8mb3_bin"), nullable=False),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+from sqlalchemy.dialects.mysql import CHAR, INTEGER
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+class Base(DeclarativeBase):
+    pass
+
+
+class ResultLogs(Base):
+    __tablename__ = 'result_logs'
+
+    id: Mapped[int] = mapped_column(INTEGER, primary_key=True)
+    result_code: Mapped[str] = mapped_column(CHAR(1, collation='utf8mb3_bin'), nullable=False)
+        """,
+    )
+
+
 def test_onetomany(generator: CodeGenerator) -> None:
     Table(
         "simple_items",
@@ -2508,14 +2542,14 @@ def test_enum_shared_values(generator: CodeGenerator) -> None:
             __tablename__ = 'accounts'
 
             id: Mapped[int] = mapped_column(Integer, primary_key=True)
-            status: Mapped[StatusEnum] = mapped_column(Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls]), nullable=False)
+            status: Mapped[StatusEnum] = mapped_column(Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls], name='status_enum'), nullable=False)
 
 
         class Users(Base):
             __tablename__ = 'users'
 
             id: Mapped[int] = mapped_column(Integer, primary_key=True)
-            status: Mapped[StatusEnum] = mapped_column(Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls]), nullable=False)
+            status: Mapped[StatusEnum] = mapped_column(Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls], name='status_enum'), nullable=False)
         """,
     )
 
@@ -2851,7 +2885,7 @@ def test_array_enum_named(generator: CodeGenerator) -> None:
             __tablename__ = 'users'
 
             id: Mapped[int] = mapped_column(Integer, primary_key=True)
-            roles: Mapped[list[RoleEnum]] = mapped_column(ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls])), nullable=False)
+            roles: Mapped[list[RoleEnum]] = mapped_column(ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls], name='role_enum')), nullable=False)
         """,
     )
 
@@ -2927,7 +2961,7 @@ def test_array_enum_nullable(generator: CodeGenerator) -> None:
             __tablename__ = 'users'
 
             id: Mapped[int] = mapped_column(Integer, primary_key=True)
-            roles: Mapped[Optional[list[RoleEnum]]] = mapped_column(ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls])))
+            roles: Mapped[Optional[list[RoleEnum]]] = mapped_column(ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls], name='role_enum')))
         """,
     )
 
@@ -2965,7 +2999,7 @@ def test_array_enum_with_dimensions(generator: CodeGenerator) -> None:
             __tablename__ = 'items'
 
             id: Mapped[int] = mapped_column(Integer, primary_key=True)
-            tag_matrix: Mapped[list[list[TagEnum]]] = mapped_column(ARRAY(Enum(TagEnum, values_callable=lambda cls: [member.value for member in cls]), dimensions=2), nullable=False)
+            tag_matrix: Mapped[list[list[TagEnum]]] = mapped_column(ARRAY(Enum(TagEnum, values_callable=lambda cls: [member.value for member in cls], name='tag_enum'), dimensions=2), nullable=False)
         """,
     )
 
@@ -3043,7 +3077,159 @@ def test_array_enum_shared_with_regular_enum(generator: CodeGenerator) -> None:
             __tablename__ = 'users'
 
             id: Mapped[int] = mapped_column(Integer, primary_key=True)
-            primary_role: Mapped[RoleEnum] = mapped_column(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls]), nullable=False)
-            all_roles: Mapped[list[RoleEnum]] = mapped_column(ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls])), nullable=False)
+            primary_role: Mapped[RoleEnum] = mapped_column(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls], name='role_enum'), nullable=False)
+            all_roles: Mapped[list[RoleEnum]] = mapped_column(ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls], name='role_enum')), nullable=False)
+        """,
+    )
+
+
+def test_enum_named_with_schema(generator: CodeGenerator) -> None:
+    Table(
+        "my_table",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column(
+            "status",
+            SAEnum("active", "inactive", name="status_enum", schema="custom_schema"),
+            nullable=False,
+        ),
+        schema="custom_schema",
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+        import enum
+
+        from sqlalchemy import Enum, Integer
+        from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+        class Base(DeclarativeBase):
+            pass
+
+
+        class StatusEnum(str, enum.Enum):
+            ACTIVE = 'active'
+            INACTIVE = 'inactive'
+
+
+        class MyTable(Base):
+            __tablename__ = 'my_table'
+            __table_args__ = {'schema': 'custom_schema'}
+
+            id: Mapped[int] = mapped_column(Integer, primary_key=True)
+            status: Mapped[StatusEnum] = mapped_column(Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls], name='status_enum', schema='custom_schema'), nullable=False)
+        """,
+    )
+
+
+def test_array_enum_named_with_schema(generator: CodeGenerator) -> None:
+    Table(
+        "my_table",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column(
+            "tags",
+            ARRAY(SAEnum("a", "b", name="tag_enum", schema="custom_schema")),
+            nullable=False,
+        ),
+        schema="custom_schema",
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+        import enum
+
+        from sqlalchemy import ARRAY, Enum, Integer
+        from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+        class Base(DeclarativeBase):
+            pass
+
+
+        class TagEnum(str, enum.Enum):
+            A = 'a'
+            B = 'b'
+
+
+        class MyTable(Base):
+            __tablename__ = 'my_table'
+            __table_args__ = {'schema': 'custom_schema'}
+
+            id: Mapped[int] = mapped_column(Integer, primary_key=True)
+            tags: Mapped[list[TagEnum]] = mapped_column(ARRAY(Enum(TagEnum, values_callable=lambda cls: [member.value for member in cls], name='tag_enum', schema='custom_schema')), nullable=False)
+        """,
+    )
+
+
+def test_index_with_empty_kwargs(generator: CodeGenerator) -> None:
+    simple_items = Table(
+        "simple_items",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column("name", VARCHAR),
+    )
+    simple_items.indexes.add(
+        Index(
+            "idx_name",
+            simple_items.c.name,
+            postgresql_using="gist",
+            postgresql_include=[],
+        )
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+from typing import Optional
+
+from sqlalchemy import Index, Integer, String
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+class Base(DeclarativeBase):
+    pass
+
+
+class SimpleItems(Base):
+    __tablename__ = 'simple_items'
+    __table_args__ = (
+        Index('idx_name', 'name', postgresql_using='gist'),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    name: Mapped[Optional[str]] = mapped_column(String)
+        """,
+    )
+
+
+@pytest.mark.parametrize("generator", [["include_dialect_options"]], indirect=True)
+def test_include_dialect_options_empty_values_skipped(
+    generator: CodeGenerator,
+) -> None:
+    Table(
+        "t_opts3",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        mysql_engine="InnoDB",
+        mysql_partition_by=[],
+        mysql_PROPERTIES={},
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+from sqlalchemy import Integer
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+class Base(DeclarativeBase):
+    pass
+
+
+class TOpts3(Base):
+    __tablename__ = 't_opts3'
+    __table_args__ = {'mysql_engine': 'InnoDB'}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
         """,
     )

{sqlacodegen-4.0.0rc3 → sqlacodegen-4.0.2}/tests/test_generator_sqlmodel.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import pytest
 from _pytest.fixtures import FixtureRequest
+from sqlalchemy import Enum as SAEnum
 from sqlalchemy import Uuid
 from sqlalchemy.engine import Engine
 from sqlalchemy.schema import (
@@ -13,7 +14,7 @@ from sqlalchemy.schema import (
     Table,
     UniqueConstraint,
 )
-from sqlalchemy.types import INTEGER, VARCHAR
+from sqlalchemy.types import ARRAY, INTEGER, VARCHAR
 
 from sqlacodegen.generators import CodeGenerator, SQLModelGenerator
 
@@ -142,6 +143,66 @@ back_populates='simple_goods')
     )
 
 
+def test_onetomany_multiref(generator: CodeGenerator) -> None:
+    Table(
+        "simple_items_multiref",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column("parent_container_id", INTEGER),
+        Column("top_container_id", INTEGER, nullable=False),
+        ForeignKeyConstraint(
+            ["parent_container_id"], ["simple_containers_multiref.id"]
+        ),
+        ForeignKeyConstraint(["top_container_id"], ["simple_containers_multiref.id"]),
+    )
+    Table(
+        "simple_containers_multiref",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+            from typing import Optional
+
+            from sqlalchemy import Column, ForeignKey, Integer
+            from sqlmodel import Field, Relationship, SQLModel
+
+            class SimpleContainersMultiref(SQLModel, table=True):
+                __tablename__ = 'simple_containers_multiref'
+
+                id: int = Field(sa_column=Column('id', Integer, primary_key=True))
+
+                simple_items_multiref_parent_container: list['SimpleItemsMultiref'] = \
+Relationship(back_populates='parent_container', sa_relationship_kwargs={\
+'foreign_keys': '[SimpleItemsMultiref.parent_container_id]'})
+                simple_items_multiref_top_container: list['SimpleItemsMultiref'] = \
+Relationship(back_populates='top_container', sa_relationship_kwargs={'foreign_keys': \
+'[SimpleItemsMultiref.top_container_id]'})
+
+
+            class SimpleItemsMultiref(SQLModel, table=True):
+                __tablename__ = 'simple_items_multiref'
+
+                id: int = Field(sa_column=Column('id', Integer, primary_key=True))
+                top_container_id: int = \
+Field(sa_column=Column('top_container_id', \
+ForeignKey('simple_containers_multiref.id'), nullable=False))
+                parent_container_id: Optional[int] = \
+Field(default=None, sa_column=Column('parent_container_id', \
+ForeignKey('simple_containers_multiref.id')))
+
+                parent_container: Optional['SimpleContainersMultiref'] = Relationship(\
+back_populates='simple_items_multiref_parent_container', sa_relationship_kwargs={\
+'foreign_keys': '[SimpleItemsMultiref.parent_container_id]'})
+                top_container: 'SimpleContainersMultiref' = Relationship(\
+back_populates='simple_items_multiref_top_container', sa_relationship_kwargs={\
+'foreign_keys': '[SimpleItemsMultiref.top_container_id]'})
+        """,
+    )
+
+
 def test_onetoone(generator: CodeGenerator) -> None:
     Table(
         "simple_onetoone",
@@ -167,7 +228,7 @@ def test_onetoone(generator: CodeGenerator) -> None:
                 id: int = Field(sa_column=Column('id', Integer, primary_key=True))
 
                 simple_onetoone: Optional['SimpleOnetoone'] = Relationship(\
-sa_relationship_kwargs={'uselist': False}, back_populates='other_item')
+back_populates='other_item', sa_relationship_kwargs={'uselist': False})
 
 
             class SimpleOnetoone(SQLModel, table=True):
@@ -269,3 +330,142 @@ def test_synthetic_enum_generation(generator: CodeGenerator) -> None:
                 status: AccountsStatus = Field(sa_column=Column('status', Enum(AccountsStatus, values_callable=lambda cls: [member.value for member in cls]), nullable=False))
         """,
     )
+
+
+def test_array_enum_named_with_schema(generator: CodeGenerator) -> None:
+    Table(
+        "my_table",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column(
+            "tags",
+            ARRAY(SAEnum("a", "b", name="tag_enum", schema="custom_schema")),
+            nullable=False,
+        ),
+        schema="custom_schema",
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+            import enum
+
+            from sqlalchemy import ARRAY, Column, Enum, Integer
+            from sqlmodel import Field, SQLModel
+
+            class TagEnum(str, enum.Enum):
+                A = 'a'
+                B = 'b'
+
+
+            class MyTable(SQLModel, table=True):
+                __tablename__ = 'my_table'
+                __table_args__ = {'schema': 'custom_schema'}
+
+                id: int = Field(sa_column=Column('id', Integer, primary_key=True))
+                tags: list[TagEnum] = Field(sa_column=Column('tags', ARRAY(Enum(TagEnum, values_callable=lambda cls: [member.value for member in cls], name='tag_enum', schema='custom_schema')), nullable=False))
+        """,
+    )
+
+
+def test_fallback_table(generator: CodeGenerator) -> None:
+    Table(
+        "simple_fallback",
+        generator.metadata,
+        Column("field", VARCHAR(20), nullable=False),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+            from sqlalchemy import Column, String, Table
+            from sqlmodel import SQLModel
+
+            t_simple_fallback = Table(
+                'simple_fallback', SQLModel.metadata,
+                Column('field', String(20), nullable=False)
+            )
+        """,
+    )
+
+
+def test_onetomany_selfref(generator: CodeGenerator) -> None:
+    Table(
+        "simple_items",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column("parent_item_id", INTEGER),
+        ForeignKeyConstraint(["parent_item_id"], ["simple_items.id"]),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+            from typing import Optional
+
+            from sqlalchemy import Column, ForeignKey, Integer
+            from sqlmodel import Field, Relationship, SQLModel
+
+            class SimpleItems(SQLModel, table=True):
+                __tablename__ = 'simple_items'
+
+                id: int = Field(sa_column=Column('id', Integer, primary_key=True))
+                parent_item_id: Optional[int] = Field(default=None, sa_column=Column(\
+'parent_item_id', ForeignKey('simple_items.id')))
+
+                parent_item: Optional['SimpleItems'] = Relationship(\
+back_populates='parent_item_reverse', sa_relationship_kwargs={\
+'remote_side': '[SimpleItems.id]'})
+                parent_item_reverse: list['SimpleItems'] = Relationship(\
+back_populates='parent_item', sa_relationship_kwargs={\
+'remote_side': '[SimpleItems.parent_item_id]'})
+        """,
+    )
+
+
+def test_onetomany_selfref_multi(generator: CodeGenerator) -> None:
+    Table(
+        "simple_items_selfref",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column("parent_item_id", INTEGER),
+        Column("top_item_id", INTEGER),
+        ForeignKeyConstraint(["parent_item_id"], ["simple_items_selfref.id"]),
+        ForeignKeyConstraint(["top_item_id"], ["simple_items_selfref.id"]),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+            from typing import Optional
+
+            from sqlalchemy import Column, ForeignKey, Integer
+            from sqlmodel import Field, Relationship, SQLModel
+
+            class SimpleItemsSelfref(SQLModel, table=True):
+                __tablename__ = 'simple_items_selfref'
+
+                id: int = Field(sa_column=Column('id', Integer, primary_key=True))
+                parent_item_id: Optional[int] = Field(default=None, sa_column=Column(\
+'parent_item_id', ForeignKey('simple_items_selfref.id')))
+                top_item_id: Optional[int] = Field(default=None, sa_column=Column(\
+'top_item_id', ForeignKey('simple_items_selfref.id')))
+
+                parent_item: Optional['SimpleItemsSelfref'] = Relationship(\
+back_populates='parent_item_reverse', sa_relationship_kwargs={\
+'remote_side': '[SimpleItemsSelfref.id]', \
+'foreign_keys': '[SimpleItemsSelfref.parent_item_id]'})
+                parent_item_reverse: list['SimpleItemsSelfref'] = Relationship(\
+back_populates='parent_item', sa_relationship_kwargs={\
+'remote_side': '[SimpleItemsSelfref.parent_item_id]', \
+'foreign_keys': '[SimpleItemsSelfref.parent_item_id]'})
+                top_item: Optional['SimpleItemsSelfref'] = Relationship(\
+back_populates='top_item_reverse', sa_relationship_kwargs={\
+'remote_side': '[SimpleItemsSelfref.id]', \
+'foreign_keys': '[SimpleItemsSelfref.top_item_id]'})
+                top_item_reverse: list['SimpleItemsSelfref'] = Relationship(\
+back_populates='top_item', sa_relationship_kwargs={\
+'remote_side': '[SimpleItemsSelfref.top_item_id]', \
+'foreign_keys': '[SimpleItemsSelfref.top_item_id]'})
+        """,
+    )

{sqlacodegen-4.0.0rc3 → sqlacodegen-4.0.2}/tests/test_generator_tables.py

@@ -76,7 +76,7 @@ def test_fancy_coltypes(generator: CodeGenerator) -> None:
 
         t_simple_items = Table(
             'simple_items', metadata,
-            Column('enum', Enum(Blah, values_callable=lambda cls: [member.value for member in cls])),
+            Column('enum', Enum(Blah, values_callable=lambda cls: [member.value for member in cls], name='blah', schema='someschema')),
             Column('bool', Boolean),
             Column('vector', VECTOR(3)),
             Column('number', Numeric(10, asdecimal=False)),
@@ -309,13 +309,13 @@ def test_enum_shared_values(generator: CodeGenerator) -> None:
         t_accounts = Table(
             'accounts', metadata,
             Column('id', Integer, primary_key=True),
-            Column('status', Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls]))
+            Column('status', Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls], name='status_enum'))
         )
 
         t_users = Table(
             'users', metadata,
             Column('id', Integer, primary_key=True),
-            Column('status', Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls]))
+            Column('status', Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls], name='status_enum'))
         )
         """,
     )
@@ -348,7 +348,7 @@ def test_array_enum_named(generator: CodeGenerator) -> None:
         t_users = Table(
             'users', metadata,
             Column('id', Integer, primary_key=True),
-            Column('roles', ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls])))
+            Column('roles', ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls], name='role_enum')))
         )
         """,
     )
@@ -386,13 +386,87 @@ def test_array_enum_shared(generator: CodeGenerator) -> None:
         t_groups = Table(
             'groups', metadata,
             Column('id', Integer, primary_key=True),
-            Column('allowed_roles', ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls])))
+            Column('allowed_roles', ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls], name='role_enum')))
         )
 
         t_users = Table(
             'users', metadata,
             Column('id', Integer, primary_key=True),
-            Column('roles', ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls])))
+            Column('roles', ARRAY(Enum(RoleEnum, values_callable=lambda cls: [member.value for member in cls], name='role_enum')))
+        )
+        """,
+    )
+
+
+def test_enum_named_with_schema(generator: CodeGenerator) -> None:
+    Table(
+        "my_table",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column(
+            "status",
+            SAEnum("active", "inactive", name="status_enum", schema="custom_schema"),
+        ),
+        schema="custom_schema",
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+        import enum
+
+        from sqlalchemy import Column, Enum, Integer, MetaData, Table
+
+        metadata = MetaData()
+
+
+        class StatusEnum(str, enum.Enum):
+            ACTIVE = 'active'
+            INACTIVE = 'inactive'
+
+
+        t_my_table = Table(
+            'my_table', metadata,
+            Column('id', Integer, primary_key=True),
+            Column('status', Enum(StatusEnum, values_callable=lambda cls: [member.value for member in cls], name='status_enum', schema='custom_schema')),
+            schema='custom_schema'
+        )
+        """,
+    )
+
+
+def test_array_enum_named_with_schema(generator: CodeGenerator) -> None:
+    Table(
+        "my_table",
+        generator.metadata,
+        Column("id", INTEGER, primary_key=True),
+        Column(
+            "tags",
+            ARRAY(SAEnum("a", "b", name="tag_enum", schema="custom_schema")),
+        ),
+        schema="custom_schema",
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+        import enum
+
+        from sqlalchemy import ARRAY, Column, Enum, Integer, MetaData, Table
+
+        metadata = MetaData()
+
+
+        class TagEnum(str, enum.Enum):
+            A = 'a'
+            B = 'b'
+
+
+        t_my_table = Table(
+            'my_table', metadata,
+            Column('id', Integer, primary_key=True),
+            Column('tags', ARRAY(Enum(TagEnum, values_callable=lambda cls: [member.value for member in cls], name='tag_enum', schema='custom_schema'))),
+            schema='custom_schema'
         )
         """,
     )
@@ -529,6 +603,34 @@ def test_mysql_column_types(generator: CodeGenerator) -> None:
     )
 
 
+@pytest.mark.parametrize("engine", ["mysql"], indirect=["engine"])
+@pytest.mark.parametrize("generator", [["keep_dialect_types"]], indirect=True)
+def test_mysql_char_collation_keep_dialect_types(generator: CodeGenerator) -> None:
+    Table(
+        "simple_items",
+        generator.metadata,
+        Column("id", mysql.INTEGER, primary_key=True),
+        Column("result_code", mysql.CHAR(1, collation="utf8mb3_bin"), nullable=False),
+    )
+
+    validate_code(
+        generator.generate(),
+        """\
+        from sqlalchemy import Column, MetaData, Table
+        from sqlalchemy.dialects.mysql import CHAR, INTEGER
+
+        metadata = MetaData()
+
+
+        t_simple_items = Table(
+            'simple_items', metadata,
+            Column('id', INTEGER, primary_key=True),
+            Column('result_code', CHAR(1, collation='utf8mb3_bin'), nullable=False)
+        )
+        """,
+    )
+
+
 def test_constraints(generator: CodeGenerator) -> None:
     Table(
         "simple_items",