Fixed #22936 -- Obsoleted Field.get_prep_lookup()/get_db_prep_lookup()

Thanks Tim Graham for completing the initial patch.

4 files changed, 10 insertions, 74 deletions

diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index 5951681e81..e567e12250 100644
--- a/django/db/models/fields/__init__.py
+++ b/django/db/models/fields/__init__.py
@@ -741,8 +741,7 @@ class Field(RegisterLookupMixin):
         """Returns field's value prepared for interacting with the database
         backend.
 
-        Used by the default implementations of ``get_db_prep_save``and
-        `get_db_prep_lookup```
+        Used by the default implementations of get_db_prep_save().
         """
         if not prepared:
             value = self.get_prep_value(value)
@@ -755,36 +754,6 @@ class Field(RegisterLookupMixin):
         return self.get_db_prep_value(value, connection=connection,
                                       prepared=False)
 
-    def get_prep_lookup(self, lookup_type, value):
-        """
-        Perform preliminary non-db specific lookup checks and conversions
-        """
-        if hasattr(value, '_prepare'):
-            return value._prepare(self)
-
-        if lookup_type in {
-            'iexact', 'contains', 'icontains',
-            'startswith', 'istartswith', 'endswith', 'iendswith',
-            'isnull', 'search', 'regex', 'iregex',
-        }:
-            return value
-        elif lookup_type in ('exact', 'gt', 'gte', 'lt', 'lte'):
-            return self.get_prep_value(value)
-        elif lookup_type in ('range', 'in'):
-            return [self.get_prep_value(v) for v in value]
-        return self.get_prep_value(value)
-
-    def get_db_prep_lookup(self, lookup_type, value, connection,
-                           prepared=False):
-        """
-        Returns field's value prepared for database lookup.
-        """
-        if not prepared:
-            value = self.get_prep_lookup(lookup_type, value)
-            prepared = True
-
-        return [value]
-
     def has_default(self):
         """
         Returns a boolean of whether this field has a default value.
@@ -1049,20 +1018,11 @@ class BooleanField(Field):
             params={'value': value},
         )
 
-    def get_prep_lookup(self, lookup_type, value):
-        # Special-case handling for filters coming from a Web request (e.g. the
-        # admin interface). Only works for scalar values (not lists). If you're
-        # passing in a list, you might as well make things the right type when
-        # constructing the list.
-        if value in ('1', '0'):
-            value = bool(int(value))
-        return super(BooleanField, self).get_prep_lookup(lookup_type, value)
-
     def get_prep_value(self, value):
         value = super(BooleanField, self).get_prep_value(value)
         if value is None:
             return None
-        return bool(value)
+        return self.to_python(value)
 
     def formfield(self, **kwargs):
         # Unlike most fields, BooleanField figures out include_blank from
@@ -1453,8 +1413,6 @@ class DateTimeField(DateField):
     # contribute_to_class is inherited from DateField, it registers
     # get_next_by_FOO and get_prev_by_FOO
 
-    # get_prep_lookup is inherited from DateField
-
     def get_prep_value(self, value):
         value = super(DateTimeField, self).get_prep_value(value)
         value = self.to_python(value)
@@ -2051,21 +2009,11 @@ class NullBooleanField(Field):
             params={'value': value},
         )
 
-    def get_prep_lookup(self, lookup_type, value):
-        # Special-case handling for filters coming from a Web request (e.g. the
-        # admin interface). Only works for scalar values (not lists). If you're
-        # passing in a list, you might as well make things the right type when
-        # constructing the list.
-        if value in ('1', '0'):
-            value = bool(int(value))
-        return super(NullBooleanField, self).get_prep_lookup(lookup_type,
-                                                             value)
-
     def get_prep_value(self, value):
         value = super(NullBooleanField, self).get_prep_value(value)
         if value is None:
             return None
-        return bool(value)
+        return self.to_python(value)
 
     def formfield(self, **kwargs):
         defaults = {
diff --git a/django/db/models/fields/files.py b/django/db/models/fields/files.py
index 3ba2c14325..f18e2f39b3 100644
--- a/django/db/models/fields/files.py
+++ b/django/db/models/fields/files.py
@@ -271,11 +271,6 @@ class FileField(Field):
     def get_internal_type(self):
         return "FileField"
 
-    def get_prep_lookup(self, lookup_type, value):
-        if hasattr(value, 'name'):
-            value = value.name
-        return super(FileField, self).get_prep_lookup(lookup_type, value)
-
     def get_prep_value(self, value):
         "Returns field's value prepared for saving into a database."
         value = super(FileField, self).get_prep_value(value)
diff --git a/django/db/models/fields/related_lookups.py b/django/db/models/fields/related_lookups.py
index 0f5a8b5e21..3123e94073 100644
--- a/django/db/models/fields/related_lookups.py
+++ b/django/db/models/fields/related_lookups.py
@@ -44,15 +44,15 @@ class RelatedIn(In):
         if not isinstance(self.lhs, MultiColSource) and self.rhs_is_direct_value():
             # If we get here, we are dealing with single-column relations.
             self.rhs = [get_normalized_value(val, self.lhs)[0] for val in self.rhs]
-            # We need to run the related field's get_prep_lookup(). Consider case
+            # We need to run the related field's get_prep_value(). Consider case
             # ForeignKey to IntegerField given value 'abc'. The ForeignKey itself
             # doesn't have validation for non-integers, so we must run validation
             # using the target field.
             if hasattr(self.lhs.output_field, 'get_path_info'):
-                # Run the target field's get_prep_lookup. We can safely assume there is
+                # Run the target field's get_prep_value. We can safely assume there is
                 # only one as we don't get to the direct value branch otherwise.
-                self.rhs = self.lhs.output_field.get_path_info()[-1].target_fields[-1].get_prep_lookup(
-                    self.lookup_name, self.rhs)
+                target_field = self.lhs.output_field.get_path_info()[-1].target_fields[-1]
+                self.rhs = [target_field.get_prep_value(v) for v in self.rhs]
         return super(RelatedIn, self).get_prep_lookup()
 
     def as_sql(self, compiler, connection):
@@ -88,15 +88,15 @@ class RelatedLookupMixin(object):
         if not isinstance(self.lhs, MultiColSource) and self.rhs_is_direct_value():
             # If we get here, we are dealing with single-column relations.
             self.rhs = get_normalized_value(self.rhs, self.lhs)[0]
-            # We need to run the related field's get_prep_lookup(). Consider case
+            # We need to run the related field's get_prep_value(). Consider case
             # ForeignKey to IntegerField given value 'abc'. The ForeignKey itself
             # doesn't have validation for non-integers, so we must run validation
             # using the target field.
             if hasattr(self.lhs.output_field, 'get_path_info'):
                 # Get the target field. We can safely assume there is only one
                 # as we don't get to the direct value branch otherwise.
-                self.rhs = self.lhs.output_field.get_path_info()[-1].target_fields[-1].get_prep_lookup(
-                    self.lookup_name, self.rhs)
+                target_field = self.lhs.output_field.get_path_info()[-1].target_fields[-1]
+                self.rhs = target_field.get_prep_value(self.rhs)
 
         return super(RelatedLookupMixin, self).get_prep_lookup()
 
diff --git a/django/db/models/fields/reverse_related.py b/django/db/models/fields/reverse_related.py
index c477ab5a93..1554261246 100644
--- a/django/db/models/fields/reverse_related.py
+++ b/django/db/models/fields/reverse_related.py
@@ -110,9 +110,6 @@ class ForeignObjectRel(object):
     def one_to_one(self):
         return self.field.one_to_one
 
-    def get_prep_lookup(self, lookup_name, value):
-        return self.field.get_prep_lookup(lookup_name, value)
-
     def get_lookup(self, lookup_name):
         return self.field.get_lookup(lookup_name)
 
@@ -142,10 +139,6 @@ class ForeignObjectRel(object):
             (x._get_pk_val(), smart_text(x)) for x in self.related_model._default_manager.all()
         ]
 
-    def get_db_prep_lookup(self, lookup_type, value, connection, prepared=False):
-        # Defer to the actual field definition for db prep
-        return self.field.get_db_prep_lookup(lookup_type, value, connection=connection, prepared=prepared)
-
     def is_hidden(self):
         "Should the related object be hidden?"
         return bool(self.related_name) and self.related_name[-1] == '+'