This pull request improves query execution performance by constants folding inner functions. This is effective when a full expression cannot be folded.

Summary

• FunctionParser.visit() now folds each constant argument into its evaluated constant form before passing it to createFunction(), eliminating redundant
  per-row evaluation of constant sub-expressions like '2026-01-01'::timestamp or 1024.1 + 1.
• Previously, FunctionParser only folded constants at the top level (line 329), when the final result of parseFunction() was constant. Intermediate constant
  sub-expressions passed as arguments to non-constant parent functions were never folded. e.g., in x < '2026-01-01'::timestamp, the ::timestamp cast remained
  a CastStrToTimestampFunction and re-executed on every row.
• The folding reuses the existing functionToConstant() method, which already handles closing the original function when a new constant is returned. Guard
  conditions mirror the top-level fold: isConstant(), extendedOps() == null, plus a TypeConstant exclusion to avoid folding type-only marker constants (like
  ArrayTypeConstant) that carry no evaluable value.

Constant reassociation

The constant folding above only applies when constant sub-expressions are already grouped together in the AST. Because SQL is parsed left-to-right, left-associative chains like col + 1 + 4 produce the tree (col + 1) + 4, where the two constants 1 and 4 are separated by the column reference and cannot be folded.

ExpressionNode.reassociateConstants() runs a single bottom-up pass over the expression tree before function parsing and regroups constants of the same associative operator into a single subtree:

• (col + 1) + 4 → col + (1 + 4) → col + 5
• (col * 2) * 3 → col * (2 * 3) → col * 6
• 4 + (col + 1) → col + (4 + 1) → col + 5 (commutative operators)

The method handles four structural patterns for each pair of adjacent operator nodes, gated on whether the operator is associative, commutative, or both. Operators that are not associative (-, /, %) are left unchanged.

Each operator declares its associative and commutative properties in OperatorExpression. The rewrite relinks existing ExpressionNode instances without allocating new nodes, consistent with QuestDB's zero-GC design.

Breaking change

Float and double Infinity / -Infinity values are now treated as NULL at compile time.

Numbers.isNull(float) and Numbers.isNull(double) already consider Infinity and -Infinity as NULL, and FloatConstant.newInstance() / DoubleConstant.newInstance() collapse non-finite values to NaN (the NULL sentinel).

Before this change, expressions like cast('Infinity' as float) remained as unevaluated CastStrToFloatFunction objects at runtime, bypassing this convention. getFloat() returned Float.POSITIVE_INFINITY directly, allowing downstream consumers like CASE/SWITCH to distinguish Infinity from NULL.

With constant folding, these cast expressions are now evaluated at compile time through FloatConstant.newInstance() / DoubleConstant.newInstance(), which applies QuestDB's NULL convention: Infinity, -Infinity, and NaN all become NULL. CASE expressions can no longer branch on Infinity or -Infinity as distinct float/double values.

Benchmark

Query executed on Apple M5 with the clickbench dataset. Measured with pgbench 18.1: 5 seconds warmup and 30 seconds execution.

Query:

SELECT SUM(AdvEngineID), COUNT(*), AVG(ResolutionWidth)
FROM read_parquet('hits.parquet')
WHERE EventTime < '2013-07-06T00:00:00.000000Z'::timestamp;

-- master: 921ms
-- patch: 336ms

Query plans

Master:

 Async Group By workers: 10
   values: [sum(AdvEngineID),count(*),avg(ResolutionWidth)]
   filter: EventTime<'2013-07-06T00:00:00.000000Z'::timestamp
     parquet page frame scan
       columns: AdvEngineID,ResolutionWidth,EventTime

Patch:

 Async Group By workers: 10
   values: [sum(AdvEngineID),count(*),avg(ResolutionWidth)]
   filter: EventTime<2013-07-06T00:00:00.000000Z
     parquet page frame scan
       columns: AdvEngineID,ResolutionWidth,EventTime

Test plan

• ConstantReassociationTest — unit tests for all four reassociation patterns (A, B, Mirror A, Mirror B), multi-level chains, logical AND/OR, n-ary functions, bind variables, NULL, and negative cases (subtraction, division, modulo)
• ExplainPlanTest — integration tests verifying end-to-end folding in query plans: addition (d + 1 + 4 → d + 5), bitwise AND (l & 3 & 5 → l & 1), commutative pattern (4 + (d + 1) → d + 5), and bind variable exclusion