package eval

Import Path
	github.com/freeeve/gochickpeas/gql/internal/eval (on go.dev)

Dependency Relation
	imports 11 packages, and imported by 4 packages

Involved Source Files

	  d arith.go
		Binary operator evaluation shared by the interpreter and the compiled
		path: string predicates (STARTS WITH / ENDS WITH / CONTAINS) and the
		arithmetic operators (+, -, *, /) over numbers, strings, lists, and
		temporals/durations, with checked integer arithmetic (overflow and
		division by zero yield Null -- eval has no per-row error channel). Split
		from funcs.go, which holds the scalar built-in functions.

	  d ctx.go
		Package eval is the interpreted expression evaluator: the portable path
		that evaluates bound AST expressions per row against the graph seam.
		Port of the Rust engine's eval.rs; the columnar compiled path (M16)
		mirrors it and both must produce identical results.

	  d eval.go
		The core interpreter: evaluate a bound expression against a slot-indexed
		row. Aggregate functions are handled by the executor, never here (they
		evaluate to Null if reached).

	  d funcop.go
		The scalar-function registry: the FuncOp enumeration and the
		name-resolution helpers that map a (case-insensitive) function name to a
		resolved op. The per-row evaluation kernels live in funcs.go; carrying a
		resolved FuncOp lets the compiled path skip name dispatch.

	  d funcs.go
		The arithmetic/string-predicate scalar-function kernels, shared verbatim
		by the interpreter and the compiled path so both produce identical
		results. No scalar function touches the graph except startNode/endNode,
		which resolve in evalScalarFunc. The FuncOp enumeration and name
		resolution live in funcop.go.

	  d funcs_apply.go
		Scalar built-in application helpers: positional argument access, the
		range/substring/toString value builders, and the datetime/duration
		constructors with their checked integer arithmetic. Split from funcs.go,
		which holds the function registry (ResolveFuncOp) and the ApplyFunc
		dispatch.

	  d lists.go
		List-scoped expression forms: the all/any/none/single quantifiers,
		reduce folds, and list comprehensions. Each binds its iteration
		variable in a slot appended past the current row.

	  d subquery.go
		Correlated subquery matching: EXISTS { MATCH ... }, COUNT { MATCH ... },
		and pattern comprehensions, all sharing one anchored DFS over the
		pattern. The DFS's evaluation-invariant setup (anchor-reversal, level
		slots, the extended scope, compiled node and rel matchers) is shaped
		once per pattern and cached on the Ctx with its evaluation scratch, so
		the per-row cost is a row refresh instead of map/slice/matcher rebuilds.

	  d subquery_walk.go
		The correlated-subquery DFS walk: level-by-level candidate generation
		over a shaped pattern (anchored endpoints, lazily compiled matchers,
		the quantified-hop reach) -- the evaluation half of subquery.go's
		shape/count entry points.

	  d temporal.go
		Temporal arithmetic for the runtime value type: epoch-millis-backed
		date/datetime values and durations, with civil-calendar decomposition.
		Query-side only -- stored i64-millis columns coerce against these on
		compare. Pure integer math (port of the Rust temporal.rs).

	  d temporal_component.go
		Temporal component access and duration arithmetic: reading a named
		component off an epoch-millis instant or a (months, days, millis)
		duration, applying a duration to an instant (checked calendar add), and
		the Euclidean integer-math helpers they share. Split from temporal.go,
		which holds the ISO parsing and formatting.
Package-Level Type Names (total 3)

	/* sort by: alphabet | popularity */
	 type Ctx (struct)
		Ctx carries the evaluation environment: the graph and the query's
		parameter values. It replaces the Rust engine's thread-local
		ParamScope/NamedParamScope -- explicit and threaded through every
		evaluation, so nested subquery evaluation and reuse across goroutines
		need no scope choreography.

		Fields (total 8)
			CompileWhere func(e ast.Expr, slots map[string]int) func(*Ctx, []value.Value) value.Value
				CompileWhere, when set, compiles a subquery WHERE against the
				walk's inner slot map and returns a per-row evaluator; nil (or
				ForceInterp) keeps the interpreted path. The executor layer
				installs it -- it can reach the compiler without an import cycle
				-- so a subquery's filter runs the same compiled machinery as a
				stage filter instead of re-interpreting the AST (and re-evaluating
				its constant subexpressions) once per candidate.

			DecorBuilds int
			DecorTables map[DecorTableKey]map[graph.NodeID]int
				DecorTables shares decorrelated COUNT{} side tables across sibling
				compiled subqueries within one execution, keyed by the subquery's
				canonical identity (endpoint variable names substituted, so the same
				subquery written against two outer variables collides) and the
				resolved anchor node. Params are fixed per Ctx, so identities that
				embed parameter slots stay valid for the Ctx's lifetime. DecorBuilds
				counts table builds across the execution -- tests assert a shared
				identity builds once, not once per sibling.

			ForceInterp bool
				ForceInterp pins every expression to the interpreted path even on a
				native-capable graph -- the differential test hook behind the
				dual-path harness.

			G graph.Graph
			MatchEpoch uint64
				MatchEpoch is bumped once per match-call by the executor, so a
				loop-invariant carried IN list's membership cache rebuilds per call
				and is reused across that call's candidates (replaces the Rust
				thread-local epoch).

			Named map[string]value.Value
				Named are the explicit $name parameter values.

			Params []value.Value
				Params are the auto-lifted parameter values, indexed by slot.

		Methods (total 2)
			(*Ctx) NamedValue(name string) value.Value
				NamedValue resolves an explicit $name parameter; an unsupplied name is
				Null (a missing parameter reads as null rather than an error).

			(*Ctx) ParamValue(slot uint32) value.Value
				ParamValue resolves an auto-lifted slot; out of range is Null.

		As Inputs Of (at least 11)
			func Eval(ctx *Ctx, expr ast.Expr, row []value.Value, slots map[string]int) value.Value
			func LitValue(ctx *Ctx, l ast.Literal) value.Value
			func SubqueryCount(ctx *Ctx, pattern *ast.Pattern, where ast.Expr, outerRow []value.Value, outerSlots map[string]int, stopAtFirst bool) int
			func SubqueryGroupCount(ctx *Ctx, pattern *ast.Pattern, where ast.Expr, outerRow []value.Value, outerSlots map[string]int, anchorVar, groupVar string) map[graph.NodeID]int
			func github.com/freeeve/gochickpeas/gql/internal/compile.ConstValue(ctx *Ctx, e ast.Expr, slots map[string]int, g *chickpeas.Snapshot) (value.Value, bool)
			func github.com/freeeve/gochickpeas/gql/internal/compile.HoistConstIn(ctx *Ctx, c *compile.Compiled, isConst func(int) bool, sample []value.Value, slots map[string]int) *compile.Compiled
			func github.com/freeeve/gochickpeas/gql/internal/compile.New(ctx *Ctx, e ast.Expr, slots map[string]int, g *chickpeas.Snapshot) *compile.Compiled
			func github.com/freeeve/gochickpeas/gql/internal/compile.(*Compiled).Eval(ctx *Ctx, row []value.Value, slots map[string]int) value.Value
			func github.com/freeeve/gochickpeas/gql/internal/exec.Execute(ctx *Ctx, p *plan.Plan) ([][]value.Value, error)
			func github.com/freeeve/gochickpeas/gql/internal/exec.ExecuteProfiled(ctx *Ctx, p *plan.Plan) *explain.Profile
			func github.com/freeeve/gochickpeas/gql/internal/exec.RowEval.Eval(ctx *Ctx, row []value.Value, slots map[string]int) value.Value

	 type DecorTableKey (struct)
		DecorTableKey identifies one shared decorrelated side table.

		Fields (total 2)
			Anchor uint32
			Canon string

	 type FuncOp uint8 (basic type)
		FuncOp is a resolved scalar function; the compiled path carries this
		instead of the name string so per-row evaluation skips name dispatch.
		
		Purity contract: every FuncOp must be a pure function of its argument
		values -- deterministic, graph-less, no ambient state (no randomness,
		no clock). Constant folding, IN-list membership baking, carried-list
		hoisting, and pushdown placement all evaluate a resolved function
		fewer times than once-per-row on the strength of this contract, and
		none of them re-checks it. A volatile function (rand, a statement
		clock) must NOT be registered here: left unresolved, the compiler's
		interpreter fallback keeps it out of every one of those paths. The
		determinism roll call in funcop_test.go enforces the contract
		behaviorally for each registered op.

		As Outputs Of (at least one exported)
			func ResolveFuncOp(name string) (FuncOp, bool)
		As Inputs Of (at least one exported)
			func ApplyFunc(op FuncOp, argv []value.Value) value.Value
		As Types Of (total 51)
			const FuncAbs
			const FuncAcos
			const FuncAsin
			const FuncAtan
			const FuncCardinality
			const FuncCeil
			const FuncCharLength
			const FuncCoalesce
			const FuncCos
			const FuncDate
			const FuncDateTime
			const FuncDegrees
			const FuncDuration
			const FuncElementID
			const FuncExp
			const FuncFloor
			const FuncHead
			const FuncID
			const FuncIsNormalized
			const FuncLast
			const FuncLeft
			const FuncLength
			const FuncLn
			const FuncLocalDateTime
			const FuncLog10
			const FuncLower
			const FuncLTrim
			const FuncMod
			const FuncNodes
			const FuncNormalize
			const FuncNullIf
			const FuncPower
			const FuncRadians
			const FuncRange
			const FuncRels
			const FuncRight
			const FuncRound
			const FuncRTrim
			const FuncSign
			const FuncSin
			const FuncSize
			const FuncSqrt
			const FuncSubstring
			const FuncTail
			const FuncTan
			const FuncToBoolean
			const FuncToFloat
			const FuncToInteger
			const FuncToString
			const FuncTrim
			const FuncUpper


Package-Level Functions (total 20)

	 func ApplyDuration(tMillis, months, days, dMillis, sign int64) (int64, bool)
		ApplyDuration applies a duration (months, days, millis) to an
		epoch-millis temporal, sign = +1 (add) or -1 (subtract). Months are a
		calendar add (day clamped to the target month length, e.g. Jan 31 + 1
		month = Feb 28); days and millis are absolute. Every step is checked:
		ok=false on overflow, so the caller yields Null rather than a wrapped
		nonsense instant. Note the boundary -- shifting a recent instant by
		i64-scale milliseconds to a very negative-but-representable value is exact
		and stays ok; only a genuine overflow declines.

	 func ApplyFunc(op FuncOp, argv []value.Value) value.Value
		ApplyFunc applies a resolved scalar function to its evaluated arguments.

	 func Arith(op ast.BinOp, l, r value.Value) value.Value
		Arith is +, -, *, /: string + concatenates; temporal +/- duration is a
		calendar add; Int op Int is checked (overflow and division by zero
		yield Null -- eval has no per-row error channel, so Null is the honest
		result); mixed numerics coerce through float64, where division by zero
		is also Null. Shared with the compiled path.

	 func CivilFromDays(z int64) (y int64, m, d uint32)
		CivilFromDays is the inverse: civil (year, month, day) from days since
		1970-01-01.

	 func CmpBool(l, r value.Value, f func(int) bool) value.Value
		CmpBool maps a three-valued comparison through a predicate on the
		ordering; incomparable is Null. Shared with the compiled path.

	 func Component(millis int64, key string) (int64, bool)
		Component is a temporal component accessor (.year/.month/.day/.hour/...
		/.epochMillis) on an epoch-millis temporal; ok is false for an unknown
		component (the caller yields Null).

	 func Concat(l, r value.Value) value.Value
		Concat is the || operator: string or list concatenation only -- unlike
		+, it never adds numbers; any other operand pair is Null.

	 func DaysFromCivil(y int64, m, d uint32) int64
		DaysFromCivil is days since 1970-01-01 for a civil (year, month, day) --
		Howard Hinnant's algorithm.

	 func DaysInMonth(y int64, m uint32) uint32
		DaysInMonth is the day count of (year, month), accounting for leap years
		(used to clamp a calendar + duration).

	 func DurationComponent(months, days, millis int64, key string) (int64, bool)
		DurationComponent is a duration component accessor on a (months, days,
		millis) duration, with the groups independent (Neo4j's convention): the
		months group answers years/quarters/months (months is the group TOTAL,
		so duration({years: 1}).months = 12), the days group weeks/days, and
		the millis group hours/minutes/seconds/milliseconds (each the group
		total at that unit, so PT2H reads .minutes = 120). ok=false for an
		unknown component.

	 func Eval(ctx *Ctx, expr ast.Expr, row []value.Value, slots map[string]int) value.Value
		Eval evaluates expr against row (slot-indexed bindings).

	 func IsKnownScalarFunc(name string) bool
		IsKnownScalarFunc reports whether name is a scalar function the engine
		evaluates (case-insensitive): a ResolveFuncOp op or the graph-resolved
		startNode/endNode. The binder consults this to reject unknown function
		names at plan time rather than silently evaluating them to null.

	 func ISOString(millis int64, kind value.TemporalKind) string
		ISOString renders an epoch-millis temporal as ISO-8601, the inverse of
		ParseISO: 'YYYY-MM-DD' for a Date; 'YYYY-MM-DDTHH:MM:SS' for the datetime
		kinds, with '.mmm' appended only when the sub-second remainder is
		non-zero. This is the single temporal string formatter -- any other
		surface that stringifies a temporal should delegate here so the forms
		cannot drift.

	 func LitValue(ctx *Ctx, l ast.Literal) value.Value
		LitValue converts a parsed literal into a runtime value, resolving
		parameters from the context.

	 func ParseISO(s string) (int64, bool)
		ParseISO parses an ISO-ish temporal string into epoch milliseconds
		(UTC): YYYY-MM-DD, optionally THH:MM[:SS[.mmm]] and a trailing Z/offset
		(the offset is accepted but treated as UTC -- no real zone handling).
		ok is false on a malformed string.

	 func ParseISODuration(s string) (months, days, ms int64, ok bool)
		ParseISODuration parses an ISO-8601 duration string (PnYnMnWnD[TnHnMnS],
		e.g. 'P100D', 'PT12H', 'P1Y2M3DT4H5M6S') into calendar components:
		months, days, and sub-day milliseconds. A leading '-'/'+' sign negates the
		whole duration, and the seconds field accepts a millisecond fraction
		('PT1.5S'); ok is false on a malformed string or a component that overflows.

	 func ResolveFuncOp(name string) (FuncOp, bool)
		ResolveFuncOp resolves a scalar-function name (case-insensitive); ok is
		false for an unknown function (which yields null at evaluation).

	 func StrPred(op ast.BinOp, l, r value.Value) value.Value
		StrPred is a string predicate (STARTS WITH / ENDS WITH / CONTAINS):
		Bool when both operands are strings, Null otherwise. Shared with the
		compiled path.

	 func SubqueryCount(ctx *Ctx, pattern *ast.Pattern, where ast.Expr, outerRow []value.Value, outerSlots map[string]int, stopAtFirst bool) int
		SubqueryCount counts matches of a correlated subquery against the
		current outer row, anchoring pattern nodes that name an outer variable
		to their bound value. stopAtFirst short-circuits for EXISTS. A single
		fixed-length pattern (quantifiers are treated as one hop).

	 func SubqueryGroupCount(ctx *Ctx, pattern *ast.Pattern, where ast.Expr, outerRow []value.Value, outerSlots map[string]int, anchorVar, groupVar string) map[graph.NodeID]int
		SubqueryGroupCount evaluates a correlated subquery ONCE with the group
		variable left free, returning the match count bucketed by the node the
		group variable binds to. It is the decorrelated form of SubqueryCount:
		where SubqueryCount re-walks the pattern once per outer entity bound to
		the group variable, a single SubqueryGroupCount call -- anchored on the
		SHARED endpoint (anchorVar, still bound from the outer row) -- yields every
		entity's count in one pass over the anchored set, so the per-entity cost
		collapses from a walk to an O(1) map read.
		
		anchorVar must name an outer variable bound in outerRow; groupVar names the
		pattern endpoint to bucket by, left UNBOUND here even when it is itself an
		outer variable (its outer binding is ignored -- enumeration rebinds it per
		match). The returned map is keyed only by node id, so it is independent of
		what the outer query calls the group variable: two subqueries with the same
		pattern, WHERE, and anchor share one table (see task 084 / rustychickpeas
		091). The result for a given entity equals SubqueryCount with that entity
		bound -- the invariant the decor parity test asserts.


Package-Level Constants (total 52)

	const FuncAbs FuncOp = 13
		Resolved scalar functions.

	const FuncAcos FuncOp = 40
		Resolved scalar functions.

	const FuncAsin FuncOp = 39
		Resolved scalar functions.

	const FuncAtan FuncOp = 41
		Resolved scalar functions.

	const FuncCardinality FuncOp = 27
		Resolved scalar functions.

	const FuncCeil FuncOp = 14
		Resolved scalar functions.

	const FuncCharLength FuncOp = 26
		Resolved scalar functions.

	const FuncCoalesce FuncOp = 23
		Resolved scalar functions.

	const FuncCos FuncOp = 37
		Resolved scalar functions.

	const FuncDate FuncOp = 0
		Resolved scalar functions.

	const FuncDateTime FuncOp = 1
		Resolved scalar functions.

	const FuncDegrees FuncOp = 42
		Resolved scalar functions.

	const FuncDuration FuncOp = 3
		Resolved scalar functions.

	const FuncElementID FuncOp = 48
		Resolved scalar functions.

	const FuncExp FuncOp = 33
		Resolved scalar functions.

	const FuncFloor FuncOp = 15
		Resolved scalar functions.

	const FuncHead FuncOp = 45
		Resolved scalar functions.

	const FuncID FuncOp = 12
		Resolved scalar functions.

	const FuncIsNormalized FuncOp = 50
		Resolved scalar functions.

	const FuncLast FuncOp = 46
		Resolved scalar functions.

	const FuncLeft FuncOp = 9
		Resolved scalar functions.

	const FuncLength FuncOp = 4
		Resolved scalar functions.

	const FuncLn FuncOp = 34
		Resolved scalar functions.

	const FuncLocalDateTime FuncOp = 2
		Resolved scalar functions.

	const FuncLog10 FuncOp = 35
		Resolved scalar functions.

	const FuncLower FuncOp = 24
		Resolved scalar functions.

	const FuncLTrim FuncOp = 29
		Resolved scalar functions.

	const FuncMod FuncOp = 31
		Resolved scalar functions.

	const FuncNodes FuncOp = 5
		Resolved scalar functions.

	const FuncNormalize FuncOp = 49
		Resolved scalar functions.

	const FuncNullIf FuncOp = 44
		Resolved scalar functions.

	const FuncPower FuncOp = 32
		Resolved scalar functions.

	const FuncRadians FuncOp = 43
		Resolved scalar functions.

	const FuncRange FuncOp = 8
		Resolved scalar functions.

	const FuncRels FuncOp = 6
		Resolved scalar functions.

	const FuncRight FuncOp = 10
		Resolved scalar functions.

	const FuncRound FuncOp = 16
		Resolved scalar functions.

	const FuncRTrim FuncOp = 30
		Resolved scalar functions.

	const FuncSign FuncOp = 17
		Resolved scalar functions.

	const FuncSin FuncOp = 36
		Resolved scalar functions.

	const FuncSize FuncOp = 7
		Resolved scalar functions.

	const FuncSqrt FuncOp = 18
		Resolved scalar functions.

	const FuncSubstring FuncOp = 11
		Resolved scalar functions.

	const FuncTail FuncOp = 47
		Resolved scalar functions.

	const FuncTan FuncOp = 38
		Resolved scalar functions.

	const FuncToBoolean FuncOp = 22
		Resolved scalar functions.

	const FuncToFloat FuncOp = 19
		Resolved scalar functions.

	const FuncToInteger FuncOp = 20
		Resolved scalar functions.

	const FuncToString FuncOp = 21
		Resolved scalar functions.

	const FuncTrim FuncOp = 28
		Resolved scalar functions.

	const FuncUpper FuncOp = 25
		Resolved scalar functions.

	const MSPerDay int64 = 86400000
		MSPerDay is the milliseconds in a civil day.

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.