Example #1
0
    def _get_expression(self, params):
        values = self._get_values_from_params(params.get(self.alias, {}))
        if not values:
            return None

        if len(values) == 1:
            return self.field == values[0]

        if self._conj_operator == QueryFilter.CONJ_AND:
            return Bool.must(*(self.field == v for v in values))
        elif all(map(is_not_none, values)):
            return self.field.in_(values)
        else:
            return Bool.should(*(self.field == v for v in values))
Example #2
0
    def _get_expression(self, params):
        values = params.get(self.alias, {}).get('exact')
        if not values:
            if self.default:
                values = [[self.default]]
        if not values:
            return None

        expressions = []
        for v in values:
            w = v[0]
            filter_value = self.get_value(w)
            if filter_value and not isinstance(filter_value.expr, MatchAll):
                expressions.append(filter_value.expr)

        if not expressions:
            return None

        if self._conj_operator == QueryFilter.CONJ_AND:
            return Bool.must(*expressions)
        else:
            return Bool.should(*expressions)
Example #3
0
    def _get_expression(self, params):
        values = params.get(self.alias, {}).get('exact')
        if not values:
            if self.default:
                values = [[self.default]]
        if not values:
            return None

        expressions = []
        for v in values:
            w = v[0]
            filter_value = self.get_value(w)
            if filter_value and not isinstance(filter_value.expr, MatchAll):
                expressions.append(filter_value.expr)

        if not expressions:
            return None

        if self._conj_operator == QueryFilter.CONJ_AND:
            return Bool.must(*expressions)
        else:
            return Bool.should(*expressions)
Example #4
0
    def _get_filter_expression(self, attr_id: int,
                               values: ParamValues) -> t.Optional[Expression]:
        gte = self._parse_last_value(values, 'gte')
        gte_value = None
        if gte is not None:
            gte_value = merge_attr_value_float(attr_id, gte)

        lte = self._parse_last_value(values, 'lte')
        lte_value = None
        if lte is not None:
            lte_value = merge_attr_value_float(attr_id, lte)

        if gte is not None and lte is not None:
            if gte >= 0.0 and lte >= 0.0:
                return Range(self.field, gte=gte_value, lte=lte_value)
            elif gte < 0.0 and lte < 0.0:
                return Range(self.field, gte=lte_value, lte=gte_value)
            elif gte < 0.0 and lte >= 0:
                return Bool.should(
                    Range(self.field,
                          gte=self._minus_zero(attr_id),
                          lte=gte_value),
                    Range(self.field,
                          gte=self._plus_zero(attr_id),
                          lte=lte_value),
                )
            else:
                return Bool.must(
                    Range(self.field,
                          gte=gte_value,
                          lte=self._plus_inf(attr_id)),
                    Range(self.field,
                          gte=lte_value,
                          lte=self._minus_inf(attr_id)),
                )

        if gte is not None:
            if gte >= 0.0:
                return Range(self.field,
                             gte=gte_value,
                             lte=self._plus_inf(attr_id))
            else:
                return Bool.should(
                    Range(self.field,
                          gte=self._minus_zero(attr_id),
                          lte=gte_value),
                    Range(self.field,
                          gte=self._plus_zero(attr_id),
                          lte=self._plus_inf(attr_id)),
                )

        if lte is not None:
            if lte < 0.0:
                return Range(self.field,
                             gte=lte_value,
                             lte=self._minus_inf(attr_id))
            else:
                return Bool.should(
                    Range(self.field,
                          gte=self._plus_zero(attr_id),
                          lte=lte_value),
                    Range(self.field,
                          gte=self._minus_zero(attr_id),
                          lte=self._minus_inf(attr_id)),
                )

        return None