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()])
