def _person_query(self):
return PersonQuery(
self._filter,
self._team_id,
self._column_optimizer,
extra_fields=["created_at"],
)
def persons(self, request: Request, **kwargs) -> Response:
cohort: Cohort = self.get_object()
team = self.team
filter = Filter(request=request, team=self.team)
is_csv_request = self.request.accepted_renderer.format == "csv"
if is_csv_request:
filter = filter.with_data({LIMIT: CSV_EXPORT_LIMIT, OFFSET: 0})
elif not filter.limit:
filter = filter.with_data({LIMIT: 100})
query, params = PersonQuery(filter, team.pk, cohort=cohort).get_query()
raw_result = sync_execute(query, params)
actor_ids = [row[0] for row in raw_result]
actors, serialized_actors = get_people(team.pk, actor_ids)
_should_paginate = should_paginate(actors, filter.limit)
next_url = format_query_params_absolute_url(
request, filter.offset +
filter.limit) if _should_paginate else None
previous_url = (format_query_params_absolute_url(
request, filter.offset -
filter.limit) if filter.offset - filter.limit >= 0 else None)
return Response({
"results": serialized_actors,
"next": next_url,
"previous": previous_url
})
def _get_actor_subquery(self) -> Tuple[str, Dict[str, Any]]:
if self.is_aggregating_by_groups:
actor_join_subquery, actor_join_subquery_params = GroupsJoinQuery(
self._filter, self._team.pk,
join_key="funnel_actors.actor_id").get_join_query()
else:
person_query, actor_join_subquery_params = PersonQuery(
self._filter,
self._team.pk,
entity=Entity({
"id":
"person",
"type":
"events",
"properties":
self._filter.correlation_property_values
}),
).get_query()
actor_join_subquery = f"""
JOIN ({person_query}) person
ON person.id = funnel_actors.actor_id
"""
return actor_join_subquery, actor_join_subquery_params
def _person_query(self):
return PersonQuery(
self._filter,
self._team_id,
self._column_optimizer,
extra_fields=self._extra_person_fields,
entity=self._entity,
)
def run_query(team: Team, filter: Filter, **kwargs):
query, params = PersonQuery(filter, team.pk, **kwargs).get_query()
rows = sync_execute(query, {**params, "team_id": team.pk})
if len(rows) > 0:
return {"rows": len(rows), "columns": len(rows[0])}
else:
return {"rows": 0}
def _person_join_condition(self) -> Tuple[str, Dict]:
person_query = PersonQuery(self.filter, self.team_id, self.column_optimizer, entity=self.entity)
event_join = EVENT_JOIN_PERSON_SQL.format(
GET_TEAM_PERSON_DISTINCT_IDS=get_team_distinct_ids_query(self.team_id)
)
if person_query.is_used:
query, params = person_query.get_query()
return (
f"""
{event_join}
INNER JOIN ({query}) person
ON person.id = pdi.person_id
""",
params,
)
elif self.entity.math == "dau":
# Only join distinct_ids
return event_join, {}
else:
return "", {}
def _get_aggregation_join_query(self):
if self._filter.aggregation_group_type_index is None:
person_query, person_query_params = PersonQuery(
self._filter, self._team.pk, EnterpriseColumnOptimizer(self._filter, self._team.pk)
).get_query()
return (
f"""
JOIN ({person_query}) person
ON person.id = funnel_actors.actor_id
""",
person_query_params,
)
else:
return GroupsJoinQuery(self._filter, self._team.pk, join_key="funnel_actors.actor_id").get_join_query()
def get_breakdown_prop_values(
filter: Filter,
entity: Entity,
aggregate_operation: str,
team_id: int,
limit: int = BREAKDOWN_VALUES_LIMIT,
extra_params={},
column_optimizer: Optional[EnterpriseColumnOptimizer] = None,
):
"""
Returns the top N breakdown prop values for event/person breakdown
e.g. for Browser with limit 3 might return ['Chrome', 'Safari', 'Firefox', 'Other']
"""
column_optimizer = column_optimizer or EnterpriseColumnOptimizer(
filter, team_id)
parsed_date_from, parsed_date_to, date_params = parse_timestamps(
filter=filter, team_id=team_id)
props_to_filter = filter.property_groups.combine_property_group(
PropertyOperatorType.AND, entity.property_groups)
outer_properties = column_optimizer.property_optimizer.parse_property_groups(
props_to_filter).outer
prop_filters, prop_filter_params = parse_prop_grouped_clauses(
team_id=team_id,
property_group=outer_properties,
table_name="e",
prepend="e_brkdwn",
person_properties_mode=PersonPropertiesMode.
USING_PERSON_PROPERTIES_COLUMN,
allow_denormalized_props=True,
)
entity_params, entity_format_params = get_entity_filtering_params(
entity=entity, team_id=team_id, table_name="e")
value_expression = _to_value_expression(filter.breakdown_type,
filter.breakdown,
filter.breakdown_group_type_index)
person_join_clauses = ""
person_join_params: Dict = {}
person_query = PersonQuery(filter,
team_id,
column_optimizer=column_optimizer,
entity=entity)
if person_query.is_used:
person_subquery, person_join_params = person_query.get_query()
person_join_clauses = f"""
INNER JOIN ({get_team_distinct_ids_query(team_id)}) AS pdi ON e.distinct_id = pdi.distinct_id
INNER JOIN ({person_subquery}) person ON pdi.person_id = person.id
"""
groups_join_condition, groups_join_params = GroupsJoinQuery(
filter, team_id, column_optimizer).get_join_query()
elements_query = TOP_ELEMENTS_ARRAY_OF_KEY_SQL.format(
value_expression=value_expression,
parsed_date_from=parsed_date_from,
parsed_date_to=parsed_date_to,
prop_filters=prop_filters,
aggregate_operation=aggregate_operation,
person_join_clauses=person_join_clauses,
groups_join_clauses=groups_join_condition,
**entity_format_params,
)
return sync_execute(
elements_query,
{
"key": filter.breakdown,
"limit": limit,
"team_id": team_id,
"offset": filter.offset,
**prop_filter_params,
**entity_params,
**person_join_params,
**groups_join_params,
**extra_params,
**date_params,
},
)[0][0]
def person_query(team: Team, filter: Filter, **kwargs):
return PersonQuery(filter, team.pk, **kwargs).get_query()[0]