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