refactor(hogql): redesign events predicate pushdown on the lowering architecture

ee/clickhouse/models/test/__snapshots__/test_cohort.ambr

@@ -169,7 +169,7 @@
                                       cohortpeople.team_id AS team_id
                       FROM cohortpeople
                       WHERE and(equals(cohortpeople.team_id, 99999), in(tuple(cohortpeople.cohort_id, cohortpeople.version), [(99999, 0)]))) AS cohort_people
-                   WHERE and(ifNull(equals(cohort_people.cohort_id, 99999), 0), ifNull(equals(cohort_people.team_id, 99999), 0))
+                   WHERE and(equals(cohort_people.cohort_id, 99999), equals(cohort_people.team_id, 99999))
                    LIMIT 1000000000))) as person SETTINGS optimize_aggregation_in_order = 1,
                                                           join_algorithm = 'auto'
   '''
@@ -217,7 +217,7 @@
                                       cohortpeople.team_id AS team_id
                       FROM cohortpeople
                       WHERE and(equals(cohortpeople.team_id, 99999), in(tuple(cohortpeople.cohort_id, cohortpeople.version), [(99999, 0)]))) AS cohort_people
-                   WHERE and(ifNull(equals(cohort_people.cohort_id, 99999), 0), ifNull(equals(cohort_people.team_id, 99999), 0))
+                   WHERE and(equals(cohort_people.cohort_id, 99999), equals(cohort_people.team_id, 99999))
                    LIMIT 1000000000))) as person SETTINGS optimize_aggregation_in_order = 1,
                                                           join_algorithm = 'auto'
   '''
@@ -272,7 +272,7 @@
                                                                                       cohortpeople.team_id AS team_id
                                                                       FROM cohortpeople
                                                                       WHERE 0) AS cohort_people
-                                                                   WHERE and(ifNull(equals(cohort_people.cohort_id, 99999), 0), ifNull(equals(cohort_people.team_id, 99999), 0))))))
+                                                                   WHERE and(equals(cohort_people.cohort_id, 99999), equals(cohort_people.team_id, 99999))))))
                LIMIT 1000000000)))
   '''
 # ---
@@ -399,7 +399,7 @@
                                       cohortpeople.team_id AS team_id
                       FROM cohortpeople
                       WHERE and(equals(cohortpeople.team_id, 99999), in(tuple(cohortpeople.cohort_id, cohortpeople.version), [(99999, 0)]))) AS cohort_people
-                   WHERE and(ifNull(equals(cohort_people.cohort_id, 99999), 0), ifNull(equals(cohort_people.team_id, 99999), 0))
+                   WHERE and(equals(cohort_people.cohort_id, 99999), equals(cohort_people.team_id, 99999))
                    LIMIT 1000000000))) as person SETTINGS optimize_aggregation_in_order = 1,
                                                           join_algorithm = 'auto'
   '''
@@ -447,7 +447,7 @@
                                       cohortpeople.team_id AS team_id
                       FROM cohortpeople
                       WHERE and(equals(cohortpeople.team_id, 99999), in(tuple(cohortpeople.cohort_id, cohortpeople.version), [(99999, 0)]))) AS cohort_people
-                   WHERE and(ifNull(equals(cohort_people.cohort_id, 99999), 0), ifNull(equals(cohort_people.team_id, 99999), 0))
+                   WHERE and(equals(cohort_people.cohort_id, 99999), equals(cohort_people.team_id, 99999))
                    LIMIT 1000000000))) as person SETTINGS optimize_aggregation_in_order = 1,
                                                           join_algorithm = 'auto'
   '''

ee/clickhouse/views/test/__snapshots__/test_clickhouse_trends.ambr

@@ -145,7 +145,7 @@
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(1)(date)[1] AS date,
                       arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
-                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+                      if(ifNull(greaterOrEquals(row_number, 25), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
   FROM
     (SELECT arrayMap(number -> plus(toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1)), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1)), toStartOfInterval(assumeNotNull(toDateTime('2012-01-15 23:59:59', 'UTC')), toIntervalDay(1)))), 1))) AS date,
             arrayFill(x -> ifNull(greater(x, 0), 0), arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
@@ -198,7 +198,7 @@
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(1)(date)[1] AS date,
                       arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
-                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+                      if(ifNull(greaterOrEquals(row_number, 25), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
   FROM
     (SELECT arrayMap(number -> plus(toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1)), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1)), toStartOfInterval(assumeNotNull(toDateTime('2012-01-15 23:59:59', 'UTC')), toIntervalDay(1)))), 1))) AS date,
             arrayFill(x -> ifNull(greater(x, 0), 0), arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)
@@ -250,11 +250,11 @@
                  CROSS JOIN
                    (SELECT minus(toStartOfInterval(assumeNotNull(toDateTime('2012-01-15 23:59:59', 'UTC')), toIntervalDay(1)), toIntervalDay(numbers.number)) AS timestamp
                     FROM numbers(dateDiff('day', minus(toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1)), toIntervalDay(7)), assumeNotNull(toDateTime('2012-01-15 23:59:59', 'UTC')))) AS numbers) AS d
-                 WHERE and(ifNull(lessOrEquals(e.timestamp, d.timestamp), 0), ifNull(greater(e.timestamp, minus(d.timestamp, toIntervalDay(7))), 0))
+                 WHERE and(lessOrEquals(e.timestamp, d.timestamp), greater(e.timestamp, minus(d.timestamp, toIntervalDay(7))))
                  GROUP BY d.timestamp,
                           breakdown_value
                  ORDER BY d.timestamp ASC)
-              WHERE and(ifNull(greaterOrEquals(timestamp, toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1))), 0), ifNull(lessOrEquals(timestamp, assumeNotNull(toDateTime('2012-01-15 23:59:59', 'UTC'))), 0)))
+              WHERE and(greaterOrEquals(timestamp, toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1))), lessOrEquals(timestamp, assumeNotNull(toDateTime('2012-01-15 23:59:59', 'UTC')))))
            GROUP BY day_start,
                     breakdown_value
            ORDER BY day_start ASC,
@@ -284,7 +284,7 @@
   /* user_id:0 request:_snapshot_ */
   SELECT groupArray(1)(date)[1] AS date,
                       arrayFold((acc, x) -> arrayMap(i -> plus(acc[i], x[i]), range(1, plus(length(date), 1))), groupArray(ifNull(total, 0)), arrayWithConstant(length(date), reinterpretAsFloat64(0))) AS total,
-                      if(ifNull(ifNull(greaterOrEquals(row_number, 25), 0), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
+                      if(ifNull(greaterOrEquals(row_number, 25), 0), '$$_posthog_breakdown_other_$$', breakdown_value) AS breakdown_value
   FROM
     (SELECT arrayMap(number -> plus(toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1)), toIntervalDay(number)), range(0, plus(coalesce(dateDiff('day', toStartOfInterval(assumeNotNull(toDateTime('2012-01-01 00:00:00', 'UTC')), toIntervalDay(1)), toStartOfInterval(assumeNotNull(toDateTime('2012-01-15 23:59:59', 'UTC')), toIntervalDay(1)))), 1))) AS date,
             arrayFill(x -> ifNull(greater(x, 0), 0), arrayMap(_match_date -> arraySum(arraySlice(groupArray(ifNull(count, 0)), indexOf(groupArray(day_start) AS _days_for_count, _match_date) AS _index, plus(minus(arrayLastIndex(x -> ifNull(equals(x, _match_date), isNull(x)

posthog/hogql/ast.py

@@ -983,6 +983,36 @@ class Tuple(Expr):
     exprs: list[Expr]
 
 
+@dataclass(kw_only=True, slots=True)
+class PropertyAccess(Expr):
+    """The lowered form of a `properties.X` read: "read this key path from this properties field."
+
+    The properties field is treated as an abstract key-value document — how the value is physically served (raw JSON
+    extract, materialized column, property-group map) is decided by later passes, never encoded in this node.
+
+    This is what a blob property read becomes after logical lowering. The contrast that matters is with
+    `PropertyType`, the read's *type* before lowering. A `PropertyType` means "this is an unresolved property — nobody has
+    turned it into anything concrete yet." A `PropertyAccess` is that property **lowered to its concrete pieces**: `expr`
+    is the blob column (e.g. `events.properties`), `keys` is the path into it, and the node's own type is the value type of
+    the read — a nullable String. It has dropped the "I'm an unresolved property" meaning (it carries *no* `PropertyType`),
+    so nothing downstream mistakes it for one and re-runs property logic on it.
+
+    It does **not** decide where the value ultimately comes from. Lowering produces a `PropertyAccess` for *every* blob
+    property — a materialized one and a raw one look identical at this stage. On ClickHouse, the next pass (the
+    materialized-column / property-group / skip-index physical passes) may rewrite this node to a concrete column read — a
+    faster source of the *same* value — when a backing column exists. Raw JSON is only the **default rendering if nothing
+    rewrites it**: each printer renders a surviving node mechanically in its own JSON syntax via `visit_property_access`
+    (ClickHouse `JSONExtractRaw` + null/quote scrub; Postgres/DuckDB `->`/`->>`) and makes no physical-column decision —
+    that is the whole point of this split. For the warehouse dialects there is no second pass, so the node always renders
+    as the extract. `keys` mirrors a `PropertyType.chain` —
+    string object keys and integer array indices, passed through untyped so each dialect's `_json_property_args` handles
+    them just like the legacy `visit_property_type` blob fallback did.
+    """
+
+    expr: Expr
+    keys: list[str | int]
+
+
 @dataclass(kw_only=True, slots=True)
 class Lambda(Expr):
     args: list[str]
@@ -992,6 +1022,13 @@ class Lambda(Expr):
 @dataclass(kw_only=True, slots=True)
 class Constant(Expr):
     value: Any
+    # Internal ClickHouse-printer hint, not part of the logical AST. Set True only by the physical pass, only for its
+    # fixed scrubbing sentinels (the nullIf ''/'null' literals, the quote-trim regex, the 'true'/'false' the property
+    # group stores booleans as), to render them inline instead of as a bound parameter — matching the inline string the
+    # `json_extract_trim_quotes` helper emits. The printer enforces a fixed allowlist (`INLINE_SENTINEL_LITERALS`), so it
+    # can never inline arbitrary text. Unset (None) by default, like `type`, so the "skip None" AST serializers (Hog
+    # compilers, `pretty_dataclasses` snapshots) leave it out.
+    inline_sentinel: bool | None = None
 
 
 # Allowlist for `Keyword.name`; the SQL printer interpolates it verbatim (CH returns `name` directly, Postgres uppercases). Restricted to the Postgres-family time pseudo-functions from `resolver.POSTGRES_KEYWORD_TYPES` — a broader `str.isidentifier()` check would still admit arbitrary Python identifiers and let them emit as unquoted ClickHouse tokens.