Use a list of dictionaries in create().

issue2358
review266002

CHANGELOG

@@ -1,3 +1,4 @@
+* Use lists of values in create
 * (Field, Operator, Operand) are replaced by Domain on Rule
 * Add global search
 * Replace view shortcut by menu favorite

doc/ref/models/fields.rst

@@ -433,8 +433,8 @@ model.
 
 This field accepts as written value a list of tuples like this:
 
-    - ``('create', {<field name>: value, ...})``: it will create a new target
-      record and link it to this one.
+    - ``('create', [{<field name>: value, ...}, ...])``: it will create new
+      target records and link them to this one.
 
     - ``('write'[, ids, ...], {<field name>: value, ...})``: it will write
       values to target ids.

doc/ref/models/models.rst

@@ -231,12 +231,12 @@ Static methods:
 
 CLass methods:
 
-.. classmethod:: ModelStorage.create(values)
+.. classmethod:: ModelStorage.create(vlist)
 
-    Create a record. ``values`` is a dictionary with fields names as key and
-    created values as value and return the new instance.
+    Create records. ``vlist`` is list of dictionaries with fields names as key
+    and created values as value and return the list of new instances.
 
-.. classmethod:: ModelStorage.trigger_create(record)
+.. classmethod:: ModelStorage.trigger_create(records)
 
     Trigger create actions. It will call actions defined in ``ir.trigger`` if
     ``on_create`` is set and ``condition`` is true.

trytond/convert.py

@@ -583,7 +583,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler):
             if not record:
                 with Transaction().set_context(
                         module=module, language='en_US'):
-                    record = Model.create(values)
+                    record, = Model.create([values])
 
                 # reset_browsercord
                 self.fs2db.reset_browsercord(
@@ -607,13 +607,13 @@ class TrytondXmlHandler(sax.handler.ContentHandler):
                             'inherit': True,
                             })
                     else:
-                        data = self.ModelData.create({
-                            'fs_id': fs_id,
-                            'module': module,
-                            'model': table,
-                            'db_id': inherit_db_ids[table],
-                            'inherit': True,
-                            })
+                        data, = self.ModelData.create([{
+                                    'fs_id': fs_id,
+                                    'module': module,
+                                    'model': table,
+                                    'db_id': inherit_db_ids[table],
+                                    'inherit': True,
+                                    }])
                     inherit_mdata_ids.append((table, data.id))
 
                 data = self.ModelData.search([
@@ -739,7 +739,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler):
         else:
             # this record is new, create it in the db:
             with Transaction().set_context(module=module, language='en_US'):
-                record = Model.create(values)
+                record, = Model.create([values])
             inherit_db_ids = {}
 
             for table, field_name, field in (
@@ -752,25 +752,25 @@ class TrytondXmlHandler(sax.handler.ContentHandler):
             for key in values:
                 values[key] = self._clean_value(key, record)
 
-            for table in inherit_db_ids.keys():
-                self.ModelData.create({
+            to_create = [{
                     'fs_id': fs_id,
-                    'model': table,
+                    'model': model,
                     'module': module,
-                    'db_id': inherit_db_ids[table],
+                    'db_id': record.id,
                     'values': str(values),
-                    'inherit': True,
                     'noupdate': self.noupdate,
-                    })
-
-            mdata = self.ModelData.create({
-                'fs_id': fs_id,
-                'model': model,
-                'module': module,
-                'db_id': record.id,
-                'values': str(values),
-                'noupdate': self.noupdate,
-                })
+                    }]
+            for table in inherit_db_ids.keys():
+                to_create.append({
+                            'fs_id': fs_id,
+                            'model': table,
+                            'module': module,
+                            'db_id': inherit_db_ids[table],
+                            'values': str(values),
+                            'inherit': True,
+                            'noupdate': self.noupdate,
+                            })
+            mdata = self.ModelData.create(to_create)[0]
 
             # update fs2db:
             self.fs2db.set(module, fs_id, {

trytond/ir/action.py

@@ -175,12 +175,14 @@ class ActionKeyword(ModelSQL, ModelView):
         super(ActionKeyword, cls).delete(keywords)
 
     @classmethod
-    def create(cls, vals):
+    def create(cls, vlist):
         ModelView._fields_view_get_cache.clear()
         ModelView._view_toolbar_get_cache.clear()
         cls._get_keyword_cache.clear()
-        vals = cls._convert_vals(vals)
-        return super(ActionKeyword, cls).create(vals)
+        new_vlist = []
+        for vals in vlist:
+            new_vlist.append(cls._convert_vals(vals))
+        return super(ActionKeyword, cls).create(new_vlist)
 
     @classmethod
     def write(cls, keywords, vals):
@@ -509,28 +511,31 @@ class ActionReport(ModelSQL, ModelView):
         return new_reports
 
     @classmethod
-    def create(cls, vals):
-        later = {}
-        vals = vals.copy()
-        for field in vals:
-            if (field in cls._fields
-                    and hasattr(cls._fields[field], 'set')):
-                later[field] = vals[field]
-        for field in later:
-            del vals[field]
-        cursor = Transaction().cursor
-        if cursor.nextid(cls._table):
-            cursor.setnextid(cls._table, cursor.currid('ir_action'))
-        report = super(ActionReport, cls).create(vals)
-        cursor.execute('SELECT action FROM "' + cls._table + '" '
-            'WHERE id = %s', (report.id,))
-        new_id, = cursor.fetchone()
-        cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
-            'WHERE id = %s', (new_id, report.id))
-        cursor.update_auto_increment(cls._table, new_id)
-        report = cls(new_id)
-        cls.write([report], later)
-        return report
+    def create(cls, vlist):
+        new_vlist = []
+        for vals in vlist:
+            later = {}
+            vals = vals.copy()
+            for field in vals:
+                if (field in cls._fields
+                        and hasattr(cls._fields[field], 'set')):
+                    later[field] = vals[field]
+            for field in later:
+                del vals[field]
+            cursor = Transaction().cursor
+            if cursor.nextid(cls._table):
+                cursor.setnextid(cls._table, cursor.currid('ir_action'))
+            report, = super(ActionReport, cls).create([vals])
+            cursor.execute('SELECT action FROM "' + cls._table + '" '
+                'WHERE id = %s', (report.id,))
+            new_id, = cursor.fetchone()
+            cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
+                'WHERE id = %s', (new_id, report.id))
+            cursor.update_auto_increment(cls._table, new_id)
+            report = cls(new_id)
+            new_vlist.append(report)
+            cls.write([report], later)
+        return new_vlist
 
     @classmethod
     def write(cls, reports, vals):
@@ -723,28 +728,31 @@ class ActionActWindow(ModelSQL, ModelView):
         return pysons
 
     @classmethod
-    def create(cls, vals):
-        later = {}
-        vals = vals.copy()
-        for field in vals:
-            if (field in cls._fields
-                    and hasattr(cls._fields[field], 'set')):
-                later[field] = vals[field]
-        for field in later:
-            del vals[field]
-        cursor = Transaction().cursor
-        if cursor.nextid(cls._table):
-            cursor.setnextid(cls._table, cursor.currid('ir_action'))
-        act_window = super(ActionActWindow, cls).create(vals)
-        cursor.execute('SELECT action FROM "' + cls._table + '" '
-            'WHERE id = %s', (act_window.id,))
-        new_id, = cursor.fetchone()
-        cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
-            'WHERE id = %s', (new_id, act_window.id))
-        cursor.update_auto_increment(cls._table, new_id)
-        act_window = cls(new_id)
-        cls.write([act_window], later)
-        return act_window
+    def create(cls, vlist):
+        new_vlist = []
+        for vals in vlist:
+            later = {}
+            vals = vals.copy()
+            for field in vals:
+                if (field in cls._fields
+                        and hasattr(cls._fields[field], 'set')):
+                    later[field] = vals[field]
+            for field in later:
+                del vals[field]
+            cursor = Transaction().cursor
+            if cursor.nextid(cls._table):
+                cursor.setnextid(cls._table, cursor.currid('ir_action'))
+            act_window, = super(ActionActWindow, cls).create([vals])
+            cursor.execute('SELECT action FROM "' + cls._table + '" '
+                'WHERE id = %s', (act_window.id,))
+            new_id, = cursor.fetchone()
+            cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
+                'WHERE id = %s', (new_id, act_window.id))
+            cursor.update_auto_increment(cls._table, new_id)
+            act_window = cls(new_id)
+            new_vlist.append(act_window)
+            cls.write([act_window], later)
+        return new_vlist
 
     @classmethod
     def write(cls, act_windows, values):
@@ -810,11 +818,11 @@ class ActionActWindowView(ModelSQL, ModelView):
         table.drop_column('multi')
 
     @classmethod
-    def create(cls, values):
+    def create(cls, vlist):
         pool = Pool()
-        window = super(ActionActWindowView, cls).create(values)
+        windows = super(ActionActWindowView, cls).create(vlist)
         pool.get('ir.action.keyword')._get_keyword_cache.clear()
-        return window
+        return windows
 
     @classmethod
     def write(cls, windows, values):
@@ -865,28 +873,31 @@ class ActionWizard(ModelSQL, ModelView):
         return 'ir.action.wizard'
 
     @classmethod
-    def create(cls, vals):
-        later = {}
-        vals = vals.copy()
-        for field in vals:
-            if (field in cls._fields
-                    and hasattr(cls._fields[field], 'set')):
-                later[field] = vals[field]
-        for field in later:
-            del vals[field]
-        cursor = Transaction().cursor
-        if cursor.nextid(cls._table):
-            cursor.setnextid(cls._table, cursor.currid('ir_action'))
-        wizard = super(ActionWizard, cls).create(vals)
-        cursor.execute('SELECT action FROM "' + cls._table + '" '
-            'WHERE id = %s', (wizard.id,))
-        new_id, = cursor.fetchone()
-        cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
-            'WHERE id = %s', (new_id, wizard.id))
-        cursor.update_auto_increment(cls._table, new_id)
-        wizard = cls(new_id)
-        cls.write([wizard], later)
-        return wizard
+    def create(cls, vlist):
+        new_vlist = []
+        for vals in vlist:
+            later = {}
+            vals = vals.copy()
+            for field in vals:
+                if (field in cls._fields
+                        and hasattr(cls._fields[field], 'set')):
+                    later[field] = vals[field]
+            for field in later:
+                del vals[field]
+            cursor = Transaction().cursor
+            if cursor.nextid(cls._table):
+                cursor.setnextid(cls._table, cursor.currid('ir_action'))
+            wizard, = super(ActionWizard, cls).create([vals])
+            cursor.execute('SELECT action FROM "' + cls._table + '" '
+                'WHERE id = %s', (wizard.id,))
+            new_id, = cursor.fetchone()
+            cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
+                'WHERE id = %s', (new_id, wizard.id))
+            cursor.update_auto_increment(cls._table, new_id)
+            wizard = cls(new_id)
+            new_vlist.append(wizard)
+            cls.write([wizard], later)
+        return new_vlist
 
     @classmethod
     def write(cls, wizards, values):
@@ -936,29 +947,32 @@ class ActionURL(ModelSQL, ModelView):
         return 'new'
 
     @classmethod
-    def create(cls, vals):
-        later = {}
-        vals = vals.copy()
-        for field in vals:
-            if (field in cls._fields
-                    and hasattr(cls._fields[field], 'set')):
-                later[field] = vals[field]
-        for field in later:
-            del vals[field]
-        cursor = Transaction().cursor
-        if cursor.nextid(cls._table):
-            cursor.setnextid(cls._table, cursor.currid('ir_action'))
-        url = super(ActionURL, cls).create(vals)
-        cursor.execute('SELECT action FROM "' + cls._table + '" '
-            'WHERE id = %s', (url.id,))
-        new_id, = cursor.fetchone()
-        cls.write([url], {})  # simulate write to clear the cache
-        cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
-            'WHERE id = %s', (new_id, url.id))
-        cursor.update_auto_increment(cls._table, new_id)
-        url = cls(new_id)
-        cls.write([url], later)
-        return url
+    def create(cls, vlist):
+        new_vlist = []
+        for vals in vlist:
+            later = {}
+            vals = vals.copy()
+            for field in vals:
+                if (field in cls._fields
+                        and hasattr(cls._fields[field], 'set')):
+                    later[field] = vals[field]
+            for field in later:
+                del vals[field]
+            cursor = Transaction().cursor
+            if cursor.nextid(cls._table):
+                cursor.setnextid(cls._table, cursor.currid('ir_action'))
+            url, = super(ActionURL, cls).create([vals])
+            cursor.execute('SELECT action FROM "' + cls._table + '" '
+                'WHERE id = %s', (url.id,))
+            new_id, = cursor.fetchone()
+            cls.write([url], {})  # simulate write to clear the cache
+            cursor.execute('UPDATE "' + cls._table + '" SET id = %s '
+                'WHERE id = %s', (new_id, url.id))
+            cursor.update_auto_increment(cls._table, new_id)
+            url = cls(new_id)
+            new_vlist.append(url)
+            cls.write([url], later)
+        return new_vlist
 
     @classmethod
     def write(cls, urls, values):

trytond/ir/attachment.py

@@ -227,10 +227,10 @@ class Attachment(ModelSQL, ModelView):
         cls.check_access(attachments, mode='write')
 
     @classmethod
-    def create(cls, vals):
-        attachment = super(Attachment, cls).create(vals)
-        cls.check_access([attachment.id], mode='create')
-        return attachment
+    def create(cls, vlist):
+        attachments = super(Attachment, cls).create(vlist)
+        cls.check_access([a.id for a in attachments], mode='create')
+        return attachments
 
     @classmethod
     def view_header_get(cls, value, view_type='form'):

trytond/ir/cron.py

@@ -135,9 +135,9 @@ class Cron(ModelSQL, ModelView):
             'body': body,
             'date_sent': datetime.datetime.now(),
             'references': [
-                ('create', {
-                    'reference': '%s,%s' % (cls.__name__, cron.id),
-                }),
+                ('create', [{
+                            'reference': '%s,%s' % (cls.__name__, cron.id),
+                            }]),
             ],
             'state': 'waiting',
             'trigger_date': datetime.datetime.now(),
@@ -163,7 +163,7 @@ class Cron(ModelSQL, ModelView):
             with contextlib.nested(Transaction().set_user(cron.user.id),
                     Transaction().set_context(language=language)):
                 values = cls._get_request_values(cron)
-                Request.create(values)
+                Request.create([values])
             Transaction().cursor.commit()
 
     @classmethod

trytond/ir/lang.py

@@ -196,10 +196,10 @@ class Lang(ModelSQL, ModelView):
         return res
 
     @classmethod
-    def create(cls, vals):
+    def create(cls, vlist):
         # Clear cache
         cls._lang_cache.clear()
-        return super(Lang, cls).create(vals)
+        return super(Lang, cls).create(vlist)
 
     @classmethod
     def write(cls, langs, vals):

trytond/ir/model.py

@@ -90,10 +90,10 @@ class Model(ModelSQL, ModelView):
             return [m.model for m in models]
 
     @classmethod
-    def create(cls, vals):
+    def create(cls, vlist):
         pool = Pool()
         Property = pool.get('ir.property')
-        res = super(Model, cls).create(vals)
+        res = super(Model, cls).create(vlist)
         # Restart the cache of models_get
         Property._models_get_cache.clear()
         return res
@@ -415,8 +415,8 @@ class ModelAccess(ModelSQL, ModelView):
         ModelView._fields_view_get_cache.clear()
 
     @classmethod
-    def create(cls, vals):
-        res = super(ModelAccess, cls).create(vals)
+    def create(cls, vlist):
+        res = super(ModelAccess, cls).create(vlist)
         # Restart the cache
         cls._get_access_cache.clear()
         ModelView._fields_view_get_cache.clear()
@@ -556,8 +556,8 @@ class ModelFieldAccess(ModelSQL, ModelView):
         ModelView._fields_view_get_cache.clear()
 
     @classmethod
-    def create(cls, vals):
-        res = super(ModelFieldAccess, cls).create(vals)
+    def create(cls, vlist):
+        res = super(ModelFieldAccess, cls).create(vlist)
         # Restart the cache
         cls._get_access_cache.clear()
         ModelView._fields_view_get_cache.clear()
@@ -591,8 +591,8 @@ class ModelButton(ModelSQL, ModelView):
         cls._order.insert(0, ('model', 'ASC'))
 
     @classmethod
-    def create(cls, values):
-        result = super(ModelButton, cls).create(values)
+    def create(cls, vlist):
+        result = super(ModelButton, cls).create(vlist)
         # Restart the cache for get_groups
         cls._groups_cache.clear()
         return result

trytond/ir/module/module.py

@@ -255,10 +255,10 @@ class Module(ModelSQL, ModelView):
             tryton = get_module_info(name)
             if not tryton:
                 continue
-            module = cls.create({
-                    'name': name,
-                    'state': 'uninstalled',
-                    })
+            module, = cls.create([{
+                        'name': name,
+                        'state': 'uninstalled',
+                        }])
             count += 1
             cls._update_dependencies(module, tryton.get('depends', []))
         return count
@@ -274,12 +274,15 @@ class Module(ModelSQL, ModelView):
         # Restart Browse Cache for deleted dependencies
         module = cls(module.id)
         dependency_names = [x.name for x in module.dependencies]
+        to_create = []
         for depend in depends:
             if depend not in dependency_names:
-                Dependency.create({
+                to_create.append({
                         'module': module.id,
                         'name': depend,
                         })
+        if to_create:
+            Dependency.create(to_create)
 
 
 class ModuleDependency(ModelSQL, ModelView):

trytond/ir/property.py

@@ -157,4 +157,4 @@ class Property(ModelSQL, ModelView):
             for res_id in ids:
                 vals = cls._set_values(model, res_id, val, model_field.id)
                 with Transaction().set_user(0, set_context=True):
-                    cls.create(vals).id
+                    cls.create([vals])

trytond/ir/rule.py

@@ -79,8 +79,8 @@ class RuleGroup(ModelSQL, ModelView):
         Pool().get('ir.rule')._domain_get_cache.clear()
 
     @classmethod
-    def create(cls, vals):
-        res = super(RuleGroup, cls).create(vals)
+    def create(cls, vlist):
+        res = super(RuleGroup, cls).create(vlist)
         # Restart the cache on the domain_get method of ir.rule
         Pool().get('ir.rule')._domain_get_cache.clear()
         return res
@@ -252,8 +252,8 @@ class Rule(ModelSQL, ModelView):
         cls._domain_get_cache.clear()
 
     @classmethod
-    def create(cls, vals):
-        res = super(Rule, cls).create(vals)
+    def create(cls, vlist):
+        res = super(Rule, cls).create(vlist)
         # Restart the cache on the domain_get method of ir.rule
         cls._domain_get_cache.clear()
         return res

trytond/ir/sequence.py

@@ -2,6 +2,7 @@
 #this repository contains the full copyright notices and license terms.
 from string import Template
 import time
+from itertools import izip
 from ..model import ModelView, ModelSQL, fields
 from ..tools import datetime_strftime
 from ..pyson import Eval, And
@@ -171,13 +172,13 @@ class Sequence(ModelSQL, ModelView):
                 })
 
     @classmethod
-    def create(cls, values):
-        sequence_id = super(Sequence, cls).create(values)
-        if sql_sequence and not cls._strict:
-            sequence = cls(sequence_id)
-            sequence.update_sql_sequence(values.get('number_next',
-                    cls.default_number_next()))
-        return sequence_id
+    def create(cls, vlist):
+        sequences = super(Sequence, cls).create(vlist)
+        for sequence, values in izip(sequences, vlist):
+            if sql_sequence and not cls._strict:
+                sequence.update_sql_sequence(values.get('number_next',
+                        cls.default_number_next()))
+        return sequences
 
     @classmethod
     def write(cls, sequences, values):

trytond/ir/translation.py

@@ -278,14 +278,14 @@ class Translation(ModelSQL, ModelView):
                     ])
                 with Transaction().set_user(0):
                     if not translation2:
-                        cls.create({
-                            'name': name,
-                            'lang': lang,
-                            'type': ttype,
-                            'src': getattr(record, field_name),
-                            'value': value,
-                            'fuzzy': False,
-                            })
+                        cls.create([{
+                                    'name': name,
+                                    'lang': lang,
+                                    'type': ttype,
+                                    'src': getattr(record, field_name),
+                                    'value': value,
+                                    'fuzzy': False,
+                                    }])
                     else:
                         cls.write(translation2, {
                             'src': getattr(record, field_name),
@@ -305,15 +305,15 @@ class Translation(ModelSQL, ModelView):
                 ])
             with Transaction().set_user(0):
                 if not translation2:
-                    cls.create({
-                        'name': name,
-                        'lang': lang,
-                        'type': ttype,
-                        'res_id': record.id,
-                        'value': value,
-                        'src': getattr(record, field_name),
-                        'fuzzy': False,
-                        })
+                    cls.create([{
+                                'name': name,
+                                'lang': lang,
+                                'type': ttype,
+                                'res_id': record.id,
+                                'value': value,
+                                'src': getattr(record, field_name),
+                                'fuzzy': False,
+                                }])
                 else:
                     cls.write(translation2, {
                         'value': value,
@@ -462,43 +462,43 @@ class Translation(ModelSQL, ModelView):
         return super(Translation, cls).delete(translations)
 
     @classmethod
-    def create(cls, vals):
+    def create(cls, vlist):
         cls._translation_cache.clear()
         ModelView._fields_view_get_cache.clear()
+        vlist = [x.copy() for x in vlist]
+
         cursor = Transaction().cursor
-        if not vals.get('module'):
-            if Transaction().context.get('module'):
-                vals = vals.copy()
-                vals['module'] = Transaction().context['module']
-            elif vals.get('type', '') in ('odt', 'view', 'wizard_button',
-                    'selection', 'error'):
-                cursor.execute('SELECT module FROM ir_translation '
-                    'WHERE name = %s '
-                        'AND res_id = %s '
-                        'AND lang = %s '
-                        'AND type = %s '
-                        'AND src = %s ',
-                    (vals.get('name') or '', vals.get('res_id') or 0, 'en_US',
-                        vals.get('type') or '', vals.get('src') or ''))
-                fetchone = cursor.fetchone()
-                if fetchone:
-                    vals = vals.copy()
-                    vals['module'] = fetchone[0]
-            else:
-                cursor.execute('SELECT module, src FROM ir_translation '
-                    'WHERE name = %s '
-                        'AND res_id = %s '
-                        'AND lang = %s '
-                        'AND type = %s',
-                    (vals.get('name') or '', vals.get('res_id') or 0, 'en_US',
-                        vals.get('type') or ''))
-                fetchone = cursor.fetchone()
-                if fetchone:
-                    vals = vals.copy()
-                    vals['module'], vals['src'] = fetchone
-        vals = vals.copy()
-        vals['src_md5'] = cls.get_src_md5(vals.get('src'))
-        return super(Translation, cls).create(vals)
+        for vals in vlist:
+            if not vals.get('module'):
+                if Transaction().context.get('module'):
+                    vals['module'] = Transaction().context['module']
+                elif vals.get('type', '') in ('odt', 'view', 'wizard_button',
+                        'selection', 'error'):
+                    cursor.execute('SELECT module FROM ir_translation '
+                        'WHERE name = %s '
+                            'AND res_id = %s '
+                            'AND lang = %s '
+                            'AND type = %s '
+                            'AND src = %s ',
+                        (vals.get('name') or '', vals.get('res_id') or 0,
+                            'en_US', vals.get('type') or '', vals.get('src')
+                            or ''))
+                    fetchone = cursor.fetchone()
+                    if fetchone:
+                        vals['module'] = fetchone[0]
+                else:
+                    cursor.execute('SELECT module, src FROM ir_translation '
+                        'WHERE name = %s '
+                            'AND res_id = %s '
+                            'AND lang = %s '
+                            'AND type = %s',
+                        (vals.get('name') or '', vals.get('res_id') or 0, 
+                            'en_US', vals.get('type') or ''))
+                    fetchone = cursor.fetchone()
+                    if fetchone:
+                        vals['module'], vals['src'] = fetchone
+            vals['src_md5'] = cls.get_src_md5(vals.get('src'))
+        return super(Translation, cls).create(vlist)
 
     @classmethod
     def write(cls, translations, vals):
@@ -522,6 +522,7 @@ class Translation(ModelSQL, ModelView):
             fs_id2model_data[model_data.model][model_data.fs_id] = model_data
 
         translations = set()
+        to_create = []
         pofile = polib.pofile(po_path)
 
         id2translation = {}
@@ -575,7 +576,7 @@ class Translation(ModelSQL, ModelView):
             with contextlib.nested(Transaction().set_user(0),
                     Transaction().set_context(module=module)):
                 if not ids:
-                    translations.add(cls.create({
+                    to_create.append({
                         'name': name,
                         'res_id': res_id,
                         'lang': lang,
@@ -584,7 +585,7 @@ class Translation(ModelSQL, ModelView):
                         'value': value,
                         'fuzzy': fuzzy,
                         'module': module,
-                        }))
+                        })
                 else:
                     translations2 = []
                     for translation_id in ids:
@@ -599,6 +600,9 @@ class Translation(ModelSQL, ModelView):
                             })
                     translations |= set(cls.browse(ids))
 
+        if to_create:
+            translations |= set(cls.create(to_create))
+
         if translations:
             all_translations = set(cls.search([
                         ('module', '=', module),
@@ -1063,16 +1067,19 @@ class TranslationUpdate(Wizard):
                     'AND type in (\'odt\', \'view\', \'wizard_button\', ' \
                     ' \'selection\', \'error\')',
                 (lang,))
+        to_create = []
         for row in cursor.dictfetchall():
+            to_create.append({
+                'name': row['name'],
+                'res_id': row['res_id'],
+                'lang': lang,
+                'type': row['type'],
+                'src': row['src'],
+                'module': row['module'],
+                })
+        if to_create:
             with Transaction().set_user(0):
-                Translation.create({
-                    'name': row['name'],
-                    'res_id': row['res_id'],
-                    'lang': lang,
-                    'type': row['type'],
-                    'src': row['src'],
-                    'module': row['module'],
-                    })
+                Translation.create(to_create)
         cursor.execute('SELECT name, res_id, type, module ' \
                 'FROM ir_translation ' \
                 'WHERE lang=\'en_US\' ' \
@@ -1082,15 +1089,18 @@ class TranslationUpdate(Wizard):
                 'WHERE lang=%s ' \
                     'AND type in (\'field\', \'model\', \'help\')',
                 (lang,))
+        to_create = []
         for row in cursor.dictfetchall():
+            to_create.append({
+                'name': row['name'],
+                'res_id': row['res_id'],
+                'lang': lang,
+                'type': row['type'],
+                'module': row['module'],
+                })
+        if to_create:
             with Transaction().set_user(0):
-                Translation.create({
-                    'name': row['name'],
-                    'res_id': row['res_id'],
-                    'lang': lang,
-                    'type': row['type'],
-                    'module': row['module'],
-                    })
+                Translation.create(to_create)
         cursor.execute('SELECT name, res_id, type, src ' \
                 'FROM ir_translation ' \
                 'WHERE lang=\'en_US\' ' \

trytond/ir/trigger.py

@@ -223,11 +223,14 @@ class Trigger(ModelSQL, ModelView):
         if records:
             getattr(Model, trigger.action_function)(records, trigger)
         if trigger.limit_number or trigger.minimum_delay:
+            to_create = []
             for record in records:
-                TriggerLog.create({
-                    'trigger': trigger.id,
-                    'record_id': record.id,
-                    })
+                to_create.append({
+                        'trigger': trigger.id,
+                        'record_id': record.id,
+                        })
+            if to_create:
+                TriggerLog.create(to_create)
 
     @classmethod
     def trigger_time(cls):
@@ -250,8 +253,8 @@ class Trigger(ModelSQL, ModelView):
                 cls.trigger_action(triggered, trigger)
 
     @classmethod
-    def create(cls, values):
-        res = super(Trigger, cls).create(values)
+    def create(cls, vlist):
+        res = super(Trigger, cls).create(vlist)
         # Restart the cache on the get_triggers method of ir.trigger
         cls._get_triggers_cache.clear()
         return res

trytond/ir/ui/menu.py

@@ -225,13 +225,16 @@ class UIMenu(ModelSQL, ModelView):
             return
         Action = pool.get(action_type)
         action = Action(int(action_id))
+        to_create = []
         for menu in menus:
             with Transaction().set_context(_timestamp=False):
-                ActionKeyword.create({
-                    'keyword': 'tree_open',
-                    'model': str(menu),
-                    'action': action.action.id,
-                    })
+                to_create.append({
+                        'keyword': 'tree_open',
+                        'model': str(menu),
+                        'action': action.action.id,
+                        })
+        if to_create:
+            ActionKeyword.create(to_create)
 
     @classmethod
     def get_favorite(cls, menus, name):
@@ -288,10 +291,10 @@ class UIMenuFavorite(ModelSQL, ModelView):
     @classmethod
     def set(cls, menu_id):
         user = Transaction().user
-        cls.create({
-                'menu': menu_id,
-                'user': user,
-                })
+        cls.create([{
+                    'menu': menu_id,
+                    'user': user,
+                    }])
 
     @classmethod
     def unset(cls, menu_id):

trytond/ir/ui/view.py

@@ -257,11 +257,11 @@ class View(ModelSQL, ModelView):
         ModelView._fields_view_get_cache.clear()
 
     @classmethod
-    def create(cls, vals):
-        view = super(View, cls).create(vals)
+    def create(cls, vlist):
+        views = super(View, cls).create(vlist)
         # Restart the cache
         ModelView._fields_view_get_cache.clear()
-        return view
+        return views
 
     @classmethod
     def write(cls, views, vals):
@@ -336,8 +336,8 @@ class ViewTreeWidth(ModelSQL, ModelView):
         super(ViewTreeWidth, cls).delete(records)
 
     @classmethod
-    def create(cls, vals):
-        res = super(ViewTreeWidth, cls).create(vals)
+    def create(cls, vlist):
+        res = super(ViewTreeWidth, cls).create(vlist)
         ModelView._fields_view_get_cache.clear()
         return res
 
@@ -359,13 +359,16 @@ class ViewTreeWidth(ModelSQL, ModelView):
             ])
         cls.delete(records)
 
+        to_create = []
         for field in fields.keys():
-            cls.create({
-                'model': model,
-                'field': field,
-                'user': Transaction().user,
-                'width': fields[field],
-                })
+            to_create.append({
+                    'model': model,
+                    'field': field,
+                    'user': Transaction().user,
+                    'width': fields[field],
+                    })
+        if to_create:
+            cls.create(to_create)
 
 
 class ViewTreeExpandedState(ModelSQL, ModelView):
@@ -410,13 +413,13 @@ class ViewTreeExpandedState(ModelSQL, ModelView):
                     ('child_name', '=', child_name),
                     ])
             cls.delete(records)
-            cls.create({
-                    'user': current_user,
-                    'model': model,
-                    'domain': domain,
-                    'child_name': child_name,
-                    'nodes': nodes,
-                    })
+            cls.create([{
+                        'user': current_user,
+                        'model': model,
+                        'domain': domain,
+                        'child_name': child_name,
+                        'nodes': nodes,
+                        }])
 
     @classmethod
     def get_expanded(cls, model, domain, child_name):

trytond/model/fields/many2many.py

@@ -102,7 +102,7 @@ class Many2Many(Field):
         Set the values.
 
         values: A list of tuples:
-            (``create``, ``{<field name>: value}``),
+            (``create``, ``[{<field name>: value}, ...]``),
             (``write``, ``<ids>``, ``{<field name>: value}``),
             (``delete``, ``<ids>``),
             (``delete_all``),
@@ -116,7 +116,6 @@ class Many2Many(Field):
             return
         Relation = pool.get(self.relation_name)
         Target = self.get_target()
-
         if self.origin in Relation._fields:
             origin_field = Relation._fields[self.origin]
         else:
@@ -137,11 +136,15 @@ class Many2Many(Field):
 
         for act in values:
             if act[0] == 'create':
+                to_create = []
                 for record_id in ids:
-                    Relation.create({
-                            self.origin: field_value(record_id),
-                            self.target: Target.create(act[1]).id,
-                            })
+                    for new in Target.create(act[1]):
+                        to_create.append({
+                                self.origin: field_value(record_id),
+                                self.target: new.id,
+                                })
+                if to_create:
+                    Relation.create(to_create)
             elif act[0] == 'write':
                 Target.write(Target.browse(act[1]), act[2])
             elif act[0] == 'delete':
@@ -182,12 +185,15 @@ class Many2Many(Field):
                             ])
                     for relation in relations:
                         existing_ids.append(getattr(relation, self.target).id)
+                to_create = []
                 for new_id in (x for x in target_ids if x not in existing_ids):
                     for record_id in ids:
-                        Relation.create({
+                        to_create.append({
                                 self.origin: field_value(record_id),
                                 self.target: new_id,
                                 })
+                if to_create:
+                    Relation.create(to_create)
             elif act[0] == 'unlink_all':
                 targets = Relation.search([
                         search_clause(ids),
@@ -205,12 +211,15 @@ class Many2Many(Field):
                         ])
                 Relation.delete(targets2)
 
+                to_create = []
                 for new_id in target_ids:
                     for record_id in ids:
-                        Relation.create({
+                        to_create.append({
                                 self.origin: field_value(record_id),
                                 self.target: new_id,
                                 })
+                if to_create:
+                    Relation.create(to_create)
             else:
                 raise Exception('Bad arguments')
 

trytond/model/fields/one2many.py

@@ -107,7 +107,7 @@ class One2Many(Field):
         '''
         Set the values.
         values: A list of tuples:
-            (``create``, ``{<field name>: value}``),
+            (``create``, ``[{<field name>: value}, ...]``),
             (``write``, ``<ids>``, ``{<field name>: value}``),
             (``delete``, ``<ids>``),
             (``delete_all``),
@@ -139,9 +139,15 @@ class One2Many(Field):
 
         for act in values:
             if act[0] == 'create':
+                to_create = []
                 for record_id in ids:
-                    act[1][self.field] = field_value(record_id)
-                    Target.create(act[1])
+                    value = field_value(record_id)
+                    for vals in act[1]:
+                        vals = vals.copy()
+                        vals[self.field] = value
+                        to_create.append(vals)
+                if to_create:
+                    Target.create(to_create)
             elif act[0] == 'write':
                 Target.write(Target.browse(act[1]), act[2])
             elif act[0] == 'delete':

trytond/model/fields/one2one.py

@@ -44,11 +44,14 @@ class One2One(Many2Many):
                 ])
         Relation.delete(relations)
         if value:
+            to_create = []
             for record_id in ids:
-                Relation.create({
+                to_create.append({
                         self.origin: record_id,
                         self.target: value,
                         })
+            if to_create:
+                Relation.create(to_create)
 
     def __set__(self, inst, value):
         Target = self.get_target()

trytond/model/modelsingleton.py

@@ -18,13 +18,13 @@ class ModelSingleton(ModelStorage):
             return singletons[0]
 
     @classmethod
-    def create(cls, values):
+    def create(cls, vlist):
+        assert len(vlist) == 1
         singleton = cls.get_singleton()
-        if singleton:
-            cls.write([singleton], values)
-        else:
-            singleton = super(ModelSingleton, cls).create(values)
-        return singleton
+        if not singleton:
+            return super(ModelSingleton, cls).create(vlist)
+        cls.write([singleton], vlist[0])
+        return [singleton]
 
     @classmethod
     def read(cls, ids, fields_names=None):
@@ -48,7 +48,7 @@ class ModelSingleton(ModelStorage):
     def write(cls, records, values):
         singleton = cls.get_singleton()
         if not singleton:
-            return cls.create(values)
+            return cls.create([values])
         return super(ModelSingleton, cls).write([singleton], values)
 
     @classmethod

trytond/model/modelsql.py

@@ -5,7 +5,7 @@ import datetime
 import re
 from functools import reduce
 from decimal import Decimal
-from itertools import islice
+from itertools import islice, izip
 
 from trytond.model import ModelStorage
 from trytond.model import fields
@@ -220,186 +220,212 @@ class ModelSQL(ModelStorage):
         return None
 
     @classmethod
-    def create(cls, values):
-        super(ModelSQL, cls).create(values)
+    def create(cls, vlist):
+        super(ModelSQL, cls).create(vlist)
         cursor = Transaction().cursor
         pool = Pool()
 
         if cls.table_query():
             return False
 
-        values = values.copy()
+        modified_fields = set()
+        new_ids = []
+        vlist = [v.copy() for v in vlist]
+        for values in vlist:
+            # Clean values
+            for key in ('create_uid', 'create_date', 'write_uid', 'write_date',
+                    'id'):
+                if key in values:
+                    del values[key]
+            modified_fields |= set(values.keys())
 
-        # Clean values
-        for key in ('create_uid', 'create_date', 'write_uid', 'write_date',
-                'id'):
-            if key in values:
-                del values[key]
+            # Get default values
+            default = []
+            avoid_table = []
+            for (i, j) in cls._inherits.items():
+                if j in values:
+                    avoid_table.append(i)
+            for i in cls._fields.keys():
+                if not i in values \
+                        and i not in ('create_uid', 'create_date',
+                                'write_uid', 'write_date'):
+                    default.append(i)
+            for i in cls._inherit_fields.keys():
+                if ((not i in values)
+                        and (not cls._inherit_fields[i][0] in avoid_table)
+                        and i in cls._defaults):
+                    default.append(i)
 
-        # Get default values
-        default = []
-        avoid_table = []
-        for (i, j) in cls._inherits.items():
-            if j in values:
-                avoid_table.append(i)
-        for i in cls._fields.keys():
-            if not i in values \
-                    and i not in ('create_uid', 'create_date',
+            if len(default):
+                defaults = cls.default_get(default, with_rec_name=False)
+                for field in defaults.keys():
+                    if '.' in field:
+                        del defaults[field]
+                    if field in ('create_uid', 'create_date',
                             'write_uid', 'write_date'):
-                default.append(i)
-        for i in cls._inherit_fields.keys():
-            if ((not i in values)
-                    and (not cls._inherit_fields[i][0] in avoid_table)
-                    and i in cls._defaults):
-                default.append(i)
+                        del defaults[field]
+                    if field in values:
+                        del defaults[field]
+                values.update(cls._clean_defaults(defaults))
 
-        if len(default):
-            defaults = cls.default_get(default, with_rec_name=False)
-            for field in defaults.keys():
-                if '.' in field:
-                    del defaults[field]
-                if field in ('create_uid', 'create_date',
-                        'write_uid', 'write_date'):
-                    del defaults[field]
-                if field in values:
-                    del defaults[field]
-            values.update(cls._clean_defaults(defaults))
+            (upd0, upd1, upd2) = ('', '', [])
+            upd_todo = []
 
-        (upd0, upd1, upd2) = ('', '', [])
-        upd_todo = []
+            # Create inherits
+            tocreate = {}
+            for i in cls._inherits:
+                if cls._inherits[i] not in values:
+                    tocreate[i] = {}
 
-        # Create inherits
-        tocreate = {}
-        for i in cls._inherits:
-            if cls._inherits[i] not in values:
-                tocreate[i] = {}
+            for i in values.keys():
+                if i in cls._inherit_fields:
+                    (inherits, _, _) = cls._inherit_fields[i]
+                    if i in cls._fields:
+                        continue
+                    if inherits in tocreate:
+                        tocreate[inherits][i] = values[i]
+                    del values[i]
 
-        for i in values.keys():
-            if i in cls._inherit_fields:
-                (inherits, _, _) = cls._inherit_fields[i]
-                if i in cls._fields:
-                    continue
-                if inherits in tocreate:
-                    tocreate[inherits][i] = values[i]
-                del values[i]
+            for inherits in tocreate:
+                Inherits = pool.get(inherits)
+                inherits_record, = Inherits.create([tocreate[inherits]])
+                values[cls._inherits[inherits]] = inherits_record.id
 
-        for inherits in tocreate:
-            Inherits = pool.get(inherits)
-            inherits_record = Inherits.create(tocreate[inherits])
-            values[cls._inherits[inherits]] = inherits_record.id
-
-        # Insert record
-        for fname, value in values.iteritems():
-            field = cls._fields[fname]
-            if not hasattr(field, 'set'):
-                upd0 = upd0 + ',"' + fname + '"'
-                upd1 = upd1 + ', %s'
-                upd2.append(FIELDS[field._type].sql_format(value))
-            else:
-                upd_todo.append(fname)
-        upd0 += ', create_uid, create_date'
-        upd1 += ', %s, %s'
-        upd2.append(Transaction().user)
-        upd2.append(datetime.datetime.now())
-        try:
-            if cursor.has_returning():
-                cursor.execute('INSERT INTO "' + cls._table + '" '
-                    '(' + upd0[1:] + ') '
-                    'VALUES (' + upd1[1:] + ') RETURNING id',
-                    tuple(upd2))
-                id_new, = cursor.fetchone()
-            else:
-                id_new = cursor.nextid(cls._table)
-                if id_new:
-                    cursor.execute('INSERT INTO "' + cls._table + '" '
-                        '(id' + upd0 + ') '
-                        'VALUES (' + str(id_new) + upd1 + ')',
-                        tuple(upd2))
+            # Insert record
+            for fname, value in values.iteritems():
+                field = cls._fields[fname]
+                if not hasattr(field, 'set'):
+                    upd0 = upd0 + ',"' + fname + '"'
+                    upd1 = upd1 + ', %s'
+                    upd2.append(FIELDS[field._type].sql_format(value))
                 else:
+                    upd_todo.append(fname)
+            upd0 += ', create_uid, create_date'
+            upd1 += ', %s, %s'
+            upd2.append(Transaction().user)
+            upd2.append(datetime.datetime.now())
+
+            try:
+                if cursor.has_returning():
                     cursor.execute('INSERT INTO "' + cls._table + '" '
                         '(' + upd0[1:] + ') '
-                        'VALUES (' + upd1[1:] + ')',
+                        'VALUES (' + upd1[1:] + ') RETURNING id',
                         tuple(upd2))
-                    id_new = cursor.lastid()
-        except DatabaseIntegrityError, exception:
-            with contextlib.nested(Transaction().new_cursor(),
-                    Transaction().set_user(0)):
-                for field_name in cls._fields:
-                    field = cls._fields[field_name]
-                    # Check required fields
-                    if field.required and \
-                            not hasattr(field, 'set') and \
-                            field_name not in ('create_uid', 'create_date'):
-                        if values.get(field_name) is None:
-                            cls.raise_user_error('required_field',
-                                    error_args=cls._get_error_args(
-                                        field_name))
-                    if isinstance(field, fields.Many2One) \
-                            and values.get(field_name):
-                        Model = pool.get(field.model_name)
-                        create_records = Transaction().create_records.get(
-                                field.model_name, set())
-                        delete_records = Transaction().delete_records.get(
-                                field.model_name, set())
-                        if not ((Model.search([
-                                            ('id', '=', values[field_name]),
-                                            ], order=[])
-                                    or values[field_name] in create_records)
-                                and values[field_name] not in delete_records):
-                            cls.raise_user_error('foreign_model_missing',
-                                    error_args=cls._get_error_args(
-                                        field_name))
-                for name, _, error in cls._sql_constraints:
-                    if name in exception[0]:
-                        cls.raise_user_error(error)
-                for name, error in cls._sql_error_messages:
-                    if name in exception[0]:
-                        cls.raise_user_error(error)
-            raise
+                    id_new, = cursor.fetchone()
+                else:
+                    id_new = cursor.nextid(cls._table)
+                    if id_new:
+                        cursor.execute('INSERT INTO "' + cls._table + '" '
+                            '(id' + upd0 + ') '
+                            'VALUES (' + str(id_new) + upd1 + ')',
+                            tuple(upd2))
+                    else:
+                        cursor.execute('INSERT INTO "' + cls._table + '" '
+                            '(' + upd0[1:] + ') '
+                            'VALUES (' + upd1[1:] + ')',
+                            tuple(upd2))
+                        id_new = cursor.lastid()
+                new_ids.append(id_new)
+            except DatabaseIntegrityError, exception:
+                with contextlib.nested(Transaction().new_cursor(),
+                        Transaction().set_user(0)):
+                    for field_name in cls._fields:
+                        field = cls._fields[field_name]
+                        # Check required fields
+                        if field.required and \
+                                not hasattr(field, 'set') and \
+                                field_name not in ('create_uid', 'create_date'):
+                            if values.get(field_name) is None:
+                                cls.raise_user_error('required_field',
+                                        error_args=cls._get_error_args(
+                                            field_name))
+                        if isinstance(field, fields.Many2One) \
+                                and values.get(field_name):
+                            Model = pool.get(field.model_name)
+                            create_records = Transaction().create_records.get(
+                                    field.model_name, set())
+                            delete_records = Transaction().delete_records.get(
+                                    field.model_name, set())
+                            if not ((Model.search([
+                                                ('id', '=', values[field_name]),
+                                                ], order=[])
+                                        or values[field_name] in create_records)
+                                    and values[field_name] not in 
+                                    delete_records):
+                                cls.raise_user_error('foreign_model_missing',
+                                        error_args=cls._get_error_args(
+                                            field_name))
+                    for name, _, error in cls._sql_constraints:
+                        if name in exception[0]:
+                            cls.raise_user_error(error)
+                    for name, error in cls._sql_error_messages:
+                        if name in exception[0]:
+                            cls.raise_user_error(error)
+                raise
 
         domain1, domain2 = pool.get('ir.rule').domain_get(cls.__name__,
                 mode='create')
         if domain1:
-            cursor.execute('SELECT id FROM "' + cls._table + '" ' \
-                    'WHERE id = %s AND (' + domain1 + ')',
-                    [id_new] + domain2)
-            if not cursor.fetchone():
-                cls.raise_user_error('access_error', cls.__name__)
+            in_max = Transaction().cursor.IN_MAX
+            for i in range(0, len(new_ids), in_max):
+                sub_ids = new_ids[i:i + in_max]
+                red_sql, red_ids = reduce_ids('id', sub_ids)
 
-        Transaction().create_records.setdefault(
-            cls.__name__, set()).add(id_new)
+                cursor.execute('SELECT id FROM "' + cls._table + '" WHERE ' +
+                        red_sql + ' AND (' + domain1 + ')', red_ids + domain2)
+                if len(cursor.fetchall()) != len(sub_ids):
+                    cls.raise_user_error('access_error', cls.__name__)
 
-        for field in values:
-            if getattr(cls._fields[field], 'translate', False):
-                pool.get('ir.translation').set_ids(
-                        cls.__name__ + ',' + field, 'model',
-                        Transaction().language, [id_new], values[field])
+        create_records = Transaction().create_records.setdefault(cls.__name__, 
+                set()).update(new_ids)
 
-        for field in upd_todo:
-            cls._fields[field].set([id_new], cls, field, values[field])
+        for values, new_id in izip(vlist, new_ids):
+            for field in values:
+                if getattr(cls._fields[field], 'translate', False):
+                        pool.get('ir.translation').set_ids(
+                                cls.__name__ + ',' + field, 'model',
+                                Transaction().language, [new_id], values[field])
+
+            for field in upd_todo:
+                if field in values:
+                    cls._fields[field].set([new_id], cls, field, values[field])
 
         if cls._history:
-            cursor.execute('INSERT INTO "' + cls._table + '__history" '
-                '(id' + upd0 + ') '
-                'SELECT id' + upd0 + ' '
-                'FROM "' + cls._table + '" '
-                'WHERE id = %s', (id_new,))
+            columns = ['"' + str(x) + '"' for x in cls._fields 
+                if not hasattr(cls._fields[x], 'set')]
+            columns = ','.join(columns)
+            for i in range(0, len(new_ids), cursor.IN_MAX):
+                sub_ids = new_ids[i:i + cursor.IN_MAX]
+                red_sql, red_ids = reduce_ids('id', sub_ids)
+                cursor.execute('INSERT INTO "' + cls._table + '__history" ' 
+                    '(' + columns + ') '
+                    'SELECT ' + columns + ' '
+                    'FROM "' + cls._table + '" '
+                    'WHERE ' + red_sql, red_ids)
 
-        record = cls(id_new)
-        cls._validate([record])
+        records = cls.browse(new_ids)
+        cls._validate(records)
 
         # Check for Modified Preorder Tree Traversal
         for k in cls._fields:
             field = cls._fields[k]
-            if isinstance(field, fields.Many2One) \
-                    and field.model_name == cls.__name__ \
-                    and field.left and field.right:
-                cls._update_tree(id_new, k, field.left, field.right)
-
-        cls.trigger_create(record)
-
-        return record
+            if (isinstance(field, fields.Many2One)
+                    and field.model_name == cls.__name__
+                    and field.left and field.right):
+                if (field.left in modified_fields 
+                        or field.right in modified_fields):
+                    raise Exception('ValidateError',
+                            'You can not update fields: "%s", "%s"' %
+                            (field.left, field.right))
+                if len(new_ids) == 1:
+                    cls._update_tree(new_ids[0], k, field.left, field.right)
+                else:
+                    with Transaction().set_user(0):
+                        cls._rebuild_tree(k, False, 0)
 
+        cls.trigger_create(records)
+        return records
+    
     @classmethod
     def read(cls, ids, fields_names=None):
         pool = Pool()

trytond/model/modelstorage.py

@@ -14,7 +14,7 @@ except ImportError:
     import StringIO
 
 from decimal import Decimal
-from itertools import islice, ifilter, ifilterfalse, chain
+from itertools import islice, ifilter, ifilterfalse, chain, izip
 from functools import reduce
 
 from trytond.model import Model
@@ -49,7 +49,7 @@ class ModelStorage(Model):
         super(ModelStorage, cls).__setup__()
         if issubclass(cls, ModelView):
             cls.__rpc__.update({
-                    'create': RPC(readonly=False, result=int),
+                    'create': RPC(readonly=False, result=lambda r: map(int, r)),
                     'read': RPC(),
                     'write': RPC(readonly=False, instantiate=0),
                     'delete': RPC(readonly=False, instantiate=0),
@@ -74,23 +74,24 @@ class ModelStorage(Model):
         return datetime.datetime.today()
 
     @classmethod
-    def create(cls, values):
+    def create(cls, vlist):
         '''
-        Create record and return an instance.
+        Returns the list of created records.
         '''
         pool = Pool()
         ModelAccess = pool.get('ir.model.access')
         ModelFieldAccess = pool.get('ir.model.field.access')
 
         ModelAccess.check(cls.__name__, 'create')
-        ModelFieldAccess.check(cls.__name__,
-            [x for x in values if x in cls._fields], 'write')
+
+        all_fields = list(set(chain(*(v.iterkeys() for v in vlist))))
+        ModelFieldAccess.check(cls.__name__, all_fields, 'write')
 
         # Increase transaction counter
         Transaction().counter += 1
 
     @classmethod
-    def trigger_create(cls, record):
+    def trigger_create(cls, records):
         '''
         Trigger create actions
         '''
@@ -99,8 +100,12 @@ class ModelStorage(Model):
         if not triggers:
             return
         for trigger in triggers:
-            if Trigger.eval(trigger, record):
-                Trigger.trigger_action([record], trigger)
+            triggers = []
+            for record in records:
+                if Trigger.eval(trigger, record):
+                    triggers.append(record)
+            if triggers:
+                Trigger.trigger_action(triggers, trigger)
 
     @classmethod
     def read(cls, ids, fields_names=None):
@@ -281,21 +286,26 @@ class ModelStorage(Model):
         ids = map(int, records)
         datas = cls.read(ids, fields_names=fields_names)
         field_defs = cls.fields_get(fields_names=fields_names)
+        data_ids = []
+        to_create = []
+        o2m_to_create = []
         for data in datas:
-            data_id = data['id']
+            data_ids.append(data['id'])
             data, data_o2m = convert_data(field_defs, data)
-            new_record = cls.create(data)
-            if new_record:
-                new_ids[data_id] = new_record.id
-            else:
-                continue
+            to_create.append(data)
+            o2m_to_create.append(data_o2m)
+        if to_create:
+            new_records = cls.create(to_create)
+        for data_id, new_record, data_o2m in izip(data_ids, new_records,
+                o2m_to_create):
+            new_ids[data_id] = new_record.id
             for field_name in data_o2m:
                 Relation = pool.get(
                         field_defs[field_name]['relation'])
                 relation_field = field_defs[field_name]['relation_field']
                 if relation_field:
                     Relation.copy(Relation.browse(data_o2m[field_name]),
-                        default={relation_field: new_ids[data_id]})
+                        default={relation_field: new_record.id})
 
         fields_translate = {}
         for field_name, field in field_defs.iteritems():
@@ -709,7 +719,7 @@ class ModelStorage(Model):
                 nbrmax = max(nbrmax, max2)
                 reduce(lambda x, y: x and y, newrow)
                 row[field] = (reduce(lambda x, y: x or y, newrow.values()) and
-                         [('create', newrow)]) or []
+                         [('create', [newrow])]) or []
                 i = max2
                 while (position + i) < len(data):
                     test = True
@@ -724,7 +734,7 @@ class ModelStorage(Model):
                             process_lines(data, prefix + [field], newfd,
                                     position + i)
                     if reduce(lambda x, y: x or y, newrow.values()):
-                        row[field].append(('create', newrow))
+                        row[field].append(('create', [newrow]))
                     i += max2
                     nbrmax = max(nbrmax, i)
             if prefix_len == 0:
@@ -756,7 +766,7 @@ class ModelStorage(Model):
                     # XXX should raise Exception
                     Transaction().cursor.rollback()
                     return (-1, res, warning, '')
-                new_id = cls.create(res)
+                new_id, = cls.create([res])
                 for lang in translate:
                     with Transaction().set_context(language=lang):
                         cls.write(new_id, translate[lang])
@@ -1128,7 +1138,7 @@ class ModelStorage(Model):
                 vals[field] = []
                 for defaults2 in defaults[field]:
                     vals2 = obj._clean_defaults(defaults2)
-                    vals[field].append(('create', vals2))
+                    vals[field].append(('create', [vals2]))
             elif fld_def._type in ('many2many',):
                 vals[field] = [('set', defaults[field])]
             elif fld_def._type in ('boolean',):
@@ -1366,7 +1376,7 @@ class ModelStorage(Model):
                     ]
                 for target in targets:
                     if target.id < 0:
-                        value.append(('create', target._save_values))
+                        value.append(('create', [target._save_values]))
                     elif target._save_values:
                         value.append(
                             ('write', [target.id], target._save_values))
@@ -1383,7 +1393,7 @@ class ModelStorage(Model):
                 if self.id < 0:
                     self._ids.remove(self.id)
                     try:
-                        self.id = self.create(self._save_values).id
+                        self.id = self.create([self._save_values])[0].id
                     finally:
                         self._ids.append(self.id)
                 else:

trytond/res/group.py

@@ -73,8 +73,8 @@ class Group(ModelSQL, ModelView):
         return new_groups
 
     @classmethod
-    def create(cls, vals):
-        res = super(Group, cls).create(vals)
+    def create(cls, vlist):
+        res = super(Group, cls).create(vlist)
         pool = Pool()
         # Restart the cache on the domain_get method
         pool.get('ir.rule')._domain_get_cache.clear()

trytond/res/ir.py

@@ -36,8 +36,8 @@ class UIMenuGroup(ModelSQL):
         super(UIMenuGroup, cls).__register__(module_name)
 
     @classmethod
-    def create(cls, vals):
-        res = super(UIMenuGroup, cls).create(vals)
+    def create(cls, vlist):
+        res = super(UIMenuGroup, cls).create(vlist)
         # Restart the cache on the domain_get method
         Pool().get('ir.rule')._domain_get_cache.clear()
         return res
@@ -77,12 +77,13 @@ class ActionGroup(ModelSQL):
         super(ActionGroup, cls).__register__(module_name)
 
     @classmethod
-    def create(cls, vals):
+    def create(cls, vlist):
         Action = Pool().get('ir.action')
-        if vals.get('action'):
-            vals = vals.copy()
-            vals['action'] = Action.get_action_id(vals['action'])
-        res = super(ActionGroup, cls).create(vals)
+        vlist = [x.copy() for x in vlist]
+        for vals in vlist:
+            if vals.get('action'):
+                vals['action'] = Action.get_action_id(vals['action'])
+        res = super(ActionGroup, cls).create(vlist)
         # Restart the cache on the domain_get method
         Pool().get('ir.rule')._domain_get_cache.clear()
         return res
@@ -137,9 +138,9 @@ class ModelButtonGroup(ModelSQL):
         return True
 
     @classmethod
-    def create(cls, values):
+    def create(cls, vlist):
         pool = Pool()
-        result = super(ModelButtonGroup, cls).create(values)
+        result = super(ModelButtonGroup, cls).create(vlist)
         # Restart the cache for get_groups
         pool.get('ir.model.button')._groups_cache.clear()
         return result
@@ -238,9 +239,9 @@ class SequenceTypeGroup(ModelSQL):
         Rule._domain_get_cache.clear()
 
     @classmethod
-    def create(cls, vals):
+    def create(cls, vlist):
         Rule = Pool().get('ir.rule')
-        res = super(SequenceTypeGroup, cls).create(vals)
+        res = super(SequenceTypeGroup, cls).create(vlist)
         # Restart the cache on the domain_get method of ir.rule
         Rule._domain_get_cache.clear()
         return res
@@ -295,10 +296,10 @@ class ModuleConfigWizardItem:
     __name__ = 'ir.module.module.config_wizard.item'
 
     @classmethod
-    def create(cls, values):
+    def create(cls, vlist):
         pool = Pool()
         User = pool.get('res.user')
-        result = super(ModuleConfigWizardItem, cls).create(values)
+        result = super(ModuleConfigWizardItem, cls).create(vlist)
         # Restart the cache for get_preferences
         User._get_preferences_cache.clear()
         return result

trytond/res/request.py

@@ -116,6 +116,7 @@ class Request(ModelSQL, ModelView):
     def send(cls, requests):
         pool = Pool()
         RequestHistory = pool.get('res.request.history')
+        to_create = []
         for request in requests:
             values = {
                 'request': request.id,
@@ -131,7 +132,9 @@ class Request(ModelSQL, ModelView):
                 values['name'] = values['body'][:125] + '...'
             else:
                 values['name'] = values['body'] or '/'
-            RequestHistory.create(values)
+            to_create.append(values)
+        if to_create:
+            RequestHistory.create(to_create)
         cls.write(requests, {
             'state': 'waiting',
             'date_sent': datetime.datetime.now(),

trytond/res/user.py

@@ -211,9 +211,9 @@ class User(ModelSQL, ModelView):
         return vals
 
     @classmethod
-    def create(cls, vals):
-        vals = cls._convert_vals(vals)
-        res = super(User, cls).create(vals)
+    def create(cls, vlist):
+        vlist = [cls._convert_vals(vals) for vals in vlist]
+        res = super(User, cls).create(vlist)
         # Restart the cache for _get_login
         cls._get_login_cache.clear()
         return res
@@ -495,9 +495,9 @@ class UserAction(ModelSQL):
         return values
 
     @classmethod
-    def create(cls, values):
-        values = cls._convert_values(values)
-        return super(UserAction, cls).create(values)
+    def create(cls, vlist):
+        vlist = [cls._convert_values(values) for values in vlist]
+        return super(UserAction, cls).create(vlist)
 
     @classmethod
     def write(cls, records, values):

trytond/security.py

@@ -25,7 +25,7 @@ def login(dbname, loginname, password, cache=True):
             return user_id
         with Transaction().start(dbname, user_id) as transaction:
             Session = pool.get('ir.session')
-            session = Session.create({})
+            session, = Session.create([{}])
             transaction.cursor.commit()
             return user_id, session.key
     return False

trytond/tests/test_access.py

@@ -28,7 +28,7 @@ class ModelAccessTestCase(unittest.TestCase):
                 context=CONTEXT) as transaction:
             model, = self.model.search([('model', '=', 'test.access')])
 
-            test = self.test_access.create({})
+            test, = self.test_access.create([{}])
 
             # Without model access
             self.test_access.read([test.id])
@@ -36,11 +36,11 @@ class ModelAccessTestCase(unittest.TestCase):
             # With model access
 
             # One access allowed for any group
-            model_access_wo_group = self.model_access.create({
-                    'model': model.id,
-                    'group': False,
-                    'perm_read': True,
-                    })
+            model_access_wo_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': False,
+                        'perm_read': True,
+                        }])
             self.test_access.read([test.id])
 
             # One access disallowed for any group
@@ -51,11 +51,11 @@ class ModelAccessTestCase(unittest.TestCase):
 
             # Two access rules with one group allowed
             group, = self.group.search([('users', '=', USER)])
-            model_access_w_group = self.model_access.create({
-                    'model': model.id,
-                    'group': group.id,
-                    'perm_read': True,
-                    })
+            model_access_w_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': group.id,
+                        'perm_read': True,
+                        }])
 
             self.test_access.read([test.id])
 
@@ -88,7 +88,7 @@ class ModelAccessTestCase(unittest.TestCase):
             self.test_access.read([test.id])
 
             # One access allowed for one other group
-            group = self.group.create({'name': 'Test'})
+            group, = self.group.create([{'name': 'Test'}])
             self.model_access.write([model_access_w_group], {
                     'group': group.id,
                     })
@@ -111,7 +111,7 @@ class ModelAccessTestCase(unittest.TestCase):
                 context=CONTEXT) as transaction:
             model, = self.model.search([('model', '=', 'test.access')])
 
-            test = self.test_access.create({})
+            test, = self.test_access.create([{}])
 
             # Without model access
             self.test_access.write([test], {})
@@ -119,11 +119,11 @@ class ModelAccessTestCase(unittest.TestCase):
             # With model access
 
             # One access allowed for any group
-            model_access_wo_group = self.model_access.create({
-                    'model': model.id,
-                    'group': False,
-                    'perm_write': True,
-                    })
+            model_access_wo_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': False,
+                        'perm_write': True,
+                        }])
             self.test_access.write([test], {})
 
             # One access disallowed for any group
@@ -134,11 +134,11 @@ class ModelAccessTestCase(unittest.TestCase):
 
             # Two access rules with one group allowed
             group, = self.group.search([('users', '=', USER)])
-            model_access_w_group = self.model_access.create({
-                    'model': model.id,
-                    'group': group.id,
-                    'perm_write': True,
-                    })
+            model_access_w_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': group.id,
+                        'perm_write': True,
+                        }])
             self.test_access.write([test], {})
 
             # Two access rules with both allowed
@@ -170,7 +170,7 @@ class ModelAccessTestCase(unittest.TestCase):
             self.test_access.write([test], {})
 
             # One access allowed for one other group
-            group = self.group.create({'name': 'Test'})
+            group, = self.group.create([{'name': 'Test'}])
             self.model_access.write([model_access_w_group], {
                     'group': group.id,
                     })
@@ -194,17 +194,17 @@ class ModelAccessTestCase(unittest.TestCase):
             model, = self.model.search([('model', '=', 'test.access')])
 
             # Without model access
-            self.test_access.create({})
+            self.test_access.create([{}])
 
             # With model access
 
             # One access allowed for any group
-            model_access_wo_group = self.model_access.create({
-                    'model': model.id,
-                    'group': False,
-                    'perm_create': True,
-                    })
-            self.test_access.create({})
+            model_access_wo_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': False,
+                        'perm_create': True,
+                        }])
+            self.test_access.create([{}])
 
             # One access disallowed for any group
             self.model_access.write([model_access_wo_group], {
@@ -214,54 +214,54 @@ class ModelAccessTestCase(unittest.TestCase):
 
             # Two access rules with one group allowed
             group, = self.group.search([('users', '=', USER)])
-            model_access_w_group = self.model_access.create({
-                    'model': model.id,
-                    'group': group.id,
-                    'perm_create': True,
-                    })
+            model_access_w_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': group.id,
+                        'perm_create': True,
+                        }])
 
-            self.test_access.create({})
+            self.test_access.create([{}])
 
             # Two access rules with both allowed
             self.model_access.write([model_access_wo_group], {
                     'perm_create': True,
                     })
-            self.test_access.create({})
+            self.test_access.create([{}])
 
             # Two access rules with any group allowed
             self.model_access.write([model_access_w_group], {
                     'perm_create': False,
                     })
-            self.test_access.create({})
+            self.test_access.create([{}])
 
             # Two access rules with both disallowed
             self.model_access.write([model_access_wo_group], {
                     'perm_create': False,
                     })
-            self.assertRaises(Exception, self.test_access.create, {})
+            self.assertRaises(Exception, self.test_access.create, [{}])
 
             # One access disallowed for one group
             self.model_access.delete([model_access_wo_group])
-            self.assertRaises(Exception, self.test_access.create, {})
+            self.assertRaises(Exception, self.test_access.create, [{}])
 
             # One access allowed for one group
             self.model_access.write([model_access_w_group], {
                     'perm_create': True,
                     })
-            self.test_access.create({})
+            self.test_access.create([{}])
 
             # One access allowed for one other group
-            group = self.group.create({'name': 'Test'})
+            group, = self.group.create([{'name': 'Test'}])
             self.model_access.write([model_access_w_group], {
                     'group': group.id,
                     })
-            self.test_access.create({})
+            self.test_access.create([{}])
 
             # One access disallowed for one other group
             self.model_access.write([model_access_w_group], {
                     'perm_create': False,
                     })
-            self.test_access.create({})
+            self.test_access.create([{}])
 
             transaction.cursor.rollback()
             self.model_access._get_access_cache.clear()
@@ -274,7 +274,7 @@ class ModelAccessTestCase(unittest.TestCase):
                 context=CONTEXT) as transaction:
             model, = self.model.search([('model', '=', 'test.access')])
 
-            tests = [self.test_access.create({}) for x in range(11)]
+            tests = [self.test_access.create([{}])[0] for x in range(11)]
 
             # Without model access
             self.test_access.delete([tests.pop()])
@@ -282,11 +282,11 @@ class ModelAccessTestCase(unittest.TestCase):
             # With model access
 
             # One access allowed for any group
-            model_access_wo_group = self.model_access.create({
-                    'model': model.id,
-                    'group': False,
-                    'perm_delete': True,
-                    })
+            model_access_wo_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': False,
+                        'perm_delete': True,
+                        }])
             self.test_access.delete([tests.pop()])
 
             # One access disallowed for any group
@@ -298,11 +298,11 @@ class ModelAccessTestCase(unittest.TestCase):
 
             # Two access rules with one group allowed
             group = self.group.search([('users', '=', USER)])[0]
-            model_access_w_group = self.model_access.create({
-                    'model': model.id,
-                    'group': group.id,
-                    'perm_delete': True,
-                    })
+            model_access_w_group, = self.model_access.create([{
+                        'model': model.id,
+                        'group': group.id,
+                        'perm_delete': True,
+                        }])
 
             self.test_access.delete([tests.pop()])
 
@@ -337,7 +337,7 @@ class ModelAccessTestCase(unittest.TestCase):
             self.test_access.delete([tests.pop()])
 
             # One access allowed for one other group
-            group = self.group.create({'name': 'Test'})
+            group, = self.group.create([{'name': 'Test'}])
             self.model_access.write([model_access_w_group], {
                     'group': group.id,
                     })
@@ -380,10 +380,10 @@ class ModelFieldAccessTestCase(unittest.TestCase):
                     ('name', '=', 'field2'),
                     ])
 
-            test = self.test_access.create({
-                    'field1': 'ham',
-                    'field2': 'spam',
-                    })
+            test, = self.test_access.create([{
+                        'field1': 'ham',
+                        'field2': 'spam',
+                        }])
 
             # Without field access
             self.test_access.read([test.id], ['field1'])
@@ -397,11 +397,11 @@ class ModelFieldAccessTestCase(unittest.TestCase):
             # With field access
 
             # One access allowed for any group
-            field_access_wo_group = self.field_access.create({
-                    'field': field1.id,
-                    'group': False,
-                    'perm_read': True,
-                    })
+            field_access_wo_group, = self.field_access.create([{
+                        'field': field1.id,
+                        'group': False,
+                        'perm_read': True,
+                        }])
             self.test_access.read([test.id], ['field1'])
             self.test_access.read([test.id], ['field2'])
             self.test_access.read([test.id])
@@ -426,11 +426,11 @@ class ModelFieldAccessTestCase(unittest.TestCase):
 
             # Two access rules with one group allowed
             group = self.group.search([('users', '=', USER)])[0]
-            field_access_w_group = self.field_access.create({
-                    'field': field1.id,
-                    'group': group.id,
-                    'perm_read': True,
-                    })
+            field_access_w_group, = self.field_access.create([{
+                        'field': field1.id,
+                        'group': group.id,
+                        'perm_read': True,
+                        }])
 
             self.test_access.read([test.id], ['field1'])
             self.test_access.read([test.id], ['field2'])
@@ -501,7 +501,7 @@ class ModelFieldAccessTestCase(unittest.TestCase):
             test = self.test_access(test.id)
 
             # One access allowed for one other group
-            group = self.group.create({'name': 'Test'})
+            group, = self.group.create([{'name': 'Test'}])
             self.field_access.write([field_access_w_group], {
                     'group': group.id,
                     })
@@ -528,16 +528,16 @@ class ModelFieldAccessTestCase(unittest.TestCase):
             # Two access rules on both fields allowed
             self.field_access.delete([field_access_w_group])
 
-            field_access1 = self.field_access.create({
-                    'field': field1.id,
-                    'group': False,
-                    'perm_read': True,
-                    })
-            field_access2 = self.field_access.create({
-                    'field': field2.id,
-                    'group': False,
-                    'perm_read': True,
-                    })
+            field_access1, = self.field_access.create([{
+                        'field': field1.id,
+                        'group': False,
+                        'perm_read': True,
+                        }])
+            field_access2, = self.field_access.create([{
+                        'field': field2.id,
+                        'group': False,
+                        'perm_read': True,
+                        }])
 
             self.test_access.read([test.id], ['field1'])
             self.test_access.read([test.id], ['field2'])
@@ -592,10 +592,10 @@ class ModelFieldAccessTestCase(unittest.TestCase):
                     ('name', '=', 'field2'),
                     ])
 
-            test = self.test_access.create({
-                    'field1': 'ham',
-                    'field2': 'spam',
-                    })
+            test, = self.test_access.create([{
+                        'field1': 'ham',
+                        'field2': 'spam',
+                        }])
 
             # Without field access
             self.test_access.write([test], {})
@@ -605,11 +605,11 @@ class ModelFieldAccessTestCase(unittest.TestCase):
             # With field access
 
             # One access allowed for any group
-            field_access_wo_group = self.field_access.create({
-                    'field': field1.id,
-                    'group': False,
-                    'perm_write': True,
-                    })
+            field_access_wo_group, = self.field_access.create([{
+                        'field': field1.id,
+                        'group': False,
+                        'perm_write': True,
+                        }])
             self.test_access.write([test], {})
             self.test_access.write([test], {'field1': 'ham'})
             self.test_access.write([test], {'field2': 'spam'})
@@ -634,11 +634,11 @@ class ModelFieldAccessTestCase(unittest.TestCase):
 
             # Two access rules with one group allowed
             group = self.group.search([('users', '=', USER)])[0]
-            field_access_w_group = self.field_access.create({
-                    'field': field1.id,
-                    'group': group.id,
-                    'perm_write': True,
-                    })
+            field_access_w_group, = self.field_access.create([{
+                        'field': field1.id,
+                        'group': group.id,
+                        'perm_write': True,
+                        }])
 
             self.test_access.write([test], {})
             self.test_access.write([test], {'field1': 'ham'})
@@ -709,7 +709,7 @@ class ModelFieldAccessTestCase(unittest.TestCase):
                     })
 
             # One access allowed for one other group
-            group = self.group.create({'name': 'Test'})
+            group, = self.group.create([{'name': 'Test'}])
             self.field_access.write([field_access_w_group], {
                     'group': group.id,
                     })
@@ -736,16 +736,16 @@ class ModelFieldAccessTestCase(unittest.TestCase):
             # Two access rules on both fields allowed
             self.field_access.delete([field_access_w_group])
 
-            field_access1 = self.field_access.create({
-                    'field': field1.id,
-                    'group': False,
-                    'perm_write': True,
-                    })
-            field_access2 = self.field_access.create({
-                    'field': field2.id,
-                    'group': False,
-                    'perm_write': True,
-                    })
+            field_access1, = self.field_access.create([{
+                        'field': field1.id,
+                        'group': False,
+                        'perm_write': True,
+                        }])
+            field_access2, = self.field_access.create([{
+                        'field': field2.id,
+                        'group': False,
+                        'perm_write': True,
+                        }])
 
             self.test_access.write([test], {})
             self.test_access.write([test], {'field1': 'ham'})

trytond/tests/test_exportdata.py

@@ -35,15 +35,15 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'boolean': True,
-                    })
+            export1, = self.export_data.create([{
+                        'boolean': True,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['boolean']), [[True]])
 
-            export2 = self.export_data.create({
-                    'boolean': False,
-                    })
+            export2, = self.export_data.create([{
+                        'boolean': False,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['boolean']),
                 [[False]])
@@ -61,15 +61,15 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'integer': 2,
-                    })
+            export1, = self.export_data.create([{
+                        'integer': 2,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['integer']), [[2]])
 
-            export2 = self.export_data.create({
-                    'integer': 0,
-                    })
+            export2, = self.export_data.create([{
+                        'integer': 0,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['integer']), [[0]])
 
@@ -85,15 +85,15 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'float': 1.1,
-                    })
+            export1, = self.export_data.create([{
+                        'float': 1.1,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['float']), [[1.1]])
 
-            export2 = self.export_data.create({
-                    'float': 0,
-                    })
+            export2, = self.export_data.create([{
+                        'float': 0,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['float']), [[0]])
 
@@ -109,16 +109,16 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'numeric': Decimal('1.1'),
-                    })
+            export1, = self.export_data.create([{
+                        'numeric': Decimal('1.1'),
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['numeric']),
                 [[Decimal('1.1')]])
 
-            export2 = self.export_data.create({
-                    'numeric': Decimal('0'),
-                    })
+            export2, = self.export_data.create([{
+                        'numeric': Decimal('0'),
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['numeric']),
                 [[Decimal('0')]])
@@ -135,15 +135,15 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'char': 'test',
-                    })
+            export1, = self.export_data.create([{
+                        'char': 'test',
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['char']), [['test']])
 
-            export2 = self.export_data.create({
-                    'char': None,
-                    })
+            export2, = self.export_data.create([{
+                        'char': None,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['char']), [['']])
 
@@ -159,15 +159,15 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'text': 'test',
-                    })
+            export1, = self.export_data.create([{
+                        'text': 'test',
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['text']), [['test']])
 
-            export2 = self.export_data.create({
-                    'text': None,
-                    })
+            export2, = self.export_data.create([{
+                        'text': None,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['text']), [['']])
 
@@ -183,9 +183,9 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'sha': 'Test',
-                    })
+            export1, = self.export_data.create([{
+                        'sha': 'Test',
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['sha']),
                 [['640ab2bae07bedc4c163f679a746f7ab7fb5d1fa']])
@@ -198,15 +198,15 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                'date': datetime.date(2010, 1, 1),
-                })
+            export1, = self.export_data.create([{
+                        'date': datetime.date(2010, 1, 1),
+                        }])
             self.assert_(self.export_data.export_data([export1],
                 ['date']) == [[datetime.date(2010, 1, 1)]])
 
-            export2 = self.export_data.create({
-                    'date': None,
-                    })
+            export2, = self.export_data.create([{
+                        'date': None,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['date']), [['']])
 
@@ -222,16 +222,16 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'datetime': datetime.datetime(2010, 1, 1, 12, 0, 0),
-                    })
+            export1, = self.export_data.create([{
+                        'datetime': datetime.datetime(2010, 1, 1, 12, 0, 0),
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['datetime']),
                 [[datetime.datetime(2010, 1, 1, 12, 0, 0)]])
 
-            export2 = self.export_data.create({
-                    'datetime': None,
-                    })
+            export2, = self.export_data.create([{
+                        'datetime': None,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['datetime']),
                 [['']])
@@ -248,16 +248,16 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({
-                    'selection': 'select1',
-                    })
+            export1, = self.export_data.create([{
+                        'selection': 'select1',
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['selection']),
                 [['select1']])
 
-            export2 = self.export_data.create({
-                    'selection': None,
-                    })
+            export2, = self.export_data.create([{
+                        'selection': None,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['selection']), [['']])
 
@@ -274,19 +274,19 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            target = self.export_data_target.create({
-                    'name': 'Target Test',
-                    })
-            export1 = self.export_data.create({
-                    'many2one': target.id,
-                    })
+            target, = self.export_data_target.create([{
+                        'name': 'Target Test',
+                        }])
+            export1, = self.export_data.create([{
+                        'many2one': target.id,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['many2one/name']),
                 [['Target Test']])
 
-            export2 = self.export_data.create({
+            export2, = self.export_data.create([{
                     'many2one': None,
-                    })
+                    }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['many2one/name']),
                 [['']])
@@ -304,19 +304,19 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            target1 = self.export_data_target.create({
-                    'name': 'Target 1',
-                    })
-            export1 = self.export_data.create({
-                    'many2many': [('set', [target1])],
-                    })
+            target1, = self.export_data_target.create([{
+                        'name': 'Target 1',
+                        }])
+            export1, = self.export_data.create([{
+                        'many2many': [('set', [target1])],
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['many2many/name']),
                 [['Target 1']])
 
-            target2 = self.export_data_target.create({
-                    'name': 'Target 2',
-                    })
+            target2, = self.export_data_target.create([{
+                        'name': 'Target 2',
+                        }])
             self.export_data.write([export1], {
                     'many2many': [('set', [target1.id, target2.id])],
                     })
@@ -325,9 +325,9 @@ class ExportDataTestCase(unittest.TestCase):
                         'many2many/name']),
                 [[export1.id, 'Target 1'], ['', 'Target 2']])
 
-            export2 = self.export_data.create({
-                    'many2many': None,
-                    })
+            export2, = self.export_data.create([{
+                        'many2many': None,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['many2many/name']),
                 [['']])
@@ -345,25 +345,25 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            export1 = self.export_data.create({})
-            self.export_data_target.create({
-                    'name': 'Target 1',
-                    'one2many': export1.id,
-                    })
+            export1, = self.export_data.create([{}])
+            self.export_data_target.create([{
+                        'name': 'Target 1',
+                        'one2many': export1.id,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['one2many/name']),
                 [['Target 1']])
 
-            self.export_data_target.create({
-                    'name': 'Target 2',
-                    'one2many': export1.id,
-                    })
+            self.export_data_target.create([{
+                        'name': 'Target 2',
+                        'one2many': export1.id,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1],
                     ['id', 'one2many/name']),
                 [[export1.id, 'Target 1'], ['', 'Target 2']])
 
-            export2 = self.export_data.create({})
+            export2, = self.export_data.create([{}])
             self.assertEqual(
                 self.export_data.export_data([export2], ['one2many/name']),
                 [['']])
@@ -381,17 +381,17 @@ class ExportDataTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            target1 = self.export_data_target.create({})
-            export1 = self.export_data.create({
-                    'reference': str(target1),
-                    })
+            target1, = self.export_data_target.create([{}])
+            export1, = self.export_data.create([{
+                        'reference': str(target1),
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export1], ['reference']),
                 [[str(target1)]])
 
-            export2 = self.export_data.create({
-                    'reference': None,
-                    })
+            export2, = self.export_data.create([{
+                        'reference': None,
+                        }])
             self.assertEqual(
                 self.export_data.export_data([export2], ['reference']), [['']])
 

trytond/tests/test_model_inherits.py

@@ -22,26 +22,26 @@ class ModelInheritsTestCase(unittest.TestCase):
         self.overridden = POOL.get('test.overriddeninheritedfieldmodel')
 
     def create_data(self):
-        parent_id = self.parent.create({'name': 'parent'})
-        sub_id = self.sub.create({
-                'name': 'sub',
-                'subfield': 'level1',
-            })
-        subsub_id = self.subsub.create({
-                'name': 'subsub',
-                'subfield': 'level2',
-                'subsubfield': 'ssfcontent',
-            })
-        subsubsub_id = self.subsubsub.create({
-                'name': 'subsubsub',
-                'subfield': 'level3',
-                'subsubfield': 'ssfcontent2',
-                'subsubsubfield': 'sssfcontent',
-            })
-        overridden_id = self.overridden.create({
-                'name': 'overridden',
-                'subfield': 3,
-            })
+        parent_id, = self.parent.create([{'name': 'parent'}])
+        sub_id, = self.sub.create([{
+                    'name': 'sub',
+                    'subfield': 'level1',
+                    }])
+        subsub_id, = self.subsub.create([{
+                    'name': 'subsub',
+                    'subfield': 'level2',
+                    'subsubfield': 'ssfcontent',
+                    }])
+        subsubsub_id, = self.subsubsub.create([{
+                    'name': 'subsubsub',
+                    'subfield': 'level3',
+                    'subsubfield': 'ssfcontent2',
+                    'subsubsubfield': 'sssfcontent',
+                    }])
+        overridden_id, = self.overridden.create([{
+                    'name': 'overridden',
+                    'subfield': 3,
+                    }])
         return (parent_id, sub_id, subsub_id, subsubsub_id, overridden_id)
 
     def test0010selfsearch(self):

trytond/tests/test_modelsingleton.py

@@ -51,11 +51,11 @@ class ModelSingletonTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            singleton = self.singleton.create({'name': 'bar'})
+            singleton, = self.singleton.create([{'name': 'bar'}])
             self.assert_(singleton)
             self.assertEqual(singleton.name, 'bar')
 
-            singleton2 = self.singleton.create({'name': 'foo'})
+            singleton2, = self.singleton.create([{'name': 'foo'}])
             self.assertEqual(singleton2, singleton)
 
             self.assertEqual(singleton.name, 'foo')
@@ -103,7 +103,7 @@ class ModelSingletonTestCase(unittest.TestCase):
                     with_rec_name=False)
             self.assertEqual(len(default), 1)
 
-            self.singleton.create({'name': 'bar'})
+            self.singleton.create([{'name': 'bar'}])
 
             default = self.singleton.default_get(['name'])
             self.assertEqual(default, {'name': 'bar'})

trytond/tests/test_modelsql.py

@@ -37,7 +37,7 @@ class ModelSQLTestCase(unittest.TestCase):
         for key, value in fields.iteritems():
             with Transaction().start(DB_NAME, USER, context=CONTEXT):
                 try:
-                    self.modelsql.create({key: value})
+                    self.modelsql.create([{key: value}])
                 except UserError, err:
                     # message must not quote key
                     msg = "'%s' not missing but quoted in error: '%s'" % (key,

trytond/tests/test_mptt.py

@@ -102,12 +102,11 @@ class MPTTTestCase(unittest.TestCase):
                 k = 0
                 for parent_record in parent_records:
                     for i in range(3):
-                        record = self.mptt.create({
-                            'name': 'Test %d %d %d' % (j, k, i),
-                            'parent': (parent_record.id
-                                    if parent_record else None),
-                            })
-                        new_records.append(record)
+                        new_records += self.mptt.create([{
+                                    'name': 'Test %d %d %d' % (j, k, i),
+                                    'parent': (parent_record.id
+                                            if parent_record else None),
+                                    }])
                     k += 1
             self.CheckTree()
 

trytond/tests/test_sequence.py

@@ -24,13 +24,13 @@ class SequenceTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            sequence = self.sequence.create({
-                    'name': 'Test incremental',
-                    'code': 'test',
-                    'prefix': '',
-                    'suffix': '',
-                    'type': 'incremental',
-                    })
+            sequence, = self.sequence.create([{
+                        'name': 'Test incremental',
+                        'code': 'test',
+                        'prefix': '',
+                        'suffix': '',
+                        'type': 'incremental',
+                        }])
             self.assertEqual(self.sequence.get_id(sequence), '1')
 
             self.sequence.write([sequence], {
@@ -52,13 +52,13 @@ class SequenceTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            sequence = self.sequence.create({
-                    'name': 'Test decimal timestamp',
-                    'code': 'test',
-                    'prefix': '',
-                    'suffix': '',
-                    'type': 'decimal timestamp',
-                    })
+            sequence, = self.sequence.create([{
+                        'name': 'Test decimal timestamp',
+                        'code': 'test',
+                        'prefix': '',
+                        'suffix': '',
+                        'type': 'decimal timestamp',
+                        }])
             timestamp = self.sequence.get_id(sequence)
             self.assertEqual(timestamp, str(sequence.last_timestamp))
 
@@ -77,13 +77,13 @@ class SequenceTestCase(unittest.TestCase):
         '''
         with Transaction().start(DB_NAME, USER,
                 context=CONTEXT) as transaction:
-            sequence = self.sequence.create({
-                    'name': 'Test hexadecimal timestamp',
-                    'code': 'test',
-                    'prefix': '',
-                    'suffix': '',
-                    'type': 'hexadecimal timestamp',
-                    })
+            sequence, = self.sequence.create([{
+                        'name': 'Test hexadecimal timestamp',
+                        'code': 'test',
+                        'prefix': '',
+                        'suffix': '',
+                        'type': 'hexadecimal timestamp',
+                        }])
             timestamp = self.sequence.get_id(sequence)
             self.assertEqual(timestamp,
                 hex(int(sequence.last_timestamp))[2:].upper())
@@ -102,13 +102,13 @@ class SequenceTestCase(unittest.TestCase):
         Test prefix/suffix
         '''
         with Transaction().start(DB_NAME, USER, context=CONTEXT):
-            sequence = self.sequence.create({
-                    'name': 'Test incremental',
-                    'code': 'test',
-                    'prefix': 'prefix/',
-                    'suffix': '/suffix',
-                    'type': 'incremental',
-                    })
+            sequence, = self.sequence.create([{
+                        'name': 'Test incremental',
+                        'code': 'test',
+                        'prefix': 'prefix/',
+                        'suffix': '/suffix',
+                        'type': 'incremental',
+                        }])
             self.assertEqual(self.sequence.get_id(sequence),
                 'prefix/1/suffix')
 

trytond/tests/test_trigger.py

@@ -61,7 +61,7 @@ class TriggerTestCase(unittest.TestCase):
                 'action_model': model.id,
                 'action_function': 'test',
                 }
-            self.assert_(self.trigger.create(values))
+            self.assert_(self.trigger.create([values]))
 
             # on_exclusive
             for i in range(1, 4):
@@ -71,13 +71,13 @@ class TriggerTestCase(unittest.TestCase):
                     for mode in combination:
                         combination_values['on_%s' % mode] = True
                     self.assertRaises(Exception, self.trigger.create,
-                        combination_values)
+                        [combination_values])
 
             # check_condition
             condition_values = values.copy()
             condition_values['condition'] = '='
             self.assertRaises(Exception, self.trigger.create,
-                condition_values)
+                [condition_values])
 
             # Restart the cache on the get_triggers method of ir.trigger
             self.trigger._get_triggers_cache.clear()
@@ -93,18 +93,18 @@ class TriggerTestCase(unittest.TestCase):
                     ('model', '=', 'test.triggered'),
                     ])
 
-            trigger = self.trigger.create({
-                    'name': 'Test',
-                    'model': model.id,
-                    'on_create': True,
-                    'condition': 'True',
-                    'action_model': model.id,
-                    'action_function': 'trigger',
-                    })
+            trigger, = self.trigger.create([{
+                        'name': 'Test',
+                        'model': model.id,
+                        'on_create': True,
+                        'condition': 'True',
+                        'action_model': model.id,
+                        'action_function': 'trigger',
+                        }])
 
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
 
             self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)])
             TRIGGER_LOGS.pop()
@@ -115,16 +115,16 @@ class TriggerTestCase(unittest.TestCase):
                     })
 
             # Matching condition
-            triggered = self.triggered.create({
-                    'name': 'Bar',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Bar',
+                        }])
             self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)])
             TRIGGER_LOGS.pop()
 
             # Non matching condition
-            triggered = self.triggered.create({
-                    'name': 'Foo',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Foo',
+                        }])
             self.assertEqual(TRIGGER_LOGS, [])
 
             # With limit number
@@ -132,9 +132,9 @@ class TriggerTestCase(unittest.TestCase):
                     'condition': 'True',
                     'limit_number': 1,
                     })
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
             self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)])
             TRIGGER_LOGS.pop()
 
@@ -143,9 +143,9 @@ class TriggerTestCase(unittest.TestCase):
                     'limit_number': 0,
                     'minimum_delay': 1,
                     })
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
             self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)])
             TRIGGER_LOGS.pop()
 
@@ -163,18 +163,18 @@ class TriggerTestCase(unittest.TestCase):
                     ('model', '=', 'test.triggered'),
                     ])
 
-            trigger = self.trigger.create({
-                    'name': 'Test',
-                    'model': model.id,
-                    'on_write': True,
-                    'condition': 'True',
-                    'action_model': model.id,
-                    'action_function': 'trigger',
-                    })
+            trigger, = self.trigger.create([{
+                        'name': 'Test',
+                        'model': model.id,
+                        'on_write': True,
+                        'condition': 'True',
+                        'action_model': model.id,
+                        'action_function': 'trigger',
+                        }])
 
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
 
             self.triggered.write([triggered], {
                     'name': 'Foo',
@@ -210,9 +210,9 @@ class TriggerTestCase(unittest.TestCase):
                     'condition': 'self.name == "Bar"',
                     'limit_number': 1,
                     })
-            triggered = self.triggered.create({
-                    'name': 'Foo',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Foo',
+                        }])
             self.triggered.write([triggered], {
                     'name': 'Bar',
                     })
@@ -230,9 +230,9 @@ class TriggerTestCase(unittest.TestCase):
                     'limit_number': 0,
                     'minimum_delay': MAXINT,
                     })
-            triggered = self.triggered.create({
-                    'name': 'Foo',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Foo',
+                        }])
             for name in ('Bar', 'Foo', 'Bar'):
                 self.triggered.write([triggered], {
                         'name': name,
@@ -243,9 +243,9 @@ class TriggerTestCase(unittest.TestCase):
             self.trigger.write([trigger], {
                     'minimum_delay': 0.02,
                     })
-            triggered = self.triggered.create({
-                    'name': 'Foo',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Foo',
+                        }])
             for name in ('Bar', 'Foo'):
                 self.triggered.write([triggered], {
                         'name': name,
@@ -273,18 +273,18 @@ class TriggerTestCase(unittest.TestCase):
                     ('model', '=', 'test.triggered'),
                     ])
 
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
 
-            trigger = self.trigger.create({
-                    'name': 'Test',
-                    'model': model.id,
-                    'on_delete': True,
-                    'condition': 'True',
-                    'action_model': model.id,
-                    'action_function': 'trigger',
-                    })
+            trigger, = self.trigger.create([{
+                        'name': 'Test',
+                        'model': model.id,
+                        'on_delete': True,
+                        'condition': 'True',
+                        'action_model': model.id,
+                        'action_function': 'trigger',
+                        }])
 
             self.triggered.delete([triggered])
             self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)])
@@ -296,9 +296,9 @@ class TriggerTestCase(unittest.TestCase):
                     'condition': 'self.name == "Bar"',
                     })
 
-            triggered = self.triggered.create({
-                    'name': 'Bar',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Bar',
+                        }])
 
             # Matching condition
             self.triggered.delete([triggered])
@@ -306,18 +306,18 @@ class TriggerTestCase(unittest.TestCase):
             TRIGGER_LOGS.pop()
             Transaction().delete = {}
 
-            triggered = self.triggered.create({
-                    'name': 'Foo',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Foo',
+                        }])
 
             # Non matching condition
             self.triggered.delete([triggered])
             self.assertEqual(TRIGGER_LOGS, [])
             Transaction().delete = {}
 
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
 
             # With limit number
             self.trigger.write([trigger], {
@@ -333,9 +333,9 @@ class TriggerTestCase(unittest.TestCase):
                         ('trigger', '=', trigger.id),
                         ]))
 
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
 
             # With minimum delay
             self.trigger.write([trigger], {
@@ -361,18 +361,18 @@ class TriggerTestCase(unittest.TestCase):
                     ('model', '=', 'test.triggered'),
                     ])
 
-            trigger = self.trigger.create({
-                    'name': 'Test',
-                    'model': model.id,
-                    'on_time': True,
-                    'condition': 'True',
-                    'action_model': model.id,
-                    'action_function': 'trigger',
-                    })
+            trigger, = self.trigger.create([{
+                        'name': 'Test',
+                        'model': model.id,
+                        'on_time': True,
+                        'condition': 'True',
+                        'action_model': model.id,
+                        'action_function': 'trigger',
+                        }])
 
-            triggered = self.triggered.create({
-                    'name': 'Test',
-                    })
+            triggered, = self.triggered.create([{
+                        'name': 'Test',
+                        }])
             self.trigger.trigger_time()
             self.assert_(TRIGGER_LOGS == [([triggered], trigger)])
             TRIGGER_LOGS.pop()

trytond/tests/test_wizard.py

@@ -31,7 +31,7 @@ class WizardTestCase(unittest.TestCase):
     def test0030session(self):
         'Session Wizard'
         with Transaction().start(DB_NAME, USER, CONTEXT):
-            session_id = self.session.create({})
+            session_id, = self.session.create([{}])
             session = self.wizard(session_id)
             self.assertEqual(session.start.id, None)
             self.assertRaises(AttributeError, getattr, session.start, 'name')
@@ -40,12 +40,12 @@ class WizardTestCase(unittest.TestCase):
             self.assertRaises(AttributeError, getattr, session.start, 'user')
             self.assertEqual(hasattr(session.start, 'user'), False)
             session.start.user = USER
-            group_a = self.group.create({
-                    'name': 'Group A',
-                    })
-            group_b = self.group.create({
-                    'name': 'Group B',
-                    })
+            group_a, = self.group.create([{
+                        'name': 'Group A',
+                        }])
+            group_b, = self.group.create([{
+                        'name': 'Group B',
+                        }])
             session.start.groups = [
                 group_a,
                 group_b,

trytond/tests/test_workflow.py

@@ -18,7 +18,7 @@ class WorkflowTestCase(unittest.TestCase):
     def test0010transition(self):
         'Test transition'
         with Transaction().start(DB_NAME, USER, context=CONTEXT):
-            wkf = self.workflow.create({})
+            wkf, = self.workflow.create([{}])
 
             self.workflow.run([wkf])
             self.assertEqual(wkf.state, 'running')

trytond/webdav/webdav.py

@@ -548,11 +548,11 @@ class Collection(ModelSQL, ModelView):
         if not object_id2:
             name = get_urifilename(uri)
             try:
-                Attachment.create({
-                    'name': name,
-                    'data': data,
-                    'resource': '%s,%s' % (object_name, object_id),
-                    })
+                Attachment.create([{
+                            'name': name,
+                            'data': data,
+                            'resource': '%s,%s' % (object_name, object_id),
+                            }])
             except Exception:
                 raise DAV_Forbidden
         else:
@@ -576,10 +576,10 @@ class Collection(ModelSQL, ModelView):
             raise DAV_Forbidden
         name = get_urifilename(uri)
         try:
-            cls.create({
-                'name': name,
-                'parent': object_id,
-                })
+            cls.create([{
+                        'name': name,
+                        'parent': object_id,
+                        }])
         except Exception:
             raise DAV_Forbidden
         return 201
@@ -790,9 +790,14 @@ class Attachment(ModelSQL, ModelView):
 
         for action in value:
             if action[0] == 'create':
+                to_create = []
                 for attachment in attachments:
-                    action[1]['path'] = attachment.path
-                    Share.create(action[1])
+                    for values in action[1]:
+                        values = values.copy()
+                        values['path'] = attachment.path
+                        to_create.append(values)
+                if to_create:
+                    Share.create(to_create)
             elif action[0] == 'write':
                 Share.write(action[1], action[2])
             elif action[0] == 'delete':

trytond/wizard/wizard.py

@@ -227,7 +227,7 @@ class Wizard(WarningErrorMixin, URLMixin):
     def create(cls):
         "Create a session"
         Session = Pool().get('ir.session.wizard')
-        return (Session.create({}).id, cls.start_state, cls.end_state)
+        return (Session.create([{}])[0].id, cls.start_state, cls.end_state)
 
     @classmethod
     def delete(cls, session_id):