Fixed invalid code generation for identical table names

Fixes #169.

Author: agronholm

CHANGES.rst

@@ -8,6 +8,8 @@ Version history
   named, single column foreign key constraints (PR by Leonardus Chen)
 . Fixed ``KeyError`` when rendering an index without any columns
 - Fixed improper handling of schema prefixes in sequence names in server defaults
+- Fixed identically named tables from different schemas resulting in invalid generated
+  code
 - Worked around PostgreSQL UUID columns getting ``Any`` as the type annotation
 
 **3.0.0b3**

src/sqlacodegen/generators.py

@@ -56,6 +56,7 @@
     get_common_fk_constraints,
     get_compiled_expression,
     get_constraint_sort_key,
+    qualified_table_name,
     render_callable,
     uses_default_name,
 )
@@ -692,6 +693,8 @@ def generate_models(self) -> list[Model]:
         # Pick association tables from the metadata into their own set, don't process them normally
         links: defaultdict[str, list[Model]] = defaultdict(lambda: [])
         for table in self.metadata.sorted_tables:
+            qualified_name = qualified_table_name(table)
+
             # Link tables have exactly two foreign key constraints and all columns are involved in
             # them
             fk_constraints = sorted(
@@ -700,18 +703,18 @@ def generate_models(self) -> list[Model]:
             if len(fk_constraints) == 2 and all(
                 col.foreign_keys for col in table.columns
             ):
-                model = models_by_table_name[table.name] = Model(table)
+                model = models_by_table_name[qualified_name] = Model(table)
                 tablename = fk_constraints[0].elements[0].column.table.name
                 links[tablename].append(model)
                 continue
 
             # Only form model classes for tables that have a primary key and are not association
             # tables
             if not table.primary_key:
-                models_by_table_name[table.name] = Model(table)
+                models_by_table_name[qualified_name] = Model(table)
             else:
                 model = ModelClass(table)
-                models_by_table_name[table.name] = model
+                models_by_table_name[qualified_name] = model
 
                 # Fill in the columns
                 for column in table.c:
@@ -735,7 +738,7 @@ def generate_models(self) -> list[Model]:
                 for constraint in model.table.foreign_key_constraints:
                     if set(get_column_names(constraint)) == pk_column_names:
                         target = models_by_table_name[
-                            constraint.elements[0].column.table.name
+                            qualified_table_name(constraint.elements[0].column.table)
                         ]
                         if isinstance(target, ModelClass):
                             model.parent_class = target
@@ -750,6 +753,7 @@ def generate_models(self) -> list[Model]:
         }
         for model in models_by_table_name.values():
             self.generate_model_name(model, global_names)
+            global_names.add(model.name)
 
         return list(models_by_table_name.values())
 
@@ -767,12 +771,14 @@ def generate_relationships(
         for constraint in sorted(
             source.table.foreign_key_constraints, key=get_constraint_sort_key
         ):
-            target = models_by_table_name[constraint.elements[0].column.table.name]
+            target = models_by_table_name[
+                qualified_table_name(constraint.elements[0].column.table)
+            ]
             if isinstance(target, ModelClass):
                 if "nojoined" not in self.options:
                     if set(get_column_names(constraint)) == pk_column_names:
                         parent = models_by_table_name[
-                            constraint.elements[0].column.table.name
+                            qualified_table_name(constraint.elements[0].column.table)
                         ]
                         if isinstance(parent, ModelClass):
                             source.parent_class = parent
@@ -841,7 +847,7 @@ def generate_relationships(
                 key=get_constraint_sort_key,
             )
             target = models_by_table_name[
-                fk_constraints[1].elements[0].column.table.name
+                qualified_table_name(fk_constraints[1].elements[0].column.table)
             ]
             if isinstance(target, ModelClass):
                 relationship = RelationshipAttribute(

src/sqlacodegen/utils.py

@@ -161,3 +161,10 @@ def render_callable(
 
     rendered_args = delimiter.join(str(arg) for arg in args)
     return f"{name}({prefix}{rendered_args}{suffix})"
+
+
+def qualified_table_name(table: Table) -> str:
+    if table.schema:
+        return f"{table.schema}.{table.name}"
+    else:
+        return str(table.name)

tests/test_generators.py

@@ -1728,6 +1728,42 @@ class SimpleSubItems(SimpleItems):
             """,
         )
 
+    def test_joined_inheritance_same_table_name(self, generator: CodeGenerator) -> None:
+        Table(
+            "simple",
+            generator.metadata,
+            Column("id", INTEGER, primary_key=True),
+        )
+        Table(
+            "simple",
+            generator.metadata,
+            Column("id", INTEGER, ForeignKey("simple.id"), primary_key=True),
+            schema="altschema",
+        )
+
+        validate_code(
+            generator.generate(),
+            """\
+    from sqlalchemy import Column, ForeignKey, Integer
+    from sqlalchemy.orm import declarative_base
+
+    Base = declarative_base()
+
+
+    class Simple(Base):
+        __tablename__ = 'simple'
+
+        id = Column(Integer, primary_key=True)
+
+
+    class Simple_(Simple):
+        __tablename__ = 'simple'
+        __table_args__ = {'schema': 'altschema'}
+
+        id = Column(ForeignKey('simple.id'), primary_key=True)
+            """,
+        )
+
     @pytest.mark.parametrize("generator", [["use_inflect"]], indirect=True)
     def test_use_inflect(self, generator: CodeGenerator) -> None:
         Table(