def _apply_agg(self, search_query, params): exclude_tags = {self.qf._name} if self._conj_operator == QueryFilter.CONJ_OR: exclude_tags.add(self.name) filters = self._get_agg_filters( search_query.get_context().iter_post_filters_with_meta(), exclude_tags ) terms_agg = agg.Nested(path=self.path, aggs={ self._filter_key_agg_name: agg.Filter( self.key_expression, aggs={ self._filter_value_agg_name: agg.Terms( self.value_field, instance_mapper=self._instance_mapper, **self._agg_kwargs ) }, **self._agg_kwargs ) }) if filters: aggs = { self._filter_agg_name: agg.Filter( Bool.must(*filters), aggs={self._agg_name: terms_agg} ) } else: aggs = {self._agg_name: terms_agg} return search_query.aggregations(**aggs)
def _apply_agg(self, search_query, params): exclude_tags = {self.qf._name} if self._conj_operator == QueryFilter.CONJ_OR: exclude_tags.add(self.name) filters = self._get_agg_filters( search_query.get_context().iter_post_filters_with_meta(), exclude_tags ) filter_aggs = {} for fv in self._values: filter_aggs[self._make_agg_name(fv.value)] = agg.Filter( fv.expr, **self.agg_kwargs ) if filters: aggs = { self._filter_agg_name: agg.Filter( Bool.must(*filters), aggs=filter_aggs ) } else: aggs = filter_aggs return search_query.aggregations(**aggs)
def _apply_agg(self, search_query, params): filters = self._get_agg_filters( search_query.get_context().iter_post_filters_with_meta(), {self.qf._name, self.name} ) aggs = {} if self._compute_enabled: aggs.update({ self._enabled_agg_name: agg.Filter(self.field != None), }) if self._compute_min_max: stat_aggs = { self._min_agg_name: agg.Min(self.field), self._max_agg_name: agg.Max(self.field), } if filters: aggs.update({ self._filter_agg_name: agg.Filter( Bool.must(*filters), aggs=stat_aggs ) }) else: aggs.update(stat_aggs) return search_query.aggregations(**aggs)
def _apply_agg(self, search_query): exclude_tags = {self.qf._name} if self._conj_operator == QueryFilter.CONJ_OR: exclude_tags.add(self.name) filters = self._get_agg_filters( search_query.get_context().iter_post_filters_with_meta(), exclude_tags ) terms_agg = agg.Nested(path=self.path, aggs={ self._filter_key_agg_name: agg.Filter( self.key_expression, aggs={ self._filter_value_agg_name: agg.Terms( self.value_field, instance_mapper=self._instance_mapper, **self._agg_kwargs ) }, **self._agg_kwargs ) }) if filters: aggs = { self._filter_agg_name: agg.Filter( Bool.must(*filters), aggs={self._agg_name: terms_agg} ) } else: aggs = {self._agg_name: terms_agg} return search_query.aggregations(**aggs)
def _apply_agg(self, search_query): exclude_tags = {self.qf._name} if self._conj_operator == QueryFilter.CONJ_OR: exclude_tags.add(self.name) filters = self._get_agg_filters( search_query.get_context().iter_post_filters_with_meta(), exclude_tags ) filter_aggs = {} for fv in self.values: filter_aggs[self._make_agg_name(fv.value)] = agg.Filter( fv.expr, **self.agg_kwargs ) if filters: aggs = { self._filter_agg_name: agg.Filter( Bool.must(*filters), aggs=filter_aggs ) } else: aggs = filter_aggs return search_query.aggregations(**aggs)
def _apply_agg(self, search_query): filters = self._get_agg_filters( search_query.get_context().iter_post_filters_with_meta(), {self.qf._name, self.name} ) aggs = {} if self._compute_enabled: aggs.update({ self._enabled_agg_name: agg.Filter(self.field != None), # noqa:E711 }) if self._compute_min_max: stat_aggs = { self._min_agg_name: agg.Min(self.field), self._max_agg_name: agg.Max(self.field), } if filters: aggs.update({ self._filter_agg_name: agg.Filter( Bool.must(*filters), aggs=stat_aggs ) }) else: aggs.update(stat_aggs) return search_query.aggregations(**aggs)
def _apply_agg(self, search_query): if self.selected: return search_query agg_filters = search_query.get_context().post_filters return search_query.aggregations( **{ self._agg_name: agg.Filter( Bool.must(*chain(agg_filters, [self._condition]))) })
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)) else: return self.field.in_(values)
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))
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 Nested( path=self.path, query=Bool.must( self.key_expression, self.value_field == values[0] ) ) expressions = [self.key_expression] if self._conj_operator == QueryFilter.CONJ_AND: expressions.extend(self.value_field == v for v in values) else: expressions.append(self.value_field.in_(values)) return Nested( path=self.path, query=Bool.must(*expressions) )
def _apply_filter(self, search_query, params): params = params.get(self.alias) or {} self.from_value = self._get_from_value(params) self.to_value = self._get_to_value(params) if self.from_value is None and self.to_value is None: return search_query expr = Nested( path=self.path, query=Bool.must( self.key_expression, self.value_field.range(gte=self.from_value, lte=self.to_value), ) ) return search_query.post_filter(expr, meta={'tags': {self.name}})
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 Nested( path=self.path, query=Bool.must( self.key_expression, self.value_field == values[0] ) ) expressions = [self.key_expression] if self._conj_operator == QueryFilter.CONJ_AND: expressions.extend([self.value_field == v for v in values]) else: expressions.append(self.value_field.in_(values)) return Nested( path=self.path, query=Bool.must(*expressions) )
def _apply_filter(self, search_query, params): params = params.get(self.alias) or {} self._from_value = self._get_from_value(params) self._to_value = self._get_to_value(params) if self._from_value is None and self._to_value is None: return search_query expr = Nested( path=self.path, query=Bool.must( self.key_expression, self.value_field.range( gte=self._from_value, lte=self._to_value ), ) ) return search_query.post_filter(expr, meta={'tags': {self.name}})
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: filter_value = self.get_value(v) 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)
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)
def _apply_agg(self, search_query): exclude_tags = {self.qf._name} if self._conj_operator == QueryFilter.CONJ_OR: exclude_tags.add(self.name) filters = self._get_agg_filters( search_query.get_context().iter_post_filters_with_meta(), exclude_tags ) additional_filters = self._filters or [] terms_agg = agg.Terms( self.field, instance_mapper=self._instance_mapper, **self._agg_kwargs ) if filters or additional_filters: aggs = { self._filter_agg_name: agg.Filter( Bool.must(*(filters + additional_filters)), aggs={self._agg_name: terms_agg} ) } else: aggs = {self._agg_name: terms_agg} return search_query.aggregations(**aggs)