✨Properly support inheritance of Relationship attributes

sqlmodel/main.py

@@ -415,6 +415,8 @@ def __new__(
         **kwargs: Any,
     ) -> Any:
         relationships: Dict[str, RelationshipInfo] = {}
+        for base in bases:
+            relationships.update(getattr(base, "__sqlmodel_relationships__", {}))
         dict_for_pydantic = {}
         original_annotations = get_annotations(class_dict)
         pydantic_annotations = {}
@@ -471,8 +473,9 @@ def get_config(name: str) -> Any:
             # If it was passed by kwargs, ensure it's also set in config
             set_config_value(model=new_cls, parameter="table", value=config_table)
             for k, v in get_model_fields(new_cls).items():
-                col = get_column_from_field(v)
-                setattr(new_cls, k, col)
+                if k not in relationships:
+                    col = get_column_from_field(v)
+                    setattr(new_cls, k, col)
             # Set a config flag to tell FastAPI that this should be read with a field
             # in orm_mode instead of preemptively converting it to a dict.
             # This could be done by reading new_cls.model_config['table'] in FastAPI, but

tests/test_relationship_inheritance.py

@@ -0,0 +1,62 @@
+from typing import Optional
+
+from sqlalchemy.orm import declared_attr, relationship
+from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select
+
+
+def test_relationship_inheritance() -> None:
+    class User(SQLModel, table=True):
+        id: Optional[int] = Field(default=None, primary_key=True)
+        name: str
+
+    class CreatedUpdatedMixin(SQLModel):
+        # With Pydantic V2, it is also possible to define `created_by` like this:
+        #
+        #   ```python
+        #   @declared_attr
+        #   def _created_by(cls):
+        #       return relationship(User, foreign_keys=cls.created_by_id)
+        #
+        #   created_by: Optional[User] = Relationship(sa_relationship=_created_by))
+        #   ```
+        #
+        # The difference from Pydantic V1 is that Pydantic V2 plucks attributes with names starting with '_' (but not '__')
+        # from class attributes and stores them separately as instances of `pydantic.ModelPrivateAttr` somewhere in depths of
+        # Pydantic internals.  Under Pydantic V1 this doesn't happen, so SQLAlchemy ends up having two class attributes
+        # (`_created_by` and `created_by`) corresponding to one database attribute, causing a conflict and unreliable behavior.
+        # The approach with a lambda always works because it doesn't produce the second class attribute and thus eliminates
+        # the possibility of a conflict entirely.
+        #
+        created_by_id: Optional[int] = Field(default=None, foreign_key="user.id")
+        created_by: Optional[User] = Relationship(
+            sa_relationship=declared_attr(
+                lambda cls: relationship(User, foreign_keys=cls.created_by_id)
+            )
+        )
+
+        updated_by_id: Optional[int] = Field(default=None, foreign_key="user.id")
+        updated_by: Optional[User] = Relationship(
+            sa_relationship=declared_attr(
+                lambda cls: relationship(User, foreign_keys=cls.updated_by_id)
+            )
+        )
+
+    class Asset(CreatedUpdatedMixin, table=True):
+        id: Optional[int] = Field(default=None, primary_key=True)
+
+    engine = create_engine("sqlite://")
+
+    SQLModel.metadata.create_all(engine)
+
+    john = User(name="John")
+    jane = User(name="Jane")
+    asset = Asset(created_by=john, updated_by=jane)
+
+    with Session(engine) as session:
+        session.add(asset)
+        session.commit()
+
+    with Session(engine) as session:
+        asset = session.exec(select(Asset)).one()
+        assert asset.created_by.name == "John"
+        assert asset.updated_by.name == "Jane"