openerp/models.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22
  23 """
  24     Object Relational Mapping module:
  25      * Hierarchical structure
  26      * Constraints consistency and validation
  27      * Object metadata depends on its status
  28      * Optimised processing by complex query (multiple actions at once)
  29      * Default field values
  30      * Permissions optimisation
  31      * Persistant object: DB postgresql
  32      * Data conversion
  33      * Multi-level caching system
  34      * Two different inheritance mechanisms
  35      * Rich set of field types:
  36           - classical (varchar, integer, boolean, ...)
  37           - relational (one2many, many2one, many2many)
  38           - functional
  39
  40 """
  41
  42 import datetime
  43 import functools
  44 import itertools
  45 import logging
  46 import operator
  47 import pickle
  48 import pytz
  49 import re
  50 import time
  51 from collections import defaultdict, MutableMapping
  52 from inspect import getmembers
  53
  54 import babel.dates
  55 import dateutil.relativedelta
  56 import psycopg2
  57 from lxml import etree
  58
  59 import openerp
  60 from . import SUPERUSER_ID
  61 from . import api
  62 from . import tools
  63 from .api import Environment
  64 from .exceptions import except_orm, AccessError, MissingError, ValidationError
  65 from .osv import fields
  66 from .osv.query import Query
  67 from .tools import lazy_property, ormcache
  68 from .tools.config import config
  69 from .tools.misc import CountingStream, DEFAULT_SERVER_DATETIME_FORMAT, DEFAULT_SERVER_DATE_FORMAT
  70 from .tools.safe_eval import safe_eval as eval
  71 from .tools.translate import _
  72
  73 _logger = logging.getLogger(__name__)
  74 _schema = logging.getLogger(__name__ + '.schema')
  75
  76 regex_order = re.compile('^( *([a-z0-9:_]+|"[a-z0-9:_]+")( *desc| *asc)?( *, *|))+$', re.I)
  77 regex_object_name = re.compile(r'^[a-z0-9_.]+$')
  78 onchange_v7 = re.compile(r"^(\w+)\((.*)\)$")
  79
  80 AUTOINIT_RECALCULATE_STORED_FIELDS = 1000
  81
  82
  83 def check_object_name(name):
  84     """ Check if the given name is a valid openerp object name.
  85
  86         The _name attribute in osv and osv_memory object is subject to
  87         some restrictions. This function returns True or False whether
  88         the given name is allowed or not.
  89
  90         TODO: this is an approximation. The goal in this approximation
  91         is to disallow uppercase characters (in some places, we quote
  92         table/column names and in other not, which leads to this kind
  93         of errors:
  94
  95             psycopg2.ProgrammingError: relation "xxx" does not exist).
  96
  97         The same restriction should apply to both osv and osv_memory
  98         objects for consistency.
  99
 100     """
 101     if regex_object_name.match(name) is None:
 102         return False
 103     return True
 104
 105 def raise_on_invalid_object_name(name):
 106     if not check_object_name(name):
 107         msg = "The _name attribute %s is not valid." % name
 108         _logger.error(msg)
 109         raise except_orm('ValueError', msg)
 110
 111 POSTGRES_CONFDELTYPES = {
 112     'RESTRICT': 'r',
 113     'NO ACTION': 'a',
 114     'CASCADE': 'c',
 115     'SET NULL': 'n',
 116     'SET DEFAULT': 'd',
 117 }
 118
 119 def intersect(la, lb):
 120     return filter(lambda x: x in lb, la)
 121
 122 def same_name(f, g):
 123     """ Test whether functions `f` and `g` are identical or have the same name """
 124     return f == g or getattr(f, '__name__', 0) == getattr(g, '__name__', 1)
 125
 126 def fix_import_export_id_paths(fieldname):
 127     """
 128     Fixes the id fields in import and exports, and splits field paths
 129     on '/'.
 130
 131     :param str fieldname: name of the field to import/export
 132     :return: split field name
 133     :rtype: list of str
 134     """
 135     fixed_db_id = re.sub(r'([^/])\.id', r'\1/.id', fieldname)
 136     fixed_external_id = re.sub(r'([^/]):id', r'\1/id', fixed_db_id)
 137     return fixed_external_id.split('/')
 138
 139 def pg_varchar(size=0):
 140     """ Returns the VARCHAR declaration for the provided size:
 141
 142     * If no size (or an empty or negative size is provided) return an
 143       'infinite' VARCHAR
 144     * Otherwise return a VARCHAR(n)
 145
 146     :type int size: varchar size, optional
 147     :rtype: str
 148     """
 149     if size:
 150         if not isinstance(size, int):
 151             raise TypeError("VARCHAR parameter should be an int, got %s"
 152                             % type(size))
 153         if size > 0:
 154             return 'VARCHAR(%d)' % size
 155     return 'VARCHAR'
 156
 157 FIELDS_TO_PGTYPES = {
 158     fields.boolean: 'bool',
 159     fields.integer: 'int4',
 160     fields.text: 'text',
 161     fields.html: 'text',
 162     fields.date: 'date',
 163     fields.datetime: 'timestamp',
 164     fields.binary: 'bytea',
 165     fields.many2one: 'int4',
 166     fields.serialized: 'text',
 167 }
 168
 169 def get_pg_type(f, type_override=None):
 170     """
 171     :param fields._column f: field to get a Postgres type for
 172     :param type type_override: use the provided type for dispatching instead of the field's own type
 173     :returns: (postgres_identification_type, postgres_type_specification)
 174     :rtype: (str, str)
 175     """
 176     field_type = type_override or type(f)
 177
 178     if field_type in FIELDS_TO_PGTYPES:
 179         pg_type =  (FIELDS_TO_PGTYPES[field_type], FIELDS_TO_PGTYPES[field_type])
 180     elif issubclass(field_type, fields.float):
 181         # Explicit support for "falsy" digits (0, False) to indicate a
 182         # NUMERIC field with no fixed precision. The values will be saved
 183         # in the database with all significant digits.
 184         # FLOAT8 type is still the default when there is no precision because
 185         # it is faster for most operations (sums, etc.)
 186         if f.digits is not None:
 187             pg_type = ('numeric', 'NUMERIC')
 188         else:
 189             pg_type = ('float8', 'DOUBLE PRECISION')
 190     elif issubclass(field_type, (fields.char, fields.reference)):
 191         pg_type = ('varchar', pg_varchar(f.size))
 192     elif issubclass(field_type, fields.selection):
 193         if (isinstance(f.selection, list) and isinstance(f.selection[0][0], int))\
 194                 or getattr(f, 'size', None) == -1:
 195             pg_type = ('int4', 'INTEGER')
 196         else:
 197             pg_type = ('varchar', pg_varchar(getattr(f, 'size', None)))
 198     elif issubclass(field_type, fields.function):
 199         if f._type == 'selection':
 200             pg_type = ('varchar', pg_varchar())
 201         else:
 202             pg_type = get_pg_type(f, getattr(fields, f._type))
 203     else:
 204         _logger.warning('%s type not supported!', field_type)
 205         pg_type = None
 206
 207     return pg_type
 208
 209
 210 class MetaModel(api.Meta):
 211     """ Metaclass for the models.
 212
 213     This class is used as the metaclass for the class :class:`BaseModel` to
 214     discover the models defined in a module (without instanciating them).
 215     If the automatic discovery is not needed, it is possible to set the model's
 216     ``_register`` attribute to False.
 217
 218     """
 219
 220     module_to_models = {}
 221
 222     def __init__(self, name, bases, attrs):
 223         if not self._register:
 224             self._register = True
 225             super(MetaModel, self).__init__(name, bases, attrs)
 226             return
 227
 228         if not hasattr(self, '_module'):
 229             # The (OpenERP) module name can be in the `openerp.addons` namespace
 230             # or not.  For instance, module `sale` can be imported as
 231             # `openerp.addons.sale` (the right way) or `sale` (for backward
 232             # compatibility).
 233             module_parts = self.__module__.split('.')
 234             if len(module_parts) > 2 and module_parts[:2] == ['openerp', 'addons']:
 235                 module_name = self.__module__.split('.')[2]
 236             else:
 237                 module_name = self.__module__.split('.')[0]
 238             self._module = module_name
 239
 240         # Remember which models to instanciate for this module.
 241         if not self._custom:
 242             self.module_to_models.setdefault(self._module, []).append(self)
 243
 244         # transform columns into new-style fields (enables field inheritance)
 245         for name, column in self._columns.iteritems():
 246             if name in self.__dict__:
 247                 _logger.warning("In class %s, field %r overriding an existing value", self, name)
 248             setattr(self, name, column.to_field())
 249
 250
 251 class NewId(object):
 252     """ Pseudo-ids for new records. """
 253     def __nonzero__(self):
 254         return False
 255
 256 IdType = (int, long, basestring, NewId)
 257
 258
 259 # maximum number of prefetched records
 260 PREFETCH_MAX = 200
 261
 262 # special columns automatically created by the ORM
 263 LOG_ACCESS_COLUMNS = ['create_uid', 'create_date', 'write_uid', 'write_date']
 264 MAGIC_COLUMNS = ['id'] + LOG_ACCESS_COLUMNS
 265
 266 class BaseModel(object):
 267     """ Base class for OpenERP models.
 268
 269     OpenERP models are created by inheriting from this class' subclasses:
 270
 271     *   :class:`Model` for regular database-persisted models
 272
 273     *   :class:`TransientModel` for temporary data, stored in the database but
 274         automatically vaccuumed every so often
 275
 276     *   :class:`AbstractModel` for abstract super classes meant to be shared by
 277         multiple inheriting model
 278
 279     The system automatically instantiates every model once per database. Those
 280     instances represent the available models on each database, and depend on
 281     which modules are installed on that database. The actual class of each
 282     instance is built from the Python classes that create and inherit from the
 283     corresponding model.
 284
 285     Every model instance is a "recordset", i.e., an ordered collection of
 286     records of the model. Recordsets are returned by methods like
 287     :meth:`~.browse`, :meth:`~.search`, or field accesses. Records have no
 288     explicit representation: a record is represented as a recordset of one
 289     record.
 290
 291     To create a class that should not be instantiated, the _register class
 292     attribute may be set to False.
 293     """
 294     __metaclass__ = MetaModel
 295     _auto = True # create database backend
 296     _register = False # Set to false if the model shouldn't be automatically discovered.
 297     _name = None
 298     _columns = {}
 299     _constraints = []
 300     _custom = False
 301     _defaults = {}
 302     _rec_name = None
 303     _parent_name = 'parent_id'
 304     _parent_store = False
 305     _parent_order = False
 306     _date_name = 'date'
 307     _order = 'id'
 308     _sequence = None
 309     _description = None
 310     _needaction = False
 311     _translate = True # set to False to disable translations export for this model
 312
 313     # dict of {field:method}, with method returning the (name_get of records, {id: fold})
 314     # to include in the _read_group, if grouped on this field
 315     _group_by_full = {}
 316
 317     # Transience
 318     _transient = False # True in a TransientModel
 319
 320     # structure:
 321     #  { 'parent_model': 'm2o_field', ... }
 322     _inherits = {}
 323
 324     # Mapping from inherits'd field name to triple (m, r, f, n) where m is the
 325     # model from which it is inherits'd, r is the (local) field towards m, f
 326     # is the _column object itself, and n is the original (i.e. top-most)
 327     # parent model.
 328     # Example:
 329     #  { 'field_name': ('parent_model', 'm2o_field_to_reach_parent',
 330     #                   field_column_obj, origina_parent_model), ... }
 331     _inherit_fields = {}
 332
 333     # Mapping field name/column_info object
 334     # This is similar to _inherit_fields but:
 335     # 1. includes self fields,
 336     # 2. uses column_info instead of a triple.
 337     # Warning: _all_columns is deprecated, use _fields instead
 338     _all_columns = {}
 339
 340     _table = None
 341     _log_create = False
 342     _sql_constraints = []
 343
 344     # model dependencies, for models backed up by sql views:
 345     # {model_name: field_names, ...}
 346     _depends = {}
 347
 348     CONCURRENCY_CHECK_FIELD = '__last_update'
 349
 350     def log(self, cr, uid, id, message, secondary=False, context=None):
 351         return _logger.warning("log() is deprecated. Please use OpenChatter notification system instead of the res.log mechanism.")
 352
 353     def view_init(self, cr, uid, fields_list, context=None):
 354         """Override this method to do specific things when a view on the object is opened."""
 355         pass
 356
 357     def _field_create(self, cr, context=None):
 358         """ Create entries in ir_model_fields for all the model's fields.
 359
 360         If necessary, also create an entry in ir_model, and if called from the
 361         modules loading scheme (by receiving 'module' in the context), also
 362         create entries in ir_model_data (for the model and the fields).
 363
 364         - create an entry in ir_model (if there is not already one),
 365         - create an entry in ir_model_data (if there is not already one, and if
 366           'module' is in the context),
 367         - update ir_model_fields with the fields found in _columns
 368           (TODO there is some redundancy as _columns is updated from
 369           ir_model_fields in __init__).
 370
 371         """
 372         if context is None:
 373             context = {}
 374         cr.execute("SELECT id FROM ir_model WHERE model=%s", (self._name,))
 375         if not cr.rowcount:
 376             cr.execute('SELECT nextval(%s)', ('ir_model_id_seq',))
 377             model_id = cr.fetchone()[0]
 378             cr.execute("INSERT INTO ir_model (id,model, name, info,state) VALUES (%s, %s, %s, %s, %s)", (model_id, self._name, self._description, self.__doc__, 'base'))
 379         else:
 380             model_id = cr.fetchone()[0]
 381         if 'module' in context:
 382             name_id = 'model_'+self._name.replace('.', '_')
 383             cr.execute('select * from ir_model_data where name=%s and module=%s', (name_id, context['module']))
 384             if not cr.rowcount:
 385                 cr.execute("INSERT INTO ir_model_data (name,date_init,date_update,module,model,res_id) VALUES (%s, (now() at time zone 'UTC'), (now() at time zone 'UTC'), %s, %s, %s)", \
 386                     (name_id, context['module'], 'ir.model', model_id)
 387                 )
 388
 389         cr.execute("SELECT * FROM ir_model_fields WHERE model=%s", (self._name,))
 390         cols = {}
 391         for rec in cr.dictfetchall():
 392             cols[rec['name']] = rec
 393
 394         ir_model_fields_obj = self.pool.get('ir.model.fields')
 395
 396         # sparse field should be created at the end, as it depends on its serialized field already existing
 397         model_fields = sorted(self._columns.items(), key=lambda x: 1 if x[1]._type == 'sparse' else 0)
 398         for (k, f) in model_fields:
 399             vals = {
 400                 'model_id': model_id,
 401                 'model': self._name,
 402                 'name': k,
 403                 'field_description': f.string,
 404                 'ttype': f._type,
 405                 'relation': f._obj or '',
 406                 'select_level': tools.ustr(int(f.select)),
 407                 'readonly': (f.readonly and 1) or 0,
 408                 'required': (f.required and 1) or 0,
 409                 'selectable': (f.selectable and 1) or 0,
 410                 'translate': (f.translate and 1) or 0,
 411                 'relation_field': f._fields_id if isinstance(f, fields.one2many) else '',
 412                 'serialization_field_id': None,
 413             }
 414             if getattr(f, 'serialization_field', None):
 415                 # resolve link to serialization_field if specified by name
 416                 serialization_field_id = ir_model_fields_obj.search(cr, SUPERUSER_ID, [('model','=',vals['model']), ('name', '=', f.serialization_field)])
 417                 if not serialization_field_id:
 418                     raise except_orm(_('Error'), _("Serialization field `%s` not found for sparse field `%s`!") % (f.serialization_field, k))
 419                 vals['serialization_field_id'] = serialization_field_id[0]
 420
 421             # When its a custom field,it does not contain f.select
 422             if context.get('field_state', 'base') == 'manual':
 423                 if context.get('field_name', '') == k:
 424                     vals['select_level'] = context.get('select', '0')
 425                 #setting value to let the problem NOT occur next time
 426                 elif k in cols:
 427                     vals['select_level'] = cols[k]['select_level']
 428
 429             if k not in cols:
 430                 cr.execute('select nextval(%s)', ('ir_model_fields_id_seq',))
 431                 id = cr.fetchone()[0]
 432                 vals['id'] = id
 433                 cr.execute("""INSERT INTO ir_model_fields (
 434                     id, model_id, model, name, field_description, ttype,
 435                     relation,state,select_level,relation_field, translate, serialization_field_id
 436                 ) VALUES (
 437                     %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s
 438                 )""", (
 439                     id, vals['model_id'], vals['model'], vals['name'], vals['field_description'], vals['ttype'],
 440                      vals['relation'], 'base',
 441                     vals['select_level'], vals['relation_field'], bool(vals['translate']), vals['serialization_field_id']
 442                 ))
 443                 if 'module' in context:
 444                     name1 = 'field_' + self._table + '_' + k
 445                     cr.execute("select name from ir_model_data where name=%s", (name1,))
 446                     if cr.fetchone():
 447                         name1 = name1 + "_" + str(id)
 448                     cr.execute("INSERT INTO ir_model_data (name,date_init,date_update,module,model,res_id) VALUES (%s, (now() at time zone 'UTC'), (now() at time zone 'UTC'), %s, %s, %s)", \
 449                         (name1, context['module'], 'ir.model.fields', id)
 450                     )
 451             else:
 452                 for key, val in vals.items():
 453                     if cols[k][key] != vals[key]:
 454                         cr.execute('update ir_model_fields set field_description=%s where model=%s and name=%s', (vals['field_description'], vals['model'], vals['name']))
 455                         cr.execute("""UPDATE ir_model_fields SET
 456                             model_id=%s, field_description=%s, ttype=%s, relation=%s,
 457                             select_level=%s, readonly=%s ,required=%s, selectable=%s, relation_field=%s, translate=%s, serialization_field_id=%s
 458                         WHERE
 459                             model=%s AND name=%s""", (
 460                                 vals['model_id'], vals['field_description'], vals['ttype'],
 461                                 vals['relation'],
 462                                 vals['select_level'], bool(vals['readonly']), bool(vals['required']), bool(vals['selectable']), vals['relation_field'], bool(vals['translate']), vals['serialization_field_id'], vals['model'], vals['name']
 463                             ))
 464                         break
 465         self.invalidate_cache(cr, SUPERUSER_ID)
 466
 467     @classmethod
 468     def _add_field(cls, name, field):
 469         """ Add the given `field` under the given `name` in the class """
 470         # add field as an attribute and in cls._fields (for reflection)
 471         if not isinstance(getattr(cls, name, field), Field):
 472             _logger.warning("In model %r, field %r overriding existing value", cls._name, name)
 473         setattr(cls, name, field)
 474         cls._fields[name] = field
 475
 476         # basic setup of field
 477         field.set_class_name(cls, name)
 478
 479         if field.store or field.column:
 480             cls._columns[name] = field.to_column()
 481         else:
 482             # remove potential column that may be overridden by field
 483             cls._columns.pop(name, None)
 484
 485     @classmethod
 486     def _pop_field(cls, name):
 487         """ Remove the field with the given `name` from the model.
 488             This method should only be used for manual fields.
 489         """
 490         field = cls._fields.pop(name)
 491         cls._columns.pop(name, None)
 492         cls._all_columns.pop(name, None)
 493         if hasattr(cls, name):
 494             delattr(cls, name)
 495         return field
 496
 497     @classmethod
 498     def _add_magic_fields(cls):
 499         """ Introduce magic fields on the current class
 500
 501         * id is a "normal" field (with a specific getter)
 502         * create_uid, create_date, write_uid and write_date have become
 503           "normal" fields
 504         * $CONCURRENCY_CHECK_FIELD is a computed field with its computing
 505           method defined dynamically. Uses ``str(datetime.datetime.utcnow())``
 506           to get the same structure as the previous
 507           ``(now() at time zone 'UTC')::timestamp``::
 508
 509               # select (now() at time zone 'UTC')::timestamp;
 510                         timezone
 511               ----------------------------
 512                2013-06-18 08:30:37.292809
 513
 514               >>> str(datetime.datetime.utcnow())
 515               '2013-06-18 08:31:32.821177'
 516         """
 517         def add(name, field):
 518             """ add `field` with the given `name` if it does not exist yet """
 519             if name not in cls._columns and name not in cls._fields:
 520                 cls._add_field(name, field)
 521
 522         # cyclic import
 523         from . import fields
 524
 525         # this field 'id' must override any other column or field
 526         cls._add_field('id', fields.Id(automatic=True))
 527
 528         add('display_name', fields.Char(string='Display Name', automatic=True,
 529             compute='_compute_display_name'))
 530
 531         if cls._log_access:
 532             add('create_uid', fields.Many2one('res.users', string='Created by', automatic=True))
 533             add('create_date', fields.Datetime(string='Created on', automatic=True))
 534             add('write_uid', fields.Many2one('res.users', string='Last Updated by', automatic=True))
 535             add('write_date', fields.Datetime(string='Last Updated on', automatic=True))
 536             last_modified_name = 'compute_concurrency_field_with_access'
 537         else:
 538             last_modified_name = 'compute_concurrency_field'
 539
 540         # this field must override any other column or field
 541         cls._add_field(cls.CONCURRENCY_CHECK_FIELD, fields.Datetime(
 542             string='Last Modified on', compute=last_modified_name, automatic=True))
 543
 544     @api.one
 545     def compute_concurrency_field(self):
 546         self[self.CONCURRENCY_CHECK_FIELD] = \
 547             datetime.datetime.utcnow().strftime(DEFAULT_SERVER_DATETIME_FORMAT)
 548
 549     @api.one
 550     @api.depends('create_date', 'write_date')
 551     def compute_concurrency_field_with_access(self):
 552         self[self.CONCURRENCY_CHECK_FIELD] = \
 553             self.write_date or self.create_date or \
 554             datetime.datetime.utcnow().strftime(DEFAULT_SERVER_DATETIME_FORMAT)
 555
 556     #
 557     # Goal: try to apply inheritance at the instanciation level and
 558     #       put objects in the pool var
 559     #
 560     @classmethod
 561     def _build_model(cls, pool, cr):
 562         """ Instanciate a given model.
 563
 564         This class method instanciates the class of some model (i.e. a class
 565         deriving from osv or osv_memory). The class might be the class passed
 566         in argument or, if it inherits from another class, a class constructed
 567         by combining the two classes.
 568
 569         """
 570
 571         # IMPORTANT: the registry contains an instance for each model. The class
 572         # of each model carries inferred metadata that is shared among the
 573         # model's instances for this registry, but not among registries. Hence
 574         # we cannot use that "registry class" for combining model classes by
 575         # inheritance, since it confuses the metadata inference process.
 576
 577         # Keep links to non-inherited constraints in cls; this is useful for
 578         # instance when exporting translations
 579         cls._local_constraints = cls.__dict__.get('_constraints', [])
 580         cls._local_sql_constraints = cls.__dict__.get('_sql_constraints', [])
 581
 582         # determine inherited models
 583         parents = getattr(cls, '_inherit', [])
 584         parents = [parents] if isinstance(parents, basestring) else (parents or [])
 585
 586         # determine the model's name
 587         name = cls._name or (len(parents) == 1 and parents[0]) or cls.__name__
 588
 589         # determine the module that introduced the model
 590         original_module = pool[name]._original_module if name in parents else cls._module
 591
 592         # build the class hierarchy for the model
 593         for parent in parents:
 594             if parent not in pool:
 595                 raise TypeError('The model "%s" specifies an unexisting parent class "%s"\n'
 596                     'You may need to add a dependency on the parent class\' module.' % (name, parent))
 597             parent_model = pool[parent]
 598
 599             # do no use the class of parent_model, since that class contains
 600             # inferred metadata; use its ancestor instead
 601             parent_class = type(parent_model).__base__
 602
 603             # don't inherit custom fields
 604             columns = dict((key, val)
 605                 for key, val in parent_class._columns.iteritems()
 606                 if not val.manual
 607             )
 608             columns.update(cls._columns)
 609
 610             inherits = dict(parent_class._inherits)
 611             inherits.update(cls._inherits)
 612
 613             depends = dict(parent_class._depends)
 614             for m, fs in cls._depends.iteritems():
 615                 depends[m] = depends.get(m, []) + fs
 616
 617             old_constraints = parent_class._constraints
 618             new_constraints = cls._constraints
 619             # filter out from old_constraints the ones overridden by a
 620             # constraint with the same function name in new_constraints
 621             constraints = new_constraints + [oldc
 622                 for oldc in old_constraints
 623                 if not any(newc[2] == oldc[2] and same_name(newc[0], oldc[0])
 624                            for newc in new_constraints)
 625             ]
 626
 627             sql_constraints = cls._sql_constraints + \
 628                               parent_class._sql_constraints
 629
 630             attrs = {
 631                 '_name': name,
 632                 '_register': False,
 633                 '_columns': columns,
 634                 '_inherits': inherits,
 635                 '_depends': depends,
 636                 '_constraints': constraints,
 637                 '_sql_constraints': sql_constraints,
 638             }
 639             cls = type(name, (cls, parent_class), attrs)
 640
 641         # introduce the "registry class" of the model;
 642         # duplicate some attributes so that the ORM can modify them
 643         attrs = {
 644             '_name': name,
 645             '_register': False,
 646             '_columns': dict(cls._columns),
 647             '_defaults': {},            # filled by Field._determine_default()
 648             '_inherits': dict(cls._inherits),
 649             '_depends': dict(cls._depends),
 650             '_constraints': list(cls._constraints),
 651             '_sql_constraints': list(cls._sql_constraints),
 652             '_original_module': original_module,
 653         }
 654         cls = type(cls._name, (cls,), attrs)
 655
 656         # instantiate the model, and initialize it
 657         model = object.__new__(cls)
 658         model.__init__(pool, cr)
 659         return model
 660
 661     @classmethod
 662     def _init_function_fields(cls, pool, cr):
 663         # initialize the list of non-stored function fields for this model
 664         pool._pure_function_fields[cls._name] = []
 665
 666         # process store of low-level function fields
 667         for fname, column in cls._columns.iteritems():
 668             if hasattr(column, 'digits_change'):
 669                 column.digits_change(cr)
 670             # filter out existing store about this field
 671             pool._store_function[cls._name] = [
 672                 stored
 673                 for stored in pool._store_function.get(cls._name, [])
 674                 if (stored[0], stored[1]) != (cls._name, fname)
 675             ]
 676             if not isinstance(column, fields.function):
 677                 continue
 678             if not column.store:
 679                 # register it on the pool for invalidation
 680                 pool._pure_function_fields[cls._name].append(fname)
 681                 continue
 682             # process store parameter
 683             store = column.store
 684             if store is True:
 685                 get_ids = lambda self, cr, uid, ids, c={}: ids
 686                 store = {cls._name: (get_ids, None, column.priority, None)}
 687             for model, spec in store.iteritems():
 688                 if len(spec) == 4:
 689                     (fnct, fields2, order, length) = spec
 690                 elif len(spec) == 3:
 691                     (fnct, fields2, order) = spec
 692                     length = None
 693                 else:
 694                     raise except_orm('Error',
 695                         ('Invalid function definition %s in object %s !\nYou must use the definition: store={object:(fnct, fields, priority, time length)}.' % (fname, cls._name)))
 696                 pool._store_function.setdefault(model, [])
 697                 t = (cls._name, fname, fnct, tuple(fields2) if fields2 else None, order, length)
 698                 if t not in pool._store_function[model]:
 699                     pool._store_function[model].append(t)
 700                     pool._store_function[model].sort(key=lambda x: x[4])
 701
 702     @classmethod
 703     def _init_manual_fields(cls, pool, cr):
 704         # Check whether the query is already done
 705         if pool.fields_by_model is not None:
 706             manual_fields = pool.fields_by_model.get(cls._name, [])
 707         else:
 708             cr.execute('SELECT * FROM ir_model_fields WHERE model=%s AND state=%s', (cls._name, 'manual'))
 709             manual_fields = cr.dictfetchall()
 710
 711         for field in manual_fields:
 712             if field['name'] in cls._columns:
 713                 continue
 714             attrs = {
 715                 'string': field['field_description'],
 716                 'required': bool(field['required']),
 717                 'readonly': bool(field['readonly']),
 718                 'domain': eval(field['domain']) if field['domain'] else None,
 719                 'size': field['size'] or None,
 720                 'ondelete': field['on_delete'],
 721                 'translate': (field['translate']),
 722                 'manual': True,
 723                 '_prefetch': False,
 724                 #'select': int(field['select_level'])
 725             }
 726             if field['serialization_field_id']:
 727                 cr.execute('SELECT name FROM ir_model_fields WHERE id=%s', (field['serialization_field_id'],))
 728                 attrs.update({'serialization_field': cr.fetchone()[0], 'type': field['ttype']})
 729                 if field['ttype'] in ['many2one', 'one2many', 'many2many']:
 730                     attrs.update({'relation': field['relation']})
 731                 cls._columns[field['name']] = fields.sparse(**attrs)
 732             elif field['ttype'] == 'selection':
 733                 cls._columns[field['name']] = fields.selection(eval(field['selection']), **attrs)
 734             elif field['ttype'] == 'reference':
 735                 cls._columns[field['name']] = fields.reference(selection=eval(field['selection']), **attrs)
 736             elif field['ttype'] == 'many2one':
 737                 cls._columns[field['name']] = fields.many2one(field['relation'], **attrs)
 738             elif field['ttype'] == 'one2many':
 739                 cls._columns[field['name']] = fields.one2many(field['relation'], field['relation_field'], **attrs)
 740             elif field['ttype'] == 'many2many':
 741                 _rel1 = field['relation'].replace('.', '_')
 742                 _rel2 = field['model'].replace('.', '_')
 743                 _rel_name = 'x_%s_%s_%s_rel' % (_rel1, _rel2, field['name'])
 744                 cls._columns[field['name']] = fields.many2many(field['relation'], _rel_name, 'id1', 'id2', **attrs)
 745             else:
 746                 cls._columns[field['name']] = getattr(fields, field['ttype'])(**attrs)
 747
 748     @classmethod
 749     def _init_constraints_onchanges(cls):
 750         # store sql constraint error messages
 751         for (key, _, msg) in cls._sql_constraints:
 752             cls.pool._sql_error[cls._table + '_' + key] = msg
 753
 754         # collect constraint and onchange methods
 755         cls._constraint_methods = []
 756         cls._onchange_methods = defaultdict(list)
 757         for attr, func in getmembers(cls, callable):
 758             if hasattr(func, '_constrains'):
 759                 if not all(name in cls._fields for name in func._constrains):
 760                     _logger.warning("@constrains%r parameters must be field names", func._constrains)
 761                 cls._constraint_methods.append(func)
 762             if hasattr(func, '_onchange'):
 763                 if not all(name in cls._fields for name in func._onchange):
 764                     _logger.warning("@onchange%r parameters must be field names", func._onchange)
 765                 for name in func._onchange:
 766                     cls._onchange_methods[name].append(func)
 767
 768     def __new__(cls):
 769         # In the past, this method was registering the model class in the server.
 770         # This job is now done entirely by the metaclass MetaModel.
 771         #
 772         # Do not create an instance here.  Model instances are created by method
 773         # _build_model().
 774         return None
 775
 776     def __init__(self, pool, cr):
 777         """ Initialize a model and make it part of the given registry.
 778
 779         - copy the stored fields' functions in the registry,
 780         - retrieve custom fields and add them in the model,
 781         - ensure there is a many2one for each _inherits'd parent,
 782         - update the children's _columns,
 783         - give a chance to each field to initialize itself.
 784
 785         """
 786         cls = type(self)
 787
 788         # link the class to the registry, and update the registry
 789         cls.pool = pool
 790         cls._model = self              # backward compatibility
 791         pool.add(cls._name, self)
 792
 793         # determine description, table, sequence and log_access
 794         if not cls._description:
 795             cls._description = cls._name
 796         if not cls._table:
 797             cls._table = cls._name.replace('.', '_')
 798         if not cls._sequence:
 799             cls._sequence = cls._table + '_id_seq'
 800         if not hasattr(cls, '_log_access'):
 801             # If _log_access is not specified, it is the same value as _auto.
 802             cls._log_access = cls._auto
 803
 804         # Transience
 805         if cls.is_transient():
 806             cls._transient_check_count = 0
 807             cls._transient_max_count = config.get('osv_memory_count_limit')
 808             cls._transient_max_hours = config.get('osv_memory_age_limit')
 809             assert cls._log_access, \
 810                 "TransientModels must have log_access turned on, " \
 811                 "in order to implement their access rights policy"
 812
 813         # retrieve new-style fields (from above registry class) and duplicate
 814         # them (to avoid clashes with inheritance between different models)
 815         cls._fields = {}
 816         above = cls.__bases__[0]
 817         for attr, field in getmembers(above, Field.__instancecheck__):
 818             if not field.inherited:
 819                 cls._add_field(attr, field.new())
 820
 821         # introduce magic fields
 822         cls._add_magic_fields()
 823
 824         # register stuff about low-level function fields and custom fields
 825         cls._init_function_fields(pool, cr)
 826         cls._init_manual_fields(pool, cr)
 827
 828         # process _inherits
 829         cls._inherits_check()
 830         cls._inherits_reload()
 831
 832         # register constraints and onchange methods
 833         cls._init_constraints_onchanges()
 834
 835         # check defaults
 836         for k in cls._defaults:
 837             assert k in cls._fields, \
 838                 "Model %s has a default for non-existing field %s" % (cls._name, k)
 839
 840         # restart columns
 841         for column in cls._columns.itervalues():
 842             column.restart()
 843
 844         # validate rec_name
 845         if cls._rec_name:
 846             assert cls._rec_name in cls._fields, \
 847                 "Invalid rec_name %s for model %s" % (cls._rec_name, cls._name)
 848         elif 'name' in cls._fields:
 849             cls._rec_name = 'name'
 850
 851         # prepare ormcache, which must be shared by all instances of the model
 852         cls._ormcache = {}
 853
 854     @api.model
 855     @ormcache()
 856     def _is_an_ordinary_table(self):
 857         self.env.cr.execute("""\
 858             SELECT  1
 859             FROM    pg_class
 860             WHERE   relname = %s
 861             AND     relkind = %s""", [self._table, 'r'])
 862         return bool(self.env.cr.fetchone())
 863
 864     def __export_xml_id(self):
 865         """ Return a valid xml_id for the record `self`. """
 866         if not self._is_an_ordinary_table():
 867             raise Exception(
 868                 "You can not export the column ID of model %s, because the "
 869                 "table %s is not an ordinary table."
 870                 % (self._name, self._table))
 871         ir_model_data = self.sudo().env['ir.model.data']
 872         data = ir_model_data.search([('model', '=', self._name), ('res_id', '=', self.id)])
 873         if data:
 874             if data[0].module:
 875                 return '%s.%s' % (data[0].module, data[0].name)
 876             else:
 877                 return data[0].name
 878         else:
 879             postfix = 0
 880             name = '%s_%s' % (self._table, self.id)
 881             while ir_model_data.search([('module', '=', '__export__'), ('name', '=', name)]):
 882                 postfix += 1
 883                 name = '%s_%s_%s' % (self._table, self.id, postfix)
 884             ir_model_data.create({
 885                 'model': self._name,
 886                 'res_id': self.id,
 887                 'module': '__export__',
 888                 'name': name,
 889             })
 890             return '__export__.' + name
 891
 892     @api.multi
 893     def __export_rows(self, fields):
 894         """ Export fields of the records in `self`.
 895
 896             :param fields: list of lists of fields to traverse
 897             :return: list of lists of corresponding values
 898         """
 899         lines = []
 900         for record in self:
 901             # main line of record, initially empty
 902             current = [''] * len(fields)
 903             lines.append(current)
 904
 905             # list of primary fields followed by secondary field(s)
 906             primary_done = []
 907
 908             # process column by column
 909             for i, path in enumerate(fields):
 910                 if not path:
 911                     continue
 912
 913                 name = path[0]
 914                 if name in primary_done:
 915                     continue
 916
 917                 if name == '.id':
 918                     current[i] = str(record.id)
 919                 elif name == 'id':
 920                     current[i] = record.__export_xml_id()
 921                 else:
 922                     field = record._fields[name]
 923                     value = record[name]
 924
 925                     # this part could be simpler, but it has to be done this way
 926                     # in order to reproduce the former behavior
 927                     if not isinstance(value, BaseModel):
 928                         current[i] = field.convert_to_export(value, self.env)
 929                     else:
 930                         primary_done.append(name)
 931
 932                         # This is a special case, its strange behavior is intended!
 933                         if field.type == 'many2many' and len(path) > 1 and path[1] == 'id':
 934                             xml_ids = [r.__export_xml_id() for r in value]
 935                             current[i] = ','.join(xml_ids) or False
 936                             continue
 937
 938                         # recursively export the fields that follow name
 939                         fields2 = [(p[1:] if p and p[0] == name else []) for p in fields]
 940                         lines2 = value.__export_rows(fields2)
 941                         if lines2:
 942                             # merge first line with record's main line
 943                             for j, val in enumerate(lines2[0]):
 944                                 if val:
 945                                     current[j] = val
 946                             # check value of current field
 947                             if not current[i]:
 948                                 # assign xml_ids, and forget about remaining lines
 949                                 xml_ids = [item[1] for item in value.name_get()]
 950                                 current[i] = ','.join(xml_ids)
 951                             else:
 952                                 # append the other lines at the end
 953                                 lines += lines2[1:]
 954                         else:
 955                             current[i] = False
 956
 957         return lines
 958
 959     @api.multi
 960     def export_data(self, fields_to_export, raw_data=False):
 961         """ Export fields for selected objects
 962
 963             :param fields_to_export: list of fields
 964             :param raw_data: True to return value in native Python type
 965             :rtype: dictionary with a *datas* matrix
 966
 967             This method is used when exporting data via client menu
 968         """
 969         fields_to_export = map(fix_import_export_id_paths, fields_to_export)
 970         if raw_data:
 971             self = self.with_context(export_raw_data=True)
 972         return {'datas': self.__export_rows(fields_to_export)}
 973
 974     def import_data(self, cr, uid, fields, datas, mode='init', current_module='', noupdate=False, context=None, filename=None):
 975         """
 976         .. deprecated:: 7.0
 977             Use :meth:`~load` instead
 978
 979         Import given data in given module
 980
 981         This method is used when importing data via client menu.
 982
 983         Example of fields to import for a sale.order::
 984
 985             .id,                         (=database_id)
 986             partner_id,                  (=name_search)
 987             order_line/.id,              (=database_id)
 988             order_line/name,
 989             order_line/product_id/id,    (=xml id)
 990             order_line/price_unit,
 991             order_line/product_uom_qty,
 992             order_line/product_uom/id    (=xml_id)
 993
 994         This method returns a 4-tuple with the following structure::
 995
 996             (return_code, errored_resource, error_message, unused)
 997
 998         * The first item is a return code, it is ``-1`` in case of
 999           import error, or the last imported row number in case of success
1000         * The second item contains the record data dict that failed to import
1001           in case of error, otherwise it's 0
1002         * The third item contains an error message string in case of error,
1003           otherwise it's 0
1004         * The last item is currently unused, with no specific semantics
1005
1006         :param fields: list of fields to import
1007         :param datas: data to import
1008         :param mode: 'init' or 'update' for record creation
1009         :param current_module: module name
1010         :param noupdate: flag for record creation
1011         :param filename: optional file to store partial import state for recovery
1012         :returns: 4-tuple in the form (return_code, errored_resource, error_message, unused)
1013         :rtype: (int, dict or 0, str or 0, str or 0)
1014         """
1015         context = dict(context) if context is not None else {}
1016         context['_import_current_module'] = current_module
1017
1018         fields = map(fix_import_export_id_paths, fields)
1019         ir_model_data_obj = self.pool.get('ir.model.data')
1020
1021         def log(m):
1022             if m['type'] == 'error':
1023                 raise Exception(m['message'])
1024
1025         if config.get('import_partial') and filename:
1026             with open(config.get('import_partial'), 'rb') as partial_import_file:
1027                 data = pickle.load(partial_import_file)
1028                 position = data.get(filename, 0)
1029
1030         position = 0
1031         try:
1032             for res_id, xml_id, res, info in self._convert_records(cr, uid,
1033                             self._extract_records(cr, uid, fields, datas,
1034                                                   context=context, log=log),
1035                             context=context, log=log):
1036                 ir_model_data_obj._update(cr, uid, self._name,
1037                      current_module, res, mode=mode, xml_id=xml_id,
1038                      noupdate=noupdate, res_id=res_id, context=context)
1039                 position = info.get('rows', {}).get('to', 0) + 1
1040                 if config.get('import_partial') and filename and (not (position%100)):
1041                     with open(config.get('import_partial'), 'rb') as partial_import:
1042                         data = pickle.load(partial_import)
1043                     data[filename] = position
1044                     with open(config.get('import_partial'), 'wb') as partial_import:
1045                         pickle.dump(data, partial_import)
1046                     if context.get('defer_parent_store_computation'):
1047                         self._parent_store_compute(cr)
1048                     cr.commit()
1049         except Exception, e:
1050             cr.rollback()
1051             return -1, {}, 'Line %d : %s' % (position + 1, tools.ustr(e)), ''
1052
1053         if context.get('defer_parent_store_computation'):
1054             self._parent_store_compute(cr)
1055         return position, 0, 0, 0
1056
1057     def load(self, cr, uid, fields, data, context=None):
1058         """
1059         Attempts to load the data matrix, and returns a list of ids (or
1060         ``False`` if there was an error and no id could be generated) and a
1061         list of messages.
1062
1063         The ids are those of the records created and saved (in database), in
1064         the same order they were extracted from the file. They can be passed
1065         directly to :meth:`~read`
1066
1067         :param fields: list of fields to import, at the same index as the corresponding data
1068         :type fields: list(str)
1069         :param data: row-major matrix of data to import
1070         :type data: list(list(str))
1071         :param dict context:
1072         :returns: {ids: list(int)|False, messages: [Message]}
1073         """
1074         cr.execute('SAVEPOINT model_load')
1075         messages = []
1076
1077         fields = map(fix_import_export_id_paths, fields)
1078         ModelData = self.pool['ir.model.data'].clear_caches()
1079
1080         fg = self.fields_get(cr, uid, context=context)
1081
1082         mode = 'init'
1083         current_module = ''
1084         noupdate = False
1085
1086         ids = []
1087         for id, xid, record, info in self._convert_records(cr, uid,
1088                 self._extract_records(cr, uid, fields, data,
1089                                       context=context, log=messages.append),
1090                 context=context, log=messages.append):
1091             try:
1092                 cr.execute('SAVEPOINT model_load_save')
1093             except psycopg2.InternalError, e:
1094                 # broken transaction, exit and hope the source error was
1095                 # already logged
1096                 if not any(message['type'] == 'error' for message in messages):
1097                     messages.append(dict(info, type='error',message=
1098                         u"Unknown database error: '%s'" % e))
1099                 break
1100             try:
1101                 ids.append(ModelData._update(cr, uid, self._name,
1102                      current_module, record, mode=mode, xml_id=xid,
1103                      noupdate=noupdate, res_id=id, context=context))
1104                 cr.execute('RELEASE SAVEPOINT model_load_save')
1105             except psycopg2.Warning, e:
1106                 messages.append(dict(info, type='warning', message=str(e)))
1107                 cr.execute('ROLLBACK TO SAVEPOINT model_load_save')
1108             except psycopg2.Error, e:
1109                 messages.append(dict(
1110                     info, type='error',
1111                     **PGERROR_TO_OE[e.pgcode](self, fg, info, e)))
1112                 # Failed to write, log to messages, rollback savepoint (to
1113                 # avoid broken transaction) and keep going
1114                 cr.execute('ROLLBACK TO SAVEPOINT model_load_save')
1115             except Exception, e:
1116                 message = (_('Unknown error during import:') +
1117                            ' %s: %s' % (type(e), unicode(e)))
1118                 moreinfo = _('Resolve other errors first')
1119                 messages.append(dict(info, type='error',
1120                                      message=message,
1121                                      moreinfo=moreinfo))
1122                 # Failed for some reason, perhaps due to invalid data supplied,
1123                 # rollback savepoint and keep going
1124                 cr.execute('ROLLBACK TO SAVEPOINT model_load_save')
1125         if any(message['type'] == 'error' for message in messages):
1126             cr.execute('ROLLBACK TO SAVEPOINT model_load')
1127             ids = False
1128         return {'ids': ids, 'messages': messages}
1129
1130     def _extract_records(self, cr, uid, fields_, data,
1131                          context=None, log=lambda a: None):
1132         """ Generates record dicts from the data sequence.
1133
1134         The result is a generator of dicts mapping field names to raw
1135         (unconverted, unvalidated) values.
1136
1137         For relational fields, if sub-fields were provided the value will be
1138         a list of sub-records
1139
1140         The following sub-fields may be set on the record (by key):
1141         * None is the name_get for the record (to use with name_create/name_search)
1142         * "id" is the External ID for the record
1143         * ".id" is the Database ID for the record
1144         """
1145         from openerp.fields import Char, Integer
1146         fields = dict(self._fields)
1147         # Fake fields to avoid special cases in extractor
1148         fields[None] = Char('rec_name')
1149         fields['id'] = Char('External ID')
1150         fields['.id'] = Integer('Database ID')
1151
1152         # m2o fields can't be on multiple lines so exclude them from the
1153         # is_relational field rows filter, but special-case it later on to
1154         # be handled with relational fields (as it can have subfields)
1155         is_relational = lambda field: fields[field].relational
1156         get_o2m_values = itemgetter_tuple(
1157             [index for index, field in enumerate(fields_)
1158                    if fields[field[0]].type == 'one2many'])
1159         get_nono2m_values = itemgetter_tuple(
1160             [index for index, field in enumerate(fields_)
1161                    if fields[field[0]].type != 'one2many'])
1162         # Checks if the provided row has any non-empty non-relational field
1163         def only_o2m_values(row, f=get_nono2m_values, g=get_o2m_values):
1164             return any(g(row)) and not any(f(row))
1165
1166         index = 0
1167         while True:
1168             if index >= len(data): return
1169
1170             row = data[index]
1171             # copy non-relational fields to record dict
1172             record = dict((field[0], value)
1173                 for field, value in itertools.izip(fields_, row)
1174                 if not is_relational(field[0]))
1175
1176             # Get all following rows which have relational values attached to
1177             # the current record (no non-relational values)
1178             record_span = itertools.takewhile(
1179                 only_o2m_values, itertools.islice(data, index + 1, None))
1180             # stitch record row back on for relational fields
1181             record_span = list(itertools.chain([row], record_span))
1182             for relfield in set(
1183                     field[0] for field in fields_
1184                              if is_relational(field[0])):
1185                 # FIXME: how to not use _obj without relying on fields_get?
1186                 Model = self.pool[fields[relfield].comodel_name]
1187
1188                 # get only cells for this sub-field, should be strictly
1189                 # non-empty, field path [None] is for name_get field
1190                 indices, subfields = zip(*((index, field[1:] or [None])
1191                                            for index, field in enumerate(fields_)
1192                                            if field[0] == relfield))
1193
1194                 # return all rows which have at least one value for the
1195                 # subfields of relfield
1196                 relfield_data = filter(any, map(itemgetter_tuple(indices), record_span))
1197                 record[relfield] = [subrecord
1198                     for subrecord, _subinfo in Model._extract_records(
1199                         cr, uid, subfields, relfield_data,
1200                         context=context, log=log)]
1201
1202             yield record, {'rows': {
1203                 'from': index,
1204                 'to': index + len(record_span) - 1
1205             }}
1206             index += len(record_span)
1207
1208     def _convert_records(self, cr, uid, records,
1209                          context=None, log=lambda a: None):
1210         """ Converts records from the source iterable (recursive dicts of
1211         strings) into forms which can be written to the database (via
1212         self.create or (ir.model.data)._update)
1213
1214         :returns: a list of triplets of (id, xid, record)
1215         :rtype: list((int|None, str|None, dict))
1216         """
1217         if context is None: context = {}
1218         Converter = self.pool['ir.fields.converter']
1219         Translation = self.pool['ir.translation']
1220         fields = dict(self._fields)
1221         field_names = dict(
1222             (f, (Translation._get_source(cr, uid, self._name + ',' + f, 'field',
1223                                          context.get('lang'))
1224                  or field.string))
1225             for f, field in fields.iteritems())
1226
1227         convert = Converter.for_model(cr, uid, self, context=context)
1228
1229         def _log(base, field, exception):
1230             type = 'warning' if isinstance(exception, Warning) else 'error'
1231             # logs the logical (not human-readable) field name for automated
1232             # processing of response, but injects human readable in message
1233             record = dict(base, type=type, field=field,
1234                           message=unicode(exception.args[0]) % base)
1235             if len(exception.args) > 1 and exception.args[1]:
1236                 record.update(exception.args[1])
1237             log(record)
1238
1239         stream = CountingStream(records)
1240         for record, extras in stream:
1241             dbid = False
1242             xid = False
1243             # name_get/name_create
1244             if None in record: pass
1245             # xid
1246             if 'id' in record:
1247                 xid = record['id']
1248             # dbid
1249             if '.id' in record:
1250                 try:
1251                     dbid = int(record['.id'])
1252                 except ValueError:
1253                     # in case of overridden id column
1254                     dbid = record['.id']
1255                 if not self.search(cr, uid, [('id', '=', dbid)], context=context):
1256                     log(dict(extras,
1257                         type='error',
1258                         record=stream.index,
1259                         field='.id',
1260                         message=_(u"Unknown database identifier '%s'") % dbid))
1261                     dbid = False
1262
1263             converted = convert(record, lambda field, err:\
1264                 _log(dict(extras, record=stream.index, field=field_names[field]), field, err))
1265
1266             yield dbid, xid, converted, dict(extras, record=stream.index)
1267
1268     @api.multi
1269     def _validate_fields(self, field_names):
1270         field_names = set(field_names)
1271
1272         # old-style constraint methods
1273         trans = self.env['ir.translation']
1274         cr, uid, context = self.env.args
1275         ids = self.ids
1276         errors = []
1277         for fun, msg, names in self._constraints:
1278             try:
1279                 # validation must be context-independent; call `fun` without context
1280                 valid = not (set(names) & field_names) or fun(self._model, cr, uid, ids)
1281                 extra_error = None
1282             except Exception, e:
1283                 _logger.debug('Exception while validating constraint', exc_info=True)
1284                 valid = False
1285                 extra_error = tools.ustr(e)
1286             if not valid:
1287                 if callable(msg):
1288                     res_msg = msg(self._model, cr, uid, ids, context=context)
1289                     if isinstance(res_msg, tuple):
1290                         template, params = res_msg
1291                         res_msg = template % params
1292                 else:
1293                     res_msg = trans._get_source(self._name, 'constraint', self.env.lang, msg)
1294                 if extra_error:
1295                     res_msg += "\n\n%s\n%s" % (_('Error details:'), extra_error)
1296                 errors.append(
1297                     _("Field(s) `%s` failed against a constraint: %s") %
1298                         (', '.join(names), res_msg)
1299                 )
1300         if errors:
1301             raise ValidationError('\n'.join(errors))
1302
1303         # new-style constraint methods
1304         for check in self._constraint_methods:
1305             if set(check._constrains) & field_names:
1306                 try:
1307                     check(self)
1308                 except ValidationError, e:
1309                     raise
1310                 except Exception, e:
1311                     raise ValidationError("Error while validating constraint\n\n%s" % tools.ustr(e))
1312
1313     @api.model
1314     def default_get(self, fields_list):
1315         """ default_get(fields) -> default_values
1316
1317         Return default values for the fields in `fields_list`. Default
1318         values are determined by the context, user defaults, and the model
1319         itself.
1320
1321         :param fields_list: a list of field names
1322         :return: a dictionary mapping each field name to its corresponding
1323             default value, if it has one.
1324
1325         """
1326         # trigger view init hook
1327         self.view_init(fields_list)
1328
1329         defaults = {}
1330         parent_fields = defaultdict(list)
1331
1332         for name in fields_list:
1333             # 1. look up context
1334             key = 'default_' + name
1335             if key in self._context:
1336                 defaults[name] = self._context[key]
1337                 continue
1338
1339             # 2. look up ir_values
1340             #    Note: performance is good, because get_defaults_dict is cached!
1341             ir_values_dict = self.env['ir.values'].get_defaults_dict(self._name)
1342             if name in ir_values_dict:
1343                 defaults[name] = ir_values_dict[name]
1344                 continue
1345
1346             field = self._fields.get(name)
1347
1348             # 3. look up property fields
1349             #    TODO: get rid of this one
1350             if field and field.company_dependent:
1351                 defaults[name] = self.env['ir.property'].get(name, self._name)
1352                 continue
1353
1354             # 4. look up field.default
1355             if field and field.default:
1356                 defaults[name] = field.default(self)
1357                 continue
1358
1359             # 5. delegate to parent model
1360             if field and field.inherited:
1361                 field = field.related_field
1362                 parent_fields[field.model_name].append(field.name)
1363
1364         # convert default values to the right format
1365         defaults = self._convert_to_cache(defaults, validate=False)
1366         defaults = self._convert_to_write(defaults)
1367
1368         # add default values for inherited fields
1369         for model, names in parent_fields.iteritems():
1370             defaults.update(self.env[model].default_get(names))
1371
1372         return defaults
1373
1374     def fields_get_keys(self, cr, user, context=None):
1375         res = self._columns.keys()
1376         # TODO I believe this loop can be replace by
1377         # res.extend(self._inherit_fields.key())
1378         for parent in self._inherits:
1379             res.extend(self.pool[parent].fields_get_keys(cr, user, context))
1380         return res
1381
1382     def _rec_name_fallback(self, cr, uid, context=None):
1383         rec_name = self._rec_name
1384         if rec_name not in self._columns:
1385             rec_name = self._columns.keys()[0] if len(self._columns.keys()) > 0 else "id"
1386         return rec_name
1387
1388     #
1389     # Overload this method if you need a window title which depends on the context
1390     #
1391     def view_header_get(self, cr, user, view_id=None, view_type='form', context=None):
1392         return False
1393
1394     def user_has_groups(self, cr, uid, groups, context=None):
1395         """Return true if the user is at least member of one of the groups
1396            in groups_str. Typically used to resolve `groups` attribute
1397            in view and model definitions.
1398
1399            :param str groups: comma-separated list of fully-qualified group
1400                               external IDs, e.g.: ``base.group_user,base.group_system``
1401            :return: True if the current user is a member of one of the
1402                     given groups
1403         """
1404         return any(self.pool['res.users'].has_group(cr, uid, group_ext_id)
1405                    for group_ext_id in groups.split(','))
1406
1407     def _get_default_form_view(self, cr, user, context=None):
1408         """ Generates a default single-line form view using all fields
1409         of the current model except the m2m and o2m ones.
1410
1411         :param cr: database cursor
1412         :param int user: user id
1413         :param dict context: connection context
1414         :returns: a form view as an lxml document
1415         :rtype: etree._Element
1416         """
1417         view = etree.Element('form', string=self._description)
1418         group = etree.SubElement(view, 'group', col="4")
1419         for fname, field in self._fields.iteritems():
1420             if field.automatic or field.type in ('one2many', 'many2many'):
1421                 continue
1422
1423             etree.SubElement(group, 'field', name=fname)
1424             if field.type == 'text':
1425                 etree.SubElement(group, 'newline')
1426         return view
1427
1428     def _get_default_search_view(self, cr, user, context=None):
1429         """ Generates a single-field search view, based on _rec_name.
1430
1431         :param cr: database cursor
1432         :param int user: user id
1433         :param dict context: connection context
1434         :returns: a tree view as an lxml document
1435         :rtype: etree._Element
1436         """
1437         view = etree.Element('search', string=self._description)
1438         etree.SubElement(view, 'field', name=self._rec_name_fallback(cr, user, context))
1439         return view
1440
1441     def _get_default_tree_view(self, cr, user, context=None):
1442         """ Generates a single-field tree view, based on _rec_name.
1443
1444         :param cr: database cursor
1445         :param int user: user id
1446         :param dict context: connection context
1447         :returns: a tree view as an lxml document
1448         :rtype: etree._Element
1449         """
1450         view = etree.Element('tree', string=self._description)
1451         etree.SubElement(view, 'field', name=self._rec_name_fallback(cr, user, context))
1452         return view
1453
1454     def _get_default_calendar_view(self, cr, user, context=None):
1455         """ Generates a default calendar view by trying to infer
1456         calendar fields from a number of pre-set attribute names
1457
1458         :param cr: database cursor
1459         :param int user: user id
1460         :param dict context: connection context
1461         :returns: a calendar view
1462         :rtype: etree._Element
1463         """
1464         def set_first_of(seq, in_, to):
1465             """Sets the first value of `seq` also found in `in_` to
1466             the `to` attribute of the view being closed over.
1467
1468             Returns whether it's found a suitable value (and set it on
1469             the attribute) or not
1470             """
1471             for item in seq:
1472                 if item in in_:
1473                     view.set(to, item)
1474                     return True
1475             return False
1476
1477         view = etree.Element('calendar', string=self._description)
1478         etree.SubElement(view, 'field', name=self._rec_name_fallback(cr, user, context))
1479
1480         if self._date_name not in self._columns:
1481             date_found = False
1482             for dt in ['date', 'date_start', 'x_date', 'x_date_start']:
1483                 if dt in self._columns:
1484                     self._date_name = dt
1485                     date_found = True
1486                     break
1487
1488             if not date_found:
1489                 raise except_orm(_('Invalid Object Architecture!'), _("Insufficient fields for Calendar View!"))
1490         view.set('date_start', self._date_name)
1491
1492         set_first_of(["user_id", "partner_id", "x_user_id", "x_partner_id"],
1493                      self._columns, 'color')
1494
1495         if not set_first_of(["date_stop", "date_end", "x_date_stop", "x_date_end"],
1496                             self._columns, 'date_stop'):
1497             if not set_first_of(["date_delay", "planned_hours", "x_date_delay", "x_planned_hours"],
1498                                 self._columns, 'date_delay'):
1499                 raise except_orm(
1500                     _('Invalid Object Architecture!'),
1501                     _("Insufficient fields to generate a Calendar View for %s, missing a date_stop or a date_delay" % self._name))
1502
1503         return view
1504
1505     def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
1506         """ fields_view_get([view_id | view_type='form'])
1507
1508         Get the detailed composition of the requested view like fields, model, view architecture
1509
1510         :param view_id: id of the view or None
1511         :param view_type: type of the view to return if view_id is None ('form', tree', ...)
1512         :param toolbar: true to include contextual actions
1513         :param submenu: deprecated
1514         :return: dictionary describing the composition of the requested view (including inherited views and extensions)
1515         :raise AttributeError:
1516                             * if the inherited view has unknown position to work with other than 'before', 'after', 'inside', 'replace'
1517                             * if some tag other than 'position' is found in parent view
1518         :raise Invalid ArchitectureError: if there is view type other than form, tree, calendar, search etc defined on the structure
1519         """
1520         if context is None:
1521             context = {}
1522         View = self.pool['ir.ui.view']
1523
1524         result = {
1525             'model': self._name,
1526             'field_parent': False,
1527         }
1528
1529         # try to find a view_id if none provided
1530         if not view_id:
1531             # <view_type>_view_ref in context can be used to overrride the default view
1532             view_ref_key = view_type + '_view_ref'
1533             view_ref = context.get(view_ref_key)
1534             if view_ref:
1535                 if '.' in view_ref:
1536                     module, view_ref = view_ref.split('.', 1)
1537                     cr.execute("SELECT res_id FROM ir_model_data WHERE model='ir.ui.view' AND module=%s AND name=%s", (module, view_ref))
1538                     view_ref_res = cr.fetchone()
1539                     if view_ref_res:
1540                         view_id = view_ref_res[0]
1541                 else:
1542                     _logger.warning('%r requires a fully-qualified external id (got: %r for model %s). '
1543                         'Please use the complete `module.view_id` form instead.', view_ref_key, view_ref,
1544                         self._name)
1545
1546             if not view_id:
1547                 # otherwise try to find the lowest priority matching ir.ui.view
1548                 view_id = View.default_view(cr, uid, self._name, view_type, context=context)
1549
1550         # context for post-processing might be overriden
1551         ctx = context
1552         if view_id:
1553             # read the view with inherited views applied
1554             root_view = View.read_combined(cr, uid, view_id, fields=['id', 'name', 'field_parent', 'type', 'model', 'arch'], context=context)
1555             result['arch'] = root_view['arch']
1556             result['name'] = root_view['name']
1557             result['type'] = root_view['type']
1558             result['view_id'] = root_view['id']
1559             result['field_parent'] = root_view['field_parent']
1560             # override context fro postprocessing
1561             if root_view.get('model') != self._name:
1562                 ctx = dict(context, base_model_name=root_view.get('model'))
1563         else:
1564             # fallback on default views methods if no ir.ui.view could be found
1565             try:
1566                 get_func = getattr(self, '_get_default_%s_view' % view_type)
1567                 arch_etree = get_func(cr, uid, context)
1568                 result['arch'] = etree.tostring(arch_etree, encoding='utf-8')
1569                 result['type'] = view_type
1570                 result['name'] = 'default'
1571             except AttributeError:
1572                 raise except_orm(_('Invalid Architecture!'), _("No default view of type '%s' could be found !") % view_type)
1573
1574         # Apply post processing, groups and modifiers etc...
1575         xarch, xfields = View.postprocess_and_fields(cr, uid, self._name, etree.fromstring(result['arch']), view_id, context=ctx)
1576         result['arch'] = xarch
1577         result['fields'] = xfields
1578
1579         # Add related action information if aksed
1580         if toolbar:
1581             toclean = ('report_sxw_content', 'report_rml_content', 'report_sxw', 'report_rml', 'report_sxw_content_data', 'report_rml_content_data')
1582             def clean(x):
1583                 x = x[2]
1584                 for key in toclean:
1585                     x.pop(key, None)
1586                 return x
1587             ir_values_obj = self.pool.get('ir.values')
1588             resprint = ir_values_obj.get(cr, uid, 'action', 'client_print_multi', [(self._name, False)], False, context)
1589             resaction = ir_values_obj.get(cr, uid, 'action', 'client_action_multi', [(self._name, False)], False, context)
1590             resrelate = ir_values_obj.get(cr, uid, 'action', 'client_action_relate', [(self._name, False)], False, context)
1591             resaction = [clean(action) for action in resaction if view_type == 'tree' or not action[2].get('multi')]
1592             resprint = [clean(print_) for print_ in resprint if view_type == 'tree' or not print_[2].get('multi')]
1593             #When multi="True" set it will display only in More of the list view
1594             resrelate = [clean(action) for action in resrelate
1595                          if (action[2].get('multi') and view_type == 'tree') or (not action[2].get('multi') and view_type == 'form')]
1596
1597             for x in itertools.chain(resprint, resaction, resrelate):
1598                 x['string'] = x['name']
1599
1600             result['toolbar'] = {
1601                 'print': resprint,
1602                 'action': resaction,
1603                 'relate': resrelate
1604             }
1605         return result
1606
1607     def get_formview_id(self, cr, uid, id, context=None):
1608         """ Return an view id to open the document with. This method is meant to be
1609             overridden in addons that want to give specific view ids for example.
1610
1611             :param int id: id of the document to open
1612         """
1613         return False
1614
1615     def get_formview_action(self, cr, uid, id, context=None):
1616         """ Return an action to open the document. This method is meant to be
1617             overridden in addons that want to give specific view ids for example.
1618
1619             :param int id: id of the document to open
1620         """
1621         view_id = self.get_formview_id(cr, uid, id, context=context)
1622         return {
1623             'type': 'ir.actions.act_window',
1624             'res_model': self._name,
1625             'view_type': 'form',
1626             'view_mode': 'form',
1627             'views': [(view_id, 'form')],
1628             'target': 'current',
1629             'res_id': id,
1630         }
1631
1632     def get_access_action(self, cr, uid, id, context=None):
1633         """ Return an action to open the document. This method is meant to be
1634         overridden in addons that want to give specific access to the document.
1635         By default it opens the formview of the document.
1636
1637         :paramt int id: id of the document to open
1638         """
1639         return self.get_formview_action(cr, uid, id, context=context)
1640
1641     def _view_look_dom_arch(self, cr, uid, node, view_id, context=None):
1642         return self.pool['ir.ui.view'].postprocess_and_fields(
1643             cr, uid, self._name, node, view_id, context=context)
1644
1645     def search_count(self, cr, user, args, context=None):
1646         """ search_count(args) -> int
1647
1648         Returns the number of records in the current model matching :ref:`the
1649         provided domain <reference/orm/domains>`.
1650         """
1651         res = self.search(cr, user, args, context=context, count=True)
1652         if isinstance(res, list):
1653             return len(res)
1654         return res
1655
1656     @api.returns('self')
1657     def search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False):
1658         """ search(args[, offset=0][, limit=None][, order=None])
1659
1660         Searches for records based on the ``args``
1661         :ref:`search domain <reference/orm/domains>`.
1662
1663         :param args: :ref:`A search domain <reference/orm/domains>`. Use an empty
1664                      list to match all records.
1665         :param int offset: number of results to ignore (default: none)
1666         :param int limit: maximum number of records to return (default: all)
1667         :param str order: sort string
1668         :returns: at most ``limit`` records matching the search criteria
1669
1670         :raise AccessError: * if user tries to bypass access rules for read on the requested object.
1671         """
1672         return self._search(cr, user, args, offset=offset, limit=limit, order=order, context=context, count=count)
1673
1674     #
1675     # display_name, name_get, name_create, name_search
1676     #
1677
1678     @api.depends(lambda self: (self._rec_name,) if self._rec_name else ())
1679     def _compute_display_name(self):
1680         names = dict(self.name_get())
1681         for record in self:
1682             record.display_name = names.get(record.id, False)
1683
1684     @api.multi
1685     def name_get(self):
1686         """ name_get() -> [(id, name), ...]
1687
1688         Returns a textual representation for the records in ``self``.
1689         By default this is the value of the ``display_name`` field.
1690
1691         :return: list of pairs ``(id, text_repr)`` for each records
1692         :rtype: list(tuple)
1693         """
1694         result = []
1695         name = self._rec_name
1696         if name in self._fields:
1697             convert = self._fields[name].convert_to_display_name
1698             for record in self:
1699                 result.append((record.id, convert(record[name])))
1700         else:
1701             for record in self:
1702                 result.append((record.id, "%s,%s" % (record._name, record.id)))
1703
1704         return result
1705
1706     @api.model
1707     def name_create(self, name):
1708         """ name_create(name) -> record
1709
1710         Create a new record by calling :meth:`~.create` with only one value
1711         provided: the display name of the new record.
1712
1713         The new record will be initialized with any default values
1714         applicable to this model, or provided through the context. The usual
1715         behavior of :meth:`~.create` applies.
1716
1717         :param name: display name of the record to create
1718         :rtype: tuple
1719         :return: the :meth:`~.name_get` pair value of the created record
1720         """
1721         if self._rec_name:
1722             record = self.create({self._rec_name: name})
1723             return record.name_get()[0]
1724         else:
1725             _logger.warning("Cannot execute name_create, no _rec_name defined on %s", self._name)
1726             return False
1727
1728     @api.model
1729     def name_search(self, name='', args=None, operator='ilike', limit=100):
1730         """ name_search(name='', args=None, operator='ilike', limit=100) -> records
1731
1732         Search for records that have a display name matching the given
1733         `name` pattern when compared with the given `operator`, while also
1734         matching the optional search domain (`args`).
1735
1736         This is used for example to provide suggestions based on a partial
1737         value for a relational field. Sometimes be seen as the inverse
1738         function of :meth:`~.name_get`, but it is not guaranteed to be.
1739
1740         This method is equivalent to calling :meth:`~.search` with a search
1741         domain based on ``display_name`` and then :meth:`~.name_get` on the
1742         result of the search.
1743
1744         :param str name: the name pattern to match
1745         :param list args: optional search domain (see :meth:`~.search` for
1746                           syntax), specifying further restrictions
1747         :param str operator: domain operator for matching `name`, such as
1748                              ``'like'`` or ``'='``.
1749         :param int limit: optional max number of records to return
1750         :rtype: list
1751         :return: list of pairs ``(id, text_repr)`` for all matching records.
1752         """
1753         return self._name_search(name, args, operator, limit=limit)
1754
1755     def _name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=100, name_get_uid=None):
1756         # private implementation of name_search, allows passing a dedicated user
1757         # for the name_get part to solve some access rights issues
1758         args = list(args or [])
1759         # optimize out the default criterion of ``ilike ''`` that matches everything
1760         if not self._rec_name:
1761             _logger.warning("Cannot execute name_search, no _rec_name defined on %s", self._name)
1762         elif not (name == '' and operator == 'ilike'):
1763             args += [(self._rec_name, operator, name)]
1764         access_rights_uid = name_get_uid or user
1765         ids = self._search(cr, user, args, limit=limit, context=context, access_rights_uid=access_rights_uid)
1766         res = self.name_get(cr, access_rights_uid, ids, context)
1767         return res
1768
1769     def read_string(self, cr, uid, id, langs, fields=None, context=None):
1770         res = {}
1771         res2 = {}
1772         self.pool.get('ir.translation').check_access_rights(cr, uid, 'read')
1773         if not fields:
1774             fields = self._columns.keys() + self._inherit_fields.keys()
1775         #FIXME: collect all calls to _get_source into one SQL call.
1776         for lang in langs:
1777             res[lang] = {'code': lang}
1778             for f in fields:
1779                 if f in self._columns:
1780                     res_trans = self.pool.get('ir.translation')._get_source(cr, uid, self._name+','+f, 'field', lang)
1781                     if res_trans:
1782                         res[lang][f] = res_trans
1783                     else:
1784                         res[lang][f] = self._columns[f].string
1785         for table in self._inherits:
1786             cols = intersect(self._inherit_fields.keys(), fields)
1787             res2 = self.pool[table].read_string(cr, uid, id, langs, cols, context)
1788         for lang in res2:
1789             if lang in res:
1790                 res[lang]['code'] = lang
1791             for f in res2[lang]:
1792                 res[lang][f] = res2[lang][f]
1793         return res
1794
1795     def write_string(self, cr, uid, id, langs, vals, context=None):
1796         self.pool.get('ir.translation').check_access_rights(cr, uid, 'write')
1797         #FIXME: try to only call the translation in one SQL
1798         for lang in langs:
1799             for field in vals:
1800                 if field in self._columns:
1801                     src = self._columns[field].string
1802                     self.pool.get('ir.translation')._set_ids(cr, uid, self._name+','+field, 'field', lang, [0], vals[field], src)
1803         for table in self._inherits:
1804             cols = intersect(self._inherit_fields.keys(), vals)
1805             if cols:
1806                 self.pool[table].write_string(cr, uid, id, langs, vals, context)
1807         return True
1808
1809     def _add_missing_default_values(self, cr, uid, values, context=None):
1810         # avoid overriding inherited values when parent is set
1811         avoid_tables = []
1812         for tables, parent_field in self._inherits.items():
1813             if parent_field in values:
1814                 avoid_tables.append(tables)
1815
1816         # compute missing fields
1817         missing_defaults = set()
1818         for field in self._columns.keys():
1819             if not field in values:
1820                 missing_defaults.add(field)
1821         for field in self._inherit_fields.keys():
1822             if (field not in values) and (self._inherit_fields[field][0] not in avoid_tables):
1823                 missing_defaults.add(field)
1824         # discard magic fields
1825         missing_defaults -= set(MAGIC_COLUMNS)
1826
1827         if missing_defaults:
1828             # override defaults with the provided values, never allow the other way around
1829             defaults = self.default_get(cr, uid, list(missing_defaults), context)
1830             for dv in defaults:
1831                 if ((dv in self._columns and self._columns[dv]._type == 'many2many') \
1832                      or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'many2many')) \
1833                         and defaults[dv] and isinstance(defaults[dv][0], (int, long)):
1834                     defaults[dv] = [(6, 0, defaults[dv])]
1835                 if (dv in self._columns and self._columns[dv]._type == 'one2many' \
1836                     or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'one2many')) \
1837                         and isinstance(defaults[dv], (list, tuple)) and defaults[dv] and isinstance(defaults[dv][0], dict):
1838                     defaults[dv] = [(0, 0, x) for x in defaults[dv]]
1839             defaults.update(values)
1840             values = defaults
1841         return values
1842
1843     def clear_caches(self):
1844         """ Clear the caches
1845
1846         This clears the caches associated to methods decorated with
1847         ``tools.ormcache`` or ``tools.ormcache_multi``.
1848         """
1849         try:
1850             self._ormcache.clear()
1851             self.pool._any_cache_cleared = True
1852         except AttributeError:
1853             pass
1854
1855
1856     def _read_group_fill_results(self, cr, uid, domain, groupby, remaining_groupbys,
1857                                  aggregated_fields, count_field,
1858                                  read_group_result, read_group_order=None, context=None):
1859         """Helper method for filling in empty groups for all possible values of
1860            the field being grouped by"""
1861
1862         # self._group_by_full should map groupable fields to a method that returns
1863         # a list of all aggregated values that we want to display for this field,
1864         # in the form of a m2o-like pair (key,label).
1865         # This is useful to implement kanban views for instance, where all columns
1866         # should be displayed even if they don't contain any record.
1867
1868         # Grab the list of all groups that should be displayed, including all present groups
1869         present_group_ids = [x[groupby][0] for x in read_group_result if x[groupby]]
1870         all_groups,folded = self._group_by_full[groupby](self, cr, uid, present_group_ids, domain,
1871                                                   read_group_order=read_group_order,
1872                                                   access_rights_uid=openerp.SUPERUSER_ID,
1873                                                   context=context)
1874
1875         result_template = dict.fromkeys(aggregated_fields, False)
1876         result_template[groupby + '_count'] = 0
1877         if remaining_groupbys:
1878             result_template['__context'] = {'group_by': remaining_groupbys}
1879
1880         # Merge the left_side (current results as dicts) with the right_side (all
1881         # possible values as m2o pairs). Both lists are supposed to be using the
1882         # same ordering, and can be merged in one pass.
1883         result = []
1884         known_values = {}
1885         def append_left(left_side):
1886             grouped_value = left_side[groupby] and left_side[groupby][0]
1887             if not grouped_value in known_values:
1888                 result.append(left_side)
1889                 known_values[grouped_value] = left_side
1890             else:
1891                 known_values[grouped_value].update({count_field: left_side[count_field]})
1892         def append_right(right_side):
1893             grouped_value = right_side[0]
1894             if not grouped_value in known_values:
1895                 line = dict(result_template)
1896                 line[groupby] = right_side
1897                 line['__domain'] = [(groupby,'=',grouped_value)] + domain
1898                 result.append(line)
1899                 known_values[grouped_value] = line
1900         while read_group_result or all_groups:
1901             left_side = read_group_result[0] if read_group_result else None
1902             right_side = all_groups[0] if all_groups else None
1903             assert left_side is None or left_side[groupby] is False \
1904                  or isinstance(left_side[groupby], (tuple,list)), \
1905                 'M2O-like pair expected, got %r' % left_side[groupby]
1906             assert right_side is None or isinstance(right_side, (tuple,list)), \
1907                 'M2O-like pair expected, got %r' % right_side
1908             if left_side is None:
1909                 append_right(all_groups.pop(0))
1910             elif right_side is None:
1911                 append_left(read_group_result.pop(0))
1912             elif left_side[groupby] == right_side:
1913                 append_left(read_group_result.pop(0))
1914                 all_groups.pop(0) # discard right_side
1915             elif not left_side[groupby] or not left_side[groupby][0]:
1916                 # left side == "Undefined" entry, not present on right_side
1917                 append_left(read_group_result.pop(0))
1918             else:
1919                 append_right(all_groups.pop(0))
1920
1921         if folded:
1922             for r in result:
1923                 r['__fold'] = folded.get(r[groupby] and r[groupby][0], False)
1924         return result
1925
1926     def _read_group_prepare(self, orderby, aggregated_fields, annotated_groupbys, query):
1927         """
1928         Prepares the GROUP BY and ORDER BY terms for the read_group method. Adds the missing JOIN clause
1929         to the query if order should be computed against m2o field.
1930         :param orderby: the orderby definition in the form "%(field)s %(order)s"
1931         :param aggregated_fields: list of aggregated fields in the query
1932         :param annotated_groupbys: list of dictionaries returned by _read_group_process_groupby
1933                 These dictionaries contains the qualified name of each groupby
1934                 (fully qualified SQL name for the corresponding field),
1935                 and the (non raw) field name.
1936         :param osv.Query query: the query under construction
1937         :return: (groupby_terms, orderby_terms)
1938         """
1939         orderby_terms = []
1940         groupby_terms = [gb['qualified_field'] for gb in annotated_groupbys]
1941         groupby_fields = [gb['groupby'] for gb in annotated_groupbys]
1942         if not orderby:
1943             return groupby_terms, orderby_terms
1944
1945         self._check_qorder(orderby)
1946         for order_part in orderby.split(','):
1947             order_split = order_part.split()
1948             order_field = order_split[0]
1949             if order_field in groupby_fields:
1950
1951                 if self._fields[order_field.split(':')[0]].type == 'many2one':
1952                     order_clause = self._generate_order_by(order_part, query).replace('ORDER BY ', '')
1953                     if order_clause:
1954                         orderby_terms.append(order_clause)
1955                         groupby_terms += [order_term.split()[0] for order_term in order_clause.split(',')]
1956                 else:
1957                     order = '"%s" %s' % (order_field, '' if len(order_split) == 1 else order_split[1])
1958                     orderby_terms.append(order)
1959             elif order_field in aggregated_fields:
1960                 orderby_terms.append(order_part)
1961             else:
1962                 # Cannot order by a field that will not appear in the results (needs to be grouped or aggregated)
1963                 _logger.warn('%s: read_group order by `%s` ignored, cannot sort on empty columns (not grouped/aggregated)',
1964                              self._name, order_part)
1965         return groupby_terms, orderby_terms
1966
1967     def _read_group_process_groupby(self, gb, query, context):
1968         """
1969             Helper method to collect important information about groupbys: raw
1970             field name, type, time informations, qualified name, ...
1971         """
1972         split = gb.split(':')
1973         field_type = self._fields[split[0]].type
1974         gb_function = split[1] if len(split) == 2 else None
1975         temporal = field_type in ('date', 'datetime')
1976         tz_convert = field_type == 'datetime' and context.get('tz') in pytz.all_timezones
1977         qualified_field = self._inherits_join_calc(split[0], query)
1978         if temporal:
1979             display_formats = {
1980                 # Careful with week/year formats:
1981                 #  - yyyy (lower) must always be used, *except* for week+year formats
1982                 #  - YYYY (upper) must always be used for week+year format
1983                 #         e.g. 2006-01-01 is W52 2005 in some locales (de_DE),
1984                 #                         and W1 2006 for others
1985                 #
1986                 # Mixing both formats, e.g. 'MMM YYYY' would yield wrong results,
1987                 # such as 2006-01-01 being formatted as "January 2005" in some locales.
1988                 # Cfr: http://babel.pocoo.org/docs/dates/#date-fields
1989                 'day': 'dd MMM yyyy', # yyyy = normal year
1990                 'week': "'W'w YYYY",  # w YYYY = ISO week-year
1991                 'month': 'MMMM yyyy',
1992                 'quarter': 'QQQ yyyy',
1993                 'year': 'yyyy',
1994             }
1995             time_intervals = {
1996                 'day': dateutil.relativedelta.relativedelta(days=1),
1997                 'week': datetime.timedelta(days=7),
1998                 'month': dateutil.relativedelta.relativedelta(months=1),
1999                 'quarter': dateutil.relativedelta.relativedelta(months=3),
2000                 'year': dateutil.relativedelta.relativedelta(years=1)
2001             }
2002             if tz_convert:
2003                 qualified_field = "timezone('%s', timezone('UTC',%s))" % (context.get('tz', 'UTC'), qualified_field)
2004             qualified_field = "date_trunc('%s', %s)" % (gb_function or 'month', qualified_field)
2005         if field_type == 'boolean':
2006             qualified_field = "coalesce(%s,false)" % qualified_field
2007         return {
2008             'field': split[0],
2009             'groupby': gb,
2010             'type': field_type,
2011             'display_format': display_formats[gb_function or 'month'] if temporal else None,
2012             'interval': time_intervals[gb_function or 'month'] if temporal else None,
2013             'tz_convert': tz_convert,
2014             'qualified_field': qualified_field
2015         }
2016
2017     def _read_group_prepare_data(self, key, value, groupby_dict, context):
2018         """
2019             Helper method to sanitize the data received by read_group. The None
2020             values are converted to False, and the date/datetime are formatted,
2021             and corrected according to the timezones.
2022         """
2023         value = False if value is None else value
2024         gb = groupby_dict.get(key)
2025         if gb and gb['type'] in ('date', 'datetime') and value:
2026             if isinstance(value, basestring):
2027                 dt_format = DEFAULT_SERVER_DATETIME_FORMAT if gb['type'] == 'datetime' else DEFAULT_SERVER_DATE_FORMAT
2028                 value = datetime.datetime.strptime(value, dt_format)
2029             if gb['tz_convert']:
2030                 value =  pytz.timezone(context['tz']).localize(value)
2031         return value
2032
2033     def _read_group_get_domain(self, groupby, value):
2034         """
2035             Helper method to construct the domain corresponding to a groupby and
2036             a given value. This is mostly relevant for date/datetime.
2037         """
2038         if groupby['type'] in ('date', 'datetime') and value:
2039             dt_format = DEFAULT_SERVER_DATETIME_FORMAT if groupby['type'] == 'datetime' else DEFAULT_SERVER_DATE_FORMAT
2040             domain_dt_begin = value
2041             domain_dt_end = value + groupby['interval']
2042             if groupby['tz_convert']:
2043                 domain_dt_begin = domain_dt_begin.astimezone(pytz.utc)
2044                 domain_dt_end = domain_dt_end.astimezone(pytz.utc)
2045             return [(groupby['field'], '>=', domain_dt_begin.strftime(dt_format)),
2046                    (groupby['field'], '<', domain_dt_end.strftime(dt_format))]
2047         if groupby['type'] == 'many2one' and value:
2048                 value = value[0]
2049         return [(groupby['field'], '=', value)]
2050
2051     def _read_group_format_result(self, data, annotated_groupbys, groupby, groupby_dict, domain, context):
2052         """
2053             Helper method to format the data contained in the dictianary data by
2054             adding the domain corresponding to its values, the groupbys in the
2055             context and by properly formatting the date/datetime values.
2056         """
2057         domain_group = [dom for gb in annotated_groupbys for dom in self._read_group_get_domain(gb, data[gb['groupby']])]
2058         for k,v in data.iteritems():
2059             gb = groupby_dict.get(k)
2060             if gb and gb['type'] in ('date', 'datetime') and v:
2061                 data[k] = babel.dates.format_date(v, format=gb['display_format'], locale=context.get('lang', 'en_US'))
2062
2063         data['__domain'] = domain_group + domain
2064         if len(groupby) - len(annotated_groupbys) >= 1:
2065             data['__context'] = { 'group_by': groupby[len(annotated_groupbys):]}
2066         del data['id']
2067         return data
2068
2069     def read_group(self, cr, uid, domain, fields, groupby, offset=0, limit=None, context=None, orderby=False, lazy=True):
2070         """
2071         Get the list of records in list view grouped by the given ``groupby`` fields
2072
2073         :param cr: database cursor
2074         :param uid: current user id
2075         :param domain: list specifying search criteria [['field_name', 'operator', 'value'], ...]
2076         :param list fields: list of fields present in the list view specified on the object
2077         :param list groupby: list of groupby descriptions by which the records will be grouped.
2078                 A groupby description is either a field (then it will be grouped by that field)
2079                 or a string 'field:groupby_function'.  Right now, the only functions supported
2080                 are 'day', 'week', 'month', 'quarter' or 'year', and they only make sense for
2081                 date/datetime fields.
2082         :param int offset: optional number of records to skip
2083         :param int limit: optional max number of records to return
2084         :param dict context: context arguments, like lang, time zone.
2085         :param list orderby: optional ``order by`` specification, for
2086                              overriding the natural sort ordering of the
2087                              groups, see also :py:meth:`~osv.osv.osv.search`
2088                              (supported only for many2one fields currently)
2089         :param bool lazy: if true, the results are only grouped by the first groupby and the
2090                 remaining groupbys are put in the __context key.  If false, all the groupbys are
2091                 done in one call.
2092         :return: list of dictionaries(one dictionary for each record) containing:
2093
2094                     * the values of fields grouped by the fields in ``groupby`` argument
2095                     * __domain: list of tuples specifying the search criteria
2096                     * __context: dictionary with argument like ``groupby``
2097         :rtype: [{'field_name_1': value, ...]
2098         :raise AccessError: * if user has no read rights on the requested object
2099                             * if user tries to bypass access rules for read on the requested object
2100         """
2101         if context is None:
2102             context = {}
2103         self.check_access_rights(cr, uid, 'read')
2104         query = self._where_calc(cr, uid, domain, context=context)
2105         fields = fields or self._columns.keys()
2106
2107         groupby = [groupby] if isinstance(groupby, basestring) else groupby
2108         groupby_list = groupby[:1] if lazy else groupby
2109         annotated_groupbys = [self._read_group_process_groupby(gb, query, context)
2110                                     for gb in groupby_list]
2111         groupby_fields = [g['field'] for g in annotated_groupbys]
2112         order = orderby or ','.join([g for g in groupby_list])
2113         groupby_dict = {gb['groupby']: gb for gb in annotated_groupbys}
2114
2115         self._apply_ir_rules(cr, uid, query, 'read', context=context)
2116         for gb in groupby_fields:
2117             assert gb in fields, "Fields in 'groupby' must appear in the list of fields to read (perhaps it's missing in the list view?)"
2118             groupby_def = self._columns.get(gb) or (self._inherit_fields.get(gb) and self._inherit_fields.get(gb)[2])
2119             assert groupby_def and groupby_def._classic_write, "Fields in 'groupby' must be regular database-persisted fields (no function or related fields), or function fields with store=True"
2120             if not (gb in self._fields):
2121                 # Don't allow arbitrary values, as this would be a SQL injection vector!
2122                 raise except_orm(_('Invalid group_by'),
2123                                  _('Invalid group_by specification: "%s".\nA group_by specification must be a list of valid fields.')%(gb,))
2124
2125         aggregated_fields = [
2126             f for f in fields
2127             if f not in ('id', 'sequence')
2128             if f not in groupby_fields
2129             if f in self._fields
2130             if self._fields[f].type in ('integer', 'float')
2131             if getattr(self._fields[f].base_field.column, '_classic_write')
2132         ]
2133
2134         field_formatter = lambda f: (self._fields[f].group_operator or 'sum', self._inherits_join_calc(f, query), f)
2135         select_terms = ["%s(%s) AS %s" % field_formatter(f) for f in aggregated_fields]
2136
2137         for gb in annotated_groupbys:
2138             select_terms.append('%s as "%s" ' % (gb['qualified_field'], gb['groupby']))
2139
2140         groupby_terms, orderby_terms = self._read_group_prepare(order, aggregated_fields, annotated_groupbys, query)
2141         from_clause, where_clause, where_clause_params = query.get_sql()
2142         if lazy and (len(groupby_fields) >= 2 or not context.get('group_by_no_leaf')):
2143             count_field = groupby_fields[0] if len(groupby_fields) >= 1 else '_'
2144         else:
2145             count_field = '_'
2146         count_field += '_count'
2147
2148         prefix_terms = lambda prefix, terms: (prefix + " " + ",".join(terms)) if terms else ''
2149         prefix_term = lambda prefix, term: ('%s %s' % (prefix, term)) if term else ''
2150
2151         query = """
2152             SELECT min(%(table)s.id) AS id, count(%(table)s.id) AS %(count_field)s %(extra_fields)s
2153             FROM %(from)s
2154             %(where)s
2155             %(groupby)s
2156             %(orderby)s
2157             %(limit)s
2158             %(offset)s
2159         """ % {
2160             'table': self._table,
2161             'count_field': count_field,
2162             'extra_fields': prefix_terms(',', select_terms),
2163             'from': from_clause,
2164             'where': prefix_term('WHERE', where_clause),
2165             'groupby': prefix_terms('GROUP BY', groupby_terms),
2166             'orderby': prefix_terms('ORDER BY', orderby_terms),
2167             'limit': prefix_term('LIMIT', int(limit) if limit else None),
2168             'offset': prefix_term('OFFSET', int(offset) if limit else None),
2169         }
2170         cr.execute(query, where_clause_params)
2171         fetched_data = cr.dictfetchall()
2172
2173         if not groupby_fields:
2174             return fetched_data
2175
2176         many2onefields = [gb['field'] for gb in annotated_groupbys if gb['type'] == 'many2one']
2177         if many2onefields:
2178             data_ids = [r['id'] for r in fetched_data]
2179             many2onefields = list(set(many2onefields))
2180             data_dict = {d['id']: d for d in self.read(cr, uid, data_ids, many2onefields, context=context)}
2181             for d in fetched_data:
2182                 d.update(data_dict[d['id']])
2183
2184         data = map(lambda r: {k: self._read_group_prepare_data(k,v, groupby_dict, context) for k,v in r.iteritems()}, fetched_data)
2185         result = [self._read_group_format_result(d, annotated_groupbys, groupby, groupby_dict, domain, context) for d in data]
2186         if lazy and groupby_fields[0] in self._group_by_full:
2187             # Right now, read_group only fill results in lazy mode (by default).
2188             # If you need to have the empty groups in 'eager' mode, then the
2189             # method _read_group_fill_results need to be completely reimplemented
2190             # in a sane way
2191             result = self._read_group_fill_results(cr, uid, domain, groupby_fields[0], groupby[len(annotated_groupbys):],
2192                                                        aggregated_fields, count_field, result, read_group_order=order,
2193                                                        context=context)
2194         return result
2195
2196     def _inherits_join_add(self, current_model, parent_model_name, query):
2197         """
2198         Add missing table SELECT and JOIN clause to ``query`` for reaching the parent table (no duplicates)
2199         :param current_model: current model object
2200         :param parent_model_name: name of the parent model for which the clauses should be added
2201         :param query: query object on which the JOIN should be added
2202         """
2203         inherits_field = current_model._inherits[parent_model_name]
2204         parent_model = self.pool[parent_model_name]
2205         parent_alias, parent_alias_statement = query.add_join((current_model._table, parent_model._table, inherits_field, 'id', inherits_field), implicit=True)
2206         return parent_alias
2207
2208     def _inherits_join_calc(self, field, query):
2209         """
2210         Adds missing table select and join clause(s) to ``query`` for reaching
2211         the field coming from an '_inherits' parent table (no duplicates).
2212
2213         :param field: name of inherited field to reach
2214         :param query: query object on which the JOIN should be added
2215         :return: qualified name of field, to be used in SELECT clause
2216         """
2217         current_table = self
2218         parent_alias = '"%s"' % current_table._table
2219         while field in current_table._inherit_fields and not field in current_table._columns:
2220             parent_model_name = current_table._inherit_fields[field][0]
2221             parent_table = self.pool[parent_model_name]
2222             parent_alias = self._inherits_join_add(current_table, parent_model_name, query)
2223             current_table = parent_table
2224         return '%s."%s"' % (parent_alias, field)
2225
2226     def _parent_store_compute(self, cr):
2227         if not self._parent_store:
2228             return
2229         _logger.info('Computing parent left and right for table %s...', self._table)
2230         def browse_rec(root, pos=0):
2231             # TODO: set order
2232             where = self._parent_name+'='+str(root)
2233             if not root:
2234                 where = self._parent_name+' IS NULL'
2235             if self._parent_order:
2236                 where += ' order by '+self._parent_order
2237             cr.execute('SELECT id FROM '+self._table+' WHERE '+where)
2238             pos2 = pos + 1
2239             for id in cr.fetchall():
2240                 pos2 = browse_rec(id[0], pos2)
2241             cr.execute('update '+self._table+' set parent_left=%s, parent_right=%s where id=%s', (pos, pos2, root))
2242             return pos2 + 1
2243         query = 'SELECT id FROM '+self._table+' WHERE '+self._parent_name+' IS NULL'
2244         if self._parent_order:
2245             query += ' order by ' + self._parent_order
2246         pos = 0
2247         cr.execute(query)
2248         for (root,) in cr.fetchall():
2249             pos = browse_rec(root, pos)
2250         self.invalidate_cache(cr, SUPERUSER_ID, ['parent_left', 'parent_right'])
2251         return True
2252
2253     def _update_store(self, cr, f, k):
2254         _logger.info("storing computed values of fields.function '%s'", k)
2255         ss = self._columns[k]._symbol_set
2256         update_query = 'UPDATE "%s" SET "%s"=%s WHERE id=%%s' % (self._table, k, ss[0])
2257         cr.execute('select id from '+self._table)
2258         ids_lst = map(lambda x: x[0], cr.fetchall())
2259         while ids_lst:
2260             iids = ids_lst[:AUTOINIT_RECALCULATE_STORED_FIELDS]
2261             ids_lst = ids_lst[AUTOINIT_RECALCULATE_STORED_FIELDS:]
2262             res = f.get(cr, self, iids, k, SUPERUSER_ID, {})
2263             for key, val in res.items():
2264                 if f._multi:
2265                     val = val[k]
2266                 # if val is a many2one, just write the ID
2267                 if type(val) == tuple:
2268                     val = val[0]
2269                 if val is not False:
2270                     cr.execute(update_query, (ss[1](val), key))
2271
2272     @api.model
2273     def _check_selection_field_value(self, field, value):
2274         """ Check whether value is among the valid values for the given
2275             selection/reference field, and raise an exception if not.
2276         """
2277         field = self._fields[field]
2278         field.convert_to_cache(value, self)
2279
2280     def _check_removed_columns(self, cr, log=False):
2281         # iterate on the database columns to drop the NOT NULL constraints
2282         # of fields which were required but have been removed (or will be added by another module)
2283         columns = [c for c in self._columns if not (isinstance(self._columns[c], fields.function) and not self._columns[c].store)]
2284         columns += MAGIC_COLUMNS
2285         cr.execute("SELECT a.attname, a.attnotnull"
2286                    "  FROM pg_class c, pg_attribute a"
2287                    " WHERE c.relname=%s"
2288                    "   AND c.oid=a.attrelid"
2289                    "   AND a.attisdropped=%s"
2290                    "   AND pg_catalog.format_type(a.atttypid, a.atttypmod) NOT IN ('cid', 'tid', 'oid', 'xid')"
2291                    "   AND a.attname NOT IN %s", (self._table, False, tuple(columns))),
2292
2293         for column in cr.dictfetchall():
2294             if log:
2295                 _logger.debug("column %s is in the table %s but not in the corresponding object %s",
2296                               column['attname'], self._table, self._name)
2297             if column['attnotnull']:
2298                 cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" DROP NOT NULL' % (self._table, column['attname']))
2299                 _schema.debug("Table '%s': column '%s': dropped NOT NULL constraint",
2300                               self._table, column['attname'])
2301
2302     def _save_constraint(self, cr, constraint_name, type, definition):
2303         """
2304         Record the creation of a constraint for this model, to make it possible
2305         to delete it later when the module is uninstalled. Type can be either
2306         'f' or 'u' depending on the constraint being a foreign key or not.
2307         """
2308         if not self._module:
2309             # no need to save constraints for custom models as they're not part
2310             # of any module
2311             return
2312         assert type in ('f', 'u')
2313         cr.execute("""
2314             SELECT type, definition FROM ir_model_constraint, ir_module_module
2315             WHERE ir_model_constraint.module=ir_module_module.id
2316                 AND ir_model_constraint.name=%s
2317                 AND ir_module_module.name=%s
2318             """, (constraint_name, self._module))
2319         constraints = cr.dictfetchone()
2320         if not constraints:
2321             cr.execute("""
2322                 INSERT INTO ir_model_constraint
2323                     (name, date_init, date_update, module, model, type, definition)
2324                 VALUES (%s, now() AT TIME ZONE 'UTC', now() AT TIME ZONE 'UTC',
2325                     (SELECT id FROM ir_module_module WHERE name=%s),
2326                     (SELECT id FROM ir_model WHERE model=%s), %s, %s)""",
2327                     (constraint_name, self._module, self._name, type, definition))
2328         elif constraints['type'] != type or (definition and constraints['definition'] != definition):
2329             cr.execute("""
2330                 UPDATE ir_model_constraint
2331                 SET date_update=now() AT TIME ZONE 'UTC', type=%s, definition=%s
2332                 WHERE name=%s AND module = (SELECT id FROM ir_module_module WHERE name=%s)""",
2333                     (type, definition, constraint_name, self._module))
2334
2335     def _save_relation_table(self, cr, relation_table):
2336         """
2337         Record the creation of a many2many for this model, to make it possible
2338         to delete it later when the module is uninstalled.
2339         """
2340         cr.execute("""
2341             SELECT 1 FROM ir_model_relation, ir_module_module
2342             WHERE ir_model_relation.module=ir_module_module.id
2343                 AND ir_model_relation.name=%s
2344                 AND ir_module_module.name=%s
2345             """, (relation_table, self._module))
2346         if not cr.rowcount:
2347             cr.execute("""INSERT INTO ir_model_relation (name, date_init, date_update, module, model)
2348                                  VALUES (%s, now() AT TIME ZONE 'UTC', now() AT TIME ZONE 'UTC',
2349                     (SELECT id FROM ir_module_module WHERE name=%s),
2350                     (SELECT id FROM ir_model WHERE model=%s))""",
2351                        (relation_table, self._module, self._name))
2352             self.invalidate_cache(cr, SUPERUSER_ID)
2353
2354     # checked version: for direct m2o starting from `self`
2355     def _m2o_add_foreign_key_checked(self, source_field, dest_model, ondelete):
2356         assert self.is_transient() or not dest_model.is_transient(), \
2357             'Many2One relationships from non-transient Model to TransientModel are forbidden'
2358         if self.is_transient() and not dest_model.is_transient():
2359             # TransientModel relationships to regular Models are annoying
2360             # usually because they could block deletion due to the FKs.
2361             # So unless stated otherwise we default them to ondelete=cascade.
2362             ondelete = ondelete or 'cascade'
2363         fk_def = (self._table, source_field, dest_model._table, ondelete or 'set null')
2364         self._foreign_keys.add(fk_def)
2365         _schema.debug("Table '%s': added foreign key '%s' with definition=REFERENCES \"%s\" ON DELETE %s", *fk_def)
2366
2367     # unchecked version: for custom cases, such as m2m relationships
2368     def _m2o_add_foreign_key_unchecked(self, source_table, source_field, dest_model, ondelete):
2369         fk_def = (source_table, source_field, dest_model._table, ondelete or 'set null')
2370         self._foreign_keys.add(fk_def)
2371         _schema.debug("Table '%s': added foreign key '%s' with definition=REFERENCES \"%s\" ON DELETE %s", *fk_def)
2372
2373     def _drop_constraint(self, cr, source_table, constraint_name):
2374         cr.execute("ALTER TABLE %s DROP CONSTRAINT %s" % (source_table,constraint_name))
2375
2376     def _m2o_fix_foreign_key(self, cr, source_table, source_field, dest_model, ondelete):
2377         # Find FK constraint(s) currently established for the m2o field,
2378         # and see whether they are stale or not
2379         cr.execute("""SELECT confdeltype as ondelete_rule, conname as constraint_name,
2380                              cl2.relname as foreign_table
2381                       FROM pg_constraint as con, pg_class as cl1, pg_class as cl2,
2382                            pg_attribute as att1, pg_attribute as att2
2383                       WHERE con.conrelid = cl1.oid
2384                         AND cl1.relname = %s
2385                         AND con.confrelid = cl2.oid
2386                         AND array_lower(con.conkey, 1) = 1
2387                         AND con.conkey[1] = att1.attnum
2388                         AND att1.attrelid = cl1.oid
2389                         AND att1.attname = %s
2390                         AND array_lower(con.confkey, 1) = 1
2391                         AND con.confkey[1] = att2.attnum
2392                         AND att2.attrelid = cl2.oid
2393                         AND att2.attname = %s
2394                         AND con.contype = 'f'""", (source_table, source_field, 'id'))
2395         constraints = cr.dictfetchall()
2396         if constraints:
2397             if len(constraints) == 1:
2398                 # Is it the right constraint?
2399                 cons, = constraints
2400                 if cons['ondelete_rule'] != POSTGRES_CONFDELTYPES.get((ondelete or 'set null').upper(), 'a')\
2401                     or cons['foreign_table'] != dest_model._table:
2402                     # Wrong FK: drop it and recreate
2403                     _schema.debug("Table '%s': dropping obsolete FK constraint: '%s'",
2404                                   source_table, cons['constraint_name'])
2405                     self._drop_constraint(cr, source_table, cons['constraint_name'])
2406                 else:
2407                     # it's all good, nothing to do!
2408                     return
2409             else:
2410                 # Multiple FKs found for the same field, drop them all, and re-create
2411                 for cons in constraints:
2412                     _schema.debug("Table '%s': dropping duplicate FK constraints: '%s'",
2413                                   source_table, cons['constraint_name'])
2414                     self._drop_constraint(cr, source_table, cons['constraint_name'])
2415
2416         # (re-)create the FK
2417         self._m2o_add_foreign_key_checked(source_field, dest_model, ondelete)
2418
2419
2420     def _set_default_value_on_column(self, cr, column_name, context=None):
2421         # ideally, we should use default_get(), but it fails due to ir.values
2422         # not being ready
2423
2424         # get default value
2425         default = self._defaults.get(column_name)
2426         if callable(default):
2427             default = default(self, cr, SUPERUSER_ID, context)
2428
2429         column = self._columns[column_name]
2430         ss = column._symbol_set
2431         db_default = ss[1](default)
2432         # Write default if non-NULL, except for booleans for which False means
2433         # the same as NULL - this saves us an expensive query on large tables.
2434         write_default = (db_default is not None if column._type != 'boolean'
2435                             else db_default)
2436         if write_default:
2437             _logger.debug("Table '%s': setting default value of new column %s to %r",
2438                           self._table, column_name, default)
2439             query = 'UPDATE "%s" SET "%s"=%s WHERE "%s" is NULL' % (
2440                 self._table, column_name, ss[0], column_name)
2441             cr.execute(query, (db_default,))
2442             # this is a disgrace
2443             cr.commit()
2444
2445     def _auto_init(self, cr, context=None):
2446         """
2447
2448         Call _field_create and, unless _auto is False:
2449
2450         - create the corresponding table in database for the model,
2451         - possibly add the parent columns in database,
2452         - possibly add the columns 'create_uid', 'create_date', 'write_uid',
2453           'write_date' in database if _log_access is True (the default),
2454         - report on database columns no more existing in _columns,
2455         - remove no more existing not null constraints,
2456         - alter existing database columns to match _columns,
2457         - create database tables to match _columns,
2458         - add database indices to match _columns,
2459         - save in self._foreign_keys a list a foreign keys to create (see
2460           _auto_end).
2461
2462         """
2463         self._foreign_keys = set()
2464         raise_on_invalid_object_name(self._name)
2465         if context is None:
2466             context = {}
2467         store_compute = False
2468         stored_fields = []              # new-style stored fields with compute
2469         todo_end = []
2470         update_custom_fields = context.get('update_custom_fields', False)
2471         self._field_create(cr, context=context)
2472         create = not self._table_exist(cr)
2473         if self._auto:
2474
2475             if create:
2476                 self._create_table(cr)
2477                 has_rows = False
2478             else:
2479                 cr.execute('SELECT 1 FROM "%s" LIMIT 1' % self._table)
2480                 has_rows = cr.rowcount
2481
2482             cr.commit()
2483             if self._parent_store:
2484                 if not self._parent_columns_exist(cr):
2485                     self._create_parent_columns(cr)
2486                     store_compute = True
2487
2488             self._check_removed_columns(cr, log=False)
2489
2490             # iterate on the "object columns"
2491             column_data = self._select_column_data(cr)
2492
2493             for k, f in self._columns.iteritems():
2494                 if k == 'id': # FIXME: maybe id should be a regular column?
2495                     continue
2496                 # Don't update custom (also called manual) fields
2497                 if f.manual and not update_custom_fields:
2498                     continue
2499
2500                 if isinstance(f, fields.one2many):
2501                     self._o2m_raise_on_missing_reference(cr, f)
2502
2503                 elif isinstance(f, fields.many2many):
2504                     self._m2m_raise_or_create_relation(cr, f)
2505
2506                 else:
2507                     res = column_data.get(k)
2508
2509                     # The field is not found as-is in database, try if it
2510                     # exists with an old name.
2511                     if not res and hasattr(f, 'oldname'):
2512                         res = column_data.get(f.oldname)
2513                         if res:
2514                             cr.execute('ALTER TABLE "%s" RENAME "%s" TO "%s"' % (self._table, f.oldname, k))
2515                             res['attname'] = k
2516                             column_data[k] = res
2517                             _schema.debug("Table '%s': renamed column '%s' to '%s'",
2518                                 self._table, f.oldname, k)
2519
2520                     # The field already exists in database. Possibly
2521                     # change its type, rename it, drop it or change its
2522                     # constraints.
2523                     if res:
2524                         f_pg_type = res['typname']
2525                         f_pg_size = res['size']
2526                         f_pg_notnull = res['attnotnull']
2527                         if isinstance(f, fields.function) and not f.store and\
2528                                 not getattr(f, 'nodrop', False):
2529                             _logger.info('column %s (%s) converted to a function, removed from table %s',
2530                                          k, f.string, self._table)
2531                             cr.execute('ALTER TABLE "%s" DROP COLUMN "%s" CASCADE' % (self._table, k))
2532                             cr.commit()
2533                             _schema.debug("Table '%s': dropped column '%s' with cascade",
2534                                 self._table, k)
2535                             f_obj_type = None
2536                         else:
2537                             f_obj_type = get_pg_type(f) and get_pg_type(f)[0]
2538
2539                         if f_obj_type:
2540                             ok = False
2541                             casts = [
2542                                 ('text', 'char', pg_varchar(f.size), '::%s' % pg_varchar(f.size)),
2543                                 ('varchar', 'text', 'TEXT', ''),
2544                                 ('int4', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
2545                                 ('date', 'datetime', 'TIMESTAMP', '::TIMESTAMP'),
2546                                 ('timestamp', 'date', 'date', '::date'),
2547                                 ('numeric', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
2548                                 ('float8', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
2549                             ]
2550                             if f_pg_type == 'varchar' and f._type == 'char' and f_pg_size and (f.size is None or f_pg_size < f.size):
2551                                 try:
2552                                     with cr.savepoint():
2553                                         cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" TYPE %s' % (self._table, k, pg_varchar(f.size)))
2554                                 except psycopg2.NotSupportedError:
2555                                     # In place alter table cannot be done because a view is depending of this field.
2556                                     # Do a manual copy. This will drop the view (that will be recreated later)
2557                                     cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
2558                                     cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, pg_varchar(f.size)))
2559                                     cr.execute('UPDATE "%s" SET "%s"=temp_change_size::%s' % (self._table, k, pg_varchar(f.size)))
2560                                     cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
2561                                 cr.commit()
2562                                 _schema.debug("Table '%s': column '%s' (type varchar) changed size from %s to %s",
2563                                     self._table, k, f_pg_size or 'unlimited', f.size or 'unlimited')
2564                             for c in casts:
2565                                 if (f_pg_type==c[0]) and (f._type==c[1]):
2566                                     if f_pg_type != f_obj_type:
2567                                         ok = True
2568                                         cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO __temp_type_cast' % (self._table, k))
2569                                         cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, c[2]))
2570                                         cr.execute(('UPDATE "%s" SET "%s"= __temp_type_cast'+c[3]) % (self._table, k))
2571                                         cr.execute('ALTER TABLE "%s" DROP COLUMN  __temp_type_cast CASCADE' % (self._table,))
2572                                         cr.commit()
2573                                         _schema.debug("Table '%s': column '%s' changed type from %s to %s",
2574                                             self._table, k, c[0], c[1])
2575                                     break
2576
2577                             if f_pg_type != f_obj_type:
2578                                 if not ok:
2579                                     i = 0
2580                                     while True:
2581                                         newname = k + '_moved' + str(i)
2582                                         cr.execute("SELECT count(1) FROM pg_class c,pg_attribute a " \
2583                                             "WHERE c.relname=%s " \
2584                                             "AND a.attname=%s " \
2585                                             "AND c.oid=a.attrelid ", (self._table, newname))
2586                                         if not cr.fetchone()[0]:
2587                                             break
2588                                         i += 1
2589                                     if f_pg_notnull:
2590                                         cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" DROP NOT NULL' % (self._table, k))
2591                                     cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO "%s"' % (self._table, k, newname))
2592                                     cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, get_pg_type(f)[1]))
2593                                     cr.execute("COMMENT ON COLUMN %s.\"%s\" IS %%s" % (self._table, k), (f.string,))
2594                                     _schema.debug("Table '%s': column '%s' has changed type (DB=%s, def=%s), data moved to column %s !",
2595                                         self._table, k, f_pg_type, f._type, newname)
2596
2597                             # if the field is required and hasn't got a NOT NULL constraint
2598                             if f.required and f_pg_notnull == 0:
2599                                 if has_rows:
2600                                     self._set_default_value_on_column(cr, k, context=context)
2601                                 # add the NOT NULL constraint
2602                                 try:
2603                                     cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k), log_exceptions=False)
2604                                     cr.commit()
2605                                     _schema.debug("Table '%s': column '%s': added NOT NULL constraint",
2606                                         self._table, k)
2607                                 except Exception:
2608                                     msg = "Table '%s': unable to set a NOT NULL constraint on column '%s' !\n"\
2609                                         "If you want to have it, you should update the records and execute manually:\n"\
2610                                         "ALTER TABLE %s ALTER COLUMN %s SET NOT NULL"
2611                                     _schema.warning(msg, self._table, k, self._table, k)
2612                                 cr.commit()
2613                             elif not f.required and f_pg_notnull == 1:
2614                                 cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" DROP NOT NULL' % (self._table, k))
2615                                 cr.commit()
2616                                 _schema.debug("Table '%s': column '%s': dropped NOT NULL constraint",
2617                                     self._table, k)
2618                             # Verify index
2619                             indexname = '%s_%s_index' % (self._table, k)
2620                             cr.execute("SELECT indexname FROM pg_indexes WHERE indexname = %s and tablename = %s", (indexname, self._table))
2621                             res2 = cr.dictfetchall()
2622                             if not res2 and f.select:
2623                                 cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (self._table, k, self._table, k))
2624                                 cr.commit()
2625                                 if f._type == 'text':
2626                                     # FIXME: for fields.text columns we should try creating GIN indexes instead (seems most suitable for an ERP context)
2627                                     msg = "Table '%s': Adding (b-tree) index for %s column '%s'."\
2628                                         "This is probably useless (does not work for fulltext search) and prevents INSERTs of long texts"\
2629                                         " because there is a length limit for indexable btree values!\n"\
2630                                         "Use a search view instead if you simply want to make the field searchable."
2631                                     _schema.warning(msg, self._table, f._type, k)
2632                             if res2 and not f.select:
2633                                 cr.execute('DROP INDEX "%s_%s_index"' % (self._table, k))
2634                                 cr.commit()
2635                                 msg = "Table '%s': dropping index for column '%s' of type '%s' as it is not required anymore"
2636                                 _schema.debug(msg, self._table, k, f._type)
2637
2638                             if isinstance(f, fields.many2one) or (isinstance(f, fields.function) and f._type == 'many2one' and f.store):
2639                                 dest_model = self.pool[f._obj]
2640                                 if dest_model._auto and dest_model._table != 'ir_actions':
2641                                     self._m2o_fix_foreign_key(cr, self._table, k, dest_model, f.ondelete)
2642
2643                     # The field doesn't exist in database. Create it if necessary.
2644                     else:
2645                         if not isinstance(f, fields.function) or f.store:
2646                             # add the missing field
2647                             cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, get_pg_type(f)[1]))
2648                             cr.execute("COMMENT ON COLUMN %s.\"%s\" IS %%s" % (self._table, k), (f.string,))
2649                             _schema.debug("Table '%s': added column '%s' with definition=%s",
2650                                 self._table, k, get_pg_type(f)[1])
2651
2652                             # initialize it
2653                             if has_rows:
2654                                 self._set_default_value_on_column(cr, k, context=context)
2655
2656                             # remember the functions to call for the stored fields
2657                             if isinstance(f, fields.function):
2658                                 order = 10
2659                                 if f.store is not True: # i.e. if f.store is a dict
2660                                     order = f.store[f.store.keys()[0]][2]
2661                                 todo_end.append((order, self._update_store, (f, k)))
2662
2663                             # remember new-style stored fields with compute method
2664                             if k in self._fields and self._fields[k].depends:
2665                                 stored_fields.append(self._fields[k])
2666
2667                             # and add constraints if needed
2668                             if isinstance(f, fields.many2one) or (isinstance(f, fields.function) and f._type == 'many2one' and f.store):
2669                                 if f._obj not in self.pool:
2670                                     raise except_orm('Programming Error', 'There is no reference available for %s' % (f._obj,))
2671                                 dest_model = self.pool[f._obj]
2672                                 ref = dest_model._table
2673                                 # ir_actions is inherited so foreign key doesn't work on it
2674                                 if dest_model._auto and ref != 'ir_actions':
2675                                     self._m2o_add_foreign_key_checked(k, dest_model, f.ondelete)
2676                             if f.select:
2677                                 cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (self._table, k, self._table, k))
2678                             if f.required:
2679                                 try:
2680                                     cr.commit()
2681                                     cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k))
2682                                     _schema.debug("Table '%s': column '%s': added a NOT NULL constraint",
2683                                         self._table, k)
2684                                 except Exception:
2685                                     msg = "WARNING: unable to set column %s of table %s not null !\n"\
2686                                         "Try to re-run: openerp-server --update=module\n"\
2687                                         "If it doesn't work, update records and execute manually:\n"\
2688                                         "ALTER TABLE %s ALTER COLUMN %s SET NOT NULL"
2689                                     _logger.warning(msg, k, self._table, self._table, k, exc_info=True)
2690                             cr.commit()
2691
2692         else:
2693             cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (self._table,))
2694             create = not bool(cr.fetchone())
2695
2696         cr.commit()     # start a new transaction
2697
2698         if self._auto:
2699             self._add_sql_constraints(cr)
2700
2701         if create:
2702             self._execute_sql(cr)
2703
2704         if store_compute:
2705             self._parent_store_compute(cr)
2706             cr.commit()
2707
2708         if stored_fields:
2709             # trigger computation of new-style stored fields with a compute
2710             def func(cr):
2711                 _logger.info("Storing computed values of %s fields %s",
2712                     self._name, ', '.join(sorted(f.name for f in stored_fields)))
2713                 recs = self.browse(cr, SUPERUSER_ID, [], {'active_test': False})
2714                 recs = recs.search([])
2715                 if recs:
2716                     map(recs._recompute_todo, stored_fields)
2717                     recs.recompute()
2718
2719             todo_end.append((1000, func, ()))
2720
2721         return todo_end
2722
2723     def _auto_end(self, cr, context=None):
2724         """ Create the foreign keys recorded by _auto_init. """
2725         for t, k, r, d in self._foreign_keys:
2726             cr.execute('ALTER TABLE "%s" ADD FOREIGN KEY ("%s") REFERENCES "%s" ON DELETE %s' % (t, k, r, d))
2727             self._save_constraint(cr, "%s_%s_fkey" % (t, k), 'f', False)
2728         cr.commit()
2729         del self._foreign_keys
2730
2731
2732     def _table_exist(self, cr):
2733         cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (self._table,))
2734         return cr.rowcount
2735
2736
2737     def _create_table(self, cr):
2738         cr.execute('CREATE TABLE "%s" (id SERIAL NOT NULL, PRIMARY KEY(id))' % (self._table,))
2739         cr.execute(("COMMENT ON TABLE \"%s\" IS %%s" % self._table), (self._description,))
2740         _schema.debug("Table '%s': created", self._table)
2741
2742
2743     def _parent_columns_exist(self, cr):
2744         cr.execute("""SELECT c.relname
2745             FROM pg_class c, pg_attribute a
2746             WHERE c.relname=%s AND a.attname=%s AND c.oid=a.attrelid
2747             """, (self._table, 'parent_left'))
2748         return cr.rowcount
2749
2750
2751     def _create_parent_columns(self, cr):
2752         cr.execute('ALTER TABLE "%s" ADD COLUMN "parent_left" INTEGER' % (self._table,))
2753         cr.execute('ALTER TABLE "%s" ADD COLUMN "parent_right" INTEGER' % (self._table,))
2754         if 'parent_left' not in self._columns:
2755             _logger.error('create a column parent_left on object %s: fields.integer(\'Left Parent\', select=1)',
2756                           self._table)
2757             _schema.debug("Table '%s': added column '%s' with definition=%s",
2758                 self._table, 'parent_left', 'INTEGER')
2759         elif not self._columns['parent_left'].select:
2760             _logger.error('parent_left column on object %s must be indexed! Add select=1 to the field definition)',
2761                           self._table)
2762         if 'parent_right' not in self._columns:
2763             _logger.error('create a column parent_right on object %s: fields.integer(\'Right Parent\', select=1)',
2764                           self._table)
2765             _schema.debug("Table '%s': added column '%s' with definition=%s",
2766                 self._table, 'parent_right', 'INTEGER')
2767         elif not self._columns['parent_right'].select:
2768             _logger.error('parent_right column on object %s must be indexed! Add select=1 to the field definition)',
2769                           self._table)
2770         if self._columns[self._parent_name].ondelete not in ('cascade', 'restrict'):
2771             _logger.error("The column %s on object %s must be set as ondelete='cascade' or 'restrict'",
2772                           self._parent_name, self._name)
2773
2774         cr.commit()
2775
2776
2777     def _select_column_data(self, cr):
2778         # attlen is the number of bytes necessary to represent the type when
2779         # the type has a fixed size. If the type has a varying size attlen is
2780         # -1 and atttypmod is the size limit + 4, or -1 if there is no limit.
2781         cr.execute("SELECT c.relname,a.attname,a.attlen,a.atttypmod,a.attnotnull,a.atthasdef,t.typname,CASE WHEN a.attlen=-1 THEN (CASE WHEN a.atttypmod=-1 THEN 0 ELSE a.atttypmod-4 END) ELSE a.attlen END as size " \
2782            "FROM pg_class c,pg_attribute a,pg_type t " \
2783            "WHERE c.relname=%s " \
2784            "AND c.oid=a.attrelid " \
2785            "AND a.atttypid=t.oid", (self._table,))
2786         return dict(map(lambda x: (x['attname'], x),cr.dictfetchall()))
2787
2788
2789     def _o2m_raise_on_missing_reference(self, cr, f):
2790         # TODO this check should be a method on fields.one2many.
2791         if f._obj in self.pool:
2792             other = self.pool[f._obj]
2793             # TODO the condition could use fields_get_keys().
2794             if f._fields_id not in other._columns.keys():
2795                 if f._fields_id not in other._inherit_fields.keys():
2796                     raise except_orm('Programming Error', "There is no reference field '%s' found for '%s'" % (f._fields_id, f._obj,))
2797
2798     def _m2m_raise_or_create_relation(self, cr, f):
2799         m2m_tbl, col1, col2 = f._sql_names(self)
2800         # do not create relations for custom fields as they do not belong to a module
2801         # they will be automatically removed when dropping the corresponding ir.model.field
2802         # table name for custom relation all starts with x_, see __init__
2803         if not m2m_tbl.startswith('x_'):
2804             self._save_relation_table(cr, m2m_tbl)
2805         cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (m2m_tbl,))
2806         if not cr.dictfetchall():
2807             if f._obj not in self.pool:
2808                 raise except_orm('Programming Error', 'Many2Many destination model does not exist: `%s`' % (f._obj,))
2809             dest_model = self.pool[f._obj]
2810             ref = dest_model._table
2811             cr.execute('CREATE TABLE "%s" ("%s" INTEGER NOT NULL, "%s" INTEGER NOT NULL, UNIQUE("%s","%s"))' % (m2m_tbl, col1, col2, col1, col2))
2812             # create foreign key references with ondelete=cascade, unless the targets are SQL views
2813             cr.execute("SELECT relkind FROM pg_class WHERE relkind IN ('v') AND relname=%s", (ref,))
2814             if not cr.fetchall():
2815                 self._m2o_add_foreign_key_unchecked(m2m_tbl, col2, dest_model, 'cascade')
2816             cr.execute("SELECT relkind FROM pg_class WHERE relkind IN ('v') AND relname=%s", (self._table,))
2817             if not cr.fetchall():
2818                 self._m2o_add_foreign_key_unchecked(m2m_tbl, col1, self, 'cascade')
2819
2820             cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (m2m_tbl, col1, m2m_tbl, col1))
2821             cr.execute('CREATE INDEX "%s_%s_index" ON "%s" ("%s")' % (m2m_tbl, col2, m2m_tbl, col2))
2822             cr.execute("COMMENT ON TABLE \"%s\" IS 'RELATION BETWEEN %s AND %s'" % (m2m_tbl, self._table, ref))
2823             cr.commit()
2824             _schema.debug("Create table '%s': m2m relation between '%s' and '%s'", m2m_tbl, self._table, ref)
2825
2826
2827     def _add_sql_constraints(self, cr):
2828         """
2829
2830         Modify this model's database table constraints so they match the one in
2831         _sql_constraints.
2832
2833         """
2834         def unify_cons_text(txt):
2835             return txt.lower().replace(', ',',').replace(' (','(')
2836
2837         for (key, con, _) in self._sql_constraints:
2838             conname = '%s_%s' % (self._table, key)
2839
2840             # using 1 to get result if no imc but one pgc
2841             cr.execute("""SELECT definition, 1
2842                           FROM ir_model_constraint imc
2843                           RIGHT JOIN pg_constraint pgc
2844                           ON (pgc.conname = imc.name)
2845                           WHERE pgc.conname=%s
2846                           """, (conname, ))
2847             existing_constraints = cr.dictfetchone()
2848             sql_actions = {
2849                 'drop': {
2850                     'execute': False,
2851                     'query': 'ALTER TABLE "%s" DROP CONSTRAINT "%s"' % (self._table, conname, ),
2852                     'msg_ok': "Table '%s': dropped constraint '%s'. Reason: its definition changed from '%%s' to '%s'" % (
2853                         self._table, conname, con),
2854                     'msg_err': "Table '%s': unable to drop \'%s\' constraint !" % (self._table, con),
2855                     'order': 1,
2856                 },
2857                 'add': {
2858                     'execute': False,
2859                     'query': 'ALTER TABLE "%s" ADD CONSTRAINT "%s" %s' % (self._table, conname, con,),
2860                     'msg_ok': "Table '%s': added constraint '%s' with definition=%s" % (self._table, conname, con),
2861                     'msg_err': "Table '%s': unable to add \'%s\' constraint !\n If you want to have it, you should update the records and execute manually:\n%%s" % (
2862                         self._table, con),
2863                     'order': 2,
2864                 },
2865             }
2866
2867             if not existing_constraints:
2868                 # constraint does not exists:
2869                 sql_actions['add']['execute'] = True
2870                 sql_actions['add']['msg_err'] = sql_actions['add']['msg_err'] % (sql_actions['add']['query'], )
2871             elif unify_cons_text(con) != existing_constraints['definition']:
2872                 # constraint exists but its definition has changed:
2873                 sql_actions['drop']['execute'] = True
2874                 sql_actions['drop']['msg_ok'] = sql_actions['drop']['msg_ok'] % (existing_constraints['definition'] or '', )
2875                 sql_actions['add']['execute'] = True
2876                 sql_actions['add']['msg_err'] = sql_actions['add']['msg_err'] % (sql_actions['add']['query'], )
2877
2878             # we need to add the constraint:
2879             self._save_constraint(cr, conname, 'u', unify_cons_text(con))
2880             sql_actions = [item for item in sql_actions.values()]
2881             sql_actions.sort(key=lambda x: x['order'])
2882             for sql_action in [action for action in sql_actions if action['execute']]:
2883                 try:
2884                     cr.execute(sql_action['query'])
2885                     cr.commit()
2886                     _schema.debug(sql_action['msg_ok'])
2887                 except:
2888                     _schema.warning(sql_action['msg_err'])
2889                     cr.rollback()
2890
2891
2892     def _execute_sql(self, cr):
2893         """ Execute the SQL code from the _sql attribute (if any)."""
2894         if hasattr(self, "_sql"):
2895             for line in self._sql.split(';'):
2896                 line2 = line.replace('\n', '').strip()
2897                 if line2:
2898                     cr.execute(line2)
2899                     cr.commit()
2900
2901     #
2902     # Update objects that uses this one to update their _inherits fields
2903     #
2904
2905     @classmethod
2906     def _inherits_reload_src(cls):
2907         """ Recompute the _inherit_fields mapping on each _inherits'd child model."""
2908         for model in cls.pool.values():
2909             if cls._name in model._inherits:
2910                 model._inherits_reload()
2911
2912     @classmethod
2913     def _inherits_reload(cls):
2914         """ Recompute the _inherit_fields mapping.
2915
2916         This will also call itself on each inherits'd child model.
2917
2918         """
2919         res = {}
2920         for table in cls._inherits:
2921             other = cls.pool[table]
2922             for col in other._columns.keys():
2923                 res[col] = (table, cls._inherits[table], other._columns[col], table)
2924             for col in other._inherit_fields.keys():
2925                 res[col] = (table, cls._inherits[table], other._inherit_fields[col][2], other._inherit_fields[col][3])
2926         cls._inherit_fields = res
2927         cls._all_columns = cls._get_column_infos()
2928
2929         # interface columns with new-style fields
2930         for attr, column in cls._columns.items():
2931             if attr not in cls._fields:
2932                 cls._add_field(attr, column.to_field())
2933
2934         # interface inherited fields with new-style fields (note that the
2935         # reverse order is for being consistent with _all_columns above)
2936         for parent_model, parent_field in reversed(cls._inherits.items()):
2937             for attr, field in cls.pool[parent_model]._fields.iteritems():
2938                 if attr not in cls._fields:
2939                     cls._add_field(attr, field.new(
2940                         inherited=True,
2941                         related=(parent_field, attr),
2942                         related_sudo=False,
2943                     ))
2944
2945         cls._inherits_reload_src()
2946
2947     @classmethod
2948     def _get_column_infos(cls):
2949         """Returns a dict mapping all fields names (direct fields and
2950            inherited field via _inherits) to a ``column_info`` struct
2951            giving detailed columns """
2952         result = {}
2953         # do not inverse for loops, since local fields may hide inherited ones!
2954         for k, (parent, m2o, col, original_parent) in cls._inherit_fields.iteritems():
2955             result[k] = fields.column_info(k, col, parent, m2o, original_parent)
2956         for k, col in cls._columns.iteritems():
2957             result[k] = fields.column_info(k, col)
2958         return result
2959
2960     @classmethod
2961     def _inherits_check(cls):
2962         for table, field_name in cls._inherits.items():
2963             if field_name not in cls._columns:
2964                 _logger.info('Missing many2one field definition for _inherits reference "%s" in "%s", using default one.', field_name, cls._name)
2965                 cls._columns[field_name] = fields.many2one(table, string="Automatically created field to link to parent %s" % table,
2966                                                              required=True, ondelete="cascade")
2967             elif not cls._columns[field_name].required or cls._columns[field_name].ondelete.lower() not in ("cascade", "restrict"):
2968                 _logger.warning('Field definition for _inherits reference "%s" in "%s" must be marked as "required" with ondelete="cascade" or "restrict", forcing it to required + cascade.', field_name, cls._name)
2969                 cls._columns[field_name].required = True
2970                 cls._columns[field_name].ondelete = "cascade"
2971
2972         # reflect fields with delegate=True in dictionary cls._inherits
2973         for field in cls._fields.itervalues():
2974             if field.type == 'many2one' and not field.related and field.delegate:
2975                 if not field.required:
2976                     _logger.warning("Field %s with delegate=True must be required.", field)
2977                     field.required = True
2978                 if field.ondelete.lower() not in ('cascade', 'restrict'):
2979                     field.ondelete = 'cascade'
2980                 cls._inherits[field.comodel_name] = field.name
2981
2982     @api.model
2983     def _prepare_setup_fields(self):
2984         """ Prepare the setup of fields once the models have been loaded. """
2985         for field in self._fields.itervalues():
2986             field.reset()
2987
2988     @api.model
2989     def _setup_fields(self, partial=False):
2990         """ Setup the fields (dependency triggers, etc). """
2991         for field in self._fields.itervalues():
2992             try:
2993                 field.setup(self.env)
2994             except Exception:
2995                 if not partial:
2996                     raise
2997
2998         # update columns (fields may have changed), and column_infos
2999         for name, field in self._fields.iteritems():
3000             if field.column:
3001                 self._columns[name] = field.to_column()
3002         self._inherits_reload()
3003
3004         # group fields by compute to determine field.computed_fields
3005         fields_by_compute = defaultdict(list)
3006         for field in self._fields.itervalues():
3007             if field.compute:
3008                 field.computed_fields = fields_by_compute[field.compute]
3009                 field.computed_fields.append(field)
3010             else:
3011                 field.computed_fields = []
3012
3013     def fields_get(self, cr, user, allfields=None, context=None, write_access=True):
3014         """ fields_get([fields])
3015
3016         Return the definition of each field.
3017
3018         The returned value is a dictionary (indiced by field name) of
3019         dictionaries. The _inherits'd fields are included. The string, help,
3020         and selection (if present) attributes are translated.
3021
3022         :param cr: database cursor
3023         :param user: current user id
3024         :param allfields: list of fields
3025         :param context: context arguments, like lang, time zone
3026         :return: dictionary of field dictionaries, each one describing a field of the business object
3027         :raise AccessError: * if user has no create/write rights on the requested object
3028
3029         """
3030         recs = self.browse(cr, user, [], context)
3031
3032         res = {}
3033         for fname, field in self._fields.iteritems():
3034             if allfields and fname not in allfields:
3035                 continue
3036             if not field.setup_done:
3037                 continue
3038             if field.groups and not recs.user_has_groups(field.groups):
3039                 continue
3040             res[fname] = field.get_description(recs.env)
3041
3042         # if user cannot create or modify records, make all fields readonly
3043         has_access = functools.partial(recs.check_access_rights, raise_exception=False)
3044         if not (has_access('write') or has_access('create')):
3045             for description in res.itervalues():
3046                 description['readonly'] = True
3047                 description['states'] = {}
3048
3049         return res
3050
3051     def get_empty_list_help(self, cr, user, help, context=None):
3052         """ Generic method giving the help message displayed when having
3053             no result to display in a list or kanban view. By default it returns
3054             the help given in parameter that is generally the help message
3055             defined in the action.
3056         """
3057         return help
3058
3059     def check_field_access_rights(self, cr, user, operation, fields, context=None):
3060         """
3061         Check the user access rights on the given fields. This raises Access
3062         Denied if the user does not have the rights. Otherwise it returns the
3063         fields (as is if the fields is not falsy, or the readable/writable
3064         fields if fields is falsy).
3065         """
3066         if user == SUPERUSER_ID:
3067             return fields or list(self._fields)
3068
3069         def valid(fname):
3070             """ determine whether user has access to field `fname` """
3071             field = self._fields.get(fname)
3072             if field and field.groups:
3073                 return self.user_has_groups(cr, user, groups=field.groups, context=context)
3074             else:
3075                 return True
3076
3077         if not fields:
3078             fields = filter(valid, self._fields)
3079         else:
3080             invalid_fields = set(filter(lambda name: not valid(name), fields))
3081             if invalid_fields:
3082                 _logger.warning('Access Denied by ACLs for operation: %s, uid: %s, model: %s, fields: %s',
3083                     operation, user, self._name, ', '.join(invalid_fields))
3084                 raise AccessError(
3085                     _('The requested operation cannot be completed due to security restrictions. '
3086                     'Please contact your system administrator.\n\n(Document type: %s, Operation: %s)') % \
3087                     (self._description, operation))
3088
3089         return fields
3090
3091     # add explicit old-style implementation to read()
3092     @api.v7
3093     def read(self, cr, user, ids, fields=None, context=None, load='_classic_read'):
3094         records = self.browse(cr, user, ids, context)
3095         result = BaseModel.read(records, fields, load=load)
3096         return result if isinstance(ids, list) else (bool(result) and result[0])
3097
3098     # new-style implementation of read()
3099     @api.v8
3100     def read(self, fields=None, load='_classic_read'):
3101         """ read([fields])
3102
3103         Reads the requested fields for the records in `self`, low-level/RPC
3104         method. In Python code, prefer :meth:`~.browse`.
3105
3106         :param fields: list of field names to return (default is all fields)
3107         :return: a list of dictionaries mapping field names to their values,
3108                  with one dictionary per record
3109         :raise AccessError: if user has no read rights on some of the given
3110                 records
3111         """
3112         # check access rights
3113         self.check_access_rights('read')
3114         fields = self.check_field_access_rights('read', fields)
3115
3116         # split fields into stored and computed fields
3117         stored, computed = [], []
3118         for name in fields:
3119             if name in self._columns:
3120                 stored.append(name)
3121             elif name in self._fields:
3122                 computed.append(name)
3123             else:
3124                 _logger.warning("%s.read() with unknown field '%s'", self._name, name)
3125
3126         # fetch stored fields from the database to the cache
3127         self._read_from_database(stored)
3128
3129         # retrieve results from records; this takes values from the cache and
3130         # computes remaining fields
3131         result = []
3132         name_fields = [(name, self._fields[name]) for name in (stored + computed)]
3133         use_name_get = (load == '_classic_read')
3134         for record in self:
3135             try:
3136                 values = {'id': record.id}
3137                 for name, field in name_fields:
3138                     values[name] = field.convert_to_read(record[name], use_name_get)
3139                 result.append(values)
3140             except MissingError:
3141                 pass
3142
3143         return result
3144
3145     @api.multi
3146     def _prefetch_field(self, field):
3147         """ Read from the database in order to fetch `field` (:class:`Field`
3148             instance) for `self` in cache.
3149         """
3150         # fetch the records of this model without field_name in their cache
3151         records = self._in_cache_without(field)
3152
3153         if len(records) > PREFETCH_MAX:
3154             records = records[:PREFETCH_MAX] | self
3155
3156         # determine which fields can be prefetched
3157         if not self.env.in_draft and \
3158                 self._context.get('prefetch_fields', True) and \
3159                 self._columns[field.name]._prefetch:
3160             # prefetch all classic and many2one fields that the user can access
3161             fnames = {fname
3162                 for fname, fcolumn in self._columns.iteritems()
3163                 if fcolumn._prefetch
3164                 if not fcolumn.groups or self.user_has_groups(fcolumn.groups)
3165             }
3166         else:
3167             fnames = {field.name}
3168
3169         # important: never prefetch fields to recompute!
3170         get_recs_todo = self.env.field_todo
3171         for fname in list(fnames):
3172             if get_recs_todo(self._fields[fname]):
3173                 if fname == field.name:
3174                     records -= get_recs_todo(field)
3175                 else:
3176                     fnames.discard(fname)
3177
3178         # fetch records with read()
3179         assert self in records and field.name in fnames
3180         result = []
3181         try:
3182             result = records.read(list(fnames), load='_classic_write')
3183         except AccessError:
3184             pass
3185
3186         # check the cache, and update it if necessary
3187         if not self._cache.contains(field):
3188             for values in result:
3189                 record = self.browse(values.pop('id'))
3190                 record._cache.update(record._convert_to_cache(values, validate=False))
3191             if not self._cache.contains(field):
3192                 e = AccessError("No value found for %s.%s" % (self, field.name))
3193                 self._cache[field] = FailedValue(e)
3194
3195     @api.multi
3196     def _read_from_database(self, field_names):
3197         """ Read the given fields of the records in `self` from the database,
3198             and store them in cache. Access errors are also stored in cache.
3199         """
3200         env = self.env
3201         cr, user, context = env.args
3202
3203         # FIXME: The query construction needs to be rewritten using the internal Query
3204         # object, as in search(), to avoid ambiguous column references when
3205         # reading/sorting on a table that is auto_joined to another table with
3206         # common columns (e.g. the magical columns)
3207
3208         # Construct a clause for the security rules.
3209         # 'tables' holds the list of tables necessary for the SELECT, including
3210         # the ir.rule clauses, and contains at least self._table.
3211         rule_clause, rule_params, tables = env['ir.rule'].domain_get(self._name, 'read')
3212
3213         # determine the fields that are stored as columns in self._table
3214         fields_pre = [f for f in field_names if self._columns[f]._classic_write]
3215
3216         # we need fully-qualified column names in case len(tables) > 1
3217         def qualify(f):
3218             if isinstance(self._columns.get(f), fields.binary) and \
3219                     context.get('bin_size_%s' % f, context.get('bin_size')):
3220                 # PG 9.2 introduces conflicting pg_size_pretty(numeric) -> need ::cast
3221                 return 'pg_size_pretty(length(%s."%s")::bigint) as "%s"' % (self._table, f, f)
3222             else:
3223                 return '%s."%s"' % (self._table, f)
3224         qual_names = map(qualify, set(fields_pre + ['id']))
3225
3226         query = """ SELECT %(qual_names)s FROM %(tables)s
3227                     WHERE %(table)s.id IN %%s AND (%(extra)s)
3228                     ORDER BY %(order)s
3229                 """ % {
3230                     'qual_names': ",".join(qual_names),
3231                     'tables': ",".join(tables),
3232                     'table': self._table,
3233                     'extra': " OR ".join(rule_clause) if rule_clause else "TRUE",
3234                     'order': self._parent_order or self._order,
3235                 }
3236
3237         result = []
3238         for sub_ids in cr.split_for_in_conditions(self.ids):
3239             cr.execute(query, [tuple(sub_ids)] + rule_params)
3240             result.extend(cr.dictfetchall())
3241
3242         ids = [vals['id'] for vals in result]
3243
3244         if ids:
3245             # translate the fields if necessary
3246             if context.get('lang'):
3247                 ir_translation = env['ir.translation']
3248                 for f in fields_pre:
3249                     if self._columns[f].translate:
3250                         #TODO: optimize out of this loop
3251                         res_trans = ir_translation._get_ids(
3252                             '%s,%s' % (self._name, f), 'model', context['lang'], ids)
3253                         for vals in result:
3254                             vals[f] = res_trans.get(vals['id'], False) or vals[f]
3255
3256             # apply the symbol_get functions of the fields we just read
3257             for f in fields_pre:
3258                 symbol_get = self._columns[f]._symbol_get
3259                 if symbol_get:
3260                     for vals in result:
3261                         vals[f] = symbol_get(vals[f])
3262
3263             # store result in cache for POST fields
3264             for vals in result:
3265                 record = self.browse(vals['id'])
3266                 record._cache.update(record._convert_to_cache(vals, validate=False))
3267
3268             # determine the fields that must be processed now
3269             fields_post = [f for f in field_names if not self._columns[f]._classic_write]
3270
3271             # Compute POST fields, grouped by multi
3272             by_multi = defaultdict(list)
3273             for f in fields_post:
3274                 by_multi[self._columns[f]._multi].append(f)
3275
3276             for multi, fs in by_multi.iteritems():
3277                 if multi:
3278                     res2 = self._columns[fs[0]].get(cr, self._model, ids, fs, user, context=context, values=result)
3279                     assert res2 is not None, \
3280                         'The function field "%s" on the "%s" model returned None\n' \
3281                         '(a dictionary was expected).' % (fs[0], self._name)
3282                     for vals in result:
3283                         # TOCHECK : why got string instend of dict in python2.6
3284                         # if isinstance(res2[vals['id']], str): res2[vals['id']] = eval(res2[vals['id']])
3285                         multi_fields = res2.get(vals['id'], {})
3286                         if multi_fields:
3287                             for f in fs:
3288                                 vals[f] = multi_fields.get(f, [])
3289                 else:
3290                     for f in fs:
3291                         res2 = self._columns[f].get(cr, self._model, ids, f, user, context=context, values=result)
3292                         for vals in result:
3293                             if res2:
3294                                 vals[f] = res2[vals['id']]
3295                             else:
3296                                 vals[f] = []
3297
3298         # Warn about deprecated fields now that fields_pre and fields_post are computed
3299         for f in field_names:
3300             column = self._columns[f]
3301             if column.deprecated:
3302                 _logger.warning('Field %s.%s is deprecated: %s', self._name, f, column.deprecated)
3303
3304         # store result in cache
3305         for vals in result:
3306             record = self.browse(vals.pop('id'))
3307             record._cache.update(record._convert_to_cache(vals, validate=False))
3308
3309         # store failed values in cache for the records that could not be read
3310         fetched = self.browse(ids)
3311         missing = self - fetched
3312         if missing:
3313             extras = fetched - self
3314             if extras:
3315                 raise AccessError(
3316                     _("Database fetch misses ids ({}) and has extra ids ({}), may be caused by a type incoherence in a previous request").format(
3317                         ', '.join(map(repr, missing._ids)),
3318                         ', '.join(map(repr, extras._ids)),
3319                     ))
3320             # store an access error exception in existing records
3321             exc = AccessError(
3322                 _('The requested operation cannot be completed due to security restrictions. Please contact your system administrator.\n\n(Document type: %s, Operation: %s)') % \
3323                 (self._name, 'read')
3324             )
3325             forbidden = missing.exists()
3326             forbidden._cache.update(FailedValue(exc))
3327             # store a missing error exception in non-existing records
3328             exc = MissingError(
3329                 _('One of the documents you are trying to access has been deleted, please try again after refreshing.')
3330             )
3331             (missing - forbidden)._cache.update(FailedValue(exc))
3332
3333     @api.multi
3334     def get_metadata(self):
3335         """
3336         Returns some metadata about the given records.
3337
3338         :return: list of ownership dictionaries for each requested record
3339         :rtype: list of dictionaries with the following keys:
3340
3341                     * id: object id
3342                     * create_uid: user who created the record
3343                     * create_date: date when the record was created
3344                     * write_uid: last user who changed the record
3345                     * write_date: date of the last change to the record
3346                     * xmlid: XML ID to use to refer to this record (if there is one), in format ``module.name``
3347         """
3348         fields = ['id']
3349         if self._log_access:
3350             fields += ['create_uid', 'create_date', 'write_uid', 'write_date']
3351         quoted_table = '"%s"' % self._table
3352         fields_str = ",".join('%s.%s' % (quoted_table, field) for field in fields)
3353         query = '''SELECT %s, __imd.module, __imd.name
3354                    FROM %s LEFT JOIN ir_model_data __imd
3355                        ON (__imd.model = %%s and __imd.res_id = %s.id)
3356                    WHERE %s.id IN %%s''' % (fields_str, quoted_table, quoted_table, quoted_table)
3357         self._cr.execute(query, (self._name, tuple(self.ids)))
3358         res = self._cr.dictfetchall()
3359
3360         uids = set(r[k] for r in res for k in ['write_uid', 'create_uid'] if r.get(k))
3361         names = dict(self.env['res.users'].browse(uids).name_get())
3362
3363         for r in res:
3364             for key in r:
3365                 value = r[key] = r[key] or False
3366                 if key in ('write_uid', 'create_uid') and value in names:
3367                     r[key] = (value, names[value])
3368             r['xmlid'] = ("%(module)s.%(name)s" % r) if r['name'] else False
3369             del r['name'], r['module']
3370         return res
3371
3372     def _check_concurrency(self, cr, ids, context):
3373         if not context:
3374             return
3375         if not (context.get(self.CONCURRENCY_CHECK_FIELD) and self._log_access):
3376             return
3377         check_clause = "(id = %s AND %s < COALESCE(write_date, create_date, (now() at time zone 'UTC'))::timestamp)"
3378         for sub_ids in cr.split_for_in_conditions(ids):
3379             ids_to_check = []
3380             for id in sub_ids:
3381                 id_ref = "%s,%s" % (self._name, id)
3382                 update_date = context[self.CONCURRENCY_CHECK_FIELD].pop(id_ref, None)
3383                 if update_date:
3384                     ids_to_check.extend([id, update_date])
3385             if not ids_to_check:
3386                 continue
3387             cr.execute("SELECT id FROM %s WHERE %s" % (self._table, " OR ".join([check_clause]*(len(ids_to_check)/2))), tuple(ids_to_check))
3388             res = cr.fetchone()
3389             if res:
3390                 # mention the first one only to keep the error message readable
3391                 raise except_orm('ConcurrencyException', _('A document was modified since you last viewed it (%s:%d)') % (self._description, res[0]))
3392
3393     def _check_record_rules_result_count(self, cr, uid, ids, result_ids, operation, context=None):
3394         """Verify the returned rows after applying record rules matches
3395            the length of `ids`, and raise an appropriate exception if it does not.
3396         """
3397         if context is None:
3398             context = {}
3399         ids, result_ids = set(ids), set(result_ids)
3400         missing_ids = ids - result_ids
3401         if missing_ids:
3402             # Attempt to distinguish record rule restriction vs deleted records,
3403             # to provide a more specific error message - check if the missinf
3404             cr.execute('SELECT id FROM ' + self._table + ' WHERE id IN %s', (tuple(missing_ids),))
3405             forbidden_ids = [x[0] for x in cr.fetchall()]
3406             if forbidden_ids:
3407                 # the missing ids are (at least partially) hidden by access rules
3408                 if uid == SUPERUSER_ID:
3409                     return
3410                 _logger.warning('Access Denied by record rules for operation: %s on record ids: %r, uid: %s, model: %s', operation, forbidden_ids, uid, self._name)
3411                 raise except_orm(_('Access Denied'),
3412                                  _('The requested operation cannot be completed due to security restrictions. Please contact your system administrator.\n\n(Document type: %s, Operation: %s)') % \
3413                                     (self._description, operation))
3414             else:
3415                 # If we get here, the missing_ids are not in the database
3416                 if operation in ('read','unlink'):
3417                     # No need to warn about deleting an already deleted record.
3418                     # And no error when reading a record that was deleted, to prevent spurious
3419                     # errors for non-transactional search/read sequences coming from clients
3420                     return
3421                 _logger.warning('Failed operation on deleted record(s): %s, uid: %s, model: %s', operation, uid, self._name)
3422                 raise except_orm(_('Missing document(s)'),
3423                                  _('One of the documents you are trying to access has been deleted, please try again after refreshing.'))
3424
3425
3426     def check_access_rights(self, cr, uid, operation, raise_exception=True): # no context on purpose.
3427         """Verifies that the operation given by ``operation`` is allowed for the user
3428            according to the access rights."""
3429         return self.pool.get('ir.model.access').check(cr, uid, self._name, operation, raise_exception)
3430
3431     def check_access_rule(self, cr, uid, ids, operation, context=None):
3432         """Verifies that the operation given by ``operation`` is allowed for the user
3433            according to ir.rules.
3434
3435            :param operation: one of ``write``, ``unlink``
3436            :raise except_orm: * if current ir.rules do not permit this operation.
3437            :return: None if the operation is allowed
3438         """
3439         if uid == SUPERUSER_ID:
3440             return
3441
3442         if self.is_transient():
3443             # Only one single implicit access rule for transient models: owner only!
3444             # This is ok to hardcode because we assert that TransientModels always
3445             # have log_access enabled so that the create_uid column is always there.
3446             # And even with _inherits, these fields are always present in the local
3447             # table too, so no need for JOINs.
3448             cr.execute("""SELECT distinct create_uid
3449                           FROM %s
3450                           WHERE id IN %%s""" % self._table, (tuple(ids),))
3451             uids = [x[0] for x in cr.fetchall()]
3452             if len(uids) != 1 or uids[0] != uid:
3453                 raise except_orm(_('Access Denied'),
3454                                  _('For this kind of document, you may only access records you created yourself.\n\n(Document type: %s)') % (self._description,))
3455         else:
3456             where_clause, where_params, tables = self.pool.get('ir.rule').domain_get(cr, uid, self._name, operation, context=context)
3457             if where_clause:
3458                 where_clause = ' and ' + ' and '.join(where_clause)
3459                 for sub_ids in cr.split_for_in_conditions(ids):
3460                     cr.execute('SELECT ' + self._table + '.id FROM ' + ','.join(tables) +
3461                                ' WHERE ' + self._table + '.id IN %s' + where_clause,
3462                                [sub_ids] + where_params)
3463                     returned_ids = [x['id'] for x in cr.dictfetchall()]
3464                     self._check_record_rules_result_count(cr, uid, sub_ids, returned_ids, operation, context=context)
3465
3466     def create_workflow(self, cr, uid, ids, context=None):
3467         """Create a workflow instance for each given record IDs."""
3468         from openerp import workflow
3469         for res_id in ids:
3470             workflow.trg_create(uid, self._name, res_id, cr)
3471         # self.invalidate_cache(cr, uid, context=context) ?
3472         return True
3473
3474     def delete_workflow(self, cr, uid, ids, context=None):
3475         """Delete the workflow instances bound to the given record IDs."""
3476         from openerp import workflow
3477         for res_id in ids:
3478             workflow.trg_delete(uid, self._name, res_id, cr)
3479         self.invalidate_cache(cr, uid, context=context)
3480         return True
3481
3482     def step_workflow(self, cr, uid, ids, context=None):
3483         """Reevaluate the workflow instances of the given record IDs."""
3484         from openerp import workflow
3485         for res_id in ids:
3486             workflow.trg_write(uid, self._name, res_id, cr)
3487         # self.invalidate_cache(cr, uid, context=context) ?
3488         return True
3489
3490     def signal_workflow(self, cr, uid, ids, signal, context=None):
3491         """Send given workflow signal and return a dict mapping ids to workflow results"""
3492         from openerp import workflow
3493         result = {}
3494         for res_id in ids:
3495             result[res_id] = workflow.trg_validate(uid, self._name, res_id, signal, cr)
3496         # self.invalidate_cache(cr, uid, context=context) ?
3497         return result
3498
3499     def redirect_workflow(self, cr, uid, old_new_ids, context=None):
3500         """ Rebind the workflow instance bound to the given 'old' record IDs to
3501             the given 'new' IDs. (``old_new_ids`` is a list of pairs ``(old, new)``.
3502         """
3503         from openerp import workflow
3504         for old_id, new_id in old_new_ids:
3505             workflow.trg_redirect(uid, self._name, old_id, new_id, cr)
3506         self.invalidate_cache(cr, uid, context=context)
3507         return True
3508
3509     def unlink(self, cr, uid, ids, context=None):
3510         """ unlink()
3511
3512         Deletes the records of the current set
3513
3514         :raise AccessError: * if user has no unlink rights on the requested object
3515                             * if user tries to bypass access rules for unlink on the requested object
3516         :raise UserError: if the record is default property for other records
3517
3518         """
3519         if not ids:
3520             return True
3521         if isinstance(ids, (int, long)):
3522             ids = [ids]
3523
3524         result_store = self._store_get_values(cr, uid, ids, self._fields.keys(), context)
3525
3526         # for recomputing new-style fields
3527         recs = self.browse(cr, uid, ids, context)
3528         recs.modified(self._fields)
3529
3530         self._check_concurrency(cr, ids, context)
3531
3532         self.check_access_rights(cr, uid, 'unlink')
3533
3534         ir_property = self.pool.get('ir.property')
3535
3536         # Check if the records are used as default properties.
3537         domain = [('res_id', '=', False),
3538                   ('value_reference', 'in', ['%s,%s' % (self._name, i) for i in ids]),
3539                  ]
3540         if ir_property.search(cr, uid, domain, context=context):
3541             raise except_orm(_('Error'), _('Unable to delete this document because it is used as a default property'))
3542
3543         # Delete the records' properties.
3544         property_ids = ir_property.search(cr, uid, [('res_id', 'in', ['%s,%s' % (self._name, i) for i in ids])], context=context)
3545         ir_property.unlink(cr, uid, property_ids, context=context)
3546
3547         self.delete_workflow(cr, uid, ids, context=context)
3548
3549         self.check_access_rule(cr, uid, ids, 'unlink', context=context)
3550         pool_model_data = self.pool.get('ir.model.data')
3551         ir_values_obj = self.pool.get('ir.values')
3552         ir_attachment_obj = self.pool.get('ir.attachment')
3553         for sub_ids in cr.split_for_in_conditions(ids):
3554             cr.execute('delete from ' + self._table + ' ' \
3555                        'where id IN %s', (sub_ids,))
3556
3557             # Removing the ir_model_data reference if the record being deleted is a record created by xml/csv file,
3558             # as these are not connected with real database foreign keys, and would be dangling references.
3559             # Note: following steps performed as admin to avoid access rights restrictions, and with no context
3560             #       to avoid possible side-effects during admin calls.
3561             # Step 1. Calling unlink of ir_model_data only for the affected IDS
3562             reference_ids = pool_model_data.search(cr, SUPERUSER_ID, [('res_id','in',list(sub_ids)),('model','=',self._name)])
3563             # Step 2. Marching towards the real deletion of referenced records
3564             if reference_ids:
3565                 pool_model_data.unlink(cr, SUPERUSER_ID, reference_ids)
3566
3567             # For the same reason, removing the record relevant to ir_values
3568             ir_value_ids = ir_values_obj.search(cr, uid,
3569                     ['|',('value','in',['%s,%s' % (self._name, sid) for sid in sub_ids]),'&',('res_id','in',list(sub_ids)),('model','=',self._name)],
3570                     context=context)
3571             if ir_value_ids:
3572                 ir_values_obj.unlink(cr, uid, ir_value_ids, context=context)
3573
3574             # For the same reason, removing the record relevant to ir_attachment
3575             # The search is performed with sql as the search method of ir_attachment is overridden to hide attachments of deleted records
3576             cr.execute('select id from ir_attachment where res_model = %s and res_id in %s', (self._name, sub_ids))
3577             ir_attachment_ids = [ir_attachment[0] for ir_attachment in cr.fetchall()]
3578             if ir_attachment_ids:
3579                 ir_attachment_obj.unlink(cr, uid, ir_attachment_ids, context=context)
3580
3581         # invalidate the *whole* cache, since the orm does not handle all
3582         # changes made in the database, like cascading delete!
3583         recs.invalidate_cache()
3584
3585         for order, obj_name, store_ids, fields in result_store:
3586             if obj_name == self._name:
3587                 effective_store_ids = set(store_ids) - set(ids)
3588             else:
3589                 effective_store_ids = store_ids
3590             if effective_store_ids:
3591                 obj = self.pool[obj_name]
3592                 cr.execute('select id from '+obj._table+' where id IN %s', (tuple(effective_store_ids),))
3593                 rids = map(lambda x: x[0], cr.fetchall())
3594                 if rids:
3595                     obj._store_set_values(cr, uid, rids, fields, context)
3596
3597         # recompute new-style fields
3598         recs.recompute()
3599
3600         return True
3601
3602     #
3603     # TODO: Validate
3604     #
3605     @api.multi
3606     def write(self, vals):
3607         """ write(vals)
3608
3609         Updates all records in the current set with the provided values.
3610
3611         :param dict vals: fields to update and the value to set on them e.g::
3612
3613                 {'foo': 1, 'bar': "Qux"}
3614
3615             will set the field ``foo`` to ``1`` and the field ``bar`` to
3616             ``"Qux"`` if those are valid (otherwise it will trigger an error).
3617
3618         :raise AccessError: * if user has no write rights on the requested object
3619                             * if user tries to bypass access rules for write on the requested object
3620         :raise ValidateError: if user tries to enter invalid value for a field that is not in selection
3621         :raise UserError: if a loop would be created in a hierarchy of objects a result of the operation (such as setting an object as its own parent)
3622
3623         .. _openerp/models/relationals/format:
3624
3625         .. note:: Relational fields use a special "commands" format to manipulate their values
3626
3627             This format is a list of command triplets executed sequentially,
3628             possible command triplets are:
3629
3630             ``(0, _, values: dict)``
3631                 links to a new record created from the provided values
3632             ``(1, id, values: dict)``
3633                 updates the already-linked record of id ``id`` with the
3634                 provided ``values``
3635             ``(2, id, _)``
3636                 unlinks and deletes the linked record of id ``id``
3637             ``(3, id, _)``
3638                 unlinks the linked record of id ``id`` without deleting it
3639             ``(4, id, _)``
3640                 links to an existing record of id ``id``
3641             ``(5, _, _)``
3642                 unlinks all records in the relation, equivalent to using
3643                 the command ``3`` on every linked record
3644             ``(6, _, ids)``
3645                 replaces the existing list of linked records by the provoded
3646                 ones, equivalent to using ``5`` then ``4`` for each id in
3647                 ``ids``)
3648
3649             (in command triplets, ``_`` values are ignored and can be
3650             anything, generally ``0`` or ``False``)
3651
3652             Any command can be used on :class:`~openerp.fields.Many2many`,
3653             only ``0``, ``1`` and ``2`` can be used on
3654             :class:`~openerp.fields.One2many`.
3655         """
3656         if not self:
3657             return True
3658
3659         self._check_concurrency(self._ids)
3660         self.check_access_rights('write')
3661
3662         # No user-driven update of these columns
3663         for field in itertools.chain(MAGIC_COLUMNS, ('parent_left', 'parent_right')):
3664             vals.pop(field, None)
3665
3666         # split up fields into old-style and pure new-style ones
3667         old_vals, new_vals, unknown = {}, {}, []
3668         for key, val in vals.iteritems():
3669             field = self._fields.get(key)
3670             if field:
3671                 if field.column or field.inherited:
3672                     old_vals[key] = val
3673                 if field.inverse and not field.inherited:
3674                     new_vals[key] = val
3675             else:
3676                 unknown.append(key)
3677
3678         if unknown:
3679             _logger.warning("%s.write() with unknown fields: %s", self._name, ', '.join(sorted(unknown)))
3680
3681         # write old-style fields with (low-level) method _write
3682         if old_vals:
3683             self._write(old_vals)
3684
3685         # put the values of pure new-style fields into cache, and inverse them
3686         if new_vals:
3687             for record in self:
3688                 record._cache.update(record._convert_to_cache(new_vals, update=True))
3689             for key in new_vals:
3690                 self._fields[key].determine_inverse(self)
3691
3692         return True
3693
3694     def _write(self, cr, user, ids, vals, context=None):
3695         # low-level implementation of write()
3696         if not context:
3697             context = {}
3698
3699         readonly = None
3700         self.check_field_access_rights(cr, user, 'write', vals.keys())
3701         deleted_related = defaultdict(list)
3702         for field in vals.keys():
3703             fobj = None
3704             if field in self._columns:
3705                 fobj = self._columns[field]
3706             elif field in self._inherit_fields:
3707                 fobj = self._inherit_fields[field][2]
3708             if not fobj:
3709                 continue
3710             if fobj._type in ['one2many', 'many2many'] and vals[field]:
3711                 for wtuple in vals[field]:
3712                     if isinstance(wtuple, (tuple, list)) and wtuple[0] == 2:
3713                         deleted_related[fobj._obj].append(wtuple[1])
3714             groups = fobj.write
3715
3716             if groups:
3717                 edit = False
3718                 for group in groups:
3719                     module = group.split(".")[0]
3720                     grp = group.split(".")[1]
3721                     cr.execute("select count(*) from res_groups_users_rel where gid IN (select res_id from ir_model_data where name=%s and module=%s and model=%s) and uid=%s", \
3722                                (grp, module, 'res.groups', user))
3723                     readonly = cr.fetchall()
3724                     if readonly[0][0] >= 1:
3725                         edit = True
3726                         break
3727
3728                 if not edit:
3729                     vals.pop(field)
3730
3731         result = self._store_get_values(cr, user, ids, vals.keys(), context) or []
3732
3733         # for recomputing new-style fields
3734         recs = self.browse(cr, user, ids, context)
3735         modified_fields = list(vals)
3736         if self._log_access:
3737             modified_fields += ['write_date', 'write_uid']
3738         recs.modified(modified_fields)
3739
3740         parents_changed = []
3741         parent_order = self._parent_order or self._order
3742         if self._parent_store and (self._parent_name in vals) and not context.get('defer_parent_store_computation'):
3743             # The parent_left/right computation may take up to
3744             # 5 seconds. No need to recompute the values if the
3745             # parent is the same.
3746             # Note: to respect parent_order, nodes must be processed in
3747             # order, so ``parents_changed`` must be ordered properly.
3748             parent_val = vals[self._parent_name]
3749             if parent_val:
3750                 query = "SELECT id FROM %s WHERE id IN %%s AND (%s != %%s OR %s IS NULL) ORDER BY %s" % \
3751                                 (self._table, self._parent_name, self._parent_name, parent_order)
3752                 cr.execute(query, (tuple(ids), parent_val))
3753             else:
3754                 query = "SELECT id FROM %s WHERE id IN %%s AND (%s IS NOT NULL) ORDER BY %s" % \
3755                                 (self._table, self._parent_name, parent_order)
3756                 cr.execute(query, (tuple(ids),))
3757             parents_changed = map(operator.itemgetter(0), cr.fetchall())
3758
3759         updates = []            # list of (column, expr) or (column, pattern, value)
3760         upd_todo = []
3761         updend = []
3762         direct = []
3763         totranslate = context.get('lang', False) and (context['lang'] != 'en_US')
3764         for field in vals:
3765             ffield = self._fields.get(field)
3766             if ffield and ffield.deprecated:
3767                 _logger.warning('Field %s.%s is deprecated: %s', self._name, field, ffield.deprecated)
3768             if field in self._columns:
3769                 column = self._columns[field]
3770                 if hasattr(column, 'selection') and vals[field]:
3771                     self._check_selection_field_value(cr, user, field, vals[field], context=context)
3772                 if column._classic_write and not hasattr(column, '_fnct_inv'):
3773                     if (not totranslate) or not column.translate:
3774                         updates.append((field, '%s', column._symbol_set[1](vals[field])))
3775                     direct.append(field)
3776                 else:
3777                     upd_todo.append(field)
3778             else:
3779                 updend.append(field)
3780
3781         if self._log_access:
3782             updates.append(('write_uid', '%s', user))
3783             updates.append(('write_date', "(now() at time zone 'UTC')"))
3784             direct.append('write_uid')
3785             direct.append('write_date')
3786
3787         if updates:
3788             self.check_access_rule(cr, user, ids, 'write', context=context)
3789             query = 'UPDATE "%s" SET %s WHERE id IN %%s' % (
3790                 self._table, ','.join('"%s"=%s' % u[:2] for u in updates),
3791             )
3792             params = tuple(u[2] for u in updates if len(u) > 2)
3793             for sub_ids in cr.split_for_in_conditions(ids):
3794                 cr.execute(query, params + (sub_ids,))
3795                 if cr.rowcount != len(sub_ids):
3796                     raise MissingError(_('One of the records you are trying to modify has already been deleted (Document type: %s).') % self._description)
3797
3798             if totranslate:
3799                 # TODO: optimize
3800                 for f in direct:
3801                     if self._columns[f].translate:
3802                         src_trans = self.pool[self._name].read(cr, user, ids, [f])[0][f]
3803                         if not src_trans:
3804                             src_trans = vals[f]
3805                             # Inserting value to DB
3806                             context_wo_lang = dict(context, lang=None)
3807                             self.write(cr, user, ids, {f: vals[f]}, context=context_wo_lang)
3808                         self.pool.get('ir.translation')._set_ids(cr, user, self._name+','+f, 'model', context['lang'], ids, vals[f], src_trans)
3809
3810         # invalidate and mark new-style fields to recompute; do this before
3811         # setting other fields, because it can require the value of computed
3812         # fields, e.g., a one2many checking constraints on records
3813         recs.modified(direct)
3814
3815         # call the 'set' method of fields which are not classic_write
3816         upd_todo.sort(lambda x, y: self._columns[x].priority-self._columns[y].priority)
3817
3818         # default element in context must be removed when call a one2many or many2many
3819         rel_context = context.copy()
3820         for c in context.items():
3821             if c[0].startswith('default_'):
3822                 del rel_context[c[0]]
3823
3824         for field in upd_todo:
3825             for id in ids:
3826                 result += self._columns[field].set(cr, self, id, field, vals[field], user, context=rel_context) or []
3827
3828         # for recomputing new-style fields
3829         recs.modified(upd_todo)
3830
3831         unknown_fields = updend[:]
3832         for table in self._inherits:
3833             col = self._inherits[table]
3834             nids = []
3835             for sub_ids in cr.split_for_in_conditions(ids):
3836                 cr.execute('select distinct "'+col+'" from "'+self._table+'" ' \
3837                            'where id IN %s', (sub_ids,))
3838                 nids.extend([x[0] for x in cr.fetchall()])
3839
3840             v = {}
3841             for val in updend:
3842                 if self._inherit_fields[val][0] == table:
3843                     v[val] = vals[val]
3844                     unknown_fields.remove(val)
3845             if v:
3846                 self.pool[table].write(cr, user, nids, v, context)
3847
3848         if unknown_fields:
3849             _logger.warning(
3850                 'No such field(s) in model %s: %s.',
3851                 self._name, ', '.join(unknown_fields))
3852
3853         # check Python constraints
3854         recs._validate_fields(vals)
3855
3856         # TODO: use _order to set dest at the right position and not first node of parent
3857         # We can't defer parent_store computation because the stored function
3858         # fields that are computer may refer (directly or indirectly) to
3859         # parent_left/right (via a child_of domain)
3860         if parents_changed:
3861             if self.pool._init:
3862                 self.pool._init_parent[self._name] = True
3863             else:
3864                 order = self._parent_order or self._order
3865                 parent_val = vals[self._parent_name]
3866                 if parent_val:
3867                     clause, params = '%s=%%s' % (self._parent_name,), (parent_val,)
3868                 else:
3869                     clause, params = '%s IS NULL' % (self._parent_name,), ()
3870
3871                 for id in parents_changed:
3872                     cr.execute('SELECT parent_left, parent_right FROM %s WHERE id=%%s' % (self._table,), (id,))
3873                     pleft, pright = cr.fetchone()
3874                     distance = pright - pleft + 1
3875
3876                     # Positions of current siblings, to locate proper insertion point;
3877                     # this can _not_ be fetched outside the loop, as it needs to be refreshed
3878                     # after each update, in case several nodes are sequentially inserted one
3879                     # next to the other (i.e computed incrementally)
3880                     cr.execute('SELECT parent_right, id FROM %s WHERE %s ORDER BY %s' % (self._table, clause, parent_order), params)
3881                     parents = cr.fetchall()
3882
3883                     # Find Position of the element
3884                     position = None
3885                     for (parent_pright, parent_id) in parents:
3886                         if parent_id == id:
3887                             break
3888                         position = parent_pright and parent_pright + 1 or 1
3889
3890                     # It's the first node of the parent
3891                     if not position:
3892                         if not parent_val:
3893                             position = 1
3894                         else:
3895                             cr.execute('select parent_left from '+self._table+' where id=%s', (parent_val,))
3896                             position = cr.fetchone()[0] + 1
3897
3898                     if pleft < position <= pright:
3899                         raise except_orm(_('UserError'), _('Recursivity Detected.'))
3900
3901                     if pleft < position:
3902                         cr.execute('update '+self._table+' set parent_left=parent_left+%s where parent_left>=%s', (distance, position))
3903                         cr.execute('update '+self._table+' set parent_right=parent_right+%s where parent_right>=%s', (distance, position))
3904                         cr.execute('update '+self._table+' set parent_left=parent_left+%s, parent_right=parent_right+%s where parent_left>=%s and parent_left<%s', (position-pleft, position-pleft, pleft, pright))
3905                     else:
3906                         cr.execute('update '+self._table+' set parent_left=parent_left+%s where parent_left>=%s', (distance, position))
3907                         cr.execute('update '+self._table+' set parent_right=parent_right+%s where parent_right>=%s', (distance, position))
3908                         cr.execute('update '+self._table+' set parent_left=parent_left-%s, parent_right=parent_right-%s where parent_left>=%s and parent_left<%s', (pleft-position+distance, pleft-position+distance, pleft+distance, pright+distance))
3909                     recs.invalidate_cache(['parent_left', 'parent_right'])
3910
3911         result += self._store_get_values(cr, user, ids, vals.keys(), context)
3912         result.sort()
3913
3914         done = {}
3915         for order, model_name, ids_to_update, fields_to_recompute in result:
3916             key = (model_name, tuple(fields_to_recompute))
3917             done.setdefault(key, {})
3918             # avoid to do several times the same computation
3919             todo = []
3920             for id in ids_to_update:
3921                 if id not in done[key]:
3922                     done[key][id] = True
3923                     if id not in deleted_related[model_name]:
3924                         todo.append(id)
3925             self.pool[model_name]._store_set_values(cr, user, todo, fields_to_recompute, context)
3926
3927         # recompute new-style fields
3928         if context.get('recompute', True):
3929             recs.recompute()
3930
3931         self.step_workflow(cr, user, ids, context=context)
3932         return True
3933
3934     #
3935     # TODO: Should set perm to user.xxx
3936     #
3937     @api.model
3938     @api.returns('self', lambda value: value.id)
3939     def create(self, vals):
3940         """ create(vals) -> record
3941
3942         Creates a new record for the model.
3943
3944         The new record is initialized using the values from ``vals`` and
3945         if necessary those from :meth:`~.default_get`.
3946
3947         :param dict vals:
3948             values for the model's fields, as a dictionary::
3949
3950                 {'field_name': field_value, ...}
3951
3952             see :meth:`~.write` for details
3953         :return: new record created
3954         :raise AccessError: * if user has no create rights on the requested object
3955                             * if user tries to bypass access rules for create on the requested object
3956         :raise ValidateError: if user tries to enter invalid value for a field that is not in selection
3957         :raise UserError: if a loop would be created in a hierarchy of objects a result of the operation (such as setting an object as its own parent)
3958         """
3959         self.check_access_rights('create')
3960
3961         # add missing defaults, and drop fields that may not be set by user
3962         vals = self._add_missing_default_values(vals)
3963         for field in itertools.chain(MAGIC_COLUMNS, ('parent_left', 'parent_right')):
3964             vals.pop(field, None)
3965
3966         # split up fields into old-style and pure new-style ones
3967         old_vals, new_vals, unknown = {}, {}, []
3968         for key, val in vals.iteritems():
3969             field = self._fields.get(key)
3970             if field:
3971                 if field.column or field.inherited:
3972                     old_vals[key] = val
3973                 if field.inverse and not field.inherited:
3974                     new_vals[key] = val
3975             else:
3976                 unknown.append(key)
3977
3978         if unknown:
3979             _logger.warning("%s.create() with unknown fields: %s", self._name, ', '.join(sorted(unknown)))
3980
3981         # create record with old-style fields
3982         record = self.browse(self._create(old_vals))
3983
3984         # put the values of pure new-style fields into cache, and inverse them
3985         record._cache.update(record._convert_to_cache(new_vals))
3986         for key in new_vals:
3987             self._fields[key].determine_inverse(record)
3988
3989         return record
3990
3991     def _create(self, cr, user, vals, context=None):
3992         # low-level implementation of create()
3993         if not context:
3994             context = {}
3995
3996         if self.is_transient():
3997             self._transient_vacuum(cr, user)
3998
3999         tocreate = {}
4000         for v in self._inherits:
4001             if self._inherits[v] not in vals:
4002                 tocreate[v] = {}
4003             else:
4004                 tocreate[v] = {'id': vals[self._inherits[v]]}
4005
4006         updates = [
4007             # list of column assignments defined as tuples like:
4008             #   (column_name, format_string, column_value)
4009             #   (column_name, sql_formula)
4010             # Those tuples will be used by the string formatting for the INSERT
4011             # statement below.
4012             ('id', "nextval('%s')" % self._sequence),
4013         ]
4014
4015         upd_todo = []
4016         unknown_fields = []
4017         for v in vals.keys():
4018             if v in self._inherit_fields and v not in self._columns:
4019                 (table, col, col_detail, original_parent) = self._inherit_fields[v]
4020                 tocreate[table][v] = vals[v]
4021                 del vals[v]
4022             else:
4023                 if (v not in self._inherit_fields) and (v not in self._columns):
4024                     del vals[v]
4025                     unknown_fields.append(v)
4026         if unknown_fields:
4027             _logger.warning(
4028                 'No such field(s) in model %s: %s.',
4029                 self._name, ', '.join(unknown_fields))
4030
4031         for table in tocreate:
4032             if self._inherits[table] in vals:
4033                 del vals[self._inherits[table]]
4034
4035             record_id = tocreate[table].pop('id', None)
4036
4037             if record_id is None or not record_id:
4038                 record_id = self.pool[table].create(cr, user, tocreate[table], context=context)
4039             else:
4040                 self.pool[table].write(cr, user, [record_id], tocreate[table], context=context)
4041
4042             updates.append((self._inherits[table], '%s', record_id))
4043
4044         #Start : Set bool fields to be False if they are not touched(to make search more powerful)
4045         bool_fields = [x for x in self._columns.keys() if self._columns[x]._type=='boolean']
4046
4047         for bool_field in bool_fields:
4048             if bool_field not in vals:
4049                 vals[bool_field] = False
4050         #End
4051         for field in vals.keys():
4052             fobj = None
4053             if field in self._columns:
4054                 fobj = self._columns[field]
4055             else:
4056                 fobj = self._inherit_fields[field][2]
4057             if not fobj:
4058                 continue
4059             groups = fobj.write
4060             if groups:
4061                 edit = False
4062                 for group in groups:
4063                     module = group.split(".")[0]
4064                     grp = group.split(".")[1]
4065                     cr.execute("select count(*) from res_groups_users_rel where gid IN (select res_id from ir_model_data where name='%s' and module='%s' and model='%s') and uid=%s" % \
4066                                (grp, module, 'res.groups', user))
4067                     readonly = cr.fetchall()
4068                     if readonly[0][0] >= 1:
4069                         edit = True
4070                         break
4071                     elif readonly[0][0] == 0:
4072                         edit = False
4073                     else:
4074                         edit = False
4075
4076                 if not edit:
4077                     vals.pop(field)
4078         for field in vals:
4079             current_field = self._columns[field]
4080             if current_field._classic_write:
4081                 updates.append((field, '%s', current_field._symbol_set[1](vals[field])))
4082
4083                 #for the function fields that receive a value, we set them directly in the database
4084                 #(they may be required), but we also need to trigger the _fct_inv()
4085                 if (hasattr(current_field, '_fnct_inv')) and not isinstance(current_field, fields.related):
4086                     #TODO: this way to special case the related fields is really creepy but it shouldn't be changed at
4087                     #one week of the release candidate. It seems the only good way to handle correctly this is to add an
4088                     #attribute to make a field `really readonly´ and thus totally ignored by the create()... otherwise
4089                     #if, for example, the related has a default value (for usability) then the fct_inv is called and it
4090                     #may raise some access rights error. Changing this is a too big change for now, and is thus postponed
4091                     #after the release but, definitively, the behavior shouldn't be different for related and function
4092                     #fields.
4093                     upd_todo.append(field)
4094             else:
4095                 #TODO: this `if´ statement should be removed because there is no good reason to special case the fields
4096                 #related. See the above TODO comment for further explanations.
4097                 if not isinstance(current_field, fields.related):
4098                     upd_todo.append(field)
4099             if field in self._columns \
4100                     and hasattr(current_field, 'selection') \
4101                     and vals[field]:
4102                 self._check_selection_field_value(cr, user, field, vals[field], context=context)
4103         if self._log_access:
4104             updates.append(('create_uid', '%s', user))
4105             updates.append(('write_uid', '%s', user))
4106             updates.append(('create_date', "(now() at time zone 'UTC')"))
4107             updates.append(('write_date', "(now() at time zone 'UTC')"))
4108
4109         # the list of tuples used in this formatting corresponds to
4110         # tuple(field_name, format, value)
4111         # In some case, for example (id, create_date, write_date) we does not
4112         # need to read the third value of the tuple, because the real value is
4113         # encoded in the second value (the format).
4114         cr.execute(
4115             """INSERT INTO "%s" (%s) VALUES(%s) RETURNING id""" % (
4116                 self._table,
4117                 ', '.join('"%s"' % u[0] for u in updates),
4118                 ', '.join(u[1] for u in updates)
4119             ),
4120             tuple([u[2] for u in updates if len(u) > 2])
4121         )
4122
4123         id_new, = cr.fetchone()
4124         recs = self.browse(cr, user, id_new, context)
4125
4126         if self._parent_store and not context.get('defer_parent_store_computation'):
4127             if self.pool._init:
4128                 self.pool._init_parent[self._name] = True
4129             else:
4130                 parent = vals.get(self._parent_name, False)
4131                 if parent:
4132                     cr.execute('select parent_right from '+self._table+' where '+self._parent_name+'=%s order by '+(self._parent_order or self._order), (parent,))
4133                     pleft_old = None
4134                     result_p = cr.fetchall()
4135                     for (pleft,) in result_p:
4136                         if not pleft:
4137                             break
4138                         pleft_old = pleft
4139                     if not pleft_old:
4140                         cr.execute('select parent_left from '+self._table+' where id=%s', (parent,))
4141                         pleft_old = cr.fetchone()[0]
4142                     pleft = pleft_old
4143                 else:
4144                     cr.execute('select max(parent_right) from '+self._table)
4145                     pleft = cr.fetchone()[0] or 0
4146                 cr.execute('update '+self._table+' set parent_left=parent_left+2 where parent_left>%s', (pleft,))
4147                 cr.execute('update '+self._table+' set parent_right=parent_right+2 where parent_right>%s', (pleft,))
4148                 cr.execute('update '+self._table+' set parent_left=%s,parent_right=%s where id=%s', (pleft+1, pleft+2, id_new))
4149                 recs.invalidate_cache(['parent_left', 'parent_right'])
4150
4151         # invalidate and mark new-style fields to recompute; do this before
4152         # setting other fields, because it can require the value of computed
4153         # fields, e.g., a one2many checking constraints on records
4154         recs.modified([u[0] for u in updates])
4155
4156         # call the 'set' method of fields which are not classic_write
4157         upd_todo.sort(lambda x, y: self._columns[x].priority-self._columns[y].priority)
4158
4159         # default element in context must be remove when call a one2many or many2many
4160         rel_context = context.copy()
4161         for c in context.items():
4162             if c[0].startswith('default_'):
4163                 del rel_context[c[0]]
4164
4165         result = []
4166         for field in upd_todo:
4167             result += self._columns[field].set(cr, self, id_new, field, vals[field], user, rel_context) or []
4168
4169         # for recomputing new-style fields
4170         recs.modified(upd_todo)
4171
4172         # check Python constraints
4173         recs._validate_fields(vals)
4174
4175         if context.get('recompute', True):
4176             result += self._store_get_values(cr, user, [id_new],
4177                 list(set(vals.keys() + self._inherits.values())),
4178                 context)
4179             result.sort()
4180             done = []
4181             for order, model_name, ids, fields2 in result:
4182                 if not (model_name, ids, fields2) in done:
4183                     self.pool[model_name]._store_set_values(cr, user, ids, fields2, context)
4184                     done.append((model_name, ids, fields2))
4185             # recompute new-style fields
4186             recs.recompute()
4187
4188         if self._log_create and context.get('recompute', True):
4189             message = self._description + \
4190                 " '" + \
4191                 self.name_get(cr, user, [id_new], context=context)[0][1] + \
4192                 "' " + _("created.")
4193             self.log(cr, user, id_new, message, True, context=context)
4194
4195         self.check_access_rule(cr, user, [id_new], 'create', context=context)
4196         self.create_workflow(cr, user, [id_new], context=context)
4197         return id_new
4198
4199     def _store_get_values(self, cr, uid, ids, fields, context):
4200         """Returns an ordered list of fields.function to call due to
4201            an update operation on ``fields`` of records with ``ids``,
4202            obtained by calling the 'store' triggers of these fields,
4203            as setup by their 'store' attribute.
4204
4205            :return: [(priority, model_name, [record_ids,], [function_fields,])]
4206         """
4207         if fields is None: fields = []
4208         stored_functions = self.pool._store_function.get(self._name, [])
4209
4210         # use indexed names for the details of the stored_functions:
4211         model_name_, func_field_to_compute_, target_ids_func_, trigger_fields_, priority_ = range(5)
4212
4213         # only keep store triggers that should be triggered for the ``fields``
4214         # being written to.
4215         triggers_to_compute = (
4216             f for f in stored_functions
4217             if not f[trigger_fields_] or set(fields).intersection(f[trigger_fields_])
4218         )
4219
4220         to_compute_map = {}
4221         target_id_results = {}
4222         for store_trigger in triggers_to_compute:
4223             target_func_id_ = id(store_trigger[target_ids_func_])
4224             if target_func_id_ not in target_id_results:
4225                 # use admin user for accessing objects having rules defined on store fields
4226                 target_id_results[target_func_id_] = [i for i in store_trigger[target_ids_func_](self, cr, SUPERUSER_ID, ids, context) if i]
4227             target_ids = target_id_results[target_func_id_]
4228
4229             # the compound key must consider the priority and model name
4230             key = (store_trigger[priority_], store_trigger[model_name_])
4231             for target_id in target_ids:
4232                 to_compute_map.setdefault(key, {}).setdefault(target_id,set()).add(tuple(store_trigger))
4233
4234         # Here to_compute_map looks like:
4235         # { (10, 'model_a') : { target_id1: [ (trigger_1_tuple, trigger_2_tuple) ], ... }
4236         #   (20, 'model_a') : { target_id2: [ (trigger_3_tuple, trigger_4_tuple) ], ... }
4237         #   (99, 'model_a') : { target_id1: [ (trigger_5_tuple, trigger_6_tuple) ], ... }
4238         # }
4239
4240         # Now we need to generate the batch function calls list
4241         # call_map =
4242         #   { (10, 'model_a') : [(10, 'model_a', [record_ids,], [function_fields,])] }
4243         call_map = {}
4244         for ((priority,model), id_map) in to_compute_map.iteritems():
4245             trigger_ids_maps = {}
4246             # function_ids_maps =
4247             #   { (function_1_tuple, function_2_tuple) : [target_id1, target_id2, ..] }
4248             for target_id, triggers in id_map.iteritems():
4249                 trigger_ids_maps.setdefault(tuple(triggers), []).append(target_id)
4250             for triggers, target_ids in trigger_ids_maps.iteritems():
4251                 call_map.setdefault((priority,model),[]).append((priority, model, target_ids,
4252                                                                  [t[func_field_to_compute_] for t in triggers]))
4253         result = []
4254         if call_map:
4255             result = reduce(operator.add, (call_map[k] for k in sorted(call_map)))
4256         return result
4257
4258     def _store_set_values(self, cr, uid, ids, fields, context):
4259         """Calls the fields.function's "implementation function" for all ``fields``, on records with ``ids`` (taking care of
4260            respecting ``multi`` attributes), and stores the resulting values in the database directly."""
4261         if not ids:
4262             return True
4263         field_flag = False
4264         field_dict = {}
4265         if self._log_access:
4266             cr.execute('select id,write_date from '+self._table+' where id IN %s', (tuple(ids),))
4267             res = cr.fetchall()
4268             for r in res:
4269                 if r[1]:
4270                     field_dict.setdefault(r[0], [])
4271                     res_date = time.strptime((r[1])[:19], '%Y-%m-%d %H:%M:%S')
4272                     write_date = datetime.datetime.fromtimestamp(time.mktime(res_date))
4273                     for i in self.pool._store_function.get(self._name, []):
4274                         if i[5]:
4275                             up_write_date = write_date + datetime.timedelta(hours=i[5])
4276                             if datetime.datetime.now() < up_write_date:
4277                                 if i[1] in fields:
4278                                     field_dict[r[0]].append(i[1])
4279                                     if not field_flag:
4280                                         field_flag = True
4281         todo = {}
4282         keys = []
4283         for f in fields:
4284             if self._columns[f]._multi not in keys:
4285                 keys.append(self._columns[f]._multi)
4286             todo.setdefault(self._columns[f]._multi, [])
4287             todo[self._columns[f]._multi].append(f)
4288         for key in keys:
4289             val = todo[key]
4290             if key:
4291                 # use admin user for accessing objects having rules defined on store fields
4292                 result = self._columns[val[0]].get(cr, self, ids, val, SUPERUSER_ID, context=context)
4293                 for id, value in result.items():
4294                     if field_flag:
4295                         for f in value.keys():
4296                             if f in field_dict[id]:
4297                                 value.pop(f)
4298                     updates = []        # list of (column, pattern, value)
4299                     for v in value:
4300                         if v not in val:
4301                             continue
4302                         column = self._columns[v]
4303                         if column._type == 'many2one':
4304                             try:
4305                                 value[v] = value[v][0]
4306                             except:
4307                                 pass
4308                         updates.append((v, '%s', column._symbol_set[1](value[v])))
4309                     if updates:
4310                         query = 'UPDATE "%s" SET %s WHERE id = %%s' % (
4311                             self._table, ','.join('"%s"=%s' % u[:2] for u in updates),
4312                         )
4313                         params = tuple(u[2] for u in updates)
4314                         cr.execute(query, params + (id,))
4315
4316             else:
4317                 for f in val:
4318                     column = self._columns[f]
4319                     # use admin user for accessing objects having rules defined on store fields
4320                     result = column.get(cr, self, ids, f, SUPERUSER_ID, context=context)
4321                     for r in result.keys():
4322                         if field_flag:
4323                             if r in field_dict.keys():
4324                                 if f in field_dict[r]:
4325                                     result.pop(r)
4326                     for id, value in result.items():
4327                         if column._type == 'many2one':
4328                             try:
4329                                 value = value[0]
4330                             except:
4331                                 pass
4332                         query = 'UPDATE "%s" SET "%s"=%%s WHERE id = %%s' % (
4333                             self._table, f,
4334                         )
4335                         cr.execute(query, (column._symbol_set[1](value), id))
4336
4337         # invalidate and mark new-style fields to recompute
4338         self.browse(cr, uid, ids, context).modified(fields)
4339
4340         return True
4341
4342     # TODO: ameliorer avec NULL
4343     def _where_calc(self, cr, user, domain, active_test=True, context=None):
4344         """Computes the WHERE clause needed to implement an OpenERP domain.
4345         :param domain: the domain to compute
4346         :type domain: list
4347         :param active_test: whether the default filtering of records with ``active``
4348                             field set to ``False`` should be applied.
4349         :return: the query expressing the given domain as provided in domain
4350         :rtype: osv.query.Query
4351         """
4352         if not context:
4353             context = {}
4354         domain = domain[:]
4355         # if the object has a field named 'active', filter out all inactive
4356         # records unless they were explicitely asked for
4357         if 'active' in self._fields and active_test and context.get('active_test', True):
4358             if domain:
4359                 # the item[0] trick below works for domain items and '&'/'|'/'!'
4360                 # operators too
4361                 if not any(item[0] == 'active' for item in domain):
4362                     domain.insert(0, ('active', '=', 1))
4363             else:
4364                 domain = [('active', '=', 1)]
4365
4366         if domain:
4367             e = expression.expression(cr, user, domain, self, context)
4368             tables = e.get_tables()
4369             where_clause, where_params = e.to_sql()
4370             where_clause = where_clause and [where_clause] or []
4371         else:
4372             where_clause, where_params, tables = [], [], ['"%s"' % self._table]
4373
4374         return Query(tables, where_clause, where_params)
4375
4376     def _check_qorder(self, word):
4377         if not regex_order.match(word):
4378             raise except_orm(_('AccessError'), _('Invalid "order" specified. A valid "order" specification is a comma-separated list of valid field names (optionally followed by asc/desc for the direction)'))
4379         return True
4380
4381     def _apply_ir_rules(self, cr, uid, query, mode='read', context=None):
4382         """Add what's missing in ``query`` to implement all appropriate ir.rules
4383           (using the ``model_name``'s rules or the current model's rules if ``model_name`` is None)
4384
4385            :param query: the current query object
4386         """
4387         if uid == SUPERUSER_ID:
4388             return
4389
4390         def apply_rule(added_clause, added_params, added_tables, parent_model=None):
4391             """ :param parent_model: name of the parent model, if the added
4392                     clause comes from a parent model
4393             """
4394             if added_clause:
4395                 if parent_model:
4396                     # as inherited rules are being applied, we need to add the missing JOIN
4397                     # to reach the parent table (if it was not JOINed yet in the query)
4398                     parent_alias = self._inherits_join_add(self, parent_model, query)
4399                     # inherited rules are applied on the external table -> need to get the alias and replace
4400                     parent_table = self.pool[parent_model]._table
4401                     added_clause = [clause.replace('"%s"' % parent_table, '"%s"' % parent_alias) for clause in added_clause]
4402                     # change references to parent_table to parent_alias, because we now use the alias to refer to the table
4403                     new_tables = []
4404                     for table in added_tables:
4405                         # table is just a table name -> switch to the full alias
4406                         if table == '"%s"' % parent_table:
4407                             new_tables.append('"%s" as "%s"' % (parent_table, parent_alias))
4408                         # table is already a full statement -> replace reference to the table to its alias, is correct with the way aliases are generated
4409                         else:
4410                             new_tables.append(table.replace('"%s"' % parent_table, '"%s"' % parent_alias))
4411                     added_tables = new_tables
4412                 query.where_clause += added_clause
4413                 query.where_clause_params += added_params
4414                 for table in added_tables:
4415                     if table not in query.tables:
4416                         query.tables.append(table)
4417                 return True
4418             return False
4419
4420         # apply main rules on the object
4421         rule_obj = self.pool.get('ir.rule')
4422         rule_where_clause, rule_where_clause_params, rule_tables = rule_obj.domain_get(cr, uid, self._name, mode, context=context)
4423         apply_rule(rule_where_clause, rule_where_clause_params, rule_tables)
4424
4425         # apply ir.rules from the parents (through _inherits)
4426         for inherited_model in self._inherits:
4427             rule_where_clause, rule_where_clause_params, rule_tables = rule_obj.domain_get(cr, uid, inherited_model, mode, context=context)
4428             apply_rule(rule_where_clause, rule_where_clause_params, rule_tables,
4429                         parent_model=inherited_model)
4430
4431     def _generate_m2o_order_by(self, order_field, query):
4432         """
4433         Add possibly missing JOIN to ``query`` and generate the ORDER BY clause for m2o fields,
4434         either native m2o fields or function/related fields that are stored, including
4435         intermediate JOINs for inheritance if required.
4436
4437         :return: the qualified field name to use in an ORDER BY clause to sort by ``order_field``
4438         """
4439         if order_field not in self._columns and order_field in self._inherit_fields:
4440             # also add missing joins for reaching the table containing the m2o field
4441             qualified_field = self._inherits_join_calc(order_field, query)
4442             order_field_column = self._inherit_fields[order_field][2]
4443         else:
4444             qualified_field = '"%s"."%s"' % (self._table, order_field)
4445             order_field_column = self._columns[order_field]
4446
4447         assert order_field_column._type == 'many2one', 'Invalid field passed to _generate_m2o_order_by()'
4448         if not order_field_column._classic_write and not getattr(order_field_column, 'store', False):
4449             _logger.debug("Many2one function/related fields must be stored " \
4450                 "to be used as ordering fields! Ignoring sorting for %s.%s",
4451                 self._name, order_field)
4452             return
4453
4454         # figure out the applicable order_by for the m2o
4455         dest_model = self.pool[order_field_column._obj]
4456         m2o_order = dest_model._order
4457         if not regex_order.match(m2o_order):
4458             # _order is complex, can't use it here, so we default to _rec_name
4459             m2o_order = dest_model._rec_name
4460         else:
4461             # extract the field names, to be able to qualify them and add desc/asc
4462             m2o_order_list = []
4463             for order_part in m2o_order.split(","):
4464                 m2o_order_list.append(order_part.strip().split(" ", 1)[0].strip())
4465             m2o_order = m2o_order_list
4466
4467         # Join the dest m2o table if it's not joined yet. We use [LEFT] OUTER join here
4468         # as we don't want to exclude results that have NULL values for the m2o
4469         src_table, src_field = qualified_field.replace('"', '').split('.', 1)
4470         dst_alias, dst_alias_statement = query.add_join((src_table, dest_model._table, src_field, 'id', src_field), implicit=False, outer=True)
4471         qualify = lambda field: '"%s"."%s"' % (dst_alias, field)
4472         return map(qualify, m2o_order) if isinstance(m2o_order, list) else qualify(m2o_order)
4473
4474     def _generate_order_by(self, order_spec, query):
4475         """
4476         Attempt to consruct an appropriate ORDER BY clause based on order_spec, which must be
4477         a comma-separated list of valid field names, optionally followed by an ASC or DESC direction.
4478
4479         :raise" except_orm in case order_spec is malformed
4480         """
4481         order_by_clause = ''
4482         order_spec = order_spec or self._order
4483         if order_spec:
4484             order_by_elements = []
4485             self._check_qorder(order_spec)
4486             for order_part in order_spec.split(','):
4487                 order_split = order_part.strip().split(' ')
4488                 order_field = order_split[0].strip()
4489                 order_direction = order_split[1].strip() if len(order_split) == 2 else ''
4490                 order_column = None
4491                 inner_clause = None
4492                 if order_field == 'id':
4493                     order_by_elements.append('"%s"."%s" %s' % (self._table, order_field, order_direction))
4494                 elif order_field in self._columns:
4495                     order_column = self._columns[order_field]
4496                     if order_column._classic_read:
4497                         inner_clause = '"%s"."%s"' % (self._table, order_field)
4498                     elif order_column._type == 'many2one':
4499                         inner_clause = self._generate_m2o_order_by(order_field, query)
4500                     else:
4501                         continue  # ignore non-readable or "non-joinable" fields
4502                 elif order_field in self._inherit_fields:
4503                     parent_obj = self.pool[self._inherit_fields[order_field][3]]
4504                     order_column = parent_obj._columns[order_field]
4505                     if order_column._classic_read:
4506                         inner_clause = self._inherits_join_calc(order_field, query)
4507                     elif order_column._type == 'many2one':
4508                         inner_clause = self._generate_m2o_order_by(order_field, query)
4509                     else:
4510                         continue  # ignore non-readable or "non-joinable" fields
4511                 else:
4512                     raise ValueError( _("Sorting field %s not found on model %s") %( order_field, self._name))
4513                 if order_column and order_column._type == 'boolean':
4514                     inner_clause = "COALESCE(%s, false)" % inner_clause
4515                 if inner_clause:
4516                     if isinstance(inner_clause, list):
4517                         for clause in inner_clause:
4518                             order_by_elements.append("%s %s" % (clause, order_direction))
4519                     else:
4520                         order_by_elements.append("%s %s" % (inner_clause, order_direction))
4521             if order_by_elements:
4522                 order_by_clause = ",".join(order_by_elements)
4523
4524         return order_by_clause and (' ORDER BY %s ' % order_by_clause) or ''
4525
4526     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
4527         """
4528         Private implementation of search() method, allowing specifying the uid to use for the access right check.
4529         This is useful for example when filling in the selection list for a drop-down and avoiding access rights errors,
4530         by specifying ``access_rights_uid=1`` to bypass access rights check, but not ir.rules!
4531         This is ok at the security level because this method is private and not callable through XML-RPC.
4532
4533         :param access_rights_uid: optional user ID to use when checking access rights
4534                                   (not for ir.rules, this is only for ir.model.access)
4535         """
4536         if context is None:
4537             context = {}
4538         self.check_access_rights(cr, access_rights_uid or user, 'read')
4539
4540         # For transient models, restrict acces to the current user, except for the super-user
4541         if self.is_transient() and self._log_access and user != SUPERUSER_ID:
4542             args = expression.AND(([('create_uid', '=', user)], args or []))
4543
4544         query = self._where_calc(cr, user, args, context=context)
4545         self._apply_ir_rules(cr, user, query, 'read', context=context)
4546         order_by = self._generate_order_by(order, query)
4547         from_clause, where_clause, where_clause_params = query.get_sql()
4548
4549         where_str = where_clause and (" WHERE %s" % where_clause) or ''
4550
4551         if count:
4552             # Ignore order, limit and offset when just counting, they don't make sense and could
4553             # hurt performance
4554             query_str = 'SELECT count(1) FROM ' + from_clause + where_str
4555             cr.execute(query_str, where_clause_params)
4556             res = cr.fetchone()
4557             return res[0]
4558
4559         limit_str = limit and ' limit %d' % limit or ''
4560         offset_str = offset and ' offset %d' % offset or ''
4561         query_str = 'SELECT "%s".id FROM ' % self._table + from_clause + where_str + order_by + limit_str + offset_str
4562         cr.execute(query_str, where_clause_params)
4563         res = cr.fetchall()
4564
4565         # TDE note: with auto_join, we could have several lines about the same result
4566         # i.e. a lead with several unread messages; we uniquify the result using
4567         # a fast way to do it while preserving order (http://www.peterbe.com/plog/uniqifiers-benchmark)
4568         def _uniquify_list(seq):
4569             seen = set()
4570             return [x for x in seq if x not in seen and not seen.add(x)]
4571
4572         return _uniquify_list([x[0] for x in res])
4573
4574     # returns the different values ever entered for one field
4575     # this is used, for example, in the client when the user hits enter on
4576     # a char field
4577     def distinct_field_get(self, cr, uid, field, value, args=None, offset=0, limit=None):
4578         if not args:
4579             args = []
4580         if field in self._inherit_fields:
4581             return self.pool[self._inherit_fields[field][0]].distinct_field_get(cr, uid, field, value, args, offset, limit)
4582         else:
4583             return self._columns[field].search(cr, self, args, field, value, offset, limit, uid)
4584
4585     def copy_data(self, cr, uid, id, default=None, context=None):
4586         """
4587         Copy given record's data with all its fields values
4588
4589         :param cr: database cursor
4590         :param uid: current user id
4591         :param id: id of the record to copy
4592         :param default: field values to override in the original values of the copied record
4593         :type default: dictionary
4594         :param context: context arguments, like lang, time zone
4595         :type context: dictionary
4596         :return: dictionary containing all the field values
4597         """
4598
4599         if context is None:
4600             context = {}
4601
4602         # avoid recursion through already copied records in case of circular relationship
4603         seen_map = context.setdefault('__copy_data_seen', {})
4604         if id in seen_map.setdefault(self._name, []):
4605             return
4606         seen_map[self._name].append(id)
4607
4608         if default is None:
4609             default = {}
4610         if 'state' not in default:
4611             if 'state' in self._defaults:
4612                 if callable(self._defaults['state']):
4613                     default['state'] = self._defaults['state'](self, cr, uid, context)
4614                 else:
4615                     default['state'] = self._defaults['state']
4616
4617         # build a black list of fields that should not be copied
4618         blacklist = set(MAGIC_COLUMNS + ['parent_left', 'parent_right'])
4619         whitelist = set(name for name, field in self._fields.iteritems() if not field.inherited)
4620
4621         def blacklist_given_fields(obj):
4622             # blacklist the fields that are given by inheritance
4623             for other, field_to_other in obj._inherits.items():
4624                 blacklist.add(field_to_other)
4625                 if field_to_other in default:
4626                     # all the fields of 'other' are given by the record: default[field_to_other],
4627                     # except the ones redefined in self
4628                     blacklist.update(set(self.pool[other]._fields) - whitelist)
4629                 else:
4630                     blacklist_given_fields(self.pool[other])
4631             # blacklist deprecated fields
4632             for name, field in obj._fields.iteritems():
4633                 if field.deprecated:
4634                     blacklist.add(name)
4635
4636         blacklist_given_fields(self)
4637
4638
4639         fields_to_copy = dict((f,fi) for f, fi in self._fields.iteritems()
4640                                      if fi.copy
4641                                      if f not in default
4642                                      if f not in blacklist)
4643
4644         data = self.read(cr, uid, [id], fields_to_copy.keys(), context=context)
4645         if data:
4646             data = data[0]
4647         else:
4648             raise IndexError( _("Record #%d of %s not found, cannot copy!") %( id, self._name))
4649
4650         res = dict(default)
4651         for f, field in fields_to_copy.iteritems():
4652             if field.type == 'many2one':
4653                 res[f] = data[f] and data[f][0]
4654             elif field.type == 'one2many':
4655                 other = self.pool[field.comodel_name]
4656                 # duplicate following the order of the ids because we'll rely on
4657                 # it later for copying translations in copy_translation()!
4658                 lines = [other.copy_data(cr, uid, line_id, context=context) for line_id in sorted(data[f])]
4659                 # the lines are duplicated using the wrong (old) parent, but then
4660                 # are reassigned to the correct one thanks to the (0, 0, ...)
4661                 res[f] = [(0, 0, line) for line in lines if line]
4662             elif field.type == 'many2many':
4663                 res[f] = [(6, 0, data[f])]
4664             else:
4665                 res[f] = data[f]
4666
4667         return res
4668
4669     def copy_translations(self, cr, uid, old_id, new_id, context=None):
4670         if context is None:
4671             context = {}
4672
4673         # avoid recursion through already copied records in case of circular relationship
4674         seen_map = context.setdefault('__copy_translations_seen',{})
4675         if old_id in seen_map.setdefault(self._name,[]):
4676             return
4677         seen_map[self._name].append(old_id)
4678
4679         trans_obj = self.pool.get('ir.translation')
4680
4681         for field_name, field in self._fields.iteritems():
4682             # removing the lang to compare untranslated values
4683             context_wo_lang = dict(context, lang=None)
4684             old_record, new_record = self.browse(cr, uid, [old_id, new_id], context=context_wo_lang)
4685             # we must recursively copy the translations for o2o and o2m
4686             if field.type == 'one2many':
4687                 target_obj = self.pool[field.comodel_name]
4688                 # here we rely on the order of the ids to match the translations
4689                 # as foreseen in copy_data()
4690                 old_children = sorted(r.id for r in old_record[field_name])
4691                 new_children = sorted(r.id for r in new_record[field_name])
4692                 for (old_child, new_child) in zip(old_children, new_children):
4693                     target_obj.copy_translations(cr, uid, old_child, new_child, context=context)
4694             # and for translatable fields we keep them for copy
4695             elif getattr(field, 'translate', False):
4696                 if field_name in self._columns:
4697                     trans_name = self._name + "," + field_name
4698                     target_id = new_id
4699                     source_id = old_id
4700                 elif field_name in self._inherit_fields:
4701                     trans_name = self._inherit_fields[field_name][0] + "," + field_name
4702                     # get the id of the parent record to set the translation
4703                     inherit_field_name = self._inherit_fields[field_name][1]
4704                     target_id = new_record[inherit_field_name].id
4705                     source_id = old_record[inherit_field_name].id
4706                 else:
4707                     continue
4708
4709                 trans_ids = trans_obj.search(cr, uid, [
4710                         ('name', '=', trans_name),
4711                         ('res_id', '=', source_id)
4712                 ])
4713                 user_lang = context.get('lang')
4714                 for record in trans_obj.read(cr, uid, trans_ids, context=context):
4715                     del record['id']
4716                     # remove source to avoid triggering _set_src
4717                     del record['source']
4718                     record.update({'res_id': target_id})
4719                     if user_lang and user_lang == record['lang']:
4720                         # 'source' to force the call to _set_src
4721                         # 'value' needed if value is changed in copy(), want to see the new_value
4722                         record['source'] = old_record[field_name]
4723                         record['value'] = new_record[field_name]
4724                     trans_obj.create(cr, uid, record, context=context)
4725
4726     @api.returns('self', lambda value: value.id)
4727     def copy(self, cr, uid, id, default=None, context=None):
4728         """ copy(default=None)
4729
4730         Duplicate record with given id updating it with default values
4731
4732         :param dict default: dictionary of field values to override in the
4733                original values of the copied record, e.g: ``{'field_name': overriden_value, ...}``
4734         :returns: new record
4735
4736         """
4737         if context is None:
4738             context = {}
4739         context = context.copy()
4740         data = self.copy_data(cr, uid, id, default, context)
4741         new_id = self.create(cr, uid, data, context)
4742         self.copy_translations(cr, uid, id, new_id, context)
4743         return new_id
4744
4745     @api.multi
4746     @api.returns('self')
4747     def exists(self):
4748         """  exists() -> records
4749
4750         Returns the subset of records in `self` that exist, and marks deleted
4751         records as such in cache. It can be used as a test on records::
4752
4753             if record.exists():
4754                 ...
4755
4756         By convention, new records are returned as existing.
4757         """
4758         ids = filter(None, self._ids)           # ids to check in database
4759         if not ids:
4760             return self
4761         query = """SELECT id FROM "%s" WHERE id IN %%s""" % self._table
4762         self._cr.execute(query, (ids,))
4763         ids = ([r[0] for r in self._cr.fetchall()] +    # ids in database
4764                [id for id in self._ids if not id])      # new ids
4765         existing = self.browse(ids)
4766         if len(existing) < len(self):
4767             # mark missing records in cache with a failed value
4768             exc = MissingError(_("Record does not exist or has been deleted."))
4769             (self - existing)._cache.update(FailedValue(exc))
4770         return existing
4771
4772     def check_recursion(self, cr, uid, ids, context=None, parent=None):
4773         _logger.warning("You are using deprecated %s.check_recursion(). Please use the '_check_recursion()' instead!" % \
4774                         self._name)
4775         assert parent is None or parent in self._columns or parent in self._inherit_fields,\
4776                     "The 'parent' parameter passed to check_recursion() must be None or a valid field name"
4777         return self._check_recursion(cr, uid, ids, context, parent)
4778
4779     def _check_recursion(self, cr, uid, ids, context=None, parent=None):
4780         """
4781         Verifies that there is no loop in a hierarchical structure of records,
4782         by following the parent relationship using the **parent** field until a loop
4783         is detected or until a top-level record is found.
4784
4785         :param cr: database cursor
4786         :param uid: current user id
4787         :param ids: list of ids of records to check
4788         :param parent: optional parent field name (default: ``self._parent_name = parent_id``)
4789         :return: **True** if the operation can proceed safely, or **False** if an infinite loop is detected.
4790         """
4791         if not parent:
4792             parent = self._parent_name
4793
4794         # must ignore 'active' flag, ir.rules, etc. => direct SQL query
4795         query = 'SELECT "%s" FROM "%s" WHERE id = %%s' % (parent, self._table)
4796         for id in ids:
4797             current_id = id
4798             while current_id is not None:
4799                 cr.execute(query, (current_id,))
4800                 result = cr.fetchone()
4801                 current_id = result[0] if result else None
4802                 if current_id == id:
4803                     return False
4804         return True
4805
4806     def _check_m2m_recursion(self, cr, uid, ids, field_name):
4807         """
4808         Verifies that there is no loop in a hierarchical structure of records,
4809         by following the parent relationship using the **parent** field until a loop
4810         is detected or until a top-level record is found.
4811
4812         :param cr: database cursor
4813         :param uid: current user id
4814         :param ids: list of ids of records to check
4815         :param field_name: field to check
4816         :return: **True** if the operation can proceed safely, or **False** if an infinite loop is detected.
4817         """
4818
4819         field = self._fields.get(field_name)
4820         if not (field and field.type == 'many2many' and
4821                 field.comodel_name == self._name and field.store):
4822             # field must be a many2many on itself
4823             raise ValueError('invalid field_name: %r' % (field_name,))
4824
4825         query = 'SELECT distinct "%s" FROM "%s" WHERE "%s" IN %%s' % \
4826                     (field.column2, field.relation, field.column1)
4827         ids_parent = ids[:]
4828         while ids_parent:
4829             ids_parent2 = []
4830             for i in range(0, len(ids_parent), cr.IN_MAX):
4831                 j = i + cr.IN_MAX
4832                 sub_ids_parent = ids_parent[i:j]
4833                 cr.execute(query, (tuple(sub_ids_parent),))
4834                 ids_parent2.extend(filter(None, map(lambda x: x[0], cr.fetchall())))
4835             ids_parent = ids_parent2
4836             for i in ids_parent:
4837                 if i in ids:
4838                     return False
4839         return True
4840
4841     def _get_external_ids(self, cr, uid, ids, *args, **kwargs):
4842         """Retrieve the External ID(s) of any database record.
4843
4844         **Synopsis**: ``_get_xml_ids(cr, uid, ids) -> { 'id': ['module.xml_id'] }``
4845
4846         :return: map of ids to the list of their fully qualified External IDs
4847                  in the form ``module.key``, or an empty list when there's no External
4848                  ID for a record, e.g.::
4849
4850                      { 'id': ['module.ext_id', 'module.ext_id_bis'],
4851                        'id2': [] }
4852         """
4853         ir_model_data = self.pool.get('ir.model.data')
4854         data_ids = ir_model_data.search(cr, uid, [('model', '=', self._name), ('res_id', 'in', ids)])
4855         data_results = ir_model_data.read(cr, uid, data_ids, ['module', 'name', 'res_id'])
4856         result = {}
4857         for id in ids:
4858             # can't use dict.fromkeys() as the list would be shared!
4859             result[id] = []
4860         for record in data_results:
4861             result[record['res_id']].append('%(module)s.%(name)s' % record)
4862         return result
4863
4864     def get_external_id(self, cr, uid, ids, *args, **kwargs):
4865         """Retrieve the External ID of any database record, if there
4866         is one. This method works as a possible implementation
4867         for a function field, to be able to add it to any
4868         model object easily, referencing it as ``Model.get_external_id``.
4869
4870         When multiple External IDs exist for a record, only one
4871         of them is returned (randomly).
4872
4873         :return: map of ids to their fully qualified XML ID,
4874                  defaulting to an empty string when there's none
4875                  (to be usable as a function field),
4876                  e.g.::
4877
4878                      { 'id': 'module.ext_id',
4879                        'id2': '' }
4880         """
4881         results = self._get_xml_ids(cr, uid, ids)
4882         for k, v in results.iteritems():
4883             if results[k]:
4884                 results[k] = v[0]
4885             else:
4886                 results[k] = ''
4887         return results
4888
4889     # backwards compatibility
4890     get_xml_id = get_external_id
4891     _get_xml_ids = _get_external_ids
4892
4893     def print_report(self, cr, uid, ids, name, data, context=None):
4894         """
4895         Render the report `name` for the given IDs. The report must be defined
4896         for this model, not another.
4897         """
4898         report = self.pool['ir.actions.report.xml']._lookup_report(cr, name)
4899         assert self._name == report.table
4900         return report.create(cr, uid, ids, data, context)
4901
4902     # Transience
4903     @classmethod
4904     def is_transient(cls):
4905         """ Return whether the model is transient.
4906
4907         See :class:`TransientModel`.
4908
4909         """
4910         return cls._transient
4911
4912     def _transient_clean_rows_older_than(self, cr, seconds):
4913         assert self._transient, "Model %s is not transient, it cannot be vacuumed!" % self._name
4914         # Never delete rows used in last 5 minutes
4915         seconds = max(seconds, 300)
4916         query = ("SELECT id FROM " + self._table + " WHERE"
4917             " COALESCE(write_date, create_date, (now() at time zone 'UTC'))::timestamp"
4918             " < ((now() at time zone 'UTC') - interval %s)")
4919         cr.execute(query, ("%s seconds" % seconds,))
4920         ids = [x[0] for x in cr.fetchall()]
4921         self.unlink(cr, SUPERUSER_ID, ids)
4922
4923     def _transient_clean_old_rows(self, cr, max_count):
4924         # Check how many rows we have in the table
4925         cr.execute("SELECT count(*) AS row_count FROM " + self._table)
4926         res = cr.fetchall()
4927         if res[0][0] <= max_count:
4928             return  # max not reached, nothing to do
4929         self._transient_clean_rows_older_than(cr, 300)
4930
4931     def _transient_vacuum(self, cr, uid, force=False):
4932         """Clean the transient records.
4933
4934         This unlinks old records from the transient model tables whenever the
4935         "_transient_max_count" or "_max_age" conditions (if any) are reached.
4936         Actual cleaning will happen only once every "_transient_check_time" calls.
4937         This means this method can be called frequently called (e.g. whenever
4938         a new record is created).
4939         Example with both max_hours and max_count active:
4940         Suppose max_hours = 0.2 (e.g. 12 minutes), max_count = 20, there are 55 rows in the
4941         table, 10 created/changed in the last 5 minutes, an additional 12 created/changed between
4942         5 and 10 minutes ago, the rest created/changed more then 12 minutes ago.
4943         - age based vacuum will leave the 22 rows created/changed in the last 12 minutes
4944         - count based vacuum will wipe out another 12 rows. Not just 2, otherwise each addition
4945           would immediately cause the maximum to be reached again.
4946         - the 10 rows that have been created/changed the last 5 minutes will NOT be deleted
4947         """
4948         assert self._transient, "Model %s is not transient, it cannot be vacuumed!" % self._name
4949         _transient_check_time = 20          # arbitrary limit on vacuum executions
4950         self._transient_check_count += 1
4951         if not force and (self._transient_check_count < _transient_check_time):
4952             return True  # no vacuum cleaning this time
4953         self._transient_check_count = 0
4954
4955         # Age-based expiration
4956         if self._transient_max_hours:
4957             self._transient_clean_rows_older_than(cr, self._transient_max_hours * 60 * 60)
4958
4959         # Count-based expiration
4960         if self._transient_max_count:
4961             self._transient_clean_old_rows(cr, self._transient_max_count)
4962
4963         return True
4964
4965     def resolve_2many_commands(self, cr, uid, field_name, commands, fields=None, context=None):
4966         """ Serializes one2many and many2many commands into record dictionaries
4967             (as if all the records came from the database via a read()).  This
4968             method is aimed at onchange methods on one2many and many2many fields.
4969
4970             Because commands might be creation commands, not all record dicts
4971             will contain an ``id`` field.  Commands matching an existing record
4972             will have an ``id``.
4973
4974             :param field_name: name of the one2many or many2many field matching the commands
4975             :type field_name: str
4976             :param commands: one2many or many2many commands to execute on ``field_name``
4977             :type commands: list((int|False, int|False, dict|False))
4978             :param fields: list of fields to read from the database, when applicable
4979             :type fields: list(str)
4980             :returns: records in a shape similar to that returned by ``read()``
4981                 (except records may be missing the ``id`` field if they don't exist in db)
4982             :rtype: list(dict)
4983         """
4984         result = []             # result (list of dict)
4985         record_ids = []         # ids of records to read
4986         updates = {}            # {id: dict} of updates on particular records
4987
4988         for command in commands or []:
4989             if not isinstance(command, (list, tuple)):
4990                 record_ids.append(command)
4991             elif command[0] == 0:
4992                 result.append(command[2])
4993             elif command[0] == 1:
4994                 record_ids.append(command[1])
4995                 updates.setdefault(command[1], {}).update(command[2])
4996             elif command[0] in (2, 3):
4997                 record_ids = [id for id in record_ids if id != command[1]]
4998             elif command[0] == 4:
4999                 record_ids.append(command[1])
5000             elif command[0] == 5:
5001                 result, record_ids = [], []
5002             elif command[0] == 6:
5003                 result, record_ids = [], list(command[2])
5004
5005         # read the records and apply the updates
5006         other_model = self.pool[self._fields[field_name].comodel_name]
5007         for record in other_model.read(cr, uid, record_ids, fields=fields, context=context):
5008             record.update(updates.get(record['id'], {}))
5009             result.append(record)
5010
5011         return result
5012
5013     # for backward compatibility
5014     resolve_o2m_commands_to_record_dicts = resolve_2many_commands
5015
5016     def search_read(self, cr, uid, domain=None, fields=None, offset=0, limit=None, order=None, context=None):
5017         """
5018         Performs a ``search()`` followed by a ``read()``.
5019
5020         :param cr: database cursor
5021         :param user: current user id
5022         :param domain: Search domain, see ``args`` parameter in ``search()``. Defaults to an empty domain that will match all records.
5023         :param fields: List of fields to read, see ``fields`` parameter in ``read()``. Defaults to all fields.
5024         :param offset: Number of records to skip, see ``offset`` parameter in ``search()``. Defaults to 0.
5025         :param limit: Maximum number of records to return, see ``limit`` parameter in ``search()``. Defaults to no limit.
5026         :param order: Columns to sort result, see ``order`` parameter in ``search()``. Defaults to no sort.
5027         :param context: context arguments.
5028         :return: List of dictionaries containing the asked fields.
5029         :rtype: List of dictionaries.
5030
5031         """
5032         record_ids = self.search(cr, uid, domain or [], offset=offset, limit=limit, order=order, context=context)
5033         if not record_ids:
5034             return []
5035
5036         if fields and fields == ['id']:
5037             # shortcut read if we only want the ids
5038             return [{'id': id} for id in record_ids]
5039
5040         # read() ignores active_test, but it would forward it to any downstream search call
5041         # (e.g. for x2m or function fields), and this is not the desired behavior, the flag
5042         # was presumably only meant for the main search().
5043         # TODO: Move this to read() directly?
5044         read_ctx = dict(context or {})
5045         read_ctx.pop('active_test', None)
5046
5047         result = self.read(cr, uid, record_ids, fields, context=read_ctx)
5048         if len(result) <= 1:
5049             return result
5050
5051         # reorder read
5052         index = dict((r['id'], r) for r in result)
5053         return [index[x] for x in record_ids if x in index]
5054
5055     def _register_hook(self, cr):
5056         """ stuff to do right after the registry is built """
5057         pass
5058
5059     @classmethod
5060     def _patch_method(cls, name, method):
5061         """ Monkey-patch a method for all instances of this model. This replaces
5062             the method called `name` by `method` in the given class.
5063             The original method is then accessible via ``method.origin``, and it
5064             can be restored with :meth:`~._revert_method`.
5065
5066             Example::
5067
5068                 @api.multi
5069                 def do_write(self, values):
5070                     # do stuff, and call the original method
5071                     return do_write.origin(self, values)
5072
5073                 # patch method write of model
5074                 model._patch_method('write', do_write)
5075
5076                 # this will call do_write
5077                 records = model.search([...])
5078                 records.write(...)
5079
5080                 # restore the original method
5081                 model._revert_method('write')
5082         """
5083         origin = getattr(cls, name)
5084         method.origin = origin
5085         # propagate decorators from origin to method, and apply api decorator
5086         wrapped = api.guess(api.propagate(origin, method))
5087         wrapped.origin = origin
5088         setattr(cls, name, wrapped)
5089
5090     @classmethod
5091     def _revert_method(cls, name):
5092         """ Revert the original method called `name` in the given class.
5093             See :meth:`~._patch_method`.
5094         """
5095         method = getattr(cls, name)
5096         setattr(cls, name, method.origin)
5097
5098     #
5099     # Instance creation
5100     #
5101     # An instance represents an ordered collection of records in a given
5102     # execution environment. The instance object refers to the environment, and
5103     # the records themselves are represented by their cache dictionary. The 'id'
5104     # of each record is found in its corresponding cache dictionary.
5105     #
5106     # This design has the following advantages:
5107     #  - cache access is direct and thus fast;
5108     #  - one can consider records without an 'id' (see new records);
5109     #  - the global cache is only an index to "resolve" a record 'id'.
5110     #
5111
5112     @classmethod
5113     def _browse(cls, env, ids):
5114         """ Create an instance attached to `env`; `ids` is a tuple of record
5115             ids.
5116         """
5117         records = object.__new__(cls)
5118         records.env = env
5119         records._ids = ids
5120         env.prefetch[cls._name].update(ids)
5121         return records
5122
5123     @api.v7
5124     def browse(self, cr, uid, arg=None, context=None):
5125         ids = _normalize_ids(arg)
5126         #assert all(isinstance(id, IdType) for id in ids), "Browsing invalid ids: %s" % ids
5127         return self._browse(Environment(cr, uid, context or {}), ids)
5128
5129     @api.v8
5130     def browse(self, arg=None):
5131         """ browse([ids]) -> records
5132
5133         Returns a recordset for the ids provided as parameter in the current
5134         environment.
5135
5136         Can take no ids, a single id or a sequence of ids.
5137         """
5138         ids = _normalize_ids(arg)
5139         #assert all(isinstance(id, IdType) for id in ids), "Browsing invalid ids: %s" % ids
5140         return self._browse(self.env, ids)
5141
5142     #
5143     # Internal properties, for manipulating the instance's implementation
5144     #
5145
5146     @property
5147     def ids(self):
5148         """ List of actual record ids in this recordset (ignores placeholder
5149         ids for records to create)
5150         """
5151         return filter(None, list(self._ids))
5152
5153     # backward-compatibility with former browse records
5154     _cr = property(lambda self: self.env.cr)
5155     _uid = property(lambda self: self.env.uid)
5156     _context = property(lambda self: self.env.context)
5157
5158     #
5159     # Conversion methods
5160     #
5161
5162     def ensure_one(self):
5163         """ Verifies that the current recorset holds a single record. Raises
5164         an exception otherwise.
5165         """
5166         if len(self) == 1:
5167             return self
5168         raise except_orm("ValueError", "Expected singleton: %s" % self)
5169
5170     def with_env(self, env):
5171         """ Returns a new version of this recordset attached to the provided
5172         environment
5173
5174         :type env: :class:`~openerp.api.Environment`
5175         """
5176         return self._browse(env, self._ids)
5177
5178     def sudo(self, user=SUPERUSER_ID):
5179         """ sudo([user=SUPERUSER])
5180
5181         Returns a new version of this recordset attached to the provided
5182         user.
5183         """
5184         return self.with_env(self.env(user=user))
5185
5186     def with_context(self, *args, **kwargs):
5187         """ with_context([context][, **overrides]) -> records
5188
5189         Returns a new version of this recordset attached to an extended
5190         context.
5191
5192         The extended context is either the provided ``context`` in which
5193         ``overrides`` are merged or the *current* context in which
5194         ``overrides`` are merged e.g.::
5195
5196             # current context is {'key1': True}
5197             r2 = records.with_context({}, key2=True)
5198             # -> r2._context is {'key2': True}
5199             r2 = records.with_context(key2=True)
5200             # -> r2._context is {'key1': True, 'key2': True}
5201         """
5202         context = dict(args[0] if args else self._context, **kwargs)
5203         return self.with_env(self.env(context=context))
5204
5205     def _convert_to_cache(self, values, update=False, validate=True):
5206         """ Convert the `values` dictionary into cached values.
5207
5208             :param update: whether the conversion is made for updating `self`;
5209                 this is necessary for interpreting the commands of *2many fields
5210             :param validate: whether values must be checked
5211         """
5212         fields = self._fields
5213         target = self if update else self.browse()
5214         return {
5215             name: fields[name].convert_to_cache(value, target, validate=validate)
5216             for name, value in values.iteritems()
5217             if name in fields
5218         }
5219
5220     def _convert_to_write(self, values):
5221         """ Convert the `values` dictionary into the format of :meth:`write`. """
5222         fields = self._fields
5223         result = {}
5224         for name, value in values.iteritems():
5225             if name in fields:
5226                 value = fields[name].convert_to_write(value)
5227                 if not isinstance(value, NewId):
5228                     result[name] = value
5229         return result
5230
5231     #
5232     # Record traversal and update
5233     #
5234
5235     def _mapped_func(self, func):
5236         """ Apply function `func` on all records in `self`, and return the
5237             result as a list or a recordset (if `func` returns recordsets).
5238         """
5239         if self:
5240             vals = [func(rec) for rec in self]
5241             return reduce(operator.or_, vals) if isinstance(vals[0], BaseModel) else vals
5242         else:
5243             vals = func(self)
5244             return vals if isinstance(vals, BaseModel) else []
5245
5246     def mapped(self, func):
5247         """ Apply `func` on all records in `self`, and return the result as a
5248             list or a recordset (if `func` return recordsets). In the latter
5249             case, the order of the returned recordset is arbritrary.
5250
5251             :param func: a function or a dot-separated sequence of field names
5252         """
5253         if isinstance(func, basestring):
5254             recs = self
5255             for name in func.split('.'):
5256                 recs = recs._mapped_func(operator.itemgetter(name))
5257             return recs
5258         else:
5259             return self._mapped_func(func)
5260
5261     def _mapped_cache(self, name_seq):
5262         """ Same as `~.mapped`, but `name_seq` is a dot-separated sequence of
5263             field names, and only cached values are used.
5264         """
5265         recs = self
5266         for name in name_seq.split('.'):
5267             field = recs._fields[name]
5268             null = field.null(self.env)
5269             recs = recs.mapped(lambda rec: rec._cache.get(field, null))
5270         return recs
5271
5272     def filtered(self, func):
5273         """ Select the records in `self` such that `func(rec)` is true, and
5274             return them as a recordset.
5275
5276             :param func: a function or a dot-separated sequence of field names
5277         """
5278         if isinstance(func, basestring):
5279             name = func
5280             func = lambda rec: filter(None, rec.mapped(name))
5281         return self.browse([rec.id for rec in self if func(rec)])
5282
5283     def sorted(self, key=None, reverse=False):
5284         """ Return the recordset `self` ordered by `key`.
5285
5286             :param key: either a function of one argument that returns a
5287                 comparison key for each record, or ``None``, in which case
5288                 records are ordered according the default model's order
5289
5290             :param reverse: if ``True``, return the result in reverse order
5291         """
5292         if key is None:
5293             recs = self.search([('id', 'in', self.ids)])
5294             return self.browse(reversed(recs._ids)) if reverse else recs
5295         else:
5296             return self.browse(map(int, sorted(self, key=key, reverse=reverse)))
5297
5298     def update(self, values):
5299         """ Update record `self[0]` with `values`. """
5300         for name, value in values.iteritems():
5301             self[name] = value
5302
5303     #
5304     # New records - represent records that do not exist in the database yet;
5305     # they are used to perform onchanges.
5306     #
5307
5308     @api.model
5309     def new(self, values={}):
5310         """ new([values]) -> record
5311
5312         Return a new record instance attached to the current environment and
5313         initialized with the provided ``value``. The record is *not* created
5314         in database, it only exists in memory.
5315         """
5316         record = self.browse([NewId()])
5317         record._cache.update(record._convert_to_cache(values, update=True))
5318
5319         if record.env.in_onchange:
5320             # The cache update does not set inverse fields, so do it manually.
5321             # This is useful for computing a function field on secondary
5322             # records, if that field depends on the main record.
5323             for name in values:
5324                 field = self._fields.get(name)
5325                 if field:
5326                     for invf in field.inverse_fields:
5327                         invf._update(record[name], record)
5328
5329         return record
5330
5331     #
5332     # Dirty flag, to mark records modified (in draft mode)
5333     #
5334
5335     @property
5336     def _dirty(self):
5337         """ Return whether any record in `self` is dirty. """
5338         dirty = self.env.dirty
5339         return any(record in dirty for record in self)
5340
5341     @_dirty.setter
5342     def _dirty(self, value):
5343         """ Mark the records in `self` as dirty. """
5344         if value:
5345             map(self.env.dirty.add, self)
5346         else:
5347             map(self.env.dirty.discard, self)
5348
5349     #
5350     # "Dunder" methods
5351     #
5352
5353     def __nonzero__(self):
5354         """ Test whether `self` is nonempty. """
5355         return bool(getattr(self, '_ids', True))
5356
5357     def __len__(self):
5358         """ Return the size of `self`. """
5359         return len(self._ids)
5360
5361     def __iter__(self):
5362         """ Return an iterator over `self`. """
5363         for id in self._ids:
5364             yield self._browse(self.env, (id,))
5365
5366     def __contains__(self, item):
5367         """ Test whether `item` (record or field name) is an element of `self`.
5368             In the first case, the test is fully equivalent to::
5369
5370                 any(item == record for record in self)
5371         """
5372         if isinstance(item, BaseModel) and self._name == item._name:
5373             return len(item) == 1 and item.id in self._ids
5374         elif isinstance(item, basestring):
5375             return item in self._fields
5376         else:
5377             raise except_orm("ValueError", "Mixing apples and oranges: %s in %s" % (item, self))
5378
5379     def __add__(self, other):
5380         """ Return the concatenation of two recordsets. """
5381         if not isinstance(other, BaseModel) or self._name != other._name:
5382             raise except_orm("ValueError", "Mixing apples and oranges: %s + %s" % (self, other))
5383         return self.browse(self._ids + other._ids)
5384
5385     def __sub__(self, other):
5386         """ Return the recordset of all the records in `self` that are not in `other`. """
5387         if not isinstance(other, BaseModel) or self._name != other._name:
5388             raise except_orm("ValueError", "Mixing apples and oranges: %s - %s" % (self, other))
5389         other_ids = set(other._ids)
5390         return self.browse([id for id in self._ids if id not in other_ids])
5391
5392     def __and__(self, other):
5393         """ Return the intersection of two recordsets.
5394             Note that recordset order is not preserved.
5395         """
5396         if not isinstance(other, BaseModel) or self._name != other._name:
5397             raise except_orm("ValueError", "Mixing apples and oranges: %s & %s" % (self, other))
5398         return self.browse(set(self._ids) & set(other._ids))
5399
5400     def __or__(self, other):
5401         """ Return the union of two recordsets.
5402             Note that recordset order is not preserved.
5403         """
5404         if not isinstance(other, BaseModel) or self._name != other._name:
5405             raise except_orm("ValueError", "Mixing apples and oranges: %s | %s" % (self, other))
5406         return self.browse(set(self._ids) | set(other._ids))
5407
5408     def __eq__(self, other):
5409         """ Test whether two recordsets are equivalent (up to reordering). """
5410         if not isinstance(other, BaseModel):
5411             if other:
5412                 _logger.warning("Comparing apples and oranges: %s == %s", self, other)
5413             return False
5414         return self._name == other._name and set(self._ids) == set(other._ids)
5415
5416     def __ne__(self, other):
5417         return not self == other
5418
5419     def __lt__(self, other):
5420         if not isinstance(other, BaseModel) or self._name != other._name:
5421             raise except_orm("ValueError", "Mixing apples and oranges: %s < %s" % (self, other))
5422         return set(self._ids) < set(other._ids)
5423
5424     def __le__(self, other):
5425         if not isinstance(other, BaseModel) or self._name != other._name:
5426             raise except_orm("ValueError", "Mixing apples and oranges: %s <= %s" % (self, other))
5427         return set(self._ids) <= set(other._ids)
5428
5429     def __gt__(self, other):
5430         if not isinstance(other, BaseModel) or self._name != other._name:
5431             raise except_orm("ValueError", "Mixing apples and oranges: %s > %s" % (self, other))
5432         return set(self._ids) > set(other._ids)
5433
5434     def __ge__(self, other):
5435         if not isinstance(other, BaseModel) or self._name != other._name:
5436             raise except_orm("ValueError", "Mixing apples and oranges: %s >= %s" % (self, other))
5437         return set(self._ids) >= set(other._ids)
5438
5439     def __int__(self):
5440         return self.id
5441
5442     def __str__(self):
5443         return "%s%s" % (self._name, getattr(self, '_ids', ""))
5444
5445     def __unicode__(self):
5446         return unicode(str(self))
5447
5448     __repr__ = __str__
5449
5450     def __hash__(self):
5451         if hasattr(self, '_ids'):
5452             return hash((self._name, frozenset(self._ids)))
5453         else:
5454             return hash(self._name)
5455
5456     def __getitem__(self, key):
5457         """ If `key` is an integer or a slice, return the corresponding record
5458             selection as an instance (attached to `self.env`).
5459             Otherwise read the field `key` of the first record in `self`.
5460
5461             Examples::
5462
5463                 inst = model.search(dom)    # inst is a recordset
5464                 r4 = inst[3]                # fourth record in inst
5465                 rs = inst[10:20]            # subset of inst
5466                 nm = rs['name']             # name of first record in inst
5467         """
5468         if isinstance(key, basestring):
5469             # important: one must call the field's getter
5470             return self._fields[key].__get__(self, type(self))
5471         elif isinstance(key, slice):
5472             return self._browse(self.env, self._ids[key])
5473         else:
5474             return self._browse(self.env, (self._ids[key],))
5475
5476     def __setitem__(self, key, value):
5477         """ Assign the field `key` to `value` in record `self`. """
5478         # important: one must call the field's setter
5479         return self._fields[key].__set__(self, value)
5480
5481     #
5482     # Cache and recomputation management
5483     #
5484
5485     @lazy_property
5486     def _cache(self):
5487         """ Return the cache of `self`, mapping field names to values. """
5488         return RecordCache(self)
5489
5490     @api.model
5491     def _in_cache_without(self, field):
5492         """ Make sure `self` is present in cache (for prefetching), and return
5493             the records of model `self` in cache that have no value for `field`
5494             (:class:`Field` instance).
5495         """
5496         env = self.env
5497         prefetch_ids = env.prefetch[self._name]
5498         prefetch_ids.update(self._ids)
5499         ids = filter(None, prefetch_ids - set(env.cache[field]))
5500         return self.browse(ids)
5501
5502     @api.model
5503     def refresh(self):
5504         """ Clear the records cache.
5505
5506             .. deprecated:: 8.0
5507                 The record cache is automatically invalidated.
5508         """
5509         self.invalidate_cache()
5510
5511     @api.model
5512     def invalidate_cache(self, fnames=None, ids=None):
5513         """ Invalidate the record caches after some records have been modified.
5514             If both `fnames` and `ids` are ``None``, the whole cache is cleared.
5515
5516             :param fnames: the list of modified fields, or ``None`` for all fields
5517             :param ids: the list of modified record ids, or ``None`` for all
5518         """
5519         if fnames is None:
5520             if ids is None:
5521                 return self.env.invalidate_all()
5522             fields = self._fields.values()
5523         else:
5524             fields = map(self._fields.__getitem__, fnames)
5525
5526         # invalidate fields and inverse fields, too
5527         spec = [(f, ids) for f in fields] + \
5528                [(invf, None) for f in fields for invf in f.inverse_fields]
5529         self.env.invalidate(spec)
5530
5531     @api.multi
5532     def modified(self, fnames):
5533         """ Notify that fields have been modified on `self`. This invalidates
5534             the cache, and prepares the recomputation of stored function fields
5535             (new-style fields only).
5536
5537             :param fnames: iterable of field names that have been modified on
5538                 records `self`
5539         """
5540         # each field knows what to invalidate and recompute
5541         spec = []
5542         for fname in fnames:
5543             spec += self._fields[fname].modified(self)
5544
5545         cached_fields = {
5546             field
5547             for env in self.env.all
5548             for field in env.cache
5549         }
5550         # invalidate non-stored fields.function which are currently cached
5551         spec += [(f, None) for f in self.pool.pure_function_fields
5552                  if f in cached_fields]
5553
5554         self.env.invalidate(spec)
5555
5556     def _recompute_check(self, field):
5557         """ If `field` must be recomputed on some record in `self`, return the
5558             corresponding records that must be recomputed.
5559         """
5560         return self.env.check_todo(field, self)
5561
5562     def _recompute_todo(self, field):
5563         """ Mark `field` to be recomputed. """
5564         self.env.add_todo(field, self)
5565
5566     def _recompute_done(self, field):
5567         """ Mark `field` as recomputed. """
5568         self.env.remove_todo(field, self)
5569
5570     @api.model
5571     def recompute(self):
5572         """ Recompute stored function fields. The fields and records to
5573             recompute have been determined by method :meth:`modified`.
5574         """
5575         while self.env.has_todo():
5576             field, recs = self.env.get_todo()
5577             # evaluate the fields to recompute, and save them to database
5578             for rec, rec1 in zip(recs, recs.with_context(recompute=False)):
5579                 try:
5580                     values = rec._convert_to_write({
5581                         f.name: rec[f.name] for f in field.computed_fields
5582                     })
5583                     rec1._write(values)
5584                 except MissingError:
5585                     pass
5586             # mark the computed fields as done
5587             map(recs._recompute_done, field.computed_fields)
5588
5589     #
5590     # Generic onchange method
5591     #
5592
5593     def _has_onchange(self, field, other_fields):
5594         """ Return whether `field` should trigger an onchange event in the
5595             presence of `other_fields`.
5596         """
5597         # test whether self has an onchange method for field, or field is a
5598         # dependency of any field in other_fields
5599         return field.name in self._onchange_methods or \
5600             any(dep in other_fields for dep in field.dependents)
5601
5602     @api.model
5603     def _onchange_spec(self, view_info=None):
5604         """ Return the onchange spec from a view description; if not given, the
5605             result of ``self.fields_view_get()`` is used.
5606         """
5607         result = {}
5608
5609         # for traversing the XML arch and populating result
5610         def process(node, info, prefix):
5611             if node.tag == 'field':
5612                 name = node.attrib['name']
5613                 names = "%s.%s" % (prefix, name) if prefix else name
5614                 if not result.get(names):
5615                     result[names] = node.attrib.get('on_change')
5616                 # traverse the subviews included in relational fields
5617                 for subinfo in info['fields'][name].get('views', {}).itervalues():
5618                     process(etree.fromstring(subinfo['arch']), subinfo, names)
5619             else:
5620                 for child in node:
5621                     process(child, info, prefix)
5622
5623         if view_info is None:
5624             view_info = self.fields_view_get()
5625         process(etree.fromstring(view_info['arch']), view_info, '')
5626         return result
5627
5628     def _onchange_eval(self, field_name, onchange, result):
5629         """ Apply onchange method(s) for field `field_name` with spec `onchange`
5630             on record `self`. Value assignments are applied on `self`, while
5631             domain and warning messages are put in dictionary `result`.
5632         """
5633         onchange = onchange.strip()
5634
5635         # onchange V8
5636         if onchange in ("1", "true"):
5637             for method in self._onchange_methods.get(field_name, ()):
5638                 method_res = method(self)
5639                 if not method_res:
5640                     continue
5641                 if 'domain' in method_res:
5642                     result.setdefault('domain', {}).update(method_res['domain'])
5643                 if 'warning' in method_res:
5644                     result['warning'] = method_res['warning']
5645             return
5646
5647         # onchange V7
5648         match = onchange_v7.match(onchange)
5649         if match:
5650             method, params = match.groups()
5651
5652             # evaluate params -> tuple
5653             global_vars = {'context': self._context, 'uid': self._uid}
5654             if self._context.get('field_parent'):
5655                 class RawRecord(object):
5656                     def __init__(self, record):
5657                         self._record = record
5658                     def __getattr__(self, name):
5659                         field = self._record._fields[name]
5660                         value = self._record[name]
5661                         return field.convert_to_onchange(value)
5662                 record = self[self._context['field_parent']]
5663                 global_vars['parent'] = RawRecord(record)
5664             field_vars = {
5665                 key: self._fields[key].convert_to_onchange(val)
5666                 for key, val in self._cache.iteritems()
5667             }
5668             params = eval("[%s]" % params, global_vars, field_vars)
5669
5670             # call onchange method
5671             args = (self._cr, self._uid, self._origin.ids) + tuple(params)
5672             method_res = getattr(self._model, method)(*args)
5673             if not isinstance(method_res, dict):
5674                 return
5675             if 'value' in method_res:
5676                 method_res['value'].pop('id', None)
5677                 self.update(self._convert_to_cache(method_res['value'], validate=False))
5678             if 'domain' in method_res:
5679                 result.setdefault('domain', {}).update(method_res['domain'])
5680             if 'warning' in method_res:
5681                 result['warning'] = method_res['warning']
5682
5683     @api.multi
5684     def onchange(self, values, field_name, field_onchange):
5685         """ Perform an onchange on the given field.
5686
5687             :param values: dictionary mapping field names to values, giving the
5688                 current state of modification
5689             :param field_name: name of the modified field_name
5690             :param field_onchange: dictionary mapping field names to their
5691                 on_change attribute
5692         """
5693         env = self.env
5694
5695         if field_name and field_name not in self._fields:
5696             return {}
5697
5698         # determine subfields for field.convert_to_write() below
5699         secondary = []
5700         subfields = defaultdict(set)
5701         for dotname in field_onchange:
5702             if '.' in dotname:
5703                 secondary.append(dotname)
5704                 name, subname = dotname.split('.')
5705                 subfields[name].add(subname)
5706
5707         # create a new record with values, and attach `self` to it
5708         with env.do_in_onchange():
5709             record = self.new(values)
5710             values = dict(record._cache)
5711             # attach `self` with a different context (for cache consistency)
5712             record._origin = self.with_context(__onchange=True)
5713
5714         # determine which field should be triggered an onchange
5715         todo = set([field_name]) if field_name else set(values)
5716         done = set()
5717
5718         # dummy assignment: trigger invalidations on the record
5719         for name in todo:
5720             value = record[name]
5721             field = self._fields[name]
5722             if not field_name and field.type == 'many2one' and field.delegate and not value:
5723                 # do not nullify all fields of parent record for new records
5724                 continue
5725             record[name] = value
5726
5727         result = {'value': {}}
5728
5729         while todo:
5730             name = todo.pop()
5731             if name in done:
5732                 continue
5733             done.add(name)
5734
5735             with env.do_in_onchange():
5736                 # apply field-specific onchange methods
5737                 if field_onchange.get(name):
5738                     record._onchange_eval(name, field_onchange[name], result)
5739
5740                 # force re-evaluation of function fields on secondary records
5741                 for field_seq in secondary:
5742                     record.mapped(field_seq)
5743
5744                 # determine which fields have been modified
5745                 for name, oldval in values.iteritems():
5746                     field = self._fields[name]
5747                     newval = record[name]
5748                     if field.type in ('one2many', 'many2many'):
5749                         if newval != oldval or newval._dirty:
5750                             # put new value in result
5751                             result['value'][name] = field.convert_to_write(
5752                                 newval, record._origin, subfields.get(name),
5753                             )
5754                             todo.add(name)
5755                         else:
5756                             # keep result: newval may have been dirty before
5757                             pass
5758                     else:
5759                         if newval != oldval:
5760                             # put new value in result
5761                             result['value'][name] = field.convert_to_write(
5762                                 newval, record._origin, subfields.get(name),
5763                             )
5764                             todo.add(name)
5765                         else:
5766                             # clean up result to not return another value
5767                             result['value'].pop(name, None)
5768
5769         # At the moment, the client does not support updates on a *2many field
5770         # while this one is modified by the user.
5771         if field_name and self._fields[field_name].type in ('one2many', 'many2many'):
5772             result['value'].pop(field_name, None)
5773
5774         return result
5775
5776
5777 class RecordCache(MutableMapping):
5778     """ Implements a proxy dictionary to read/update the cache of a record.
5779         Upon iteration, it looks like a dictionary mapping field names to
5780         values. However, fields may be used as keys as well.
5781     """
5782     def __init__(self, records):
5783         self._recs = records
5784
5785     def contains(self, field):
5786         """ Return whether `records[0]` has a value for `field` in cache. """
5787         if isinstance(field, basestring):
5788             field = self._recs._fields[field]
5789         return self._recs.id in self._recs.env.cache[field]
5790
5791     def __contains__(self, field):
5792         """ Return whether `records[0]` has a regular value for `field` in cache. """
5793         if isinstance(field, basestring):
5794             field = self._recs._fields[field]
5795         dummy = SpecialValue(None)
5796         value = self._recs.env.cache[field].get(self._recs.id, dummy)
5797         return not isinstance(value, SpecialValue)
5798
5799     def __getitem__(self, field):
5800         """ Return the cached value of `field` for `records[0]`. """
5801         if isinstance(field, basestring):
5802             field = self._recs._fields[field]
5803         value = self._recs.env.cache[field][self._recs.id]
5804         return value.get() if isinstance(value, SpecialValue) else value
5805
5806     def __setitem__(self, field, value):
5807         """ Assign the cached value of `field` for all records in `records`. """
5808         if isinstance(field, basestring):
5809             field = self._recs._fields[field]
5810         values = dict.fromkeys(self._recs._ids, value)
5811         self._recs.env.cache[field].update(values)
5812
5813     def update(self, *args, **kwargs):
5814         """ Update the cache of all records in `records`. If the argument is a
5815             `SpecialValue`, update all fields (except "magic" columns).
5816         """
5817         if args and isinstance(args[0], SpecialValue):
5818             values = dict.fromkeys(self._recs._ids, args[0])
5819             for name, field in self._recs._fields.iteritems():
5820                 if name != 'id':
5821                     self._recs.env.cache[field].update(values)
5822         else:
5823             return super(RecordCache, self).update(*args, **kwargs)
5824
5825     def __delitem__(self, field):
5826         """ Remove the cached value of `field` for all `records`. """
5827         if isinstance(field, basestring):
5828             field = self._recs._fields[field]
5829         field_cache = self._recs.env.cache[field]
5830         for id in self._recs._ids:
5831             field_cache.pop(id, None)
5832
5833     def __iter__(self):
5834         """ Iterate over the field names with a regular value in cache. """
5835         cache, id = self._recs.env.cache, self._recs.id
5836         dummy = SpecialValue(None)
5837         for name, field in self._recs._fields.iteritems():
5838             if name != 'id' and not isinstance(cache[field].get(id, dummy), SpecialValue):
5839                 yield name
5840
5841     def __len__(self):
5842         """ Return the number of fields with a regular value in cache. """
5843         return sum(1 for name in self)
5844
5845 class Model(BaseModel):
5846     """Main super-class for regular database-persisted OpenERP models.
5847
5848     OpenERP models are created by inheriting from this class::
5849
5850         class user(Model):
5851             ...
5852
5853     The system will later instantiate the class once per database (on
5854     which the class' module is installed).
5855     """
5856     _auto = True
5857     _register = False # not visible in ORM registry, meant to be python-inherited only
5858     _transient = False # True in a TransientModel
5859
5860 class TransientModel(BaseModel):
5861     """Model super-class for transient records, meant to be temporarily
5862        persisted, and regularly vaccuum-cleaned.
5863
5864        A TransientModel has a simplified access rights management,
5865        all users can create new records, and may only access the
5866        records they created. The super-user has unrestricted access
5867        to all TransientModel records.
5868     """
5869     _auto = True
5870     _register = False # not visible in ORM registry, meant to be python-inherited only
5871     _transient = True
5872
5873 class AbstractModel(BaseModel):
5874     """Abstract Model super-class for creating an abstract class meant to be
5875        inherited by regular models (Models or TransientModels) but not meant to
5876        be usable on its own, or persisted.
5877
5878        Technical note: we don't want to make AbstractModel the super-class of
5879        Model or BaseModel because it would not make sense to put the main
5880        definition of persistence methods such as create() in it, and still we
5881        should be able to override them within an AbstractModel.
5882        """
5883     _auto = False # don't create any database backend for AbstractModels
5884     _register = False # not visible in ORM registry, meant to be python-inherited only
5885     _transient = False
5886
5887 def itemgetter_tuple(items):
5888     """ Fixes itemgetter inconsistency (useful in some cases) of not returning
5889     a tuple if len(items) == 1: always returns an n-tuple where n = len(items)
5890     """
5891     if len(items) == 0:
5892         return lambda a: ()
5893     if len(items) == 1:
5894         return lambda gettable: (gettable[items[0]],)
5895     return operator.itemgetter(*items)
5896
5897 def convert_pgerror_23502(model, fields, info, e):
5898     m = re.match(r'^null value in column "(?P<field>\w+)" violates '
5899                  r'not-null constraint\n',
5900                  str(e))
5901     field_name = m and m.group('field')
5902     if not m or field_name not in fields:
5903         return {'message': unicode(e)}
5904     message = _(u"Missing required value for the field '%s'.") % field_name
5905     field = fields.get(field_name)
5906     if field:
5907         message = _(u"Missing required value for the field '%s' (%s)") % (field['string'], field_name)
5908     return {
5909         'message': message,
5910         'field': field_name,
5911     }
5912
5913 def convert_pgerror_23505(model, fields, info, e):
5914     m = re.match(r'^duplicate key (?P<field>\w+) violates unique constraint',
5915                  str(e))
5916     field_name = m and m.group('field')
5917     if not m or field_name not in fields:
5918         return {'message': unicode(e)}
5919     message = _(u"The value for the field '%s' already exists.") % field_name
5920     field = fields.get(field_name)
5921     if field:
5922         message = _(u"%s This might be '%s' in the current model, or a field "
5923                     u"of the same name in an o2m.") % (message, field['string'])
5924     return {
5925         'message': message,
5926         'field': field_name,
5927     }
5928
5929 PGERROR_TO_OE = defaultdict(
5930     # shape of mapped converters
5931     lambda: (lambda model, fvg, info, pgerror: {'message': unicode(pgerror)}), {
5932     # not_null_violation
5933     '23502': convert_pgerror_23502,
5934     # unique constraint error
5935     '23505': convert_pgerror_23505,
5936 })
5937
5938 def _normalize_ids(arg, atoms={int, long, str, unicode, NewId}):
5939     """ Normalizes the ids argument for ``browse`` (v7 and v8) to a tuple.
5940
5941     Various implementations were tested on the corpus of all browse() calls
5942     performed during a full crawler run (after having installed all website_*
5943     modules) and this one was the most efficient overall.
5944
5945     A possible bit of correctness was sacrificed by not doing any test on
5946     Iterable and just assuming that any non-atomic type was an iterable of
5947     some kind.
5948
5949     :rtype: tuple
5950     """
5951     # much of the corpus is falsy objects (empty list, tuple or set, None)
5952     if not arg:
5953         return ()
5954
5955     # `type in set` is significantly faster (because more restrictive) than
5956     # isinstance(arg, set) or issubclass(type, set); and for new-style classes
5957     # obj.__class__ is equivalent to but faster than type(obj). Not relevant
5958     # (and looks much worse) in most cases, but over millions of calls it
5959     # does have a very minor effect.
5960     if arg.__class__ in atoms:
5961         return arg,
5962
5963     return tuple(arg)
5964
5965 # keep those imports here to avoid dependency cycle errors
5966 from .osv import expression
5967 from .fields import Field, SpecialValue, FailedValue
5968
5969 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: