Ticket #19527: django_patch_bulk_create_sets_pk-1.5.1.patch

django/db/backends/__init__.py

@@ -576 +576 @@
         """
         return cursor.fetchone()[0]
 
+    def fetch_returned_insert_ids(self, cursor):
+        """
+        Given a cursor object that has just performed an INSERT...RETURNING
+        statement into a table that has an auto-incrementing ID, returns the
+        list of newly created IDs.
+        """
+        return [item[0] for item in cursor.fetchall()]
+
     def field_cast_sql(self, db_type):
         """
         Given a column type (e.g. 'BLOB', 'VARCHAR'), returns the SQL necessary

django/db/models/query.py

@@ -441 +441 @@
                     self._batched_insert(objs_with_pk, fields, batch_size)
                 if objs_without_pk:
                     fields= [f for f in fields if not isinstance(f, AutoField)]
-                    self._batched_insert(objs_without_pk, fields, batch_size)
+                    ids = self._batched_insert(objs_without_pk, fields, batch_size)
+                    for i in range(len(ids)):
+                        objs_without_pk[i].pk = ids[i]
             if forced_managed:
                 transaction.commit(using=self.db)
             else:
@@ -896 +898 @@
             return
         ops = connections[self.db].ops
         batch_size = (batch_size or max(ops.bulk_batch_size(fields, objs), 1))
+        ret = []
         for batch in [objs[i:i+batch_size]
                       for i in range(0, len(objs), batch_size)]:
-            self.model._base_manager._insert(batch, fields=fields,
-                                             using=self.db)
+            if connections[self.db].features.can_return_id_from_insert:
+                if len(objs) > 1:
+                    ret.extend(self.model._base_manager._insert(batch, fields=fields,
+                                                                using=self.db, return_id=True))
+                else:
+                    assert(len(objs) is 1)
+                    ret.append(self.model._base_manager._insert(batch, fields=fields,
+                                                                using=self.db, return_id=True))
+            else:
+                self.model._base_manager._insert(batch, fields=fields,
+                                                 using=self.db)
+        return ret
 
     def _clone(self, klass=None, setup=False, **kwargs):
         if klass is None:

django/db/models/sql/compiler.py

@@ -897 +897 @@
             values = [[self.connection.ops.pk_default_value()] for obj in self.query.objs]
             params = [[]]
             fields = [None]
-        can_bulk = (not any(hasattr(field, "get_placeholder") for field in fields) and
-            not self.return_id and self.connection.features.has_bulk_insert)
-
-        if can_bulk:
+        can_bulk_and_not_return_ids = (not any(hasattr(field, "get_placeholder") for field in fields) and
+                                      not self.return_id and self.connection.features.has_bulk_insert)
+        # If not all of these conditions are met, fall back to doing a bunch of single inserts
+        can_bulk_and_return_ids = self.return_id and self.connection.features.can_return_id_from_insert \
+                                  and (not any(hasattr(field, "get_placeholder") for field in fields)) \
+                                  and self.connection.features.has_bulk_insert
+        if can_bulk_and_not_return_ids or can_bulk_and_return_ids:
             placeholders = [["%s"] * len(fields)]
         else:
             placeholders = [
@@ -909 +912 @@
             ]
             # Oracle Spatial needs to remove some values due to #10888
             params = self.connection.ops.modify_insert_params(placeholders, params)
-        if self.return_id and self.connection.features.can_return_id_from_insert:
+        if can_bulk_and_return_ids:
+            result.append(self.connection.ops.bulk_insert_sql(fields, len(values)))
+            r_fmt, r_params = self.connection.ops.return_insert_id()
+            if r_fmt:
+                col = "%s.%s" % (qn(opts.db_table), qn(opts.pk.column))
+                result.append(r_fmt % col)
+                params += r_params
+            return [(" ".join(result), tuple([v for val in values for v in val]))]
+        elif self.return_id and self.connection.features.can_return_id_from_insert:
             params = params[0]
             col = "%s.%s" % (qn(opts.db_table), qn(opts.pk.column))
             result.append("VALUES (%s)" % ", ".join(placeholders[0]))
@@ -920 +931 @@
                 result.append(r_fmt % col)
                 params += r_params
             return [(" ".join(result), tuple(params))]
-        if can_bulk:
+        elif can_bulk_and_not_return_ids:
             result.append(self.connection.ops.bulk_insert_sql(fields, len(values)))
             return [(" ".join(result), tuple([v for val in values for v in val]))]
         else:
@@ -930 +941 @@
             ]
 
     def execute_sql(self, return_id=False):
-        assert not (return_id and len(self.query.objs) != 1)
+        assert not (return_id and len(self.query.objs) != 1 and 
+                    not self.connection.features.can_return_id_from_insert)
         self.return_id = return_id
         cursor = self.connection.cursor()
         for sql, params in self.as_sql():
             cursor.execute(sql, params)
         if not (return_id and cursor):
             return
-        if self.connection.features.can_return_id_from_insert:
+        if self.connection.features.can_return_id_from_insert and len(self.query.objs) > 1:
+            return self.connection.ops.fetch_returned_insert_ids(cursor)
+        if self.connection.features.can_return_id_from_insert and len(self.query.objs) is 1:
             return self.connection.ops.fetch_returned_insert_id(cursor)
         return self.connection.ops.last_insert_id(cursor,
                 self.query.model._meta.db_table, self.query.model._meta.pk.column)