Ticket #14700: patch_obj_creation.diff

django/db/models/base.py

@@ -272 +272 @@
 
         # Set up the storage for instance state
         self._state = ModelState()
+        if '_use_dict' in kwargs:
+            self.__dict__.update(kwargs['_use_dict'])
+            # for attname, val in kwargs['_use_dict'].iteritems():
+            #     setattr(self, attname, val)
+            signals.post_init.send(sender=self.__class__, instance=self)
+            return
 
         # There is a rather weird disparity here; if kwargs, it's set, then args
         # overrides it. It should be one or the other; don't duplicate the work

django/db/models/query.py

@@ -1291 +1291 @@
         self.translations = translations or {}
 
     def __iter__(self):
-        for row in self.query:
-            yield self.transform_results(row)
+        # mapping of attrnames to row column positions.
+        model_init_field_names = {}
+        # just the positions for as-fast-as-possible iteration.
+        # contains the same values as model_init_field_names.itervalues(),
+        # but ordered in the order model.__init__ expects them. Used so that
+        # when all fields are present, we can use *args based model 
+        # initialization.
+        model_init_field_pos = []
+        # A list of tuples of column name to column position.
+        annotation_fields = []
+
+        # Note, calling self.db is relatively expensive, so we need to call it
+        # just once instead of inside the loop.
+        db = self.db
+        connection = connections[db]
+
+        compiler = connection.ops.compiler('SQLCompiler')(self.query, connection, db)
+        if hasattr(compiler, 'resolve_columns'):
+            fields = [self.model_fields.get(c, None) for c in self.columns]
+        model_fields_keys = self.model_fields.keys()
+        for pos, column in enumerate(self.columns):
+            if column in model_fields_keys:
+                model_init_field_names[self.model_fields[column].attname] = pos
+            else:
+                annotation_fields.append((column, pos))
+        skip = set()
+        for field in self.model._meta.fields:
+            if field.attname not in model_init_field_names:
+                skip.add(field.attname)
+        if skip:
+            if self.model._meta.pk.attname in skip:
+                raise InvalidQuery('Raw query must include the primary key')
+            model_cls = deferred_class_factory(self.model, skip)
+        else:
+            model_cls = self.model
+            for field in self.model._meta.fields:
+                model_init_field_pos.append(model_init_field_names[field.attname])
+        need_resolv_columns = hasattr(compiler, 'resolve_columns')
+        for values in self.query:
+            if need_resolv_columns:
+                values = compiler.resolve_columns(values, fields)
+            # Associate fields to values
+            #if skip:
+            model_init_kwargs = {}
+            for attname, pos in model_init_field_names.iteritems():
+                model_init_kwargs[attname] = values[pos]
+            instance = model_cls(_use_dict=model_init_kwargs)
+            # else:
+            #     model_init_args = []
+            #     model_init_args = [values[pos] for pos in model_init_field_pos]
+            #    instance = model_cls(*model_init_args)
+            # Construct model instance and apply annotations
+            if annotation_fields:
+                for column, pos in annotation_fields:
+                    setattr(instance, column, values[pos])
+
+            instance._state.db = db
+
+            yield instance
 
     def __repr__(self):
         return "<RawQuerySet: %r>" % (self.raw_query % self.params)
@@ -1347 +1404 @@
                 self._model_fields[converter(column)] = field
         return self._model_fields
 
-    def transform_results(self, values):
-        model_init_kwargs = {}
-        annotations = ()
-
-        # Perform database backend type resolution
-        connection = connections[self.db]
-        compiler = connection.ops.compiler('SQLCompiler')(self.query, connection, self.db)
-        if hasattr(compiler, 'resolve_columns'):
-            fields = [self.model_fields.get(c,None) for c in self.columns]
-            values = compiler.resolve_columns(values, fields)
-
-        # Associate fields to values
-        for pos, value in enumerate(values):
-            column = self.columns[pos]
-
-            # Separate properties from annotations
-            if column in self.model_fields.keys():
-                model_init_kwargs[self.model_fields[column].attname] = value
-            else:
-                annotations += (column, value),
-
-        # Construct model instance and apply annotations
-        skip = set()
-        for field in self.model._meta.fields:
-            if field.attname not in model_init_kwargs.keys():
-                skip.add(field.attname)
-
-        if skip:
-            if self.model._meta.pk.attname in skip:
-                raise InvalidQuery('Raw query must include the primary key')
-            model_cls = deferred_class_factory(self.model, skip)
-        else:
-            model_cls = self.model
-
-        instance = model_cls(**model_init_kwargs)
-
-        for field, value in annotations:
-            setattr(instance, field, value)
-
-        instance._state.db = self.query.using
-
-        return instance
 
 def insert_query(model, values, return_id=False, raw_values=False, using=None):
     """