feat(hogql): automatic person table joins

frontend/src/queries/examples.ts

@@ -308,7 +308,21 @@ const HogQL: HogQLQuery = {
 const HogQLTable: DataTableNode = {
     kind: NodeKind.DataTableNode,
     full: true,
-    source: HogQL,
+    source: {
+        kind: NodeKind.HogQLQuery,
+        query: `   select event,
+          person.properties.email,
+          properties.$browser,
+          count()
+     from events
+    where timestamp > now () - interval 1 month
+      and person.properties.email is not null
+ group by event,
+          properties.$browser,
+          person.properties.email
+ order by count() desc
+    limit 100`,
+    },
 }
 
 export const examples: Record<string, Node> = {

frontend/src/queries/nodes/DataTable/renderColumn.tsx

@@ -7,7 +7,7 @@ import { Property } from 'lib/components/Property'
 import { urls } from 'scenes/urls'
 import { PersonHeader } from 'scenes/persons/PersonHeader'
 import { DataTableNode, HasPropertiesNode, QueryContext } from '~/queries/schema'
-import { isEventsQuery, isPersonsNode } from '~/queries/utils'
+import { isEventsQuery, isHogQLQuery, isPersonsNode } from '~/queries/utils'
 import { combineUrl, router } from 'kea-router'
 import { CopyToClipboardInline } from 'lib/components/CopyToClipboard'
 import { DeletePersonButton } from '~/queries/nodes/PersonsNode/DeletePersonButton'
@@ -28,6 +28,18 @@ export function renderColumn(
         return <Spinner />
     } else if (value === errorColumn) {
         return <LemonTag color="red">Error</LemonTag>
+    } else if (isHogQLQuery(query.source)) {
+        if (typeof value === 'string') {
+            try {
+                if ((value.startsWith('{') && value.endsWith('}')) || (value.startsWith('[') && value.endsWith(']'))) {
+                    return <ReactJson src={JSON.parse(value)} name={key} collapsed={1} />
+                }
+            } catch (e) {}
+            if (value.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}/)) {
+                return <TZLabel time={value} showSeconds />
+            }
+        }
+        return <Property value={value} />
     } else if (key === 'event' && isEventsQuery(query.source)) {
         const resultRow = record as any[]
         const eventRecord = query.source.select.includes('*') ? resultRow[query.source.select.indexOf('*')] : null

frontend/src/queries/nodes/DataTable/renderColumnMeta.tsx

@@ -1,7 +1,7 @@
 import { PropertyFilterType } from '~/types'
 import { PropertyKeyInfo } from 'lib/components/PropertyKeyInfo'
 import { QueryContext, DataTableNode } from '~/queries/schema'
-import { isEventsQuery } from '~/queries/utils'
+import { isEventsQuery, isHogQLQuery } from '~/queries/utils'
 import { extractExpressionComment } from '~/queries/nodes/DataTable/utils'
 import { SortingIndicator } from 'lib/lemon-ui/LemonTable/sorting'
 
@@ -14,7 +14,9 @@ export function renderColumnMeta(key: string, query: DataTableNode, context?: Qu
     let width: number | undefined
     let title: JSX.Element | string | undefined
 
-    if (key === 'timestamp') {
+    if (isHogQLQuery(query.source)) {
+        title = key
+    } else if (key === 'timestamp') {
         title = 'Time'
     } else if (key === 'created_at') {
         title = 'First seen'

posthog/api/action.py

@@ -236,7 +236,7 @@ def people(self, request: request.Request, *args: Any, **kwargs: Any) -> Respons
     def count(self, request: request.Request, **kwargs) -> Response:
         action = self.get_object()
         # NOTE: never accepts cohort parameters so no need for explicit person_id_joined_alias
-        hogql_context = HogQLContext()
+        hogql_context = HogQLContext(legacy_person_property_handling=True)
         query, params = format_action_filter(team_id=action.team_id, action=action, hogql_context=hogql_context)
         if query == "":
             return Response({"count": 0})

posthog/hogql/ast.py

@@ -5,7 +5,14 @@
 from pydantic import BaseModel, Extra
 from pydantic import Field as PydanticField
 
-from posthog.hogql.database import DatabaseField, StringJSONDatabaseField, Table
+from posthog.hogql.database import (
+    DatabaseField,
+    FieldTraverser,
+    LazyTable,
+    StringJSONDatabaseField,
+    Table,
+    VirtualTable,
+)
 
 # NOTE: when you add new AST fields or nodes, add them to the Visitor classes in visitor.py as well!
 
@@ -46,36 +53,62 @@ def has_child(self, name: str) -> bool:
         return self.symbol.has_child(name)
 
 
-class TableSymbol(Symbol):
-    table: Table
+class BaseTableSymbol(Symbol):
+    def resolve_database_table(self) -> Table:
+        raise NotImplementedError("BaseTableSymbol.resolve_database_table not overridden")
 
     def has_child(self, name: str) -> bool:
-        return self.table.has_field(name)
+        return self.resolve_database_table().has_field(name)
 
     def get_child(self, name: str) -> Symbol:
         if name == "*":
             return AsteriskSymbol(table=self)
         if self.has_child(name):
-            field = self.table.get_field(name)
-            if isinstance(field, Table):
-                return TableSymbol(table=field)
+            field = self.resolve_database_table().get_field(name)
+            if isinstance(field, LazyTable):
+                return LazyTableSymbol(table=self, field=name, lazy_table=field)
+            if isinstance(field, FieldTraverser):
+                return FieldTraverserSymbol(table=self, chain=field.chain)
+            if isinstance(field, VirtualTable):
+                return VirtualTableSymbol(table=self, field=name, virtual_table=field)
             return FieldSymbol(name=name, table=self)
-        raise ValueError(f'Field "{name}" not found on table {type(self.table).__name__}')
+        raise ValueError(f"Field not found: {name}")
+
+
+class TableSymbol(BaseTableSymbol):
+    table: Table
 
+    def resolve_database_table(self) -> Table:
+        return self.table
 
-class TableAliasSymbol(Symbol):
+
+class TableAliasSymbol(BaseTableSymbol):
     name: str
-    table: TableSymbol
+    table_symbol: TableSymbol
 
-    def has_child(self, name: str) -> bool:
-        return self.table.has_child(name)
+    def resolve_database_table(self) -> Table:
+        return self.table_symbol.table
 
-    def get_child(self, name: str) -> Symbol:
-        if name == "*":
-            return AsteriskSymbol(table=self)
-        if self.has_child(name):
-            return FieldSymbol(name=name, table=self)
-        return self.table.get_child(name)
+
+class LazyTableSymbol(BaseTableSymbol):
+    table: BaseTableSymbol
+    field: str
+    lazy_table: LazyTable
+
+    def resolve_database_table(self) -> Table:
+        return self.lazy_table.table
+
+
+class VirtualTableSymbol(BaseTableSymbol):
+    table: BaseTableSymbol
+    field: str
+    virtual_table: VirtualTable
+
+    def resolve_database_table(self) -> Table:
+        return self.virtual_table
+
+    def has_child(self, name: str) -> bool:
+        return self.virtual_table.has_field(name)
 
 
 class SelectQuerySymbol(Symbol):
@@ -84,12 +117,21 @@ class SelectQuerySymbol(Symbol):
     # all symbols a select query exports
     columns: Dict[str, Symbol] = PydanticField(default_factory=dict)
     # all from and join, tables and subqueries with aliases
-    tables: Dict[
-        str, Union[TableSymbol, TableAliasSymbol, "SelectQuerySymbol", "SelectQueryAliasSymbol"]
-    ] = PydanticField(default_factory=dict)
+    tables: Dict[str, Union[BaseTableSymbol, "SelectQuerySymbol", "SelectQueryAliasSymbol"]] = PydanticField(
+        default_factory=dict
+    )
     # all from and join subqueries without aliases
     anonymous_tables: List["SelectQuerySymbol"] = PydanticField(default_factory=list)
 
+    def get_alias_for_table_symbol(
+        self,
+        table_symbol: Union[BaseTableSymbol, "SelectQuerySymbol", "SelectQueryAliasSymbol"],
+    ) -> Optional[str]:
+        for key, value in self.tables.items():
+            if value == table_symbol:
+                return key
+        return None
+
     def get_child(self, name: str) -> Symbol:
         if name == "*":
             return AsteriskSymbol(table=self)
@@ -129,27 +171,29 @@ class ConstantSymbol(Symbol):
 
 
 class AsteriskSymbol(Symbol):
-    table: Union[TableSymbol, TableAliasSymbol, SelectQuerySymbol, SelectQueryAliasSymbol]
+    table: Union[BaseTableSymbol, SelectQuerySymbol, SelectQueryAliasSymbol]
+
+
+class FieldTraverserSymbol(Symbol):
+    chain: List[str]
+    table: Union[BaseTableSymbol, SelectQuerySymbol, SelectQueryAliasSymbol]
 
 
 class FieldSymbol(Symbol):
     name: str
-    table: Union[TableSymbol, TableAliasSymbol, SelectQuerySymbol, SelectQueryAliasSymbol]
-
-    def resolve_database_field(self) -> Optional[Union[DatabaseField, Table]]:
-        table_symbol = self.table
-        while isinstance(table_symbol, TableAliasSymbol):
-            table_symbol = table_symbol.table
-        if isinstance(table_symbol, TableSymbol):
-            return table_symbol.table.get_field(self.name)
+    table: Union[BaseTableSymbol, SelectQuerySymbol, SelectQueryAliasSymbol]
+
+    def resolve_database_field(self) -> Optional[DatabaseField]:
+        if isinstance(self.table, BaseTableSymbol):
+            table = self.table.resolve_database_table()
+            if table is not None:
+                return table.get_field(self.name)
         return None
 
     def get_child(self, name: str) -> Symbol:
         database_field = self.resolve_database_field()
         if database_field is None:
             raise ValueError(f'Can not access property "{name}" on field "{self.name}".')
-        if isinstance(database_field, Table):
-            return FieldSymbol(name=name, table=TableSymbol(table=database_field))
         if isinstance(database_field, StringJSONDatabaseField):
             return PropertySymbol(name=name, parent=self)
         raise ValueError(

posthog/hogql/context.py

@@ -16,13 +16,13 @@ class HogQLContext:
 
     # If set, will save string constants to this dict. Inlines strings into the query if None.
     values: Dict = field(default_factory=dict)
-    # List of field and property accesses found in the expression
-    field_access_logs: List[HogQLFieldAccess] = field(default_factory=list)
-    # Did the last calls to translate_hogql since setting these to False contain any of the following
-    found_aggregation: bool = False
-    # Do we need to join the persons table or not
+    # Are we small part of a non-HogQL query? If so, use custom syntax for accessed person properties.
+    legacy_person_property_handling: bool = False
+    # Do we need to join the persons table or not. Has effect if legacy_person_property_handling = True
     using_person_on_events: bool = True
     # If set, allows printing full SELECT queries in ClickHouse
     select_team_id: Optional[int] = None
     # Do we apply a limit of MAX_SELECT_RETURNED_ROWS=65535 to the topmost select query?
     limit_top_select: bool = True
+    # To be removed. Did the last calls to translate_hogql since setting this to False contain an aggregation?
+    found_aggregation: bool = False