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 _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
)
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):
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):
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 = 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 _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 _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)