resolved_ast

type AbortBatchStmtNode ¶

type AbortBatchStmtNode struct {
	*BaseStatementNode
}

AbortBatchStmtNode this statement: ABORT BATCH;

type ActionOperation ¶

type ActionOperation int

const (
	ActionOperationNoAction ActionOperation = 0
	ActionOperationRestrict ActionOperation = 1
	ActionOperationCascade  ActionOperation = 2
	ActionOperationSetNull  ActionOperation = 3
)

type ActionType ¶

type ActionType int

const (
	ActionTypeInsert ActionType = 0
	ActionTypeUpdate ActionType = 1
	ActionTypeDelete ActionType = 2
)

type AddColumnActionNode ¶

type AddColumnActionNode struct {
	*BaseAlterActionNode
}

AddColumnActionNode ADD COLUMN action for ALTER TABLE statement.

func (n *AddColumnActionNode) ColumnDefinition() *ColumnDefinitionNode

func (n *AddColumnActionNode) IsIfNotExists() bool

func (n *AddColumnActionNode) SetColumnDefinition(v *ColumnDefinitionNode)

func (n *AddColumnActionNode) SetIsIfNotExists(v bool)

type AddConstraintActionNode ¶

type AddConstraintActionNode struct {
	*BaseAlterActionNode
}

AddConstraintActionNode ADD CONSTRAINT for ALTER TABLE statement.

func (n *AddConstraintActionNode) Constraint() ConstraintNode

func (n *AddConstraintActionNode) IsIfNotExists() bool

func (n *AddConstraintActionNode) SetConstraint(v ConstraintNode)

func (n *AddConstraintActionNode) SetIsIfNotExists(v bool)

func (n *AddConstraintActionNode) SetTable(v types.Table)

func (n *AddConstraintActionNode) Table() types.Table

type AddToRestricteeListActionNode ¶

type AddToRestricteeListActionNode struct {
	*BaseAlterActionNode
}

AddToRestricteeListActionNode This action for ALTER PRIVILEGE RESTRICTION statement:

ADD [IF NOT EXISTS] <restrictee_list>

<restrictee_list> is a list of users and groups the privilege restrictions

should apply to. Each restrictee is either a string
literal or a parameter.

func (n *AddToRestricteeListActionNode) AddRestrictee(v ExprNode)

func (n *AddToRestricteeListActionNode) IsIfNotExists() bool

func (n *AddToRestricteeListActionNode) RestricteeList() []ExprNode

func (n *AddToRestricteeListActionNode) SetIsIfNotExists(v bool)

func (n *AddToRestricteeListActionNode) SetRestricteeList(v []ExprNode)

type AggregateFunctionCallNode ¶

type AggregateFunctionCallNode struct {
	*BaseNonScalarFunctionCallNode
}

AggregateFunctionCallNode an aggregate function call. The signature always has mode AGGREGATE. This node only ever shows up as the outer function call in a AggregateScanNode.AggregateList.

func (n *AggregateFunctionCallNode) AddOrderByItem(v *OrderByItemNode)

func (n *AggregateFunctionCallNode) FunctionCallInfo() *FunctionCallInfo

func (n *AggregateFunctionCallNode) HavingModifier() *AggregateHavingModifierNode

func (n *AggregateFunctionCallNode) Limit() ExprNode

func (n *AggregateFunctionCallNode) OrderByItemList() []*OrderByItemNode

func (n *AggregateFunctionCallNode) SetFunctionCallInfo(v *FunctionCallInfo)

func (n *AggregateFunctionCallNode) SetHavingModifier(v *AggregateHavingModifierNode)

func (n *AggregateFunctionCallNode) SetLimit(v ExprNode)

func (n *AggregateFunctionCallNode) SetOrderByItemList(v []*OrderByItemNode)

type AggregateHavingModifierNode ¶

type AggregateHavingModifierNode struct {
	*BaseArgumentNode
}

AggregateHavingModifierNode this represents a HAVING MAX or HAVING MIN modifier in an aggregate expression. If an aggregate has arguments (x HAVING {MAX/MIN} y), the aggregate will be computed over only the x values in the rows with the maximal/minimal values of y.

<kind> the MAX/MIN kind of this HAVING <having_expr> the HAVING expression (y in the above example)

func (n *AggregateHavingModifierNode) HavingExpr() ExprNode

func (n *AggregateHavingModifierNode) ModifierKind() HavingModifierKind

func (n *AggregateHavingModifierNode) SetHavingExpr(v ExprNode)

func (n *AggregateHavingModifierNode) SetModifierKind(v HavingModifierKind)

type AggregateScanNode ¶

type AggregateScanNode struct {
	*BaseAggregateScanNode
}

AggregateScanNode apply aggregation to rows produced from input_scan, and output aggregated rows.

For each item in <grouping_set_list>, output additional rows computing the same <aggregate_list> over the input rows using a particular grouping set. The aggregation input values, including <input_scan>, computed columns in <group_by_list>, and aggregate function arguments in <aggregate_list>, should be computed just once and then reused as aggregation input for each grouping set. (This ensures that ROLLUP rows have correct totals, even with non-stable functions in the input.) For each grouping set, the <group_by_list> elements not included in the <group_by_column_list> are replaced with NULL.

<rollup_column_list> is the original list of columns from GROUP BY ROLLUP(...), if there was a ROLLUP clause, and is used only for rebuilding equivalent SQL for the resolved AST. Engines should refer to <grouping_set_list> rather than <rollup_column_list>.

func (n *AggregateScanNode) AddGroupingSet(v *GroupingSetNode)

func (n *AggregateScanNode) AddRollupColumn(v *ColumnRefNode)

func (n *AggregateScanNode) GroupingSetList() []*GroupingSetNode

func (n *AggregateScanNode) RollupColumnList() []*ColumnRefNode

func (n *AggregateScanNode) SetGroupingSetList(v []*GroupingSetNode)

func (n *AggregateScanNode) SetRollupColumnList(v []*ColumnRefNode)

type AlterActionNode ¶

type AlterActionNode interface {
	ArgumentNode
}

AlterActionNode a common node for all actions in statement ALTER <object>.

type AlterAllRowAccessPoliciesStmtNode ¶

type AlterAllRowAccessPoliciesStmtNode struct {
	*AlterObjectStmtNode
}

AlterAllRowAccessPoliciesStmtNode this statement:

ALTER ALL ROW ACCESS POLICIES ON <name_path> <alter_action_list>

<name_path> is a vector giving the identifier path in the table name. <alter_action_list> is a vector of actions to be done to the object. It

must have exactly one REVOKE FROM action with either
a non-empty grantee list or 'all'.

<table_scan> is a TableScan for the target table, which is used during

resolving and validation. Consumers can use either the table
object inside it or base <name_path> to reference the table.

func (n *AlterAllRowAccessPoliciesStmtNode) SetTableScan(v *TableScanNode)

func (n *AlterAllRowAccessPoliciesStmtNode) TableScan() *TableScanNode

type AlterColumnActionNode ¶

type AlterColumnActionNode interface {
	AlterActionNode
	IsIfExists() bool
	SetIsIfExists(bool)
	Column() string
	SetColumn(string)
}

AlterColumnActionNode a abstract node for all ALTER COLUMN actions in the ALTER TABLE statement:

ALTER TABLE <table_name> ALTER COLUMN [IF EXISTS] <column>

<is_if_exists> silently ignores the "column does not exist" error. <column> is the name of the column.

type AlterColumnDropDefaultActionNode ¶

type AlterColumnDropDefaultActionNode struct {
	*BaseAlterColumnActionNode
}

AlterColumnDropDefaultAction this ALTER action:

ALTER COLUMN [IF EXISTS] <column> DROP DEFAULT

Removes the DEFAULT constraint from the given column.

type AlterColumnDropNotNullActionNode ¶

type AlterColumnDropNotNullActionNode struct {
	*BaseAlterColumnActionNode
}

AlterColumnDropNotNullActionNode This ALTER action:

ALTER COLUMN [IF EXISTS] <column> DROP NOT NULL

Removes the NOT NULL constraint from the given column.

type AlterColumnOptionsActionNode ¶

type AlterColumnOptionsActionNode struct {
	*BaseAlterColumnActionNode
}

AlterColumnOptionsActionNode

func (n *AlterColumnOptionsActionNode) AddOption(v *OptionNode)

func (n *AlterColumnOptionsActionNode) OptionList() []*OptionNode

func (n *AlterColumnOptionsActionNode) SetOptionList(v []*OptionNode)

type AlterColumnSetDataTypeActionNode ¶

type AlterColumnSetDataTypeActionNode struct {
	*BaseAlterColumnActionNode
}

AlterColumnSetDataTypeActionNode ALTER COLUMN <column> SET DATA TYPE action for ALTER TABLE statement. It supports updating the data type of the column as well as updating type parameters and collation specifications of the column (and on struct fields and array elements).

func (n *AlterColumnSetDataTypeActionNode) SetUpdatedAnnotations(v *ColumnAnnotationsNode)

func (n *AlterColumnSetDataTypeActionNode) SetUpdatedType(v types.Type)

func (n *AlterColumnSetDataTypeActionNode) SetUpdatedTypeParameters(v *types.TypeParameters)

func (n *AlterColumnSetDataTypeActionNode) UpdatedAnnotations() *ColumnAnnotationsNode

func (n *AlterColumnSetDataTypeActionNode) UpdatedType() types.Type

func (n *AlterColumnSetDataTypeActionNode) UpdatedTypeParameters() *types.TypeParameters

type AlterColumnSetDefaultActionNode ¶

type AlterColumnSetDefaultActionNode struct {
	*BaseAlterColumnActionNode
}

AlterColumnSetDefaultActionNode alter column set default action:

ALTER COLUMN [IF EXISTS] <column> SET DEFAULT <default_value>

<default_value> sets the new default value expression. It only impacts future inserted rows, and has no impact on existing rows with the current default value. This is a metadata only operation.

Resolver validates that <default_value> expression can be coerced to the column type when <column> exists. If <column> is not found and <is_if_exists> is true, Resolver skips type match check.

func (n *AlterColumnSetDefaultActionNode) DefaultValue() *ColumnDefaultValueNode

func (n *AlterColumnSetDefaultActionNode) SetDefaultValue(v *ColumnDefaultValueNode)

type AlterDatabaseStmtNode ¶

type AlterDatabaseStmtNode struct {
	*AlterObjectStmtNode
}

AlterDatabaseStmtNode this statement:

ALTER DATABASE [IF EXISTS] <name_path> <alter_action_list>

This statement could be used to change the database level options.

type AlterEntityStmtNode ¶

type AlterEntityStmtNode struct {
	*AlterObjectStmtNode
}

AlterEntityStmtNode this statement: ALTER <entity_type> [IF EXISTS] <path_expression> <generic_alter_action>, ...

<entity_type> engine-specific entity type to be altered.

func (n *AlterEntityStmtNode) EntityType() string

func (n *AlterEntityStmtNode) SetEntityType(v string)

type AlterMaterializedViewStmtNode ¶

type AlterMaterializedViewStmtNode struct {
	*AlterObjectStmtNode
}

AlterMaterializedViewStmtNode this statement: ALTER MATERIALIZED VIEW [IF EXISTS] <name_path> <alter_action_list>.

type AlterObjectStmtNode ¶

type AlterObjectStmtNode struct {
	*BaseStatementNode
}

AlterObjectStmtNode common node for statements:

ALTER <object> [IF EXISTS] <name_path> <alter_action_list>

<name_path> is a vector giving the identifier path in the table <name>. It

is optional if
FEATURE_ALLOW_MISSING_PATH_EXPRESSION_IN_ALTER_DDL is enabled.

<alter_action_list> is a vector of actions to be done to the object. <is_if_exists> silently ignores the "name_path does not exist" error.

func (n *AlterObjectStmtNode) AddAlterAction(v AlterActionNode)

func (n *AlterObjectStmtNode) AddNamePath(v string)

func (n *AlterObjectStmtNode) AlterActionList() []AlterActionNode

func (n *AlterObjectStmtNode) IsIfExists() bool

func (n *AlterObjectStmtNode) NamePath() []string

func (n *AlterObjectStmtNode) SetAlterActionList(v []AlterActionNode)

func (n *AlterObjectStmtNode) SetIsIfExists(v bool)

func (n *AlterObjectStmtNode) SetNamePath(v []string)

type AlterPrivilegeRestrictionStmtNode ¶

type AlterPrivilegeRestrictionStmtNode struct {
	*AlterObjectStmtNode
}

AlterPrivilegeRestrictionStmtNode this statement:

ALTER PRIVILEGE RESTRICTION [IF EXISTS]
ON <column_privilege_list> ON <object_type> <name_path>
<alter_action_list>

<column_privilege_list> is the name of the column privileges on which

the restrictions have been applied.

<object_type> is a string identifier, which is currently either TABLE or

VIEW, which tells the engine how to look up the name.

func (n *AlterPrivilegeRestrictionStmtNode) AddColumnPrivilege(v *PrivilegeNode)

func (n *AlterPrivilegeRestrictionStmtNode) ColumnPrivilegeList() []*PrivilegeNode

func (n *AlterPrivilegeRestrictionStmtNode) ObjectType() string

func (n *AlterPrivilegeRestrictionStmtNode) SetColumnPrivilegeList(v []*PrivilegeNode)

func (n *AlterPrivilegeRestrictionStmtNode) SetObjectType(v string)

type AlterRowAccessPolicyStmtNode ¶

type AlterRowAccessPolicyStmtNode struct {
	*AlterObjectStmtNode
}

AlterRowAccessPolicyStmtNode this statement:

ALTER ROW ACCESS POLICY [IF EXISTS]
<name> ON <name_path>
<alter_action_list>

<name> is the name of the row access policy to be altered, scoped to the

table in the base <name_path>.

<table_scan> is a TableScan for the target table, which is used during

resolving and validation. Consumers can use either the table
object inside it or base <name_path> to reference the table.

func (n *AlterRowAccessPolicyStmtNode) Name() string

func (n *AlterRowAccessPolicyStmtNode) SetName(v string)

func (n *AlterRowAccessPolicyStmtNode) SetTableScan(v *TableScanNode)

func (n *AlterRowAccessPolicyStmtNode) TableScan() *TableScanNode

type AlterSchemaStmtNode ¶

type AlterSchemaStmtNode struct {
	*AlterObjectStmtNode
}

AlterSchemaStmtNode this statement: ALTER SCHEMA [IF NOT EXISTS] <name_path> <alter_action_list>.

type AlterTableSetOptionsStmtNode ¶

type AlterTableSetOptionsStmtNode struct {
	*BaseStatementNode
}

AlterTableSetOptionsStmtNode this statement:

ALTER TABLE [IF EXISTS] <name> SET OPTIONS (...)

NOTE: This is deprecated in favor of AlterTableStmtNode.

<name_path> is a vector giving the identifier path in the table <name>. <option_list> has engine-specific directives that specify how to

alter the metadata for this table.

<is_if_exists> silently ignore the "name_path does not exist" error.

func (n *AlterTableSetOptionsStmtNode) AddNamePath(v string)

func (n *AlterTableSetOptionsStmtNode) AddOption(v *OptionNode)

func (n *AlterTableSetOptionsStmtNode) IsIfExists() bool

func (n *AlterTableSetOptionsStmtNode) NamePath() []string

func (n *AlterTableSetOptionsStmtNode) OptionList() []*OptionNode

func (n *AlterTableSetOptionsStmtNode) SetIsIfExists(v bool)

func (n *AlterTableSetOptionsStmtNode) SetNamePath(v []string)

func (n *AlterTableSetOptionsStmtNode) SetOptionList(v []*OptionNode)

type AlterTableStmtNode ¶

type AlterTableStmtNode struct {
	*AlterObjectStmtNode
}

AlterTableStmtNode this statement: ALTER TABLE [IF EXISTS] <name_path> <alter_action_list>.

type AlterViewStmtNode ¶

type AlterViewStmtNode struct {
	*AlterObjectStmtNode
}

AlterViewStmtNode this statement: ALTER VIEW [IF EXISTS] <name_path> <alter_action_list>.

type AnalyticFunctionCallNode ¶

type AnalyticFunctionCallNode struct {
	*BaseNonScalarFunctionCallNode
}

AnalyticFunctionCallNode an analytic function call. The mode of the function is either AGGREGATE or ANALYTIC. This node only ever shows up as a function call in a AnalyticFunctionGroupNode.AnalyticFunctionList. Its associated window is not under this node but as a sibling of its parent node.

WindowFrame can be nil.

func (n *AnalyticFunctionCallNode) SetWindowFrame(v *WindowFrameNode)

func (n *AnalyticFunctionCallNode) WindowFrame() *WindowFrameNode

type AnalyticFunctionGroupNode ¶

type AnalyticFunctionGroupNode struct {
	*BaseArgumentNode
}

AnalyticFunctionGroupNode represents a group of analytic function calls that shares PARTITION BY and ORDER BY.

<partition_by> can be NULL. <order_by> may be NULL depending on the functions in <analytic_function_list> and the window frame unit. See (broken link) for more details.

All expressions in <analytic_function_list> have a ResolvedAggregateFunctionCall with a function in mode Function::AGGREGATE or Function::ANALYTIC.

func (n *AnalyticFunctionGroupNode) AddAnalyticFunction(v *ComputedColumnNode)

func (n *AnalyticFunctionGroupNode) AnalyticFunctionList() []*ComputedColumnNode

func (n *AnalyticFunctionGroupNode) OrderBy() *WindowOrderingNode

func (n *AnalyticFunctionGroupNode) PartitionBy() *WindowPartitioningNode

func (n *AnalyticFunctionGroupNode) SetAnalyticFunctionList(v []*ComputedColumnNode)

func (n *AnalyticFunctionGroupNode) SetOrderBy(v *WindowOrderingNode)

func (n *AnalyticFunctionGroupNode) SetPartitionBy(v *WindowPartitioningNode)

type AnalyticScanNode ¶

type AnalyticScanNode struct {
	*BaseScanNode
}

AnalyticScanNode apply analytic functions to rows produced from input_scan.

The set of analytic functions are partitioned into a list of analytic function groups <function_group_list> by the window PARTITION BY and the window ORDER BY.

The output <column_list> contains all columns from <input_scan>, one column per analytic function. It may also conain partitioning/ordering expression columns if they reference to select columns.

func (n *AnalyticScanNode) AddFunctionGroup(v *AnalyticFunctionGroupNode)

func (n *AnalyticScanNode) FunctionGroupList() []*AnalyticFunctionGroupNode

func (n *AnalyticScanNode) InputScan() ScanNode

func (n *AnalyticScanNode) SetFunctionGroupList(v []*AnalyticFunctionGroupNode)

func (n *AnalyticScanNode) SetInputScan(v ScanNode)

type AnalyzeStmtNode ¶

type AnalyzeStmtNode struct {
	*BaseStatementNode
}

AnalyzeStmtNode represents the ANALYZE statement: ANALYZE [OPTIONS (<option_list>)] [<table_and_column_index_list> [, ...]];

<option_list> is a list of options for ANALYZE.

<table_and_column_info_list> identifies a list of tables along with their related columns that are the target of ANALYZE.

func (n *AnalyzeStmtNode) AddOption(v *OptionNode)

func (n *AnalyzeStmtNode) AddTableAndColumnIndex(v *TableAndColumnInfoNode)

func (n *AnalyzeStmtNode) OptionList() []*OptionNode

func (n *AnalyzeStmtNode) SetOptionList(v []*OptionNode)

func (n *AnalyzeStmtNode) SetTableAndColumnIndexList(v []*TableAndColumnInfoNode)

func (n *AnalyzeStmtNode) TableAndColumnIndexList() []*TableAndColumnInfoNode

type AnonymizedAggregateScanNode ¶

type AnonymizedAggregateScanNode struct {
	*BaseAggregateScanNode
}

AnonymizedAggregateScanNode apply differentially private aggregation (anonymization) to rows produced from input_scan, and output anonymized rows.

<k_threshold_expr> when non-null, points to a function call in the <aggregate_list> and adds a filter that acts like:

HAVING <k_threshold_expr> >= <implementation-defined k-threshold>

omitting any rows that would not pass this condition. TODO: Update this comment after splitting the rewriter out into a separate stage.

<anonymization_option_list> provides user-specified options, and requires that option names are one of: delta, epsilon, kappa, or k_threshold.

func (n *AnonymizedAggregateScanNode) AddAnonymizationOption(v *OptionNode)

func (n *AnonymizedAggregateScanNode) AnonymizationOptionList() []*OptionNode

func (n *AnonymizedAggregateScanNode) KThresholdExpr() *ColumnRefNode

func (n *AnonymizedAggregateScanNode) SetAnonymizationOptionList(v []*OptionNode)

func (n *AnonymizedAggregateScanNode) SetKThresholdExpr(v *ColumnRefNode)

type ArgumentDefNode ¶

type ArgumentDefNode struct {
	*BaseArgumentNode
}

ArgumentDefNode this represents an argument definition, e.g. in a function's argument list.

<name> is the name of the argument; optional for DROP FUNCTION statements. <type> is the type of the argument. <argument_kind> indicates what kind of argument this is, including scalar

vs aggregate.  NOT_AGGREGATE means this is a non-aggregate
argument in an aggregate function, which can only passed constant
values only.

NOTE: Statements that create functions now include a FunctionSignature directly, and an argument_name_list if applicable. These completely describe the function signature, so the ArgumentDefNode list can be considered unnecessary and deprecated. TODO We could remove this node in the future.

func (n *ArgumentDefNode) ArgumentKind() ArgumentKind

func (n *ArgumentDefNode) Name() string

func (n *ArgumentDefNode) SetArgumentKind(v ArgumentKind)

func (n *ArgumentDefNode) SetName(v string)

func (n *ArgumentDefNode) SetType(v types.Type)

func (n *ArgumentDefNode) Type() types.Type

type ArgumentKind ¶

type ArgumentKind int

const (
	ArgumentKindScalar       ArgumentKind = 0
	ArgumentKindAggregate    ArgumentKind = 1
	ArgumentKindNotAggregate ArgumentKind = 2
)

type ArgumentListNode ¶

type ArgumentListNode struct {
	*BaseArgumentNode
}

ArgumentListNode this statement: [ (<arg_list>) ];

<arg_list> is an optional list of parameters. If given, each parameter

may consist of a type, or a name and a type.

NOTE: This can be considered deprecated in favor of the FunctionSignature

stored directly in the statement.

NOTE: ArgumentListNode is not related to the ArgumentNode,

which just exists to organize node classes.

func (n *ArgumentListNode) AddArg(v *ArgumentDefNode)

func (n *ArgumentListNode) ArgList() []*ArgumentDefNode

func (n *ArgumentListNode) SetArgList(v []*ArgumentDefNode)

type ArgumentNode ¶

type ArgumentNode interface {
	Node
}

ArgumentNode nodes are not self-contained nodes in the tree. They exist only to describe parameters to another node (e.g. columns in an OrderByNode). This node is here for organizational purposes only, to cluster these argument nodes.

type ArgumentRefNode ¶

type ArgumentRefNode struct {
	*BaseExprNode
}

ArgumentRefNode this represents an argument reference, e.g. in a function's body. <name> is the name of the argument. <argument_kind> is the ArgumentKind from the ArgumentDefNode.

For scalar functions, this is always SCALAR.
For aggregate functions, it can be AGGREGATE or NOT_AGGREGATE.
If NOT_AGGREGATE, then this is a non-aggregate argument
to an aggregate function, which has one constant value
for the entire function call (over all rows in all groups).
(This is copied from the ArgumentDefNode for convenience.)

func (n *ArgumentRefNode) ArgumentKind() ArgumentKind

func (n *ArgumentRefNode) Name() string

func (n *ArgumentRefNode) SetArgumentKind(v ArgumentKind)

func (n *ArgumentRefNode) SetName(v string)

type ArrayScanNode ¶

type ArrayScanNode struct {
	*BaseScanNode
}

ArrayScanNode scan an array value, produced from some expression.

If input_scan is NULL, this scans the given array value and produces one row per array element. This can occur when using UNNEST(expression).

If <input_scan> is non-NULL, for each row in the stream produced by input_scan, this evaluates the expression <array_expr> (which must return an array type) and then produces a stream with one row per array element.

If <join_expr> is non-NULL, then this condition is evaluated as an ON clause for the array join. The named column produced in <array_expr> may be used inside <join_expr>.

If the array is empty (after evaluating <join_expr>), then

1. If <is_outer> is false, the scan produces zero rows.
2. If <is_outer> is true, the scan produces one row with a NULL value for the <element_column>.

<element_column> is the new column produced by this scan that stores the array element value for each row.

If present, <array_offset_column> defines the column produced by this scan that stores the array offset (0-based) for the corresponding <element_column>.

This node's column_list can have columns from input_scan, <element_column> and <array_offset_column>.

func (n *ArrayScanNode) ArrayExpr() ExprNode

func (n *ArrayScanNode) ArrayOffsetColumn() *ColumnHolderNode

func (n *ArrayScanNode) ElementColumn() *Column

func (n *ArrayScanNode) InputScan() ScanNode

func (n *ArrayScanNode) IsOuter() bool

func (n *ArrayScanNode) JoinExpr() ExprNode

func (n *ArrayScanNode) SetArrayExpr(v ExprNode)

func (n *ArrayScanNode) SetArrayOffsetColumn(v *ColumnHolderNode)

func (n *ArrayScanNode) SetElementColumn(v *Column)

func (n *ArrayScanNode) SetInputScan(v ScanNode)

func (n *ArrayScanNode) SetIsOuter(v bool)

func (n *ArrayScanNode) SetJoinExpr(v ExprNode)

type AssertRowsModifiedNode ¶

type AssertRowsModifiedNode struct {
	*BaseArgumentNode
}

AssertRowsModifiedNode represents the ASSERT ROWS MODIFIED clause on a DML statement. The value must be a literal or (possibly casted) parameter int64.

The statement should fail if the number of rows updated does not exactly match this number.

func (n *AssertRowsModifiedNode) Rows() ExprNode

func (n *AssertRowsModifiedNode) SetRows(v ExprNode)

type AssertStmtNode ¶

type AssertStmtNode struct {
	*BaseStatementNode
}

AssertStmtNode represents the ASSERT statement:

ASSERT <expression> [AS <description>];

<expression> is any expression that returns a bool. <description> is an optional string literal used to give a more descriptive error message in case the ASSERT fails.

func (n *AssertStmtNode) Description() string

func (n *AssertStmtNode) Expression() ExprNode

func (n *AssertStmtNode) SetDescription(v string)

func (n *AssertStmtNode) SetExpression(v ExprNode)

type AssignmentStmtNode ¶

type AssignmentStmtNode struct {
	*BaseStatementNode
}

AssignmentStmtNode an assignment of a value to another value.

func (n *AssignmentStmtNode) Expr() ExprNode

func (n *AssignmentStmtNode) SetExpr(v ExprNode)

func (n *AssignmentStmtNode) SetTarget(v ExprNode)

func (n *AssignmentStmtNode) Target() ExprNode

type AuxLoadDataStmtNode ¶

type AuxLoadDataStmtNode struct {
	*BaseStatementNode
}

AuxLoadDataStmtNode LOAD DATA {OVERWRITE|INTO} <table_name> ... FROM FILES ...

This statement loads an external file to a new or existing table.
See (broken link).

<insertion_mode> either OVERWRITE or APPEND (INTO) the destination table. <name_path> the table to load data into. <output_column_list> the list of visible columns of the destination table.

If <column_definition_list> is explicitly specified:
  <output_column_list> =
      <column_definition_list> + <with_partition_columns>
Or if the table already exists:
  <output_column_list> = <name_path>.columns
Last, if the table doesn't exist and <column_definition_list> isn't
explicitly specified:
  <output_column_list> = detected-columns + <with_partition_columns>

<column_definition_list> If not empty, the explicit columns of the

destination table. Must be coerciable from the source file's fields.

When the destination table doesn't already exist, it will be created
with these columns (plus the additional columns from WITH PARTITION
COLUMNS subclause); otherwise, the destination table's schema must
match the explicit columns by both name and type.

<pseudo_column_list> is a list of pseudo-columns expected to be present on

the created table (provided by AnalyzerOptions::SetDdlPseudoColumns*).
These can be referenced in expressions in <partition_by_list> and
<cluster_by_list>.

<primary_key> specifies the PRIMARY KEY constraint on the table. It is

nullptr when no PRIMARY KEY is specified.
If specified, and the table already exists, the primary_key is
required to be the same as that of the existing.

<foreign_key_list> specifies the FOREIGN KEY constraints on the table.

If specified, and the table already exists, the foreign keys are
required to be the same as that of the existing.

<check_constraint_list> specifies the ZETASQL_CHECK constraints on the table.

If specified, and the table already exists, the constraints are
required to be the same as that of the existing.

<partition_by_list> The list of columns to partition the destination

table. Similar to <column_definition_list>, it must match the
destination table's partitioning spec if it already exists.

<cluster_by_list> The list of columns to cluster the destination

table. Similar to <column_definition_list>, it must match the
destination table's partitioning spec if it already exists.

<option_list> the options list describing the destination table.

If the destination doesn't already exist, it will be created with
these options; otherwise it must match the existing destination
table's options.

<with_partition_columns> The columns decoded from partitioned source

files. If the destination table doesn't already exist, these columns
will be implicitly added to the destination table's schema; otherwise
the destination table must already have these columns
(matching by both names and types).

The hive partition columns from the source file do not automatically
partition the destination table. To apply the partition, the
<partition_by_list> must be specified.

<connection> optional connection reference for accessing files. <from_files_option_list> the options list describing the source file(s).

func (n *AuxLoadDataStmtNode) AddCheckConstraint(v *CheckConstraintNode)

func (n *AuxLoadDataStmtNode) AddClusterBy(v ExprNode)

func (n *AuxLoadDataStmtNode) AddColumnDefinition(v *ColumnDefinitionNode)

func (n *AuxLoadDataStmtNode) AddForeignKey(v *ForeignKeyNode)

func (n *AuxLoadDataStmtNode) AddFromFilesOption(v *OptionNode)

func (n *AuxLoadDataStmtNode) AddNamePath(v string)

func (n *AuxLoadDataStmtNode) AddOption(v *OptionNode)

func (n *AuxLoadDataStmtNode) AddOutputColumn(v *OutputColumnNode)

func (n *AuxLoadDataStmtNode) AddPartitionBy(v ExprNode)

func (n *AuxLoadDataStmtNode) AddPseudoColumn(v *Column)

func (n *AuxLoadDataStmtNode) CheckConstraintList() []*CheckConstraintNode

func (n *AuxLoadDataStmtNode) ClusterByList() []ExprNode

func (n *AuxLoadDataStmtNode) ColumnDefinitionList() []*ColumnDefinitionNode

func (n *AuxLoadDataStmtNode) Connection() *ConnectionNode

func (n *AuxLoadDataStmtNode) ForeignKeyList() []*ForeignKeyNode

func (n *AuxLoadDataStmtNode) FromFilesOptionList() []*OptionNode

func (n *AuxLoadDataStmtNode) InsertionMode() InsertionMode

func (n *AuxLoadDataStmtNode) NamePath() []string

func (n *AuxLoadDataStmtNode) OptionList() []*OptionNode

func (n *AuxLoadDataStmtNode) OutputColumnList() []*OutputColumnNode

func (n *AuxLoadDataStmtNode) PartitionByList() []ExprNode

func (n *AuxLoadDataStmtNode) PrimaryKey() *PrimaryKeyNode

func (n *AuxLoadDataStmtNode) PseudoColumnList() []*Column

func (n *AuxLoadDataStmtNode) SetCheckConstraintList(v []*CheckConstraintNode)

func (n *AuxLoadDataStmtNode) SetClusterByList(v []ExprNode)

func (n *AuxLoadDataStmtNode) SetColumnDefinitionList(v []*ColumnDefinitionNode)

func (n *AuxLoadDataStmtNode) SetConnection(v *ConnectionNode)

func (n *AuxLoadDataStmtNode) SetForeignKeyList(v []*ForeignKeyNode)

func (n *AuxLoadDataStmtNode) SetFromFilesOptionList(v []*OptionNode)

func (n *AuxLoadDataStmtNode) SetInsertionMode(v InsertionMode)

func (n *AuxLoadDataStmtNode) SetNamePath(v []string)

func (n *AuxLoadDataStmtNode) SetOptionList(v []*OptionNode)

func (n *AuxLoadDataStmtNode) SetOutputColumnList(v []*OutputColumnNode)

func (n *AuxLoadDataStmtNode) SetPartitionByList(v []ExprNode)

func (n *AuxLoadDataStmtNode) SetPrimaryKey(v *PrimaryKeyNode)

func (n *AuxLoadDataStmtNode) SetPseudoColumnList(v []*Column)

func (n *AuxLoadDataStmtNode) SetWithPartitionColumns(v *WithPartitionColumnsNode)

func (n *AuxLoadDataStmtNode) WithPartitionColumns() *WithPartitionColumnsNode

type BaseAggregateScanNode ¶

type BaseAggregateScanNode struct {
	*BaseScanNode
}

BaseAggregateScanNode base node for aggregation scans. Apply aggregation to rows produced from input_scan, and output aggregated rows.

Group by keys in <group_by_list>. If <group_by_list> is empty, aggregate all input rows into one output row.

<collation_list> is either empty to indicate that all the elements in <group_by_list> have the default collation, or <collation_list> has the same number of elements as <group_by_list>. Each element is the collation for the element in <group_by_list> with the same index, or can be empty to indicate default collation or when the type is not collatable. <collation_list> is only set when FEATURE_V_1_3_COLLATION_SUPPORT is enabled.

Compute all aggregations in <aggregate_list>. All expressions in <aggregate_list> have a AggregateFunctionCallNode with mode Function.AGGREGATE as their outermost node.

The output <column_list> contains only columns produced from <group_by_list> and <aggregate_list>. No other columns are visible after aggregation.

func (n *BaseAggregateScanNode) AddAggregate(v *ComputedColumnNode)

func (n *BaseAggregateScanNode) AddCollation(v *Collation)

func (n *BaseAggregateScanNode) AddGroupBy(v *ComputedColumnNode)

func (n *BaseAggregateScanNode) AggregateList() []*ComputedColumnNode

func (n *BaseAggregateScanNode) CollationList() []*Collation

func (n *BaseAggregateScanNode) GroupByList() []*ComputedColumnNode

func (n *BaseAggregateScanNode) InputScan() ScanNode

func (n *BaseAggregateScanNode) SetAggregateList(v []*ComputedColumnNode)

func (n *BaseAggregateScanNode) SetCollationList(v []*Collation)

func (n *BaseAggregateScanNode) SetGroupByList(v []*ComputedColumnNode)

func (n *BaseAggregateScanNode) SetInputScan(v ScanNode)

type BaseAlterActionNode ¶

type BaseAlterActionNode struct {
	*BaseArgumentNode
}

type BaseAlterColumnActionNode ¶

type BaseAlterColumnActionNode struct {
	*BaseAlterActionNode
}

func (n *BaseAlterColumnActionNode) Column() string

func (n *BaseAlterColumnActionNode) IsIfExists() bool

func (n *BaseAlterColumnActionNode) SetColumn(v string)

func (n *BaseAlterColumnActionNode) SetIsIfExists(v bool)

type BaseArgumentNode ¶

type BaseArgumentNode struct {
	*BaseNode
}

type BaseConstraintNode ¶

type BaseConstraintNode struct {
	*BaseArgumentNode
}

type BaseCreateStatementNode ¶

type BaseCreateStatementNode struct {
	*BaseStatementNode
}

BaseCreateStatementNode

func (n *BaseCreateStatementNode) AddNamePath(v string)

func (n *BaseCreateStatementNode) CreateMode() CreateMode

func (n *BaseCreateStatementNode) CreateScope() CreateScope

func (n *BaseCreateStatementNode) NamePath() []string

func (n *BaseCreateStatementNode) SetCreateMode(v CreateMode)

func (n *BaseCreateStatementNode) SetCreateScope(v CreateScope)

func (n *BaseCreateStatementNode) SetNamePath(v []string)

type BaseCreateTableStmtNode ¶

type BaseCreateTableStmtNode struct {
	*BaseCreateStatementNode
}

BaseCreateTableStmtNode this statement:

CREATE [TEMP] TABLE <name> [(column type, ...) | LIKE <name_path>]
[DEFAULT COLLATE <collation>] [PARTITION BY expr, ...]
[CLUSTER BY expr, ...] [OPTIONS (...)]

<option_list> has engine-specific directives for how and where to

materialize this table.

<column_definition_list> has the names and types of the columns in the

created table. If <is_value_table> is true, it
must contain exactly one column, with a generated
name such as "$struct".

<pseudo_column_list> is a list of some pseudo-columns expected to be

present on the created table (provided by
AnalyzerOptions::SetDdlPseudoColumns*).  These can be
referenced in expressions in <partition_by_list> and
<cluster_by_list>.

<primary_key> specifies the PRIMARY KEY constraint on the table, it is

nullptr when no PRIMARY KEY is specified.

<foreign_key_list> specifies the FOREIGN KEY constraints on the table. <check_constraint_list> specifies the ZETASQL_CHECK constraints on the table. <partition_by_list> specifies the partitioning expressions for the table. <cluster_by_list> specifies the clustering expressions for the table. TODO: Return error when the PARTITION BY / CLUSTER BY expression resolves to have collation specified. <is_value_table> specifies whether the table is a value table. <like_table> identifies the table in the LIKE <name_path>.

By default, all fields (column names, types, constraints,
keys, clustering etc.) will be inherited from the source
table. But if explicitly set, the explicit settings will
take precedence.

<collation_name> specifies the default collation specification to apply to

newly added STRING fields in this table. A change of this field affects
only the STRING columns and the STRING fields in STRUCTs added
afterwards, not existing columns. Only string literals are allowed for
this field.

Note: During table creation or alteration, if a STRING field is added to
this table without explicit collation specified, the engine should copy
the table default collation to the STRING field.

func (n *BaseCreateTableStmtNode) AddCheckConstraint(v *CheckConstraintNode)

func (n *BaseCreateTableStmtNode) AddColumnDefinition(v *ColumnDefinitionNode)

func (n *BaseCreateTableStmtNode) AddForeignKey(v *ForeignKeyNode)

func (n *BaseCreateTableStmtNode) AddOption(v *OptionNode)

func (n *BaseCreateTableStmtNode) AddPseudoColumn(v *Column)

func (n *BaseCreateTableStmtNode) CheckConstraintList() []*CheckConstraintNode

func (n *BaseCreateTableStmtNode) CollationName() ExprNode

func (n *BaseCreateTableStmtNode) ColumnDefinitionList() []*ColumnDefinitionNode

func (n *BaseCreateTableStmtNode) ForeignKeyList() []*ForeignKeyNode

func (n *BaseCreateTableStmtNode) IsValueTable() bool

func (n *BaseCreateTableStmtNode) LikeTable() types.Table

func (n *BaseCreateTableStmtNode) OptionList() []*OptionNode

func (n *BaseCreateTableStmtNode) PrimaryKey() *PrimaryKeyNode

func (n *BaseCreateTableStmtNode) PseudoColumnList() []*Column

func (n *BaseCreateTableStmtNode) SetCheckConstraintList(v []*CheckConstraintNode)

func (n *BaseCreateTableStmtNode) SetCollationName(v ExprNode)

func (n *BaseCreateTableStmtNode) SetColumnDefinitionList(v []*ColumnDefinitionNode)

func (n *BaseCreateTableStmtNode) SetForeignKeyList(v []*ForeignKeyNode)

func (n *BaseCreateTableStmtNode) SetIsValueTable(v bool)

func (n *BaseCreateTableStmtNode) SetLikeTable(v types.Table)

func (n *BaseCreateTableStmtNode) SetOptionList(v []*OptionNode)

func (n *BaseCreateTableStmtNode) SetPrimaryKey(v *PrimaryKeyNode)

func (n *BaseCreateTableStmtNode) SetPseudoColumnList(v []*Column)

type BaseCreateViewNode ¶

type BaseCreateViewNode struct {
	*BaseCreateStatementNode
}

BaseCreateView common node for CREATE view/materialized view:

CREATE [TEMP|MATERIALIZED] [RECURSIVE] VIEW <name> [(...)]
  [OPTIONS (...)]
  AS SELECT ...

<option_list> has engine-specific directives for options attached to

this view.

<output_column_list> has the names and types of the columns in the

created view, and maps from <query>'s column_list
to these output columns. If <has_explicit_columns> is
true, names will be explicitly provided.

<has_explicit_columns> If this is set, the statement includes an explicit

column name list. These column names should still be applied even if the
query changes or is re-resolved in the future. The view becomes invalid
if the query produces a different number of columns.

<query> is the query to run. <sql> is the view query text. <sql_security> is the declared security mode for the function. Values

include 'INVOKER', 'DEFINER'.

<recursive> specifies whether or not the view is created with the

RECURSIVE keyword.

Note that <query> and <sql> are both marked as IGNORABLE because an engine could look at either one (but might not look at both). An engine must look at one (and cannot ignore both) to be semantically valid, but there is currently no way to enforce that.

The view must produce named columns with unique names.

func (n *BaseCreateViewNode) AddOption(v *OptionNode)

func (n *BaseCreateViewNode) AddOutputColumn(v *OutputColumnNode)

func (n *BaseCreateViewNode) HasExplicitColumns() bool

func (n *BaseCreateViewNode) IsValueTable() bool

func (n *BaseCreateViewNode) OptionList() []*OptionNode

func (n *BaseCreateViewNode) OutputColumnList() []*OutputColumnNode

func (n *BaseCreateViewNode) Query() ScanNode

func (n *BaseCreateViewNode) Recursive() bool

func (n *BaseCreateViewNode) SQL() string

func (n *BaseCreateViewNode) SQLSecurity() SQLSecurity

func (n *BaseCreateViewNode) SetHasExplicitColumns(v bool)

func (n *BaseCreateViewNode) SetIsValueTable(v bool)

func (n *BaseCreateViewNode) SetOptionList(v []*OptionNode)

func (n *BaseCreateViewNode) SetOutputColumnList(v []*OutputColumnNode)

func (n *BaseCreateViewNode) SetQuery(v ScanNode)

func (n *BaseCreateViewNode) SetRecursive(v bool)

func (n *BaseCreateViewNode) SetSQL(v string)

func (n *BaseCreateViewNode) SetSQLSecurity(v SQLSecurity)

type BaseExprNode ¶

type BaseExprNode struct {
	*BaseNode
}

func (n *BaseExprNode) SetType(v types.Type)

func (n *BaseExprNode) SetTypeAnnotationMap(v types.AnnotationMap)

func (n *BaseExprNode) Type() types.Type

func (n *BaseExprNode) TypeAnnotationMap() types.AnnotationMap

type BaseFunctionCallNode ¶

type BaseFunctionCallNode struct {
	*BaseExprNode
}

BaseFunctionCallNode common base node for scalar and aggregate function calls.

<argument_list> contains a list of arguments of type ExprNode.

<generic_argument_list> contains an alternative list of generic arguments. This is used for function calls that accept non-expression arguments (i.e. arguments that aren't part of the type system, like lambdas).

If all arguments of this function call are ExprNodes, <argument_list> is used. If any of the argument is not a ExprNode, <generic_argument_list> will be used. Only one of <argument_list> or <generic_argument_list> can be non-empty.

<collation_list> (only set when FEATURE_V_1_3_COLLATION_SUPPORT is enabled) is the operation collation to use. (broken link) lists the functions affected by collation, where this can show up. <collation_list> is a vector for future extension. For now, functions could have at most one element in the <collation_list>.

func (n *BaseFunctionCallNode) AddArgument(v ExprNode)

func (n *BaseFunctionCallNode) AddCollation(v *Collation)

func (n *BaseFunctionCallNode) AddGenericArgument(v *FunctionArgumentNode)

func (n *BaseFunctionCallNode) AddHint(v *OptionNode)

func (n *BaseFunctionCallNode) ArgumentList() []ExprNode

func (n *BaseFunctionCallNode) CollationList() []*Collation

func (n *BaseFunctionCallNode) ErrorMode() ErrorMode

func (n *BaseFunctionCallNode) Function() *types.Function

func (n *BaseFunctionCallNode) GenericArgumentList() []*FunctionArgumentNode

func (n *BaseFunctionCallNode) HintList() []*OptionNode

func (n *BaseFunctionCallNode) SetArgumentList(v []ExprNode)

func (n *BaseFunctionCallNode) SetCollationList(v []*Collation)

func (n *BaseFunctionCallNode) SetErrorMode(v ErrorMode)

func (n *BaseFunctionCallNode) SetFunction(v *types.Function)

func (n *BaseFunctionCallNode) SetGenericArgumentList(v []*FunctionArgumentNode)

func (n *BaseFunctionCallNode) SetHintList(v []*OptionNode)

func (n *BaseFunctionCallNode) SetSignature(v *types.FunctionSignature)

func (n *BaseFunctionCallNode) Signature() *types.FunctionSignature

type BaseNode ¶

type BaseNode struct {
	// contains filtered or unexported fields
}

func (n *BaseNode) ChildNodes() []Node

func (n *BaseNode) DebugString() string

func (n *BaseNode) IsExpression() bool

func (n *BaseNode) IsScan() bool

func (n *BaseNode) IsStatement() bool

func (n *BaseNode) Kind() Kind

func (n *BaseNode) ParseLocationRange() *types.ParseLocationRange

func (n *BaseNode) TreeDepth() int

type BaseNonScalarFunctionCallNode ¶

type BaseNonScalarFunctionCallNode struct {
	*BaseFunctionCallNode
}

BaseNonScalarFunctionCallNode common base node for scalar and aggregate function calls.

func (n *BaseNonScalarFunctionCallNode) AddWithGroupRowsParameter(v *ColumnRefNode)

func (n *BaseNonScalarFunctionCallNode) Distinct() bool

func (n *BaseNonScalarFunctionCallNode) NullHandlingModifier() NullHandlingModifier

func (n *BaseNonScalarFunctionCallNode) SetDistinct(v bool)

func (n *BaseNonScalarFunctionCallNode) SetNullHandlingModifier(v NullHandlingModifier)

func (n *BaseNonScalarFunctionCallNode) SetWithGroupRowsParameterList(v []*ColumnRefNode)

func (n *BaseNonScalarFunctionCallNode) SetWithGroupRowsSubquery(v ScanNode)

func (n *BaseNonScalarFunctionCallNode) WithGroupRowsParameterList() []*ColumnRefNode

func (n *BaseNonScalarFunctionCallNode) WithGroupRowsSubquery() ScanNode

type BaseScanNode ¶

type BaseScanNode struct {
	*BaseNode
}

func (n *BaseScanNode) AddColumn(v *Column)

func (n *BaseScanNode) AddHint(v *OptionNode)

func (n *BaseScanNode) ColumnList() []*Column

func (n *BaseScanNode) HintList() []*OptionNode

func (n *BaseScanNode) IsOrdered() bool

func (n *BaseScanNode) SetColumnList(v []*Column)

func (n *BaseScanNode) SetHintList(v []*OptionNode)

func (n *BaseScanNode) SetIsOrdered(v bool)

type BaseStatementNode ¶

type BaseStatementNode struct {
	*BaseNode
}

BaseStatementNode

func (n *BaseStatementNode) AddHint(v *OptionNode)

func (n *BaseStatementNode) HintList() []*OptionNode

func (n *BaseStatementNode) SetHintList(v []*OptionNode)

type BeginStmtNode ¶

type BeginStmtNode struct {
	*BaseStatementNode
}

BeginStmtNode this statement: BEGIN [TRANSACTION] [ <transaction_mode> [, ...] ]

Where transaction_mode is one of:

READ ONLY
READ WRITE
<isolation_level>

<isolation_level> is a string vector storing the identifiers after

ISOLATION LEVEL. The strings inside vector could be one of the
SQL standard isolation levels:

            READ UNCOMMITTED
            READ COMMITTED
            READ REPEATABLE
            SERIALIZABLE

or could be arbitrary strings. ZetaSQL does not validate that
the string is valid.

func (n *BeginStmtNode) AddIsolationLevel(v string)

func (n *BeginStmtNode) IsolationLevelList() []string

func (n *BeginStmtNode) ReadWriteMode() ReadWriteMode

func (n *BeginStmtNode) SetIsolationLevelList(v []string)

func (n *BeginStmtNode) SetReadWriteMode(v ReadWriteMode)

type BoundaryType ¶

type BoundaryType int

const (
	UnboundedPrecedingType BoundaryType = 0
	OffsetPrecedingType    BoundaryType = 1
	CurrentRowType         BoundaryType = 2
	OffsetFollowingType    BoundaryType = 3
	UnboundedFollowingType BoundaryType = 4
)

type CallStmtNode ¶

type CallStmtNode struct {
	*BaseStatementNode
}

CallStmtNode this statement: CALL <procedure>;

<procedure> Procedure to call. <signature> Resolved FunctionSignature for this procedure. <argument_list> Procedure arguments.

func (n *CallStmtNode) AddArgument(v ExprNode)

func (n *CallStmtNode) ArgumentList() []ExprNode

func (n *CallStmtNode) Procedure() types.Procedure

func (n *CallStmtNode) SetArgumentList(v []ExprNode)

func (n *CallStmtNode) SetProcedure(v types.Procedure)

func (n *CallStmtNode) SetSignature(v *types.FunctionSignature)

func (n *CallStmtNode) Signature() *types.FunctionSignature

type CastNode ¶

type CastNode struct {
	*BaseExprNode
}

CastNode a cast expression, casting the result of an input expression to the target Type.

Valid casts are defined in the CastHashMap, which identifies valid from-Type, to-Type pairs. Consumers can access it through ZetaSQLCasts().

func (n *CastNode) Expr() ExprNode

func (n *CastNode) ExtendedCast() *ExtendedCastNode

func (n *CastNode) Format() ExprNode

func (n *CastNode) ReturnNullOnError() bool

func (n *CastNode) SetExpr(v ExprNode)

func (n *CastNode) SetExtendedCast(v *ExtendedCastNode)

func (n *CastNode) SetFormat(v ExprNode)

func (n *CastNode) SetReturnNullOnError(v bool)

func (n *CastNode) SetTimeZone(v ExprNode)

func (n *CastNode) SetTypeParameters(v *types.TypeParameters)

func (n *CastNode) TimeZone() ExprNode

func (n *CastNode) TypeParameters() *types.TypeParameters

CAST("ABC" as STRING(2)) should error out
CAST(1234 as NUMERIC(2)) should error out
CAST(1.234 as NUMERIC(2,1)) should return a NumericValue of 1.2

type CheckConstraintNode ¶

type CheckConstraintNode struct {
	*BaseConstraintNode
}

CheckConstraintNode this represents the ZETASQL_CHECK constraint on a table. It is of the form:

CONSTRAINT <constraint_name>
ZETASQL_CHECK <expression>
<enforced>
<option_list>

<constraint_name> uniquely identifies the constraint.

<expression> defines a boolean expression to be evaluated when the row is updated. If the result is FALSE, update to the row is not allowed.

<enforced> specifies whether or not the constraint is enforced.

<option_list> list of options for check constraint.

func (n *CheckConstraintNode) AddOption(v *OptionNode)

func (n *CheckConstraintNode) ConstraintName() string

func (n *CheckConstraintNode) Enforced() bool

func (n *CheckConstraintNode) Expression() ExprNode

func (n *CheckConstraintNode) OptionList() []*OptionNode

func (n *CheckConstraintNode) SetConstraintName(v string)

func (n *CheckConstraintNode) SetEnforced(v bool)

func (n *CheckConstraintNode) SetExpression(v ExprNode)

func (n *CheckConstraintNode) SetOptionList(v []*OptionNode)

type CloneDataStmtNode ¶

type CloneDataStmtNode struct {
	*BaseStatementNode
}

CloneDataStmtNode CLONE DATA INTO <table_name> FROM ...

<target_table> the table to clone data into. Cannot be value table. <clone_from> The source table(s) to clone data from.

For a single table, the scan is TableScan, with an optional
    for_system_time_expr;
If WHERE clause is present, the Scan is wrapped inside
    FilterScanNode;
When multiple sources are present, they are UNION'ed together
    in a SetOperationScanNode.

Constraints:
  The target_table must not be the same as any source table,
  and two sources cannot refer to the same table.
  All source tables and target table must have equal number
  of columns, with positionally identical column names and
  types.
  Cannot be value table.

func (n *CloneDataStmtNode) CloneFrom() ScanNode

func (n *CloneDataStmtNode) SetCloneFrom(v ScanNode)

func (n *CloneDataStmtNode) SetTargetTable(v *TableScanNode)

func (n *CloneDataStmtNode) TargetTable() *TableScanNode

type Collation ¶

type Collation struct {
	// contains filtered or unexported fields
}

Collation is used with types.Type to indicate the resolved collation for the type. For nested types, see comments on <child_list_> for how collation on subfield(s) are stored. This is always stored in a normalized form, meaning on all the nested levels, it has either an empty <child_list_> to indicate that it has no collation in any child, or it has at least one non-empty child.

func (c *Collation) ChildList() []*Collation

func (c *Collation) CollationName() string

func (c *Collation) DebugString() string

func (c *Collation) Empty() bool

func (c *Collation) Equals(that *Collation) bool

func (c *Collation) HasCollation() bool

func (c *Collation) HasCompatibleStructure(typ types.Type) bool

type Column ¶

type Column struct {
	// contains filtered or unexported fields
}

Column a column produced by part of a query (e.g. a scan or subquery).

This is used in the column_list of a resolved AST node to represent a "slot" in the "tuple" produced by that logical operator. This is also used in expressions in ColumnRefNode to point at the column selected during name resolution.

The column_id is the definitive identifier for a Column, and the column_id should be used to match a ColumnRefNode in an expression to the scan that produces that column. column_ids are unique within a query. If the same table is scanned multiple times, distinct column_ids will be chosen for each scan.

Joins and other combining nodes may propagate Columns from their inputs, with the same column_ids.

func (c *Column) AnnotatedType() *types.AnnotatedType

func (c *Column) Clear()

func (c *Column) ColumnID() int

func (c *Column) DebugString() string

func (c *Column) IsInitialized() bool

func (c *Column) Name() string

func (c *Column) NameID() string

func (c *Column) ShortDebugString() string

func (c *Column) TableName() string

func (c *Column) TableNameID() string

func (c *Column) Type() types.Type

func (c *Column) TypeAnnotationMap() types.AnnotationMap

type ColumnAnnotationsNode ¶

type ColumnAnnotationsNode struct {
	*BaseArgumentNode
}

ColumnAnnotationsNode this is used in CREATE TABLE statements to provide column annotations such as collation, NOT NULL, type parameters, and OPTIONS().

This class is recursive. It mirrors the structure of the column type except that child_list might be truncated.

For ARRAY:

If the element or its subfield has annotations, then child_list.size()
is 1, and child_list(0) stores the element annotations.
Otherwise child_list is empty.

For STRUCT:

If the i-th field has annotations then child_list(i) stores the
field annotations.
Otherwise either child_list.size() <= i or child_list(i) is trivial.
If none of the fields and none of their subfields has annotations, then
child_list is empty.

For other types, child_list is empty.

func (n *ColumnAnnotationsNode) AddChild(v *ColumnAnnotationsNode)

func (n *ColumnAnnotationsNode) AddOption(v *OptionNode)

func (n *ColumnAnnotationsNode) ChildList() []*ColumnAnnotationsNode

func (n *ColumnAnnotationsNode) CollationName() ExprNode

func (n *ColumnAnnotationsNode) NotNull() bool

func (n *ColumnAnnotationsNode) OptionList() []*OptionNode