Fixed #19385 again, now with real code changes

The commit of 266de5f9 included only
tests, this time also code changes included...

django/contrib/contenttypes/generic.py

@@ -8,10 +8,11 @@ from functools import partial
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import connection
-from django.db.models import signals
 from django.db import models, router, DEFAULT_DB_ALIAS
-from django.db.models.fields.related import RelatedField, Field, ManyToManyRel
+from django.db.models import signals
+from django.db.models.fields.related import ForeignObject, ForeignObjectRel
 from django.db.models.related import PathInfo
+from django.db.models.sql.where import Constraint
 from django.forms import ModelForm
 from django.forms.models import BaseModelFormSet, modelformset_factory, save_instance
 from django.contrib.admin.options import InlineModelAdmin, flatten_fieldsets
@@ -149,17 +150,14 @@ class GenericForeignKey(six.with_metaclass(RenameGenericForeignKeyMethods)):
         setattr(instance, self.fk_field, fk)
         setattr(instance, self.cache_attr, value)
 
-class GenericRelation(RelatedField, Field):
+class GenericRelation(ForeignObject):
     """Provides an accessor to generic related objects (e.g. comments)"""
 
     def __init__(self, to, **kwargs):
         kwargs['verbose_name'] = kwargs.get('verbose_name', None)
-        kwargs['rel'] = GenericRel(to,
-                            related_name=kwargs.pop('related_name', None),
-                            limit_choices_to=kwargs.pop('limit_choices_to', None),
-                            symmetrical=kwargs.pop('symmetrical', True))
-
-
+        kwargs['rel'] = GenericRel(
+            self, to, related_name=kwargs.pop('related_name', None),
+            limit_choices_to=kwargs.pop('limit_choices_to', None),)
         # Override content-type/object-id field names on the related class
         self.object_id_field_name = kwargs.pop("object_id_field", "object_id")
         self.content_type_field_name = kwargs.pop("content_type_field", "content_type")
@@ -167,47 +165,44 @@ class GenericRelation(RelatedField, Field):
         kwargs['blank'] = True
         kwargs['editable'] = False
         kwargs['serialize'] = False
-        Field.__init__(self, **kwargs)
-
-    def get_path_info(self):
-        from_field = self.model._meta.pk
+        # This construct is somewhat of an abuse of ForeignObject. This field
+        # represents a relation from pk to object_id field. But, this relation
+        # isn't direct, the join is generated reverse along foreign key. So,
+        # the from_field is object_id field, to_field is pk because of the
+        # reverse join.
+        super(GenericRelation, self).__init__(
+            to, to_fields=[],
+            from_fields=[self.object_id_field_name], **kwargs)
+
+    def resolve_related_fields(self):
+        self.to_fields = [self.model._meta.pk.name]
+        return [(self.rel.to._meta.get_field_by_name(self.object_id_field_name)[0],
+                 self.model._meta.pk)]
+
+    def get_reverse_path_info(self):
         opts = self.rel.to._meta
         target = opts.get_field_by_name(self.object_id_field_name)[0]
-        # Note that we are using different field for the join_field
-        # than from_field or to_field. This is a hack, but we need the
-        # GenericRelation to generate the extra SQL.
-        return ([PathInfo(from_field, target, self.model._meta, opts, self, True, False)],
-                opts, target, self)
+        return [PathInfo(self.model._meta, opts, (target,), self.rel, True, False)]
 
     def get_choices_default(self):
-        return Field.get_choices(self, include_blank=False)
+        return super(GenericRelation, self).get_choices(include_blank=False)
 
     def value_to_string(self, obj):
         qs = getattr(obj, self.name).all()
         return smart_text([instance._get_pk_val() for instance in qs])
 
-    def m2m_db_table(self):
-        return self.rel.to._meta.db_table
-
-    def m2m_column_name(self):
-        return self.object_id_field_name
-
-    def m2m_reverse_name(self):
-        return self.rel.to._meta.pk.column
-
-    def m2m_target_field_name(self):
-        return self.model._meta.pk.name
-
-    def m2m_reverse_target_field_name(self):
-        return self.rel.to._meta.pk.name
+    def get_joining_columns(self, reverse_join=False):
+        if not reverse_join:
+            # This error message is meant for the user, and from user
+            # perspective this is a reverse join along the GenericRelation.
+            raise ValueError('Joining in reverse direction not allowed.')
+        return super(GenericRelation, self).get_joining_columns(reverse_join)
 
     def contribute_to_class(self, cls, name):
-        super(GenericRelation, self).contribute_to_class(cls, name)
-
+        super(GenericRelation, self).contribute_to_class(cls, name, virtual_only=True)
         # Save a reference to which model this class is on for future use
         self.model = cls
-
-        # Add the descriptor for the m2m relation
+        # Add the descriptor for the relation
         setattr(cls, self.name, ReverseGenericRelatedObjectsDescriptor(self))
 
     def contribute_to_related_class(self, cls, related):
@@ -219,21 +214,18 @@ class GenericRelation(RelatedField, Field):
     def get_internal_type(self):
         return "ManyToManyField"
 
-    def db_type(self, connection):
-        # Since we're simulating a ManyToManyField, in effect, best return the
-        # same db_type as well.
-        return None
-
     def get_content_type(self):
         """
         Returns the content type associated with this field's model.
         """
         return ContentType.objects.get_for_model(self.model)
 
-    def get_extra_join_sql(self, connection, qn, lhs_alias, rhs_alias):
-        extra_col = self.rel.to._meta.get_field_by_name(self.content_type_field_name)[0].column
-        contenttype = self.get_content_type().pk
-        return " AND %s.%s = %%s" % (qn(rhs_alias), qn(extra_col)), [contenttype]
+    def get_extra_restriction(self, where_class, alias, remote_alias):
+        field = self.rel.to._meta.get_field_by_name(self.content_type_field_name)[0]
+        contenttype_pk = self.get_content_type().pk
+        cond = where_class()
+        cond.add((Constraint(remote_alias, field.column, field), 'exact', contenttype_pk), 'AND')
+        return cond
 
     def bulk_related_objects(self, objs, using=DEFAULT_DB_ALIAS):
         """
@@ -273,12 +265,12 @@ class ReverseGenericRelatedObjectsDescriptor(object):
         qn = connection.ops.quote_name
         content_type = ContentType.objects.db_manager(instance._state.db).get_for_model(instance)
 
+        join_cols = self.field.get_joining_columns(reverse_join=True)[0]
         manager = RelatedManager(
             model = rel_model,
             instance = instance,
-            symmetrical = (self.field.rel.symmetrical and instance.__class__ == rel_model),
-            source_col_name = qn(self.field.m2m_column_name()),
-            target_col_name = qn(self.field.m2m_reverse_name()),
+            source_col_name = qn(join_cols[0]),
+            target_col_name = qn(join_cols[1]),
             content_type = content_type,
             content_type_field_name = self.field.content_type_field_name,
             object_id_field_name = self.field.object_id_field_name,
@@ -378,14 +370,10 @@ def create_generic_related_manager(superclass):
 
     return GenericRelatedObjectManager
 
-class GenericRel(ManyToManyRel):
-    def __init__(self, to, related_name=None, limit_choices_to=None, symmetrical=True):
-        self.to = to
-        self.related_name = related_name
-        self.limit_choices_to = limit_choices_to or {}
-        self.symmetrical = symmetrical
-        self.multiple = True
-        self.through = None
+class GenericRel(ForeignObjectRel):
+
+    def __init__(self, field, to, related_name=None, limit_choices_to=None):
+        super(GenericRel, self).__init__(field, to, related_name, limit_choices_to)
 
 class BaseGenericInlineFormSet(BaseModelFormSet):
     """

django/core/management/validation.py

@@ -153,8 +153,16 @@ def get_validation_errors(outfile, app=None):
                     continue
 
                 # Make sure the related field specified by a ForeignKey is unique
-                if not f.rel.to._meta.get_field(f.rel.field_name).unique:
-                    e.add(opts, "Field '%s' under model '%s' must have a unique=True constraint." % (f.rel.field_name, f.rel.to.__name__))
+                if f.requires_unique_target:
+                    if len(f.foreign_related_fields) > 1:
+                        has_unique_field = False
+                        for rel_field in f.foreign_related_fields:
+                            has_unique_field = has_unique_field or rel_field.unique
+                        if not has_unique_field:
+                            e.add(opts, "Field combination '%s' under model '%s' must have a unique=True constraint" % (','.join([rel_field.name for rel_field in f.foreign_related_fields]), f.rel.to.__name__))
+                    else:
+                        if not f.foreign_related_fields[0].unique:
+                            e.add(opts, "Field '%s' under model '%s' must have a unique=True constraint." % (f.foreign_related_fields[0].name, f.rel.to.__name__))
 
                 rel_opts = f.rel.to._meta
                 rel_name = f.related.get_accessor_name()

django/db/backends/mysql/compiler.py

@@ -17,6 +17,12 @@ class SQLCompiler(compiler.SQLCompiler):
             values.append(value)
         return row[:index_extra_select] + tuple(values)
 
+    def as_subquery_condition(self, alias, columns):
+        qn = self.quote_name_unless_alias
+        qn2 = self.connection.ops.quote_name
+        sql, params = self.as_sql()
+        return '(%s) IN (%s)' % (', '.join(['%s.%s' % (qn(alias), qn2(column)) for column in columns]), sql), params
+
 class SQLInsertCompiler(compiler.SQLInsertCompiler, SQLCompiler):
     pass
 

django/db/models/__init__.py

@@ -8,7 +8,7 @@ from django.db.models.aggregates import *
 from django.db.models.fields import *
 from django.db.models.fields.subclassing import SubfieldBase
 from django.db.models.fields.files import FileField, ImageField
-from django.db.models.fields.related import ForeignKey, OneToOneField, ManyToManyField, ManyToOneRel, ManyToManyRel, OneToOneRel
+from django.db.models.fields.related import ForeignKey, ForeignObject, OneToOneField, ManyToManyField, ManyToOneRel, ManyToManyRel, OneToOneRel
 from django.db.models.deletion import CASCADE, PROTECT, SET, SET_NULL, SET_DEFAULT, DO_NOTHING, ProtectedError
 from django.db.models import signals
 from django.utils.decorators import wraps

django/db/models/base.py

@@ -10,7 +10,7 @@ from django.conf import settings
 from django.core.exceptions import (ObjectDoesNotExist,
     MultipleObjectsReturned, FieldError, ValidationError, NON_FIELD_ERRORS)
 from django.db.models.fields import AutoField, FieldDoesNotExist
-from django.db.models.fields.related import (ManyToOneRel,
+from django.db.models.fields.related import (ForeignObjectRel, ManyToOneRel,
     OneToOneField, add_lazy_relation)
 from django.db import (router, transaction, DatabaseError,
     DEFAULT_DB_ALIAS)
@@ -333,12 +333,12 @@ class Model(six.with_metaclass(ModelBase)):
         # The reason for the kwargs check is that standard iterator passes in by
         # args, and instantiation for iteration is 33% faster.
         args_len = len(args)
-        if args_len > len(self._meta.fields):
+        if args_len > len(self._meta.concrete_fields):
             # Daft, but matches old exception sans the err msg.
             raise IndexError("Number of args exceeds number of fields")
 
-        fields_iter = iter(self._meta.fields)
         if not kwargs:
+            fields_iter = iter(self._meta.concrete_fields)
             # The ordering of the zip calls matter - zip throws StopIteration
             # when an iter throws it. So if the first iter throws it, the second
             # is *not* consumed. We rely on this, so don't change the order
@@ -347,6 +347,7 @@ class Model(six.with_metaclass(ModelBase)):
                 setattr(self, field.attname, val)
         else:
             # Slower, kwargs-ready version.
+            fields_iter = iter(self._meta.fields)
             for val, field in zip(args, fields_iter):
                 setattr(self, field.attname, val)
                 kwargs.pop(field.name, None)
@@ -363,11 +364,12 @@ class Model(six.with_metaclass(ModelBase)):
             # data-descriptor object (DeferredAttribute) without triggering its
             # __get__ method.
             if (field.attname not in kwargs and
-                    isinstance(self.__class__.__dict__.get(field.attname), DeferredAttribute)):
+                    (isinstance(self.__class__.__dict__.get(field.attname), DeferredAttribute)
+                     or field.column is None)):
                 # This field will be populated on request.
                 continue
             if kwargs:
-                if isinstance(field.rel, ManyToOneRel):
+                if isinstance(field.rel, ForeignObjectRel):
                     try:
                         # Assume object instance was passed in.
                         rel_obj = kwargs.pop(field.name)
@@ -394,6 +396,7 @@ class Model(six.with_metaclass(ModelBase)):
                         val = field.get_default()
             else:
                 val = field.get_default()
+
             if is_related_object:
                 # If we are passed a related instance, set it using the
                 # field.name instead of field.attname (e.g. "user" instead of
@@ -528,7 +531,7 @@ class Model(six.with_metaclass(ModelBase)):
         # automatically do a "update_fields" save on the loaded fields.
         elif not force_insert and self._deferred and using == self._state.db:
             field_names = set()
-            for field in self._meta.fields:
+            for field in self._meta.concrete_fields:
                 if not field.primary_key and not hasattr(field, 'through'):
                     field_names.add(field.attname)
             deferred_fields = [
@@ -614,7 +617,7 @@ class Model(six.with_metaclass(ModelBase)):
         for a single table.
         """
         meta = cls._meta
-        non_pks = [f for f in meta.local_fields if not f.primary_key]
+        non_pks = [f for f in meta.local_concrete_fields if not f.primary_key]
 
         if update_fields:
             non_pks = [f for f in non_pks
@@ -652,7 +655,7 @@ class Model(six.with_metaclass(ModelBase)):
                     **{field.name: getattr(self, field.attname)}).count()
                 self._order = order_value
 
-            fields = meta.local_fields
+            fields = meta.local_concrete_fields
             if not pk_set:
                 fields = [f for f in fields if not isinstance(f, AutoField)]
 

django/db/models/deletion.py

-from functools import wraps
 from operator import attrgetter
 
 from django.db import connections, transaction, IntegrityError
@@ -196,17 +195,13 @@ class Collector(object):
                     self.fast_deletes.append(sub_objs)
                 elif sub_objs:
                     field.rel.on_delete(self, field, sub_objs, self.using)
-
-            # TODO This entire block is only needed as a special case to
-            # support cascade-deletes for GenericRelation. It should be
-            # removed/fixed when the ORM gains a proper abstraction for virtual
-            # or composite fields, and GFKs are reworked to fit into that.
-            for relation in model._meta.many_to_many:
-                if not relation.rel.through:
-                    sub_objs = relation.bulk_related_objects(new_objs, self.using)
+            for field in model._meta.virtual_fields:
+                if hasattr(field, 'bulk_related_objects'):
+                    # Its something like generic foreign key.
+                    sub_objs = field.bulk_related_objects(new_objs, self.using)
                     self.collect(sub_objs,
                                  source=model,
-                                 source_attr=relation.rel.related_name,
+                                 source_attr=field.rel.related_name,
                                  nullable=True)
 
     def related_objects(self, related, objs):

django/db/models/fields/__init__.py

@@ -292,10 +292,13 @@ class Field(object):
         if self.verbose_name is None and self.name:
             self.verbose_name = self.name.replace('_', ' ')
 
-    def contribute_to_class(self, cls, name):
+    def contribute_to_class(self, cls, name, virtual_only=False):
         self.set_attributes_from_name(name)
         self.model = cls
-        cls._meta.add_field(self)
+        if virtual_only:
+            cls._meta.add_virtual_field(self)
+        else:
+            cls._meta.add_field(self)
         if self.choices:
             setattr(cls, 'get_%s_display' % self.name,
                     curry(cls._get_FIELD_display, field=self))

django/db/models/options.py

@@ -10,6 +10,7 @@ from django.db.models.fields import AutoField, FieldDoesNotExist
 from django.db.models.fields.proxy import OrderWrt
 from django.db.models.loading import get_models, app_cache_ready
 from django.utils import six
+from django.utils.functional import cached_property
 from django.utils.datastructures import SortedDict
 from django.utils.encoding import force_text, smart_text, python_2_unicode_compatible
 from django.utils.translation import activate, deactivate_all, get_language, string_concat
@@ -173,6 +174,22 @@ class Options(object):
             if hasattr(self, '_field_cache'):
                 del self._field_cache
                 del self._field_name_cache
+                # The fields, concrete_fields and local_concrete_fields are
+                # implemented as cached properties for performance reasons.
+                # The attrs will not exists if the cached property isn't
+                # accessed yet, hence the try-excepts.
+                try:
+                    del self.fields
+                except AttributeError:
+                    pass
+                try:
+                    del self.concrete_fields
+                except AttributeError:
+                    pass
+                try:
+                    del self.local_concrete_fields
+                except AttributeError:
+                    pass
 
         if hasattr(self, '_name_map'):
             del self._name_map
@@ -245,7 +262,8 @@ class Options(object):
         return None
     swapped = property(_swapped)
 
-    def _fields(self):
+    @cached_property
+    def fields(self):
         """
         The getter for self.fields. This returns the list of field objects
         available to this model (including through parent models).
@@ -258,7 +276,14 @@ class Options(object):
         except AttributeError:
             self._fill_fields_cache()
         return self._field_name_cache
-    fields = property(_fields)
+
+    @cached_property
+    def concrete_fields(self):
+        return [f for f in self.fields if f.column is not None]
+
+    @cached_property
+    def local_concrete_fields(self):
+        return [f for f in self.local_fields if f.column is not None]
 
     def get_fields_with_model(self):
         """
@@ -272,6 +297,10 @@ class Options(object):
             self._fill_fields_cache()
         return self._field_cache
 
+    def get_concrete_fields_with_model(self):
+        return [(field, model) for field, model in self.get_fields_with_model() if
+                field.column is not None]
+
     def _fill_fields_cache(self):
         cache = []
         for parent in self.parents:
@@ -377,6 +406,9 @@ class Options(object):
             cache[f.name] = (f, model, True, True)
         for f, model in self.get_fields_with_model():
             cache[f.name] = (f, model, True, False)
+        for f in self.virtual_fields:
+            if hasattr(f, 'related'):
+                cache[f.name] = (f.related, None if f.model == self.model else f.model, True, False)
         if app_cache_ready():
             self._name_map = cache
         return cache
@@ -432,7 +464,7 @@ class Options(object):
         for klass in get_models(include_auto_created=True, only_installed=False):
             if not klass._meta.swapped:
                 for f in klass._meta.local_fields:
-                    if f.rel and not isinstance(f.rel.to, six.string_types):
+                    if f.rel and not isinstance(f.rel.to, six.string_types) and f.generate_reverse_relation:
                         if self == f.rel.to._meta:
                             cache[f.related] = None
                             proxy_cache[f.related] = None

django/db/models/query.py

@@ -261,13 +261,13 @@ class QuerySet(object):
 
         only_load = self.query.get_loaded_field_names()
         if not fill_cache:
-            fields = self.model._meta.fields
+            fields = self.model._meta.concrete_fields
 
         load_fields = []
         # If only/defer clauses have been specified,
         # build the list of fields that are to be loaded.
         if only_load:
-            for field, model in self.model._meta.get_fields_with_model():
+            for field, model in self.model._meta.get_concrete_fields_with_model():
                 if model is None:
                     model = self.model
                 try:
@@ -280,7 +280,7 @@ class QuerySet(object):
                     load_fields.append(field.name)
 
         index_start = len(extra_select)
-        aggregate_start = index_start + len(load_fields or self.model._meta.fields)
+        aggregate_start = index_start + len(load_fields or self.model._meta.concrete_fields)
 
         skip = None
         if load_fields and not fill_cache:
@@ -312,7 +312,11 @@ class QuerySet(object):
                 if skip:
                     obj = model_cls(**dict(zip(init_list, row_data)))
                 else:
-                    obj = model(*row_data)
+                    try:
+                        obj = model(*row_data)
+                    except IndexError:
+                        import ipdb; ipdb.set_trace()
+                        pass
 
                 # Store the source database of the object
                 obj._state.db = db
@@ -962,7 +966,7 @@ class QuerySet(object):
         """
         opts = self.model._meta
         if self.query.group_by is None:
-            field_names = [f.attname for f in opts.fields]
+            field_names = [f.attname for f in opts.concrete_fields]
             self.query.add_fields(field_names, False)
             self.query.set_group_by()
 
@@ -1055,7 +1059,7 @@ class ValuesQuerySet(QuerySet):
         else:
             # Default to all fields.
             self.extra_names = None
-            self.field_names = [f.attname for f in self.model._meta.fields]
+            self.field_names = [f.attname for f in self.model._meta.concrete_fields]
             self.aggregate_names = None
 
         self.query.select = []
@@ -1266,7 +1270,7 @@ def get_klass_info(klass, max_depth=0, cur_depth=0, requested=None,
         skip = set()
         init_list = []
         # Build the list of fields that *haven't* been requested
-        for field, model in klass._meta.get_fields_with_model():
+        for field, model in klass._meta.get_concrete_fields_with_model():
             if field.name not in load_fields:
                 skip.add(field.attname)
             elif from_parent and issubclass(from_parent, model.__class__):
@@ -1285,22 +1289,22 @@ def get_klass_info(klass, max_depth=0, cur_depth=0, requested=None,
     else:
         # Load all fields on klass
 
-        field_count = len(klass._meta.fields)
+        field_count = len(klass._meta.concrete_fields)
         # Check if we need to skip some parent fields.
-        if from_parent and len(klass._meta.local_fields) != len(klass._meta.fields):
+        if from_parent and len(klass._meta.local_concrete_fields) != len(klass._meta.concrete_fields):
             # Only load those fields which haven't been already loaded into
             # 'from_parent'.
             non_seen_models = [p for p in klass._meta.get_parent_list()
                                if not issubclass(from_parent, p)]
             # Load local fields, too...
             non_seen_models.append(klass)
-            field_names = [f.attname for f in klass._meta.fields
+            field_names = [f.attname for f in klass._meta.concrete_fields
                            if f.model in non_seen_models]
             field_count = len(field_names)
         # Try to avoid populating field_names variable for perfomance reasons.
         # If field_names variable is set, we use **kwargs based model init
         # which is slower than normal init.
-        if field_count == len(klass._meta.fields):
+        if field_count == len(klass._meta.concrete_fields):
             field_names = ()
 
     restricted = requested is not None

django/db/models/related.py

@@ -7,7 +7,7 @@ from django.db.models.fields import BLANK_CHOICE_DASH
 # describe the relation in Model terms (model Options and Fields for both
 # sides of the relation. The join_field is the field backing the relation.
 PathInfo = namedtuple('PathInfo',
-                      'from_field to_field from_opts to_opts join_field '
+                      'from_opts to_opts target_fields join_field '
                       'm2m direct')
 
 class RelatedObject(object):

django/db/models/sql/constants.py

@@ -25,7 +25,7 @@ GET_ITERATOR_CHUNK_SIZE = 100
 # dictionary in the Query class).
 JoinInfo = namedtuple('JoinInfo',
                       'table_name rhs_alias join_type lhs_alias '
-                      'lhs_join_col rhs_join_col nullable join_field')
+                      'join_cols nullable join_field')
 
 # Pairs of column clauses to select, and (possibly None) field for the clause.
 SelectInfo = namedtuple('SelectInfo', 'col field')

django/db/models/sql/expressions.py

@@ -55,13 +55,14 @@ class SQLEvaluator(object):
             self.cols.append((node, query.aggregate_select[node.name]))
         else:
             try:
-                field, source, opts, join_list, path = query.setup_joins(
+                field, sources, opts, join_list, path = query.setup_joins(
                     field_list, query.get_meta(),
                     query.get_initial_alias(), self.reuse)
-                target, _, join_list = query.trim_joins(source, join_list, path)
+                targets, _, join_list = query.trim_joins(sources, join_list, path)
                 if self.reuse is not None:
                     self.reuse.update(join_list)
-                self.cols.append((node, (join_list[-1], target.column)))
+                for t in targets:
+                    self.cols.append((node, (join_list[-1], t.column)))
             except FieldDoesNotExist:
                 raise FieldError("Cannot resolve keyword %r into field. "
                                  "Choices are: %s" % (self.name,

django/db/models/sql/where.py

@@ -382,3 +382,28 @@ class Constraint(object):
             new.__class__ = self.__class__
             new.alias, new.col, new.field = change_map[self.alias], self.col, self.field
             return new
+
+class SubqueryConstraint(object):
+    def __init__(self, alias, columns, targets, query_object):
+        self.alias = alias
+        self.columns = columns
+        self.targets = targets
+        self.query_object = query_object
+
+    def as_sql(self, qn, connection):
+        query = self.query_object
+
+        # QuerySet was sent
+        if hasattr(query, 'values'):
+            # as_sql should throw if we are using a
+            # connection on another database
+            query._as_sql(connection=connection)
+            query = query.values(*self.targets).query
+
+        query_compiler = query.get_compiler(connection=connection)
+        return query_compiler.as_subquery_condition(self.alias, self.columns)
+
+    def relabeled_clone(self, relabels):
+        return self.__class__(
+            relabels.get(self.alias, self.alias),
+            self.columns, self.query_object)

django/forms/models.py

@@ -110,7 +110,7 @@ def model_to_dict(instance, fields=None, exclude=None):
     from django.db.models.fields.related import ManyToManyField
     opts = instance._meta
     data = {}
-    for f in opts.fields + opts.many_to_many:
+    for f in opts.concrete_fields + opts.many_to_many:
         if not f.editable:
             continue
         if fields and not f.name in fields:
@@ -149,7 +149,7 @@ def fields_for_model(model, fields=None, exclude=None, widgets=None, formfield_c
     field_list = []
     ignored = []
     opts = model._meta
-    for f in sorted(opts.fields + opts.many_to_many):
+    for f in sorted(opts.concrete_fields + opts.many_to_many):
         if not f.editable:
             continue
         if fields is not None and not f.name in fields: