Uses of Interface
dev.frostlake.executor.expressions.Expression

Packages that use Expression

Package	Description
dev.frostlake.executor
dev.frostlake.executor.expressions
dev.frostlake.executor.operators
dev.frostlake.executor.procedural

Uses of Expression in dev.frostlake.executor

Methods in dev.frostlake.executor that return Expression

Modifier and Type	Method	Description
static Expression	ExpressionEvaluator.parse(String expression)	Parse an expression string into an Expression AST — the parse-once entry point for operators that previously re-evaluated the same text once per row.
static Expression	DeclarationTypes.sqlExpression(FrostlakeParser.ExpressionContext initialiser)	The initialiser as a SQL expression, or null when it cannot be read as one.
Expression	ExpressionEvaluator.withNarrowingCastEqualitiesAnswered(Expression predicate)	A filter's predicate with the narrowing casts live answers without converting dropped: see ExpressionEvaluatorVisitor.withNarrowingCastEqualitiesAnswered(dev.frostlake.executor.expressions.Expression).

Methods in dev.frostlake.executor with parameters of type Expression

Modifier and Type	Method	Description
String	ExpressionEvaluator.argumentTypeText(Expression expression)	How Snowflake NAMES an expression's type when it refuses it as an argument — VARCHAR(7) for a seven-character literal, VARCHAR(50) for a declared column, NUMBER(1,0), DATE.
String	ExpressionEvaluator.collationOf(Expression expression)	The collation expression carries, lower-cased, or null for none — see ExpressionEvaluatorVisitor.collationOf(dev.frostlake.executor.expressions.Expression).
boolean	ExpressionEvaluator.countsStoredColumn(Expression argument)	Whether a COUNT over argument is answered from the statistics: over a constant or a stored column (see ExpressionEvaluatorVisitor#countsStoredColumn).
Object	ExpressionEvaluator.evaluate(Expression expression, Row row)	Evaluate an expression AST against a row (RECOMMENDED) This method is more efficient than string-based evaluation because the expression is already parsed.
ValueRange	ExpressionEvaluator.inferStaticRange(Expression expression)	The interval expression's values lie in, as the account's statistics would bound it, or null when none can be known.
DataType	ExpressionEvaluator.inferStaticType(Expression expression)	The type expression is statically KNOWN to produce in this table context, or null when it cannot be determined.
CollationSpec	ExpressionEvaluator.keyCollation(Expression expression)	The collation an ORDER BY, GROUP BY, DISTINCT, PARTITION BY or set-operation key compares under.
static DataType	DeclarationTypes.ofExpression(Expression expression, Map<String,DataType> typesInScope, QueryExecutor queryExecutor)
String	ExpressionEvaluator.qualifiedAggregateText(Expression expression)	ExpressionEvaluator.qualifiedText(dev.frostlake.executor.expressions.Expression) for an aggregate call that a NESTING message brackets: a plain AVG at that root prints as its SUM half, the way live names it — see ExpressionEvaluatorVisitor.strictAggregateText(dev.frostlake.executor.expressions.Expression).
String	ExpressionEvaluator.qualifiedText(Expression expression)	How Snowflake RE-PRINTS an expression when it names it in a refusal: from the analysed plan, so a bare column reference comes back qualified with the name its relation is known by in scope — n over FROM eb prints EB.N, and over FROM eb x prints X.N.
void	ExpressionEvaluator.rejectArgumentFamilies(Expression expression)	Applies the argument-family refusals to every call in expression from declared types, before any row is read — see ExpressionEvaluatorVisitor.rejectArgumentFamilies(dev.frostlake.executor.expressions.Expression).
boolean	ExpressionEvaluator.resolvesToAFunctionName(Expression expression)	PHASE TWO as a QUESTION rather than a refusal.
DataType	ExpressionEvaluator.spelledNumber(Expression expression)	The NUMBER expression spells when it is a bare string literal, or a column carrying one out of a derived relation — what a projected column hands on so a conditional over it folds as live folds the literal (see TableColumn#getSpelledNumber); null for anything else.
static DataType	DeclarationTypes.staticType(Expression expression, Map<String,DataType> typesInScope, QueryExecutor queryExecutor)	The static type an expression carries over the declared types in scope, as SQL types it — before any widening a declaration applies.
DataType	ProceduralExecutor.typeOfSqlInitialiser(Expression sqlInitialiser)	The type an untyped declaration takes from an initialiser ProceduralExecutor.inferUntypedDeclarationType(dev.frostlake.executor.procedural.BaseExpression) does not type directly — see DeclarationTypes — over the declared types in scope.
void	ExpressionEvaluator.validateBooleanPositions(Expression expression)	The BOOLEAN positions inside expression — a searched CASE's WHEN conditions, IFF's condition — judged at plan time on their static types, for a path that evaluates values before the strict walk would type them (the FROM-less select list).
void	ExpressionEvaluator.validateCollations(Expression expression)	A JOIN condition's collation rules, judged before any row is read — see ExpressionEvaluatorVisitor.validateCollations(dev.frostlake.executor.expressions.Expression).
void	ExpressionEvaluator.validateColumnScope(Expression expression)	PHASE ONE of the plan-time walk: every column reference, and nothing else.
void	ExpressionEvaluator.validateFunctionNames(Expression expression)	PHASE TWO: every call's NAME, and nothing else.
void	ExpressionEvaluator.validateKey(Expression expression, SortKeyRole role)	Key-position validation: Snowflake rejects a FILE-typed expression used as a GROUP BY, ORDER BY or window PARTITION BY key at compile time, while leaving it usable everywhere else (equality, DISTINCT, joins).
void	ExpressionEvaluator.validateOrderedValue(Expression expression)	WITHIN GROUP (ORDER BY …) value validation: Snowflake rejects a semi-structured value in the position an ordering aggregate accumulates, with the same "incompatible types" sentence MEDIAN uses for its argument.
void	ExpressionEvaluator.validatePredicate(Expression expression)	Predicate-position validation (Snowflake rejects VARCHAR/NUMBER-typed WHERE, HAVING and QUALIFY conditions at compile time) — run once per query on the parsed predicate before row evaluation.
void	ExpressionEvaluator.validateStrict(Expression expression)	Plan-time strict-argument validation over a parsed expression: runs the Snowflake argument-type checks for every function call in expression WITHOUT evaluating it, so rejection fires even over zero input rows.
void	ExpressionEvaluator.validateStrictWindowed(Expression expression)	ExpressionEvaluator.validateStrict(dev.frostlake.executor.expressions.Expression) for a WINDOW call re-formed without its OVER clause — the walk runs with the windowed marker set, so the bare-form desugared-name rewrites stay off (live reports the WRITTEN name for windowed forms, measured).
void	ExpressionEvaluator.validateUdfArguments(Expression expression)	The plan-time user-defined function argument check alone, over a parsed expression.
Expression	ExpressionEvaluator.withNarrowingCastEqualitiesAnswered(Expression predicate)	A filter's predicate with the narrowing casts live answers without converting dropped: see ExpressionEvaluatorVisitor.withNarrowingCastEqualitiesAnswered(dev.frostlake.executor.expressions.Expression).

Uses of Expression in dev.frostlake.executor.expressions

Classes in dev.frostlake.executor.expressions that implement Expression

Modifier and Type	Class	Description
class	ArrayAccessExpression	Represents array element access (e.g., arr[0], data[index])
class	BetweenExpression	Represents a BETWEEN expression (e.g., x BETWEEN 1 AND 10)
class	BinaryOperationExpression	Represents a binary operation (e.g., a + b, x > 5, name = 'Alice')
class	BindVariableExpression	A :name bind-variable reference — inside a Snowflake Scripting block, SQL statements refer to the block's variables (and a procedure's parameters) as :name.
class	CaseExpression	Represents a CASE expression
class	CastExpression	Represents a type cast (e.g., CAST(x AS INTEGER), x::VARCHAR).
class	ColumnReferenceExpression	Represents a column reference (e.g., "name", "users.id", "u.name")
class	ConnectByRootExpression	CONNECT_BY_ROOT <column>: the column's value on the ROOT row of the hierarchy branch that produced the current row.
class	DefaultMarkerExpression	The bare word DEFAULT where a DML value is expected — INSERT … VALUES (DEFAULT), UPDATE t SET c = DEFAULT, and the same two inside MERGE.
class	ExecuteImmediateExpression	EXECUTE IMMEDIATE <sql-expr> [USING (v1, v2, …)] used as an expression: the SQL string (itself an expression — a literal, bind variable, concatenation, …) is evaluated, any USING values are bound to its ? placeholders, the dynamic statement is executed, and its first column of the first row is returned (scalar), like a scalar subquery.
class	FunctionCallExpression	Represents a function call (e.g., UPPER(name), COUNT(*), SUM(salary))
class	InExpression	Represents an IN expression (e.g., x IN (1, 2, 3) or x IN (SELECT ...))
class	IntervalExpression	Represents an INTERVAL expression (e.g., INTERVAL '10' DAY)
class	IsNullExpression	Represents an x IS NULL / x IS NOT NULL test.
class	JsonArrayExpression	Represents a JSON array literal (e.g., [1, 2, 3])
class	JsonObjectExpression	Represents a JSON object literal (e.g., {'name': 'Alice', 'age': 30})
class	LambdaExpression	A lambda argument to a higher-order function — <param> -> <body> or (<param>, …) -> <body> (e.g.
class	LikeAnyAllExpression	Snowflake multi-pattern matching: x LIKE ANY (p1, p2, …), x LIKE ALL (…) and x ILIKE ANY (…), with an optional shared ESCAPE.
class	LiteralExpression	Represents a literal value (string, number, boolean, null)
class	ObjectAccessExpression	Represents object property access (e.g., data:name, json:address:city).
class	PriorExpression	PRIOR <column> inside a CONNECT BY predicate: the column's value on the PARENT row of the hierarchy step being considered, as opposed to the candidate child row every other reference reads.
class	QuantifiedComparisonExpression	Represents a quantified comparison expression (e.g., x > ANY (subquery))
class	SessionVarExpression
class	SpreadExpression	The spread operator **<expr>: inside an array constructor or a function argument list the inner ARRAY's elements are spliced in as individual elements/arguments; inside an object constructor the inner OBJECT's pairs are merged in.
class	SubqueryExpression	Represents a subquery expression (scalar subquery or EXISTS)
class	SystemStreamHasDataExpression
class	SystemUserTaskCancelExpression
final class	TupleInExpression	Row-constructor IN test: (a, b) IN (SELECT x, y ...), (a, b) IN ((1, 2), (3, 4)), or the type-invalid flat spelling (a, b) IN (1, 2).
class	UnaryOperationExpression	Represents a unary operation (e.g., NOT x, -5, EXISTS(...))
class	WindowFunctionExpression	A window function call (one carrying an OVER clause) that appears nested inside a larger expression — e.g.

Methods in dev.frostlake.executor.expressions that return Expression

Modifier and Type	Method	Description
Expression	ExpressionAstBuilder.build(FrostlakeParser.BooleanExprContext ctx)	Build an Expression AST from a parsed booleanExpr (top) context.
Expression	ArrayAccessExpression.getArray()
Expression	ObjectAccessExpression.getBase()
Expression	LambdaExpression.getBody()
Expression	WhenClause.getCondition()
Expression	CaseExpression.getElseExpression()
Expression	BinaryOperationExpression.getEscape()	The LIKE/ILIKE ESCAPE character expression, or null if the query had no ESCAPE clause.
Expression	LikeAnyAllExpression.getEscape()
Expression	CastExpression.getExpression()
Expression	ArrayAccessExpression.getIndex()
Expression	SpreadExpression.getInner()
Expression	BinaryOperationExpression.getLeft()
Expression	QuantifiedComparisonExpression.getLeft()
Expression	BetweenExpression.getLower()
Expression	FunctionCallExpression.getNameExpression()
Expression	IsNullExpression.getOperand()
Expression	UnaryOperationExpression.getOperand()
Expression	WhenClause.getResult()
Expression	BinaryOperationExpression.getRight()
Expression	ExecuteImmediateExpression.getSqlExpression()
Expression	SystemStreamHasDataExpression.getStreamNameExpr()
Expression	LikeAnyAllExpression.getSubject()
Expression	QuantifiedComparisonExpression.getSubquery()
Expression	SystemUserTaskCancelExpression.getTaskNameExpr()
Expression	BetweenExpression.getUpper()
Expression	BetweenExpression.getValue()
Expression	InExpression.getValue()
Expression	IntervalExpression.getValueExpression()
Expression	FunctionCallExpression.getWithinGroupOrdered()	The expression a trailing WITHIN GROUP orders by — see FunctionCallExpression.describeWithinGroup(dev.frostlake.executor.expressions.Expression).
Expression	WindowFunctionExpression.getWithinGroupOrdered()	The WITHIN GROUP (ORDER BY …) key, or null when the call carries no such clause.
static Expression	AntlrExpressionParser.parse(String expression)	Parses the expression string into an Expression AST: AntlrExpressionParser.parseTree(String) for the grammar's parse tree, then ExpressionAstBuilder to turn it into AST nodes.
Expression	ExpressionAstBuilder.visitAdditiveExpr(FrostlakeParser.AdditiveExprContext ctx)
Expression	ExpressionAstBuilder.visitAndExpr(FrostlakeParser.AndExprContext ctx)
Expression	ExpressionAstBuilder.visitAnsiSubstringExpr(FrostlakeParser.AnsiSubstringExprContext ctx)	The ANSI SUBSTRING(<x> FROM <a> FOR <b>) spelling, which Snowflake refuses for every function name there is — SUBSTRING included.
Expression	ExpressionAstBuilder.visitArrayAccessExpr(FrostlakeParser.ArrayAccessExprContext ctx)
Expression	ExpressionAstBuilder.visitBetweenExpr(FrostlakeParser.BetweenExprContext ctx)
Expression	ExpressionAstBuilder.visitBindVarExpr(FrostlakeParser.BindVarExprContext ctx)
Expression	ExpressionAstBuilder.visitCaseExpr(FrostlakeParser.CaseExprContext ctx)
Expression	ExpressionAstBuilder.visitCastExpr(FrostlakeParser.CastExprContext ctx)
Expression	ExpressionAstBuilder.visitCastExpr2(FrostlakeParser.CastExpr2Context ctx)
Expression	ExpressionAstBuilder.visitChildren(org.antlr.v4.runtime.tree.RuleNode node)	Backstop for any expression alternative not explicitly handled above.
Expression	ExpressionAstBuilder.visitCollateExpr(FrostlakeParser.CollateExprContext ctx)
Expression	ExpressionAstBuilder.visitCollateFuncExpr(FrostlakeParser.CollateFuncExprContext ctx)
Expression	ExpressionAstBuilder.visitComparisonExpr(FrostlakeParser.ComparisonExprContext ctx)
Expression	ExpressionAstBuilder.visitConcatExpr(FrostlakeParser.ConcatExprContext ctx)
Expression	ExpressionAstBuilder.visitConnectByRootExpr(FrostlakeParser.ConnectByRootExprContext ctx)	CONNECT_BY_ROOT <column> — the hierarchy root row's value of that column.
Expression	ExpressionAstBuilder.visitCurrentDateExpr(FrostlakeParser.CurrentDateExprContext ctx)
Expression	ExpressionAstBuilder.visitCurrentTimeExpr(FrostlakeParser.CurrentTimeExprContext ctx)
Expression	ExpressionAstBuilder.visitCurrentTimestampExpr(FrostlakeParser.CurrentTimestampExprContext ctx)
Expression	ExpressionAstBuilder.visitCurrentUserExpr(FrostlakeParser.CurrentUserExprContext ctx)
Expression	ExpressionAstBuilder.visitExistsExpr(FrostlakeParser.ExistsExprContext ctx)
Expression	ExpressionAstBuilder.visitExtractFromExpr(FrostlakeParser.ExtractFromExprContext ctx)
Expression	ExpressionAstBuilder.visitFieldAccessExpr(FrostlakeParser.FieldAccessExprContext ctx)
Expression	ExpressionAstBuilder.visitFunctionCallExpr(FrostlakeParser.FunctionCallExprContext ctx)
Expression	ExpressionAstBuilder.visitFunctionCallMixedArgsExpr(FrostlakeParser.FunctionCallMixedArgsExprContext ctx)
Expression	ExpressionAstBuilder.visitFunctionCallNamedArgsExpr(FrostlakeParser.FunctionCallNamedArgsExprContext ctx)
Expression	ExpressionAstBuilder.visitFunctionCallStarExpr(FrostlakeParser.FunctionCallStarExprContext ctx)
Expression	ExpressionAstBuilder.visitInListExpr(FrostlakeParser.InListExprContext ctx)
Expression	ExpressionAstBuilder.visitInSubqueryExpr(FrostlakeParser.InSubqueryExprContext ctx)
Expression	ExpressionAstBuilder.visitIntervalExpr(FrostlakeParser.IntervalExprContext ctx)
Expression	ExpressionAstBuilder.visitIntervalStringExpr(FrostlakeParser.IntervalStringExprContext ctx)
Expression	ExpressionAstBuilder.visitIsDistinctExpr(FrostlakeParser.IsDistinctExprContext ctx)
Expression	ExpressionAstBuilder.visitIsNullExpr(FrostlakeParser.IsNullExprContext ctx)
Expression	ExpressionAstBuilder.visitJsonArrayExpr(FrostlakeParser.JsonArrayExprContext ctx)
Expression	ExpressionAstBuilder.visitJsonObjectExpr(FrostlakeParser.JsonObjectExprContext ctx)
Expression	ExpressionAstBuilder.visitLikeAnyAllExpr(FrostlakeParser.LikeAnyAllExprContext ctx)
Expression	ExpressionAstBuilder.visitLikeExpr(FrostlakeParser.LikeExprContext ctx)
Expression	ExpressionAstBuilder.visitLiteralExpr(FrostlakeParser.LiteralExprContext ctx)	A literal, STAMPED with where it was written.
Expression	ExpressionAstBuilder.visitMultiplicativeExpr(FrostlakeParser.MultiplicativeExprContext ctx)
Expression	ExpressionAstBuilder.visitNotExpr(FrostlakeParser.NotExprContext ctx)
Expression	ExpressionAstBuilder.visitObjectAccessExpr(FrostlakeParser.ObjectAccessExprContext ctx)
Expression	ExpressionAstBuilder.visitOrExpr(FrostlakeParser.OrExprContext ctx)
Expression	ExpressionAstBuilder.visitOuterJoinColumnExpr(FrostlakeParser.OuterJoinColumnExprContext ctx)	column(+) — the Oracle legacy outer-join marker.
Expression	ExpressionAstBuilder.visitParenExpr(FrostlakeParser.ParenExprContext ctx)
Expression	ExpressionAstBuilder.visitPositionalBindExpr(FrostlakeParser.PositionalBindExprContext ctx)
Expression	ExpressionAstBuilder.visitPositionInExpr(FrostlakeParser.PositionInExprContext ctx)
Expression	ExpressionAstBuilder.visitPriorExpr(FrostlakeParser.PriorExprContext ctx)	PRIOR <column> — the parent-row side of a CONNECT BY step.
Expression	ExpressionAstBuilder.visitQualifiedNameExpr(FrostlakeParser.QualifiedNameExprContext ctx)
Expression	ExpressionAstBuilder.visitQuantifiedComparisonExpr(FrostlakeParser.QuantifiedComparisonExprContext ctx)
Expression	ExpressionAstBuilder.visitRlikeExpr(FrostlakeParser.RlikeExprContext ctx)
Expression	ExpressionAstBuilder.visitScalarSubqueryExpr(FrostlakeParser.ScalarSubqueryExprContext ctx)
Expression	ExpressionAstBuilder.visitSearchedCaseExpr(FrostlakeParser.SearchedCaseExprContext ctx)
Expression	ExpressionAstBuilder.visitSessionVarExpr(FrostlakeParser.SessionVarExprContext ctx)
Expression	ExpressionAstBuilder.visitSimpleCaseExpr(FrostlakeParser.SimpleCaseExprContext ctx)
Expression	ExpressionAstBuilder.visitSystemFuncExpr(FrostlakeParser.SystemFuncExprContext ctx)
Expression	ExpressionAstBuilder.visitSystemStreamHasDataExpr(FrostlakeParser.SystemStreamHasDataExprContext ctx)
Expression	ExpressionAstBuilder.visitSystemUserTaskCancelExpr(FrostlakeParser.SystemUserTaskCancelExprContext ctx)
Expression	ExpressionAstBuilder.visitTryCastExpr(FrostlakeParser.TryCastExprContext ctx)
Expression	ExpressionAstBuilder.visitTupleInFlatListExpr(FrostlakeParser.TupleInFlatListExprContext ctx)
Expression	ExpressionAstBuilder.visitTupleInListExpr(FrostlakeParser.TupleInListExprContext ctx)
Expression	ExpressionAstBuilder.visitTupleInSubqueryExpr(FrostlakeParser.TupleInSubqueryExprContext ctx)
Expression	ExpressionAstBuilder.visitTypedDateTimeLiteralExpr(FrostlakeParser.TypedDateTimeLiteralExprContext ctx)
Expression	ExpressionAstBuilder.visitTypedLiteralArgExpr(FrostlakeParser.TypedLiteralArgExprContext ctx)	An IDENTIFIER followed by a STRING inside a call, which live reads as a TYPED LITERAL and refuses by NAME rather than by syntax: TRIM(BOTH ' ') is "Unsupported data type literal 'BOTH ' ''" there, and UPPER(FOO ' ') is the same sentence with the same shape — so it is not a TRIM rule, it is the DATE '2020-01-01' form with an unknown word in front.
Expression	ExpressionAstBuilder.visitUnaryExpr(FrostlakeParser.UnaryExprContext ctx)
Expression	ExpressionAstBuilder.visitValueExpr(FrostlakeParser.ValueExprContext ctx)	Boolean tier value alternative: drop straight through to the underlying value expression.
Expression	ExpressionEvaluatorVisitor.withNarrowingCastEqualitiesAnswered(Expression predicate)	A WHERE's or ON's predicate with live's one exemption from the width check applied.

Methods in dev.frostlake.executor.expressions that return types with arguments of type Expression

Modifier and Type	Method	Description
List<Expression>	FunctionCallExpression.getArguments()
List<Expression>	WindowFunctionExpression.getArguments()
List<Expression>	JsonArrayExpression.getElements()
List<Expression>	TupleInExpression.getFlatListValues()
List<Expression>	WindowFunctionExpression.getOrderKeys()
List<Expression>	WindowFunctionExpression.getPartitionKeys()	The PARTITION BY keys, or null when the OVER clause was never described.
List<Expression>	LikeAnyAllExpression.getPatterns()
Map<String,Expression>	JsonObjectExpression.getProperties()
List<List<Expression>>	TupleInExpression.getTupleRows()
List<Expression>	ExecuteImmediateExpression.getUsingBindings()	The USING bind expressions (bound positionally to ? placeholders), or null/empty if none.
List<Expression>	InExpression.getValues()
List<Expression>	TupleInExpression.getValues()

Methods in dev.frostlake.executor.expressions with parameters of type Expression

Modifier and Type	Method	Description
String	ExpressionEvaluatorVisitor.argumentTypeText(Expression arg)	The type name live prints when it refuses an argument, for callers outside the strict-argument walk — the table-function parameter checks name their offending argument the same way.
ExpressionCollation	ExpressionEvaluatorVisitor.collationOf(Expression expr)	The collation expr carries, and the level it holds it at (see CollationLevel).
boolean	ExpressionEvaluatorVisitor.countsStoredColumn(Expression argument)	Whether a COUNT over argument is answered from the statistics: over a constant, or over a column that is one of the catalog table's stored columns — a derived relation's too, where it passes one through unchanged.
void	FunctionCallExpression.describeWithinGroup(Expression ordered)	Record the expression a trailing WITHIN GROUP (ORDER BY …) orders by.
void	WindowFunctionExpression.describeWithinGroup(Expression ordered)	Record the call's WITHIN GROUP (ORDER BY …) key, which is where an ORDERED aggregate's VALUES come from — for a percentile the arguments carry only the fraction, so a node without this has nothing to type from but the fraction, and typed the fraction.
ValueRange	ExpressionEvaluatorVisitor.inferStaticRange(Expression expr)	The interval expr's values lie in, or null when none can be known.
DataType	ExpressionEvaluatorVisitor.inferStaticType(Expression expr)	The statically-known type of expr in this table context, or null when undetermined — the projection-time entry point that gives a derived relation's columns their declared types.
static boolean	ImpliedTextNumber.isTextLiteral(Expression expr)	Whether an expression is a text literal, whose reading keeps its own scale.
static String	AstPrinterVisitor.print(Expression expression)	Convenience: render an expression to its canonical string.
void	ExpressionEvaluatorVisitor.rejectArgumentFamilies(Expression expr)	Applies every function's argument-family refusals to the calls in expr from their DECLARED types, before any row is read — the check the row loop makes for each call, brought forward so that an aggregate over an empty table is refused as live refuses it: SELECT AVG(bo) FROM t WHERE FALSE is "Invalid argument types for function 'SUM': (BOOLEAN)" at the call on the account, not NULL.
DataType	ExpressionEvaluatorVisitor.spelledNumber(Expression expr)	The NUMBER expr spells when it is a bare string literal, or a column that carries one out of a derived relation, else null — see TableColumn#getSpelledNumber.
String	ExpressionEvaluatorVisitor.strictAggregateText(Expression expr)	ExpressionEvaluatorVisitor.strictText(dev.frostlake.executor.expressions.Expression) for one of the two calls a NESTING message brackets: a plain AVG at that root is named by its SUM half rather than its whole definition — see StrictMessagePrinter.averageSumHalf(dev.frostlake.executor.expressions.Expression).
String	ExpressionEvaluatorVisitor.strictConversionText(Expression expr)	ExpressionEvaluatorVisitor.strictText(dev.frostlake.executor.expressions.Expression) as an invalid-type sentence quotes an operand: its conversions spelled as the functions the plan made of them, TO_VECTOR(ARRAY_CONSTRUCT(1, 2, 3)) and FIXED_TO_FIXED(1 AS NUMBER(10,2)[UNKNOWN]) — see StrictPrintMode.CONVERSION.
String	ExpressionEvaluatorVisitor.strictPlanText(Expression expr)	ExpressionEvaluatorVisitor.strictText(dev.frostlake.executor.expressions.Expression) in the plan-shaped mode — the aggregate, cast and scalar rewrites live's plan applies before it names an operand — for the sentences that re-print an operand from the plan, such as a conversion refusal's parameter.
String	ExpressionEvaluatorVisitor.strictText(Expression expr)	The expression as a strictness message renders it: live prints the call from its analysed plan, so a column reference comes out qualified with its source relation (TO_VARCHAR(FK.F), CAST(STT.SO AS …)) — see StrictMessagePrinter.
void	ExpressionEvaluatorVisitor.validateBooleanPositions(Expression expr)	The BOOLEAN positions inside a predicate — a searched CASE's WHEN conditions and the ExpressionEvaluatorVisitor.BOOLEAN_STRICT_ARGS calls — judged at plan time, so that WHERE CASE WHEN g THEN TRUE END over a VARCHAR refuses over an empty table exactly as it does in a SELECT list.
void	ExpressionEvaluatorVisitor.validateCollations(Expression expr)	The collation rules alone, walked over a JOIN's ON condition before any pair of rows is read: AND, OR and NOT are descended, and every comparison, LIKE, IN list and BETWEEN beneath them settles its operands' collations — so two that disagree are refused over tables with no rows, as they are live, rather than surfacing only when a pair happens to be compared.
void	ExpressionEvaluatorVisitor.validateColumnScopeOnly(Expression expression)	PHASE ONE of the plan-time walk: every column reference in expression, nothing else.
void	ExpressionEvaluatorVisitor.validateFunctionNamesOnly(Expression expression)	PHASE TWO: every call NAME in expression, nothing else.
void	ExpressionEvaluatorVisitor.validateGeoComparisons(Expression expr)	The GEOSPATIAL comparison rules alone, walked over a PREDICATE.
void	ExpressionEvaluatorVisitor.validateKeyExpression(Expression expr, SortKeyRole role)	Plan-time rejection of a FILE or a GEOSPATIAL value in a GROUPING / SORTING key position.
void	ExpressionEvaluatorVisitor.validateOrderedValueExpression(Expression expr)	The value an ordering aggregate accumulates may not be semi-structured.
void	ExpressionEvaluatorVisitor.validatePredicateType(Expression predicate)	Predicate-position strictness: Snowflake rejects a WHERE, HAVING or QUALIFY condition whose static type is VARCHAR or NUMBER (live: "Invalid data type [VARCHAR(10)] for predicate [STRICT_T.S10]", "[NUMBER(38,0)] for predicate [T.N]", and "[VARCHAR(4)] for predicate ['true']" for a literal).
void	ExpressionEvaluatorVisitor.validateStrictArguments(Expression expr)
void	ExpressionEvaluatorVisitor.validateUdfArguments(Expression expr)	The user-defined function argument check alone, for a FROM-less select item: that path computes the item's value without the strict walk, so the one plan-time refusal it must not miss is run here on its own, before the value is (see ExpressionEvaluatorVisitor.rejectUncoercibleUdfArguments(java.lang.String, dev.frostlake.executor.expressions.FunctionCallExpression)).
Expression	ExpressionEvaluatorVisitor.withNarrowingCastEqualitiesAnswered(Expression predicate)	A WHERE's or ON's predicate with live's one exemption from the width check applied.

Method parameters in dev.frostlake.executor.expressions with type arguments of type Expression

Modifier and Type	Method	Description
void	WindowFunctionExpression.describeCall(String name, List<Expression> callArgs)	Record what the call IS, read off the parse tree when this node was built.
void	WindowFunctionExpression.describeOver(boolean distinctCall, List<Expression> partition, List<Expression> order, List<Boolean> ascending, List<Boolean> nullsFirst)	Describe the OVER clause itself, so a message can re-print the call the way live's plan spells it — every key qualified, every sort key with its direction and null placement, the frame and the null treatment dropped — rather than as the source text it was written in.
static TupleInExpression	TupleInExpression.ofFlatList(List<Expression> values, List<Expression> flatListValues, boolean not)
static TupleInExpression	TupleInExpression.ofSubquery(List<Expression> values, SubqueryExpression subquery, boolean not)
static TupleInExpression	TupleInExpression.ofTupleRows(List<Expression> values, List<List<Expression>> tupleRows, boolean not)
FunctionCallExpression	FunctionCallExpression.withArguments(List<Expression> spliced)	This call with another argument list and everything else as written — a star spliced in place.

Constructors in dev.frostlake.executor.expressions with parameters of type Expression

Modifier	Constructor	Description
	ArrayAccessExpression(Expression array, Expression index)
	BetweenExpression(Expression value, Expression lower, Expression upper, boolean not)
	BinaryOperationExpression(Expression left, BinaryOperator operator, Expression right)
	BinaryOperationExpression(Expression left, BinaryOperator operator, Expression right, Expression escape)
	CaseExpression(List<WhenClause> whenClauses, Expression elseExpression)
	CastExpression(Expression expression, String targetType)
	CastExpression(Expression expression, String targetType, boolean tryMode)
	CastExpression(Expression expression, String targetType, boolean tryMode, DataType declaredTarget, CastFieldsModifier fieldsModifier)
	ExecuteImmediateExpression(Expression sqlExpression, List<Expression> usingBindings)
	FunctionCallExpression(String displayName, Expression nameExpression, List<Expression> arguments)	A dynamically named call — IDENTIFIER('fn')(args): displayName keeps the source text (for printing/HAVING matching); nameExpression yields the actual function name.
	InExpression(Expression value, SubqueryExpression subquery, boolean not)
	InExpression(Expression value, List<Expression> values, boolean not)
	IntervalExpression(Expression valueExpression, IntervalUnit unit)
	IntervalExpression(Expression valueExpression, IntervalUnit unit, IntervalExpression rest)
	IsNullExpression(Expression operand, boolean not)
	LambdaExpression(List<String> parameters, List<String> parameterTypes, Expression body)
	LikeAnyAllExpression(Expression subject, List<Expression> patterns, boolean all, boolean caseInsensitive, Expression escape)
	ObjectAccessExpression(Expression base, List<String> pathParts)
	QuantifiedComparisonExpression(Expression left, BinaryOperator operator, Quantifier quantifier, Expression subquery)
	SpreadExpression(Expression inner)
	SystemStreamHasDataExpression(Expression streamNameExpr)
	SystemUserTaskCancelExpression(Expression taskNameExpr)
	UnaryOperationExpression(UnaryOperator operator, Expression operand)
	WhenClause(Expression condition, Expression result)
	WhenClause(Expression condition, Expression result, boolean operandMatch)	A WHEN of either CASE form.

Constructor parameters in dev.frostlake.executor.expressions with type arguments of type Expression

Modifier	Constructor	Description
	ExecuteImmediateExpression(Expression sqlExpression, List<Expression> usingBindings)
	FunctionCallExpression(String displayName, Expression nameExpression, List<Expression> arguments)	A dynamically named call — IDENTIFIER('fn')(args): displayName keeps the source text (for printing/HAVING matching); nameExpression yields the actual function name.
	FunctionCallExpression(String functionName, List<Expression> arguments)
	FunctionCallExpression(String functionName, List<Expression> arguments, boolean distinct, boolean star)
	FunctionCallExpression(String functionName, List<Expression> arguments, List<String> argumentNames)
	InExpression(Expression value, List<Expression> values, boolean not)
	JsonArrayExpression(List<Expression> elements)
	JsonObjectExpression(Map<String,Expression> properties)
	LikeAnyAllExpression(Expression subject, List<Expression> patterns, boolean all, boolean caseInsensitive, Expression escape)

Uses of Expression in dev.frostlake.executor.operators

Methods in dev.frostlake.executor.operators with parameters of type Expression

Modifier and Type	Method	Description
boolean	HavingEvaluator.evaluate(Expression condition, Row aggregatedRow)
boolean	QualifyEvaluator.evaluate(Expression condition, Row row, int rowIndex)
Object	RowExpressionEvaluator.evaluate(Expression expression, Row row)	Evaluate a parsed expression AST on a row.

Constructors in dev.frostlake.executor.operators with parameters of type Expression

Modifier	Constructor	Description
	AsofJoinOperator(Table leftTable, Table rightTable, List<Row> rightRows, BinaryOperator matchOperator, Expression leftMatchExpression, RowExpressionEvaluator leftMatchEvaluator, Expression rightMatchExpression, RowExpressionEvaluator rightMatchEvaluator, JoinConditionEvaluator partitionEvaluator)

Uses of Expression in dev.frostlake.executor.procedural

Methods in dev.frostlake.executor.procedural that return Expression

Modifier and Type	Method	Description
Expression	SqlScalarExpression.getExpression()
Expression	ReturnStatement.getSqlExpression()
Expression	SetStatement.getSqlInitialiser()

Methods in dev.frostlake.executor.procedural with parameters of type Expression

Modifier and Type	Method	Description
void	ReturnStatement.setSqlExpression(Expression sqlExpression)
void	SetStatement.setSqlInitialiser(Expression sqlInitialiser)

Constructors in dev.frostlake.executor.procedural with parameters of type Expression

Modifier	Constructor	Description
	SqlScalarExpression(Expression expression)