five/hbrtl/sqlexpr.go

// Copyright (c) 2026 Charles KWON OhJun (charleskwonohjun@gmail.com)
// All rights reserved.

// Go-native FiveSql2 expression helpers.
// Port of the tight, interpreter-heavy recursive walkers from
// _FiveSql2/src/TSqlExpr.prg into straight Go — the PRG versions
// are bottleneck-prone because every recursion pays the full VM
// frame setup cost, and SqlExprHasAgg is invoked per result
// column per query.

package hbrtl

import (
	"five/hbrt"
)

// FiveSql2 AST node kinds — must mirror _FiveSql2/src/FiveSqlDef.ch.
// Nodes are stored as Five arrays { nKind, xVal, xLeft, xRight, xExtra }
// (1-based in PRG, 0-based here).
const (
	ndLit    = 1
	ndCol    = 2
	ndFn     = 3
	ndBin    = 4
	ndUni    = 5
	ndCase   = 6
	ndSub    = 7
	ndPar    = 9
	ndNil    = 10
	ndWindow = 12
)

// aggFuncSet mirrors the AGG_FUNCTIONS macro in FiveSqlDef.ch. Names
// are stored in canonical upper case; the PRG parser upper-cases
// function identifiers at parse time so no ToUpper is needed on the
// hot path. If that invariant ever changes, upper-case here.
var aggFuncSet = map[string]struct{}{
	"COUNT":          {},
	"SUM":            {},
	"AVG":            {},
	"MIN":            {},
	"MAX":            {},
	"GROUP_CONCAT":   {},
	"STRING_AGG":     {},
	"LISTAGG":        {},
	"JSON_ARRAYAGG":  {},
	"JSON_OBJECTAGG": {},
	"XMLAGG":         {},
	"ANY_VALUE":      {},
	"BOOL_AND":       {},
	"BOOL_OR":        {},
}

// sqlExprHasAggWalk is the actual recursion shared by the RTL entry
// point. Returns true if the tree rooted at v contains a direct
// aggregate call. Matches TSqlExpr.prg:SqlExprHasAgg — walks into
// ND_BIN children, ND_UNI child, ND_FN args, ND_CASE WHEN/THEN pairs
// and ELSE; does not descend into ND_WINDOW or ND_SUB (those carry
// their own aggregation scope).
func sqlExprHasAggWalk(v hbrt.Value) bool {
	if v.IsNil() {
		return false
	}
	arr := v.AsArray()
	if arr == nil || len(arr.Items) < 2 {
		return false
	}
	kind := int(arr.Items[0].AsNumInt())

	switch kind {
	case ndFn:
		name := arr.Items[1].AsString()
		if _, ok := aggFuncSet[name]; ok {
			return true
		}
		// Scalar function — descend into args for nested aggregates.
		if len(arr.Items) >= 3 && arr.Items[2].IsArray() {
			for _, a := range arr.Items[2].AsArray().Items {
				if sqlExprHasAggWalk(a) {
					return true
				}
			}
		}
		return false

	case ndBin:
		if len(arr.Items) < 4 {
			return false
		}
		return sqlExprHasAggWalk(arr.Items[2]) || sqlExprHasAggWalk(arr.Items[3])

	case ndUni:
		if len(arr.Items) < 3 {
			return false
		}
		return sqlExprHasAggWalk(arr.Items[2])

	case ndCase:
		// arr.Items[1] is the WHEN/THEN pair array,
		// arr.Items[2] is the ELSE branch (may be NIL).
		if arr.Items[1].IsArray() {
			for _, pair := range arr.Items[1].AsArray().Items {
				pa := pair.AsArray()
				if pa == nil || len(pa.Items) < 2 {
					continue
				}
				if sqlExprHasAggWalk(pa.Items[0]) || sqlExprHasAggWalk(pa.Items[1]) {
					return true
				}
			}
		}
		if len(arr.Items) >= 3 && !arr.Items[2].IsNil() {
			return sqlExprHasAggWalk(arr.Items[2])
		}
		return false
	}

	return false
}

// SqlExprHasAgg(xExpr) → lHasAgg
//
// Returns .T. if the AST tree contains an aggregate function call.
// Drop-in replacement for the PRG SqlExprHasAgg function — same
// output for every input, just without the interpreter per-frame
// cost on deep expression trees.
func SqlExprHasAgg(t *hbrt.Thread) {
	t.Frame(1, 0)
	defer t.EndProc()
	t.RetBool(sqlExprHasAggWalk(t.Local(1)))
}

// Silence "declared and not used" for constants that exist solely to
// document FiveSqlDef.ch layout — keeping them in source form helps
// future walker additions (ND_SUB for subquery flattening, ND_WINDOW
// for window-over-aggregate detection).
var _ = [...]int{ndLit, ndCol, ndSub, ndPar, ndNil, ndWindow}