chore: trends query runner tests

posthog/hogql/database/schema/event_sessions.py

@@ -55,6 +55,18 @@ def visit_field(self, node: ast.Field):
         return super().visit_field(node)
 
 
+class ContainsLazyJoinType(TraversingVisitor):
+    contains_lazy_join: bool
+
+    def __init__(self, expr: ast.Expr):
+        super().__init__()
+        self.contains_lazy_join = False
+        super().visit(expr)
+
+    def visit_lazy_join_type(self, node: ast.LazyJoinType):
+        self.contains_lazy_join = True
+
+
 class WhereClauseExtractor:
     compare_operators: List[ast.Expr]
 
@@ -109,14 +121,30 @@ def _is_field_on_table(self, field: ast.Field) -> bool:
     def run(self, expr: ast.Expr) -> List[ast.Expr]:
         exprs_to_apply: List[ast.Expr] = []
 
+        def should_add(expression: ast.Expr, fields: List[ast.Field]) -> bool:
+            for field in fields:
+                on_table = self._is_field_on_table(field)
+                if not on_table:
+                    return False
+
+                # Ignore comparisons on the `event` field for session durations
+                if field.chain[-1] == "event":
+                    return False
+
+                # Ignore if there's a lazy join involved
+                if ContainsLazyJoinType(expression).contains_lazy_join:
+                    return False
+
+            return True
+
         if isinstance(expr, ast.And):
             for expression in expr.exprs:
                 if not isinstance(expression, ast.CompareOperation):
                     continue
 
                 fields = GetFieldsTraverser(expression).fields
-                res = [self._is_field_on_table(field) for field in fields]
-                if all(res):
+
+                if should_add(expression, fields):
                     exprs_to_apply.append(expression)
         elif isinstance(expr, ast.CompareOperation):
             exprs_to_apply.extend(self.run(ast.And(exprs=[expr])))

posthog/hogql/database/schema/test/test_event_sessions.py

@@ -30,17 +30,17 @@ def test_with_simple_equality_clause(self):
             """
                 SELECT event
                 FROM events
-                WHERE event = '$pageview'
+                WHERE team_id = 1
             """
         )
 
         compare_operators = self._compare_operators(query, "events")
 
         assert len(compare_operators) == 1
         assert compare_operators[0] == ast.CompareOperation(
-            left=ast.Field(chain=["event"]),
+            left=ast.Field(chain=["team_id"]),
             op=ast.CompareOperationOp.Eq,
-            right=ast.Constant(value="$pageview"),
+            right=ast.Constant(value=1),
         )
 
     def test_with_timestamps(self):
@@ -66,35 +66,35 @@ def test_with_alias_table(self):
             """
                 SELECT e.event
                 FROM events e
-                WHERE e.event = '$pageview'
+                WHERE e.team_id = 1
             """
         )
 
         compare_operators = self._compare_operators(query, "e")
 
         assert len(compare_operators) == 1
         assert compare_operators[0] == ast.CompareOperation(
-            left=ast.Field(chain=["event"]),
+            left=ast.Field(chain=["team_id"]),
             op=ast.CompareOperationOp.Eq,
-            right=ast.Constant(value="$pageview"),
+            right=ast.Constant(value=1),
         )
 
     def test_with_multiple_clauses(self):
         query = self._select(
             """
                 SELECT event
                 FROM events
-                WHERE event = '$pageview' AND timestamp > '2023-01-01'
+                WHERE team_id = 1 AND timestamp > '2023-01-01'
             """
         )
 
         compare_operators = self._compare_operators(query, "events")
 
         assert len(compare_operators) == 2
         assert compare_operators[0] == ast.CompareOperation(
-            left=ast.Field(chain=["event"]),
+            left=ast.Field(chain=["team_id"]),
             op=ast.CompareOperationOp.Eq,
-            right=ast.Constant(value="$pageview"),
+            right=ast.Constant(value=1),
         )
         assert compare_operators[1] == ast.CompareOperation(
             left=ast.Field(chain=["timestamp"]),
@@ -109,25 +109,25 @@ def test_with_join(self):
                 FROM events e
                 LEFT JOIN persons p
                 ON e.person_id = p.id
-                WHERE e.event = '$pageview' and p.is_identified = 0
+                WHERE e.team_id = 1 and p.is_identified = 0
             """
         )
 
         compare_operators = self._compare_operators(query, "e")
 
         assert len(compare_operators) == 1
         assert compare_operators[0] == ast.CompareOperation(
-            left=ast.Field(chain=["event"]),
+            left=ast.Field(chain=["team_id"]),
             op=ast.CompareOperationOp.Eq,
-            right=ast.Constant(value="$pageview"),
+            right=ast.Constant(value=1),
         )
 
     def test_with_ignoring_ors(self):
         query = self._select(
             """
                 SELECT event
                 FROM events
-                WHERE event = '$pageleave' OR event = '$pageview'
+                WHERE team_id = 1 OR team_id = 2
             """
         )
 

posthog/hogql/printer.py

@@ -892,7 +892,10 @@ def visit_field_type(self, type: ast.FieldType):
                     field_sql = "person_props"
 
         else:
-            raise HogQLException(f"Unknown FieldType table type: {type.table_type.__class__.__name__}")
+            error = f"Can't access field '{type.name}' on a table with type '{type.table_type.__class__.__name__}'."
+            if isinstance(type.table_type, ast.LazyJoinType):
+                error += f" Lazy joins should have all been replaced in the resolver."
+            raise HogQLException(error)
 
         return field_sql
 

posthog/hogql/property.py

@@ -113,13 +113,24 @@ def property_to_expr(
 
     if property.type == "hogql":
         return parse_expr(property.key)
-    elif property.type == "event" or property.type == "feature" or property.type == "person":
+    elif (
+        property.type == "event" or property.type == "feature" or property.type == "person" or property.type == "group"
+    ):
         if scope == "person" and property.type != "person":
             raise NotImplementedException(
                 f"The '{property.type}' property filter only works in 'event' scope, not in '{scope}' scope"
             )
         operator = cast(Optional[PropertyOperator], property.operator) or PropertyOperator.exact
         value = property.value
+
+        if property.type == "person" and scope != "person":
+            chain = ["person", "properties"]
+        elif property.type == "group":
+            chain = [f"group_{property.group_type_index}", "properties"]
+        else:
+            chain = ["properties"]
+        field = ast.Field(chain=chain + [property.key])
+
         if isinstance(value, list):
             if len(value) == 0:
                 return ast.Constant(value=True)
@@ -135,7 +146,7 @@ def property_to_expr(
 
                     return ast.CompareOperation(
                         op=op,
-                        left=ast.Field(chain=["properties", property.key]),
+                        left=field,
                         right=ast.Tuple(exprs=[ast.Constant(value=v) for v in value]),
                     )
                 else:
@@ -156,8 +167,6 @@ def property_to_expr(
                         return ast.And(exprs=exprs)
                     return ast.Or(exprs=exprs)
 
-        chain = ["person", "properties"] if property.type == "person" and scope != "person" else ["properties"]
-        field = ast.Field(chain=chain + [property.key])
         properties_field = ast.Field(chain=chain)
 
         if operator == PropertyOperator.is_set:
@@ -297,9 +306,11 @@ def property_to_expr(
             right=ast.Constant(value=cohort.pk),
         )
 
-    # TODO: Add support for these types "group", "recording", "behavioral", and "session" types
+    # TODO: Add support for these types "recording", "behavioral", and "session" types
 
-    raise NotImplementedException(f"property_to_expr not implemented for filter type {type(property).__name__}")
+    raise NotImplementedException(
+        f"property_to_expr not implemented for filter type {type(property).__name__} and {property.type}"
+    )
 
 
 def action_to_expr(action: Action) -> ast.Expr:

posthog/hogql/test/test_property.py

@@ -65,6 +65,29 @@ def test_property_to_expr_hogql(self):
             ast.Constant(value=1),
         )
 
+    def test_property_to_expr_group(self):
+        self.assertEqual(
+            self._property_to_expr({"type": "group", "group_type_index": 0, "key": "a", "value": "b"}),
+            self._parse_expr("group_0.properties.a = 'b'"),
+        )
+        self.assertEqual(
+            self._property_to_expr({"type": "group", "group_type_index": 3, "key": "a", "value": "b"}),
+            self._parse_expr("group_3.properties.a = 'b'"),
+        )
+        self.assertEqual(
+            self._parse_expr("group_0.properties.a = NULL OR (NOT JSONHas(group_0.properties, 'a'))"),
+            self._property_to_expr(
+                {"type": "group", "group_type_index": 0, "key": "a", "value": "b", "operator": "is_not_set"}
+            ),
+        )
+
+        with self.assertRaises(Exception) as e:
+            self._property_to_expr({"type": "group", "key": "a", "value": "b"})
+        self.assertEqual(
+            str(e.exception),
+            "Missing required key group_type_index for property type group",
+        )
+
     def test_property_to_expr_event(self):
         self.assertEqual(
             self._property_to_expr({"key": "a", "value": "b"}),