Fixed conflict between server_default and column attributes

Fixes #185.

Author: agronholm

CHANGES.rst

@@ -10,6 +10,7 @@ Version history
 - Fixed improper handling of schema prefixes in sequence names in server defaults
 - Fixed identically named tables from different schemas resulting in invalid generated
   code
+- Fixed imports caused by ``server_default`` conflicting with class attribute names
 - Worked around PostgreSQL UUID columns getting ``Any`` as the type annotation
 
 **3.0.0b3**

src/sqlacodegen/generators.py

@@ -198,6 +198,15 @@ def collect_imports_for_column(self, column: Column[Any]) -> None:
             ):
                 self.add_import(column.type.astext_type)
 
+        if column.default:
+            self.add_import(column.default)
+
+        if column.server_default:
+            if isinstance(column.server_default, (Computed, Identity)):
+                self.add_import(column.server_default)
+            elif isinstance(column.server_default, DefaultClause):
+                self.add_literal_import("sqlalchemy", "text")
+
     def collect_imports_for_constraint(self, constraint: Constraint | Index) -> None:
         if isinstance(constraint, Index):
             if len(constraint.columns) > 1 or not uses_default_name(constraint):
@@ -382,6 +391,9 @@ def render_column(self, column: Column[Any], show_name: bool) -> str:
         for fk in dedicated_fks:
             args.append(self.render_constraint(fk))
 
+        if column.default:
+            args.append(repr(column.default))
+
         if column.key != column.name:
             kwargs["key"] = column.key
         if is_primary:
@@ -401,31 +413,6 @@ def render_column(self, column: Column[Any], show_name: bool) -> str:
             kwargs["server_default"] = render_callable(
                 "text", repr(column.server_default.arg.text)
             )
-            if isinstance(column.server_default.arg, TextClause):
-                if self.bind.dialect.name == "postgresql":
-                    match = _re_postgresql_nextval_sequence.match(
-                        column.server_default.arg.text
-                    )
-                    if match:
-                        # Add an explicit sequence
-                        if match.group(2) != f"{column.table.name}_{column.name}_seq":
-                            callable_kwargs = {}
-                            if match.group(1):
-                                callable_kwargs["schema"] = repr(match.group(1))
-
-                            args.append(
-                                render_callable(
-                                    "Sequence",
-                                    repr(match.group(2)),
-                                    kwargs=callable_kwargs,
-                                )
-                            )
-                            self.add_literal_import("sqlalchemy", "Sequence")
-
-                        del kwargs["server_default"]
-
-            if "server_default" in kwargs:
-                self.add_literal_import("sqlalchemy", "text")
         elif isinstance(column.server_default, Computed):
             expression = str(column.server_default.sqltext)
 
@@ -436,10 +423,8 @@ def render_column(self, column: Column[Any], show_name: bool) -> str:
             args.append(
                 render_callable("Computed", repr(expression), kwargs=computed_kwargs)
             )
-            self.add_import(Computed)
         elif isinstance(column.server_default, Identity):
             args.append(repr(column.server_default))
-            self.add_import(Identity)
         elif column.server_default:
             kwargs["server_default"] = repr(column.server_default)
 
@@ -603,6 +588,23 @@ def fix_column_types(self, table: Table) -> None:
             except CompileError:
                 pass
 
+            # PostgreSQL specific fix: detect sequences from server_default
+            if column.server_default and self.bind.dialect.name == "postgresql":
+                if isinstance(column.server_default, DefaultClause) and isinstance(
+                    column.server_default.arg, TextClause
+                ):
+                    match = _re_postgresql_nextval_sequence.match(
+                        column.server_default.arg.text
+                    )
+                    if match:
+                        # Add an explicit sequence
+                        if match.group(2) != f"{column.table.name}_{column.name}_seq":
+                            column.default = sqlalchemy.Sequence(
+                                match.group(2), schema=match.group(1)
+                            )
+
+                        column.server_default = None
+
     def get_adapted_type(self, coltype: Any) -> Any:
         compiled_type = coltype.compile(self.bind.engine.dialect)
         for supercls in coltype.__class__.__mro__:

tests/test_generators.py

@@ -2208,6 +2208,34 @@ class SimpleItems(Base):
             """,
         )
 
+    # @pytest.mark.xfail(strict=True)
+    def test_colname_import_conflict(self, generator: CodeGenerator) -> None:
+        Table(
+            "simple",
+            generator.metadata,
+            Column("id", INTEGER, primary_key=True),
+            Column("text", VARCHAR),
+            Column("textwithdefault", VARCHAR, server_default=text("'test'")),
+        )
+
+        validate_code(
+            generator.generate(),
+            """\
+            from sqlalchemy import Column, Integer, String, text
+            from sqlalchemy.orm import declarative_base
+
+            Base = declarative_base()
+
+
+            class Simple(Base):
+                __tablename__ = 'simple'
+
+                id = Column(Integer, primary_key=True)
+                text_ = Column('text', String)
+                textwithdefault = Column(String, server_default=text("'test'"))
+            """,
+        )
+
 
 class TestDataclassGenerator:
     @pytest.fixture
@@ -2255,7 +2283,7 @@ def test_mandatory_field_last(self, generator: CodeGenerator) -> None:
             "simple",
             generator.metadata,
             Column("id", INTEGER, primary_key=True),
-            Column("name", VARCHAR(20), default="foo"),
+            Column("name", VARCHAR(20), server_default=text("foo")),
             Column("age", INTEGER, nullable=False),
         )
 
@@ -2267,7 +2295,7 @@ def test_mandatory_field_last(self, generator: CodeGenerator) -> None:
             from dataclasses import dataclass, field
             from typing import Optional
 
-            from sqlalchemy import Column, Integer, String
+            from sqlalchemy import Column, Integer, String, text
             from sqlalchemy.orm import registry
 
             mapper_registry = registry()
@@ -2281,7 +2309,7 @@ class Simple:
 
                 id: int = field(init=False, metadata={'sa': Column(Integer, primary_key=True)})
                 age: int = field(metadata={'sa': Column(Integer, nullable=False)})
-                name: Optional[str] = field(default=None, metadata={'sa': Column(String(20))})
+                name: Optional[str] = field(default=None, metadata={'sa': Column(String(20), server_default=text('foo'))})
             """,
         )