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, ), )