class FunctionIfBranchSegment(BaseSegment):
"""The definition of a if branch within a function body."""
type = "function_if_branch"
match_grammar = Sequence(
"IF",
AnyNumberOf(Ref("ExpressionSegment")),
"THEN",
AnyNumberOf(Ref("FunctionBodySegment"), min_times=1),
AnyNumberOf(
Sequence(
OneOf("ELSIF", "ELSEIF"),
Ref("ExpressionSegment"),
"THEN",
AnyNumberOf(Ref("FunctionBodySegment"), min_times=1),
),
optional=True,
),
Sequence("ELSE",
AnyNumberOf(Ref("FunctionBodySegment"), min_times=1),
optional=True),
"END",
"IF",
Ref("DelimiterSegment"),
)
class FunctionForLoopSegment(BaseSegment):
"""The definition of a for loop within a function body."""
type = "function_for_loop"
match_grammar = Sequence(
"FOR",
Ref("NakedIdentifierSegment"),
OneOf(
# # for x := 1 to 10 do...
Sequence(
Ref("WalrusOperatorSegment"),
# Anything(),
Ref("ExpressionSegment"), # could be a variable
"TO",
Ref("ExpressionSegment"), # could be a variable
"DO",
AnyNumberOf(Ref("FunctionBodySegment"), min_times=1),
"END",
"FOR",
),
# for x IN 1..10...
Sequence(
"IN",
Ref("ExpressionSegment"), # could be a variable
Ref("RangeOperator"),
Ref("ExpressionSegment"), # could be a variable
"LOOP",
AnyNumberOf(Ref("FunctionBodySegment"), min_times=1),
"END",
"LOOP",
),
),
Ref("DelimiterSegment"),
)
class CreateFunctionStatementSegment(BaseSegment):
"""A `CREATE FUNCTION` statement."""
type = "create_function_statement"
is_ddl = True
is_dml = False
is_dql = False
is_dcl = False
match_grammar = StartsWith(
Sequence(
"CREATE",
Ref("OrReplaceGrammar", optional=True),
"FUNCTION",
)
)
parse_grammar = Sequence(
"CREATE",
Ref("OrReplaceGrammar", optional=True),
"FUNCTION",
Ref("FunctionReferenceSegment"),
Bracketed(
Delimited(
Sequence(
Ref("SingleIdentifierGrammar"), # Column name
Ref.keyword("IN", optional=True),
Ref("DatatypeSegment"), # Column type
),
optional=True,
),
),
"RETURN",
Ref("DatatypeSegment"),
OneOf("IS", "AS", optional=True),
AnyNumberOf(
Sequence(
Ref("VariableNameSegment"),
Ref("DatatypeSegment"),
Ref("SemicolonSegment"),
),
optional=True,
),
"BEGIN",
AnyNumberOf(Ref("FunctionBodySegment")),
"RETURN",
Ref("FunctionContentsExpressionGrammar"),
Ref("SemicolonSegment"),
"END",
Ref("FunctionReferenceSegment", optional=True),
Ref("SemicolonSegment", optional=True),
)
class WhileStatementSegment(BaseSegment):
"""A `WHILE-DO-END WHILE` statement.
https://dev.mysql.com/doc/refman/8.0/en/while.html
"""
type = "while_statement"
match_grammar = OneOf(
Sequence(
Sequence(
Ref("SingleIdentifierGrammar"), Ref("ColonSegment"), optional=True
),
Sequence(
"WHILE",
Ref("ExpressionSegment"),
"DO",
AnyNumberOf(
Ref("StatementSegment"),
),
),
),
Sequence(
"END",
"WHILE",
Ref("SingleIdentifierGrammar", optional=True),
),
)
class RepeatStatementSegment(BaseSegment):
"""A `REPEAT-UNTIL` statement.
https://dev.mysql.com/doc/refman/8.0/en/repeat.html
"""
type = "repeat_statement"
match_grammar = OneOf(
Sequence(
Sequence(
Ref("SingleIdentifierGrammar"), Ref("ColonSegment"), optional=True
),
"REPEAT",
AnyNumberOf(
Ref("StatementSegment"),
),
),
Sequence(
"UNTIL",
Ref("ExpressionSegment"),
Sequence(
"END",
"REPEAT",
Ref("SingleIdentifierGrammar", optional=True),
),
),
)
class SemiStructuredAccessorSegment(BaseSegment):
"""A semi-structured data accessor segment.
https://docs.snowflake.com/en/user-guide/semistructured-considerations.html
"""
type = "snowflake_semi_structured_expression"
match_grammar = Sequence(
Ref("ColonSegment"),
OneOf(
Ref("NakedSemiStructuredElementSegment"),
Ref("QuotedSemiStructuredElementSegment"),
),
Ref("ArrayAccessorSegment", optional=True),
AnyNumberOf(
Sequence(
OneOf(
# Can be delimited by dots or colons
Ref("DotSegment"),
Ref("ColonSegment"),
),
OneOf(
Ref("NakedSemiStructuredElementSegment"),
Ref("QuotedSemiStructuredElementSegment"),
),
Ref("ArrayAccessorSegment", optional=True),
allow_gaps=True,
),
allow_gaps=True,
),
allow_gaps=True,
)
class FunctionDefinitionGrammar(BaseSegment):
"""This is the body of a `CREATE FUNCTION AS` statement."""
match_grammar = Sequence(
AnyNumberOf(
Sequence(
"LANGUAGE",
# Not really a parameter, but best fit for now.
Ref("ParameterNameSegment"),
Sequence(
"OPTIONS",
Bracketed(
Delimited(
Sequence(
Ref("ParameterNameSegment"),
Ref("EqualsSegment"),
Anything(),
),
delimiter=Ref("CommaSegment"),
)),
optional=True,
),
),
# There is some syntax not implemented here,
Sequence(
"AS",
OneOf(
Ref("DoubleQuotedLiteralSegment"),
Ref("QuotedLiteralSegment"),
Bracketed(
OneOf(Ref("ExpressionSegment"),
Ref("SelectStatementSegment"))),
),
),
))
class ColumnReferenceSegment(ObjectReferenceSegment): # type: ignore
"""A reference to column, field or alias.
Adjusted to support column references for Redshift's SUPER data type
(https://docs.aws.amazon.com/redshift/latest/dg/super-overview.html), which
uses a subset of the PartiQL language (https://partiql.org/) to reference
columns.
"""
type = "column_reference"
match_grammar: Matchable = Delimited(
Sequence(
Ref("SingleIdentifierGrammar"),
AnyNumberOf(Ref("ArrayAccessorSegment")),
),
delimiter=OneOf(Ref("DotSegment"),
Sequence(Ref("DotSegment"), Ref("DotSegment"))),
terminator=OneOf(
"ON",
"AS",
"USING",
Ref("CommaSegment"),
Ref("CastOperatorSegment"),
Ref("BinaryOperatorGrammar"),
Ref("ColonSegment"),
Ref("DelimiterSegment"),
Ref("JoinLikeClauseGrammar"),
),
allow_gaps=False,
)
class TypelessStructSegment(BaseSegment):
"""Expression to construct a STRUCT with implicit types.
https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#typeless_struct_syntax
"""
type = "typeless_struct"
match_grammar = Sequence(
"STRUCT",
Bracketed(
Delimited(
AnyNumberOf(
Sequence(
OneOf(
Ref("LiteralGrammar"),
Ref("FunctionSegment"),
Ref("IntervalExpressionSegment"),
Ref("ObjectReferenceSegment"),
Ref("ExpressionSegment"),
),
Ref("AliasExpressionSegment", optional=True),
), ),
delimiter=Ref("CommaSegment"),
),
optional=True,
),
)
class CallStoredProcedureSegment(BaseSegment):
"""This is a CALL statement used to execute a stored procedure.
https://dev.mysql.com/doc/refman/8.0/en/call.html
"""
type = "call_segment"
match_grammar = Sequence(
"CALL",
OneOf(
Ref("SingleIdentifierGrammar"),
Ref("QuotedIdentifierSegment"),
),
Bracketed(
AnyNumberOf(
Delimited(
Ref("QuotedLiteralSegment"),
Ref("NumericLiteralSegment"),
Ref("DoubleQuotedLiteralSegment"),
Ref("SessionVariableNameSegment"),
Ref("LocalVariableNameSegment"),
Ref("FunctionSegment"),
),
),
),
)
class TdCreateTableOptions(BaseSegment):
"""CreateTableOptions.
, NO FALLBACK, NO BEFORE JOURNAL, NO AFTER JOURNAL, CHECKSUM = DEFAULT
, DEFAULT MERGEBLOCKRATIO
"""
type = "create_table_options_statement"
match_grammar = AnyNumberOf(
Sequence(
Ref("CommaSegment"),
OneOf(
# [ NO ] FALLBACK [ PROTECTION ]
Sequence(
Ref.keyword("NO", optional=True),
"FALLBACK",
Ref.keyword("PROTECTION", optional=True),
),
# [NO | DUAL | LOCAL |NOT LOCAL] [AFTER | BEFORE] JOURNAL
Sequence(
OneOf("NO",
"DUAL",
"LOCAL",
Sequence("NOT", "LOCAL"),
optional=True),
OneOf("BEFORE", "AFTER", optional=True),
"JOURNAL",
),
# CHECKSUM = (ON|OFF|DEFAULT)
Sequence(
"CHECKSUM",
Ref("EqualsSegment"),
OneOf(
"ON",
"OFF",
"DEFAULT",
),
),
# (NO|Default) MergeBlockRatio
Sequence(
OneOf(
"DEFAULT",
"NO",
),
"MERGEBLOCKRATIO",
),
# MergeBlockRatio = integer [PERCENT]
Sequence(
"MERGEBLOCKRATIO",
Ref("EqualsSegment"),
Ref("NumericLiteralSegment"),
Ref.keyword("PERCENT", optional=True),
),
),
), )
class FunctionSegment(BaseSegment):
"""A scalar or aggregate function.
Maybe in the future we should distinguish between
aggregate functions and other functions. For now
we treat them the same because they look the same
for our purposes.
"""
type = "function"
match_grammar = Sequence(
Sequence(
Ref("FunctionNameSegment"),
Bracketed(
Ref(
"FunctionContentsGrammar",
# The brackets might be empty for some functions...
optional=True,
ephemeral_name="FunctionContentsGrammar",
)),
# Functions returning ARRYS in BigQuery can have optional
# OFFSET or ORDINAL clauses
Sequence(
Bracketed(
OneOf(
"OFFSET",
"ORDINAL",
),
Bracketed(Ref("NumericLiteralSegment"), ),
bracket_type="square",
),
optional=True,
),
# Functions returning STRUCTs in BigQuery can have the fields
# elements referenced (e.g. ".a"), including wildcards (e.g. ".*")
# or multiple nested fields (e.g. ".a.b", or ".a.b.c")
Sequence(
Ref("DotSegment"),
AnyNumberOf(
Sequence(
Ref("ParameterNameSegment"),
Ref("DotSegment"),
), ),
OneOf(
Ref("ParameterNameSegment"),
Ref("StarSegment"),
),
optional=True,
),
),
Ref("PostFunctionGrammar", optional=True),
)
class CreateTableStatementSegment(BaseSegment):
"""A `CREATE TABLE` statement.
As specified in
https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_NEW.html
"""
type = "create_table_statement"
match_grammar = Sequence(
"CREATE",
Ref.keyword("LOCAL", optional=True),
Ref("TemporaryGrammar", optional=True),
"TABLE",
Ref("IfNotExistsGrammar", optional=True),
Ref("TableReferenceSegment"),
Bracketed(
OneOf(
# Columns and comment syntax:
Delimited(
Sequence(
Ref("ColumnReferenceSegment"),
Ref("DatatypeSegment"),
AnyNumberOf(Ref("ColumnAttributeSegment"),
optional=True),
AnyNumberOf(Ref("ColumnConstraintSegment"),
optional=True),
),
Ref("TableConstraintSegment", optional=True),
),
Sequence(
"LIKE",
Ref("TableReferenceSegment"),
AnyNumberOf(Ref("LikeOptionSegment"), optional=True),
),
)),
Sequence("BACKUP", OneOf("YES", "NO", optional=True), optional=True),
AnyNumberOf(Ref("TableAttributeSegment"), optional=True),
)
class FileSegment(BaseFileSegment):
"""A segment representing a whole file or script.
This is also the default "root" segment of the dialect,
and so is usually instantiated directly. It therefore
has no match_grammar.
Override ANSI to allow addition of ExecuteFileSegment without
ending in DelimiterGrammar
"""
# NB: We don't need a match_grammar here because we're
# going straight into instantiating it directly usually.
parse_grammar = AnyNumberOf(
Ref("ExecuteFileSegment"),
Delimited(
Ref("StatementSegment"),
delimiter=AnyNumberOf(Ref("DelimiterGrammar"), min_times=1),
allow_gaps=True,
allow_trailing=True,
),
)
class FunctionWhileLoopSegment(BaseSegment):
"""The definition of a while loop within a function body."""
type = "function_while_loop"
match_grammar = Sequence(
"WHILE",
Ref("ExpressionSegment"),
"DO",
AnyNumberOf(Ref("FunctionBodySegment"), min_times=1),
"END",
"WHILE",
Ref("DelimiterSegment"),
)
class TdTableConstraints(BaseSegment):
"""Teradata specific table attributes.
e.g.
UNIQUE PRIMARY INDEX Column_name | ( Column_name, ... )
NO PRIMARY INDEX
...
"""
type = "td_table_constraint"
match_grammar = AnyNumberOf(
# PRIMARY Index
OneOf(
Sequence( # UNIQUE PRIMARY INDEX Column_name | ( Column_name, ... )
Ref.keyword("UNIQUE", optional=True),
"PRIMARY",
"INDEX",
Ref("ObjectReferenceSegment", optional=True), # primary index name
OneOf(
Bracketed(
Delimited(
Ref("SingleIdentifierGrammar"),
)
),
Ref("SingleIdentifierGrammar"),
),
),
Sequence("NO", "PRIMARY", "INDEX"), # NO PRIMARY INDEX
),
# PARTITION BY ...
Sequence( # INDEX HOPR_TRN_TRAV_SIN_MP_I ( IND_TIPO_TARJETA );
"PARTITION",
"BY",
Ref("TdTablePartitioningLevel"),
),
# Index
Sequence( # INDEX HOPR_TRN_TRAV_SIN_MP_I ( IND_TIPO_TARJETA );
Ref.keyword("UNIQUE", optional=True),
"INDEX",
Ref("ObjectReferenceSegment"), # Index name
Ref.keyword("ALL", optional=True),
Bracketed( # Columns making up constraint
Delimited(Ref("ColumnReferenceSegment")),
),
),
# WITH DATA
Sequence("WITH", Sequence("NO", optional=True), "DATA"),
# ON COMMIT PRESERVE ROWS
Sequence("ON", "COMMIT", OneOf("PRESERVE", "DELETE"), "ROWS"),
)
class ColumnDefinitionSegment(BaseSegment):
"""A column definition, e.g. for CREATE TABLE or ALTER TABLE."""
type = "column_definition"
match_grammar = Sequence(
Ref("ColumnReferenceSegment"), # Column name
Ref("DatatypeSegment"), # Column type
Bracketed(Anything(), optional=True), # For types like VARCHAR(100)
AnyNumberOf(
Ref("ColumnOptionSegment", optional=True),
# Adding Teradata specific column definitions
Ref("TdColumnOptionSegment", optional=True),
),
)
class ProcedureParameterListSegment(BaseSegment):
"""The parameters for a procedure.
https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_PROCEDURE.html
"""
type = "procedure_parameter_list"
# Odd syntax, but prevents eager parameters being confused for data types
_param_type = OneOf("REFCURSOR", Ref("DatatypeSegment"))
match_grammar = Bracketed(
Sequence(
AnyNumberOf(
OneOf(
Ref("ParameterNameSegment"),
exclude=OneOf(_param_type, Ref("ArgModeGrammar")),
optional=True,
),
Ref("ArgModeGrammar", optional=True),
max_times_per_element=1,
),
_param_type,
AnyNumberOf(
Sequence(
Ref("CommaSegment"),
AnyNumberOf(
OneOf(
Ref("ParameterNameSegment"),
exclude=OneOf(_param_type, Ref("ArgModeGrammar")),
optional=True,
),
Ref("ArgModeGrammar", optional=True),
max_times_per_element=1,
),
_param_type,
), ),
optional=True,
), )
class CreateTableStatementSegment(
ansi_dialect.get_segment("CreateTableStatementSegment") # type: ignore
):
"""Create table segment.
https://dev.mysql.com/doc/refman/8.0/en/create-table.html
"""
match_grammar = ansi_dialect.get_segment(
"CreateTableStatementSegment").match_grammar.copy(insert=[
AnyNumberOf(
Sequence(
Ref.keyword("DEFAULT", optional=True),
Ref("ParameterNameSegment"),
Ref("EqualsSegment"),
OneOf(Ref("LiteralGrammar"), Ref("ParameterNameSegment")),
), ),
], )
class SetAssignmentStatementSegment(BaseSegment):
"""A `SET` statement.
mysql: https://dev.mysql.com/doc/refman/8.0/en/set-variable.html
"""
type = "set_statement"
match_grammar = Sequence(
"SET",
OneOf(Ref("SessionVariableNameSegment"), Ref("LocalVariableNameSegment")),
Ref("EqualsSegment"),
AnyNumberOf(
Ref("QuotedLiteralSegment"),
Ref("DoubleQuotedLiteralSegment"),
Ref("SessionVariableNameSegment"),
Ref("LocalVariableNameSegment"),
Ref("FunctionSegment"),
),
)
class ExecuteFileSegment(BaseSegment):
"""A reference to an indextype."""
type = "execute_file_statement"
match_grammar = Sequence(
OneOf(
Sequence(
Ref("AtSignSegment"),
Ref("AtSignSegment", optional=True),
),
"START",
),
# Probably should have a better file definition but this will do for now
AnyNumberOf(
Ref("SingleIdentifierGrammar"),
Ref("DotSegment"),
Ref("DivideSegment"),
),
)
class IfExpressionStatement(BaseSegment):
"""IF-THEN-ELSE-ELSEIF-END IF statement.
https://dev.mysql.com/doc/refman/8.0/en/if.html
"""
type = "if_then_statement"
match_grammar = AnyNumberOf(
Sequence(
"IF",
Ref("ExpressionSegment"),
"THEN",
Ref("StatementSegment"),
),
Sequence(
"ELSEIF",
Ref("ExpressionSegment"),
"THEN",
Ref("StatementSegment"),
),
Sequence("ELSE", Ref("StatementSegment"), optional=True),
)
class BteqStatementSegment(BaseSegment):
"""Bteq statements start with a dot, followed by a Keyword.
Non exhaustive and maybe catching too many statements?
# BTEQ commands
.if errorcode > 0 then .quit 2
.IF ACTIVITYCOUNT = 0 THEN .QUIT
"""
type = "bteq_statement"
match_grammar = Sequence(
Ref("DotSegment"),
Ref("BteqKeyWordSegment"),
AnyNumberOf(
Ref("BteqKeyWordSegment"),
# if ... then: the ...
Sequence(
Ref("ComparisonOperatorGrammar"), Ref("LiteralGrammar"), optional=True
),
optional=True,
),
)
class IntoClauseSegment(BaseSegment):
"""This is an `INTO` clause for assigning variables in a select statement.
https://dev.mysql.com/doc/refman/5.7/en/load-data.html
https://dev.mysql.com/doc/refman/5.7/en/select-into.html
"""
type = "into_clause"
match_grammar = Sequence(
"INTO",
OneOf(
Delimited(
AnyNumberOf(
Ref("SessionVariableNameSegment"),
Ref("LocalVariableNameSegment"),
),
Sequence("DUMPFILE", Ref("QuotedLiteralSegment")),
Sequence(
"OUTFILE",
Ref("QuotedLiteralSegment"),
Sequence(
"CHARACTER", "SET", Ref("NakedIdentifierSegment"), optional=True
),
Sequence(
OneOf("FIELDS", "COLUMNS"),
Sequence(
"TERMINATED",
"BY",
Ref("QuotedLiteralSegment"),
optional=True,
),
Sequence(
Ref.keyword("OPTIONALLY", optional=True),
"ENCLOSED",
"BY",
Ref("QuotedLiteralSegment"),
optional=True,
),
Sequence(
"ESCAPED", "BY", Ref("QuotedLiteralSegment"), optional=True
),
optional=True,
),
Sequence(
"LINES",
Sequence(
"STARTING", "BY", Ref("QuotedLiteralSegment"), optional=True
),
Sequence(
"TERMINATED",
"BY",
Ref("QuotedLiteralSegment"),
optional=True,
),
optional=True,
),
),
),
),
)
class FunctionSegment(BaseSegment):
"""A scalar or aggregate function.
Maybe in the future we should distinguish between
aggregate functions and other functions. For now
we treat them the same because they look the same
for our purposes.
"""
type = "function"
match_grammar = OneOf(
Sequence(
Sequence(
Ref("DateAddFunctionNameSegment"),
Bracketed(
Delimited(
Ref("DatePartClause"),
Ref(
"FunctionContentsGrammar",
# The brackets might be empty for some functions...
optional=True,
ephemeral_name="FunctionContentsGrammar",
),
)),
)),
Sequence(
Sequence(
Ref("ConvertFunctionNameSegment"),
Bracketed(
Delimited(
Ref("DatatypeSegment"),
Ref(
"FunctionContentsGrammar",
# The brackets might be empty for some functions...
optional=True,
ephemeral_name="FunctionContentsGrammar",
),
)),
)),
Sequence(
Sequence(
AnyNumberOf(
Ref("FunctionNameSegment"),
max_times=1,
min_times=1,
exclude=OneOf(
Ref("ConvertFunctionNameSegment"),
Ref("DateAddFunctionNameSegment"),
),
),
Bracketed(
Ref(
"FunctionContentsGrammar",
# The brackets might be empty for some functions...
optional=True,
ephemeral_name="FunctionContentsGrammar",
)),
),
Ref("PostFunctionGrammar", optional=True),
),
)
bracket_pairs_set="angle_bracket_pairs",
),
),
# BigQuery allows underscore in parameter names, and also anything if quoted in
# backticks
ParameterNameSegment=OneOf(
RegexParser(
r"[A-Z_][A-Z0-9_]*", CodeSegment, name="parameter", type="parameter"
),
RegexParser(r"`[^`]*`", CodeSegment, name="parameter", type="parameter"),
),
DateTimeLiteralGrammar=Nothing(),
JoinLikeClauseGrammar=Sequence(
AnyNumberOf(
Ref("FromPivotExpressionSegment"),
Ref("FromUnpivotExpressionSegment"),
min_times=1,
),
Ref("TableAliasExpressionSegment", optional=True),
),
NaturalJoinKeywords=Nothing(),
)
# Set Keywords
bigquery_dialect.sets("unreserved_keywords").clear()
bigquery_dialect.sets("unreserved_keywords").update(
[n.strip().upper() for n in bigquery_unreserved_keywords.split("\n")]
)
bigquery_dialect.sets("reserved_keywords").clear()
type="semi_structured_element",
),
QuotedSemiStructuredElementSegment=NamedSegment.make(
"double_quote",
name="quoted_semi_structured_element",
type="semi_structured_element",
),
ColumnIndexIdentifierSegment=ReSegment.make(
r"\$[0-9]+", name="column_index_identifier_segment",
type="identifier"),
)
snowflake_dialect.replace(
Accessor_Grammar=AnyNumberOf(
Ref("ArrayAccessorSegment"),
# Add in semi structured expressions
Ref("SemiStructuredAccessorSegment"),
),
PreTableFunctionKeywordsGrammar=OneOf(Ref("LateralKeywordSegment")),
FunctionContentsExpressionGrammar=OneOf(
Ref("DatetimeUnitSegment"),
Ref("NamedParameterExpressionSegment"),
Ref("ExpressionSegment"),
),
JoinLikeClauseGrammar=Sequence(
OneOf(
Ref("FromAtExpressionSegment"),
Ref("FromBeforeExpressionSegment"),
Ref("FromPivotExpressionSegment"),
Ref("FromUnpivotExpressionSegment"),
),
CodeSegment,
name="quoted_semi_structured_element",
type="semi_structured_element",
),
ColumnIndexIdentifierSegment=RegexParser(
r"\$[0-9]+",
CodeSegment,
name="column_index_identifier_segment",
type="identifier",
),
)
snowflake_dialect.replace(
Accessor_Grammar=AnyNumberOf(
Ref("ArrayAccessorSegment"),
# Add in semi structured expressions
Ref("SemiStructuredAccessorSegment"),
),
PreTableFunctionKeywordsGrammar=OneOf(Ref("LateralKeywordSegment")),
FunctionContentsExpressionGrammar=OneOf(
Ref("DatetimeUnitSegment"),
Ref("NamedParameterExpressionSegment"),
Sequence(
Ref("ExpressionSegment"),
Sequence(OneOf("IGNORE", "RESPECT"), "NULLS", optional=True),
),
),
JoinLikeClauseGrammar=Sequence(
AnyNumberOf(
Ref("FromAtExpressionSegment"),
Ref("FromBeforeExpressionSegment"),
class DatatypeSegment(BaseSegment):
"""Data types."""
type = "data_type"
match_grammar = OneOf(
Ref("PrimitiveTypeSegment"),
Sequence(
"ARRAY",
Bracketed(
Ref("DatatypeSegment"),
bracket_pairs_set="angle_bracket_pairs",
bracket_type="angle",
),
),
Sequence(
"MAP",
Bracketed(
Sequence(
Ref("PrimitiveTypeSegment"),
Ref("CommaSegment"),
Ref("DatatypeSegment"),
),
bracket_pairs_set="angle_bracket_pairs",
bracket_type="angle",
),
),
Sequence(
"STRUCT",
Bracketed(
Delimited(
Sequence(
Ref("NakedIdentifierSegment"),
Ref("ColonSegment"),
Ref("DatatypeSegment"),
Ref("CommentGrammar", optional=True),
),
bracket_pairs_set="angle_bracket_pairs",
),
bracket_pairs_set="angle_bracket_pairs",
bracket_type="angle",
),
),
Sequence(
"UNIONTYPE",
Bracketed(
Delimited(
Ref("DatatypeSegment"), bracket_pairs_set="angle_bracket_pairs"
),
bracket_pairs_set="angle_bracket_pairs",
bracket_type="angle",
),
),
# array types
OneOf(
AnyNumberOf(
Bracketed(
Ref("ExpressionSegment", optional=True), bracket_type="square"
)
),
Ref("SimpleArrayTypeGrammar"),
Sequence(Ref("SimpleArrayTypeGrammar"), Ref("ArrayLiteralSegment")),
optional=True,
),
)