def _search_parents(self, domain=[], order=None): self._check_parent_field() self.check_access_rights('read') if expression.is_false(self, domain): return [] query = self._where_calc(domain) self._apply_ir_rules(query, 'read') from_clause, where_clause, where_clause_arguments = query.get_sql() parent_where = where_clause and (" WHERE %s" % where_clause) or '' parent_query = 'SELECT "%s".id FROM ' % self._table + from_clause + parent_where no_parent_clause = '"{table}"."{field}" IS NULL'.format( table=self._table, field=self._parent_name) no_access_clause = '"{table}"."{field}" NOT IN ({query})'.format( table=self._table, field=self._parent_name, query=parent_query) parent_clause = '({0} OR {1})'.format(no_parent_clause, no_access_clause) order_by = self._generate_order_by(order, query) from_clause, where_clause, where_clause_params = query.get_sql() where_str = (where_clause and (" WHERE %s AND %s" % (where_clause, parent_clause)) or (" WHERE %s" % parent_clause)) query_str = 'SELECT "%s".id FROM ' % self._table + from_clause + where_str + order_by complete_where_clause_params = where_clause_params + where_clause_arguments self._cr.execute(query_str, complete_where_clause_params) return utils.uniquify_list([x[0] for x in self._cr.fetchall()])
def _search_messages(self, args, limit=None, order=None): """ This a shortcut function for mail.message model only """ if expression.is_false(self, args): # optimization: no need to query, as no record satisfies the domain return [] # the flush must be done before the _where_calc(), # as the latter can do some selects self._flush_search(args, order=order) query = self._where_calc(args) self._apply_ir_rules(query, "read") order_by = self._generate_order_by(order, query) from_clause, where_clause, where_clause_params = query.get_sql() where_str = where_clause and (" WHERE %s" % where_clause) or "" limit_str = limit and " limit %d" % limit or "" query_str = ('SELECT "mail_message".id,' ' "mail_message".model,' ' "mail_message".res_id FROM ' + from_clause + where_str + order_by + limit_str) # noqa E8103 self._cr.execute(query_str, where_clause_params) res = self._cr.fetchall() return res
def test_force_storage_domain(self): force_storage_domain = expression.AND([ self.model._get_storage_domain("db"), [ "&", "|", ("res_field", "=", False), ("res_field", "!=", False), ("type", "=", "binary"), ], ]) self.assertFalse(expression.is_false(self.model, force_storage_domain))
def execute_orm_search(self): """ Through the standard logic of model._search() method """ offset = self.offset or 0 limit = self.limit or None order = self.order or None _model = self._model if _model._abstract: raise ValidationError( _('Current type of model not supported! ' '"%s" is abstract model!' % (self.model, ))) try: args = eval(self.domain_expr) except Exception as ex: _logger.debug(ex) raise ValidationError( _('Got "expression" fault during domain evaluation!')) if expression.is_false(_model, args): raise ValidationError( _('Got "expression" fault during domain parsing!')) query = _model._where_calc(args) _model._apply_ir_rules(query, 'read') order_by = _model._generate_order_by(order, query) from_clause, where_clause, where_clause_params = query.get_sql() where_str = where_clause and (' WHERE %s' % where_clause) or '' if self.count: query_str = 'SELECT count(1) FROM ' + from_clause + where_str self._cr.execute(query_str, where_clause_params) res_id = self._cr.fetchone() fetch_result = res_id[0] else: limit_str = limit and ' limit %d' % limit or '' offset_str = offset and ' offset %d' % offset or '' _format = from_clause + where_str + order_by + limit_str + offset_str query_str = 'SELECT "%s".id FROM ' % _model._table + _format self._cr.execute(query_str, where_clause_params) result = self._cr.fetchall() res_ids = [rec[0] for rec in result] fetch_result = str(_model.browse(res_ids)) self.write({ 'full_query': self._compile_search_query(), 'sql_text': self._cr._obj.query.decode(), 'fetch_result': fetch_result, }) return self.raise_form()
def _search_parents(self, domain=False, offset=0, limit=None, order=None, count=False): if not domain: domain = [] self._check_parent_field() self.check_access_rights("read") if expression.is_false(self, domain): return [] query = self._where_calc(domain) self._apply_ir_rules(query, "read") from_clause, where_clause, where_clause_arguments = query.get_sql() parent_where = where_clause and (" WHERE %s" % where_clause) or "" parent_query = 'SELECT "%s".id FROM ' % self._table + from_clause + parent_where no_parent_clause = '"{table}"."{field}" IS NULL'.format( table=self._table, field=self._parent_name) no_access_clause = '"{table}"."{field}" NOT IN ({query})'.format( table=self._table, field=self._parent_name, query=parent_query) parent_clause = "({} OR {})".format(no_parent_clause, no_access_clause) order_by = self._generate_order_by(order, query) from_clause, where_clause, where_clause_params = query.get_sql() where_str = (where_clause and (" WHERE {} AND {}".format(where_clause, parent_clause)) or (" WHERE %s" % parent_clause)) if count: # pylint: disable=sql-injection query_str = "SELECT count(1) FROM " + from_clause + where_str self._cr.execute(query_str, where_clause_params) return self._cr.fetchone()[0] limit_str = limit and " limit %s" or "" offset_str = offset and " offset %s" or "" query_str = ('SELECT "%s".id FROM ' % (self._table) + from_clause + where_str + order_by + limit_str + offset_str) complete_where_clause_params = where_clause_params + where_clause_arguments if limit: complete_where_clause_params.append(limit) if offset: complete_where_clause_params.append(offset) # pylint: disable=sql-injection self._cr.execute(query_str, complete_where_clause_params) return list({x[0] for x in self._cr.fetchall()})
def _search_parents(self, domain=[], offset=0, limit=None, order=None, count=False): self._check_parent_field() self.check_access_rights("read") if expression.is_false(self, domain): return 0 if count else [] self._flush_search(domain, fields=[self._parent_name], order=order) query = self._where_calc(domain) self._apply_ir_rules(query, "read") from_clause, where_clause, where_clause_arguments = query.get_sql() parent_where = where_clause and ( " WHERE {}".format(where_clause)) or "" parent_query = ('SELECT "{}".id FROM '.format(self._table) + from_clause + parent_where) no_parent_clause = '"{table}"."{field}" IS NULL'.format( table=self._table, field=self._parent_name) no_access_clause = '"{table}"."{field}" NOT IN ({query})'.format( table=self._table, field=self._parent_name, query=parent_query) parent_clause = "({} OR {})".format(no_parent_clause, no_access_clause) order_by = self._generate_order_by(order, query) from_clause, where_clause, where_clause_params = query.get_sql() where_str = (where_clause and (" WHERE {} AND {}".format(where_clause, parent_clause)) or (" WHERE {}".format(parent_clause))) if count: query_str = "SELECT count(1) FROM " + from_clause + where_str self.env.cr.execute(query_str, where_clause_params + where_clause_arguments) return self.env.cr.fetchone()[0] limit_str = limit and " limit %d" % limit or "" offset_str = offset and " offset %d" % offset or "" query_str = ('SELECT "{}".id FROM '.format(self._table) + from_clause + where_str + order_by + limit_str + offset_str) self.env.cr.execute(query_str, where_clause_params + where_clause_arguments) return utils.uniquify_list([x[0] for x in self.env.cr.fetchall()])