From 439ddaa52d41973ab30ed136705977533c737563 Mon Sep 17 00:00:00 2001 From: Mohammed Ba Karman Date: Sat, 21 Nov 2026 12:25:12 +0300 Subject: [PATCH] Reject frozen assignments before SQLAlchemy records changes --- sqlmodel/main.py | 24 ++++++++- tests/test_validation.py | 114 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 135 insertions(+), 3 deletions(-) diff --git a/sqlmodel/main.py b/sqlmodel/main.py index 0d4ccd7634..d72b3e71af 100644 --- a/sqlmodel/main.py +++ b/sqlmodel/main.py @@ -25,7 +25,14 @@ overload, ) -from pydantic import AwareDatetime, BaseModel, Discriminator, EmailStr, NaiveDatetime +from pydantic import ( + AwareDatetime, + BaseModel, + Discriminator, + EmailStr, + NaiveDatetime, + ValidationError, +) from pydantic.fields import FieldInfo as PydanticFieldInfo from sqlalchemy import ( Boolean, @@ -841,6 +848,20 @@ def get_column_from_field(field: Any) -> Column: _TSQLModel = TypeVar("_TSQLModel", bound="SQLModel") +def _reject_frozen(cls: type[SQLModel], name: str, value: Any) -> None: + field = cls.__pydantic_fields__.get(name) + if field is None: + return + + model_frozen: bool = cls.model_config.get("frozen", False) + if (model_frozen or field.frozen) and name not in cls.__sqlmodel_relationships__: + error_type: str = "frozen_instance" if model_frozen else "frozen_field" + raise ValidationError.from_exception_data( + cls.__name__, + [{"type": error_type, "loc": (name,), "input": value}], + ) + + class SQLModel(BaseModel, metaclass=SQLModelMetaclass, registry=default_registry): # SQLAlchemy needs to set weakref(s), Pydantic will set the other slots values __slots__ = ("__weakref__",) @@ -890,6 +911,7 @@ def __setattr__(self, name: str, value: Any) -> None: else: # Set in SQLAlchemy, before Pydantic to trigger events and updates if is_table_model_class(self.__class__) and is_instrumented(self, name): + _reject_frozen(self.__class__, name, value) set_attribute(self, name, value) # Set in Pydantic model to trigger possible validation changes, only for # non relationship values diff --git a/tests/test_validation.py b/tests/test_validation.py index 47fbca87c2..8945077408 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -1,6 +1,9 @@ +from unittest.mock import Mock + import pytest -from pydantic.error_wrappers import ValidationError -from sqlmodel import SQLModel +from pydantic import ValidationError +from sqlalchemy import Engine, event, insert, inspect +from sqlmodel import Field, Relationship, Session, SQLModel def test_validation_pydantic_v2(clear_sqlmodel): @@ -29,3 +32,110 @@ def reject_none(cls, v): with pytest.raises(ValidationError): Hero.model_validate({"name": None, "age": 25}) + + +@pytest.mark.parametrize("expired", [False, True], ids=["loaded", "expired"]) +def test_frozen_field_assignment_preserves_pending_edits( + database_engine: Engine, expired: bool +) -> None: + class Hero(SQLModel, table=True): + id: int = Field(primary_key=True) + code: str = Field(schema_extra={"frozen": True}) + name: str + + SQLModel.metadata.create_all(database_engine) + with database_engine.begin() as connection: + connection.execute(insert(Hero).values(id=1, code="original", name="old")) + + on_set = Mock() + event.listen(Hero.code, "set", on_set, active_history=True) + with Session(database_engine) as session: + hero = session.get(Hero, 1) + assert hero is not None + hero.name = "updated" + if expired: + session.expire(hero, ["code"]) + + with pytest.raises(ValidationError) as exc_info: + hero.code = "rejected" + + (error,) = exc_info.value.errors() + assert error["type"] == "frozen_field" + assert error["loc"] == ("code",) + assert error["input"] == "rejected" + state = inspect(hero) + if expired: + assert "code" in state.expired_attributes + assert not state.attrs.code.history.has_changes() + assert hero.code == "original" + session.commit() + + on_set.assert_not_called() + with Session(database_engine) as session: + saved = session.get(Hero, 1) + assert saved is not None + assert (saved.code, saved.name) == ("original", "updated") + + +@pytest.mark.parametrize( + "field_frozen", [False, True], ids=["model", "model-and-field"] +) +def test_frozen_model_assignment_preserves_primary_key( + database_engine: Engine, field_frozen: bool +) -> None: + class Hero(SQLModel, table=True): + model_config = {"frozen": True} + id: int = Field(primary_key=True, schema_extra={"frozen": field_frozen}) + + SQLModel.metadata.create_all(database_engine) + with database_engine.begin() as connection: + connection.execute(insert(Hero).values(id=1)) + + with Session(database_engine) as session: + hero = session.get(Hero, 1) + assert hero is not None + with pytest.raises(ValidationError) as exc_info: + hero.id = 2 + + (error,) = exc_info.value.errors() + assert error["type"] == "frozen_instance" + assert error["loc"] == ("id",) + session.commit() + + with Session(database_engine) as session: + assert session.get(Hero, 1) is not None + assert session.get(Hero, 2) is None + + +def test_frozen_foreign_key_preserves_pending_relationship_change( + database_engine: Engine, +) -> None: + class Team(SQLModel, table=True): + id: int = Field(primary_key=True) + + class Hero(SQLModel, table=True): + id: int = Field(primary_key=True) + team_id: int = Field(foreign_key="team.id", schema_extra={"frozen": True}) + team: Team = Relationship() + + SQLModel.metadata.create_all(database_engine) + with database_engine.begin() as connection: + connection.execute(insert(Team), [{"id": 1}, {"id": 2}]) + connection.execute(insert(Hero).values(id=1, team_id=1)) + + with Session(database_engine) as session: + hero = session.get(Hero, 1) + team = session.get(Team, 2) + assert hero is not None + assert team is not None + hero.team = team + with pytest.raises(ValidationError): + hero.team_id = 3 + + assert hero.team_id == 1 + session.commit() + + with Session(database_engine) as session: + saved = session.get(Hero, 1) + assert saved is not None + assert saved.team_id == 2