Remove unused interprets_empty_strings_as_nulls

Author: davegaeddert

plain-models/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/plain/models/backends/base/schema.py

@@ -297,14 +297,6 @@ def _iter_column_sql(
                 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 @@ def _alter_column_null_sql(self, model, old_field, new_field):
         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/plain/models/base.py

@@ -833,10 +833,7 @@ def _perform_unique_checks(self, unique_checks):
                 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/plain/models/constraints.py

@@ -2,7 +2,6 @@
 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 @@ def validate(self, model, instance, exclude=None):
                     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/plain/models/fields/__init__.py

@@ -365,11 +365,7 @@ def _check_db_comment(self, database=False, **kwargs):
         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 @@ def _get_default(self):
                 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/plain/models/fields/related.py

@@ -974,11 +974,7 @@ def get_default(self):
 
     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 @@ def convert_empty_strings(self, value, expression, connection):
 
     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/plain/models/fields/related_descriptors.py

@@ -369,15 +369,12 @@ def _apply_rel_filters(self, queryset):
             """
             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/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/plain/models/sql/query.py

@@ -1233,16 +1233,6 @@ def build_lookup(self, lookups, lhs, rhs):
                 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 @@ def trim_start(self, names_with_path):
         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"):