def _split_where_expression_and_having_expression(expression: BinaryExpression) -> Tuple[Optional[BinaryExpression],
Optional[BinaryExpression]]:
stack = [expression]
and_expressions = []
while stack:
exp = stack.pop()
if exp is None:
continue
if exp.operator == 'AND':
stack.append(exp.right)
stack.append(exp.left)
continue
and_expressions.append(exp)
where_expressions = []
having_expressions = []
for exp in and_expressions:
if _check_aggregation(exp):
having_expressions.append(exp)
else:
where_expressions.append(exp)
where_expression = None
having_expression = None
if where_expressions:
where_expression = reduce(operator.and_, where_expressions)
if having_expressions:
having_expression = reduce(operator.and_, having_expressions)
return where_expression, having_expression
def filter(self, *expressions, **expression_dict):
self._model_class._check_attrs(expression_dict)
expression_dict = self._model_class._wash_attrs(
expression_dict
)
expressions = list(expressions) + list(
_dict_to_expressions(
self._model_class, expression_dict
)
)
expression = self._expression
if expressions:
_expression = reduce(
operator.and_,
expressions,
)
if expression is not None:
expression &= _expression
else:
expression = _expression
expression, having_expression = _split_where_expression_and_having_expression(expression)
q = self
if expression is not None:
q = q._update(_expression=expression)
if having_expression is not None:
q = q.having(having_expression)
return q
def _get_expression(self, is_having=False, is_on=False):
if is_having:
expressions = self._having_expressions # pragma: no cover
elif is_on:
expressions = self._on_expressions # pragma: no cover
else:
expressions = self._expressions
if expressions:
return reduce(operator.and_, expressions)
def unique_expression(self):
keys = []
if self.__primary_key__:
keys.extend(self.__primary_key__)
elif self.__unique_keys__: # pragma: no cover
keys = self.__unique_keys__[0] # pragma: no cover
if not keys:
return None # pragma: no cover
return reduce(
operator.and_,
map(lambda k: getattr(self.__class__, k) == getattr(self, k),
keys))
def having(self, *having_expressions, **having_expression_dict):
self._model_class._check_attrs(having_expression_dict)
having_expression_dict = self._model_class._wash_attrs(
having_expression_dict
)
having_expressions = (
list(having_expressions) + list(
_dict_to_expressions(
self._model_class, having_expression_dict
)
)
)
q = self
if having_expressions:
having_expression = reduce(operator.and_, having_expressions)
if self._having_expression is not None:
having_expression = self._having_expression & having_expression
q = q._update(_having_expression=having_expression)
return q
def on(self, *on_expressions, **on_expression_dict):
if self._join_chain is None:
raise ORMError('this query does not have a join chain!')
self._model_class._check_attrs(on_expression_dict)
on_expression_dict = self._model_class._wash_attrs(
on_expression_dict
)
on_expressions = list(on_expressions) + list(
_dict_to_expressions(
self._model_class, on_expression_dict
)
)
on_expression = reduce(
operator.and_,
on_expressions
)
join_chain = self._join_chain.clone()
join_chain.on(on_expression)
return self._update(_join_chain=join_chain)
def postBitand(self, node):
return lambda: reduce(operator.and_, (x.factory() for x in node.nodes))
def postBitxor(self, node):
return lambda: reduce(operator.xor, (x.factory() for x in node.nodes))
def postOr(self, node):
return lambda: reduce(operator.or_, (x.factory() for x in node.nodes))
