plain.models 0.34.2__tar.gz → 0.34.4__tar.gz

{plain_models-0.34.2 → plain_models-0.34.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.models
-Version: 0.34.2
+Version: 0.34.4
 Summary: Database models for Plain.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/CHANGELOG.md

@@ -1,5 +1,26 @@
 # plain-models changelog
 
+## [0.34.4](https://github.com/dropseed/plain/releases/plain-models@0.34.4) (2025-07-02)
+
+### What's changed
+
+- The built-in `on_delete` behaviors (`CASCADE`, `PROTECT`, `RESTRICT`, `SET_NULL`, `SET_DEFAULT`, and the callables returned by `SET(...)`) no longer receive the legacy `using` argument. Their signatures are now `(collector, field, sub_objs)` ([20325a1](https://github.com/dropseed/plain/commit/20325a1)).
+- Removed the unused `interprets_empty_strings_as_nulls` backend feature flag and the related fallback logic ([285378c](https://github.com/dropseed/plain/commit/285378c)).
+
+### Upgrade instructions
+
+- No changes required
+
+## [0.34.3](https://github.com/dropseed/plain/releases/plain-models@0.34.3) (2025-06-29)
+
+### What's changed
+
+- Simplified log output when creating or destroying test databases during test setup. The messages now display the test database name directly and no longer reference the deprecated "alias" terminology ([a543706](https://github.com/dropseed/plain/commit/a543706)).
+
+### Upgrade instructions
+
+- No changes required
+
 ## [0.34.2](https://github.com/dropseed/plain/releases/plain-models@0.34.2) (2025-06-27)
 
 ### What's changed

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/backends/base/creation.py

@@ -36,9 +36,7 @@ class BaseDatabaseCreation:
         test_database_name = self._get_test_db_name(prefix)
 
         if verbosity >= 1:
-            self.log(
-                f"Creating test database for alias {self._get_database_display_str(verbosity, test_database_name)}..."
-            )
+            self.log(f"Creating test database '{test_database_name}'...")
 
         self._create_test_db(
             test_database_name=test_database_name, verbosity=verbosity, autoclobber=True
@@ -127,15 +125,6 @@ class BaseDatabaseCreation:
     #         # because constraint checks were disabled.
     #         self.connection.check_constraints(table_names=table_names)
 
-    def _get_database_display_str(self, verbosity, database_name):
-        """
-        Return display string for a database for use in various actions.
-        """
-        return "'{}'{}".format(
-            self.connection.alias,
-            (f" ('{database_name}')") if verbosity >= 2 else "",
-        )
-
     def _get_test_db_name(self, prefix=""):
         """
         Internal implementation - return the name of the test DB that will be
@@ -182,11 +171,7 @@ class BaseDatabaseCreation:
                     try:
                         if verbosity >= 1:
                             self.log(
-                                "Destroying old test database for alias {}...".format(
-                                    self._get_database_display_str(
-                                        verbosity, test_database_name
-                                    ),
-                                )
+                                f"Destroying old test database '{test_database_name}'..."
                             )
                         cursor.execute(
                             "DROP DATABASE {dbname}".format(**test_db_params)
@@ -211,9 +196,7 @@ class BaseDatabaseCreation:
         test_database_name = self.connection.settings_dict["NAME"]
 
         if verbosity >= 1:
-            self.log(
-                f"Destroying test database for alias {self._get_database_display_str(verbosity, test_database_name)}..."
-            )
+            self.log(f"Destroying test database '{test_database_name}'...")
         self._destroy_test_db(test_database_name, verbosity)
 
         # Restore the original database name

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/backends/base/features.py

@@ -9,9 +9,6 @@ class BaseDatabaseFeatures:
     empty_fetchmany_value = []
     update_can_self_select = True
 
-    # Does the backend distinguish between '' and None?
-    interprets_empty_strings_as_nulls = False
-
     # Does the backend support initially deferrable unique constraints?
     supports_deferrable_unique_constraints = False
 

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/backends/base/schema.py

@@ -297,14 +297,6 @@ class BaseDatabaseSchemaEditor:
                 else:
                     yield column_default
                     params.append(default_value)
-        # Oracle treats the empty string ('') as null, so coerce the null
-        # option whenever '' is a possible value.
-        if (
-            field.empty_strings_allowed
-            and not field.primary_key
-            and self.connection.features.interprets_empty_strings_as_nulls
-        ):
-            null = True
 
         if not null:
             yield "NOT NULL"
@@ -1042,27 +1034,20 @@ class BaseDatabaseSchemaEditor:
         Return a (sql, params) fragment to set a column to null or non-null
         as required by new_field, or None if no changes are required.
         """
-        if (
-            self.connection.features.interprets_empty_strings_as_nulls
-            and new_field.empty_strings_allowed
-        ):
-            # The field is nullable in the database anyway, leave it alone.
-            return
-        else:
-            new_db_params = new_field.db_parameters(connection=self.connection)
-            sql = (
-                self.sql_alter_column_null
-                if new_field.allow_null
-                else self.sql_alter_column_not_null
-            )
-            return (
-                sql
-                % {
-                    "column": self.quote_name(new_field.column),
-                    "type": new_db_params["type"],
-                },
-                [],
-            )
+        new_db_params = new_field.db_parameters(connection=self.connection)
+        sql = (
+            self.sql_alter_column_null
+            if new_field.allow_null
+            else self.sql_alter_column_not_null
+        )
+        return (
+            sql
+            % {
+                "column": self.quote_name(new_field.column),
+                "type": new_db_params["type"],
+            },
+            [],
+        )
 
     def _alter_column_default_sql(self, model, old_field, new_field, drop=False):
         """

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/backends/sqlite3/creation.py

@@ -32,9 +32,7 @@ class DatabaseCreation(BaseDatabaseCreation):
         if not self.is_in_memory_db(test_database_name):
             # Erase the old test database file.
             if verbosity >= 1:
-                self.log(
-                    f"Destroying old test database for alias {self._get_database_display_str(verbosity, test_database_name)}..."
-                )
+                self.log(f"Destroying old test database '{test_database_name}'...")
             if os.access(test_database_name, os.F_OK):
                 if not autoclobber:
                     confirm = input(

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/base.py

@@ -833,10 +833,7 @@ class Model(metaclass=ModelBase):
                 f = self._meta.get_field(field_name)
                 lookup_value = getattr(self, f.attname)
                 # TODO: Handle multiple backends with different feature flags.
-                if lookup_value is None or (
-                    lookup_value == ""
-                    and db_connection.features.interprets_empty_strings_as_nulls
-                ):
+                if lookup_value is None:
                     # no value, skip the lookup
                     continue
                 if f.primary_key and not self._state.adding:

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/constraints.py

@@ -2,7 +2,6 @@ from enum import Enum
 from types import NoneType
 
 from plain.exceptions import FieldError, ValidationError
-from plain.models.db import db_connection
 from plain.models.expressions import Exists, ExpressionList, F, OrderBy
 from plain.models.indexes import IndexExpression
 from plain.models.lookups import Exact
@@ -356,10 +355,7 @@ class UniqueConstraint(BaseConstraint):
                     return
                 field = model._meta.get_field(field_name)
                 lookup_value = getattr(instance, field.attname)
-                if lookup_value is None or (
-                    lookup_value == ""
-                    and db_connection.features.interprets_empty_strings_as_nulls
-                ):
+                if lookup_value is None:
                     # A composite constraint containing NULL value cannot cause
                     # a violation since NULL != NULL in SQL.
                     return

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/deletion.py

@@ -24,7 +24,7 @@ class RestrictedError(IntegrityError):
         super().__init__(msg, restricted_objects)
 
 
-def CASCADE(collector, field, sub_objs, using):
+def CASCADE(collector, field, sub_objs):
     collector.collect(
         sub_objs,
         source=field.remote_field.model,
@@ -35,7 +35,7 @@ def CASCADE(collector, field, sub_objs, using):
         collector.add_field_update(field, None, sub_objs)
 
 
-def PROTECT(collector, field, sub_objs, using):
+def PROTECT(collector, field, sub_objs):
     raise ProtectedError(
         f"Cannot delete some instances of model '{field.remote_field.model.__name__}' because they are "
         f"referenced through a protected foreign key: '{sub_objs[0].__class__.__name__}.{field.name}'",
@@ -43,7 +43,7 @@ def PROTECT(collector, field, sub_objs, using):
     )
 
 
-def RESTRICT(collector, field, sub_objs, using):
+def RESTRICT(collector, field, sub_objs):
     collector.add_restricted_objects(field, sub_objs)
     collector.add_dependency(field.remote_field.model, field.model)
 
@@ -51,12 +51,12 @@ def RESTRICT(collector, field, sub_objs, using):
 def SET(value):
     if callable(value):
 
-        def set_on_delete(collector, field, sub_objs, using):
+        def set_on_delete(collector, field, sub_objs):
             collector.add_field_update(field, value(), sub_objs)
 
     else:
 
-        def set_on_delete(collector, field, sub_objs, using):
+        def set_on_delete(collector, field, sub_objs):
             collector.add_field_update(field, value, sub_objs)
 
     set_on_delete.deconstruct = lambda: ("plain.models.SET", (value,), {})
@@ -64,21 +64,21 @@ def SET(value):
     return set_on_delete
 
 
-def SET_NULL(collector, field, sub_objs, using):
+def SET_NULL(collector, field, sub_objs):
     collector.add_field_update(field, None, sub_objs)
 
 
 SET_NULL.lazy_sub_objs = True
 
 
-def SET_DEFAULT(collector, field, sub_objs, using):
+def SET_DEFAULT(collector, field, sub_objs):
     collector.add_field_update(field, field.get_default(), sub_objs)
 
 
 SET_DEFAULT.lazy_sub_objs = True
 
 
-def DO_NOTHING(collector, field, sub_objs, using):
+def DO_NOTHING(collector, field, sub_objs):
     pass
 
 

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/fields/__init__.py

@@ -365,11 +365,7 @@ class Field(RegisterLookupMixin):
         return errors
 
     def _check_null_allowed_for_primary_keys(self):
-        if (
-            self.primary_key
-            and self.allow_null
-            and not db_connection.features.interprets_empty_strings_as_nulls
-        ):
+        if self.primary_key and self.allow_null:
             # We cannot reliably check this for backends like Oracle which
             # consider NULL and '' to be equal (and thus set up
             # character-based fields a little differently).
@@ -885,11 +881,7 @@ class Field(RegisterLookupMixin):
                 return self.default
             return lambda: self.default
 
-        if (
-            not self.empty_strings_allowed
-            or self.allow_null
-            and not db_connection.features.interprets_empty_strings_as_nulls
-        ):
+        if not self.empty_strings_allowed or self.allow_null:
             return return_None
         return str  # return empty string
 

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/fields/related.py

@@ -974,11 +974,7 @@ class ForeignKey(ForeignObject):
 
     def get_db_prep_save(self, value, connection):
         if value is None or (
-            value == ""
-            and (
-                not self.target_field.empty_strings_allowed
-                or connection.features.interprets_empty_strings_as_nulls
-            )
+            value == "" and not self.target_field.empty_strings_allowed
         ):
             return None
         else:
@@ -1019,8 +1015,6 @@ class ForeignKey(ForeignObject):
 
     def get_db_converters(self, connection):
         converters = super().get_db_converters(connection)
-        if connection.features.interprets_empty_strings_as_nulls:
-            converters += [self.convert_empty_strings]
         return converters
 
     def get_col(self, alias, output_field=None):

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/fields/related_descriptors.py

@@ -369,15 +369,12 @@ def create_reverse_many_to_one_manager(superclass, rel):
             """
             Filter the queryset for the instance this manager is bound to.
             """
-            empty_strings_as_null = (
-                db_connection.features.interprets_empty_strings_as_nulls
-            )
             queryset._add_hints(instance=self.instance)
             queryset._defer_next_filter = True
             queryset = queryset.filter(**self.core_filters)
             for field in self.field.foreign_related_fields:
                 val = getattr(self.instance, field.attname)
-                if val is None or (val == "" and empty_strings_as_null):
+                if val is None:
                     return queryset.none()
             if self.field.many_to_one:
                 # Guard against field-like objects such as GenericRelation

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/forms.py

@@ -769,13 +769,7 @@ def modelfield_to_formfield(
         # Passing max_length to forms.CharField means that the value's length
         # will be validated twice. This is considered acceptable since we want
         # the value in the form field (to pass into widget for example).
-        # TODO: Handle multiple backends with different feature flags.
-        from plain.models.db import db_connection
-
-        if (
-            modelfield.allow_null
-            and not db_connection.features.interprets_empty_strings_as_nulls
-        ):
+        if modelfield.allow_null:
             defaults["empty_value"] = None
         return fields.CharField(
             max_length=modelfield.max_length,

{plain_models-0.34.2 → plain_models-0.34.4}/plain/models/sql/query.py

@@ -1233,16 +1233,6 @@ class Query(BaseExpression):
                 raise ValueError("Cannot use None as a query value")
             return lhs.get_lookup("isnull")(lhs, True)
 
-        # For Oracle '' is equivalent to null. The check must be done at this
-        # stage because join promotion can't be done in the compiler. A similar
-        # thing is done in is_nullable(), too.
-        if (
-            lookup_name == "exact"
-            and lookup.rhs == ""
-            and db_connection.features.interprets_empty_strings_as_nulls
-        ):
-            return lhs.get_lookup("isnull")(lhs, True)
-
         return lookup
 
     def try_transform(self, lhs, name):
@@ -2466,20 +2456,11 @@ class Query(BaseExpression):
         return trimmed_prefix, contains_louter
 
     def is_nullable(self, field):
-        """
-        Check if the given field should be treated as nullable.
-
-        Some backends treat '' as null and Plain treats such fields as
-        nullable for those backends. In such situations field.allow_null can be
-        False even if we should treat the field as nullable.
-        """
+        """Check if the given field should be treated as nullable."""
         # QuerySet does not have knowledge of which connection is going to be
         # used. For the single-database setup we always reference the default
         # connection here.
-        return field.allow_null or (
-            field.empty_strings_allowed
-            and db_connection.features.interprets_empty_strings_as_nulls
-        )
+        return field.allow_null
 
 
 def get_order_dir(field, default="ASC"):

{plain_models-0.34.2 → plain_models-0.34.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.models"
-version = "0.34.2"
+version = "0.34.4"
 description = "Database models for Plain."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 readme = "README.md"

plain_models-0.34.4/tests/app/examples/migrations/0003_deleteparent_childsetnull_childsetdefault_and_more.py

@@ -0,0 +1,101 @@
+# Generated by Plain 0.52.2 on 2025-07-02 18:16
+
+import plain.models.deletion
+from plain import models
+from plain.models import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("examples", "0002_test_field_removed"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="DeleteParent",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True)),
+                ("name", models.CharField(max_length=100)),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ChildSetNull",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True)),
+                (
+                    "parent",
+                    models.ForeignKey(
+                        allow_null=True,
+                        on_delete=plain.models.deletion.SET_NULL,
+                        to="examples.deleteparent",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ChildSetDefault",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True)),
+                (
+                    "parent",
+                    models.ForeignKey(
+                        default=1,
+                        on_delete=plain.models.deletion.SET_DEFAULT,
+                        to="examples.deleteparent",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ChildDoNothing",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True)),
+                (
+                    "parent",
+                    models.ForeignKey(
+                        on_delete=plain.models.deletion.DO_NOTHING,
+                        to="examples.deleteparent",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ChildCascade",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True)),
+                (
+                    "parent",
+                    models.ForeignKey(
+                        on_delete=plain.models.deletion.CASCADE,
+                        to="examples.deleteparent",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ChildRestrict",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True)),
+                (
+                    "parent",
+                    models.ForeignKey(
+                        on_delete=plain.models.deletion.RESTRICT,
+                        to="examples.deleteparent",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="ChildProtect",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True)),
+                (
+                    "parent",
+                    models.ForeignKey(
+                        on_delete=plain.models.deletion.PROTECT,
+                        to="examples.deleteparent",
+                    ),
+                ),
+            ],
+        ),
+    ]

plain_models-0.34.4/tests/app/examples/models.py

@@ -0,0 +1,59 @@
+from plain import models
+
+
+@models.register_model
+class Car(models.Model):
+    make = models.CharField(max_length=100)
+    model = models.CharField(max_length=100)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(fields=["make", "model"], name="unique_make_model"),
+        ]
+
+
+class UnregisteredModel(models.Model):
+    pass
+
+
+@models.register_model
+class DeleteParent(models.Model):
+    name = models.CharField(max_length=100)
+
+
+@models.register_model
+class ChildCascade(models.Model):
+    parent = models.ForeignKey(DeleteParent, on_delete=models.CASCADE)
+
+
+@models.register_model
+class ChildProtect(models.Model):
+    parent = models.ForeignKey(DeleteParent, on_delete=models.PROTECT)
+
+
+@models.register_model
+class ChildRestrict(models.Model):
+    parent = models.ForeignKey(DeleteParent, on_delete=models.RESTRICT)
+
+
+@models.register_model
+class ChildSetNull(models.Model):
+    parent = models.ForeignKey(
+        DeleteParent,
+        on_delete=models.SET_NULL,
+        allow_null=True,
+    )
+
+
+@models.register_model
+class ChildSetDefault(models.Model):
+    parent = models.ForeignKey(
+        DeleteParent,
+        on_delete=models.SET_DEFAULT,
+        default=1,
+    )
+
+
+@models.register_model
+class ChildDoNothing(models.Model):
+    parent = models.ForeignKey(DeleteParent, on_delete=models.DO_NOTHING)

plain_models-0.34.4/tests/test_delete_behaviors.py

@@ -0,0 +1,76 @@
+import pytest
+from app.examples.models import (
+    ChildCascade,
+    ChildDoNothing,
+    ChildProtect,
+    ChildRestrict,
+    ChildSetDefault,
+    ChildSetNull,
+    DeleteParent,
+)
+
+from plain.models import (
+    IntegrityError,
+    ProtectedError,
+    RestrictedError,
+    db_connection,
+)
+
+
+def _create_parents():
+    default_parent = DeleteParent.objects.create(name="default")
+    parent = DeleteParent.objects.create(name="parent")
+    return default_parent, parent
+
+
+def test_cascade_delete(db):
+    _create_parents()
+    parent = DeleteParent.objects.get(name="parent")
+    ChildCascade.objects.create(parent=parent)
+    parent.delete()
+    assert ChildCascade.objects.count() == 0
+
+
+def test_protect_delete(db):
+    _create_parents()
+    parent = DeleteParent.objects.get(name="parent")
+    ChildProtect.objects.create(parent=parent)
+    with pytest.raises(ProtectedError):
+        parent.delete()
+    assert DeleteParent.objects.filter(pk=parent.pk).exists()
+
+
+def test_restrict_delete(db):
+    _create_parents()
+    parent = DeleteParent.objects.get(name="parent")
+    ChildRestrict.objects.create(parent=parent)
+    with pytest.raises(RestrictedError):
+        parent.delete()
+    assert DeleteParent.objects.filter(pk=parent.pk).exists()
+
+
+def test_set_null_delete(db):
+    _create_parents()
+    parent = DeleteParent.objects.get(name="parent")
+    child = ChildSetNull.objects.create(parent=parent)
+    parent.delete()
+    child.refresh_from_db()
+    assert child.parent_id is None
+
+
+def test_set_default_delete(db):
+    default_parent, parent = _create_parents()
+    child = ChildSetDefault.objects.create(parent=parent)
+    parent.delete()
+    child.refresh_from_db()
+    assert child.parent_id == default_parent.pk
+
+
+def test_do_nothing_delete(db):
+    default_parent, parent = _create_parents()
+    child = ChildDoNothing.objects.create(parent=parent)
+    parent.delete()
+    with pytest.raises(IntegrityError):
+        db_connection.check_constraints()
+    child.parent = default_parent
+    child.save(clean_and_validate=False)

plain_models-0.34.2/tests/app/examples/models.py

@@ -1,16 +0,0 @@
-from plain import models
-
-
-@models.register_model
-class Car(models.Model):
-    make = models.CharField(max_length=100)
-    model = models.CharField(max_length=100)
-
-    class Meta:
-        constraints = [
-            models.UniqueConstraint(fields=["make", "model"], name="unique_make_model"),
-        ]
-
-
-class UnregisteredModel(models.Model):
-    pass