partiql-lang/org.partiql.lang.eval.visitors/GroupKeyReferencesVisitorTransform

GroupKeyReferencesVisitorTransform

~~class~~ ~~GroupKeyReferencesVisitorTransform~~(~~keys~~: Map<String, PartiqlAst.GroupKey>, ~~groupAliases~~: Set<String>) : ~~VisitorTransformBase~~

Specifies any previously unspecified select list item aliases.

Turns:

SELECT groupKey AS projectionAlias
FROM source AS sourceTable
GROUP BY sourceTable.a AS groupKey(meta = UniqueNameMeta:someUniqueName)
ORDER BY groupKey

Into:

SELECT someUniqueName AS projectionAlias
FROM source AS sourceTable
GROUP BY sourceTable.a AS groupKey(meta = UniqueNameMeta:someUniqueName)
ORDER BY someUniqueName

If provided with a query with all of the select list aliases are already specified, an exact clone is returned.

Constructors

GroupKeyReferencesVisitorTransform

fun GroupKeyReferencesVisitorTransform(keys: Map<String, PartiqlAst.GroupKey> = emptyMap(), groupAliases: Set<String> = emptySet())

Functions

transformAnyElement

open fun transformAnyElement(node: AnyElement): AnyElement

transformAssignment

open fun transformAssignment(node: PartiqlAst.Assignment): PartiqlAst.Assignment

transformAssignment_metas

open fun transformAssignment_metas(node: PartiqlAst.Assignment): Map<String, Any>

transformAssignment_target

open fun transformAssignment_target(node: PartiqlAst.Assignment): PartiqlAst.Expr

transformAssignment_value

open fun transformAssignment_value(node: PartiqlAst.Assignment): PartiqlAst.Expr

transformBagOpType

open fun transformBagOpType(node: PartiqlAst.BagOpType): PartiqlAst.BagOpType

transformBagOpTypeExcept

open fun transformBagOpTypeExcept(node: PartiqlAst.BagOpType.Except): PartiqlAst.BagOpType

transformBagOpTypeExcept_metas

open fun transformBagOpTypeExcept_metas(node: PartiqlAst.BagOpType.Except): Map<String, Any>

transformBagOpTypeIntersect

open fun transformBagOpTypeIntersect(node: PartiqlAst.BagOpType.Intersect): PartiqlAst.BagOpType

transformBagOpTypeIntersect_metas

open fun transformBagOpTypeIntersect_metas(node: PartiqlAst.BagOpType.Intersect): Map<String, Any>

transformBagOpTypeOuterExcept

open fun transformBagOpTypeOuterExcept(node: PartiqlAst.BagOpType.OuterExcept): PartiqlAst.BagOpType

transformBagOpTypeOuterExcept_metas

open fun transformBagOpTypeOuterExcept_metas(node: PartiqlAst.BagOpType.OuterExcept): Map<String, Any>

transformBagOpTypeOuterIntersect

open fun transformBagOpTypeOuterIntersect(node: PartiqlAst.BagOpType.OuterIntersect): PartiqlAst.BagOpType

transformBagOpTypeOuterIntersect_metas

open fun transformBagOpTypeOuterIntersect_metas(node: PartiqlAst.BagOpType.OuterIntersect): Map<String, Any>

transformBagOpTypeOuterUnion

open fun transformBagOpTypeOuterUnion(node: PartiqlAst.BagOpType.OuterUnion): PartiqlAst.BagOpType

transformBagOpTypeOuterUnion_metas

open fun transformBagOpTypeOuterUnion_metas(node: PartiqlAst.BagOpType.OuterUnion): Map<String, Any>

transformBagOpTypeUnion

open fun transformBagOpTypeUnion(node: PartiqlAst.BagOpType.Union): PartiqlAst.BagOpType

transformBagOpTypeUnion_metas

open fun transformBagOpTypeUnion_metas(node: PartiqlAst.BagOpType.Union): Map<String, Any>

transformBoolPrimitive

open fun transformBoolPrimitive(b: BoolPrimitive): BoolPrimitive

transformBoolPrimitiveMetas

open fun transformBoolPrimitiveMetas(b: BoolPrimitive): MetaContainer

transformBoolPrimitiveValue

open fun transformBoolPrimitiveValue(sym: BoolPrimitive): Boolean

transformCaseSensitivity

open fun transformCaseSensitivity(node: PartiqlAst.CaseSensitivity): PartiqlAst.CaseSensitivity

transformCaseSensitivityCaseInsensitive

open fun transformCaseSensitivityCaseInsensitive(node: PartiqlAst.CaseSensitivity.CaseInsensitive): PartiqlAst.CaseSensitivity

transformCaseSensitivityCaseInsensitive_metas

open fun transformCaseSensitivityCaseInsensitive_metas(node: PartiqlAst.CaseSensitivity.CaseInsensitive): Map<String, Any>

transformCaseSensitivityCaseSensitive

open fun transformCaseSensitivityCaseSensitive(node: PartiqlAst.CaseSensitivity.CaseSensitive): PartiqlAst.CaseSensitivity

transformCaseSensitivityCaseSensitive_metas

open fun transformCaseSensitivityCaseSensitive_metas(node: PartiqlAst.CaseSensitivity.CaseSensitive): Map<String, Any>

transformColumnComponent

open fun transformColumnComponent(node: PartiqlAst.ColumnComponent): PartiqlAst.ColumnComponent

transformColumnComponentReturningColumn

open fun transformColumnComponentReturningColumn(node: PartiqlAst.ColumnComponent.ReturningColumn): PartiqlAst.ColumnComponent

transformColumnComponentReturningColumn_expr

open fun transformColumnComponentReturningColumn_expr(node: PartiqlAst.ColumnComponent.ReturningColumn): PartiqlAst.Expr

transformColumnComponentReturningColumn_metas

open fun transformColumnComponentReturningColumn_metas(node: PartiqlAst.ColumnComponent.ReturningColumn): Map<String, Any>

transformColumnComponentReturningWildcard

open fun transformColumnComponentReturningWildcard(node: PartiqlAst.ColumnComponent.ReturningWildcard): PartiqlAst.ColumnComponent

transformColumnComponentReturningWildcard_metas

open fun transformColumnComponentReturningWildcard_metas(node: PartiqlAst.ColumnComponent.ReturningWildcard): Map<String, Any>

transformColumnConstraint

open fun transformColumnConstraint(node: PartiqlAst.ColumnConstraint): PartiqlAst.ColumnConstraint

transformColumnConstraint_def

open fun transformColumnConstraint_def(node: PartiqlAst.ColumnConstraint): PartiqlAst.ColumnConstraintDef

transformColumnConstraint_metas

open fun transformColumnConstraint_metas(node: PartiqlAst.ColumnConstraint): Map<String, Any>

transformColumnConstraint_name

open fun transformColumnConstraint_name(node: PartiqlAst.ColumnConstraint): SymbolPrimitive?

transformColumnConstraintDef

open fun transformColumnConstraintDef(node: PartiqlAst.ColumnConstraintDef): PartiqlAst.ColumnConstraintDef

transformColumnConstraintDefColumnNotnull

open fun transformColumnConstraintDefColumnNotnull(node: PartiqlAst.ColumnConstraintDef.ColumnNotnull): PartiqlAst.ColumnConstraintDef

transformColumnConstraintDefColumnNotnull_metas

open fun transformColumnConstraintDefColumnNotnull_metas(node: PartiqlAst.ColumnConstraintDef.ColumnNotnull): Map<String, Any>

transformColumnConstraintDefColumnNull

open fun transformColumnConstraintDefColumnNull(node: PartiqlAst.ColumnConstraintDef.ColumnNull): PartiqlAst.ColumnConstraintDef

transformColumnConstraintDefColumnNull_metas

open fun transformColumnConstraintDefColumnNull_metas(node: PartiqlAst.ColumnConstraintDef.ColumnNull): Map<String, Any>

transformConflictAction

open fun transformConflictAction(node: PartiqlAst.ConflictAction): PartiqlAst.ConflictAction

transformConflictActionDoNothing

open fun transformConflictActionDoNothing(node: PartiqlAst.ConflictAction.DoNothing): PartiqlAst.ConflictAction

transformConflictActionDoNothing_metas

open fun transformConflictActionDoNothing_metas(node: PartiqlAst.ConflictAction.DoNothing): Map<String, Any>

transformConflictActionDoReplace

open fun transformConflictActionDoReplace(node: PartiqlAst.ConflictAction.DoReplace): PartiqlAst.ConflictAction

transformConflictActionDoReplace_condition

open fun transformConflictActionDoReplace_condition(node: PartiqlAst.ConflictAction.DoReplace): PartiqlAst.Expr?

transformConflictActionDoReplace_metas

open fun transformConflictActionDoReplace_metas(node: PartiqlAst.ConflictAction.DoReplace): Map<String, Any>

transformConflictActionDoReplace_value

open fun transformConflictActionDoReplace_value(node: PartiqlAst.ConflictAction.DoReplace): PartiqlAst.OnConflictValue

transformConflictActionDoUpdate

open fun transformConflictActionDoUpdate(node: PartiqlAst.ConflictAction.DoUpdate): PartiqlAst.ConflictAction

transformConflictActionDoUpdate_condition

open fun transformConflictActionDoUpdate_condition(node: PartiqlAst.ConflictAction.DoUpdate): PartiqlAst.Expr?

transformConflictActionDoUpdate_metas

open fun transformConflictActionDoUpdate_metas(node: PartiqlAst.ConflictAction.DoUpdate): Map<String, Any>

transformConflictActionDoUpdate_value

open fun transformConflictActionDoUpdate_value(node: PartiqlAst.ConflictAction.DoUpdate): PartiqlAst.OnConflictValue

transformDataManipulationEvaluationOrder

fun transformDataManipulationEvaluationOrder(node: PartiqlAst.Statement.Dml): PartiqlAst.Statement

Transforms the PartiqlAst.Statement.Dml expression following the PartiQL evaluation order. That is:

open fun transformDdlOp(node: PartiqlAst.DdlOp): PartiqlAst.DdlOp

transformDdlOpCreateIndex

open fun transformDdlOpCreateIndex(node: PartiqlAst.DdlOp.CreateIndex): PartiqlAst.DdlOp

transformDdlOpCreateIndex_fields

open fun transformDdlOpCreateIndex_fields(node: PartiqlAst.DdlOp.CreateIndex): List<PartiqlAst.Expr>

transformDdlOpCreateIndex_indexName

open fun transformDdlOpCreateIndex_indexName(node: PartiqlAst.DdlOp.CreateIndex): PartiqlAst.Identifier

transformDdlOpCreateIndex_metas

open fun transformDdlOpCreateIndex_metas(node: PartiqlAst.DdlOp.CreateIndex): Map<String, Any>

transformDdlOpCreateTable

open fun transformDdlOpCreateTable(node: PartiqlAst.DdlOp.CreateTable): PartiqlAst.DdlOp

transformDdlOpCreateTable_def

open fun transformDdlOpCreateTable_def(node: PartiqlAst.DdlOp.CreateTable): PartiqlAst.TableDef?

transformDdlOpCreateTable_metas

open fun transformDdlOpCreateTable_metas(node: PartiqlAst.DdlOp.CreateTable): Map<String, Any>

transformDdlOpCreateTable_tableName

open fun transformDdlOpCreateTable_tableName(node: PartiqlAst.DdlOp.CreateTable): SymbolPrimitive

transformDdlOpDropIndex

open fun transformDdlOpDropIndex(node: PartiqlAst.DdlOp.DropIndex): PartiqlAst.DdlOp

transformDdlOpDropIndex_keys

open fun transformDdlOpDropIndex_keys(node: PartiqlAst.DdlOp.DropIndex): PartiqlAst.Identifier

transformDdlOpDropIndex_metas

open fun transformDdlOpDropIndex_metas(node: PartiqlAst.DdlOp.DropIndex): Map<String, Any>

transformDdlOpDropIndex_table

open fun transformDdlOpDropIndex_table(node: PartiqlAst.DdlOp.DropIndex): PartiqlAst.Identifier

transformDdlOpDropTable

open fun transformDdlOpDropTable(node: PartiqlAst.DdlOp.DropTable): PartiqlAst.DdlOp

transformDdlOpDropTable_metas

open fun transformDdlOpDropTable_metas(node: PartiqlAst.DdlOp.DropTable): Map<String, Any>

transformDdlOpDropTable_tableName

open fun transformDdlOpDropTable_tableName(node: PartiqlAst.DdlOp.DropTable): PartiqlAst.Identifier

open fun transformDmlOp(node: PartiqlAst.DmlOp): PartiqlAst.DmlOp

transformDmlOpDelete

open fun transformDmlOpDelete(node: PartiqlAst.DmlOp.Delete): PartiqlAst.DmlOp

transformDmlOpDelete_metas

open fun transformDmlOpDelete_metas(node: PartiqlAst.DmlOp.Delete): Map<String, Any>

transformDmlOpInsert

open fun transformDmlOpInsert(node: PartiqlAst.DmlOp.Insert): PartiqlAst.DmlOp

transformDmlOpInsert_asAlias

open fun transformDmlOpInsert_asAlias(node: PartiqlAst.DmlOp.Insert): SymbolPrimitive?

transformDmlOpInsert_conflictAction

open fun transformDmlOpInsert_conflictAction(node: PartiqlAst.DmlOp.Insert): PartiqlAst.ConflictAction?

transformDmlOpInsert_metas

open fun transformDmlOpInsert_metas(node: PartiqlAst.DmlOp.Insert): Map<String, Any>

transformDmlOpInsert_target

open fun transformDmlOpInsert_target(node: PartiqlAst.DmlOp.Insert): PartiqlAst.Expr

transformDmlOpInsert_values

open fun transformDmlOpInsert_values(node: PartiqlAst.DmlOp.Insert): PartiqlAst.Expr

transformDmlOpInsertValue

open fun transformDmlOpInsertValue(node: PartiqlAst.DmlOp.InsertValue): PartiqlAst.DmlOp

transformDmlOpInsertValue_index

open fun transformDmlOpInsertValue_index(node: PartiqlAst.DmlOp.InsertValue): PartiqlAst.Expr?

transformDmlOpInsertValue_metas

open fun transformDmlOpInsertValue_metas(node: PartiqlAst.DmlOp.InsertValue): Map<String, Any>

transformDmlOpInsertValue_onConflict

open fun transformDmlOpInsertValue_onConflict(node: PartiqlAst.DmlOp.InsertValue): PartiqlAst.OnConflict?

transformDmlOpInsertValue_target

open fun transformDmlOpInsertValue_target(node: PartiqlAst.DmlOp.InsertValue): PartiqlAst.Expr

transformDmlOpInsertValue_value

open fun transformDmlOpInsertValue_value(node: PartiqlAst.DmlOp.InsertValue): PartiqlAst.Expr

transformDmlOpList

open fun transformDmlOpList(node: PartiqlAst.DmlOpList): PartiqlAst.DmlOpList

transformDmlOpList_metas

open fun transformDmlOpList_metas(node: PartiqlAst.DmlOpList): Map<String, Any>

transformDmlOpList_ops

open fun transformDmlOpList_ops(node: PartiqlAst.DmlOpList): List<PartiqlAst.DmlOp>

transformDmlOpRemove

open fun transformDmlOpRemove(node: PartiqlAst.DmlOp.Remove): PartiqlAst.DmlOp

transformDmlOpRemove_metas

open fun transformDmlOpRemove_metas(node: PartiqlAst.DmlOp.Remove): Map<String, Any>

transformDmlOpRemove_target

open fun transformDmlOpRemove_target(node: PartiqlAst.DmlOp.Remove): PartiqlAst.Expr

transformDmlOpSet

open fun transformDmlOpSet(node: PartiqlAst.DmlOp.Set): PartiqlAst.DmlOp

transformDmlOpSet_assignment

open fun transformDmlOpSet_assignment(node: PartiqlAst.DmlOp.Set): PartiqlAst.Assignment

transformDmlOpSet_metas

open fun transformDmlOpSet_metas(node: PartiqlAst.DmlOp.Set): Map<String, Any>

transformExplainTarget

open fun transformExplainTarget(node: PartiqlAst.ExplainTarget): PartiqlAst.ExplainTarget

transformExplainTargetDomain

open fun transformExplainTargetDomain(node: PartiqlAst.ExplainTarget.Domain): PartiqlAst.ExplainTarget

transformExplainTargetDomain_format

open fun transformExplainTargetDomain_format(node: PartiqlAst.ExplainTarget.Domain): SymbolPrimitive?

transformExplainTargetDomain_metas

open fun transformExplainTargetDomain_metas(node: PartiqlAst.ExplainTarget.Domain): Map<String, Any>

transformExplainTargetDomain_statement

open fun transformExplainTargetDomain_statement(node: PartiqlAst.ExplainTarget.Domain): PartiqlAst.Statement

transformExplainTargetDomain_type

open fun transformExplainTargetDomain_type(node: PartiqlAst.ExplainTarget.Domain): SymbolPrimitive?

open override fun transformExpr(node: PartiqlAst.Expr): PartiqlAst.Expr

transformExprAnd

open fun transformExprAnd(node: PartiqlAst.Expr.And): PartiqlAst.Expr

transformExprAnd_metas

open fun transformExprAnd_metas(node: PartiqlAst.Expr.And): Map<String, Any>

transformExprAnd_operands

open fun transformExprAnd_operands(node: PartiqlAst.Expr.And): List<PartiqlAst.Expr>

transformExprBag

open fun transformExprBag(node: PartiqlAst.Expr.Bag): PartiqlAst.Expr

transformExprBag_metas

open fun transformExprBag_metas(node: PartiqlAst.Expr.Bag): Map<String, Any>

transformExprBag_values

open fun transformExprBag_values(node: PartiqlAst.Expr.Bag): List<PartiqlAst.Expr>

transformExprBagOp

open fun transformExprBagOp(node: PartiqlAst.Expr.BagOp): PartiqlAst.Expr

transformExprBagOp_metas

open fun transformExprBagOp_metas(node: PartiqlAst.Expr.BagOp): Map<String, Any>

transformExprBagOp_op

open fun transformExprBagOp_op(node: PartiqlAst.Expr.BagOp): PartiqlAst.BagOpType

transformExprBagOp_operands

open fun transformExprBagOp_operands(node: PartiqlAst.Expr.BagOp): List<PartiqlAst.Expr>

transformExprBagOp_quantifier

open fun transformExprBagOp_quantifier(node: PartiqlAst.Expr.BagOp): PartiqlAst.SetQuantifier

transformExprBetween

open fun transformExprBetween(node: PartiqlAst.Expr.Between): PartiqlAst.Expr

transformExprBetween_from

open fun transformExprBetween_from(node: PartiqlAst.Expr.Between): PartiqlAst.Expr

transformExprBetween_metas

open fun transformExprBetween_metas(node: PartiqlAst.Expr.Between): Map<String, Any>

transformExprBetween_to

open fun transformExprBetween_to(node: PartiqlAst.Expr.Between): PartiqlAst.Expr

transformExprBetween_value

open fun transformExprBetween_value(node: PartiqlAst.Expr.Between): PartiqlAst.Expr

transformExprCall

open fun transformExprCall(node: PartiqlAst.Expr.Call): PartiqlAst.Expr

transformExprCall_args

open fun transformExprCall_args(node: PartiqlAst.Expr.Call): List<PartiqlAst.Expr>

transformExprCall_funcName

open fun transformExprCall_funcName(node: PartiqlAst.Expr.Call): SymbolPrimitive

transformExprCall_metas

open fun transformExprCall_metas(node: PartiqlAst.Expr.Call): Map<String, Any>

transformExprCallAgg

open fun transformExprCallAgg(node: PartiqlAst.Expr.CallAgg): PartiqlAst.Expr

transformExprCallAgg_arg

open fun transformExprCallAgg_arg(node: PartiqlAst.Expr.CallAgg): PartiqlAst.Expr

transformExprCallAgg_funcName

open fun transformExprCallAgg_funcName(node: PartiqlAst.Expr.CallAgg): SymbolPrimitive

transformExprCallAgg_metas

open fun transformExprCallAgg_metas(node: PartiqlAst.Expr.CallAgg): Map<String, Any>

transformExprCallAgg_setq

open fun transformExprCallAgg_setq(node: PartiqlAst.Expr.CallAgg): PartiqlAst.SetQuantifier

transformExprCallWindow

open fun transformExprCallWindow(node: PartiqlAst.Expr.CallWindow): PartiqlAst.Expr

transformExprCallWindow_args

open fun transformExprCallWindow_args(node: PartiqlAst.Expr.CallWindow): List<PartiqlAst.Expr>

transformExprCallWindow_funcName

open fun transformExprCallWindow_funcName(node: PartiqlAst.Expr.CallWindow): SymbolPrimitive

transformExprCallWindow_metas

open fun transformExprCallWindow_metas(node: PartiqlAst.Expr.CallWindow): Map<String, Any>

transformExprCallWindow_over

open fun transformExprCallWindow_over(node: PartiqlAst.Expr.CallWindow): PartiqlAst.Over

transformExprCanCast

open fun transformExprCanCast(node: PartiqlAst.Expr.CanCast): PartiqlAst.Expr

transformExprCanCast_asType

open fun transformExprCanCast_asType(node: PartiqlAst.Expr.CanCast): PartiqlAst.Type

transformExprCanCast_metas

open fun transformExprCanCast_metas(node: PartiqlAst.Expr.CanCast): Map<String, Any>

transformExprCanCast_value

open fun transformExprCanCast_value(node: PartiqlAst.Expr.CanCast): PartiqlAst.Expr

transformExprCanLosslessCast

open fun transformExprCanLosslessCast(node: PartiqlAst.Expr.CanLosslessCast): PartiqlAst.Expr

transformExprCanLosslessCast_asType

open fun transformExprCanLosslessCast_asType(node: PartiqlAst.Expr.CanLosslessCast): PartiqlAst.Type

transformExprCanLosslessCast_metas

open fun transformExprCanLosslessCast_metas(node: PartiqlAst.Expr.CanLosslessCast): Map<String, Any>

transformExprCanLosslessCast_value

open fun transformExprCanLosslessCast_value(node: PartiqlAst.Expr.CanLosslessCast): PartiqlAst.Expr

transformExprCast

open fun transformExprCast(node: PartiqlAst.Expr.Cast): PartiqlAst.Expr

transformExprCast_asType

open fun transformExprCast_asType(node: PartiqlAst.Expr.Cast): PartiqlAst.Type

transformExprCast_metas

open fun transformExprCast_metas(node: PartiqlAst.Expr.Cast): Map<String, Any>

transformExprCast_value

open fun transformExprCast_value(node: PartiqlAst.Expr.Cast): PartiqlAst.Expr

transformExprCoalesce

open fun transformExprCoalesce(node: PartiqlAst.Expr.Coalesce): PartiqlAst.Expr

transformExprCoalesce_args

open fun transformExprCoalesce_args(node: PartiqlAst.Expr.Coalesce): List<PartiqlAst.Expr>

transformExprCoalesce_metas

open fun transformExprCoalesce_metas(node: PartiqlAst.Expr.Coalesce): Map<String, Any>

transformExprConcat

open fun transformExprConcat(node: PartiqlAst.Expr.Concat): PartiqlAst.Expr

transformExprConcat_metas

open fun transformExprConcat_metas(node: PartiqlAst.Expr.Concat): Map<String, Any>

transformExprConcat_operands

open fun transformExprConcat_operands(node: PartiqlAst.Expr.Concat): List<PartiqlAst.Expr>

transformExprDate

open fun transformExprDate(node: PartiqlAst.Expr.Date): PartiqlAst.Expr

transformExprDate_day

open fun transformExprDate_day(node: PartiqlAst.Expr.Date): LongPrimitive

transformExprDate_metas

open fun transformExprDate_metas(node: PartiqlAst.Expr.Date): Map<String, Any>

transformExprDate_month

open fun transformExprDate_month(node: PartiqlAst.Expr.Date): LongPrimitive

transformExprDate_year

open fun transformExprDate_year(node: PartiqlAst.Expr.Date): LongPrimitive

transformExprDivide

open fun transformExprDivide(node: PartiqlAst.Expr.Divide): PartiqlAst.Expr

transformExprDivide_metas

open fun transformExprDivide_metas(node: PartiqlAst.Expr.Divide): Map<String, Any>

transformExprDivide_operands

open fun transformExprDivide_operands(node: PartiqlAst.Expr.Divide): List<PartiqlAst.Expr>

transformExprEq

open fun transformExprEq(node: PartiqlAst.Expr.Eq): PartiqlAst.Expr

transformExprEq_metas

open fun transformExprEq_metas(node: PartiqlAst.Expr.Eq): Map<String, Any>

transformExprEq_operands

open fun transformExprEq_operands(node: PartiqlAst.Expr.Eq): List<PartiqlAst.Expr>

transformExprGraphMatch

open fun transformExprGraphMatch(node: PartiqlAst.Expr.GraphMatch): PartiqlAst.Expr

transformExprGraphMatch_expr

open fun transformExprGraphMatch_expr(node: PartiqlAst.Expr.GraphMatch): PartiqlAst.Expr

transformExprGraphMatch_gpmlPattern

open fun transformExprGraphMatch_gpmlPattern(node: PartiqlAst.Expr.GraphMatch): PartiqlAst.GpmlPattern

transformExprGraphMatch_metas

open fun transformExprGraphMatch_metas(node: PartiqlAst.Expr.GraphMatch): Map<String, Any>

transformExprGt

open fun transformExprGt(node: PartiqlAst.Expr.Gt): PartiqlAst.Expr

transformExprGt_metas

open fun transformExprGt_metas(node: PartiqlAst.Expr.Gt): Map<String, Any>

transformExprGt_operands

open fun transformExprGt_operands(node: PartiqlAst.Expr.Gt): List<PartiqlAst.Expr>

transformExprGte

open fun transformExprGte(node: PartiqlAst.Expr.Gte): PartiqlAst.Expr

transformExprGte_metas

open fun transformExprGte_metas(node: PartiqlAst.Expr.Gte): Map<String, Any>

transformExprGte_operands

open fun transformExprGte_operands(node: PartiqlAst.Expr.Gte): List<PartiqlAst.Expr>

transformExprId

open fun transformExprId(node: PartiqlAst.Expr.Id): PartiqlAst.Expr

transformExprId_case

open fun transformExprId_case(node: PartiqlAst.Expr.Id): PartiqlAst.CaseSensitivity

transformExprId_metas

open fun transformExprId_metas(node: PartiqlAst.Expr.Id): Map<String, Any>

transformExprId_name

open fun transformExprId_name(node: PartiqlAst.Expr.Id): SymbolPrimitive

transformExprId_qualifier

open fun transformExprId_qualifier(node: PartiqlAst.Expr.Id): PartiqlAst.ScopeQualifier

transformExprInCollection

open fun transformExprInCollection(node: PartiqlAst.Expr.InCollection): PartiqlAst.Expr

transformExprInCollection_metas

open fun transformExprInCollection_metas(node: PartiqlAst.Expr.InCollection): Map<String, Any>

transformExprInCollection_operands

open fun transformExprInCollection_operands(node: PartiqlAst.Expr.InCollection): List<PartiqlAst.Expr>

transformExprIsType

open fun transformExprIsType(node: PartiqlAst.Expr.IsType): PartiqlAst.Expr

transformExprIsType_metas

open fun transformExprIsType_metas(node: PartiqlAst.Expr.IsType): Map<String, Any>

transformExprIsType_type

open fun transformExprIsType_type(node: PartiqlAst.Expr.IsType): PartiqlAst.Type

transformExprIsType_value

open fun transformExprIsType_value(node: PartiqlAst.Expr.IsType): PartiqlAst.Expr

transformExprLike

open fun transformExprLike(node: PartiqlAst.Expr.Like): PartiqlAst.Expr

transformExprLike_escape

open fun transformExprLike_escape(node: PartiqlAst.Expr.Like): PartiqlAst.Expr?

transformExprLike_metas

open fun transformExprLike_metas(node: PartiqlAst.Expr.Like): Map<String, Any>

transformExprLike_pattern

open fun transformExprLike_pattern(node: PartiqlAst.Expr.Like): PartiqlAst.Expr

transformExprLike_value

open fun transformExprLike_value(node: PartiqlAst.Expr.Like): PartiqlAst.Expr

transformExprList

open fun transformExprList(node: PartiqlAst.Expr.List): PartiqlAst.Expr

transformExprList_metas

open fun transformExprList_metas(node: PartiqlAst.Expr.List): Map<String, Any>

transformExprList_values

open fun transformExprList_values(node: PartiqlAst.Expr.List): List<PartiqlAst.Expr>

transformExprLit

open fun transformExprLit(node: PartiqlAst.Expr.Lit): PartiqlAst.Expr

transformExprLit_metas

open fun transformExprLit_metas(node: PartiqlAst.Expr.Lit): Map<String, Any>

transformExprLit_value

open fun transformExprLit_value(node: PartiqlAst.Expr.Lit): AnyElement

transformExprLitTime

open fun transformExprLitTime(node: PartiqlAst.Expr.LitTime): PartiqlAst.Expr

transformExprLitTime_metas

open fun transformExprLitTime_metas(node: PartiqlAst.Expr.LitTime): Map<String, Any>

transformExprLitTime_value

open fun transformExprLitTime_value(node: PartiqlAst.Expr.LitTime): PartiqlAst.TimeValue

transformExprLt

open fun transformExprLt(node: PartiqlAst.Expr.Lt): PartiqlAst.Expr

transformExprLt_metas

open fun transformExprLt_metas(node: PartiqlAst.Expr.Lt): Map<String, Any>

transformExprLt_operands

open fun transformExprLt_operands(node: PartiqlAst.Expr.Lt): List<PartiqlAst.Expr>

transformExprLte

open fun transformExprLte(node: PartiqlAst.Expr.Lte): PartiqlAst.Expr

transformExprLte_metas

open fun transformExprLte_metas(node: PartiqlAst.Expr.Lte): Map<String, Any>

transformExprLte_operands

open fun transformExprLte_operands(node: PartiqlAst.Expr.Lte): List<PartiqlAst.Expr>

transformExprMinus

open fun transformExprMinus(node: PartiqlAst.Expr.Minus): PartiqlAst.Expr

transformExprMinus_metas

open fun transformExprMinus_metas(node: PartiqlAst.Expr.Minus): Map<String, Any>

transformExprMinus_operands

open fun transformExprMinus_operands(node: PartiqlAst.Expr.Minus): List<PartiqlAst.Expr>

transformExprMissing

open fun transformExprMissing(node: PartiqlAst.Expr.Missing): PartiqlAst.Expr

transformExprMissing_metas

open fun transformExprMissing_metas(node: PartiqlAst.Expr.Missing): Map<String, Any>

transformExprModulo

open fun transformExprModulo(node: PartiqlAst.Expr.Modulo): PartiqlAst.Expr

transformExprModulo_metas

open fun transformExprModulo_metas(node: PartiqlAst.Expr.Modulo): Map<String, Any>

transformExprModulo_operands

open fun transformExprModulo_operands(node: PartiqlAst.Expr.Modulo): List<PartiqlAst.Expr>

transformExprNe

open fun transformExprNe(node: PartiqlAst.Expr.Ne): PartiqlAst.Expr

transformExprNe_metas

open fun transformExprNe_metas(node: PartiqlAst.Expr.Ne): Map<String, Any>

transformExprNe_operands

open fun transformExprNe_operands(node: PartiqlAst.Expr.Ne): List<PartiqlAst.Expr>

transformExprNeg

open fun transformExprNeg(node: PartiqlAst.Expr.Neg): PartiqlAst.Expr

transformExprNeg_expr

open fun transformExprNeg_expr(node: PartiqlAst.Expr.Neg): PartiqlAst.Expr

transformExprNeg_metas

open fun transformExprNeg_metas(node: PartiqlAst.Expr.Neg): Map<String, Any>

transformExprNot

open fun transformExprNot(node: PartiqlAst.Expr.Not): PartiqlAst.Expr

transformExprNot_expr

open fun transformExprNot_expr(node: PartiqlAst.Expr.Not): PartiqlAst.Expr

transformExprNot_metas

open fun transformExprNot_metas(node: PartiqlAst.Expr.Not): Map<String, Any>

transformExprNullIf

open fun transformExprNullIf(node: PartiqlAst.Expr.NullIf): PartiqlAst.Expr

transformExprNullIf_expr1

open fun transformExprNullIf_expr1(node: PartiqlAst.Expr.NullIf): PartiqlAst.Expr

transformExprNullIf_expr2

open fun transformExprNullIf_expr2(node: PartiqlAst.Expr.NullIf): PartiqlAst.Expr

transformExprNullIf_metas

open fun transformExprNullIf_metas(node: PartiqlAst.Expr.NullIf): Map<String, Any>

transformExprOr

open fun transformExprOr(node: PartiqlAst.Expr.Or): PartiqlAst.Expr

transformExprOr_metas

open fun transformExprOr_metas(node: PartiqlAst.Expr.Or): Map<String, Any>

transformExprOr_operands

open fun transformExprOr_operands(node: PartiqlAst.Expr.Or): List<PartiqlAst.Expr>

transformExprPair

open fun transformExprPair(node: PartiqlAst.ExprPair): PartiqlAst.ExprPair

transformExprPair_first

open fun transformExprPair_first(node: PartiqlAst.ExprPair): PartiqlAst.Expr

transformExprPair_metas

open fun transformExprPair_metas(node: PartiqlAst.ExprPair): Map<String, Any>

transformExprPair_second

open fun transformExprPair_second(node: PartiqlAst.ExprPair): PartiqlAst.Expr

transformExprPairList

open fun transformExprPairList(node: PartiqlAst.ExprPairList): PartiqlAst.ExprPairList

transformExprPairList_metas

open fun transformExprPairList_metas(node: PartiqlAst.ExprPairList): Map<String, Any>

transformExprPairList_pairs

open fun transformExprPairList_pairs(node: PartiqlAst.ExprPairList): List<PartiqlAst.ExprPair>

transformExprParameter

open fun transformExprParameter(node: PartiqlAst.Expr.Parameter): PartiqlAst.Expr

transformExprParameter_index

open fun transformExprParameter_index(node: PartiqlAst.Expr.Parameter): LongPrimitive

transformExprParameter_metas

open fun transformExprParameter_metas(node: PartiqlAst.Expr.Parameter): Map<String, Any>

transformExprPath

open fun transformExprPath(node: PartiqlAst.Expr.Path): PartiqlAst.Expr

transformExprPath_metas

open fun transformExprPath_metas(node: PartiqlAst.Expr.Path): Map<String, Any>

transformExprPath_root

open fun transformExprPath_root(node: PartiqlAst.Expr.Path): PartiqlAst.Expr

transformExprPath_steps

open fun transformExprPath_steps(node: PartiqlAst.Expr.Path): List<PartiqlAst.PathStep>

transformExprPlus

open fun transformExprPlus(node: PartiqlAst.Expr.Plus): PartiqlAst.Expr

transformExprPlus_metas

open fun transformExprPlus_metas(node: PartiqlAst.Expr.Plus): Map<String, Any>

transformExprPlus_operands

open fun transformExprPlus_operands(node: PartiqlAst.Expr.Plus): List<PartiqlAst.Expr>

transformExprPos

open fun transformExprPos(node: PartiqlAst.Expr.Pos): PartiqlAst.Expr

transformExprPos_expr

open fun transformExprPos_expr(node: PartiqlAst.Expr.Pos): PartiqlAst.Expr

transformExprPos_metas

open fun transformExprPos_metas(node: PartiqlAst.Expr.Pos): Map<String, Any>

transformExprSearchedCase

open fun transformExprSearchedCase(node: PartiqlAst.Expr.SearchedCase): PartiqlAst.Expr

transformExprSearchedCase_cases

open fun transformExprSearchedCase_cases(node: PartiqlAst.Expr.SearchedCase): PartiqlAst.ExprPairList

transformExprSearchedCase_default

open fun transformExprSearchedCase_default(node: PartiqlAst.Expr.SearchedCase): PartiqlAst.Expr?

transformExprSearchedCase_metas

open fun transformExprSearchedCase_metas(node: PartiqlAst.Expr.SearchedCase): Map<String, Any>

transformExprSelect

open override fun transformExprSelect(node: PartiqlAst.Expr.Select): PartiqlAst.Expr

transformExprSelect_from

open fun transformExprSelect_from(node: PartiqlAst.Expr.Select): PartiqlAst.FromSource

transformExprSelect_fromLet

open fun transformExprSelect_fromLet(node: PartiqlAst.Expr.Select): PartiqlAst.Let?

transformExprSelect_group

open fun transformExprSelect_group(node: PartiqlAst.Expr.Select): PartiqlAst.GroupBy?

transformExprSelect_having

open fun transformExprSelect_having(node: PartiqlAst.Expr.Select): PartiqlAst.Expr?

transformExprSelect_limit

open fun transformExprSelect_limit(node: PartiqlAst.Expr.Select): PartiqlAst.Expr?

transformExprSelect_metas

open fun transformExprSelect_metas(node: PartiqlAst.Expr.Select): Map<String, Any>

transformExprSelect_offset

open fun transformExprSelect_offset(node: PartiqlAst.Expr.Select): PartiqlAst.Expr?

transformExprSelect_order

open fun transformExprSelect_order(node: PartiqlAst.Expr.Select): PartiqlAst.OrderBy?

transformExprSelect_project

open fun transformExprSelect_project(node: PartiqlAst.Expr.Select): PartiqlAst.Projection

transformExprSelect_setq

open fun transformExprSelect_setq(node: PartiqlAst.Expr.Select): PartiqlAst.SetQuantifier?

transformExprSelect_where

open fun transformExprSelect_where(node: PartiqlAst.Expr.Select): PartiqlAst.Expr?

transformExprSelectEvaluationOrder

fun transformExprSelectEvaluationOrder(node: PartiqlAst.Expr.Select): PartiqlAst.Expr

Transforms the PartiqlAst.Expr.Select expression following the PartiQL evaluation order. That is:

transformExprSessionAttribute

open fun transformExprSessionAttribute(node: PartiqlAst.Expr.SessionAttribute): PartiqlAst.Expr

transformExprSessionAttribute_metas

open fun transformExprSessionAttribute_metas(node: PartiqlAst.Expr.SessionAttribute): Map<String, Any>

transformExprSessionAttribute_value

open fun transformExprSessionAttribute_value(node: PartiqlAst.Expr.SessionAttribute): SymbolPrimitive

transformExprSexp

open fun transformExprSexp(node: PartiqlAst.Expr.Sexp): PartiqlAst.Expr

transformExprSexp_metas

open fun transformExprSexp_metas(node: PartiqlAst.Expr.Sexp): Map<String, Any>

transformExprSexp_values

open fun transformExprSexp_values(node: PartiqlAst.Expr.Sexp): List<PartiqlAst.Expr>

transformExprSimpleCase

open fun transformExprSimpleCase(node: PartiqlAst.Expr.SimpleCase): PartiqlAst.Expr

transformExprSimpleCase_cases

open fun transformExprSimpleCase_cases(node: PartiqlAst.Expr.SimpleCase): PartiqlAst.ExprPairList

transformExprSimpleCase_default

open fun transformExprSimpleCase_default(node: PartiqlAst.Expr.SimpleCase): PartiqlAst.Expr?

transformExprSimpleCase_expr

open fun transformExprSimpleCase_expr(node: PartiqlAst.Expr.SimpleCase): PartiqlAst.Expr

transformExprSimpleCase_metas

open fun transformExprSimpleCase_metas(node: PartiqlAst.Expr.SimpleCase): Map<String, Any>

transformExprStruct

open fun transformExprStruct(node: PartiqlAst.Expr.Struct): PartiqlAst.Expr

transformExprStruct_fields

open fun transformExprStruct_fields(node: PartiqlAst.Expr.Struct): List<PartiqlAst.ExprPair>

transformExprStruct_metas

open fun transformExprStruct_metas(node: PartiqlAst.Expr.Struct): Map<String, Any>

transformExprTimes

open fun transformExprTimes(node: PartiqlAst.Expr.Times): PartiqlAst.Expr

transformExprTimes_metas

open fun transformExprTimes_metas(node: PartiqlAst.Expr.Times): Map<String, Any>

transformExprTimes_operands

open fun transformExprTimes_operands(node: PartiqlAst.Expr.Times): List<PartiqlAst.Expr>

transformFromSource

open fun transformFromSource(node: PartiqlAst.FromSource): PartiqlAst.FromSource

transformFromSourceJoin

open fun transformFromSourceJoin(node: PartiqlAst.FromSource.Join): PartiqlAst.FromSource

transformFromSourceJoin_left

open fun transformFromSourceJoin_left(node: PartiqlAst.FromSource.Join): PartiqlAst.FromSource

transformFromSourceJoin_metas

open fun transformFromSourceJoin_metas(node: PartiqlAst.FromSource.Join): Map<String, Any>

transformFromSourceJoin_predicate

open fun transformFromSourceJoin_predicate(node: PartiqlAst.FromSource.Join): PartiqlAst.Expr?

transformFromSourceJoin_right

open fun transformFromSourceJoin_right(node: PartiqlAst.FromSource.Join): PartiqlAst.FromSource

transformFromSourceJoin_type

open fun transformFromSourceJoin_type(node: PartiqlAst.FromSource.Join): PartiqlAst.JoinType

transformFromSourceScan

open fun transformFromSourceScan(node: PartiqlAst.FromSource.Scan): PartiqlAst.FromSource

transformFromSourceScan_asAlias

open fun transformFromSourceScan_asAlias(node: PartiqlAst.FromSource.Scan): SymbolPrimitive?

transformFromSourceScan_atAlias

open fun transformFromSourceScan_atAlias(node: PartiqlAst.FromSource.Scan): SymbolPrimitive?

transformFromSourceScan_byAlias

open fun transformFromSourceScan_byAlias(node: PartiqlAst.FromSource.Scan): SymbolPrimitive?

transformFromSourceScan_expr

open fun transformFromSourceScan_expr(node: PartiqlAst.FromSource.Scan): PartiqlAst.Expr

transformFromSourceScan_metas

open fun transformFromSourceScan_metas(node: PartiqlAst.FromSource.Scan): Map<String, Any>

transformFromSourceUnpivot

open fun transformFromSourceUnpivot(node: PartiqlAst.FromSource.Unpivot): PartiqlAst.FromSource

transformFromSourceUnpivot_asAlias

open fun transformFromSourceUnpivot_asAlias(node: PartiqlAst.FromSource.Unpivot): SymbolPrimitive?

transformFromSourceUnpivot_atAlias

open fun transformFromSourceUnpivot_atAlias(node: PartiqlAst.FromSource.Unpivot): SymbolPrimitive?

transformFromSourceUnpivot_byAlias

open fun transformFromSourceUnpivot_byAlias(node: PartiqlAst.FromSource.Unpivot): SymbolPrimitive?

transformFromSourceUnpivot_expr

open fun transformFromSourceUnpivot_expr(node: PartiqlAst.FromSource.Unpivot): PartiqlAst.Expr

transformFromSourceUnpivot_metas

open fun transformFromSourceUnpivot_metas(node: PartiqlAst.FromSource.Unpivot): Map<String, Any>

transformGpmlPattern

open fun transformGpmlPattern(node: PartiqlAst.GpmlPattern): PartiqlAst.GpmlPattern

transformGpmlPattern_metas

open fun transformGpmlPattern_metas(node: PartiqlAst.GpmlPattern): Map<String, Any>

transformGpmlPattern_patterns

open fun transformGpmlPattern_patterns(node: PartiqlAst.GpmlPattern): List<PartiqlAst.GraphMatchPattern>

transformGpmlPattern_selector

open fun transformGpmlPattern_selector(node: PartiqlAst.GpmlPattern): PartiqlAst.GraphMatchSelector?

transformGraphMatchDirection

open fun transformGraphMatchDirection(node: PartiqlAst.GraphMatchDirection): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeLeft

open fun transformGraphMatchDirectionEdgeLeft(node: PartiqlAst.GraphMatchDirection.EdgeLeft): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeLeft_metas

open fun transformGraphMatchDirectionEdgeLeft_metas(node: PartiqlAst.GraphMatchDirection.EdgeLeft): Map<String, Any>

transformGraphMatchDirectionEdgeLeftOrRight

open fun transformGraphMatchDirectionEdgeLeftOrRight(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrRight): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeLeftOrRight_metas

open fun transformGraphMatchDirectionEdgeLeftOrRight_metas(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrRight): Map<String, Any>

transformGraphMatchDirectionEdgeLeftOrUndirected

open fun transformGraphMatchDirectionEdgeLeftOrUndirected(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirected): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeLeftOrUndirected_metas

open fun transformGraphMatchDirectionEdgeLeftOrUndirected_metas(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirected): Map<String, Any>

transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight

open fun transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirectedOrRight): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight_metas

open fun transformGraphMatchDirectionEdgeLeftOrUndirectedOrRight_metas(node: PartiqlAst.GraphMatchDirection.EdgeLeftOrUndirectedOrRight): Map<String, Any>

transformGraphMatchDirectionEdgeRight

open fun transformGraphMatchDirectionEdgeRight(node: PartiqlAst.GraphMatchDirection.EdgeRight): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeRight_metas

open fun transformGraphMatchDirectionEdgeRight_metas(node: PartiqlAst.GraphMatchDirection.EdgeRight): Map<String, Any>

transformGraphMatchDirectionEdgeUndirected

open fun transformGraphMatchDirectionEdgeUndirected(node: PartiqlAst.GraphMatchDirection.EdgeUndirected): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeUndirected_metas

open fun transformGraphMatchDirectionEdgeUndirected_metas(node: PartiqlAst.GraphMatchDirection.EdgeUndirected): Map<String, Any>

transformGraphMatchDirectionEdgeUndirectedOrRight

open fun transformGraphMatchDirectionEdgeUndirectedOrRight(node: PartiqlAst.GraphMatchDirection.EdgeUndirectedOrRight): PartiqlAst.GraphMatchDirection

transformGraphMatchDirectionEdgeUndirectedOrRight_metas

open fun transformGraphMatchDirectionEdgeUndirectedOrRight_metas(node: PartiqlAst.GraphMatchDirection.EdgeUndirectedOrRight): Map<String, Any>

transformGraphMatchPattern

open fun transformGraphMatchPattern(node: PartiqlAst.GraphMatchPattern): PartiqlAst.GraphMatchPattern

transformGraphMatchPattern_metas

open fun transformGraphMatchPattern_metas(node: PartiqlAst.GraphMatchPattern): Map<String, Any>

transformGraphMatchPattern_parts

open fun transformGraphMatchPattern_parts(node: PartiqlAst.GraphMatchPattern): List<PartiqlAst.GraphMatchPatternPart>

transformGraphMatchPattern_prefilter

open fun transformGraphMatchPattern_prefilter(node: PartiqlAst.GraphMatchPattern): PartiqlAst.Expr?

transformGraphMatchPattern_quantifier

open fun transformGraphMatchPattern_quantifier(node: PartiqlAst.GraphMatchPattern): PartiqlAst.GraphMatchQuantifier?

transformGraphMatchPattern_restrictor

open fun transformGraphMatchPattern_restrictor(node: PartiqlAst.GraphMatchPattern): PartiqlAst.GraphMatchRestrictor?

transformGraphMatchPattern_variable

open fun transformGraphMatchPattern_variable(node: PartiqlAst.GraphMatchPattern): SymbolPrimitive?

transformGraphMatchPatternPart

open fun transformGraphMatchPatternPart(node: PartiqlAst.GraphMatchPatternPart): PartiqlAst.GraphMatchPatternPart

transformGraphMatchPatternPartEdge

open fun transformGraphMatchPatternPartEdge(node: PartiqlAst.GraphMatchPatternPart.Edge): PartiqlAst.GraphMatchPatternPart

transformGraphMatchPatternPartEdge_direction

open fun transformGraphMatchPatternPartEdge_direction(node: PartiqlAst.GraphMatchPatternPart.Edge): PartiqlAst.GraphMatchDirection

transformGraphMatchPatternPartEdge_label

open fun transformGraphMatchPatternPartEdge_label(node: PartiqlAst.GraphMatchPatternPart.Edge): List<SymbolPrimitive>

transformGraphMatchPatternPartEdge_metas

open fun transformGraphMatchPatternPartEdge_metas(node: PartiqlAst.GraphMatchPatternPart.Edge): Map<String, Any>

transformGraphMatchPatternPartEdge_prefilter

open fun transformGraphMatchPatternPartEdge_prefilter(node: PartiqlAst.GraphMatchPatternPart.Edge): PartiqlAst.Expr?

transformGraphMatchPatternPartEdge_quantifier

open fun transformGraphMatchPatternPartEdge_quantifier(node: PartiqlAst.GraphMatchPatternPart.Edge): PartiqlAst.GraphMatchQuantifier?

transformGraphMatchPatternPartEdge_variable

open fun transformGraphMatchPatternPartEdge_variable(node: PartiqlAst.GraphMatchPatternPart.Edge): SymbolPrimitive?

transformGraphMatchPatternPartNode

open fun transformGraphMatchPatternPartNode(node: PartiqlAst.GraphMatchPatternPart.Node): PartiqlAst.GraphMatchPatternPart

transformGraphMatchPatternPartNode_label

open fun transformGraphMatchPatternPartNode_label(node: PartiqlAst.GraphMatchPatternPart.Node): List<SymbolPrimitive>

transformGraphMatchPatternPartNode_metas

open fun transformGraphMatchPatternPartNode_metas(node: PartiqlAst.GraphMatchPatternPart.Node): Map<String, Any>

transformGraphMatchPatternPartNode_prefilter

open fun transformGraphMatchPatternPartNode_prefilter(node: PartiqlAst.GraphMatchPatternPart.Node): PartiqlAst.Expr?

transformGraphMatchPatternPartNode_variable

open fun transformGraphMatchPatternPartNode_variable(node: PartiqlAst.GraphMatchPatternPart.Node): SymbolPrimitive?

transformGraphMatchPatternPartPattern

open fun transformGraphMatchPatternPartPattern(node: PartiqlAst.GraphMatchPatternPart.Pattern): PartiqlAst.GraphMatchPatternPart

transformGraphMatchPatternPartPattern_metas

open fun transformGraphMatchPatternPartPattern_metas(node: PartiqlAst.GraphMatchPatternPart.Pattern): Map<String, Any>

transformGraphMatchPatternPartPattern_pattern

open fun transformGraphMatchPatternPartPattern_pattern(node: PartiqlAst.GraphMatchPatternPart.Pattern): PartiqlAst.GraphMatchPattern

transformGraphMatchQuantifier

open fun transformGraphMatchQuantifier(node: PartiqlAst.GraphMatchQuantifier): PartiqlAst.GraphMatchQuantifier

transformGraphMatchQuantifier_lower

open fun transformGraphMatchQuantifier_lower(node: PartiqlAst.GraphMatchQuantifier): LongPrimitive

transformGraphMatchQuantifier_metas

open fun transformGraphMatchQuantifier_metas(node: PartiqlAst.GraphMatchQuantifier): Map<String, Any>

transformGraphMatchQuantifier_upper

open fun transformGraphMatchQuantifier_upper(node: PartiqlAst.GraphMatchQuantifier): LongPrimitive?

transformGraphMatchRestrictor

open fun transformGraphMatchRestrictor(node: PartiqlAst.GraphMatchRestrictor): PartiqlAst.GraphMatchRestrictor

transformGraphMatchRestrictorRestrictorAcyclic

open fun transformGraphMatchRestrictorRestrictorAcyclic(node: PartiqlAst.GraphMatchRestrictor.RestrictorAcyclic): PartiqlAst.GraphMatchRestrictor

transformGraphMatchRestrictorRestrictorAcyclic_metas

open fun transformGraphMatchRestrictorRestrictorAcyclic_metas(node: PartiqlAst.GraphMatchRestrictor.RestrictorAcyclic): Map<String, Any>

transformGraphMatchRestrictorRestrictorSimple

open fun transformGraphMatchRestrictorRestrictorSimple(node: PartiqlAst.GraphMatchRestrictor.RestrictorSimple): PartiqlAst.GraphMatchRestrictor

transformGraphMatchRestrictorRestrictorSimple_metas

open fun transformGraphMatchRestrictorRestrictorSimple_metas(node: PartiqlAst.GraphMatchRestrictor.RestrictorSimple): Map<String, Any>

transformGraphMatchRestrictorRestrictorTrail

open fun transformGraphMatchRestrictorRestrictorTrail(node: PartiqlAst.GraphMatchRestrictor.RestrictorTrail): PartiqlAst.GraphMatchRestrictor

transformGraphMatchRestrictorRestrictorTrail_metas

open fun transformGraphMatchRestrictorRestrictorTrail_metas(node: PartiqlAst.GraphMatchRestrictor.RestrictorTrail): Map<String, Any>

transformGraphMatchSelector

open fun transformGraphMatchSelector(node: PartiqlAst.GraphMatchSelector): PartiqlAst.GraphMatchSelector

transformGraphMatchSelectorSelectorAllShortest

open fun transformGraphMatchSelectorSelectorAllShortest(node: PartiqlAst.GraphMatchSelector.SelectorAllShortest): PartiqlAst.GraphMatchSelector

transformGraphMatchSelectorSelectorAllShortest_metas

open fun transformGraphMatchSelectorSelectorAllShortest_metas(node: PartiqlAst.GraphMatchSelector.SelectorAllShortest): Map<String, Any>

transformGraphMatchSelectorSelectorAny

open fun transformGraphMatchSelectorSelectorAny(node: PartiqlAst.GraphMatchSelector.SelectorAny): PartiqlAst.GraphMatchSelector

transformGraphMatchSelectorSelectorAny_metas

open fun transformGraphMatchSelectorSelectorAny_metas(node: PartiqlAst.GraphMatchSelector.SelectorAny): Map<String, Any>

transformGraphMatchSelectorSelectorAnyK

open fun transformGraphMatchSelectorSelectorAnyK(node: PartiqlAst.GraphMatchSelector.SelectorAnyK): PartiqlAst.GraphMatchSelector

transformGraphMatchSelectorSelectorAnyK_k

open fun transformGraphMatchSelectorSelectorAnyK_k(node: PartiqlAst.GraphMatchSelector.SelectorAnyK): LongPrimitive

transformGraphMatchSelectorSelectorAnyK_metas

open fun transformGraphMatchSelectorSelectorAnyK_metas(node: PartiqlAst.GraphMatchSelector.SelectorAnyK): Map<String, Any>

transformGraphMatchSelectorSelectorAnyShortest

open fun transformGraphMatchSelectorSelectorAnyShortest(node: PartiqlAst.GraphMatchSelector.SelectorAnyShortest): PartiqlAst.GraphMatchSelector

transformGraphMatchSelectorSelectorAnyShortest_metas

open fun transformGraphMatchSelectorSelectorAnyShortest_metas(node: PartiqlAst.GraphMatchSelector.SelectorAnyShortest): Map<String, Any>

transformGraphMatchSelectorSelectorShortestK

open fun transformGraphMatchSelectorSelectorShortestK(node: PartiqlAst.GraphMatchSelector.SelectorShortestK): PartiqlAst.GraphMatchSelector

transformGraphMatchSelectorSelectorShortestK_k

open fun transformGraphMatchSelectorSelectorShortestK_k(node: PartiqlAst.GraphMatchSelector.SelectorShortestK): LongPrimitive

transformGraphMatchSelectorSelectorShortestK_metas

open fun transformGraphMatchSelectorSelectorShortestK_metas(node: PartiqlAst.GraphMatchSelector.SelectorShortestK): Map<String, Any>

transformGraphMatchSelectorSelectorShortestKGroup

open fun transformGraphMatchSelectorSelectorShortestKGroup(node: PartiqlAst.GraphMatchSelector.SelectorShortestKGroup): PartiqlAst.GraphMatchSelector

transformGraphMatchSelectorSelectorShortestKGroup_k

open fun transformGraphMatchSelectorSelectorShortestKGroup_k(node: PartiqlAst.GraphMatchSelector.SelectorShortestKGroup): LongPrimitive

transformGraphMatchSelectorSelectorShortestKGroup_metas

open fun transformGraphMatchSelectorSelectorShortestKGroup_metas(node: PartiqlAst.GraphMatchSelector.SelectorShortestKGroup): Map<String, Any>

transformGroupBy

open fun transformGroupBy(node: PartiqlAst.GroupBy): PartiqlAst.GroupBy

transformGroupBy_groupAsAlias

open fun transformGroupBy_groupAsAlias(node: PartiqlAst.GroupBy): SymbolPrimitive?

transformGroupBy_keyList

open fun transformGroupBy_keyList(node: PartiqlAst.GroupBy): PartiqlAst.GroupKeyList

transformGroupBy_metas

open fun transformGroupBy_metas(node: PartiqlAst.GroupBy): Map<String, Any>

transformGroupBy_strategy

open fun transformGroupBy_strategy(node: PartiqlAst.GroupBy): PartiqlAst.GroupingStrategy

transformGroupingStrategy

open fun transformGroupingStrategy(node: PartiqlAst.GroupingStrategy): PartiqlAst.GroupingStrategy

transformGroupingStrategyGroupFull

open fun transformGroupingStrategyGroupFull(node: PartiqlAst.GroupingStrategy.GroupFull): PartiqlAst.GroupingStrategy

transformGroupingStrategyGroupFull_metas

open fun transformGroupingStrategyGroupFull_metas(node: PartiqlAst.GroupingStrategy.GroupFull): Map<String, Any>

transformGroupingStrategyGroupPartial

open fun transformGroupingStrategyGroupPartial(node: PartiqlAst.GroupingStrategy.GroupPartial): PartiqlAst.GroupingStrategy

transformGroupingStrategyGroupPartial_metas

open fun transformGroupingStrategyGroupPartial_metas(node: PartiqlAst.GroupingStrategy.GroupPartial): Map<String, Any>

transformGroupKey

open fun transformGroupKey(node: PartiqlAst.GroupKey): PartiqlAst.GroupKey

transformGroupKey_asAlias

open fun transformGroupKey_asAlias(node: PartiqlAst.GroupKey): SymbolPrimitive?

transformGroupKey_expr

open fun transformGroupKey_expr(node: PartiqlAst.GroupKey): PartiqlAst.Expr

transformGroupKey_metas

open fun transformGroupKey_metas(node: PartiqlAst.GroupKey): Map<String, Any>

transformGroupKeyList

open fun transformGroupKeyList(node: PartiqlAst.GroupKeyList): PartiqlAst.GroupKeyList

transformGroupKeyList_keys

open fun transformGroupKeyList_keys(node: PartiqlAst.GroupKeyList): List<PartiqlAst.GroupKey>

transformGroupKeyList_metas

open fun transformGroupKeyList_metas(node: PartiqlAst.GroupKeyList): Map<String, Any>

transformIdentifier

open fun transformIdentifier(node: PartiqlAst.Identifier): PartiqlAst.Identifier

transformIdentifier_case

open fun transformIdentifier_case(node: PartiqlAst.Identifier): PartiqlAst.CaseSensitivity

transformIdentifier_metas

open fun transformIdentifier_metas(node: PartiqlAst.Identifier): Map<String, Any>

transformIdentifier_name

open fun transformIdentifier_name(node: PartiqlAst.Identifier): SymbolPrimitive

transformJoinType

open fun transformJoinType(node: PartiqlAst.JoinType): PartiqlAst.JoinType

transformJoinTypeFull

open fun transformJoinTypeFull(node: PartiqlAst.JoinType.Full): PartiqlAst.JoinType

transformJoinTypeFull_metas

open fun transformJoinTypeFull_metas(node: PartiqlAst.JoinType.Full): Map<String, Any>

transformJoinTypeInner

open fun transformJoinTypeInner(node: PartiqlAst.JoinType.Inner): PartiqlAst.JoinType

transformJoinTypeInner_metas

open fun transformJoinTypeInner_metas(node: PartiqlAst.JoinType.Inner): Map<String, Any>

transformJoinTypeLeft

open fun transformJoinTypeLeft(node: PartiqlAst.JoinType.Left): PartiqlAst.JoinType

transformJoinTypeLeft_metas

open fun transformJoinTypeLeft_metas(node: PartiqlAst.JoinType.Left): Map<String, Any>

transformJoinTypeRight

open fun transformJoinTypeRight(node: PartiqlAst.JoinType.Right): PartiqlAst.JoinType

transformJoinTypeRight_metas

open fun transformJoinTypeRight_metas(node: PartiqlAst.JoinType.Right): Map<String, Any>

open fun transformLet(node: PartiqlAst.Let): PartiqlAst.Let

transformLet_letBindings

open fun transformLet_letBindings(node: PartiqlAst.Let): List<PartiqlAst.LetBinding>

transformLet_metas

open fun transformLet_metas(node: PartiqlAst.Let): Map<String, Any>

transformLetBinding

open fun transformLetBinding(node: PartiqlAst.LetBinding): PartiqlAst.LetBinding

transformLetBinding_expr

open fun transformLetBinding_expr(node: PartiqlAst.LetBinding): PartiqlAst.Expr

transformLetBinding_metas

open fun transformLetBinding_metas(node: PartiqlAst.LetBinding): Map<String, Any>

transformLetBinding_name

open fun transformLetBinding_name(node: PartiqlAst.LetBinding): SymbolPrimitive

transformLongPrimitive

open fun transformLongPrimitive(lng: LongPrimitive): LongPrimitive

transformLongPrimitiveMetas

open fun transformLongPrimitiveMetas(sym: LongPrimitive): MetaContainer

transformLongPrimitiveValue

open fun transformLongPrimitiveValue(sym: LongPrimitive): Long

open fun transformMetas(metas: MetaContainer): MetaContainer

transformNullsSpec

open fun transformNullsSpec(node: PartiqlAst.NullsSpec): PartiqlAst.NullsSpec

transformNullsSpecNullsFirst

open fun transformNullsSpecNullsFirst(node: PartiqlAst.NullsSpec.NullsFirst): PartiqlAst.NullsSpec

transformNullsSpecNullsFirst_metas

open fun transformNullsSpecNullsFirst_metas(node: PartiqlAst.NullsSpec.NullsFirst): Map<String, Any>

transformNullsSpecNullsLast

open fun transformNullsSpecNullsLast(node: PartiqlAst.NullsSpec.NullsLast): PartiqlAst.NullsSpec

transformNullsSpecNullsLast_metas

open fun transformNullsSpecNullsLast_metas(node: PartiqlAst.NullsSpec.NullsLast): Map<String, Any>

transformOnConflict

open fun transformOnConflict(node: PartiqlAst.OnConflict): PartiqlAst.OnConflict

transformOnConflict_conflictAction

open fun transformOnConflict_conflictAction(node: PartiqlAst.OnConflict): PartiqlAst.ConflictAction

transformOnConflict_expr

open fun transformOnConflict_expr(node: PartiqlAst.OnConflict): PartiqlAst.Expr

transformOnConflict_metas

open fun transformOnConflict_metas(node: PartiqlAst.OnConflict): Map<String, Any>

transformOnConflictValue

open fun transformOnConflictValue(node: PartiqlAst.OnConflictValue): PartiqlAst.OnConflictValue

transformOnConflictValueExcluded

open fun transformOnConflictValueExcluded(node: PartiqlAst.OnConflictValue.Excluded): PartiqlAst.OnConflictValue

transformOnConflictValueExcluded_metas

open fun transformOnConflictValueExcluded_metas(node: PartiqlAst.OnConflictValue.Excluded): Map<String, Any>

transformOrderBy

open fun transformOrderBy(node: PartiqlAst.OrderBy): PartiqlAst.OrderBy

transformOrderBy_metas

open fun transformOrderBy_metas(node: PartiqlAst.OrderBy): Map<String, Any>

transformOrderBy_sortSpecs

open fun transformOrderBy_sortSpecs(node: PartiqlAst.OrderBy): List<PartiqlAst.SortSpec>

transformOrderingSpec

open fun transformOrderingSpec(node: PartiqlAst.OrderingSpec): PartiqlAst.OrderingSpec

transformOrderingSpecAsc

open fun transformOrderingSpecAsc(node: PartiqlAst.OrderingSpec.Asc): PartiqlAst.OrderingSpec

transformOrderingSpecAsc_metas

open fun transformOrderingSpecAsc_metas(node: PartiqlAst.OrderingSpec.Asc): Map<String, Any>

transformOrderingSpecDesc

open fun transformOrderingSpecDesc(node: PartiqlAst.OrderingSpec.Desc): PartiqlAst.OrderingSpec

transformOrderingSpecDesc_metas

open fun transformOrderingSpecDesc_metas(node: PartiqlAst.OrderingSpec.Desc): Map<String, Any>

open fun transformOver(node: PartiqlAst.Over): PartiqlAst.Over

transformOver_metas

open fun transformOver_metas(node: PartiqlAst.Over): Map<String, Any>

transformOver_orderBy

open fun transformOver_orderBy(node: PartiqlAst.Over): PartiqlAst.WindowSortSpecList?

transformOver_partitionBy

open fun transformOver_partitionBy(node: PartiqlAst.Over): PartiqlAst.WindowPartitionList?

transformPathStep

open fun transformPathStep(node: PartiqlAst.PathStep): PartiqlAst.PathStep

transformPathStepPathExpr

open fun transformPathStepPathExpr(node: PartiqlAst.PathStep.PathExpr): PartiqlAst.PathStep

transformPathStepPathExpr_case

open fun transformPathStepPathExpr_case(node: PartiqlAst.PathStep.PathExpr): PartiqlAst.CaseSensitivity

transformPathStepPathExpr_index

open fun transformPathStepPathExpr_index(node: PartiqlAst.PathStep.PathExpr): PartiqlAst.Expr

transformPathStepPathExpr_metas

open fun transformPathStepPathExpr_metas(node: PartiqlAst.PathStep.PathExpr): Map<String, Any>

transformPathStepPathUnpivot

open fun transformPathStepPathUnpivot(node: PartiqlAst.PathStep.PathUnpivot): PartiqlAst.PathStep

transformPathStepPathUnpivot_metas

open fun transformPathStepPathUnpivot_metas(node: PartiqlAst.PathStep.PathUnpivot): Map<String, Any>

transformPathStepPathWildcard

open fun transformPathStepPathWildcard(node: PartiqlAst.PathStep.PathWildcard): PartiqlAst.PathStep

transformPathStepPathWildcard_metas

open fun transformPathStepPathWildcard_metas(node: PartiqlAst.PathStep.PathWildcard): Map<String, Any>

transformProjection

open fun transformProjection(node: PartiqlAst.Projection): PartiqlAst.Projection

transformProjectionProjectList

open override fun transformProjectionProjectList(node: PartiqlAst.Projection.ProjectList): PartiqlAst.Projection

transformProjectionProjectList_metas

open fun transformProjectionProjectList_metas(node: PartiqlAst.Projection.ProjectList): Map<String, Any>

transformProjectionProjectList_projectItems

open fun transformProjectionProjectList_projectItems(node: PartiqlAst.Projection.ProjectList): List<PartiqlAst.ProjectItem>

transformProjectionProjectPivot

open fun transformProjectionProjectPivot(node: PartiqlAst.Projection.ProjectPivot): PartiqlAst.Projection

transformProjectionProjectPivot_key

open fun transformProjectionProjectPivot_key(node: PartiqlAst.Projection.ProjectPivot): PartiqlAst.Expr

transformProjectionProjectPivot_metas

open fun transformProjectionProjectPivot_metas(node: PartiqlAst.Projection.ProjectPivot): Map<String, Any>

transformProjectionProjectPivot_value

open fun transformProjectionProjectPivot_value(node: PartiqlAst.Projection.ProjectPivot): PartiqlAst.Expr

transformProjectionProjectStar

open fun transformProjectionProjectStar(node: PartiqlAst.Projection.ProjectStar): PartiqlAst.Projection

transformProjectionProjectStar_metas

open fun transformProjectionProjectStar_metas(node: PartiqlAst.Projection.ProjectStar): Map<String, Any>

transformProjectionProjectValue

open override fun transformProjectionProjectValue(node: PartiqlAst.Projection.ProjectValue): PartiqlAst.Projection

transformProjectionProjectValue_metas

open fun transformProjectionProjectValue_metas(node: PartiqlAst.Projection.ProjectValue): Map<String, Any>

transformProjectionProjectValue_value

open fun transformProjectionProjectValue_value(node: PartiqlAst.Projection.ProjectValue): PartiqlAst.Expr

transformProjectItem

open fun transformProjectItem(node: PartiqlAst.ProjectItem): PartiqlAst.ProjectItem

transformProjectItemProjectAll

open fun transformProjectItemProjectAll(node: PartiqlAst.ProjectItem.ProjectAll): PartiqlAst.ProjectItem

transformProjectItemProjectAll_expr

open fun transformProjectItemProjectAll_expr(node: PartiqlAst.ProjectItem.ProjectAll): PartiqlAst.Expr

transformProjectItemProjectAll_metas

open fun transformProjectItemProjectAll_metas(node: PartiqlAst.ProjectItem.ProjectAll): Map<String, Any>

transformProjectItemProjectExpr

open fun transformProjectItemProjectExpr(node: PartiqlAst.ProjectItem.ProjectExpr): PartiqlAst.ProjectItem

transformProjectItemProjectExpr_asAlias

open fun transformProjectItemProjectExpr_asAlias(node: PartiqlAst.ProjectItem.ProjectExpr): SymbolPrimitive?

transformProjectItemProjectExpr_expr

open fun transformProjectItemProjectExpr_expr(node: PartiqlAst.ProjectItem.ProjectExpr): PartiqlAst.Expr

transformProjectItemProjectExpr_metas

open fun transformProjectItemProjectExpr_metas(node: PartiqlAst.ProjectItem.ProjectExpr): Map<String, Any>

transformReturningElem

open fun transformReturningElem(node: PartiqlAst.ReturningElem): PartiqlAst.ReturningElem

transformReturningElem_column

open fun transformReturningElem_column(node: PartiqlAst.ReturningElem): PartiqlAst.ColumnComponent

transformReturningElem_mapping

open fun transformReturningElem_mapping(node: PartiqlAst.ReturningElem): PartiqlAst.ReturningMapping

transformReturningElem_metas

open fun transformReturningElem_metas(node: PartiqlAst.ReturningElem): Map<String, Any>

transformReturningExpr

open fun transformReturningExpr(node: PartiqlAst.ReturningExpr): PartiqlAst.ReturningExpr

transformReturningExpr_elems

open fun transformReturningExpr_elems(node: PartiqlAst.ReturningExpr): List<PartiqlAst.ReturningElem>

transformReturningExpr_metas

open fun transformReturningExpr_metas(node: PartiqlAst.ReturningExpr): Map<String, Any>

transformReturningMapping

open fun transformReturningMapping(node: PartiqlAst.ReturningMapping): PartiqlAst.ReturningMapping

transformReturningMappingAllNew

open fun transformReturningMappingAllNew(node: PartiqlAst.ReturningMapping.AllNew): PartiqlAst.ReturningMapping

transformReturningMappingAllNew_metas

open fun transformReturningMappingAllNew_metas(node: PartiqlAst.ReturningMapping.AllNew): Map<String, Any>

transformReturningMappingAllOld

open fun transformReturningMappingAllOld(node: PartiqlAst.ReturningMapping.AllOld): PartiqlAst.ReturningMapping

transformReturningMappingAllOld_metas

open fun transformReturningMappingAllOld_metas(node: PartiqlAst.ReturningMapping.AllOld): Map<String, Any>

transformReturningMappingModifiedNew

open fun transformReturningMappingModifiedNew(node: PartiqlAst.ReturningMapping.ModifiedNew): PartiqlAst.ReturningMapping

transformReturningMappingModifiedNew_metas

open fun transformReturningMappingModifiedNew_metas(node: PartiqlAst.ReturningMapping.ModifiedNew): Map<String, Any>

transformReturningMappingModifiedOld

open fun transformReturningMappingModifiedOld(node: PartiqlAst.ReturningMapping.ModifiedOld): PartiqlAst.ReturningMapping

transformReturningMappingModifiedOld_metas

open fun transformReturningMappingModifiedOld_metas(node: PartiqlAst.ReturningMapping.ModifiedOld): Map<String, Any>

transformScopeQualifier

open fun transformScopeQualifier(node: PartiqlAst.ScopeQualifier): PartiqlAst.ScopeQualifier

transformScopeQualifierLocalsFirst

open fun transformScopeQualifierLocalsFirst(node: PartiqlAst.ScopeQualifier.LocalsFirst): PartiqlAst.ScopeQualifier

transformScopeQualifierLocalsFirst_metas

open fun transformScopeQualifierLocalsFirst_metas(node: PartiqlAst.ScopeQualifier.LocalsFirst): Map<String, Any>

transformScopeQualifierUnqualified

open fun transformScopeQualifierUnqualified(node: PartiqlAst.ScopeQualifier.Unqualified): PartiqlAst.ScopeQualifier

transformScopeQualifierUnqualified_metas

open fun transformScopeQualifierUnqualified_metas(node: PartiqlAst.ScopeQualifier.Unqualified): Map<String, Any>

transformSetQuantifier

open fun transformSetQuantifier(node: PartiqlAst.SetQuantifier): PartiqlAst.SetQuantifier

transformSetQuantifierAll

open fun transformSetQuantifierAll(node: PartiqlAst.SetQuantifier.All): PartiqlAst.SetQuantifier

transformSetQuantifierAll_metas

open fun transformSetQuantifierAll_metas(node: PartiqlAst.SetQuantifier.All): Map<String, Any>

transformSetQuantifierDistinct

open fun transformSetQuantifierDistinct(node: PartiqlAst.SetQuantifier.Distinct): PartiqlAst.SetQuantifier

transformSetQuantifierDistinct_metas

open fun transformSetQuantifierDistinct_metas(node: PartiqlAst.SetQuantifier.Distinct): Map<String, Any>

transformSortSpec

open fun transformSortSpec(node: PartiqlAst.SortSpec): PartiqlAst.SortSpec

transformSortSpec_expr

open override fun transformSortSpec_expr(node: PartiqlAst.SortSpec): PartiqlAst.Expr

transformSortSpec_metas

open fun transformSortSpec_metas(node: PartiqlAst.SortSpec): Map<String, Any>

transformSortSpec_nullsSpec

open fun transformSortSpec_nullsSpec(node: PartiqlAst.SortSpec): PartiqlAst.NullsSpec?

transformSortSpec_orderingSpec

open fun transformSortSpec_orderingSpec(node: PartiqlAst.SortSpec): PartiqlAst.OrderingSpec?

transformStatement

open fun transformStatement(node: PartiqlAst.Statement): PartiqlAst.Statement

transformStatementDdl

open fun transformStatementDdl(node: PartiqlAst.Statement.Ddl): PartiqlAst.Statement

transformStatementDdl_metas

open fun transformStatementDdl_metas(node: PartiqlAst.Statement.Ddl): Map<String, Any>

transformStatementDdl_op

open fun transformStatementDdl_op(node: PartiqlAst.Statement.Ddl): PartiqlAst.DdlOp

transformStatementDml

open fun transformStatementDml(node: PartiqlAst.Statement.Dml): PartiqlAst.Statement

transformStatementDml_from

open fun transformStatementDml_from(node: PartiqlAst.Statement.Dml): PartiqlAst.FromSource?

transformStatementDml_metas

open fun transformStatementDml_metas(node: PartiqlAst.Statement.Dml): Map<String, Any>

transformStatementDml_operations

open fun transformStatementDml_operations(node: PartiqlAst.Statement.Dml): PartiqlAst.DmlOpList

transformStatementDml_returning

open fun transformStatementDml_returning(node: PartiqlAst.Statement.Dml): PartiqlAst.ReturningExpr?

transformStatementDml_where

open fun transformStatementDml_where(node: PartiqlAst.Statement.Dml): PartiqlAst.Expr?

transformStatementExec

open fun transformStatementExec(node: PartiqlAst.Statement.Exec): PartiqlAst.Statement

transformStatementExec_args

open fun transformStatementExec_args(node: PartiqlAst.Statement.Exec): List<PartiqlAst.Expr>

transformStatementExec_metas

open fun transformStatementExec_metas(node: PartiqlAst.Statement.Exec): Map<String, Any>

transformStatementExec_procedureName

open fun transformStatementExec_procedureName(node: PartiqlAst.Statement.Exec): SymbolPrimitive

transformStatementExplain

open fun transformStatementExplain(node: PartiqlAst.Statement.Explain): PartiqlAst.Statement

transformStatementExplain_metas

open fun transformStatementExplain_metas(node: PartiqlAst.Statement.Explain): Map<String, Any>

transformStatementExplain_target

open fun transformStatementExplain_target(node: PartiqlAst.Statement.Explain): PartiqlAst.ExplainTarget

transformStatementQuery

open fun transformStatementQuery(node: PartiqlAst.Statement.Query): PartiqlAst.Statement

transformStatementQuery_expr

open fun transformStatementQuery_expr(node: PartiqlAst.Statement.Query): PartiqlAst.Expr

transformStatementQuery_metas

open fun transformStatementQuery_metas(node: PartiqlAst.Statement.Query): Map<String, Any>

transformSymbolPrimitive

open fun transformSymbolPrimitive(sym: SymbolPrimitive): SymbolPrimitive

transformSymbolPrimitiveMetas

open fun transformSymbolPrimitiveMetas(sym: SymbolPrimitive): MetaContainer

transformSymbolPrimitiveText

open fun transformSymbolPrimitiveText(sym: SymbolPrimitive): String

transformTableDef

open fun transformTableDef(node: PartiqlAst.TableDef): PartiqlAst.TableDef

transformTableDef_metas

open fun transformTableDef_metas(node: PartiqlAst.TableDef): Map<String, Any>

transformTableDef_parts

open fun transformTableDef_parts(node: PartiqlAst.TableDef): List<PartiqlAst.TableDefPart>

transformTableDefPart

open fun transformTableDefPart(node: PartiqlAst.TableDefPart): PartiqlAst.TableDefPart

transformTableDefPartColumnDeclaration

open fun transformTableDefPartColumnDeclaration(node: PartiqlAst.TableDefPart.ColumnDeclaration): PartiqlAst.TableDefPart

transformTableDefPartColumnDeclaration_constraints

open fun transformTableDefPartColumnDeclaration_constraints(node: PartiqlAst.TableDefPart.ColumnDeclaration): List<PartiqlAst.ColumnConstraint>

transformTableDefPartColumnDeclaration_metas

open fun transformTableDefPartColumnDeclaration_metas(node: PartiqlAst.TableDefPart.ColumnDeclaration): Map<String, Any>

transformTableDefPartColumnDeclaration_name

open fun transformTableDefPartColumnDeclaration_name(node: PartiqlAst.TableDefPart.ColumnDeclaration): SymbolPrimitive

transformTableDefPartColumnDeclaration_type

open fun transformTableDefPartColumnDeclaration_type(node: PartiqlAst.TableDefPart.ColumnDeclaration): PartiqlAst.Type

transformTimeValue

open fun transformTimeValue(node: PartiqlAst.TimeValue): PartiqlAst.TimeValue

transformTimeValue_hour

open fun transformTimeValue_hour(node: PartiqlAst.TimeValue): LongPrimitive

transformTimeValue_metas

open fun transformTimeValue_metas(node: PartiqlAst.TimeValue): Map<String, Any>

transformTimeValue_minute

open fun transformTimeValue_minute(node: PartiqlAst.TimeValue): LongPrimitive

transformTimeValue_nano

open fun transformTimeValue_nano(node: PartiqlAst.TimeValue): LongPrimitive

transformTimeValue_precision

open fun transformTimeValue_precision(node: PartiqlAst.TimeValue): LongPrimitive

transformTimeValue_second

open fun transformTimeValue_second(node: PartiqlAst.TimeValue): LongPrimitive

transformTimeValue_tzMinutes

open fun transformTimeValue_tzMinutes(node: PartiqlAst.TimeValue): LongPrimitive?

transformTimeValue_withTimeZone

open fun transformTimeValue_withTimeZone(node: PartiqlAst.TimeValue): BoolPrimitive

open fun transformType(node: PartiqlAst.Type): PartiqlAst.Type

transformTypeAnyType

open fun transformTypeAnyType(node: PartiqlAst.Type.AnyType): PartiqlAst.Type

transformTypeAnyType_metas

open fun transformTypeAnyType_metas(node: PartiqlAst.Type.AnyType): Map<String, Any>

transformTypeBagType

open fun transformTypeBagType(node: PartiqlAst.Type.BagType): PartiqlAst.Type

transformTypeBagType_metas

open fun transformTypeBagType_metas(node: PartiqlAst.Type.BagType): Map<String, Any>

transformTypeBlobType

open fun transformTypeBlobType(node: PartiqlAst.Type.BlobType): PartiqlAst.Type

transformTypeBlobType_metas

open fun transformTypeBlobType_metas(node: PartiqlAst.Type.BlobType): Map<String, Any>

transformTypeBooleanType

open fun transformTypeBooleanType(node: PartiqlAst.Type.BooleanType): PartiqlAst.Type

transformTypeBooleanType_metas

open fun transformTypeBooleanType_metas(node: PartiqlAst.Type.BooleanType): Map<String, Any>

transformTypeCharacterType

open fun transformTypeCharacterType(node: PartiqlAst.Type.CharacterType): PartiqlAst.Type

transformTypeCharacterType_length

open fun transformTypeCharacterType_length(node: PartiqlAst.Type.CharacterType): LongPrimitive?

transformTypeCharacterType_metas

open fun transformTypeCharacterType_metas(node: PartiqlAst.Type.CharacterType): Map<String, Any>

transformTypeCharacterVaryingType

open fun transformTypeCharacterVaryingType(node: PartiqlAst.Type.CharacterVaryingType): PartiqlAst.Type

transformTypeCharacterVaryingType_length

open fun transformTypeCharacterVaryingType_length(node: PartiqlAst.Type.CharacterVaryingType): LongPrimitive?

transformTypeCharacterVaryingType_metas

open fun transformTypeCharacterVaryingType_metas(node: PartiqlAst.Type.CharacterVaryingType): Map<String, Any>

transformTypeClobType

open fun transformTypeClobType(node: PartiqlAst.Type.ClobType): PartiqlAst.Type

transformTypeClobType_metas

open fun transformTypeClobType_metas(node: PartiqlAst.Type.ClobType): Map<String, Any>

transformTypeCustomType

open fun transformTypeCustomType(node: PartiqlAst.Type.CustomType): PartiqlAst.Type

transformTypeCustomType_metas

open fun transformTypeCustomType_metas(node: PartiqlAst.Type.CustomType): Map<String, Any>

transformTypeCustomType_name

open fun transformTypeCustomType_name(node: PartiqlAst.Type.CustomType): SymbolPrimitive

transformTypeDateType

open fun transformTypeDateType(node: PartiqlAst.Type.DateType): PartiqlAst.Type

transformTypeDateType_metas

open fun transformTypeDateType_metas(node: PartiqlAst.Type.DateType): Map<String, Any>

transformTypeDecimalType

open fun transformTypeDecimalType(node: PartiqlAst.Type.DecimalType): PartiqlAst.Type

transformTypeDecimalType_metas

open fun transformTypeDecimalType_metas(node: PartiqlAst.Type.DecimalType): Map<String, Any>

transformTypeDecimalType_precision

open fun transformTypeDecimalType_precision(node: PartiqlAst.Type.DecimalType): LongPrimitive?

transformTypeDecimalType_scale

open fun transformTypeDecimalType_scale(node: PartiqlAst.Type.DecimalType): LongPrimitive?

transformTypeDoublePrecisionType

open fun transformTypeDoublePrecisionType(node: PartiqlAst.Type.DoublePrecisionType): PartiqlAst.Type

transformTypeDoublePrecisionType_metas

open fun transformTypeDoublePrecisionType_metas(node: PartiqlAst.Type.DoublePrecisionType): Map<String, Any>

transformTypeFloatType

open fun transformTypeFloatType(node: PartiqlAst.Type.FloatType): PartiqlAst.Type

transformTypeFloatType_metas

open fun transformTypeFloatType_metas(node: PartiqlAst.Type.FloatType): Map<String, Any>

transformTypeFloatType_precision

open fun transformTypeFloatType_precision(node: PartiqlAst.Type.FloatType): LongPrimitive?

transformTypeInteger4Type

open fun transformTypeInteger4Type(node: PartiqlAst.Type.Integer4Type): PartiqlAst.Type

transformTypeInteger4Type_metas

open fun transformTypeInteger4Type_metas(node: PartiqlAst.Type.Integer4Type): Map<String, Any>

transformTypeInteger8Type

open fun transformTypeInteger8Type(node: PartiqlAst.Type.Integer8Type): PartiqlAst.Type

transformTypeInteger8Type_metas

open fun transformTypeInteger8Type_metas(node: PartiqlAst.Type.Integer8Type): Map<String, Any>

transformTypeIntegerType

open fun transformTypeIntegerType(node: PartiqlAst.Type.IntegerType): PartiqlAst.Type

transformTypeIntegerType_metas

open fun transformTypeIntegerType_metas(node: PartiqlAst.Type.IntegerType): Map<String, Any>

transformTypeListType

open fun transformTypeListType(node: PartiqlAst.Type.ListType): PartiqlAst.Type

transformTypeListType_metas

open fun transformTypeListType_metas(node: PartiqlAst.Type.ListType): Map<String, Any>

transformTypeMissingType

open fun transformTypeMissingType(node: PartiqlAst.Type.MissingType): PartiqlAst.Type

transformTypeMissingType_metas

open fun transformTypeMissingType_metas(node: PartiqlAst.Type.MissingType): Map<String, Any>

transformTypeNullType

open fun transformTypeNullType(node: PartiqlAst.Type.NullType): PartiqlAst.Type

transformTypeNullType_metas

open fun transformTypeNullType_metas(node: PartiqlAst.Type.NullType): Map<String, Any>

transformTypeNumericType

open fun transformTypeNumericType(node: PartiqlAst.Type.NumericType): PartiqlAst.Type

transformTypeNumericType_metas

open fun transformTypeNumericType_metas(node: PartiqlAst.Type.NumericType): Map<String, Any>

transformTypeNumericType_precision

open fun transformTypeNumericType_precision(node: PartiqlAst.Type.NumericType): LongPrimitive?

transformTypeNumericType_scale

open fun transformTypeNumericType_scale(node: PartiqlAst.Type.NumericType): LongPrimitive?

transformTypeRealType

open fun transformTypeRealType(node: PartiqlAst.Type.RealType): PartiqlAst.Type

transformTypeRealType_metas

open fun transformTypeRealType_metas(node: PartiqlAst.Type.RealType): Map<String, Any>

transformTypeSexpType

open fun transformTypeSexpType(node: PartiqlAst.Type.SexpType): PartiqlAst.Type

transformTypeSexpType_metas

open fun transformTypeSexpType_metas(node: PartiqlAst.Type.SexpType): Map<String, Any>

transformTypeSmallintType

open fun transformTypeSmallintType(node: PartiqlAst.Type.SmallintType): PartiqlAst.Type

transformTypeSmallintType_metas

open fun transformTypeSmallintType_metas(node: PartiqlAst.Type.SmallintType): Map<String, Any>

transformTypeStringType

open fun transformTypeStringType(node: PartiqlAst.Type.StringType): PartiqlAst.Type

transformTypeStringType_metas

open fun transformTypeStringType_metas(node: PartiqlAst.Type.StringType): Map<String, Any>

transformTypeStructType

open fun transformTypeStructType(node: PartiqlAst.Type.StructType): PartiqlAst.Type

transformTypeStructType_metas

open fun transformTypeStructType_metas(node: PartiqlAst.Type.StructType): Map<String, Any>

transformTypeSymbolType

open fun transformTypeSymbolType(node: PartiqlAst.Type.SymbolType): PartiqlAst.Type

transformTypeSymbolType_metas

open fun transformTypeSymbolType_metas(node: PartiqlAst.Type.SymbolType): Map<String, Any>

transformTypeTimestampType

open fun transformTypeTimestampType(node: PartiqlAst.Type.TimestampType): PartiqlAst.Type

transformTypeTimestampType_metas

open fun transformTypeTimestampType_metas(node: PartiqlAst.Type.TimestampType): Map<String, Any>

transformTypeTimeType

open fun transformTypeTimeType(node: PartiqlAst.Type.TimeType): PartiqlAst.Type

transformTypeTimeType_metas

open fun transformTypeTimeType_metas(node: PartiqlAst.Type.TimeType): Map<String, Any>

transformTypeTimeType_precision

open fun transformTypeTimeType_precision(node: PartiqlAst.Type.TimeType): LongPrimitive?

transformTypeTimeWithTimeZoneType

open fun transformTypeTimeWithTimeZoneType(node: PartiqlAst.Type.TimeWithTimeZoneType): PartiqlAst.Type

transformTypeTimeWithTimeZoneType_metas

open fun transformTypeTimeWithTimeZoneType_metas(node: PartiqlAst.Type.TimeWithTimeZoneType): Map<String, Any>

transformTypeTimeWithTimeZoneType_precision

open fun transformTypeTimeWithTimeZoneType_precision(node: PartiqlAst.Type.TimeWithTimeZoneType): LongPrimitive?

transformTypeTupleType

open fun transformTypeTupleType(node: PartiqlAst.Type.TupleType): PartiqlAst.Type

transformTypeTupleType_metas

open fun transformTypeTupleType_metas(node: PartiqlAst.Type.TupleType): Map<String, Any>

transformWindowPartitionList

open fun transformWindowPartitionList(node: PartiqlAst.WindowPartitionList): PartiqlAst.WindowPartitionList

transformWindowPartitionList_exprs

open fun transformWindowPartitionList_exprs(node: PartiqlAst.WindowPartitionList): List<PartiqlAst.Expr>

transformWindowPartitionList_metas

open fun transformWindowPartitionList_metas(node: PartiqlAst.WindowPartitionList): Map<String, Any>

transformWindowSortSpecList

open fun transformWindowSortSpecList(node: PartiqlAst.WindowSortSpecList): PartiqlAst.WindowSortSpecList

transformWindowSortSpecList_metas

open fun transformWindowSortSpecList_metas(node: PartiqlAst.WindowSortSpecList): Map<String, Any>

transformWindowSortSpecList_sortSpecs

open fun transformWindowSortSpecList_sortSpecs(node: PartiqlAst.WindowSortSpecList): List<PartiqlAst.SortSpec>