diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 1d06732..dc952b1 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -34,7 +34,7 @@ jobs: id: set-matrix run: | # List of all available parsers - ALL_PARSERS="redshift postgresql cql snowflake tsql doris trino plsql googlesql mysql partiql tidb" + ALL_PARSERS="redshift postgresql cql snowflake tsql doris trino plsql googlesql mysql partiql tidb bq" # Add more parsers here as they are added to the repository # ALL_PARSERS="redshift mysql postgresql" diff --git a/bq/BigQueryLexer.g4 b/bq/BigQueryLexer.g4 new file mode 100644 index 0000000..823ff0b --- /dev/null +++ b/bq/BigQueryLexer.g4 @@ -0,0 +1,192 @@ +lexer grammar BigQueryLexer; + +// ARRAY and STRUCT included in the list of BQ keywords instead of here +QUOTE : '\'' ; +DQOUTE : '"'; +SEMI : ';'; + +/* + * BigQuery Keywords: + * Based off the list of BigQuery Reserved Keywords at: + * https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical + */ +ALL : A L L ; +AND : A N D ; +ANY : A N Y ; +ARRAY : A R R A Y ; +AS : A S ; +ASC : A S C ; +ASSERT_ROWS_MODIFIED : A S S E R T [_] R O W S [_] M O D I F I E D ; +AT : A T ; +BETWEEN : B E T W E E N ; +BY : B Y ; +CASE : C A S E ; +CAST : C A S T ; +COLLATE : C O L L A T E ; +CONTAINS : C O N T A I N S ; +CREATE : C R E A T E ; +CROSS : C R O S S ; +CUBE : C U B E ; +CURRENT : C U R R E N T ; +DEFAULT : D E F A U L T ; +DEFINE : D E F I N E ; +DESC : D E S C ; +DISTINCT : D I S T I N C T ; +ELSE : E L S E ; +END : E N D ; +ENUM : E N U M ; +ESCAPE : E S C A P E ; +EXCEPT : E X C E P T ; +EXCLUDE : E X C L U D E ; +EXISTS : E X I S T S ; +EXTRACT : E X T R A C T ; +FALSE : F A L S E ; +FETCH : F E T C H ; +FOLLOWING : F O L L O W I N G ; +FOR : F O R ; +FROM : F R O M ; +FULL : F U L L ; +GROUP : G R O U P ; +GROUPING : G R O U P I N G ; +GROUPS : G R O U P S ; +HASH : H A S H ; +HAVING : H A V I N G ; +IF : I F ; +IGNORE : I G N O R E ; +IN : I N ; +INNER : I N N E R ; +INTERSECT : I N T E R S E C T ; +INTERVAL : I N T E R V A L ; +INTO : I N T O ; +IS : I S ; +JOIN : J O I N ; +LATERAL : L A T E R A L ; +LEFT : L E F T ; +LIKE : L I K E ; +LIMIT : L I M I T ; +LOOKUP : L O O K U P ; +MERGE : M E R G E ; +NATURAL : N A T U R A L ; +NEW : N E W ; +NO : N O ; +NOT : N O T ; +S_NULL : N U L L ; +NULLS : N U L L S ; +OF : O F ; +OFFSET : O F F S E T; +ON : O N ; +OR : O R ; +ORDER : O R D E R ; +ORDINAL : O R D I N A L; +OUTER : O U T E R ; +OVER : O V E R ; +PARTITION : P A R T I T I O N ; +PRECEDING : P R E C E D I N G ; +PROTO : P R O T O ; +RANGE : R A N G E ; +RECURSIVE : R E C U R S I V E ; +REPLACE : R E P L A C E; +RESPECT : R E S P E C T ; +RIGHT : R I G H T ; +ROLLUP : R O L L U P ; +ROWS : R O W S ; +SAFE_OFFSET : S A F E '_' O F F S E T ; +SAFE_ORDINAL : S A F E '_' O R D I N A L ; +SELECT : S E L E C T ; +SET : S E T ; +SOME : S O M E ; +SSTRUCT : S T R U C T ; +SYSTEM : S Y S T E M ; +TABLESAMPLE : T A B L E S A M P L E ; +THEN : T H E N ; +TIME : T I M E ; +TO : T O ; +TREAT : T R E A T ; +TRUE : T R U E ; +UNBOUNDED : U N B O U N D E D ; +UNION : U N I O N ; +UNNEST : U N N E S T ; +USING : U S I N G ; +WHEN : W H E N ; +WHERE : W H E R E ; +WINDOW : W I N D O W ; +WITH : W I T H ; +WITHIN : W I T H I N ; + +INT : ('+' | '-')? ('0x')? DIGITS; +FLOAT : ('+' | '-')? DIGITS '.' DIGITS? ('e' ('+' | '-') DIGITS)? + | DIGITS? '.' DIGITS ('e' ('+' | '-') DIGITS)? + | DIGITS 'e' ('+' | '-')? DIGITS; +DIGITS : DIGIT+ ; + +// Whitespace +WS : [ \t\r\n]+ -> channel(HIDDEN) ; +// Comments +CMT : '--' ~[\r\n]* -> channel(HIDDEN) ; +M_CMT : '/*' .*? '*/' -> channel(HIDDEN) ; +// Quoted String +QUOTED_STRING : '"' (~'"' | '\\' '"')* '"' + | '\'' (~'\'' | '\\' '\'' )* '\'' ; +TRIPLE_QUOTED_STRING : QUOTE QUOTE QUOTE .*? ~'\\' QUOTE QUOTE QUOTE + | DQOUTE DQOUTE DQOUTE .*? ~'\\' DQOUTE DQOUTE DQOUTE ; +RAW_STRING : R (QUOTED_STRING | TRIPLE_QUOTED_STRING) ; +BYTE_STRING : B (QUOTED_STRING | TRIPLE_QUOTED_STRING) ; +RAW_BYTE_STRING : RB (QUOTED_STRING | TRIPLE_QUOTED_STRING) ; +// ID regex +QUOTED_ID : BACKTICK (('\\'? .))+ BACKTICK ; +ID : [a-zA-Z_][A-Za-z_0-9]* ; +RB : [rR][bB] | [bB][rR] ; + +DOT: '.'; +BACKTICK: '`'; +LR_BRACKET: '('; +RR_BRACKET: ')'; +LSB: '['; +RSB: ']'; +EQ: '='; +LT: '<'; +GT: '>'; +DOUBLE_LT: '<<'; +DOUBLE_GT: '>>'; +LE: '<='; +GE: '>='; +NE: '!='; +LTGT: '<>'; +BIT_AND: '&'; +BIT_OR: '|'; +STAR: '*'; +DIVIDE: '/'; +PLUS: '+'; +MINUS: '-'; +COMMA: ','; +TILDE: '~'; +CARET: '^'; + +fragment DIGIT : [0-9] ; +// Fragments for each letter of the alphabet. This is necessary because SQL keywords are case-insensitive. +fragment A : [aA]; +fragment B : [bB]; +fragment C : [cC]; +fragment D : [dD]; +fragment E : [eE]; +fragment F : [fF]; +fragment G : [gG]; +fragment H : [hH]; +fragment I : [iI]; +fragment J : [jJ]; +fragment K : [kK]; +fragment L : [lL]; +fragment M : [mM]; +fragment N : [nN]; +fragment O : [oO]; +fragment P : [pP]; +fragment Q : [qQ]; +fragment R : [rR]; +fragment S : [sS]; +fragment T : [tT]; +fragment U : [uU]; +fragment V : [vV]; +fragment W : [wW]; +fragment X : [xX]; +fragment Y : [yY]; +fragment Z : [zZ]; \ No newline at end of file diff --git a/bq/BigQueryParser.g4 b/bq/BigQueryParser.g4 new file mode 100644 index 0000000..4220568 --- /dev/null +++ b/bq/BigQueryParser.g4 @@ -0,0 +1,342 @@ +/* +* WIP BigQuery grammar for ANTLR v4 +* This grammar is designed to parse BigQuery SQL statements, and is based off of the BigQuery SQL syntax specified at: +* https://cloud.google.com/bigquery/docs/reference/standard-sql/query-syntax + */ + +parser grammar BigQueryParser; + +options { tokenVocab=BigQueryLexer; } + +root + : stmtmulti EOF + ; + +stmtmulti + : (stmt SEMI?)* + ; + +stmt + : query_statement; + +// Root statement for a SELECT query +query_statement : with_statement? query_expr; + +// A Query Expression can contain a Select Statement, a parenthized Query Expression, or a set operation of two or more +// Query Expressions +query_expr : select_statement order_clause? limit_clause? + | LR_BRACKET query_expr RR_BRACKET order_clause? limit_clause? + | query_expr set_op query_expr order_clause? limit_clause? + ; + +// A Select Statement can select from table columns w/wo aliases, wildcard expressions, or any other 'expr' (Like a function call) +select_statement : SELECT (ALL | DISTINCT)? + ( ( expr? DOT? STAR (except_statement)? (replace_statement)? ) | expr (AS? alias_name)? ) ( COMMA ( ( expr? STAR (except_statement)? (replace_statement)? ) | expr (AS? alias_name)? ) )* + from_statement? + where_statement? + group_statement? + having_statement? + window_statement?; + +// From Statement can have one or more 'from_item's, separated by a comma +from_statement : FROM from_item (COMMA from_item )* ; + +// From Item - WIP +// From Items can be table expressions (project.dataset.table, Query Statements (subqueries), or a valid array expression). +// Array expressions are still WIP +from_item : table_expr (AS? alias_name)? (FOR SYSTEM TIME AS OF string)? + | from_item join_type? JOIN from_item (on_clause | using_clause) + | LR_BRACKET query_statement RR_BRACKET (AS? alias_name)? + | field_path + | UNNEST LR_BRACKET array_expr RR_BRACKET (AS? alias_name)? (WITH OFFSET (AS? alias_name))? + | UNNEST LR_BRACKET array_path RR_BRACKET (AS? alias_name)? (WITH OFFSET (AS? alias_name))? + | array_path (AS? alias_name)? (WITH OFFSET (AS? alias_name))? + //| with_query_name (AS? alias_name)? + ; + +// Where Statement can contain any boolean expression +where_statement : WHERE bool_expression; + +// Group Statement can contain one or more expressions, separated by commas +group_statement : GROUP BY ( (expr (COMMA expr)* ) | ROLLUP LR_BRACKET expr (COMMA expr)* RR_BRACKET ); + +// Having statement can contain a boolean expression (TODO: Can HAVING statement contain comma separated boolean expressions?) +having_statement : HAVING bool_expression; + +// Window statement is not complete +window_statement : WINDOW window_name AS LR_BRACKET window_definition RR_BRACKET; + +// Order Statement can contain any number of comma separated expressions to order by. +order_clause : ORDER BY expr (ASC | DESC)? (COMMA expr (ASC | DESC)?)* ; + +// Limit Statement can contain a limit number and an optional offset +limit_clause : LIMIT count (OFFSET skip_rows)? ; + +// Unary Operators +unary_operator : MINUS | TILDE | NOT; + +// Main expression rule can expand to any valid BigQuery expression. Still WIP +expr : number + | string + | array_name LSB (OFFSET | ORDINAL | SAFE_OFFSET | SAFE_ORDINAL ) LR_BRACKET expr RR_BRACKET RSB + | unary_operator expr + | expr (STAR | DIVIDE) expr + | expr (PLUS | MINUS) expr + | expr (DOUBLE_LT | DOUBLE_GT) expr + | expr BIT_AND expr + | expr CARET expr + | expr BIT_OR expr + | expr ( EQ + | LT + | GT + | LE + | GE + | NE + | LTGT + | NOT? LIKE + | NOT? BETWEEN expr AND expr + ) expr + | expr IS NOT? S_NULL + | IS NOT? TRUE + | IS NOT? FALSE + // TODO: Separate this out into separate STRUCT and ARRAY rules. + | expr NOT? IN ( + ( LR_BRACKET expr (COMMA expr)* RR_BRACKET) + | query_statement + | UNNEST LR_BRACKET array_expr RR_BRACKET + ) + | expr AND expr + | expr OR expr + | function_name LR_BRACKET ((expr (COMMA expr)*) | STAR) RR_BRACKET + | cast_expr + | LR_BRACKET expr RR_BRACKET + | LSB expr (COMMA expr)* RSB + | column_expr + | keyword + ; + +// Cast Expression can cast any expression to one of the datatype_name options +cast_expr : CAST LR_BRACKET expr AS datatype_name RR_BRACKET ; + +// column_expr : BACKTICK column_expr BACKTICK +// | (((project_name DOT)? dataset_name DOT)? table_name DOT)? column_name +// ; + +column_expr + : name dot_name* + ; + +// Except Statement can exclude any number of comma separated column names. +except_statement : EXCEPT LR_BRACKET column_name (COMMA column_name)* RR_BRACKET; + +// Replace Statement can replace any number of optionally aliased, comma separated expressions. +replace_statement : REPLACE LR_BRACKET expr (AS? alias_name)? (COMMA expr (AS? alias_name) )* RR_BRACKET ; + +// Join Type rule can expand to be any type of JOIN keyword. +join_type : INNER + | CROSS + | FULL OUTER? + | LEFT OUTER? + | RIGHT OUTER? + ; + +// On Clause can contain a single boolean expression +on_clause : ON bool_expression; + +// Set Operation expands to the keywords for each type of set operation +set_op : UNION (ALL | DISTINCT)? + | INTERSECT DISTINCT + | EXCEPT DISTINCT; + +// Using Clause expands to a comma separated list of names +using_clause : USING LR_BRACKET join_name (COMMA join_name)* RR_BRACKET; + +// Field path is WIP +field_path : ; +// Struct can be the struct keyword followed by a datatype name. TODO: Need to expand this to support multiple comma separated datatypes +sstruct : SSTRUCT LT datatype_name GT ; +// Array can be the Array keyword followed by a datatype name. +array_expr : ARRAY LT datatype_name GT ; + +// Array path is WIP +array_path : ; + +// Boolean expression can be any expression. (May change this later, but for now it works because we assume all queries are valid) +bool_expression : expr; + +// Window name is WIP +window_name : ; + +// Window Definition is WIP +window_definition : ; + +// Count can be any number +count : number; +// Skip rows can be any number +skip_rows : number; +//with_query_name : ; +// WITH statement (CTE statement) +with_statement : WITH cte_name AS LR_BRACKET query_expr RR_BRACKET (COMMA cte_name AS LR_BRACKET query_expr RR_BRACKET )* ; + +// Name can be any ID or string, with optional quotes and parens +// name : ID | '"' name '"' | LR_BRACKET name RR_BRACKET | BACKTICK name BACKTICK | '\'' name '\'' ; +name + : ID + | QUOTED_ID + ; + +dot_name + : DOT (name | keyword) + ; + +// Name rules + +// Each specific type of name just expands to the parent name rule. This lets us assign handlers +// to only a specific type of name. (i.e. we care about cte_names and column_names, but not about datatype_names) +alias_name : name; +array_name : name; +column_name : name; +cte_name : name; +dataset_name : name; +datatype_name : name; +function_name : name; +join_name : name; +member_name : name; +project_name : name; +struct_name : name; +table_name : name; +table_expr : (((project_name DOT)? dataset_name DOT)? table_name) + | BACKTICK table_expr BACKTICK; + +// NUMBER LITERALS +number : integer_type | float_type ; +integer_type : INT; +float_type : FLOAT; + +// STRING LITERAL +string : quoted_string + | triple_quoted_string + | raw_string + | byte_string + | raw_byte_string + | special_string + ; + + +// Quoted strings can be in single or double quotes. They can contain escaped quotes of the type +// enclosing the string, or non escaped versions of the other type of quote. (A single quoted string can contain +// unescaped double quotes or escaped single quotes, etc) +quoted_string : QUOTED_STRING; +triple_quoted_string : TRIPLE_QUOTED_STRING; +raw_string : RAW_STRING ; +byte_string : BYTE_STRING ; +raw_byte_string : RAW_BYTE_STRING ; +// Special strings are strings with DATE, DATETIME, TIME, or TIMESTAMP preceding the string. +// These keywords are not reserved keywords, which means that they can be used as identifiers without +// backticks. +special_string : datatype_name QUOTED_STRING; + + +keyword : ALL + | AND + | ANY + | ARRAY + | AS + | ASC + | ASSERT_ROWS_MODIFIED + | AT + | BETWEEN + | BY + | CASE + | CAST + | COLLATE + | CONTAINS + | CREATE + | CROSS + | CUBE + | CURRENT + | DEFAULT + | DEFINE + | DESC + | DISTINCT + | ELSE + | END + | ENUM + | ESCAPE + | EXCEPT + | EXCLUDE + | EXISTS + | EXTRACT + | FALSE + | FETCH + | FOLLOWING + | FOR + | FROM + | FULL + | GROUP + | GROUPING + | GROUPS + | HASH + | HAVING + | IF + | IGNORE + | IN + | INNER + | INTERSECT + | INTERVAL + | INTO + | IS + | JOIN + | LATERAL + | LEFT + | LIKE + | LIMIT + | LOOKUP + | MERGE + | NATURAL + | NEW + | NO + | NOT + | S_NULL + | NULLS + | OF + | OFFSET + | ON + | OR + | ORDER + | ORDINAL + | OUTER + | OVER + | PARTITION + | PRECEDING + | PROTO + | RANGE + | RECURSIVE + | REPLACE + | RESPECT + | RIGHT + | ROLLUP + | ROWS + | SAFE_OFFSET + | SAFE_ORDINAL + | SELECT + | SET + | SOME + | SSTRUCT + | SYSTEM + | TABLESAMPLE + | THEN + | TIME + | TO + | TREAT + | TRUE + | UNBOUNDED + | UNION + | UNNEST + | USING + | WHEN + | WHERE + | WINDOW + | WITH + | WITHIN + ; diff --git a/bq/Makefile b/bq/Makefile new file mode 100644 index 0000000..4b0357b --- /dev/null +++ b/bq/Makefile @@ -0,0 +1,7 @@ +all: build test + +build: + antlr -Dlanguage=Go -package bq -visitor -o . BigQueryLexer.g4 BigQueryParser.g4 + +test: + go test -v -run TestBQParser diff --git a/bq/README.md b/bq/README.md new file mode 100644 index 0000000..cdc80cb --- /dev/null +++ b/bq/README.md @@ -0,0 +1 @@ +# bq-parser \ No newline at end of file diff --git a/bq/bigquery_lexer.go b/bq/bigquery_lexer.go new file mode 100644 index 0000000..cf8edf2 --- /dev/null +++ b/bq/bigquery_lexer.go @@ -0,0 +1,871 @@ +// Code generated from BigQueryLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package bq + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type BigQueryLexer struct { + *antlr.BaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var BigQueryLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func bigquerylexerLexerInit() { + staticData := &BigQueryLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "'''", "'\"'", "';'", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "'.'", "'`'", "'('", "')'", "'['", "']'", "'='", "'<'", + "'>'", "'<<'", "'>>'", "'<='", "'>='", "'!='", "'<>'", "'&'", "'|'", + "'*'", "'/'", "'+'", "'-'", "','", "'~'", "'^'", + } + staticData.SymbolicNames = []string{ + "", "QUOTE", "DQOUTE", "SEMI", "ALL", "AND", "ANY", "ARRAY", "AS", "ASC", + "ASSERT_ROWS_MODIFIED", "AT", "BETWEEN", "BY", "CASE", "CAST", "COLLATE", + "CONTAINS", "CREATE", "CROSS", "CUBE", "CURRENT", "DEFAULT", "DEFINE", + "DESC", "DISTINCT", "ELSE", "END", "ENUM", "ESCAPE", "EXCEPT", "EXCLUDE", + "EXISTS", "EXTRACT", "FALSE", "FETCH", "FOLLOWING", "FOR", "FROM", "FULL", + "GROUP", "GROUPING", "GROUPS", "HASH", "HAVING", "IF", "IGNORE", "IN", + "INNER", "INTERSECT", "INTERVAL", "INTO", "IS", "JOIN", "LATERAL", "LEFT", + "LIKE", "LIMIT", "LOOKUP", "MERGE", "NATURAL", "NEW", "NO", "NOT", "S_NULL", + "NULLS", "OF", "OFFSET", "ON", "OR", "ORDER", "ORDINAL", "OUTER", "OVER", + "PARTITION", "PRECEDING", "PROTO", "RANGE", "RECURSIVE", "REPLACE", + "RESPECT", "RIGHT", "ROLLUP", "ROWS", "SAFE_OFFSET", "SAFE_ORDINAL", + "SELECT", "SET", "SOME", "SSTRUCT", "SYSTEM", "TABLESAMPLE", "THEN", + "TIME", "TO", "TREAT", "TRUE", "UNBOUNDED", "UNION", "UNNEST", "USING", + "WHEN", "WHERE", "WINDOW", "WITH", "WITHIN", "INT", "FLOAT", "DIGITS", + "WS", "CMT", "M_CMT", "QUOTED_STRING", "TRIPLE_QUOTED_STRING", "RAW_STRING", + "BYTE_STRING", "RAW_BYTE_STRING", "QUOTED_ID", "ID", "RB", "DOT", "BACKTICK", + "LR_BRACKET", "RR_BRACKET", "LSB", "RSB", "EQ", "LT", "GT", "DOUBLE_LT", + "DOUBLE_GT", "LE", "GE", "NE", "LTGT", "BIT_AND", "BIT_OR", "STAR", + "DIVIDE", "PLUS", "MINUS", "COMMA", "TILDE", "CARET", + } + staticData.RuleNames = []string{ + "QUOTE", "DQOUTE", "SEMI", "ALL", "AND", "ANY", "ARRAY", "AS", "ASC", + "ASSERT_ROWS_MODIFIED", "AT", "BETWEEN", "BY", "CASE", "CAST", "COLLATE", + "CONTAINS", "CREATE", "CROSS", "CUBE", "CURRENT", "DEFAULT", "DEFINE", + "DESC", "DISTINCT", "ELSE", "END", "ENUM", "ESCAPE", "EXCEPT", "EXCLUDE", + "EXISTS", "EXTRACT", "FALSE", "FETCH", "FOLLOWING", "FOR", "FROM", "FULL", + "GROUP", "GROUPING", "GROUPS", "HASH", "HAVING", "IF", "IGNORE", "IN", + "INNER", "INTERSECT", "INTERVAL", "INTO", "IS", "JOIN", "LATERAL", "LEFT", + "LIKE", "LIMIT", "LOOKUP", "MERGE", "NATURAL", "NEW", "NO", "NOT", "S_NULL", + "NULLS", "OF", "OFFSET", "ON", "OR", "ORDER", "ORDINAL", "OUTER", "OVER", + "PARTITION", "PRECEDING", "PROTO", "RANGE", "RECURSIVE", "REPLACE", + "RESPECT", "RIGHT", "ROLLUP", "ROWS", "SAFE_OFFSET", "SAFE_ORDINAL", + "SELECT", "SET", "SOME", "SSTRUCT", "SYSTEM", "TABLESAMPLE", "THEN", + "TIME", "TO", "TREAT", "TRUE", "UNBOUNDED", "UNION", "UNNEST", "USING", + "WHEN", "WHERE", "WINDOW", "WITH", "WITHIN", "INT", "FLOAT", "DIGITS", + "WS", "CMT", "M_CMT", "QUOTED_STRING", "TRIPLE_QUOTED_STRING", "RAW_STRING", + "BYTE_STRING", "RAW_BYTE_STRING", "QUOTED_ID", "ID", "RB", "DOT", "BACKTICK", + "LR_BRACKET", "RR_BRACKET", "LSB", "RSB", "EQ", "LT", "GT", "DOUBLE_LT", + "DOUBLE_GT", "LE", "GE", "NE", "LTGT", "BIT_AND", "BIT_OR", "STAR", + "DIVIDE", "PLUS", "MINUS", "COMMA", "TILDE", "CARET", "DIGIT", "A", + "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", + "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 143, 1272, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, + 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, + 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, + 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, + 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, + 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, + 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, + 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, + 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, + 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, + 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, + 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, + 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, + 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, + 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, + 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, + 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, + 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, + 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, + 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, + 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, + 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, + 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, + 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, + 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, + 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, + 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, + 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, + 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, + 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, + 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, + 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157, + 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162, + 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166, + 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 1, 0, 1, 0, 1, 1, 1, 1, + 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, + 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, + 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, + 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, + 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, + 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, + 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, + 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, + 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, + 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, + 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, + 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, + 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, + 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, + 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, + 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, + 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, + 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, + 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, + 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 47, + 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, + 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, + 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, + 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, + 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, + 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, + 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, + 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, + 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, + 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, + 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, + 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, + 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, + 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, + 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, + 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, + 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, + 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, + 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, + 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, + 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, + 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, + 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, + 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, + 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, + 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, + 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, + 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, + 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, + 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, + 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 3, 105, + 997, 8, 105, 1, 105, 1, 105, 3, 105, 1001, 8, 105, 1, 105, 1, 105, 1, 106, + 3, 106, 1006, 8, 106, 1, 106, 1, 106, 1, 106, 3, 106, 1011, 8, 106, 1, + 106, 1, 106, 1, 106, 3, 106, 1016, 8, 106, 1, 106, 3, 106, 1019, 8, 106, + 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 1026, 8, 106, 1, 106, 1, + 106, 1, 106, 3, 106, 1031, 8, 106, 1, 106, 1, 106, 3, 106, 1035, 8, 106, + 1, 107, 4, 107, 1038, 8, 107, 11, 107, 12, 107, 1039, 1, 108, 4, 108, 1043, + 8, 108, 11, 108, 12, 108, 1044, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, + 1, 109, 5, 109, 1053, 8, 109, 10, 109, 12, 109, 1056, 9, 109, 1, 109, 1, + 109, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 1064, 8, 110, 10, 110, 12, + 110, 1067, 9, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, + 1, 111, 1, 111, 5, 111, 1078, 8, 111, 10, 111, 12, 111, 1081, 9, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 1088, 8, 111, 10, 111, 12, + 111, 1091, 9, 111, 1, 111, 3, 111, 1094, 8, 111, 1, 112, 1, 112, 1, 112, + 1, 112, 5, 112, 1100, 8, 112, 10, 112, 12, 112, 1103, 9, 112, 1, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 5, 112, 1114, + 8, 112, 10, 112, 12, 112, 1117, 9, 112, 1, 112, 1, 112, 1, 112, 1, 112, + 1, 112, 3, 112, 1124, 8, 112, 1, 113, 1, 113, 1, 113, 3, 113, 1129, 8, + 113, 1, 114, 1, 114, 1, 114, 3, 114, 1134, 8, 114, 1, 115, 1, 115, 1, 115, + 3, 115, 1139, 8, 115, 1, 116, 1, 116, 3, 116, 1143, 8, 116, 1, 116, 4, + 116, 1146, 8, 116, 11, 116, 12, 116, 1147, 1, 116, 1, 116, 1, 117, 1, 117, + 5, 117, 1154, 8, 117, 10, 117, 12, 117, 1157, 9, 117, 1, 118, 1, 118, 1, + 118, 1, 118, 3, 118, 1163, 8, 118, 1, 119, 1, 119, 1, 120, 1, 120, 1, 121, + 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 1, 124, 1, 124, 1, 125, 1, 125, + 1, 126, 1, 126, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, + 1, 129, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, + 1, 132, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, + 1, 136, 1, 137, 1, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 140, 1, 140, + 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 1, 145, + 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 148, 1, 148, 1, 149, 1, 149, + 1, 150, 1, 150, 1, 151, 1, 151, 1, 152, 1, 152, 1, 153, 1, 153, 1, 154, + 1, 154, 1, 155, 1, 155, 1, 156, 1, 156, 1, 157, 1, 157, 1, 158, 1, 158, + 1, 159, 1, 159, 1, 160, 1, 160, 1, 161, 1, 161, 1, 162, 1, 162, 1, 163, + 1, 163, 1, 164, 1, 164, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, 1, 167, + 1, 168, 1, 168, 1, 169, 1, 169, 3, 1065, 1101, 1115, 0, 170, 1, 1, 3, 2, + 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, + 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, + 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, + 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, + 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, + 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, + 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, + 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, + 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, + 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, + 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, + 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, + 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, + 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, + 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, + 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, + 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, + 142, 285, 143, 287, 0, 289, 0, 291, 0, 293, 0, 295, 0, 297, 0, 299, 0, + 301, 0, 303, 0, 305, 0, 307, 0, 309, 0, 311, 0, 313, 0, 315, 0, 317, 0, + 319, 0, 321, 0, 323, 0, 325, 0, 327, 0, 329, 0, 331, 0, 333, 0, 335, 0, + 337, 0, 339, 0, 1, 0, 36, 1, 0, 95, 95, 2, 0, 43, 43, 45, 45, 3, 0, 9, + 10, 13, 13, 32, 32, 2, 0, 10, 10, 13, 13, 1, 0, 34, 34, 1, 0, 39, 39, 1, + 0, 92, 92, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, + 97, 122, 2, 0, 82, 82, 114, 114, 2, 0, 66, 66, 98, 98, 1, 0, 48, 57, 2, + 0, 65, 65, 97, 97, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, + 69, 69, 101, 101, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, + 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, + 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, + 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, + 81, 81, 113, 113, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, + 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, + 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 1273, + 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, + 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, + 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, + 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, + 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, + 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, + 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, + 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, + 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, + 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, + 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, + 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, + 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, + 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, + 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, + 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, + 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, + 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, + 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, + 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, + 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, + 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, + 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, + 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, + 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, + 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, + 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, + 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, + 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, + 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, + 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, + 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, + 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, + 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, + 0, 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, + 259, 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, + 0, 0, 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, + 1, 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, + 0, 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 1, 341, 1, + 0, 0, 0, 3, 343, 1, 0, 0, 0, 5, 345, 1, 0, 0, 0, 7, 347, 1, 0, 0, 0, 9, + 351, 1, 0, 0, 0, 11, 355, 1, 0, 0, 0, 13, 359, 1, 0, 0, 0, 15, 365, 1, + 0, 0, 0, 17, 368, 1, 0, 0, 0, 19, 372, 1, 0, 0, 0, 21, 393, 1, 0, 0, 0, + 23, 396, 1, 0, 0, 0, 25, 404, 1, 0, 0, 0, 27, 407, 1, 0, 0, 0, 29, 412, + 1, 0, 0, 0, 31, 417, 1, 0, 0, 0, 33, 425, 1, 0, 0, 0, 35, 434, 1, 0, 0, + 0, 37, 441, 1, 0, 0, 0, 39, 447, 1, 0, 0, 0, 41, 452, 1, 0, 0, 0, 43, 460, + 1, 0, 0, 0, 45, 468, 1, 0, 0, 0, 47, 475, 1, 0, 0, 0, 49, 480, 1, 0, 0, + 0, 51, 489, 1, 0, 0, 0, 53, 494, 1, 0, 0, 0, 55, 498, 1, 0, 0, 0, 57, 503, + 1, 0, 0, 0, 59, 510, 1, 0, 0, 0, 61, 517, 1, 0, 0, 0, 63, 525, 1, 0, 0, + 0, 65, 532, 1, 0, 0, 0, 67, 540, 1, 0, 0, 0, 69, 546, 1, 0, 0, 0, 71, 552, + 1, 0, 0, 0, 73, 562, 1, 0, 0, 0, 75, 566, 1, 0, 0, 0, 77, 571, 1, 0, 0, + 0, 79, 576, 1, 0, 0, 0, 81, 582, 1, 0, 0, 0, 83, 591, 1, 0, 0, 0, 85, 598, + 1, 0, 0, 0, 87, 603, 1, 0, 0, 0, 89, 610, 1, 0, 0, 0, 91, 613, 1, 0, 0, + 0, 93, 620, 1, 0, 0, 0, 95, 623, 1, 0, 0, 0, 97, 629, 1, 0, 0, 0, 99, 639, + 1, 0, 0, 0, 101, 648, 1, 0, 0, 0, 103, 653, 1, 0, 0, 0, 105, 656, 1, 0, + 0, 0, 107, 661, 1, 0, 0, 0, 109, 669, 1, 0, 0, 0, 111, 674, 1, 0, 0, 0, + 113, 679, 1, 0, 0, 0, 115, 685, 1, 0, 0, 0, 117, 692, 1, 0, 0, 0, 119, + 698, 1, 0, 0, 0, 121, 706, 1, 0, 0, 0, 123, 710, 1, 0, 0, 0, 125, 713, + 1, 0, 0, 0, 127, 717, 1, 0, 0, 0, 129, 722, 1, 0, 0, 0, 131, 728, 1, 0, + 0, 0, 133, 731, 1, 0, 0, 0, 135, 738, 1, 0, 0, 0, 137, 741, 1, 0, 0, 0, + 139, 744, 1, 0, 0, 0, 141, 750, 1, 0, 0, 0, 143, 758, 1, 0, 0, 0, 145, + 764, 1, 0, 0, 0, 147, 769, 1, 0, 0, 0, 149, 779, 1, 0, 0, 0, 151, 789, + 1, 0, 0, 0, 153, 795, 1, 0, 0, 0, 155, 801, 1, 0, 0, 0, 157, 811, 1, 0, + 0, 0, 159, 819, 1, 0, 0, 0, 161, 827, 1, 0, 0, 0, 163, 833, 1, 0, 0, 0, + 165, 840, 1, 0, 0, 0, 167, 845, 1, 0, 0, 0, 169, 857, 1, 0, 0, 0, 171, + 870, 1, 0, 0, 0, 173, 877, 1, 0, 0, 0, 175, 881, 1, 0, 0, 0, 177, 886, + 1, 0, 0, 0, 179, 893, 1, 0, 0, 0, 181, 900, 1, 0, 0, 0, 183, 912, 1, 0, + 0, 0, 185, 917, 1, 0, 0, 0, 187, 922, 1, 0, 0, 0, 189, 925, 1, 0, 0, 0, + 191, 931, 1, 0, 0, 0, 193, 936, 1, 0, 0, 0, 195, 946, 1, 0, 0, 0, 197, + 952, 1, 0, 0, 0, 199, 959, 1, 0, 0, 0, 201, 965, 1, 0, 0, 0, 203, 970, + 1, 0, 0, 0, 205, 976, 1, 0, 0, 0, 207, 983, 1, 0, 0, 0, 209, 988, 1, 0, + 0, 0, 211, 996, 1, 0, 0, 0, 213, 1034, 1, 0, 0, 0, 215, 1037, 1, 0, 0, + 0, 217, 1042, 1, 0, 0, 0, 219, 1048, 1, 0, 0, 0, 221, 1059, 1, 0, 0, 0, + 223, 1093, 1, 0, 0, 0, 225, 1123, 1, 0, 0, 0, 227, 1125, 1, 0, 0, 0, 229, + 1130, 1, 0, 0, 0, 231, 1135, 1, 0, 0, 0, 233, 1140, 1, 0, 0, 0, 235, 1151, + 1, 0, 0, 0, 237, 1162, 1, 0, 0, 0, 239, 1164, 1, 0, 0, 0, 241, 1166, 1, + 0, 0, 0, 243, 1168, 1, 0, 0, 0, 245, 1170, 1, 0, 0, 0, 247, 1172, 1, 0, + 0, 0, 249, 1174, 1, 0, 0, 0, 251, 1176, 1, 0, 0, 0, 253, 1178, 1, 0, 0, + 0, 255, 1180, 1, 0, 0, 0, 257, 1182, 1, 0, 0, 0, 259, 1185, 1, 0, 0, 0, + 261, 1188, 1, 0, 0, 0, 263, 1191, 1, 0, 0, 0, 265, 1194, 1, 0, 0, 0, 267, + 1197, 1, 0, 0, 0, 269, 1200, 1, 0, 0, 0, 271, 1202, 1, 0, 0, 0, 273, 1204, + 1, 0, 0, 0, 275, 1206, 1, 0, 0, 0, 277, 1208, 1, 0, 0, 0, 279, 1210, 1, + 0, 0, 0, 281, 1212, 1, 0, 0, 0, 283, 1214, 1, 0, 0, 0, 285, 1216, 1, 0, + 0, 0, 287, 1218, 1, 0, 0, 0, 289, 1220, 1, 0, 0, 0, 291, 1222, 1, 0, 0, + 0, 293, 1224, 1, 0, 0, 0, 295, 1226, 1, 0, 0, 0, 297, 1228, 1, 0, 0, 0, + 299, 1230, 1, 0, 0, 0, 301, 1232, 1, 0, 0, 0, 303, 1234, 1, 0, 0, 0, 305, + 1236, 1, 0, 0, 0, 307, 1238, 1, 0, 0, 0, 309, 1240, 1, 0, 0, 0, 311, 1242, + 1, 0, 0, 0, 313, 1244, 1, 0, 0, 0, 315, 1246, 1, 0, 0, 0, 317, 1248, 1, + 0, 0, 0, 319, 1250, 1, 0, 0, 0, 321, 1252, 1, 0, 0, 0, 323, 1254, 1, 0, + 0, 0, 325, 1256, 1, 0, 0, 0, 327, 1258, 1, 0, 0, 0, 329, 1260, 1, 0, 0, + 0, 331, 1262, 1, 0, 0, 0, 333, 1264, 1, 0, 0, 0, 335, 1266, 1, 0, 0, 0, + 337, 1268, 1, 0, 0, 0, 339, 1270, 1, 0, 0, 0, 341, 342, 5, 39, 0, 0, 342, + 2, 1, 0, 0, 0, 343, 344, 5, 34, 0, 0, 344, 4, 1, 0, 0, 0, 345, 346, 5, + 59, 0, 0, 346, 6, 1, 0, 0, 0, 347, 348, 3, 289, 144, 0, 348, 349, 3, 311, + 155, 0, 349, 350, 3, 311, 155, 0, 350, 8, 1, 0, 0, 0, 351, 352, 3, 289, + 144, 0, 352, 353, 3, 315, 157, 0, 353, 354, 3, 295, 147, 0, 354, 10, 1, + 0, 0, 0, 355, 356, 3, 289, 144, 0, 356, 357, 3, 315, 157, 0, 357, 358, + 3, 337, 168, 0, 358, 12, 1, 0, 0, 0, 359, 360, 3, 289, 144, 0, 360, 361, + 3, 323, 161, 0, 361, 362, 3, 323, 161, 0, 362, 363, 3, 289, 144, 0, 363, + 364, 3, 337, 168, 0, 364, 14, 1, 0, 0, 0, 365, 366, 3, 289, 144, 0, 366, + 367, 3, 325, 162, 0, 367, 16, 1, 0, 0, 0, 368, 369, 3, 289, 144, 0, 369, + 370, 3, 325, 162, 0, 370, 371, 3, 293, 146, 0, 371, 18, 1, 0, 0, 0, 372, + 373, 3, 289, 144, 0, 373, 374, 3, 325, 162, 0, 374, 375, 3, 325, 162, 0, + 375, 376, 3, 297, 148, 0, 376, 377, 3, 323, 161, 0, 377, 378, 3, 327, 163, + 0, 378, 379, 7, 0, 0, 0, 379, 380, 3, 323, 161, 0, 380, 381, 3, 317, 158, + 0, 381, 382, 3, 333, 166, 0, 382, 383, 3, 325, 162, 0, 383, 384, 7, 0, + 0, 0, 384, 385, 3, 313, 156, 0, 385, 386, 3, 317, 158, 0, 386, 387, 3, + 295, 147, 0, 387, 388, 3, 305, 152, 0, 388, 389, 3, 299, 149, 0, 389, 390, + 3, 305, 152, 0, 390, 391, 3, 297, 148, 0, 391, 392, 3, 295, 147, 0, 392, + 20, 1, 0, 0, 0, 393, 394, 3, 289, 144, 0, 394, 395, 3, 327, 163, 0, 395, + 22, 1, 0, 0, 0, 396, 397, 3, 291, 145, 0, 397, 398, 3, 297, 148, 0, 398, + 399, 3, 327, 163, 0, 399, 400, 3, 333, 166, 0, 400, 401, 3, 297, 148, 0, + 401, 402, 3, 297, 148, 0, 402, 403, 3, 315, 157, 0, 403, 24, 1, 0, 0, 0, + 404, 405, 3, 291, 145, 0, 405, 406, 3, 337, 168, 0, 406, 26, 1, 0, 0, 0, + 407, 408, 3, 293, 146, 0, 408, 409, 3, 289, 144, 0, 409, 410, 3, 325, 162, + 0, 410, 411, 3, 297, 148, 0, 411, 28, 1, 0, 0, 0, 412, 413, 3, 293, 146, + 0, 413, 414, 3, 289, 144, 0, 414, 415, 3, 325, 162, 0, 415, 416, 3, 327, + 163, 0, 416, 30, 1, 0, 0, 0, 417, 418, 3, 293, 146, 0, 418, 419, 3, 317, + 158, 0, 419, 420, 3, 311, 155, 0, 420, 421, 3, 311, 155, 0, 421, 422, 3, + 289, 144, 0, 422, 423, 3, 327, 163, 0, 423, 424, 3, 297, 148, 0, 424, 32, + 1, 0, 0, 0, 425, 426, 3, 293, 146, 0, 426, 427, 3, 317, 158, 0, 427, 428, + 3, 315, 157, 0, 428, 429, 3, 327, 163, 0, 429, 430, 3, 289, 144, 0, 430, + 431, 3, 305, 152, 0, 431, 432, 3, 315, 157, 0, 432, 433, 3, 325, 162, 0, + 433, 34, 1, 0, 0, 0, 434, 435, 3, 293, 146, 0, 435, 436, 3, 323, 161, 0, + 436, 437, 3, 297, 148, 0, 437, 438, 3, 289, 144, 0, 438, 439, 3, 327, 163, + 0, 439, 440, 3, 297, 148, 0, 440, 36, 1, 0, 0, 0, 441, 442, 3, 293, 146, + 0, 442, 443, 3, 323, 161, 0, 443, 444, 3, 317, 158, 0, 444, 445, 3, 325, + 162, 0, 445, 446, 3, 325, 162, 0, 446, 38, 1, 0, 0, 0, 447, 448, 3, 293, + 146, 0, 448, 449, 3, 329, 164, 0, 449, 450, 3, 291, 145, 0, 450, 451, 3, + 297, 148, 0, 451, 40, 1, 0, 0, 0, 452, 453, 3, 293, 146, 0, 453, 454, 3, + 329, 164, 0, 454, 455, 3, 323, 161, 0, 455, 456, 3, 323, 161, 0, 456, 457, + 3, 297, 148, 0, 457, 458, 3, 315, 157, 0, 458, 459, 3, 327, 163, 0, 459, + 42, 1, 0, 0, 0, 460, 461, 3, 295, 147, 0, 461, 462, 3, 297, 148, 0, 462, + 463, 3, 299, 149, 0, 463, 464, 3, 289, 144, 0, 464, 465, 3, 329, 164, 0, + 465, 466, 3, 311, 155, 0, 466, 467, 3, 327, 163, 0, 467, 44, 1, 0, 0, 0, + 468, 469, 3, 295, 147, 0, 469, 470, 3, 297, 148, 0, 470, 471, 3, 299, 149, + 0, 471, 472, 3, 305, 152, 0, 472, 473, 3, 315, 157, 0, 473, 474, 3, 297, + 148, 0, 474, 46, 1, 0, 0, 0, 475, 476, 3, 295, 147, 0, 476, 477, 3, 297, + 148, 0, 477, 478, 3, 325, 162, 0, 478, 479, 3, 293, 146, 0, 479, 48, 1, + 0, 0, 0, 480, 481, 3, 295, 147, 0, 481, 482, 3, 305, 152, 0, 482, 483, + 3, 325, 162, 0, 483, 484, 3, 327, 163, 0, 484, 485, 3, 305, 152, 0, 485, + 486, 3, 315, 157, 0, 486, 487, 3, 293, 146, 0, 487, 488, 3, 327, 163, 0, + 488, 50, 1, 0, 0, 0, 489, 490, 3, 297, 148, 0, 490, 491, 3, 311, 155, 0, + 491, 492, 3, 325, 162, 0, 492, 493, 3, 297, 148, 0, 493, 52, 1, 0, 0, 0, + 494, 495, 3, 297, 148, 0, 495, 496, 3, 315, 157, 0, 496, 497, 3, 295, 147, + 0, 497, 54, 1, 0, 0, 0, 498, 499, 3, 297, 148, 0, 499, 500, 3, 315, 157, + 0, 500, 501, 3, 329, 164, 0, 501, 502, 3, 313, 156, 0, 502, 56, 1, 0, 0, + 0, 503, 504, 3, 297, 148, 0, 504, 505, 3, 325, 162, 0, 505, 506, 3, 293, + 146, 0, 506, 507, 3, 289, 144, 0, 507, 508, 3, 319, 159, 0, 508, 509, 3, + 297, 148, 0, 509, 58, 1, 0, 0, 0, 510, 511, 3, 297, 148, 0, 511, 512, 3, + 335, 167, 0, 512, 513, 3, 293, 146, 0, 513, 514, 3, 297, 148, 0, 514, 515, + 3, 319, 159, 0, 515, 516, 3, 327, 163, 0, 516, 60, 1, 0, 0, 0, 517, 518, + 3, 297, 148, 0, 518, 519, 3, 335, 167, 0, 519, 520, 3, 293, 146, 0, 520, + 521, 3, 311, 155, 0, 521, 522, 3, 329, 164, 0, 522, 523, 3, 295, 147, 0, + 523, 524, 3, 297, 148, 0, 524, 62, 1, 0, 0, 0, 525, 526, 3, 297, 148, 0, + 526, 527, 3, 335, 167, 0, 527, 528, 3, 305, 152, 0, 528, 529, 3, 325, 162, + 0, 529, 530, 3, 327, 163, 0, 530, 531, 3, 325, 162, 0, 531, 64, 1, 0, 0, + 0, 532, 533, 3, 297, 148, 0, 533, 534, 3, 335, 167, 0, 534, 535, 3, 327, + 163, 0, 535, 536, 3, 323, 161, 0, 536, 537, 3, 289, 144, 0, 537, 538, 3, + 293, 146, 0, 538, 539, 3, 327, 163, 0, 539, 66, 1, 0, 0, 0, 540, 541, 3, + 299, 149, 0, 541, 542, 3, 289, 144, 0, 542, 543, 3, 311, 155, 0, 543, 544, + 3, 325, 162, 0, 544, 545, 3, 297, 148, 0, 545, 68, 1, 0, 0, 0, 546, 547, + 3, 299, 149, 0, 547, 548, 3, 297, 148, 0, 548, 549, 3, 327, 163, 0, 549, + 550, 3, 293, 146, 0, 550, 551, 3, 303, 151, 0, 551, 70, 1, 0, 0, 0, 552, + 553, 3, 299, 149, 0, 553, 554, 3, 317, 158, 0, 554, 555, 3, 311, 155, 0, + 555, 556, 3, 311, 155, 0, 556, 557, 3, 317, 158, 0, 557, 558, 3, 333, 166, + 0, 558, 559, 3, 305, 152, 0, 559, 560, 3, 315, 157, 0, 560, 561, 3, 301, + 150, 0, 561, 72, 1, 0, 0, 0, 562, 563, 3, 299, 149, 0, 563, 564, 3, 317, + 158, 0, 564, 565, 3, 323, 161, 0, 565, 74, 1, 0, 0, 0, 566, 567, 3, 299, + 149, 0, 567, 568, 3, 323, 161, 0, 568, 569, 3, 317, 158, 0, 569, 570, 3, + 313, 156, 0, 570, 76, 1, 0, 0, 0, 571, 572, 3, 299, 149, 0, 572, 573, 3, + 329, 164, 0, 573, 574, 3, 311, 155, 0, 574, 575, 3, 311, 155, 0, 575, 78, + 1, 0, 0, 0, 576, 577, 3, 301, 150, 0, 577, 578, 3, 323, 161, 0, 578, 579, + 3, 317, 158, 0, 579, 580, 3, 329, 164, 0, 580, 581, 3, 319, 159, 0, 581, + 80, 1, 0, 0, 0, 582, 583, 3, 301, 150, 0, 583, 584, 3, 323, 161, 0, 584, + 585, 3, 317, 158, 0, 585, 586, 3, 329, 164, 0, 586, 587, 3, 319, 159, 0, + 587, 588, 3, 305, 152, 0, 588, 589, 3, 315, 157, 0, 589, 590, 3, 301, 150, + 0, 590, 82, 1, 0, 0, 0, 591, 592, 3, 301, 150, 0, 592, 593, 3, 323, 161, + 0, 593, 594, 3, 317, 158, 0, 594, 595, 3, 329, 164, 0, 595, 596, 3, 319, + 159, 0, 596, 597, 3, 325, 162, 0, 597, 84, 1, 0, 0, 0, 598, 599, 3, 303, + 151, 0, 599, 600, 3, 289, 144, 0, 600, 601, 3, 325, 162, 0, 601, 602, 3, + 303, 151, 0, 602, 86, 1, 0, 0, 0, 603, 604, 3, 303, 151, 0, 604, 605, 3, + 289, 144, 0, 605, 606, 3, 331, 165, 0, 606, 607, 3, 305, 152, 0, 607, 608, + 3, 315, 157, 0, 608, 609, 3, 301, 150, 0, 609, 88, 1, 0, 0, 0, 610, 611, + 3, 305, 152, 0, 611, 612, 3, 299, 149, 0, 612, 90, 1, 0, 0, 0, 613, 614, + 3, 305, 152, 0, 614, 615, 3, 301, 150, 0, 615, 616, 3, 315, 157, 0, 616, + 617, 3, 317, 158, 0, 617, 618, 3, 323, 161, 0, 618, 619, 3, 297, 148, 0, + 619, 92, 1, 0, 0, 0, 620, 621, 3, 305, 152, 0, 621, 622, 3, 315, 157, 0, + 622, 94, 1, 0, 0, 0, 623, 624, 3, 305, 152, 0, 624, 625, 3, 315, 157, 0, + 625, 626, 3, 315, 157, 0, 626, 627, 3, 297, 148, 0, 627, 628, 3, 323, 161, + 0, 628, 96, 1, 0, 0, 0, 629, 630, 3, 305, 152, 0, 630, 631, 3, 315, 157, + 0, 631, 632, 3, 327, 163, 0, 632, 633, 3, 297, 148, 0, 633, 634, 3, 323, + 161, 0, 634, 635, 3, 325, 162, 0, 635, 636, 3, 297, 148, 0, 636, 637, 3, + 293, 146, 0, 637, 638, 3, 327, 163, 0, 638, 98, 1, 0, 0, 0, 639, 640, 3, + 305, 152, 0, 640, 641, 3, 315, 157, 0, 641, 642, 3, 327, 163, 0, 642, 643, + 3, 297, 148, 0, 643, 644, 3, 323, 161, 0, 644, 645, 3, 331, 165, 0, 645, + 646, 3, 289, 144, 0, 646, 647, 3, 311, 155, 0, 647, 100, 1, 0, 0, 0, 648, + 649, 3, 305, 152, 0, 649, 650, 3, 315, 157, 0, 650, 651, 3, 327, 163, 0, + 651, 652, 3, 317, 158, 0, 652, 102, 1, 0, 0, 0, 653, 654, 3, 305, 152, + 0, 654, 655, 3, 325, 162, 0, 655, 104, 1, 0, 0, 0, 656, 657, 3, 307, 153, + 0, 657, 658, 3, 317, 158, 0, 658, 659, 3, 305, 152, 0, 659, 660, 3, 315, + 157, 0, 660, 106, 1, 0, 0, 0, 661, 662, 3, 311, 155, 0, 662, 663, 3, 289, + 144, 0, 663, 664, 3, 327, 163, 0, 664, 665, 3, 297, 148, 0, 665, 666, 3, + 323, 161, 0, 666, 667, 3, 289, 144, 0, 667, 668, 3, 311, 155, 0, 668, 108, + 1, 0, 0, 0, 669, 670, 3, 311, 155, 0, 670, 671, 3, 297, 148, 0, 671, 672, + 3, 299, 149, 0, 672, 673, 3, 327, 163, 0, 673, 110, 1, 0, 0, 0, 674, 675, + 3, 311, 155, 0, 675, 676, 3, 305, 152, 0, 676, 677, 3, 309, 154, 0, 677, + 678, 3, 297, 148, 0, 678, 112, 1, 0, 0, 0, 679, 680, 3, 311, 155, 0, 680, + 681, 3, 305, 152, 0, 681, 682, 3, 313, 156, 0, 682, 683, 3, 305, 152, 0, + 683, 684, 3, 327, 163, 0, 684, 114, 1, 0, 0, 0, 685, 686, 3, 311, 155, + 0, 686, 687, 3, 317, 158, 0, 687, 688, 3, 317, 158, 0, 688, 689, 3, 309, + 154, 0, 689, 690, 3, 329, 164, 0, 690, 691, 3, 319, 159, 0, 691, 116, 1, + 0, 0, 0, 692, 693, 3, 313, 156, 0, 693, 694, 3, 297, 148, 0, 694, 695, + 3, 323, 161, 0, 695, 696, 3, 301, 150, 0, 696, 697, 3, 297, 148, 0, 697, + 118, 1, 0, 0, 0, 698, 699, 3, 315, 157, 0, 699, 700, 3, 289, 144, 0, 700, + 701, 3, 327, 163, 0, 701, 702, 3, 329, 164, 0, 702, 703, 3, 323, 161, 0, + 703, 704, 3, 289, 144, 0, 704, 705, 3, 311, 155, 0, 705, 120, 1, 0, 0, + 0, 706, 707, 3, 315, 157, 0, 707, 708, 3, 297, 148, 0, 708, 709, 3, 333, + 166, 0, 709, 122, 1, 0, 0, 0, 710, 711, 3, 315, 157, 0, 711, 712, 3, 317, + 158, 0, 712, 124, 1, 0, 0, 0, 713, 714, 3, 315, 157, 0, 714, 715, 3, 317, + 158, 0, 715, 716, 3, 327, 163, 0, 716, 126, 1, 0, 0, 0, 717, 718, 3, 315, + 157, 0, 718, 719, 3, 329, 164, 0, 719, 720, 3, 311, 155, 0, 720, 721, 3, + 311, 155, 0, 721, 128, 1, 0, 0, 0, 722, 723, 3, 315, 157, 0, 723, 724, + 3, 329, 164, 0, 724, 725, 3, 311, 155, 0, 725, 726, 3, 311, 155, 0, 726, + 727, 3, 325, 162, 0, 727, 130, 1, 0, 0, 0, 728, 729, 3, 317, 158, 0, 729, + 730, 3, 299, 149, 0, 730, 132, 1, 0, 0, 0, 731, 732, 3, 317, 158, 0, 732, + 733, 3, 299, 149, 0, 733, 734, 3, 299, 149, 0, 734, 735, 3, 325, 162, 0, + 735, 736, 3, 297, 148, 0, 736, 737, 3, 327, 163, 0, 737, 134, 1, 0, 0, + 0, 738, 739, 3, 317, 158, 0, 739, 740, 3, 315, 157, 0, 740, 136, 1, 0, + 0, 0, 741, 742, 3, 317, 158, 0, 742, 743, 3, 323, 161, 0, 743, 138, 1, + 0, 0, 0, 744, 745, 3, 317, 158, 0, 745, 746, 3, 323, 161, 0, 746, 747, + 3, 295, 147, 0, 747, 748, 3, 297, 148, 0, 748, 749, 3, 323, 161, 0, 749, + 140, 1, 0, 0, 0, 750, 751, 3, 317, 158, 0, 751, 752, 3, 323, 161, 0, 752, + 753, 3, 295, 147, 0, 753, 754, 3, 305, 152, 0, 754, 755, 3, 315, 157, 0, + 755, 756, 3, 289, 144, 0, 756, 757, 3, 311, 155, 0, 757, 142, 1, 0, 0, + 0, 758, 759, 3, 317, 158, 0, 759, 760, 3, 329, 164, 0, 760, 761, 3, 327, + 163, 0, 761, 762, 3, 297, 148, 0, 762, 763, 3, 323, 161, 0, 763, 144, 1, + 0, 0, 0, 764, 765, 3, 317, 158, 0, 765, 766, 3, 331, 165, 0, 766, 767, + 3, 297, 148, 0, 767, 768, 3, 323, 161, 0, 768, 146, 1, 0, 0, 0, 769, 770, + 3, 319, 159, 0, 770, 771, 3, 289, 144, 0, 771, 772, 3, 323, 161, 0, 772, + 773, 3, 327, 163, 0, 773, 774, 3, 305, 152, 0, 774, 775, 3, 327, 163, 0, + 775, 776, 3, 305, 152, 0, 776, 777, 3, 317, 158, 0, 777, 778, 3, 315, 157, + 0, 778, 148, 1, 0, 0, 0, 779, 780, 3, 319, 159, 0, 780, 781, 3, 323, 161, + 0, 781, 782, 3, 297, 148, 0, 782, 783, 3, 293, 146, 0, 783, 784, 3, 297, + 148, 0, 784, 785, 3, 295, 147, 0, 785, 786, 3, 305, 152, 0, 786, 787, 3, + 315, 157, 0, 787, 788, 3, 301, 150, 0, 788, 150, 1, 0, 0, 0, 789, 790, + 3, 319, 159, 0, 790, 791, 3, 323, 161, 0, 791, 792, 3, 317, 158, 0, 792, + 793, 3, 327, 163, 0, 793, 794, 3, 317, 158, 0, 794, 152, 1, 0, 0, 0, 795, + 796, 3, 323, 161, 0, 796, 797, 3, 289, 144, 0, 797, 798, 3, 315, 157, 0, + 798, 799, 3, 301, 150, 0, 799, 800, 3, 297, 148, 0, 800, 154, 1, 0, 0, + 0, 801, 802, 3, 323, 161, 0, 802, 803, 3, 297, 148, 0, 803, 804, 3, 293, + 146, 0, 804, 805, 3, 329, 164, 0, 805, 806, 3, 323, 161, 0, 806, 807, 3, + 325, 162, 0, 807, 808, 3, 305, 152, 0, 808, 809, 3, 331, 165, 0, 809, 810, + 3, 297, 148, 0, 810, 156, 1, 0, 0, 0, 811, 812, 3, 323, 161, 0, 812, 813, + 3, 297, 148, 0, 813, 814, 3, 319, 159, 0, 814, 815, 3, 311, 155, 0, 815, + 816, 3, 289, 144, 0, 816, 817, 3, 293, 146, 0, 817, 818, 3, 297, 148, 0, + 818, 158, 1, 0, 0, 0, 819, 820, 3, 323, 161, 0, 820, 821, 3, 297, 148, + 0, 821, 822, 3, 325, 162, 0, 822, 823, 3, 319, 159, 0, 823, 824, 3, 297, + 148, 0, 824, 825, 3, 293, 146, 0, 825, 826, 3, 327, 163, 0, 826, 160, 1, + 0, 0, 0, 827, 828, 3, 323, 161, 0, 828, 829, 3, 305, 152, 0, 829, 830, + 3, 301, 150, 0, 830, 831, 3, 303, 151, 0, 831, 832, 3, 327, 163, 0, 832, + 162, 1, 0, 0, 0, 833, 834, 3, 323, 161, 0, 834, 835, 3, 317, 158, 0, 835, + 836, 3, 311, 155, 0, 836, 837, 3, 311, 155, 0, 837, 838, 3, 329, 164, 0, + 838, 839, 3, 319, 159, 0, 839, 164, 1, 0, 0, 0, 840, 841, 3, 323, 161, + 0, 841, 842, 3, 317, 158, 0, 842, 843, 3, 333, 166, 0, 843, 844, 3, 325, + 162, 0, 844, 166, 1, 0, 0, 0, 845, 846, 3, 325, 162, 0, 846, 847, 3, 289, + 144, 0, 847, 848, 3, 299, 149, 0, 848, 849, 3, 297, 148, 0, 849, 850, 5, + 95, 0, 0, 850, 851, 3, 317, 158, 0, 851, 852, 3, 299, 149, 0, 852, 853, + 3, 299, 149, 0, 853, 854, 3, 325, 162, 0, 854, 855, 3, 297, 148, 0, 855, + 856, 3, 327, 163, 0, 856, 168, 1, 0, 0, 0, 857, 858, 3, 325, 162, 0, 858, + 859, 3, 289, 144, 0, 859, 860, 3, 299, 149, 0, 860, 861, 3, 297, 148, 0, + 861, 862, 5, 95, 0, 0, 862, 863, 3, 317, 158, 0, 863, 864, 3, 323, 161, + 0, 864, 865, 3, 295, 147, 0, 865, 866, 3, 305, 152, 0, 866, 867, 3, 315, + 157, 0, 867, 868, 3, 289, 144, 0, 868, 869, 3, 311, 155, 0, 869, 170, 1, + 0, 0, 0, 870, 871, 3, 325, 162, 0, 871, 872, 3, 297, 148, 0, 872, 873, + 3, 311, 155, 0, 873, 874, 3, 297, 148, 0, 874, 875, 3, 293, 146, 0, 875, + 876, 3, 327, 163, 0, 876, 172, 1, 0, 0, 0, 877, 878, 3, 325, 162, 0, 878, + 879, 3, 297, 148, 0, 879, 880, 3, 327, 163, 0, 880, 174, 1, 0, 0, 0, 881, + 882, 3, 325, 162, 0, 882, 883, 3, 317, 158, 0, 883, 884, 3, 313, 156, 0, + 884, 885, 3, 297, 148, 0, 885, 176, 1, 0, 0, 0, 886, 887, 3, 325, 162, + 0, 887, 888, 3, 327, 163, 0, 888, 889, 3, 323, 161, 0, 889, 890, 3, 329, + 164, 0, 890, 891, 3, 293, 146, 0, 891, 892, 3, 327, 163, 0, 892, 178, 1, + 0, 0, 0, 893, 894, 3, 325, 162, 0, 894, 895, 3, 337, 168, 0, 895, 896, + 3, 325, 162, 0, 896, 897, 3, 327, 163, 0, 897, 898, 3, 297, 148, 0, 898, + 899, 3, 313, 156, 0, 899, 180, 1, 0, 0, 0, 900, 901, 3, 327, 163, 0, 901, + 902, 3, 289, 144, 0, 902, 903, 3, 291, 145, 0, 903, 904, 3, 311, 155, 0, + 904, 905, 3, 297, 148, 0, 905, 906, 3, 325, 162, 0, 906, 907, 3, 289, 144, + 0, 907, 908, 3, 313, 156, 0, 908, 909, 3, 319, 159, 0, 909, 910, 3, 311, + 155, 0, 910, 911, 3, 297, 148, 0, 911, 182, 1, 0, 0, 0, 912, 913, 3, 327, + 163, 0, 913, 914, 3, 303, 151, 0, 914, 915, 3, 297, 148, 0, 915, 916, 3, + 315, 157, 0, 916, 184, 1, 0, 0, 0, 917, 918, 3, 327, 163, 0, 918, 919, + 3, 305, 152, 0, 919, 920, 3, 313, 156, 0, 920, 921, 3, 297, 148, 0, 921, + 186, 1, 0, 0, 0, 922, 923, 3, 327, 163, 0, 923, 924, 3, 317, 158, 0, 924, + 188, 1, 0, 0, 0, 925, 926, 3, 327, 163, 0, 926, 927, 3, 323, 161, 0, 927, + 928, 3, 297, 148, 0, 928, 929, 3, 289, 144, 0, 929, 930, 3, 327, 163, 0, + 930, 190, 1, 0, 0, 0, 931, 932, 3, 327, 163, 0, 932, 933, 3, 323, 161, + 0, 933, 934, 3, 329, 164, 0, 934, 935, 3, 297, 148, 0, 935, 192, 1, 0, + 0, 0, 936, 937, 3, 329, 164, 0, 937, 938, 3, 315, 157, 0, 938, 939, 3, + 291, 145, 0, 939, 940, 3, 317, 158, 0, 940, 941, 3, 329, 164, 0, 941, 942, + 3, 315, 157, 0, 942, 943, 3, 295, 147, 0, 943, 944, 3, 297, 148, 0, 944, + 945, 3, 295, 147, 0, 945, 194, 1, 0, 0, 0, 946, 947, 3, 329, 164, 0, 947, + 948, 3, 315, 157, 0, 948, 949, 3, 305, 152, 0, 949, 950, 3, 317, 158, 0, + 950, 951, 3, 315, 157, 0, 951, 196, 1, 0, 0, 0, 952, 953, 3, 329, 164, + 0, 953, 954, 3, 315, 157, 0, 954, 955, 3, 315, 157, 0, 955, 956, 3, 297, + 148, 0, 956, 957, 3, 325, 162, 0, 957, 958, 3, 327, 163, 0, 958, 198, 1, + 0, 0, 0, 959, 960, 3, 329, 164, 0, 960, 961, 3, 325, 162, 0, 961, 962, + 3, 305, 152, 0, 962, 963, 3, 315, 157, 0, 963, 964, 3, 301, 150, 0, 964, + 200, 1, 0, 0, 0, 965, 966, 3, 333, 166, 0, 966, 967, 3, 303, 151, 0, 967, + 968, 3, 297, 148, 0, 968, 969, 3, 315, 157, 0, 969, 202, 1, 0, 0, 0, 970, + 971, 3, 333, 166, 0, 971, 972, 3, 303, 151, 0, 972, 973, 3, 297, 148, 0, + 973, 974, 3, 323, 161, 0, 974, 975, 3, 297, 148, 0, 975, 204, 1, 0, 0, + 0, 976, 977, 3, 333, 166, 0, 977, 978, 3, 305, 152, 0, 978, 979, 3, 315, + 157, 0, 979, 980, 3, 295, 147, 0, 980, 981, 3, 317, 158, 0, 981, 982, 3, + 333, 166, 0, 982, 206, 1, 0, 0, 0, 983, 984, 3, 333, 166, 0, 984, 985, + 3, 305, 152, 0, 985, 986, 3, 327, 163, 0, 986, 987, 3, 303, 151, 0, 987, + 208, 1, 0, 0, 0, 988, 989, 3, 333, 166, 0, 989, 990, 3, 305, 152, 0, 990, + 991, 3, 327, 163, 0, 991, 992, 3, 303, 151, 0, 992, 993, 3, 305, 152, 0, + 993, 994, 3, 315, 157, 0, 994, 210, 1, 0, 0, 0, 995, 997, 7, 1, 0, 0, 996, + 995, 1, 0, 0, 0, 996, 997, 1, 0, 0, 0, 997, 1000, 1, 0, 0, 0, 998, 999, + 5, 48, 0, 0, 999, 1001, 5, 120, 0, 0, 1000, 998, 1, 0, 0, 0, 1000, 1001, + 1, 0, 0, 0, 1001, 1002, 1, 0, 0, 0, 1002, 1003, 3, 215, 107, 0, 1003, 212, + 1, 0, 0, 0, 1004, 1006, 7, 1, 0, 0, 1005, 1004, 1, 0, 0, 0, 1005, 1006, + 1, 0, 0, 0, 1006, 1007, 1, 0, 0, 0, 1007, 1008, 3, 215, 107, 0, 1008, 1010, + 5, 46, 0, 0, 1009, 1011, 3, 215, 107, 0, 1010, 1009, 1, 0, 0, 0, 1010, + 1011, 1, 0, 0, 0, 1011, 1015, 1, 0, 0, 0, 1012, 1013, 5, 101, 0, 0, 1013, + 1014, 7, 1, 0, 0, 1014, 1016, 3, 215, 107, 0, 1015, 1012, 1, 0, 0, 0, 1015, + 1016, 1, 0, 0, 0, 1016, 1035, 1, 0, 0, 0, 1017, 1019, 3, 215, 107, 0, 1018, + 1017, 1, 0, 0, 0, 1018, 1019, 1, 0, 0, 0, 1019, 1020, 1, 0, 0, 0, 1020, + 1021, 5, 46, 0, 0, 1021, 1025, 3, 215, 107, 0, 1022, 1023, 5, 101, 0, 0, + 1023, 1024, 7, 1, 0, 0, 1024, 1026, 3, 215, 107, 0, 1025, 1022, 1, 0, 0, + 0, 1025, 1026, 1, 0, 0, 0, 1026, 1035, 1, 0, 0, 0, 1027, 1028, 3, 215, + 107, 0, 1028, 1030, 5, 101, 0, 0, 1029, 1031, 7, 1, 0, 0, 1030, 1029, 1, + 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1032, 1, 0, 0, 0, 1032, 1033, 3, + 215, 107, 0, 1033, 1035, 1, 0, 0, 0, 1034, 1005, 1, 0, 0, 0, 1034, 1018, + 1, 0, 0, 0, 1034, 1027, 1, 0, 0, 0, 1035, 214, 1, 0, 0, 0, 1036, 1038, + 3, 287, 143, 0, 1037, 1036, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1039, 1037, + 1, 0, 0, 0, 1039, 1040, 1, 0, 0, 0, 1040, 216, 1, 0, 0, 0, 1041, 1043, + 7, 2, 0, 0, 1042, 1041, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, 1042, + 1, 0, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1047, + 6, 108, 0, 0, 1047, 218, 1, 0, 0, 0, 1048, 1049, 5, 45, 0, 0, 1049, 1050, + 5, 45, 0, 0, 1050, 1054, 1, 0, 0, 0, 1051, 1053, 8, 3, 0, 0, 1052, 1051, + 1, 0, 0, 0, 1053, 1056, 1, 0, 0, 0, 1054, 1052, 1, 0, 0, 0, 1054, 1055, + 1, 0, 0, 0, 1055, 1057, 1, 0, 0, 0, 1056, 1054, 1, 0, 0, 0, 1057, 1058, + 6, 109, 0, 0, 1058, 220, 1, 0, 0, 0, 1059, 1060, 5, 47, 0, 0, 1060, 1061, + 5, 42, 0, 0, 1061, 1065, 1, 0, 0, 0, 1062, 1064, 9, 0, 0, 0, 1063, 1062, + 1, 0, 0, 0, 1064, 1067, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1065, 1063, + 1, 0, 0, 0, 1066, 1068, 1, 0, 0, 0, 1067, 1065, 1, 0, 0, 0, 1068, 1069, + 5, 42, 0, 0, 1069, 1070, 5, 47, 0, 0, 1070, 1071, 1, 0, 0, 0, 1071, 1072, + 6, 110, 0, 0, 1072, 222, 1, 0, 0, 0, 1073, 1079, 5, 34, 0, 0, 1074, 1078, + 8, 4, 0, 0, 1075, 1076, 5, 92, 0, 0, 1076, 1078, 5, 34, 0, 0, 1077, 1074, + 1, 0, 0, 0, 1077, 1075, 1, 0, 0, 0, 1078, 1081, 1, 0, 0, 0, 1079, 1077, + 1, 0, 0, 0, 1079, 1080, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081, 1079, + 1, 0, 0, 0, 1082, 1094, 5, 34, 0, 0, 1083, 1089, 5, 39, 0, 0, 1084, 1088, + 8, 5, 0, 0, 1085, 1086, 5, 92, 0, 0, 1086, 1088, 5, 39, 0, 0, 1087, 1084, + 1, 0, 0, 0, 1087, 1085, 1, 0, 0, 0, 1088, 1091, 1, 0, 0, 0, 1089, 1087, + 1, 0, 0, 0, 1089, 1090, 1, 0, 0, 0, 1090, 1092, 1, 0, 0, 0, 1091, 1089, + 1, 0, 0, 0, 1092, 1094, 5, 39, 0, 0, 1093, 1073, 1, 0, 0, 0, 1093, 1083, + 1, 0, 0, 0, 1094, 224, 1, 0, 0, 0, 1095, 1096, 3, 1, 0, 0, 1096, 1097, + 3, 1, 0, 0, 1097, 1101, 3, 1, 0, 0, 1098, 1100, 9, 0, 0, 0, 1099, 1098, + 1, 0, 0, 0, 1100, 1103, 1, 0, 0, 0, 1101, 1102, 1, 0, 0, 0, 1101, 1099, + 1, 0, 0, 0, 1102, 1104, 1, 0, 0, 0, 1103, 1101, 1, 0, 0, 0, 1104, 1105, + 8, 6, 0, 0, 1105, 1106, 3, 1, 0, 0, 1106, 1107, 3, 1, 0, 0, 1107, 1108, + 3, 1, 0, 0, 1108, 1124, 1, 0, 0, 0, 1109, 1110, 3, 3, 1, 0, 1110, 1111, + 3, 3, 1, 0, 1111, 1115, 3, 3, 1, 0, 1112, 1114, 9, 0, 0, 0, 1113, 1112, + 1, 0, 0, 0, 1114, 1117, 1, 0, 0, 0, 1115, 1116, 1, 0, 0, 0, 1115, 1113, + 1, 0, 0, 0, 1116, 1118, 1, 0, 0, 0, 1117, 1115, 1, 0, 0, 0, 1118, 1119, + 8, 6, 0, 0, 1119, 1120, 3, 3, 1, 0, 1120, 1121, 3, 3, 1, 0, 1121, 1122, + 3, 3, 1, 0, 1122, 1124, 1, 0, 0, 0, 1123, 1095, 1, 0, 0, 0, 1123, 1109, + 1, 0, 0, 0, 1124, 226, 1, 0, 0, 0, 1125, 1128, 3, 323, 161, 0, 1126, 1129, + 3, 223, 111, 0, 1127, 1129, 3, 225, 112, 0, 1128, 1126, 1, 0, 0, 0, 1128, + 1127, 1, 0, 0, 0, 1129, 228, 1, 0, 0, 0, 1130, 1133, 3, 291, 145, 0, 1131, + 1134, 3, 223, 111, 0, 1132, 1134, 3, 225, 112, 0, 1133, 1131, 1, 0, 0, + 0, 1133, 1132, 1, 0, 0, 0, 1134, 230, 1, 0, 0, 0, 1135, 1138, 3, 237, 118, + 0, 1136, 1139, 3, 223, 111, 0, 1137, 1139, 3, 225, 112, 0, 1138, 1136, + 1, 0, 0, 0, 1138, 1137, 1, 0, 0, 0, 1139, 232, 1, 0, 0, 0, 1140, 1145, + 3, 241, 120, 0, 1141, 1143, 5, 92, 0, 0, 1142, 1141, 1, 0, 0, 0, 1142, + 1143, 1, 0, 0, 0, 1143, 1144, 1, 0, 0, 0, 1144, 1146, 9, 0, 0, 0, 1145, + 1142, 1, 0, 0, 0, 1146, 1147, 1, 0, 0, 0, 1147, 1145, 1, 0, 0, 0, 1147, + 1148, 1, 0, 0, 0, 1148, 1149, 1, 0, 0, 0, 1149, 1150, 3, 241, 120, 0, 1150, + 234, 1, 0, 0, 0, 1151, 1155, 7, 7, 0, 0, 1152, 1154, 7, 8, 0, 0, 1153, + 1152, 1, 0, 0, 0, 1154, 1157, 1, 0, 0, 0, 1155, 1153, 1, 0, 0, 0, 1155, + 1156, 1, 0, 0, 0, 1156, 236, 1, 0, 0, 0, 1157, 1155, 1, 0, 0, 0, 1158, + 1159, 7, 9, 0, 0, 1159, 1163, 7, 10, 0, 0, 1160, 1161, 7, 10, 0, 0, 1161, + 1163, 7, 9, 0, 0, 1162, 1158, 1, 0, 0, 0, 1162, 1160, 1, 0, 0, 0, 1163, + 238, 1, 0, 0, 0, 1164, 1165, 5, 46, 0, 0, 1165, 240, 1, 0, 0, 0, 1166, + 1167, 5, 96, 0, 0, 1167, 242, 1, 0, 0, 0, 1168, 1169, 5, 40, 0, 0, 1169, + 244, 1, 0, 0, 0, 1170, 1171, 5, 41, 0, 0, 1171, 246, 1, 0, 0, 0, 1172, + 1173, 5, 91, 0, 0, 1173, 248, 1, 0, 0, 0, 1174, 1175, 5, 93, 0, 0, 1175, + 250, 1, 0, 0, 0, 1176, 1177, 5, 61, 0, 0, 1177, 252, 1, 0, 0, 0, 1178, + 1179, 5, 60, 0, 0, 1179, 254, 1, 0, 0, 0, 1180, 1181, 5, 62, 0, 0, 1181, + 256, 1, 0, 0, 0, 1182, 1183, 5, 60, 0, 0, 1183, 1184, 5, 60, 0, 0, 1184, + 258, 1, 0, 0, 0, 1185, 1186, 5, 62, 0, 0, 1186, 1187, 5, 62, 0, 0, 1187, + 260, 1, 0, 0, 0, 1188, 1189, 5, 60, 0, 0, 1189, 1190, 5, 61, 0, 0, 1190, + 262, 1, 0, 0, 0, 1191, 1192, 5, 62, 0, 0, 1192, 1193, 5, 61, 0, 0, 1193, + 264, 1, 0, 0, 0, 1194, 1195, 5, 33, 0, 0, 1195, 1196, 5, 61, 0, 0, 1196, + 266, 1, 0, 0, 0, 1197, 1198, 5, 60, 0, 0, 1198, 1199, 5, 62, 0, 0, 1199, + 268, 1, 0, 0, 0, 1200, 1201, 5, 38, 0, 0, 1201, 270, 1, 0, 0, 0, 1202, + 1203, 5, 124, 0, 0, 1203, 272, 1, 0, 0, 0, 1204, 1205, 5, 42, 0, 0, 1205, + 274, 1, 0, 0, 0, 1206, 1207, 5, 47, 0, 0, 1207, 276, 1, 0, 0, 0, 1208, + 1209, 5, 43, 0, 0, 1209, 278, 1, 0, 0, 0, 1210, 1211, 5, 45, 0, 0, 1211, + 280, 1, 0, 0, 0, 1212, 1213, 5, 44, 0, 0, 1213, 282, 1, 0, 0, 0, 1214, + 1215, 5, 126, 0, 0, 1215, 284, 1, 0, 0, 0, 1216, 1217, 5, 94, 0, 0, 1217, + 286, 1, 0, 0, 0, 1218, 1219, 7, 11, 0, 0, 1219, 288, 1, 0, 0, 0, 1220, + 1221, 7, 12, 0, 0, 1221, 290, 1, 0, 0, 0, 1222, 1223, 7, 10, 0, 0, 1223, + 292, 1, 0, 0, 0, 1224, 1225, 7, 13, 0, 0, 1225, 294, 1, 0, 0, 0, 1226, + 1227, 7, 14, 0, 0, 1227, 296, 1, 0, 0, 0, 1228, 1229, 7, 15, 0, 0, 1229, + 298, 1, 0, 0, 0, 1230, 1231, 7, 16, 0, 0, 1231, 300, 1, 0, 0, 0, 1232, + 1233, 7, 17, 0, 0, 1233, 302, 1, 0, 0, 0, 1234, 1235, 7, 18, 0, 0, 1235, + 304, 1, 0, 0, 0, 1236, 1237, 7, 19, 0, 0, 1237, 306, 1, 0, 0, 0, 1238, + 1239, 7, 20, 0, 0, 1239, 308, 1, 0, 0, 0, 1240, 1241, 7, 21, 0, 0, 1241, + 310, 1, 0, 0, 0, 1242, 1243, 7, 22, 0, 0, 1243, 312, 1, 0, 0, 0, 1244, + 1245, 7, 23, 0, 0, 1245, 314, 1, 0, 0, 0, 1246, 1247, 7, 24, 0, 0, 1247, + 316, 1, 0, 0, 0, 1248, 1249, 7, 25, 0, 0, 1249, 318, 1, 0, 0, 0, 1250, + 1251, 7, 26, 0, 0, 1251, 320, 1, 0, 0, 0, 1252, 1253, 7, 27, 0, 0, 1253, + 322, 1, 0, 0, 0, 1254, 1255, 7, 9, 0, 0, 1255, 324, 1, 0, 0, 0, 1256, 1257, + 7, 28, 0, 0, 1257, 326, 1, 0, 0, 0, 1258, 1259, 7, 29, 0, 0, 1259, 328, + 1, 0, 0, 0, 1260, 1261, 7, 30, 0, 0, 1261, 330, 1, 0, 0, 0, 1262, 1263, + 7, 31, 0, 0, 1263, 332, 1, 0, 0, 0, 1264, 1265, 7, 32, 0, 0, 1265, 334, + 1, 0, 0, 0, 1266, 1267, 7, 33, 0, 0, 1267, 336, 1, 0, 0, 0, 1268, 1269, + 7, 34, 0, 0, 1269, 338, 1, 0, 0, 0, 1270, 1271, 7, 35, 0, 0, 1271, 340, + 1, 0, 0, 0, 29, 0, 996, 1000, 1005, 1010, 1015, 1018, 1025, 1030, 1034, + 1039, 1044, 1054, 1065, 1077, 1079, 1087, 1089, 1093, 1101, 1115, 1123, + 1128, 1133, 1138, 1142, 1147, 1155, 1162, 1, 0, 1, 0, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// BigQueryLexerInit initializes any static state used to implement BigQueryLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewBigQueryLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func BigQueryLexerInit() { + staticData := &BigQueryLexerLexerStaticData + staticData.once.Do(bigquerylexerLexerInit) +} + +// NewBigQueryLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewBigQueryLexer(input antlr.CharStream) *BigQueryLexer { + BigQueryLexerInit() + l := new(BigQueryLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &BigQueryLexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + l.channelNames = staticData.ChannelNames + l.modeNames = staticData.ModeNames + l.RuleNames = staticData.RuleNames + l.LiteralNames = staticData.LiteralNames + l.SymbolicNames = staticData.SymbolicNames + l.GrammarFileName = "BigQueryLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// BigQueryLexer tokens. +const ( + BigQueryLexerQUOTE = 1 + BigQueryLexerDQOUTE = 2 + BigQueryLexerSEMI = 3 + BigQueryLexerALL = 4 + BigQueryLexerAND = 5 + BigQueryLexerANY = 6 + BigQueryLexerARRAY = 7 + BigQueryLexerAS = 8 + BigQueryLexerASC = 9 + BigQueryLexerASSERT_ROWS_MODIFIED = 10 + BigQueryLexerAT = 11 + BigQueryLexerBETWEEN = 12 + BigQueryLexerBY = 13 + BigQueryLexerCASE = 14 + BigQueryLexerCAST = 15 + BigQueryLexerCOLLATE = 16 + BigQueryLexerCONTAINS = 17 + BigQueryLexerCREATE = 18 + BigQueryLexerCROSS = 19 + BigQueryLexerCUBE = 20 + BigQueryLexerCURRENT = 21 + BigQueryLexerDEFAULT = 22 + BigQueryLexerDEFINE = 23 + BigQueryLexerDESC = 24 + BigQueryLexerDISTINCT = 25 + BigQueryLexerELSE = 26 + BigQueryLexerEND = 27 + BigQueryLexerENUM = 28 + BigQueryLexerESCAPE = 29 + BigQueryLexerEXCEPT = 30 + BigQueryLexerEXCLUDE = 31 + BigQueryLexerEXISTS = 32 + BigQueryLexerEXTRACT = 33 + BigQueryLexerFALSE = 34 + BigQueryLexerFETCH = 35 + BigQueryLexerFOLLOWING = 36 + BigQueryLexerFOR = 37 + BigQueryLexerFROM = 38 + BigQueryLexerFULL = 39 + BigQueryLexerGROUP = 40 + BigQueryLexerGROUPING = 41 + BigQueryLexerGROUPS = 42 + BigQueryLexerHASH = 43 + BigQueryLexerHAVING = 44 + BigQueryLexerIF = 45 + BigQueryLexerIGNORE = 46 + BigQueryLexerIN = 47 + BigQueryLexerINNER = 48 + BigQueryLexerINTERSECT = 49 + BigQueryLexerINTERVAL = 50 + BigQueryLexerINTO = 51 + BigQueryLexerIS = 52 + BigQueryLexerJOIN = 53 + BigQueryLexerLATERAL = 54 + BigQueryLexerLEFT = 55 + BigQueryLexerLIKE = 56 + BigQueryLexerLIMIT = 57 + BigQueryLexerLOOKUP = 58 + BigQueryLexerMERGE = 59 + BigQueryLexerNATURAL = 60 + BigQueryLexerNEW = 61 + BigQueryLexerNO = 62 + BigQueryLexerNOT = 63 + BigQueryLexerS_NULL = 64 + BigQueryLexerNULLS = 65 + BigQueryLexerOF = 66 + BigQueryLexerOFFSET = 67 + BigQueryLexerON = 68 + BigQueryLexerOR = 69 + BigQueryLexerORDER = 70 + BigQueryLexerORDINAL = 71 + BigQueryLexerOUTER = 72 + BigQueryLexerOVER = 73 + BigQueryLexerPARTITION = 74 + BigQueryLexerPRECEDING = 75 + BigQueryLexerPROTO = 76 + BigQueryLexerRANGE = 77 + BigQueryLexerRECURSIVE = 78 + BigQueryLexerREPLACE = 79 + BigQueryLexerRESPECT = 80 + BigQueryLexerRIGHT = 81 + BigQueryLexerROLLUP = 82 + BigQueryLexerROWS = 83 + BigQueryLexerSAFE_OFFSET = 84 + BigQueryLexerSAFE_ORDINAL = 85 + BigQueryLexerSELECT = 86 + BigQueryLexerSET = 87 + BigQueryLexerSOME = 88 + BigQueryLexerSSTRUCT = 89 + BigQueryLexerSYSTEM = 90 + BigQueryLexerTABLESAMPLE = 91 + BigQueryLexerTHEN = 92 + BigQueryLexerTIME = 93 + BigQueryLexerTO = 94 + BigQueryLexerTREAT = 95 + BigQueryLexerTRUE = 96 + BigQueryLexerUNBOUNDED = 97 + BigQueryLexerUNION = 98 + BigQueryLexerUNNEST = 99 + BigQueryLexerUSING = 100 + BigQueryLexerWHEN = 101 + BigQueryLexerWHERE = 102 + BigQueryLexerWINDOW = 103 + BigQueryLexerWITH = 104 + BigQueryLexerWITHIN = 105 + BigQueryLexerINT = 106 + BigQueryLexerFLOAT = 107 + BigQueryLexerDIGITS = 108 + BigQueryLexerWS = 109 + BigQueryLexerCMT = 110 + BigQueryLexerM_CMT = 111 + BigQueryLexerQUOTED_STRING = 112 + BigQueryLexerTRIPLE_QUOTED_STRING = 113 + BigQueryLexerRAW_STRING = 114 + BigQueryLexerBYTE_STRING = 115 + BigQueryLexerRAW_BYTE_STRING = 116 + BigQueryLexerQUOTED_ID = 117 + BigQueryLexerID = 118 + BigQueryLexerRB = 119 + BigQueryLexerDOT = 120 + BigQueryLexerBACKTICK = 121 + BigQueryLexerLR_BRACKET = 122 + BigQueryLexerRR_BRACKET = 123 + BigQueryLexerLSB = 124 + BigQueryLexerRSB = 125 + BigQueryLexerEQ = 126 + BigQueryLexerLT = 127 + BigQueryLexerGT = 128 + BigQueryLexerDOUBLE_LT = 129 + BigQueryLexerDOUBLE_GT = 130 + BigQueryLexerLE = 131 + BigQueryLexerGE = 132 + BigQueryLexerNE = 133 + BigQueryLexerLTGT = 134 + BigQueryLexerBIT_AND = 135 + BigQueryLexerBIT_OR = 136 + BigQueryLexerSTAR = 137 + BigQueryLexerDIVIDE = 138 + BigQueryLexerPLUS = 139 + BigQueryLexerMINUS = 140 + BigQueryLexerCOMMA = 141 + BigQueryLexerTILDE = 142 + BigQueryLexerCARET = 143 +) diff --git a/bq/bigquery_parser.go b/bq/bigquery_parser.go new file mode 100644 index 0000000..ca8b409 --- /dev/null +++ b/bq/bigquery_parser.go @@ -0,0 +1,13115 @@ +// Code generated from BigQueryParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package bq // BigQueryParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type BigQueryParser struct { + *antlr.BaseParser +} + +var BigQueryParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func bigqueryparserParserInit() { + staticData := &BigQueryParserParserStaticData + staticData.LiteralNames = []string{ + "", "'''", "'\"'", "';'", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "'.'", "'`'", "'('", "')'", "'['", "']'", "'='", "'<'", + "'>'", "'<<'", "'>>'", "'<='", "'>='", "'!='", "'<>'", "'&'", "'|'", + "'*'", "'/'", "'+'", "'-'", "','", "'~'", "'^'", + } + staticData.SymbolicNames = []string{ + "", "QUOTE", "DQOUTE", "SEMI", "ALL", "AND", "ANY", "ARRAY", "AS", "ASC", + "ASSERT_ROWS_MODIFIED", "AT", "BETWEEN", "BY", "CASE", "CAST", "COLLATE", + "CONTAINS", "CREATE", "CROSS", "CUBE", "CURRENT", "DEFAULT", "DEFINE", + "DESC", "DISTINCT", "ELSE", "END", "ENUM", "ESCAPE", "EXCEPT", "EXCLUDE", + "EXISTS", "EXTRACT", "FALSE", "FETCH", "FOLLOWING", "FOR", "FROM", "FULL", + "GROUP", "GROUPING", "GROUPS", "HASH", "HAVING", "IF", "IGNORE", "IN", + "INNER", "INTERSECT", "INTERVAL", "INTO", "IS", "JOIN", "LATERAL", "LEFT", + "LIKE", "LIMIT", "LOOKUP", "MERGE", "NATURAL", "NEW", "NO", "NOT", "S_NULL", + "NULLS", "OF", "OFFSET", "ON", "OR", "ORDER", "ORDINAL", "OUTER", "OVER", + "PARTITION", "PRECEDING", "PROTO", "RANGE", "RECURSIVE", "REPLACE", + "RESPECT", "RIGHT", "ROLLUP", "ROWS", "SAFE_OFFSET", "SAFE_ORDINAL", + "SELECT", "SET", "SOME", "SSTRUCT", "SYSTEM", "TABLESAMPLE", "THEN", + "TIME", "TO", "TREAT", "TRUE", "UNBOUNDED", "UNION", "UNNEST", "USING", + "WHEN", "WHERE", "WINDOW", "WITH", "WITHIN", "INT", "FLOAT", "DIGITS", + "WS", "CMT", "M_CMT", "QUOTED_STRING", "TRIPLE_QUOTED_STRING", "RAW_STRING", + "BYTE_STRING", "RAW_BYTE_STRING", "QUOTED_ID", "ID", "RB", "DOT", "BACKTICK", + "LR_BRACKET", "RR_BRACKET", "LSB", "RSB", "EQ", "LT", "GT", "DOUBLE_LT", + "DOUBLE_GT", "LE", "GE", "NE", "LTGT", "BIT_AND", "BIT_OR", "STAR", + "DIVIDE", "PLUS", "MINUS", "COMMA", "TILDE", "CARET", + } + staticData.RuleNames = []string{ + "root", "stmtmulti", "stmt", "query_statement", "query_expr", "select_statement", + "from_statement", "from_item", "where_statement", "group_statement", + "having_statement", "window_statement", "order_clause", "limit_clause", + "unary_operator", "expr", "cast_expr", "column_expr", "except_statement", + "replace_statement", "join_type", "on_clause", "set_op", "using_clause", + "field_path", "sstruct", "array_expr", "array_path", "bool_expression", + "window_name", "window_definition", "count", "skip_rows", "with_statement", + "name", "dot_name", "alias_name", "array_name", "column_name", "cte_name", + "dataset_name", "datatype_name", "function_name", "join_name", "member_name", + "project_name", "struct_name", "table_name", "table_expr", "number", + "integer_type", "float_type", "string", "quoted_string", "triple_quoted_string", + "raw_string", "byte_string", "raw_byte_string", "special_string", "keyword", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 143, 755, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, + 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, + 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, + 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, + 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, + 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, + 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, + 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, + 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, + 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, + 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, + 2, 58, 7, 58, 2, 59, 7, 59, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 126, 8, + 1, 5, 1, 128, 8, 1, 10, 1, 12, 1, 131, 9, 1, 1, 2, 1, 2, 1, 3, 3, 3, 136, + 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 3, 4, 143, 8, 4, 1, 4, 3, 4, 146, 8, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 152, 8, 4, 1, 4, 3, 4, 155, 8, 4, 3, 4, + 157, 8, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 163, 8, 4, 1, 4, 3, 4, 166, 8, + 4, 5, 4, 168, 8, 4, 10, 4, 12, 4, 171, 9, 4, 1, 5, 1, 5, 3, 5, 175, 8, + 5, 1, 5, 3, 5, 178, 8, 5, 1, 5, 3, 5, 181, 8, 5, 1, 5, 1, 5, 3, 5, 185, + 8, 5, 1, 5, 3, 5, 188, 8, 5, 1, 5, 1, 5, 3, 5, 192, 8, 5, 1, 5, 3, 5, 195, + 8, 5, 3, 5, 197, 8, 5, 1, 5, 1, 5, 3, 5, 201, 8, 5, 1, 5, 1, 5, 3, 5, 205, + 8, 5, 1, 5, 3, 5, 208, 8, 5, 1, 5, 1, 5, 3, 5, 212, 8, 5, 1, 5, 3, 5, 215, + 8, 5, 3, 5, 217, 8, 5, 5, 5, 219, 8, 5, 10, 5, 12, 5, 222, 9, 5, 1, 5, + 3, 5, 225, 8, 5, 1, 5, 3, 5, 228, 8, 5, 1, 5, 3, 5, 231, 8, 5, 1, 5, 3, + 5, 234, 8, 5, 1, 5, 3, 5, 237, 8, 5, 1, 6, 1, 6, 1, 6, 1, 6, 5, 6, 243, + 8, 6, 10, 6, 12, 6, 246, 9, 6, 1, 7, 1, 7, 1, 7, 3, 7, 251, 8, 7, 1, 7, + 3, 7, 254, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 262, 8, 7, 1, + 7, 1, 7, 1, 7, 1, 7, 3, 7, 268, 8, 7, 1, 7, 3, 7, 271, 8, 7, 1, 7, 1, 7, + 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 279, 8, 7, 1, 7, 3, 7, 282, 8, 7, 1, 7, 1, + 7, 1, 7, 3, 7, 287, 8, 7, 1, 7, 3, 7, 290, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, + 1, 7, 3, 7, 297, 8, 7, 1, 7, 3, 7, 300, 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 305, + 8, 7, 1, 7, 3, 7, 308, 8, 7, 1, 7, 1, 7, 3, 7, 312, 8, 7, 1, 7, 3, 7, 315, + 8, 7, 1, 7, 1, 7, 1, 7, 3, 7, 320, 8, 7, 1, 7, 3, 7, 323, 8, 7, 3, 7, 325, + 8, 7, 1, 7, 1, 7, 3, 7, 329, 8, 7, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 335, 8, + 7, 5, 7, 337, 8, 7, 10, 7, 12, 7, 340, 9, 7, 1, 8, 1, 8, 1, 8, 1, 9, 1, + 9, 1, 9, 1, 9, 1, 9, 5, 9, 350, 8, 9, 10, 9, 12, 9, 353, 9, 9, 1, 9, 1, + 9, 1, 9, 1, 9, 1, 9, 5, 9, 360, 8, 9, 10, 9, 12, 9, 363, 9, 9, 1, 9, 1, + 9, 3, 9, 367, 8, 9, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, + 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 383, 8, 12, 1, 12, + 1, 12, 1, 12, 3, 12, 388, 8, 12, 5, 12, 390, 8, 12, 10, 12, 12, 12, 393, + 9, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 399, 8, 13, 1, 14, 1, 14, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 419, 8, 15, 1, 15, 1, 15, 1, + 15, 3, 15, 424, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, + 432, 8, 15, 10, 15, 12, 15, 435, 9, 15, 1, 15, 3, 15, 438, 8, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, + 15, 451, 8, 15, 10, 15, 12, 15, 454, 9, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 3, 15, 460, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 489, + 8, 15, 1, 15, 1, 15, 3, 15, 493, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, + 15, 3, 15, 500, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 3, 15, 512, 8, 15, 1, 15, 1, 15, 1, 15, 3, 15, 517, + 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 524, 8, 15, 10, 15, 12, + 15, 527, 9, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 3, 15, 537, 8, 15, 5, 15, 539, 8, 15, 10, 15, 12, 15, 542, 9, 15, 1, 16, + 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 5, 17, 553, 8, + 17, 10, 17, 12, 17, 556, 9, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 5, 18, + 563, 8, 18, 10, 18, 12, 18, 566, 9, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, + 19, 1, 19, 3, 19, 574, 8, 19, 1, 19, 3, 19, 577, 8, 19, 1, 19, 1, 19, 1, + 19, 3, 19, 582, 8, 19, 1, 19, 1, 19, 5, 19, 586, 8, 19, 10, 19, 12, 19, + 589, 9, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 3, 20, 597, 8, 20, + 1, 20, 1, 20, 3, 20, 601, 8, 20, 1, 20, 1, 20, 3, 20, 605, 8, 20, 3, 20, + 607, 8, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 3, 22, 614, 8, 22, 1, 22, + 1, 22, 1, 22, 1, 22, 3, 22, 620, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, + 23, 5, 23, 627, 8, 23, 10, 23, 12, 23, 630, 9, 23, 1, 23, 1, 23, 1, 24, + 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, + 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, + 33, 1, 33, 1, 33, 1, 33, 1, 33, 5, 33, 671, 8, 33, 10, 33, 12, 33, 674, + 9, 33, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 3, 35, 681, 8, 35, 1, 36, 1, + 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, + 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, + 47, 1, 47, 1, 48, 1, 48, 1, 48, 3, 48, 710, 8, 48, 1, 48, 1, 48, 1, 48, + 3, 48, 715, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 722, 8, 48, + 1, 49, 1, 49, 3, 49, 726, 8, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, + 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 738, 8, 52, 1, 53, 1, 53, 1, 54, + 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, + 59, 1, 59, 1, 59, 0, 3, 8, 14, 30, 60, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, + 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, + 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, + 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 0, 9, + 2, 0, 4, 4, 25, 25, 2, 0, 9, 9, 24, 24, 3, 0, 63, 63, 140, 140, 142, 142, + 3, 0, 67, 67, 71, 71, 84, 85, 1, 0, 137, 138, 1, 0, 139, 140, 1, 0, 129, + 130, 1, 0, 117, 118, 1, 0, 4, 105, 828, 0, 120, 1, 0, 0, 0, 2, 129, 1, + 0, 0, 0, 4, 132, 1, 0, 0, 0, 6, 135, 1, 0, 0, 0, 8, 156, 1, 0, 0, 0, 10, + 172, 1, 0, 0, 0, 12, 238, 1, 0, 0, 0, 14, 324, 1, 0, 0, 0, 16, 341, 1, + 0, 0, 0, 18, 344, 1, 0, 0, 0, 20, 368, 1, 0, 0, 0, 22, 371, 1, 0, 0, 0, + 24, 378, 1, 0, 0, 0, 26, 394, 1, 0, 0, 0, 28, 400, 1, 0, 0, 0, 30, 459, + 1, 0, 0, 0, 32, 543, 1, 0, 0, 0, 34, 550, 1, 0, 0, 0, 36, 557, 1, 0, 0, + 0, 38, 569, 1, 0, 0, 0, 40, 606, 1, 0, 0, 0, 42, 608, 1, 0, 0, 0, 44, 619, + 1, 0, 0, 0, 46, 621, 1, 0, 0, 0, 48, 633, 1, 0, 0, 0, 50, 635, 1, 0, 0, + 0, 52, 640, 1, 0, 0, 0, 54, 645, 1, 0, 0, 0, 56, 647, 1, 0, 0, 0, 58, 649, + 1, 0, 0, 0, 60, 651, 1, 0, 0, 0, 62, 653, 1, 0, 0, 0, 64, 655, 1, 0, 0, + 0, 66, 657, 1, 0, 0, 0, 68, 675, 1, 0, 0, 0, 70, 677, 1, 0, 0, 0, 72, 682, + 1, 0, 0, 0, 74, 684, 1, 0, 0, 0, 76, 686, 1, 0, 0, 0, 78, 688, 1, 0, 0, + 0, 80, 690, 1, 0, 0, 0, 82, 692, 1, 0, 0, 0, 84, 694, 1, 0, 0, 0, 86, 696, + 1, 0, 0, 0, 88, 698, 1, 0, 0, 0, 90, 700, 1, 0, 0, 0, 92, 702, 1, 0, 0, + 0, 94, 704, 1, 0, 0, 0, 96, 721, 1, 0, 0, 0, 98, 725, 1, 0, 0, 0, 100, + 727, 1, 0, 0, 0, 102, 729, 1, 0, 0, 0, 104, 737, 1, 0, 0, 0, 106, 739, + 1, 0, 0, 0, 108, 741, 1, 0, 0, 0, 110, 743, 1, 0, 0, 0, 112, 745, 1, 0, + 0, 0, 114, 747, 1, 0, 0, 0, 116, 749, 1, 0, 0, 0, 118, 752, 1, 0, 0, 0, + 120, 121, 3, 2, 1, 0, 121, 122, 5, 0, 0, 1, 122, 1, 1, 0, 0, 0, 123, 125, + 3, 4, 2, 0, 124, 126, 5, 3, 0, 0, 125, 124, 1, 0, 0, 0, 125, 126, 1, 0, + 0, 0, 126, 128, 1, 0, 0, 0, 127, 123, 1, 0, 0, 0, 128, 131, 1, 0, 0, 0, + 129, 127, 1, 0, 0, 0, 129, 130, 1, 0, 0, 0, 130, 3, 1, 0, 0, 0, 131, 129, + 1, 0, 0, 0, 132, 133, 3, 6, 3, 0, 133, 5, 1, 0, 0, 0, 134, 136, 3, 66, + 33, 0, 135, 134, 1, 0, 0, 0, 135, 136, 1, 0, 0, 0, 136, 137, 1, 0, 0, 0, + 137, 138, 3, 8, 4, 0, 138, 7, 1, 0, 0, 0, 139, 140, 6, 4, -1, 0, 140, 142, + 3, 10, 5, 0, 141, 143, 3, 24, 12, 0, 142, 141, 1, 0, 0, 0, 142, 143, 1, + 0, 0, 0, 143, 145, 1, 0, 0, 0, 144, 146, 3, 26, 13, 0, 145, 144, 1, 0, + 0, 0, 145, 146, 1, 0, 0, 0, 146, 157, 1, 0, 0, 0, 147, 148, 5, 122, 0, + 0, 148, 149, 3, 8, 4, 0, 149, 151, 5, 123, 0, 0, 150, 152, 3, 24, 12, 0, + 151, 150, 1, 0, 0, 0, 151, 152, 1, 0, 0, 0, 152, 154, 1, 0, 0, 0, 153, + 155, 3, 26, 13, 0, 154, 153, 1, 0, 0, 0, 154, 155, 1, 0, 0, 0, 155, 157, + 1, 0, 0, 0, 156, 139, 1, 0, 0, 0, 156, 147, 1, 0, 0, 0, 157, 169, 1, 0, + 0, 0, 158, 159, 10, 1, 0, 0, 159, 160, 3, 44, 22, 0, 160, 162, 3, 8, 4, + 0, 161, 163, 3, 24, 12, 0, 162, 161, 1, 0, 0, 0, 162, 163, 1, 0, 0, 0, + 163, 165, 1, 0, 0, 0, 164, 166, 3, 26, 13, 0, 165, 164, 1, 0, 0, 0, 165, + 166, 1, 0, 0, 0, 166, 168, 1, 0, 0, 0, 167, 158, 1, 0, 0, 0, 168, 171, + 1, 0, 0, 0, 169, 167, 1, 0, 0, 0, 169, 170, 1, 0, 0, 0, 170, 9, 1, 0, 0, + 0, 171, 169, 1, 0, 0, 0, 172, 174, 5, 86, 0, 0, 173, 175, 7, 0, 0, 0, 174, + 173, 1, 0, 0, 0, 174, 175, 1, 0, 0, 0, 175, 196, 1, 0, 0, 0, 176, 178, + 3, 30, 15, 0, 177, 176, 1, 0, 0, 0, 177, 178, 1, 0, 0, 0, 178, 180, 1, + 0, 0, 0, 179, 181, 5, 120, 0, 0, 180, 179, 1, 0, 0, 0, 180, 181, 1, 0, + 0, 0, 181, 182, 1, 0, 0, 0, 182, 184, 5, 137, 0, 0, 183, 185, 3, 36, 18, + 0, 184, 183, 1, 0, 0, 0, 184, 185, 1, 0, 0, 0, 185, 187, 1, 0, 0, 0, 186, + 188, 3, 38, 19, 0, 187, 186, 1, 0, 0, 0, 187, 188, 1, 0, 0, 0, 188, 197, + 1, 0, 0, 0, 189, 194, 3, 30, 15, 0, 190, 192, 5, 8, 0, 0, 191, 190, 1, + 0, 0, 0, 191, 192, 1, 0, 0, 0, 192, 193, 1, 0, 0, 0, 193, 195, 3, 72, 36, + 0, 194, 191, 1, 0, 0, 0, 194, 195, 1, 0, 0, 0, 195, 197, 1, 0, 0, 0, 196, + 177, 1, 0, 0, 0, 196, 189, 1, 0, 0, 0, 197, 220, 1, 0, 0, 0, 198, 216, + 5, 141, 0, 0, 199, 201, 3, 30, 15, 0, 200, 199, 1, 0, 0, 0, 200, 201, 1, + 0, 0, 0, 201, 202, 1, 0, 0, 0, 202, 204, 5, 137, 0, 0, 203, 205, 3, 36, + 18, 0, 204, 203, 1, 0, 0, 0, 204, 205, 1, 0, 0, 0, 205, 207, 1, 0, 0, 0, + 206, 208, 3, 38, 19, 0, 207, 206, 1, 0, 0, 0, 207, 208, 1, 0, 0, 0, 208, + 217, 1, 0, 0, 0, 209, 214, 3, 30, 15, 0, 210, 212, 5, 8, 0, 0, 211, 210, + 1, 0, 0, 0, 211, 212, 1, 0, 0, 0, 212, 213, 1, 0, 0, 0, 213, 215, 3, 72, + 36, 0, 214, 211, 1, 0, 0, 0, 214, 215, 1, 0, 0, 0, 215, 217, 1, 0, 0, 0, + 216, 200, 1, 0, 0, 0, 216, 209, 1, 0, 0, 0, 217, 219, 1, 0, 0, 0, 218, + 198, 1, 0, 0, 0, 219, 222, 1, 0, 0, 0, 220, 218, 1, 0, 0, 0, 220, 221, + 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 220, 1, 0, 0, 0, 223, 225, 3, 12, + 6, 0, 224, 223, 1, 0, 0, 0, 224, 225, 1, 0, 0, 0, 225, 227, 1, 0, 0, 0, + 226, 228, 3, 16, 8, 0, 227, 226, 1, 0, 0, 0, 227, 228, 1, 0, 0, 0, 228, + 230, 1, 0, 0, 0, 229, 231, 3, 18, 9, 0, 230, 229, 1, 0, 0, 0, 230, 231, + 1, 0, 0, 0, 231, 233, 1, 0, 0, 0, 232, 234, 3, 20, 10, 0, 233, 232, 1, + 0, 0, 0, 233, 234, 1, 0, 0, 0, 234, 236, 1, 0, 0, 0, 235, 237, 3, 22, 11, + 0, 236, 235, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 11, 1, 0, 0, 0, 238, + 239, 5, 38, 0, 0, 239, 244, 3, 14, 7, 0, 240, 241, 5, 141, 0, 0, 241, 243, + 3, 14, 7, 0, 242, 240, 1, 0, 0, 0, 243, 246, 1, 0, 0, 0, 244, 242, 1, 0, + 0, 0, 244, 245, 1, 0, 0, 0, 245, 13, 1, 0, 0, 0, 246, 244, 1, 0, 0, 0, + 247, 248, 6, 7, -1, 0, 248, 253, 3, 96, 48, 0, 249, 251, 5, 8, 0, 0, 250, + 249, 1, 0, 0, 0, 250, 251, 1, 0, 0, 0, 251, 252, 1, 0, 0, 0, 252, 254, + 3, 72, 36, 0, 253, 250, 1, 0, 0, 0, 253, 254, 1, 0, 0, 0, 254, 261, 1, + 0, 0, 0, 255, 256, 5, 37, 0, 0, 256, 257, 5, 90, 0, 0, 257, 258, 5, 93, + 0, 0, 258, 259, 5, 8, 0, 0, 259, 260, 5, 66, 0, 0, 260, 262, 3, 104, 52, + 0, 261, 255, 1, 0, 0, 0, 261, 262, 1, 0, 0, 0, 262, 325, 1, 0, 0, 0, 263, + 264, 5, 122, 0, 0, 264, 265, 3, 6, 3, 0, 265, 270, 5, 123, 0, 0, 266, 268, + 5, 8, 0, 0, 267, 266, 1, 0, 0, 0, 267, 268, 1, 0, 0, 0, 268, 269, 1, 0, + 0, 0, 269, 271, 3, 72, 36, 0, 270, 267, 1, 0, 0, 0, 270, 271, 1, 0, 0, + 0, 271, 325, 1, 0, 0, 0, 272, 325, 3, 48, 24, 0, 273, 274, 5, 99, 0, 0, + 274, 275, 5, 122, 0, 0, 275, 276, 3, 52, 26, 0, 276, 281, 5, 123, 0, 0, + 277, 279, 5, 8, 0, 0, 278, 277, 1, 0, 0, 0, 278, 279, 1, 0, 0, 0, 279, + 280, 1, 0, 0, 0, 280, 282, 3, 72, 36, 0, 281, 278, 1, 0, 0, 0, 281, 282, + 1, 0, 0, 0, 282, 289, 1, 0, 0, 0, 283, 284, 5, 104, 0, 0, 284, 286, 5, + 67, 0, 0, 285, 287, 5, 8, 0, 0, 286, 285, 1, 0, 0, 0, 286, 287, 1, 0, 0, + 0, 287, 288, 1, 0, 0, 0, 288, 290, 3, 72, 36, 0, 289, 283, 1, 0, 0, 0, + 289, 290, 1, 0, 0, 0, 290, 325, 1, 0, 0, 0, 291, 292, 5, 99, 0, 0, 292, + 293, 5, 122, 0, 0, 293, 294, 3, 54, 27, 0, 294, 299, 5, 123, 0, 0, 295, + 297, 5, 8, 0, 0, 296, 295, 1, 0, 0, 0, 296, 297, 1, 0, 0, 0, 297, 298, + 1, 0, 0, 0, 298, 300, 3, 72, 36, 0, 299, 296, 1, 0, 0, 0, 299, 300, 1, + 0, 0, 0, 300, 307, 1, 0, 0, 0, 301, 302, 5, 104, 0, 0, 302, 304, 5, 67, + 0, 0, 303, 305, 5, 8, 0, 0, 304, 303, 1, 0, 0, 0, 304, 305, 1, 0, 0, 0, + 305, 306, 1, 0, 0, 0, 306, 308, 3, 72, 36, 0, 307, 301, 1, 0, 0, 0, 307, + 308, 1, 0, 0, 0, 308, 325, 1, 0, 0, 0, 309, 314, 3, 54, 27, 0, 310, 312, + 5, 8, 0, 0, 311, 310, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 313, 1, 0, + 0, 0, 313, 315, 3, 72, 36, 0, 314, 311, 1, 0, 0, 0, 314, 315, 1, 0, 0, + 0, 315, 322, 1, 0, 0, 0, 316, 317, 5, 104, 0, 0, 317, 319, 5, 67, 0, 0, + 318, 320, 5, 8, 0, 0, 319, 318, 1, 0, 0, 0, 319, 320, 1, 0, 0, 0, 320, + 321, 1, 0, 0, 0, 321, 323, 3, 72, 36, 0, 322, 316, 1, 0, 0, 0, 322, 323, + 1, 0, 0, 0, 323, 325, 1, 0, 0, 0, 324, 247, 1, 0, 0, 0, 324, 263, 1, 0, + 0, 0, 324, 272, 1, 0, 0, 0, 324, 273, 1, 0, 0, 0, 324, 291, 1, 0, 0, 0, + 324, 309, 1, 0, 0, 0, 325, 338, 1, 0, 0, 0, 326, 328, 10, 6, 0, 0, 327, + 329, 3, 40, 20, 0, 328, 327, 1, 0, 0, 0, 328, 329, 1, 0, 0, 0, 329, 330, + 1, 0, 0, 0, 330, 331, 5, 53, 0, 0, 331, 334, 3, 14, 7, 0, 332, 335, 3, + 42, 21, 0, 333, 335, 3, 46, 23, 0, 334, 332, 1, 0, 0, 0, 334, 333, 1, 0, + 0, 0, 335, 337, 1, 0, 0, 0, 336, 326, 1, 0, 0, 0, 337, 340, 1, 0, 0, 0, + 338, 336, 1, 0, 0, 0, 338, 339, 1, 0, 0, 0, 339, 15, 1, 0, 0, 0, 340, 338, + 1, 0, 0, 0, 341, 342, 5, 102, 0, 0, 342, 343, 3, 56, 28, 0, 343, 17, 1, + 0, 0, 0, 344, 345, 5, 40, 0, 0, 345, 366, 5, 13, 0, 0, 346, 351, 3, 30, + 15, 0, 347, 348, 5, 141, 0, 0, 348, 350, 3, 30, 15, 0, 349, 347, 1, 0, + 0, 0, 350, 353, 1, 0, 0, 0, 351, 349, 1, 0, 0, 0, 351, 352, 1, 0, 0, 0, + 352, 367, 1, 0, 0, 0, 353, 351, 1, 0, 0, 0, 354, 355, 5, 82, 0, 0, 355, + 356, 5, 122, 0, 0, 356, 361, 3, 30, 15, 0, 357, 358, 5, 141, 0, 0, 358, + 360, 3, 30, 15, 0, 359, 357, 1, 0, 0, 0, 360, 363, 1, 0, 0, 0, 361, 359, + 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 364, 1, 0, 0, 0, 363, 361, 1, 0, + 0, 0, 364, 365, 5, 123, 0, 0, 365, 367, 1, 0, 0, 0, 366, 346, 1, 0, 0, + 0, 366, 354, 1, 0, 0, 0, 367, 19, 1, 0, 0, 0, 368, 369, 5, 44, 0, 0, 369, + 370, 3, 56, 28, 0, 370, 21, 1, 0, 0, 0, 371, 372, 5, 103, 0, 0, 372, 373, + 3, 58, 29, 0, 373, 374, 5, 8, 0, 0, 374, 375, 5, 122, 0, 0, 375, 376, 3, + 60, 30, 0, 376, 377, 5, 123, 0, 0, 377, 23, 1, 0, 0, 0, 378, 379, 5, 70, + 0, 0, 379, 380, 5, 13, 0, 0, 380, 382, 3, 30, 15, 0, 381, 383, 7, 1, 0, + 0, 382, 381, 1, 0, 0, 0, 382, 383, 1, 0, 0, 0, 383, 391, 1, 0, 0, 0, 384, + 385, 5, 141, 0, 0, 385, 387, 3, 30, 15, 0, 386, 388, 7, 1, 0, 0, 387, 386, + 1, 0, 0, 0, 387, 388, 1, 0, 0, 0, 388, 390, 1, 0, 0, 0, 389, 384, 1, 0, + 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, + 392, 25, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 394, 395, 5, 57, 0, 0, 395, + 398, 3, 62, 31, 0, 396, 397, 5, 67, 0, 0, 397, 399, 3, 64, 32, 0, 398, + 396, 1, 0, 0, 0, 398, 399, 1, 0, 0, 0, 399, 27, 1, 0, 0, 0, 400, 401, 7, + 2, 0, 0, 401, 29, 1, 0, 0, 0, 402, 403, 6, 15, -1, 0, 403, 460, 3, 98, + 49, 0, 404, 460, 3, 104, 52, 0, 405, 406, 3, 74, 37, 0, 406, 407, 5, 124, + 0, 0, 407, 408, 7, 3, 0, 0, 408, 409, 5, 122, 0, 0, 409, 410, 3, 30, 15, + 0, 410, 411, 5, 123, 0, 0, 411, 412, 5, 125, 0, 0, 412, 460, 1, 0, 0, 0, + 413, 414, 3, 28, 14, 0, 414, 415, 3, 30, 15, 20, 415, 460, 1, 0, 0, 0, + 416, 418, 5, 52, 0, 0, 417, 419, 5, 63, 0, 0, 418, 417, 1, 0, 0, 0, 418, + 419, 1, 0, 0, 0, 419, 420, 1, 0, 0, 0, 420, 460, 5, 96, 0, 0, 421, 423, + 5, 52, 0, 0, 422, 424, 5, 63, 0, 0, 423, 422, 1, 0, 0, 0, 423, 424, 1, + 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 460, 5, 34, 0, 0, 426, 427, 3, 84, + 42, 0, 427, 437, 5, 122, 0, 0, 428, 433, 3, 30, 15, 0, 429, 430, 5, 141, + 0, 0, 430, 432, 3, 30, 15, 0, 431, 429, 1, 0, 0, 0, 432, 435, 1, 0, 0, + 0, 433, 431, 1, 0, 0, 0, 433, 434, 1, 0, 0, 0, 434, 438, 1, 0, 0, 0, 435, + 433, 1, 0, 0, 0, 436, 438, 5, 137, 0, 0, 437, 428, 1, 0, 0, 0, 437, 436, + 1, 0, 0, 0, 438, 439, 1, 0, 0, 0, 439, 440, 5, 123, 0, 0, 440, 460, 1, + 0, 0, 0, 441, 460, 3, 32, 16, 0, 442, 443, 5, 122, 0, 0, 443, 444, 3, 30, + 15, 0, 444, 445, 5, 123, 0, 0, 445, 460, 1, 0, 0, 0, 446, 447, 5, 124, + 0, 0, 447, 452, 3, 30, 15, 0, 448, 449, 5, 141, 0, 0, 449, 451, 3, 30, + 15, 0, 450, 448, 1, 0, 0, 0, 451, 454, 1, 0, 0, 0, 452, 450, 1, 0, 0, 0, + 452, 453, 1, 0, 0, 0, 453, 455, 1, 0, 0, 0, 454, 452, 1, 0, 0, 0, 455, + 456, 5, 125, 0, 0, 456, 460, 1, 0, 0, 0, 457, 460, 3, 34, 17, 0, 458, 460, + 3, 118, 59, 0, 459, 402, 1, 0, 0, 0, 459, 404, 1, 0, 0, 0, 459, 405, 1, + 0, 0, 0, 459, 413, 1, 0, 0, 0, 459, 416, 1, 0, 0, 0, 459, 421, 1, 0, 0, + 0, 459, 426, 1, 0, 0, 0, 459, 441, 1, 0, 0, 0, 459, 442, 1, 0, 0, 0, 459, + 446, 1, 0, 0, 0, 459, 457, 1, 0, 0, 0, 459, 458, 1, 0, 0, 0, 460, 540, + 1, 0, 0, 0, 461, 462, 10, 19, 0, 0, 462, 463, 7, 4, 0, 0, 463, 539, 3, + 30, 15, 20, 464, 465, 10, 18, 0, 0, 465, 466, 7, 5, 0, 0, 466, 539, 3, + 30, 15, 19, 467, 468, 10, 17, 0, 0, 468, 469, 7, 6, 0, 0, 469, 539, 3, + 30, 15, 18, 470, 471, 10, 16, 0, 0, 471, 472, 5, 135, 0, 0, 472, 539, 3, + 30, 15, 17, 473, 474, 10, 15, 0, 0, 474, 475, 5, 143, 0, 0, 475, 539, 3, + 30, 15, 16, 476, 477, 10, 14, 0, 0, 477, 478, 5, 136, 0, 0, 478, 539, 3, + 30, 15, 15, 479, 499, 10, 13, 0, 0, 480, 500, 5, 126, 0, 0, 481, 500, 5, + 127, 0, 0, 482, 500, 5, 128, 0, 0, 483, 500, 5, 131, 0, 0, 484, 500, 5, + 132, 0, 0, 485, 500, 5, 133, 0, 0, 486, 500, 5, 134, 0, 0, 487, 489, 5, + 63, 0, 0, 488, 487, 1, 0, 0, 0, 488, 489, 1, 0, 0, 0, 489, 490, 1, 0, 0, + 0, 490, 500, 5, 56, 0, 0, 491, 493, 5, 63, 0, 0, 492, 491, 1, 0, 0, 0, + 492, 493, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0, 494, 495, 5, 12, 0, 0, 495, + 496, 3, 30, 15, 0, 496, 497, 5, 5, 0, 0, 497, 498, 3, 30, 15, 0, 498, 500, + 1, 0, 0, 0, 499, 480, 1, 0, 0, 0, 499, 481, 1, 0, 0, 0, 499, 482, 1, 0, + 0, 0, 499, 483, 1, 0, 0, 0, 499, 484, 1, 0, 0, 0, 499, 485, 1, 0, 0, 0, + 499, 486, 1, 0, 0, 0, 499, 488, 1, 0, 0, 0, 499, 492, 1, 0, 0, 0, 500, + 501, 1, 0, 0, 0, 501, 539, 3, 30, 15, 14, 502, 503, 10, 8, 0, 0, 503, 504, + 5, 5, 0, 0, 504, 539, 3, 30, 15, 9, 505, 506, 10, 7, 0, 0, 506, 507, 5, + 69, 0, 0, 507, 539, 3, 30, 15, 8, 508, 509, 10, 12, 0, 0, 509, 511, 5, + 52, 0, 0, 510, 512, 5, 63, 0, 0, 511, 510, 1, 0, 0, 0, 511, 512, 1, 0, + 0, 0, 512, 513, 1, 0, 0, 0, 513, 539, 5, 64, 0, 0, 514, 516, 10, 9, 0, + 0, 515, 517, 5, 63, 0, 0, 516, 515, 1, 0, 0, 0, 516, 517, 1, 0, 0, 0, 517, + 518, 1, 0, 0, 0, 518, 536, 5, 47, 0, 0, 519, 520, 5, 122, 0, 0, 520, 525, + 3, 30, 15, 0, 521, 522, 5, 141, 0, 0, 522, 524, 3, 30, 15, 0, 523, 521, + 1, 0, 0, 0, 524, 527, 1, 0, 0, 0, 525, 523, 1, 0, 0, 0, 525, 526, 1, 0, + 0, 0, 526, 528, 1, 0, 0, 0, 527, 525, 1, 0, 0, 0, 528, 529, 5, 123, 0, + 0, 529, 537, 1, 0, 0, 0, 530, 537, 3, 6, 3, 0, 531, 532, 5, 99, 0, 0, 532, + 533, 5, 122, 0, 0, 533, 534, 3, 52, 26, 0, 534, 535, 5, 123, 0, 0, 535, + 537, 1, 0, 0, 0, 536, 519, 1, 0, 0, 0, 536, 530, 1, 0, 0, 0, 536, 531, + 1, 0, 0, 0, 537, 539, 1, 0, 0, 0, 538, 461, 1, 0, 0, 0, 538, 464, 1, 0, + 0, 0, 538, 467, 1, 0, 0, 0, 538, 470, 1, 0, 0, 0, 538, 473, 1, 0, 0, 0, + 538, 476, 1, 0, 0, 0, 538, 479, 1, 0, 0, 0, 538, 502, 1, 0, 0, 0, 538, + 505, 1, 0, 0, 0, 538, 508, 1, 0, 0, 0, 538, 514, 1, 0, 0, 0, 539, 542, + 1, 0, 0, 0, 540, 538, 1, 0, 0, 0, 540, 541, 1, 0, 0, 0, 541, 31, 1, 0, + 0, 0, 542, 540, 1, 0, 0, 0, 543, 544, 5, 15, 0, 0, 544, 545, 5, 122, 0, + 0, 545, 546, 3, 30, 15, 0, 546, 547, 5, 8, 0, 0, 547, 548, 3, 82, 41, 0, + 548, 549, 5, 123, 0, 0, 549, 33, 1, 0, 0, 0, 550, 554, 3, 68, 34, 0, 551, + 553, 3, 70, 35, 0, 552, 551, 1, 0, 0, 0, 553, 556, 1, 0, 0, 0, 554, 552, + 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 35, 1, 0, 0, 0, 556, 554, 1, 0, + 0, 0, 557, 558, 5, 30, 0, 0, 558, 559, 5, 122, 0, 0, 559, 564, 3, 76, 38, + 0, 560, 561, 5, 141, 0, 0, 561, 563, 3, 76, 38, 0, 562, 560, 1, 0, 0, 0, + 563, 566, 1, 0, 0, 0, 564, 562, 1, 0, 0, 0, 564, 565, 1, 0, 0, 0, 565, + 567, 1, 0, 0, 0, 566, 564, 1, 0, 0, 0, 567, 568, 5, 123, 0, 0, 568, 37, + 1, 0, 0, 0, 569, 570, 5, 79, 0, 0, 570, 571, 5, 122, 0, 0, 571, 576, 3, + 30, 15, 0, 572, 574, 5, 8, 0, 0, 573, 572, 1, 0, 0, 0, 573, 574, 1, 0, + 0, 0, 574, 575, 1, 0, 0, 0, 575, 577, 3, 72, 36, 0, 576, 573, 1, 0, 0, + 0, 576, 577, 1, 0, 0, 0, 577, 587, 1, 0, 0, 0, 578, 579, 5, 141, 0, 0, + 579, 581, 3, 30, 15, 0, 580, 582, 5, 8, 0, 0, 581, 580, 1, 0, 0, 0, 581, + 582, 1, 0, 0, 0, 582, 583, 1, 0, 0, 0, 583, 584, 3, 72, 36, 0, 584, 586, + 1, 0, 0, 0, 585, 578, 1, 0, 0, 0, 586, 589, 1, 0, 0, 0, 587, 585, 1, 0, + 0, 0, 587, 588, 1, 0, 0, 0, 588, 590, 1, 0, 0, 0, 589, 587, 1, 0, 0, 0, + 590, 591, 5, 123, 0, 0, 591, 39, 1, 0, 0, 0, 592, 607, 5, 48, 0, 0, 593, + 607, 5, 19, 0, 0, 594, 596, 5, 39, 0, 0, 595, 597, 5, 72, 0, 0, 596, 595, + 1, 0, 0, 0, 596, 597, 1, 0, 0, 0, 597, 607, 1, 0, 0, 0, 598, 600, 5, 55, + 0, 0, 599, 601, 5, 72, 0, 0, 600, 599, 1, 0, 0, 0, 600, 601, 1, 0, 0, 0, + 601, 607, 1, 0, 0, 0, 602, 604, 5, 81, 0, 0, 603, 605, 5, 72, 0, 0, 604, + 603, 1, 0, 0, 0, 604, 605, 1, 0, 0, 0, 605, 607, 1, 0, 0, 0, 606, 592, + 1, 0, 0, 0, 606, 593, 1, 0, 0, 0, 606, 594, 1, 0, 0, 0, 606, 598, 1, 0, + 0, 0, 606, 602, 1, 0, 0, 0, 607, 41, 1, 0, 0, 0, 608, 609, 5, 68, 0, 0, + 609, 610, 3, 56, 28, 0, 610, 43, 1, 0, 0, 0, 611, 613, 5, 98, 0, 0, 612, + 614, 7, 0, 0, 0, 613, 612, 1, 0, 0, 0, 613, 614, 1, 0, 0, 0, 614, 620, + 1, 0, 0, 0, 615, 616, 5, 49, 0, 0, 616, 620, 5, 25, 0, 0, 617, 618, 5, + 30, 0, 0, 618, 620, 5, 25, 0, 0, 619, 611, 1, 0, 0, 0, 619, 615, 1, 0, + 0, 0, 619, 617, 1, 0, 0, 0, 620, 45, 1, 0, 0, 0, 621, 622, 5, 100, 0, 0, + 622, 623, 5, 122, 0, 0, 623, 628, 3, 86, 43, 0, 624, 625, 5, 141, 0, 0, + 625, 627, 3, 86, 43, 0, 626, 624, 1, 0, 0, 0, 627, 630, 1, 0, 0, 0, 628, + 626, 1, 0, 0, 0, 628, 629, 1, 0, 0, 0, 629, 631, 1, 0, 0, 0, 630, 628, + 1, 0, 0, 0, 631, 632, 5, 123, 0, 0, 632, 47, 1, 0, 0, 0, 633, 634, 1, 0, + 0, 0, 634, 49, 1, 0, 0, 0, 635, 636, 5, 89, 0, 0, 636, 637, 5, 127, 0, + 0, 637, 638, 3, 82, 41, 0, 638, 639, 5, 128, 0, 0, 639, 51, 1, 0, 0, 0, + 640, 641, 5, 7, 0, 0, 641, 642, 5, 127, 0, 0, 642, 643, 3, 82, 41, 0, 643, + 644, 5, 128, 0, 0, 644, 53, 1, 0, 0, 0, 645, 646, 1, 0, 0, 0, 646, 55, + 1, 0, 0, 0, 647, 648, 3, 30, 15, 0, 648, 57, 1, 0, 0, 0, 649, 650, 1, 0, + 0, 0, 650, 59, 1, 0, 0, 0, 651, 652, 1, 0, 0, 0, 652, 61, 1, 0, 0, 0, 653, + 654, 3, 98, 49, 0, 654, 63, 1, 0, 0, 0, 655, 656, 3, 98, 49, 0, 656, 65, + 1, 0, 0, 0, 657, 658, 5, 104, 0, 0, 658, 659, 3, 78, 39, 0, 659, 660, 5, + 8, 0, 0, 660, 661, 5, 122, 0, 0, 661, 662, 3, 8, 4, 0, 662, 672, 5, 123, + 0, 0, 663, 664, 5, 141, 0, 0, 664, 665, 3, 78, 39, 0, 665, 666, 5, 8, 0, + 0, 666, 667, 5, 122, 0, 0, 667, 668, 3, 8, 4, 0, 668, 669, 5, 123, 0, 0, + 669, 671, 1, 0, 0, 0, 670, 663, 1, 0, 0, 0, 671, 674, 1, 0, 0, 0, 672, + 670, 1, 0, 0, 0, 672, 673, 1, 0, 0, 0, 673, 67, 1, 0, 0, 0, 674, 672, 1, + 0, 0, 0, 675, 676, 7, 7, 0, 0, 676, 69, 1, 0, 0, 0, 677, 680, 5, 120, 0, + 0, 678, 681, 3, 68, 34, 0, 679, 681, 3, 118, 59, 0, 680, 678, 1, 0, 0, + 0, 680, 679, 1, 0, 0, 0, 681, 71, 1, 0, 0, 0, 682, 683, 3, 68, 34, 0, 683, + 73, 1, 0, 0, 0, 684, 685, 3, 68, 34, 0, 685, 75, 1, 0, 0, 0, 686, 687, + 3, 68, 34, 0, 687, 77, 1, 0, 0, 0, 688, 689, 3, 68, 34, 0, 689, 79, 1, + 0, 0, 0, 690, 691, 3, 68, 34, 0, 691, 81, 1, 0, 0, 0, 692, 693, 3, 68, + 34, 0, 693, 83, 1, 0, 0, 0, 694, 695, 3, 68, 34, 0, 695, 85, 1, 0, 0, 0, + 696, 697, 3, 68, 34, 0, 697, 87, 1, 0, 0, 0, 698, 699, 3, 68, 34, 0, 699, + 89, 1, 0, 0, 0, 700, 701, 3, 68, 34, 0, 701, 91, 1, 0, 0, 0, 702, 703, + 3, 68, 34, 0, 703, 93, 1, 0, 0, 0, 704, 705, 3, 68, 34, 0, 705, 95, 1, + 0, 0, 0, 706, 707, 3, 90, 45, 0, 707, 708, 5, 120, 0, 0, 708, 710, 1, 0, + 0, 0, 709, 706, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, + 711, 712, 3, 80, 40, 0, 712, 713, 5, 120, 0, 0, 713, 715, 1, 0, 0, 0, 714, + 709, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 722, + 3, 94, 47, 0, 717, 718, 5, 121, 0, 0, 718, 719, 3, 96, 48, 0, 719, 720, + 5, 121, 0, 0, 720, 722, 1, 0, 0, 0, 721, 714, 1, 0, 0, 0, 721, 717, 1, + 0, 0, 0, 722, 97, 1, 0, 0, 0, 723, 726, 3, 100, 50, 0, 724, 726, 3, 102, + 51, 0, 725, 723, 1, 0, 0, 0, 725, 724, 1, 0, 0, 0, 726, 99, 1, 0, 0, 0, + 727, 728, 5, 106, 0, 0, 728, 101, 1, 0, 0, 0, 729, 730, 5, 107, 0, 0, 730, + 103, 1, 0, 0, 0, 731, 738, 3, 106, 53, 0, 732, 738, 3, 108, 54, 0, 733, + 738, 3, 110, 55, 0, 734, 738, 3, 112, 56, 0, 735, 738, 3, 114, 57, 0, 736, + 738, 3, 116, 58, 0, 737, 731, 1, 0, 0, 0, 737, 732, 1, 0, 0, 0, 737, 733, + 1, 0, 0, 0, 737, 734, 1, 0, 0, 0, 737, 735, 1, 0, 0, 0, 737, 736, 1, 0, + 0, 0, 738, 105, 1, 0, 0, 0, 739, 740, 5, 112, 0, 0, 740, 107, 1, 0, 0, + 0, 741, 742, 5, 113, 0, 0, 742, 109, 1, 0, 0, 0, 743, 744, 5, 114, 0, 0, + 744, 111, 1, 0, 0, 0, 745, 746, 5, 115, 0, 0, 746, 113, 1, 0, 0, 0, 747, + 748, 5, 116, 0, 0, 748, 115, 1, 0, 0, 0, 749, 750, 3, 82, 41, 0, 750, 751, + 5, 112, 0, 0, 751, 117, 1, 0, 0, 0, 752, 753, 7, 8, 0, 0, 753, 119, 1, + 0, 0, 0, 95, 125, 129, 135, 142, 145, 151, 154, 156, 162, 165, 169, 174, + 177, 180, 184, 187, 191, 194, 196, 200, 204, 207, 211, 214, 216, 220, 224, + 227, 230, 233, 236, 244, 250, 253, 261, 267, 270, 278, 281, 286, 289, 296, + 299, 304, 307, 311, 314, 319, 322, 324, 328, 334, 338, 351, 361, 366, 382, + 387, 391, 398, 418, 423, 433, 437, 452, 459, 488, 492, 499, 511, 516, 525, + 536, 538, 540, 554, 564, 573, 576, 581, 587, 596, 600, 604, 606, 613, 619, + 628, 672, 680, 709, 714, 721, 725, 737, + } + deserializer := antlr.NewATNDeserializer(nil) + staticData.atn = deserializer.Deserialize(staticData.serializedATN) + atn := staticData.atn + staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState)) + decisionToDFA := staticData.decisionToDFA + for index, state := range atn.DecisionToState { + decisionToDFA[index] = antlr.NewDFA(state, index) + } +} + +// BigQueryParserInit initializes any static state used to implement BigQueryParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewBigQueryParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func BigQueryParserInit() { + staticData := &BigQueryParserParserStaticData + staticData.once.Do(bigqueryparserParserInit) +} + +// NewBigQueryParser produces a new parser instance for the optional input antlr.TokenStream. +func NewBigQueryParser(input antlr.TokenStream) *BigQueryParser { + BigQueryParserInit() + this := new(BigQueryParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &BigQueryParserParserStaticData + this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + this.RuleNames = staticData.RuleNames + this.LiteralNames = staticData.LiteralNames + this.SymbolicNames = staticData.SymbolicNames + this.GrammarFileName = "BigQueryParser.g4" + + return this +} + +// BigQueryParser tokens. +const ( + BigQueryParserEOF = antlr.TokenEOF + BigQueryParserQUOTE = 1 + BigQueryParserDQOUTE = 2 + BigQueryParserSEMI = 3 + BigQueryParserALL = 4 + BigQueryParserAND = 5 + BigQueryParserANY = 6 + BigQueryParserARRAY = 7 + BigQueryParserAS = 8 + BigQueryParserASC = 9 + BigQueryParserASSERT_ROWS_MODIFIED = 10 + BigQueryParserAT = 11 + BigQueryParserBETWEEN = 12 + BigQueryParserBY = 13 + BigQueryParserCASE = 14 + BigQueryParserCAST = 15 + BigQueryParserCOLLATE = 16 + BigQueryParserCONTAINS = 17 + BigQueryParserCREATE = 18 + BigQueryParserCROSS = 19 + BigQueryParserCUBE = 20 + BigQueryParserCURRENT = 21 + BigQueryParserDEFAULT = 22 + BigQueryParserDEFINE = 23 + BigQueryParserDESC = 24 + BigQueryParserDISTINCT = 25 + BigQueryParserELSE = 26 + BigQueryParserEND = 27 + BigQueryParserENUM = 28 + BigQueryParserESCAPE = 29 + BigQueryParserEXCEPT = 30 + BigQueryParserEXCLUDE = 31 + BigQueryParserEXISTS = 32 + BigQueryParserEXTRACT = 33 + BigQueryParserFALSE = 34 + BigQueryParserFETCH = 35 + BigQueryParserFOLLOWING = 36 + BigQueryParserFOR = 37 + BigQueryParserFROM = 38 + BigQueryParserFULL = 39 + BigQueryParserGROUP = 40 + BigQueryParserGROUPING = 41 + BigQueryParserGROUPS = 42 + BigQueryParserHASH = 43 + BigQueryParserHAVING = 44 + BigQueryParserIF = 45 + BigQueryParserIGNORE = 46 + BigQueryParserIN = 47 + BigQueryParserINNER = 48 + BigQueryParserINTERSECT = 49 + BigQueryParserINTERVAL = 50 + BigQueryParserINTO = 51 + BigQueryParserIS = 52 + BigQueryParserJOIN = 53 + BigQueryParserLATERAL = 54 + BigQueryParserLEFT = 55 + BigQueryParserLIKE = 56 + BigQueryParserLIMIT = 57 + BigQueryParserLOOKUP = 58 + BigQueryParserMERGE = 59 + BigQueryParserNATURAL = 60 + BigQueryParserNEW = 61 + BigQueryParserNO = 62 + BigQueryParserNOT = 63 + BigQueryParserS_NULL = 64 + BigQueryParserNULLS = 65 + BigQueryParserOF = 66 + BigQueryParserOFFSET = 67 + BigQueryParserON = 68 + BigQueryParserOR = 69 + BigQueryParserORDER = 70 + BigQueryParserORDINAL = 71 + BigQueryParserOUTER = 72 + BigQueryParserOVER = 73 + BigQueryParserPARTITION = 74 + BigQueryParserPRECEDING = 75 + BigQueryParserPROTO = 76 + BigQueryParserRANGE = 77 + BigQueryParserRECURSIVE = 78 + BigQueryParserREPLACE = 79 + BigQueryParserRESPECT = 80 + BigQueryParserRIGHT = 81 + BigQueryParserROLLUP = 82 + BigQueryParserROWS = 83 + BigQueryParserSAFE_OFFSET = 84 + BigQueryParserSAFE_ORDINAL = 85 + BigQueryParserSELECT = 86 + BigQueryParserSET = 87 + BigQueryParserSOME = 88 + BigQueryParserSSTRUCT = 89 + BigQueryParserSYSTEM = 90 + BigQueryParserTABLESAMPLE = 91 + BigQueryParserTHEN = 92 + BigQueryParserTIME = 93 + BigQueryParserTO = 94 + BigQueryParserTREAT = 95 + BigQueryParserTRUE = 96 + BigQueryParserUNBOUNDED = 97 + BigQueryParserUNION = 98 + BigQueryParserUNNEST = 99 + BigQueryParserUSING = 100 + BigQueryParserWHEN = 101 + BigQueryParserWHERE = 102 + BigQueryParserWINDOW = 103 + BigQueryParserWITH = 104 + BigQueryParserWITHIN = 105 + BigQueryParserINT = 106 + BigQueryParserFLOAT = 107 + BigQueryParserDIGITS = 108 + BigQueryParserWS = 109 + BigQueryParserCMT = 110 + BigQueryParserM_CMT = 111 + BigQueryParserQUOTED_STRING = 112 + BigQueryParserTRIPLE_QUOTED_STRING = 113 + BigQueryParserRAW_STRING = 114 + BigQueryParserBYTE_STRING = 115 + BigQueryParserRAW_BYTE_STRING = 116 + BigQueryParserQUOTED_ID = 117 + BigQueryParserID = 118 + BigQueryParserRB = 119 + BigQueryParserDOT = 120 + BigQueryParserBACKTICK = 121 + BigQueryParserLR_BRACKET = 122 + BigQueryParserRR_BRACKET = 123 + BigQueryParserLSB = 124 + BigQueryParserRSB = 125 + BigQueryParserEQ = 126 + BigQueryParserLT = 127 + BigQueryParserGT = 128 + BigQueryParserDOUBLE_LT = 129 + BigQueryParserDOUBLE_GT = 130 + BigQueryParserLE = 131 + BigQueryParserGE = 132 + BigQueryParserNE = 133 + BigQueryParserLTGT = 134 + BigQueryParserBIT_AND = 135 + BigQueryParserBIT_OR = 136 + BigQueryParserSTAR = 137 + BigQueryParserDIVIDE = 138 + BigQueryParserPLUS = 139 + BigQueryParserMINUS = 140 + BigQueryParserCOMMA = 141 + BigQueryParserTILDE = 142 + BigQueryParserCARET = 143 +) + +// BigQueryParser rules. +const ( + BigQueryParserRULE_root = 0 + BigQueryParserRULE_stmtmulti = 1 + BigQueryParserRULE_stmt = 2 + BigQueryParserRULE_query_statement = 3 + BigQueryParserRULE_query_expr = 4 + BigQueryParserRULE_select_statement = 5 + BigQueryParserRULE_from_statement = 6 + BigQueryParserRULE_from_item = 7 + BigQueryParserRULE_where_statement = 8 + BigQueryParserRULE_group_statement = 9 + BigQueryParserRULE_having_statement = 10 + BigQueryParserRULE_window_statement = 11 + BigQueryParserRULE_order_clause = 12 + BigQueryParserRULE_limit_clause = 13 + BigQueryParserRULE_unary_operator = 14 + BigQueryParserRULE_expr = 15 + BigQueryParserRULE_cast_expr = 16 + BigQueryParserRULE_column_expr = 17 + BigQueryParserRULE_except_statement = 18 + BigQueryParserRULE_replace_statement = 19 + BigQueryParserRULE_join_type = 20 + BigQueryParserRULE_on_clause = 21 + BigQueryParserRULE_set_op = 22 + BigQueryParserRULE_using_clause = 23 + BigQueryParserRULE_field_path = 24 + BigQueryParserRULE_sstruct = 25 + BigQueryParserRULE_array_expr = 26 + BigQueryParserRULE_array_path = 27 + BigQueryParserRULE_bool_expression = 28 + BigQueryParserRULE_window_name = 29 + BigQueryParserRULE_window_definition = 30 + BigQueryParserRULE_count = 31 + BigQueryParserRULE_skip_rows = 32 + BigQueryParserRULE_with_statement = 33 + BigQueryParserRULE_name = 34 + BigQueryParserRULE_dot_name = 35 + BigQueryParserRULE_alias_name = 36 + BigQueryParserRULE_array_name = 37 + BigQueryParserRULE_column_name = 38 + BigQueryParserRULE_cte_name = 39 + BigQueryParserRULE_dataset_name = 40 + BigQueryParserRULE_datatype_name = 41 + BigQueryParserRULE_function_name = 42 + BigQueryParserRULE_join_name = 43 + BigQueryParserRULE_member_name = 44 + BigQueryParserRULE_project_name = 45 + BigQueryParserRULE_struct_name = 46 + BigQueryParserRULE_table_name = 47 + BigQueryParserRULE_table_expr = 48 + BigQueryParserRULE_number = 49 + BigQueryParserRULE_integer_type = 50 + BigQueryParserRULE_float_type = 51 + BigQueryParserRULE_string = 52 + BigQueryParserRULE_quoted_string = 53 + BigQueryParserRULE_triple_quoted_string = 54 + BigQueryParserRULE_raw_string = 55 + BigQueryParserRULE_byte_string = 56 + BigQueryParserRULE_raw_byte_string = 57 + BigQueryParserRULE_special_string = 58 + BigQueryParserRULE_keyword = 59 +) + +// IRootContext is an interface to support dynamic dispatch. +type IRootContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Stmtmulti() IStmtmultiContext + EOF() antlr.TerminalNode + + // IsRootContext differentiates from other interfaces. + IsRootContext() +} + +type RootContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRootContext() *RootContext { + var p = new(RootContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_root + return p +} + +func InitEmptyRootContext(p *RootContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_root +} + +func (*RootContext) IsRootContext() {} + +func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext { + var p = new(RootContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_root + + return p +} + +func (s *RootContext) GetParser() antlr.Parser { return s.parser } + +func (s *RootContext) Stmtmulti() IStmtmultiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtmultiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmtmultiContext) +} + +func (s *RootContext) EOF() antlr.TerminalNode { + return s.GetToken(BigQueryParserEOF, 0) +} + +func (s *RootContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterRoot(s) + } +} + +func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitRoot(s) + } +} + +func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitRoot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Root() (localctx IRootContext) { + localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, BigQueryParserRULE_root) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(120) + p.Stmtmulti() + } + { + p.SetState(121) + p.Match(BigQueryParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmtmultiContext is an interface to support dynamic dispatch. +type IStmtmultiContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStmt() []IStmtContext + Stmt(i int) IStmtContext + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + + // IsStmtmultiContext differentiates from other interfaces. + IsStmtmultiContext() +} + +type StmtmultiContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmtmultiContext() *StmtmultiContext { + var p = new(StmtmultiContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_stmtmulti + return p +} + +func InitEmptyStmtmultiContext(p *StmtmultiContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_stmtmulti +} + +func (*StmtmultiContext) IsStmtmultiContext() {} + +func NewStmtmultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtmultiContext { + var p = new(StmtmultiContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_stmtmulti + + return p +} + +func (s *StmtmultiContext) GetParser() antlr.Parser { return s.parser } + +func (s *StmtmultiContext) AllStmt() []IStmtContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStmtContext); ok { + len++ + } + } + + tst := make([]IStmtContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStmtContext); ok { + tst[i] = t.(IStmtContext) + i++ + } + } + + return tst +} + +func (s *StmtmultiContext) Stmt(i int) IStmtContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStmtContext) +} + +func (s *StmtmultiContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserSEMI) +} + +func (s *StmtmultiContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserSEMI, i) +} + +func (s *StmtmultiContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StmtmultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StmtmultiContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterStmtmulti(s) + } +} + +func (s *StmtmultiContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitStmtmulti(s) + } +} + +func (s *StmtmultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitStmtmulti(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Stmtmulti() (localctx IStmtmultiContext) { + localctx = NewStmtmultiContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, BigQueryParserRULE_stmtmulti) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for (int64((_la-86)) & ^0x3f) == 0 && ((int64(1)<<(_la-86))&68719738881) != 0 { + { + p.SetState(123) + p.Stmt() + } + p.SetState(125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserSEMI { + { + p.SetState(124) + p.Match(BigQueryParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmtContext is an interface to support dynamic dispatch. +type IStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_statement() IQuery_statementContext + + // IsStmtContext differentiates from other interfaces. + IsStmtContext() +} + +type StmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmtContext() *StmtContext { + var p = new(StmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_stmt + return p +} + +func InitEmptyStmtContext(p *StmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_stmt +} + +func (*StmtContext) IsStmtContext() {} + +func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext { + var p = new(StmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_stmt + + return p +} + +func (s *StmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *StmtContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *StmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterStmt(s) + } +} + +func (s *StmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitStmt(s) + } +} + +func (s *StmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitStmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Stmt() (localctx IStmtContext) { + localctx = NewStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, BigQueryParserRULE_stmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(132) + p.Query_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_statementContext is an interface to support dynamic dispatch. +type IQuery_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_expr() IQuery_exprContext + With_statement() IWith_statementContext + + // IsQuery_statementContext differentiates from other interfaces. + IsQuery_statementContext() +} + +type Query_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_statementContext() *Query_statementContext { + var p = new(Query_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_query_statement + return p +} + +func InitEmptyQuery_statementContext(p *Query_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_query_statement +} + +func (*Query_statementContext) IsQuery_statementContext() {} + +func NewQuery_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_statementContext { + var p = new(Query_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_query_statement + + return p +} + +func (s *Query_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_statementContext) Query_expr() IQuery_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_exprContext) +} + +func (s *Query_statementContext) With_statement() IWith_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_statementContext) +} + +func (s *Query_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterQuery_statement(s) + } +} + +func (s *Query_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitQuery_statement(s) + } +} + +func (s *Query_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitQuery_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Query_statement() (localctx IQuery_statementContext) { + localctx = NewQuery_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, BigQueryParserRULE_query_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserWITH { + { + p.SetState(134) + p.With_statement() + } + + } + { + p.SetState(137) + p.query_expr(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_exprContext is an interface to support dynamic dispatch. +type IQuery_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + Order_clause() IOrder_clauseContext + Limit_clause() ILimit_clauseContext + LR_BRACKET() antlr.TerminalNode + AllQuery_expr() []IQuery_exprContext + Query_expr(i int) IQuery_exprContext + RR_BRACKET() antlr.TerminalNode + Set_op() ISet_opContext + + // IsQuery_exprContext differentiates from other interfaces. + IsQuery_exprContext() +} + +type Query_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_exprContext() *Query_exprContext { + var p = new(Query_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_query_expr + return p +} + +func InitEmptyQuery_exprContext(p *Query_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_query_expr +} + +func (*Query_exprContext) IsQuery_exprContext() {} + +func NewQuery_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_exprContext { + var p = new(Query_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_query_expr + + return p +} + +func (s *Query_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_exprContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Query_exprContext) Order_clause() IOrder_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_clauseContext) +} + +func (s *Query_exprContext) Limit_clause() ILimit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_clauseContext) +} + +func (s *Query_exprContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *Query_exprContext) AllQuery_expr() []IQuery_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuery_exprContext); ok { + len++ + } + } + + tst := make([]IQuery_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuery_exprContext); ok { + tst[i] = t.(IQuery_exprContext) + i++ + } + } + + return tst +} + +func (s *Query_exprContext) Query_expr(i int) IQuery_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuery_exprContext) +} + +func (s *Query_exprContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *Query_exprContext) Set_op() ISet_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_opContext) +} + +func (s *Query_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterQuery_expr(s) + } +} + +func (s *Query_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitQuery_expr(s) + } +} + +func (s *Query_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitQuery_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Query_expr() (localctx IQuery_exprContext) { + return p.query_expr(0) +} + +func (p *BigQueryParser) query_expr(_p int) (localctx IQuery_exprContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewQuery_exprContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IQuery_exprContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 8 + p.EnterRecursionRule(localctx, 8, BigQueryParserRULE_query_expr, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserSELECT: + { + p.SetState(140) + p.Select_statement() + } + p.SetState(142) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) == 1 { + { + p.SetState(141) + p.Order_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(145) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) == 1 { + { + p.SetState(144) + p.Limit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case BigQueryParserLR_BRACKET: + { + p.SetState(147) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(148) + p.query_expr(0) + } + { + p.SetState(149) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(151) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) == 1 { + { + p.SetState(150) + p.Order_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(154) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) == 1 { + { + p.SetState(153) + p.Limit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewQuery_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_query_expr) + p.SetState(158) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(159) + p.Set_op() + } + { + p.SetState(160) + p.query_expr(0) + } + p.SetState(162) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 8, p.GetParserRuleContext()) == 1 { + { + p.SetState(161) + p.Order_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(165) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, p.GetParserRuleContext()) == 1 { + { + p.SetState(164) + p.Limit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_statementContext is an interface to support dynamic dispatch. +type ISelect_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + From_statement() IFrom_statementContext + Where_statement() IWhere_statementContext + Group_statement() IGroup_statementContext + Having_statement() IHaving_statementContext + Window_statement() IWindow_statementContext + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + AllSTAR() []antlr.TerminalNode + STAR(i int) antlr.TerminalNode + AllAlias_name() []IAlias_nameContext + Alias_name(i int) IAlias_nameContext + DOT() antlr.TerminalNode + AllExcept_statement() []IExcept_statementContext + Except_statement(i int) IExcept_statementContext + AllReplace_statement() []IReplace_statementContext + Replace_statement(i int) IReplace_statementContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + + // IsSelect_statementContext differentiates from other interfaces. + IsSelect_statementContext() +} + +type Select_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_statementContext() *Select_statementContext { + var p = new(Select_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_select_statement + return p +} + +func InitEmptySelect_statementContext(p *Select_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_select_statement +} + +func (*Select_statementContext) IsSelect_statementContext() {} + +func NewSelect_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_statementContext { + var p = new(Select_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_select_statement + + return p +} + +func (s *Select_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_statementContext) SELECT() antlr.TerminalNode { + return s.GetToken(BigQueryParserSELECT, 0) +} + +func (s *Select_statementContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Select_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *Select_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *Select_statementContext) From_statement() IFrom_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_statementContext) +} + +func (s *Select_statementContext) Where_statement() IWhere_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_statementContext) +} + +func (s *Select_statementContext) Group_statement() IGroup_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_statementContext) +} + +func (s *Select_statementContext) Having_statement() IHaving_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_statementContext) +} + +func (s *Select_statementContext) Window_statement() IWindow_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_statementContext) +} + +func (s *Select_statementContext) ALL() antlr.TerminalNode { + return s.GetToken(BigQueryParserALL, 0) +} + +func (s *Select_statementContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDISTINCT, 0) +} + +func (s *Select_statementContext) AllSTAR() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserSTAR) +} + +func (s *Select_statementContext) STAR(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserSTAR, i) +} + +func (s *Select_statementContext) AllAlias_name() []IAlias_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlias_nameContext); ok { + len++ + } + } + + tst := make([]IAlias_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlias_nameContext); ok { + tst[i] = t.(IAlias_nameContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Alias_name(i int) IAlias_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlias_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlias_nameContext) +} + +func (s *Select_statementContext) DOT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDOT, 0) +} + +func (s *Select_statementContext) AllExcept_statement() []IExcept_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExcept_statementContext); ok { + len++ + } + } + + tst := make([]IExcept_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExcept_statementContext); ok { + tst[i] = t.(IExcept_statementContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Except_statement(i int) IExcept_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExcept_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExcept_statementContext) +} + +func (s *Select_statementContext) AllReplace_statement() []IReplace_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReplace_statementContext); ok { + len++ + } + } + + tst := make([]IReplace_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReplace_statementContext); ok { + tst[i] = t.(IReplace_statementContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Replace_statement(i int) IReplace_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReplace_statementContext) +} + +func (s *Select_statementContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserAS) +} + +func (s *Select_statementContext) AS(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserAS, i) +} + +func (s *Select_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterSelect_statement(s) + } +} + +func (s *Select_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitSelect_statement(s) + } +} + +func (s *Select_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitSelect_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Select_statement() (localctx ISelect_statementContext) { + localctx = NewSelect_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, BigQueryParserRULE_select_statement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(172) + p.Match(BigQueryParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(174) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 11, p.GetParserRuleContext()) == 1 { + { + p.SetState(173) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserALL || _la == BigQueryParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) { + case 1: + p.SetState(177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-16) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&1476916794986856447) != 0) || _la == BigQueryParserMINUS || _la == BigQueryParserTILDE { + { + p.SetState(176) + p.expr(0) + } + + } + p.SetState(180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserDOT { + { + p.SetState(179) + p.Match(BigQueryParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(182) + p.Match(BigQueryParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(184) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) == 1 { + { + p.SetState(183) + p.Except_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(187) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 { + { + p.SetState(186) + p.Replace_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(189) + p.expr(0) + } + p.SetState(194) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 17, p.GetParserRuleContext()) == 1 { + p.SetState(191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(190) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(193) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 25, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(198) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 24, p.GetParserRuleContext()) { + case 1: + p.SetState(200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-16) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&1476916794986856447) != 0) || _la == BigQueryParserMINUS || _la == BigQueryParserTILDE { + { + p.SetState(199) + p.expr(0) + } + + } + { + p.SetState(202) + p.Match(BigQueryParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(204) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 20, p.GetParserRuleContext()) == 1 { + { + p.SetState(203) + p.Except_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(207) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) == 1 { + { + p.SetState(206) + p.Replace_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(209) + p.expr(0) + } + p.SetState(214) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 { + p.SetState(211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(210) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(213) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 25, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(224) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 26, p.GetParserRuleContext()) == 1 { + { + p.SetState(223) + p.From_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(227) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 27, p.GetParserRuleContext()) == 1 { + { + p.SetState(226) + p.Where_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(230) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 { + { + p.SetState(229) + p.Group_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(233) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 { + { + p.SetState(232) + p.Having_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(236) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 { + { + p.SetState(235) + p.Window_statement() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_statementContext is an interface to support dynamic dispatch. +type IFrom_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + AllFrom_item() []IFrom_itemContext + From_item(i int) IFrom_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFrom_statementContext differentiates from other interfaces. + IsFrom_statementContext() +} + +type From_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_statementContext() *From_statementContext { + var p = new(From_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_from_statement + return p +} + +func InitEmptyFrom_statementContext(p *From_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_from_statement +} + +func (*From_statementContext) IsFrom_statementContext() {} + +func NewFrom_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_statementContext { + var p = new(From_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_from_statement + + return p +} + +func (s *From_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(BigQueryParserFROM, 0) +} + +func (s *From_statementContext) AllFrom_item() []IFrom_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFrom_itemContext); ok { + len++ + } + } + + tst := make([]IFrom_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFrom_itemContext); ok { + tst[i] = t.(IFrom_itemContext) + i++ + } + } + + return tst +} + +func (s *From_statementContext) From_item(i int) IFrom_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFrom_itemContext) +} + +func (s *From_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *From_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *From_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterFrom_statement(s) + } +} + +func (s *From_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitFrom_statement(s) + } +} + +func (s *From_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitFrom_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) From_statement() (localctx IFrom_statementContext) { + localctx = NewFrom_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, BigQueryParserRULE_from_statement) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(238) + p.Match(BigQueryParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(239) + p.from_item(0) + } + p.SetState(244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 31, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(240) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(241) + p.from_item(0) + } + + } + p.SetState(246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 31, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_itemContext is an interface to support dynamic dispatch. +type IFrom_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_expr() ITable_exprContext + AllAlias_name() []IAlias_nameContext + Alias_name(i int) IAlias_nameContext + FOR() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + TIME() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + OF() antlr.TerminalNode + String_() IStringContext + LR_BRACKET() antlr.TerminalNode + Query_statement() IQuery_statementContext + RR_BRACKET() antlr.TerminalNode + Field_path() IField_pathContext + UNNEST() antlr.TerminalNode + Array_expr() IArray_exprContext + WITH() antlr.TerminalNode + OFFSET() antlr.TerminalNode + Array_path() IArray_pathContext + AllFrom_item() []IFrom_itemContext + From_item(i int) IFrom_itemContext + JOIN() antlr.TerminalNode + On_clause() IOn_clauseContext + Using_clause() IUsing_clauseContext + Join_type() IJoin_typeContext + + // IsFrom_itemContext differentiates from other interfaces. + IsFrom_itemContext() +} + +type From_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_itemContext() *From_itemContext { + var p = new(From_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_from_item + return p +} + +func InitEmptyFrom_itemContext(p *From_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_from_item +} + +func (*From_itemContext) IsFrom_itemContext() {} + +func NewFrom_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_itemContext { + var p = new(From_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_from_item + + return p +} + +func (s *From_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_itemContext) Table_expr() ITable_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_exprContext) +} + +func (s *From_itemContext) AllAlias_name() []IAlias_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlias_nameContext); ok { + len++ + } + } + + tst := make([]IAlias_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlias_nameContext); ok { + tst[i] = t.(IAlias_nameContext) + i++ + } + } + + return tst +} + +func (s *From_itemContext) Alias_name(i int) IAlias_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlias_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlias_nameContext) +} + +func (s *From_itemContext) FOR() antlr.TerminalNode { + return s.GetToken(BigQueryParserFOR, 0) +} + +func (s *From_itemContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(BigQueryParserSYSTEM, 0) +} + +func (s *From_itemContext) TIME() antlr.TerminalNode { + return s.GetToken(BigQueryParserTIME, 0) +} + +func (s *From_itemContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserAS) +} + +func (s *From_itemContext) AS(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserAS, i) +} + +func (s *From_itemContext) OF() antlr.TerminalNode { + return s.GetToken(BigQueryParserOF, 0) +} + +func (s *From_itemContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *From_itemContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *From_itemContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *From_itemContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *From_itemContext) Field_path() IField_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_pathContext) +} + +func (s *From_itemContext) UNNEST() antlr.TerminalNode { + return s.GetToken(BigQueryParserUNNEST, 0) +} + +func (s *From_itemContext) Array_expr() IArray_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_exprContext) +} + +func (s *From_itemContext) WITH() antlr.TerminalNode { + return s.GetToken(BigQueryParserWITH, 0) +} + +func (s *From_itemContext) OFFSET() antlr.TerminalNode { + return s.GetToken(BigQueryParserOFFSET, 0) +} + +func (s *From_itemContext) Array_path() IArray_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_pathContext) +} + +func (s *From_itemContext) AllFrom_item() []IFrom_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFrom_itemContext); ok { + len++ + } + } + + tst := make([]IFrom_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFrom_itemContext); ok { + tst[i] = t.(IFrom_itemContext) + i++ + } + } + + return tst +} + +func (s *From_itemContext) From_item(i int) IFrom_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFrom_itemContext) +} + +func (s *From_itemContext) JOIN() antlr.TerminalNode { + return s.GetToken(BigQueryParserJOIN, 0) +} + +func (s *From_itemContext) On_clause() IOn_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_clauseContext) +} + +func (s *From_itemContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *From_itemContext) Join_type() IJoin_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_typeContext) +} + +func (s *From_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterFrom_item(s) + } +} + +func (s *From_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitFrom_item(s) + } +} + +func (s *From_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitFrom_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) From_item() (localctx IFrom_itemContext) { + return p.from_item(0) +} + +func (p *BigQueryParser) from_item(_p int) (localctx IFrom_itemContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewFrom_itemContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IFrom_itemContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 14 + p.EnterRecursionRule(localctx, 14, BigQueryParserRULE_from_item, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) { + case 1: + { + p.SetState(248) + p.Table_expr() + } + p.SetState(253) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 { + p.SetState(250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(249) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(252) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(261) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 34, p.GetParserRuleContext()) == 1 { + { + p.SetState(255) + p.Match(BigQueryParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(256) + p.Match(BigQueryParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(257) + p.Match(BigQueryParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(258) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(259) + p.Match(BigQueryParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(260) + p.String_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(263) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(264) + p.Query_statement() + } + { + p.SetState(265) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(270) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 36, p.GetParserRuleContext()) == 1 { + p.SetState(267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(266) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(269) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(272) + p.Field_path() + } + + case 4: + { + p.SetState(273) + p.Match(BigQueryParserUNNEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(274) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(275) + p.Array_expr() + } + { + p.SetState(276) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(281) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) == 1 { + p.SetState(278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(277) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(280) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(289) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 40, p.GetParserRuleContext()) == 1 { + { + p.SetState(283) + p.Match(BigQueryParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(284) + p.Match(BigQueryParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(285) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(288) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + { + p.SetState(291) + p.Match(BigQueryParserUNNEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(292) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(293) + p.Array_path() + } + { + p.SetState(294) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(299) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 42, p.GetParserRuleContext()) == 1 { + p.SetState(296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(295) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(298) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(307) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 44, p.GetParserRuleContext()) == 1 { + { + p.SetState(301) + p.Match(BigQueryParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(302) + p.Match(BigQueryParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(303) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(306) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + { + p.SetState(309) + p.Array_path() + } + p.SetState(314) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 46, p.GetParserRuleContext()) == 1 { + p.SetState(311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(310) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(313) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(322) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 48, p.GetParserRuleContext()) == 1 { + { + p.SetState(316) + p.Match(BigQueryParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(317) + p.Match(BigQueryParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(318) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(321) + p.Alias_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 52, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewFrom_itemContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_from_item) + p.SetState(326) + + if !(p.Precpred(p.GetParserRuleContext(), 6)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) + goto errorExit + } + p.SetState(328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-19)) & ^0x3f) == 0 && ((int64(1)<<(_la-19))&4611686087684784129) != 0 { + { + p.SetState(327) + p.Join_type() + } + + } + { + p.SetState(330) + p.Match(BigQueryParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(331) + p.from_item(0) + } + p.SetState(334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserON: + { + p.SetState(332) + p.On_clause() + } + + case BigQueryParserUSING: + { + p.SetState(333) + p.Using_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 52, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhere_statementContext is an interface to support dynamic dispatch. +type IWhere_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + Bool_expression() IBool_expressionContext + + // IsWhere_statementContext differentiates from other interfaces. + IsWhere_statementContext() +} + +type Where_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhere_statementContext() *Where_statementContext { + var p = new(Where_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_where_statement + return p +} + +func InitEmptyWhere_statementContext(p *Where_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_where_statement +} + +func (*Where_statementContext) IsWhere_statementContext() {} + +func NewWhere_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_statementContext { + var p = new(Where_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_where_statement + + return p +} + +func (s *Where_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Where_statementContext) WHERE() antlr.TerminalNode { + return s.GetToken(BigQueryParserWHERE, 0) +} + +func (s *Where_statementContext) Bool_expression() IBool_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBool_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBool_expressionContext) +} + +func (s *Where_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Where_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Where_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterWhere_statement(s) + } +} + +func (s *Where_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitWhere_statement(s) + } +} + +func (s *Where_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitWhere_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Where_statement() (localctx IWhere_statementContext) { + localctx = NewWhere_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, BigQueryParserRULE_where_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(341) + p.Match(BigQueryParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(342) + p.Bool_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_statementContext is an interface to support dynamic dispatch. +type IGroup_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + BY() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGroup_statementContext differentiates from other interfaces. + IsGroup_statementContext() +} + +type Group_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_statementContext() *Group_statementContext { + var p = new(Group_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_group_statement + return p +} + +func InitEmptyGroup_statementContext(p *Group_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_group_statement +} + +func (*Group_statementContext) IsGroup_statementContext() {} + +func NewGroup_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_statementContext { + var p = new(Group_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_group_statement + + return p +} + +func (s *Group_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_statementContext) GROUP() antlr.TerminalNode { + return s.GetToken(BigQueryParserGROUP, 0) +} + +func (s *Group_statementContext) BY() antlr.TerminalNode { + return s.GetToken(BigQueryParserBY, 0) +} + +func (s *Group_statementContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(BigQueryParserROLLUP, 0) +} + +func (s *Group_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *Group_statementContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Group_statementContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Group_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *Group_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *Group_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *Group_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterGroup_statement(s) + } +} + +func (s *Group_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitGroup_statement(s) + } +} + +func (s *Group_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitGroup_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Group_statement() (localctx IGroup_statementContext) { + localctx = NewGroup_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, BigQueryParserRULE_group_statement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(344) + p.Match(BigQueryParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(345) + p.Match(BigQueryParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext()) { + case 1: + { + p.SetState(346) + p.expr(0) + } + p.SetState(351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 53, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(347) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(348) + p.expr(0) + } + + } + p.SetState(353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 53, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(354) + p.Match(BigQueryParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(355) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(356) + p.expr(0) + } + p.SetState(361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(357) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(358) + p.expr(0) + } + + p.SetState(363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(364) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHaving_statementContext is an interface to support dynamic dispatch. +type IHaving_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HAVING() antlr.TerminalNode + Bool_expression() IBool_expressionContext + + // IsHaving_statementContext differentiates from other interfaces. + IsHaving_statementContext() +} + +type Having_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHaving_statementContext() *Having_statementContext { + var p = new(Having_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_having_statement + return p +} + +func InitEmptyHaving_statementContext(p *Having_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_having_statement +} + +func (*Having_statementContext) IsHaving_statementContext() {} + +func NewHaving_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Having_statementContext { + var p = new(Having_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_having_statement + + return p +} + +func (s *Having_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Having_statementContext) HAVING() antlr.TerminalNode { + return s.GetToken(BigQueryParserHAVING, 0) +} + +func (s *Having_statementContext) Bool_expression() IBool_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBool_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBool_expressionContext) +} + +func (s *Having_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Having_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Having_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterHaving_statement(s) + } +} + +func (s *Having_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitHaving_statement(s) + } +} + +func (s *Having_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitHaving_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Having_statement() (localctx IHaving_statementContext) { + localctx = NewHaving_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, BigQueryParserRULE_having_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(368) + p.Match(BigQueryParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(369) + p.Bool_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_statementContext is an interface to support dynamic dispatch. +type IWindow_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WINDOW() antlr.TerminalNode + Window_name() IWindow_nameContext + AS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Window_definition() IWindow_definitionContext + RR_BRACKET() antlr.TerminalNode + + // IsWindow_statementContext differentiates from other interfaces. + IsWindow_statementContext() +} + +type Window_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_statementContext() *Window_statementContext { + var p = new(Window_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_window_statement + return p +} + +func InitEmptyWindow_statementContext(p *Window_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_window_statement +} + +func (*Window_statementContext) IsWindow_statementContext() {} + +func NewWindow_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_statementContext { + var p = new(Window_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_window_statement + + return p +} + +func (s *Window_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_statementContext) WINDOW() antlr.TerminalNode { + return s.GetToken(BigQueryParserWINDOW, 0) +} + +func (s *Window_statementContext) Window_name() IWindow_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_nameContext) +} + +func (s *Window_statementContext) AS() antlr.TerminalNode { + return s.GetToken(BigQueryParserAS, 0) +} + +func (s *Window_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *Window_statementContext) Window_definition() IWindow_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_definitionContext) +} + +func (s *Window_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *Window_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterWindow_statement(s) + } +} + +func (s *Window_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitWindow_statement(s) + } +} + +func (s *Window_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitWindow_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Window_statement() (localctx IWindow_statementContext) { + localctx = NewWindow_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, BigQueryParserRULE_window_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(371) + p.Match(BigQueryParserWINDOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(372) + p.Window_name() + } + { + p.SetState(373) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(374) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(375) + p.Window_definition() + } + { + p.SetState(376) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_clauseContext is an interface to support dynamic dispatch. +type IOrder_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + + // IsOrder_clauseContext differentiates from other interfaces. + IsOrder_clauseContext() +} + +type Order_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_clauseContext() *Order_clauseContext { + var p = new(Order_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_order_clause + return p +} + +func InitEmptyOrder_clauseContext(p *Order_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_order_clause +} + +func (*Order_clauseContext) IsOrder_clauseContext() {} + +func NewOrder_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_clauseContext { + var p = new(Order_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_order_clause + + return p +} + +func (s *Order_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(BigQueryParserORDER, 0) +} + +func (s *Order_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(BigQueryParserBY, 0) +} + +func (s *Order_clauseContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Order_clauseContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Order_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *Order_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *Order_clauseContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserASC) +} + +func (s *Order_clauseContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserASC, i) +} + +func (s *Order_clauseContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserDESC) +} + +func (s *Order_clauseContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserDESC, i) +} + +func (s *Order_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterOrder_clause(s) + } +} + +func (s *Order_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitOrder_clause(s) + } +} + +func (s *Order_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitOrder_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Order_clause() (localctx IOrder_clauseContext) { + localctx = NewOrder_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, BigQueryParserRULE_order_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(378) + p.Match(BigQueryParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(379) + p.Match(BigQueryParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(380) + p.expr(0) + } + p.SetState(382) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 56, p.GetParserRuleContext()) == 1 { + { + p.SetState(381) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserASC || _la == BigQueryParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 58, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(384) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(385) + p.expr(0) + } + p.SetState(387) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 { + { + p.SetState(386) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserASC || _la == BigQueryParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 58, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILimit_clauseContext is an interface to support dynamic dispatch. +type ILimit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIMIT() antlr.TerminalNode + Count() ICountContext + OFFSET() antlr.TerminalNode + Skip_rows() ISkip_rowsContext + + // IsLimit_clauseContext differentiates from other interfaces. + IsLimit_clauseContext() +} + +type Limit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLimit_clauseContext() *Limit_clauseContext { + var p = new(Limit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_limit_clause + return p +} + +func InitEmptyLimit_clauseContext(p *Limit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_limit_clause +} + +func (*Limit_clauseContext) IsLimit_clauseContext() {} + +func NewLimit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_clauseContext { + var p = new(Limit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_limit_clause + + return p +} + +func (s *Limit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Limit_clauseContext) LIMIT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLIMIT, 0) +} + +func (s *Limit_clauseContext) Count() ICountContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICountContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICountContext) +} + +func (s *Limit_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(BigQueryParserOFFSET, 0) +} + +func (s *Limit_clauseContext) Skip_rows() ISkip_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISkip_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISkip_rowsContext) +} + +func (s *Limit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Limit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Limit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterLimit_clause(s) + } +} + +func (s *Limit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitLimit_clause(s) + } +} + +func (s *Limit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitLimit_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Limit_clause() (localctx ILimit_clauseContext) { + localctx = NewLimit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, BigQueryParserRULE_limit_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(394) + p.Match(BigQueryParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(395) + p.Count() + } + p.SetState(398) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext()) == 1 { + { + p.SetState(396) + p.Match(BigQueryParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(397) + p.Skip_rows() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_operatorContext is an interface to support dynamic dispatch. +type IUnary_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINUS() antlr.TerminalNode + TILDE() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsUnary_operatorContext differentiates from other interfaces. + IsUnary_operatorContext() +} + +type Unary_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnary_operatorContext() *Unary_operatorContext { + var p = new(Unary_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_unary_operator + return p +} + +func InitEmptyUnary_operatorContext(p *Unary_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_unary_operator +} + +func (*Unary_operatorContext) IsUnary_operatorContext() {} + +func NewUnary_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operatorContext { + var p = new(Unary_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_unary_operator + + return p +} + +func (s *Unary_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_operatorContext) MINUS() antlr.TerminalNode { + return s.GetToken(BigQueryParserMINUS, 0) +} + +func (s *Unary_operatorContext) TILDE() antlr.TerminalNode { + return s.GetToken(BigQueryParserTILDE, 0) +} + +func (s *Unary_operatorContext) NOT() antlr.TerminalNode { + return s.GetToken(BigQueryParserNOT, 0) +} + +func (s *Unary_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterUnary_operator(s) + } +} + +func (s *Unary_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitUnary_operator(s) + } +} + +func (s *Unary_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitUnary_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Unary_operator() (localctx IUnary_operatorContext) { + localctx = NewUnary_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, BigQueryParserRULE_unary_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(400) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserNOT || _la == BigQueryParserMINUS || _la == BigQueryParserTILDE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExprContext is an interface to support dynamic dispatch. +type IExprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Number() INumberContext + String_() IStringContext + Array_name() IArray_nameContext + LSB() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + RR_BRACKET() antlr.TerminalNode + RSB() antlr.TerminalNode + OFFSET() antlr.TerminalNode + ORDINAL() antlr.TerminalNode + SAFE_OFFSET() antlr.TerminalNode + SAFE_ORDINAL() antlr.TerminalNode + Unary_operator() IUnary_operatorContext + IS() antlr.TerminalNode + TRUE() antlr.TerminalNode + NOT() antlr.TerminalNode + FALSE() antlr.TerminalNode + Function_name() IFunction_nameContext + STAR() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Cast_expr() ICast_exprContext + Column_expr() IColumn_exprContext + Keyword() IKeywordContext + DIVIDE() antlr.TerminalNode + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + DOUBLE_LT() antlr.TerminalNode + DOUBLE_GT() antlr.TerminalNode + BIT_AND() antlr.TerminalNode + CARET() antlr.TerminalNode + BIT_OR() antlr.TerminalNode + EQ() antlr.TerminalNode + LT() antlr.TerminalNode + GT() antlr.TerminalNode + LE() antlr.TerminalNode + GE() antlr.TerminalNode + NE() antlr.TerminalNode + LTGT() antlr.TerminalNode + LIKE() antlr.TerminalNode + BETWEEN() antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + S_NULL() antlr.TerminalNode + IN() antlr.TerminalNode + Query_statement() IQuery_statementContext + UNNEST() antlr.TerminalNode + Array_expr() IArray_exprContext + + // IsExprContext differentiates from other interfaces. + IsExprContext() +} + +type ExprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExprContext() *ExprContext { + var p = new(ExprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_expr + return p +} + +func InitEmptyExprContext(p *ExprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_expr +} + +func (*ExprContext) IsExprContext() {} + +func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext { + var p = new(ExprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_expr + + return p +} + +func (s *ExprContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExprContext) Number() INumberContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumberContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumberContext) +} + +func (s *ExprContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *ExprContext) Array_name() IArray_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_nameContext) +} + +func (s *ExprContext) LSB() antlr.TerminalNode { + return s.GetToken(BigQueryParserLSB, 0) +} + +func (s *ExprContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *ExprContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *ExprContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *ExprContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *ExprContext) RSB() antlr.TerminalNode { + return s.GetToken(BigQueryParserRSB, 0) +} + +func (s *ExprContext) OFFSET() antlr.TerminalNode { + return s.GetToken(BigQueryParserOFFSET, 0) +} + +func (s *ExprContext) ORDINAL() antlr.TerminalNode { + return s.GetToken(BigQueryParserORDINAL, 0) +} + +func (s *ExprContext) SAFE_OFFSET() antlr.TerminalNode { + return s.GetToken(BigQueryParserSAFE_OFFSET, 0) +} + +func (s *ExprContext) SAFE_ORDINAL() antlr.TerminalNode { + return s.GetToken(BigQueryParserSAFE_ORDINAL, 0) +} + +func (s *ExprContext) Unary_operator() IUnary_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_operatorContext) +} + +func (s *ExprContext) IS() antlr.TerminalNode { + return s.GetToken(BigQueryParserIS, 0) +} + +func (s *ExprContext) TRUE() antlr.TerminalNode { + return s.GetToken(BigQueryParserTRUE, 0) +} + +func (s *ExprContext) NOT() antlr.TerminalNode { + return s.GetToken(BigQueryParserNOT, 0) +} + +func (s *ExprContext) FALSE() antlr.TerminalNode { + return s.GetToken(BigQueryParserFALSE, 0) +} + +func (s *ExprContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *ExprContext) STAR() antlr.TerminalNode { + return s.GetToken(BigQueryParserSTAR, 0) +} + +func (s *ExprContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *ExprContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *ExprContext) Cast_expr() ICast_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICast_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICast_exprContext) +} + +func (s *ExprContext) Column_expr() IColumn_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_exprContext) +} + +func (s *ExprContext) Keyword() IKeywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeywordContext) +} + +func (s *ExprContext) DIVIDE() antlr.TerminalNode { + return s.GetToken(BigQueryParserDIVIDE, 0) +} + +func (s *ExprContext) PLUS() antlr.TerminalNode { + return s.GetToken(BigQueryParserPLUS, 0) +} + +func (s *ExprContext) MINUS() antlr.TerminalNode { + return s.GetToken(BigQueryParserMINUS, 0) +} + +func (s *ExprContext) DOUBLE_LT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDOUBLE_LT, 0) +} + +func (s *ExprContext) DOUBLE_GT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDOUBLE_GT, 0) +} + +func (s *ExprContext) BIT_AND() antlr.TerminalNode { + return s.GetToken(BigQueryParserBIT_AND, 0) +} + +func (s *ExprContext) CARET() antlr.TerminalNode { + return s.GetToken(BigQueryParserCARET, 0) +} + +func (s *ExprContext) BIT_OR() antlr.TerminalNode { + return s.GetToken(BigQueryParserBIT_OR, 0) +} + +func (s *ExprContext) EQ() antlr.TerminalNode { + return s.GetToken(BigQueryParserEQ, 0) +} + +func (s *ExprContext) LT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLT, 0) +} + +func (s *ExprContext) GT() antlr.TerminalNode { + return s.GetToken(BigQueryParserGT, 0) +} + +func (s *ExprContext) LE() antlr.TerminalNode { + return s.GetToken(BigQueryParserLE, 0) +} + +func (s *ExprContext) GE() antlr.TerminalNode { + return s.GetToken(BigQueryParserGE, 0) +} + +func (s *ExprContext) NE() antlr.TerminalNode { + return s.GetToken(BigQueryParserNE, 0) +} + +func (s *ExprContext) LTGT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLTGT, 0) +} + +func (s *ExprContext) LIKE() antlr.TerminalNode { + return s.GetToken(BigQueryParserLIKE, 0) +} + +func (s *ExprContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(BigQueryParserBETWEEN, 0) +} + +func (s *ExprContext) AND() antlr.TerminalNode { + return s.GetToken(BigQueryParserAND, 0) +} + +func (s *ExprContext) OR() antlr.TerminalNode { + return s.GetToken(BigQueryParserOR, 0) +} + +func (s *ExprContext) S_NULL() antlr.TerminalNode { + return s.GetToken(BigQueryParserS_NULL, 0) +} + +func (s *ExprContext) IN() antlr.TerminalNode { + return s.GetToken(BigQueryParserIN, 0) +} + +func (s *ExprContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *ExprContext) UNNEST() antlr.TerminalNode { + return s.GetToken(BigQueryParserUNNEST, 0) +} + +func (s *ExprContext) Array_expr() IArray_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_exprContext) +} + +func (s *ExprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterExpr(s) + } +} + +func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitExpr(s) + } +} + +func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitExpr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Expr() (localctx IExprContext) { + return p.expr(0) +} + +func (p *BigQueryParser) expr(_p int) (localctx IExprContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExprContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 30 + p.EnterRecursionRule(localctx, 30, BigQueryParserRULE_expr, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 65, p.GetParserRuleContext()) { + case 1: + { + p.SetState(403) + p.Number() + } + + case 2: + { + p.SetState(404) + p.String_() + } + + case 3: + { + p.SetState(405) + p.Array_name() + } + { + p.SetState(406) + p.Match(BigQueryParserLSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(407) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-67)) & ^0x3f) == 0 && ((int64(1)<<(_la-67))&393233) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(408) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(409) + p.expr(0) + } + { + p.SetState(410) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(411) + p.Match(BigQueryParserRSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(413) + p.Unary_operator() + } + { + p.SetState(414) + p.expr(20) + } + + case 5: + { + p.SetState(416) + p.Match(BigQueryParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserNOT { + { + p.SetState(417) + p.Match(BigQueryParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(420) + p.Match(BigQueryParserTRUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(421) + p.Match(BigQueryParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserNOT { + { + p.SetState(422) + p.Match(BigQueryParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(425) + p.Match(BigQueryParserFALSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(426) + p.Function_name() + } + { + p.SetState(427) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserALL, BigQueryParserAND, BigQueryParserANY, BigQueryParserARRAY, BigQueryParserAS, BigQueryParserASC, BigQueryParserASSERT_ROWS_MODIFIED, BigQueryParserAT, BigQueryParserBETWEEN, BigQueryParserBY, BigQueryParserCASE, BigQueryParserCAST, BigQueryParserCOLLATE, BigQueryParserCONTAINS, BigQueryParserCREATE, BigQueryParserCROSS, BigQueryParserCUBE, BigQueryParserCURRENT, BigQueryParserDEFAULT, BigQueryParserDEFINE, BigQueryParserDESC, BigQueryParserDISTINCT, BigQueryParserELSE, BigQueryParserEND, BigQueryParserENUM, BigQueryParserESCAPE, BigQueryParserEXCEPT, BigQueryParserEXCLUDE, BigQueryParserEXISTS, BigQueryParserEXTRACT, BigQueryParserFALSE, BigQueryParserFETCH, BigQueryParserFOLLOWING, BigQueryParserFOR, BigQueryParserFROM, BigQueryParserFULL, BigQueryParserGROUP, BigQueryParserGROUPING, BigQueryParserGROUPS, BigQueryParserHASH, BigQueryParserHAVING, BigQueryParserIF, BigQueryParserIGNORE, BigQueryParserIN, BigQueryParserINNER, BigQueryParserINTERSECT, BigQueryParserINTERVAL, BigQueryParserINTO, BigQueryParserIS, BigQueryParserJOIN, BigQueryParserLATERAL, BigQueryParserLEFT, BigQueryParserLIKE, BigQueryParserLIMIT, BigQueryParserLOOKUP, BigQueryParserMERGE, BigQueryParserNATURAL, BigQueryParserNEW, BigQueryParserNO, BigQueryParserNOT, BigQueryParserS_NULL, BigQueryParserNULLS, BigQueryParserOF, BigQueryParserOFFSET, BigQueryParserON, BigQueryParserOR, BigQueryParserORDER, BigQueryParserORDINAL, BigQueryParserOUTER, BigQueryParserOVER, BigQueryParserPARTITION, BigQueryParserPRECEDING, BigQueryParserPROTO, BigQueryParserRANGE, BigQueryParserRECURSIVE, BigQueryParserREPLACE, BigQueryParserRESPECT, BigQueryParserRIGHT, BigQueryParserROLLUP, BigQueryParserROWS, BigQueryParserSAFE_OFFSET, BigQueryParserSAFE_ORDINAL, BigQueryParserSELECT, BigQueryParserSET, BigQueryParserSOME, BigQueryParserSSTRUCT, BigQueryParserSYSTEM, BigQueryParserTABLESAMPLE, BigQueryParserTHEN, BigQueryParserTIME, BigQueryParserTO, BigQueryParserTREAT, BigQueryParserTRUE, BigQueryParserUNBOUNDED, BigQueryParserUNION, BigQueryParserUNNEST, BigQueryParserUSING, BigQueryParserWHEN, BigQueryParserWHERE, BigQueryParserWINDOW, BigQueryParserWITH, BigQueryParserWITHIN, BigQueryParserINT, BigQueryParserFLOAT, BigQueryParserQUOTED_STRING, BigQueryParserTRIPLE_QUOTED_STRING, BigQueryParserRAW_STRING, BigQueryParserBYTE_STRING, BigQueryParserRAW_BYTE_STRING, BigQueryParserQUOTED_ID, BigQueryParserID, BigQueryParserLR_BRACKET, BigQueryParserLSB, BigQueryParserMINUS, BigQueryParserTILDE: + { + p.SetState(428) + p.expr(0) + } + p.SetState(433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(429) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(430) + p.expr(0) + } + + p.SetState(435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case BigQueryParserSTAR: + { + p.SetState(436) + p.Match(BigQueryParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(439) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(441) + p.Cast_expr() + } + + case 9: + { + p.SetState(442) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(443) + p.expr(0) + } + { + p.SetState(444) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + { + p.SetState(446) + p.Match(BigQueryParserLSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(447) + p.expr(0) + } + p.SetState(452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(448) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(449) + p.expr(0) + } + + p.SetState(454) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(455) + p.Match(BigQueryParserRSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + { + p.SetState(457) + p.Column_expr() + } + + case 12: + { + p.SetState(458) + p.Keyword() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + p.SetState(538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 73, p.GetParserRuleContext()) { + case 1: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(461) + + if !(p.Precpred(p.GetParserRuleContext(), 19)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", "")) + goto errorExit + } + { + p.SetState(462) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserSTAR || _la == BigQueryParserDIVIDE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(463) + p.expr(20) + } + + case 2: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(464) + + if !(p.Precpred(p.GetParserRuleContext(), 18)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", "")) + goto errorExit + } + { + p.SetState(465) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserPLUS || _la == BigQueryParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(466) + p.expr(19) + } + + case 3: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(467) + + if !(p.Precpred(p.GetParserRuleContext(), 17)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", "")) + goto errorExit + } + { + p.SetState(468) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserDOUBLE_LT || _la == BigQueryParserDOUBLE_GT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(469) + p.expr(18) + } + + case 4: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(470) + + if !(p.Precpred(p.GetParserRuleContext(), 16)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", "")) + goto errorExit + } + { + p.SetState(471) + p.Match(BigQueryParserBIT_AND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(472) + p.expr(17) + } + + case 5: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(473) + + if !(p.Precpred(p.GetParserRuleContext(), 15)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 15)", "")) + goto errorExit + } + { + p.SetState(474) + p.Match(BigQueryParserCARET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(475) + p.expr(16) + } + + case 6: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(476) + + if !(p.Precpred(p.GetParserRuleContext(), 14)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 14)", "")) + goto errorExit + } + { + p.SetState(477) + p.Match(BigQueryParserBIT_OR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(478) + p.expr(15) + } + + case 7: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(479) + + if !(p.Precpred(p.GetParserRuleContext(), 13)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 13)", "")) + goto errorExit + } + p.SetState(499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 68, p.GetParserRuleContext()) { + case 1: + { + p.SetState(480) + p.Match(BigQueryParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(481) + p.Match(BigQueryParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(482) + p.Match(BigQueryParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(483) + p.Match(BigQueryParserLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(484) + p.Match(BigQueryParserGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(485) + p.Match(BigQueryParserNE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(486) + p.Match(BigQueryParserLTGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.SetState(488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserNOT { + { + p.SetState(487) + p.Match(BigQueryParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(490) + p.Match(BigQueryParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.SetState(492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserNOT { + { + p.SetState(491) + p.Match(BigQueryParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(494) + p.Match(BigQueryParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(495) + p.expr(0) + } + { + p.SetState(496) + p.Match(BigQueryParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(497) + p.expr(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(501) + p.expr(14) + } + + case 8: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(502) + + if !(p.Precpred(p.GetParserRuleContext(), 8)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) + goto errorExit + } + { + p.SetState(503) + p.Match(BigQueryParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(504) + p.expr(9) + } + + case 9: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(505) + + if !(p.Precpred(p.GetParserRuleContext(), 7)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) + goto errorExit + } + { + p.SetState(506) + p.Match(BigQueryParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(507) + p.expr(8) + } + + case 10: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(508) + + if !(p.Precpred(p.GetParserRuleContext(), 12)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 12)", "")) + goto errorExit + } + { + p.SetState(509) + p.Match(BigQueryParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserNOT { + { + p.SetState(510) + p.Match(BigQueryParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(513) + p.Match(BigQueryParserS_NULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, BigQueryParserRULE_expr) + p.SetState(514) + + if !(p.Precpred(p.GetParserRuleContext(), 9)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 9)", "")) + goto errorExit + } + p.SetState(516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserNOT { + { + p.SetState(515) + p.Match(BigQueryParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(518) + p.Match(BigQueryParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) { + case 1: + { + p.SetState(519) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(520) + p.expr(0) + } + p.SetState(525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(521) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(522) + p.expr(0) + } + + p.SetState(527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(528) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(530) + p.Query_statement() + } + + case 3: + { + p.SetState(531) + p.Match(BigQueryParserUNNEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(532) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(533) + p.Array_expr() + } + { + p.SetState(534) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICast_exprContext is an interface to support dynamic dispatch. +type ICast_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CAST() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expr() IExprContext + AS() antlr.TerminalNode + Datatype_name() IDatatype_nameContext + RR_BRACKET() antlr.TerminalNode + + // IsCast_exprContext differentiates from other interfaces. + IsCast_exprContext() +} + +type Cast_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCast_exprContext() *Cast_exprContext { + var p = new(Cast_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_cast_expr + return p +} + +func InitEmptyCast_exprContext(p *Cast_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_cast_expr +} + +func (*Cast_exprContext) IsCast_exprContext() {} + +func NewCast_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cast_exprContext { + var p = new(Cast_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_cast_expr + + return p +} + +func (s *Cast_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cast_exprContext) CAST() antlr.TerminalNode { + return s.GetToken(BigQueryParserCAST, 0) +} + +func (s *Cast_exprContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *Cast_exprContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Cast_exprContext) AS() antlr.TerminalNode { + return s.GetToken(BigQueryParserAS, 0) +} + +func (s *Cast_exprContext) Datatype_name() IDatatype_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatype_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatype_nameContext) +} + +func (s *Cast_exprContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *Cast_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cast_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cast_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterCast_expr(s) + } +} + +func (s *Cast_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitCast_expr(s) + } +} + +func (s *Cast_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitCast_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Cast_expr() (localctx ICast_exprContext) { + localctx = NewCast_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, BigQueryParserRULE_cast_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(543) + p.Match(BigQueryParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(544) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(545) + p.expr(0) + } + { + p.SetState(546) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(547) + p.Datatype_name() + } + { + p.SetState(548) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_exprContext is an interface to support dynamic dispatch. +type IColumn_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + AllDot_name() []IDot_nameContext + Dot_name(i int) IDot_nameContext + + // IsColumn_exprContext differentiates from other interfaces. + IsColumn_exprContext() +} + +type Column_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_exprContext() *Column_exprContext { + var p = new(Column_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_column_expr + return p +} + +func InitEmptyColumn_exprContext(p *Column_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_column_expr +} + +func (*Column_exprContext) IsColumn_exprContext() {} + +func NewColumn_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_exprContext { + var p = new(Column_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_column_expr + + return p +} + +func (s *Column_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_exprContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Column_exprContext) AllDot_name() []IDot_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDot_nameContext); ok { + len++ + } + } + + tst := make([]IDot_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDot_nameContext); ok { + tst[i] = t.(IDot_nameContext) + i++ + } + } + + return tst +} + +func (s *Column_exprContext) Dot_name(i int) IDot_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDot_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDot_nameContext) +} + +func (s *Column_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterColumn_expr(s) + } +} + +func (s *Column_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitColumn_expr(s) + } +} + +func (s *Column_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitColumn_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Column_expr() (localctx IColumn_exprContext) { + localctx = NewColumn_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, BigQueryParserRULE_column_expr) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(550) + p.Name() + } + p.SetState(554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 75, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(551) + p.Dot_name() + } + + } + p.SetState(556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 75, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExcept_statementContext is an interface to support dynamic dispatch. +type IExcept_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPT() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExcept_statementContext differentiates from other interfaces. + IsExcept_statementContext() +} + +type Except_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExcept_statementContext() *Except_statementContext { + var p = new(Except_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_except_statement + return p +} + +func InitEmptyExcept_statementContext(p *Except_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_except_statement +} + +func (*Except_statementContext) IsExcept_statementContext() {} + +func NewExcept_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Except_statementContext { + var p = new(Except_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_except_statement + + return p +} + +func (s *Except_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Except_statementContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(BigQueryParserEXCEPT, 0) +} + +func (s *Except_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *Except_statementContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Except_statementContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Except_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *Except_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *Except_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *Except_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Except_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Except_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterExcept_statement(s) + } +} + +func (s *Except_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitExcept_statement(s) + } +} + +func (s *Except_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitExcept_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Except_statement() (localctx IExcept_statementContext) { + localctx = NewExcept_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, BigQueryParserRULE_except_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(557) + p.Match(BigQueryParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(558) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(559) + p.Column_name() + } + p.SetState(564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(560) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(561) + p.Column_name() + } + + p.SetState(566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(567) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplace_statementContext is an interface to support dynamic dispatch. +type IReplace_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + RR_BRACKET() antlr.TerminalNode + AllAlias_name() []IAlias_nameContext + Alias_name(i int) IAlias_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + + // IsReplace_statementContext differentiates from other interfaces. + IsReplace_statementContext() +} + +type Replace_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_statementContext() *Replace_statementContext { + var p = new(Replace_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_replace_statement + return p +} + +func InitEmptyReplace_statementContext(p *Replace_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_replace_statement +} + +func (*Replace_statementContext) IsReplace_statementContext() {} + +func NewReplace_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_statementContext { + var p = new(Replace_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_replace_statement + + return p +} + +func (s *Replace_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_statementContext) REPLACE() antlr.TerminalNode { + return s.GetToken(BigQueryParserREPLACE, 0) +} + +func (s *Replace_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *Replace_statementContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Replace_statementContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Replace_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *Replace_statementContext) AllAlias_name() []IAlias_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlias_nameContext); ok { + len++ + } + } + + tst := make([]IAlias_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlias_nameContext); ok { + tst[i] = t.(IAlias_nameContext) + i++ + } + } + + return tst +} + +func (s *Replace_statementContext) Alias_name(i int) IAlias_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlias_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlias_nameContext) +} + +func (s *Replace_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *Replace_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *Replace_statementContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserAS) +} + +func (s *Replace_statementContext) AS(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserAS, i) +} + +func (s *Replace_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterReplace_statement(s) + } +} + +func (s *Replace_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitReplace_statement(s) + } +} + +func (s *Replace_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitReplace_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Replace_statement() (localctx IReplace_statementContext) { + localctx = NewReplace_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, BigQueryParserRULE_replace_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(569) + p.Match(BigQueryParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(570) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(571) + p.expr(0) + } + p.SetState(576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS || _la == BigQueryParserQUOTED_ID || _la == BigQueryParserID { + p.SetState(573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(572) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(575) + p.Alias_name() + } + + } + p.SetState(587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(578) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(579) + p.expr(0) + } + + p.SetState(581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserAS { + { + p.SetState(580) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(583) + p.Alias_name() + } + + p.SetState(589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(590) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_typeContext is an interface to support dynamic dispatch. +type IJoin_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INNER() antlr.TerminalNode + CROSS() antlr.TerminalNode + FULL() antlr.TerminalNode + OUTER() antlr.TerminalNode + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + + // IsJoin_typeContext differentiates from other interfaces. + IsJoin_typeContext() +} + +type Join_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_typeContext() *Join_typeContext { + var p = new(Join_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_join_type + return p +} + +func InitEmptyJoin_typeContext(p *Join_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_join_type +} + +func (*Join_typeContext) IsJoin_typeContext() {} + +func NewJoin_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_typeContext { + var p = new(Join_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_join_type + + return p +} + +func (s *Join_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_typeContext) INNER() antlr.TerminalNode { + return s.GetToken(BigQueryParserINNER, 0) +} + +func (s *Join_typeContext) CROSS() antlr.TerminalNode { + return s.GetToken(BigQueryParserCROSS, 0) +} + +func (s *Join_typeContext) FULL() antlr.TerminalNode { + return s.GetToken(BigQueryParserFULL, 0) +} + +func (s *Join_typeContext) OUTER() antlr.TerminalNode { + return s.GetToken(BigQueryParserOUTER, 0) +} + +func (s *Join_typeContext) LEFT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLEFT, 0) +} + +func (s *Join_typeContext) RIGHT() antlr.TerminalNode { + return s.GetToken(BigQueryParserRIGHT, 0) +} + +func (s *Join_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterJoin_type(s) + } +} + +func (s *Join_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitJoin_type(s) + } +} + +func (s *Join_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitJoin_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Join_type() (localctx IJoin_typeContext) { + localctx = NewJoin_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, BigQueryParserRULE_join_type) + var _la int + + p.SetState(606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserINNER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(592) + p.Match(BigQueryParserINNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case BigQueryParserCROSS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(593) + p.Match(BigQueryParserCROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case BigQueryParserFULL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(594) + p.Match(BigQueryParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserOUTER { + { + p.SetState(595) + p.Match(BigQueryParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case BigQueryParserLEFT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(598) + p.Match(BigQueryParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserOUTER { + { + p.SetState(599) + p.Match(BigQueryParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case BigQueryParserRIGHT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(602) + p.Match(BigQueryParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserOUTER { + { + p.SetState(603) + p.Match(BigQueryParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_clauseContext is an interface to support dynamic dispatch. +type IOn_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Bool_expression() IBool_expressionContext + + // IsOn_clauseContext differentiates from other interfaces. + IsOn_clauseContext() +} + +type On_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_clauseContext() *On_clauseContext { + var p = new(On_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_on_clause + return p +} + +func InitEmptyOn_clauseContext(p *On_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_on_clause +} + +func (*On_clauseContext) IsOn_clauseContext() {} + +func NewOn_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_clauseContext { + var p = new(On_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_on_clause + + return p +} + +func (s *On_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(BigQueryParserON, 0) +} + +func (s *On_clauseContext) Bool_expression() IBool_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBool_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBool_expressionContext) +} + +func (s *On_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterOn_clause(s) + } +} + +func (s *On_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitOn_clause(s) + } +} + +func (s *On_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitOn_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) On_clause() (localctx IOn_clauseContext) { + localctx = NewOn_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, BigQueryParserRULE_on_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(608) + p.Match(BigQueryParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(609) + p.Bool_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_opContext is an interface to support dynamic dispatch. +type ISet_opContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNION() antlr.TerminalNode + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsSet_opContext differentiates from other interfaces. + IsSet_opContext() +} + +type Set_opContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_opContext() *Set_opContext { + var p = new(Set_opContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_set_op + return p +} + +func InitEmptySet_opContext(p *Set_opContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_set_op +} + +func (*Set_opContext) IsSet_opContext() {} + +func NewSet_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_opContext { + var p = new(Set_opContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_set_op + + return p +} + +func (s *Set_opContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_opContext) UNION() antlr.TerminalNode { + return s.GetToken(BigQueryParserUNION, 0) +} + +func (s *Set_opContext) ALL() antlr.TerminalNode { + return s.GetToken(BigQueryParserALL, 0) +} + +func (s *Set_opContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDISTINCT, 0) +} + +func (s *Set_opContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(BigQueryParserINTERSECT, 0) +} + +func (s *Set_opContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(BigQueryParserEXCEPT, 0) +} + +func (s *Set_opContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_opContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterSet_op(s) + } +} + +func (s *Set_opContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitSet_op(s) + } +} + +func (s *Set_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitSet_op(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Set_op() (localctx ISet_opContext) { + localctx = NewSet_opContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, BigQueryParserRULE_set_op) + var _la int + + p.SetState(619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserUNION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(611) + p.Match(BigQueryParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == BigQueryParserALL || _la == BigQueryParserDISTINCT { + { + p.SetState(612) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserALL || _la == BigQueryParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case BigQueryParserINTERSECT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(615) + p.Match(BigQueryParserINTERSECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(616) + p.Match(BigQueryParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case BigQueryParserEXCEPT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(617) + p.Match(BigQueryParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(618) + p.Match(BigQueryParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_clauseContext is an interface to support dynamic dispatch. +type IUsing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllJoin_name() []IJoin_nameContext + Join_name(i int) IJoin_nameContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUsing_clauseContext differentiates from other interfaces. + IsUsing_clauseContext() +} + +type Using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_clauseContext() *Using_clauseContext { + var p = new(Using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_using_clause + return p +} + +func InitEmptyUsing_clauseContext(p *Using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_using_clause +} + +func (*Using_clauseContext) IsUsing_clauseContext() {} + +func NewUsing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_clauseContext { + var p = new(Using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_using_clause + + return p +} + +func (s *Using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(BigQueryParserUSING, 0) +} + +func (s *Using_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, 0) +} + +func (s *Using_clauseContext) AllJoin_name() []IJoin_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_nameContext); ok { + len++ + } + } + + tst := make([]IJoin_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_nameContext); ok { + tst[i] = t.(IJoin_nameContext) + i++ + } + } + + return tst +} + +func (s *Using_clauseContext) Join_name(i int) IJoin_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_nameContext) +} + +func (s *Using_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, 0) +} + +func (s *Using_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *Using_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *Using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterUsing_clause(s) + } +} + +func (s *Using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitUsing_clause(s) + } +} + +func (s *Using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitUsing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Using_clause() (localctx IUsing_clauseContext) { + localctx = NewUsing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, BigQueryParserRULE_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(621) + p.Match(BigQueryParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(622) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(623) + p.Join_name() + } + p.SetState(628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(624) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(625) + p.Join_name() + } + + p.SetState(630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(631) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IField_pathContext is an interface to support dynamic dispatch. +type IField_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsField_pathContext differentiates from other interfaces. + IsField_pathContext() +} + +type Field_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_pathContext() *Field_pathContext { + var p = new(Field_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_field_path + return p +} + +func InitEmptyField_pathContext(p *Field_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_field_path +} + +func (*Field_pathContext) IsField_pathContext() {} + +func NewField_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_pathContext { + var p = new(Field_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_field_path + + return p +} + +func (s *Field_pathContext) GetParser() antlr.Parser { return s.parser } +func (s *Field_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterField_path(s) + } +} + +func (s *Field_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitField_path(s) + } +} + +func (s *Field_pathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitField_path(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Field_path() (localctx IField_pathContext) { + localctx = NewField_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, BigQueryParserRULE_field_path) + p.EnterOuterAlt(localctx, 1) + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISstructContext is an interface to support dynamic dispatch. +type ISstructContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SSTRUCT() antlr.TerminalNode + LT() antlr.TerminalNode + Datatype_name() IDatatype_nameContext + GT() antlr.TerminalNode + + // IsSstructContext differentiates from other interfaces. + IsSstructContext() +} + +type SstructContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySstructContext() *SstructContext { + var p = new(SstructContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_sstruct + return p +} + +func InitEmptySstructContext(p *SstructContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_sstruct +} + +func (*SstructContext) IsSstructContext() {} + +func NewSstructContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SstructContext { + var p = new(SstructContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_sstruct + + return p +} + +func (s *SstructContext) GetParser() antlr.Parser { return s.parser } + +func (s *SstructContext) SSTRUCT() antlr.TerminalNode { + return s.GetToken(BigQueryParserSSTRUCT, 0) +} + +func (s *SstructContext) LT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLT, 0) +} + +func (s *SstructContext) Datatype_name() IDatatype_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatype_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatype_nameContext) +} + +func (s *SstructContext) GT() antlr.TerminalNode { + return s.GetToken(BigQueryParserGT, 0) +} + +func (s *SstructContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SstructContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SstructContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterSstruct(s) + } +} + +func (s *SstructContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitSstruct(s) + } +} + +func (s *SstructContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitSstruct(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Sstruct() (localctx ISstructContext) { + localctx = NewSstructContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, BigQueryParserRULE_sstruct) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(635) + p.Match(BigQueryParserSSTRUCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(636) + p.Match(BigQueryParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(637) + p.Datatype_name() + } + { + p.SetState(638) + p.Match(BigQueryParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_exprContext is an interface to support dynamic dispatch. +type IArray_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARRAY() antlr.TerminalNode + LT() antlr.TerminalNode + Datatype_name() IDatatype_nameContext + GT() antlr.TerminalNode + + // IsArray_exprContext differentiates from other interfaces. + IsArray_exprContext() +} + +type Array_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_exprContext() *Array_exprContext { + var p = new(Array_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_array_expr + return p +} + +func InitEmptyArray_exprContext(p *Array_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_array_expr +} + +func (*Array_exprContext) IsArray_exprContext() {} + +func NewArray_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_exprContext { + var p = new(Array_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_array_expr + + return p +} + +func (s *Array_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_exprContext) ARRAY() antlr.TerminalNode { + return s.GetToken(BigQueryParserARRAY, 0) +} + +func (s *Array_exprContext) LT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLT, 0) +} + +func (s *Array_exprContext) Datatype_name() IDatatype_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatype_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatype_nameContext) +} + +func (s *Array_exprContext) GT() antlr.TerminalNode { + return s.GetToken(BigQueryParserGT, 0) +} + +func (s *Array_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterArray_expr(s) + } +} + +func (s *Array_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitArray_expr(s) + } +} + +func (s *Array_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitArray_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Array_expr() (localctx IArray_exprContext) { + localctx = NewArray_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, BigQueryParserRULE_array_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(640) + p.Match(BigQueryParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(641) + p.Match(BigQueryParserLT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(642) + p.Datatype_name() + } + { + p.SetState(643) + p.Match(BigQueryParserGT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_pathContext is an interface to support dynamic dispatch. +type IArray_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsArray_pathContext differentiates from other interfaces. + IsArray_pathContext() +} + +type Array_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_pathContext() *Array_pathContext { + var p = new(Array_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_array_path + return p +} + +func InitEmptyArray_pathContext(p *Array_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_array_path +} + +func (*Array_pathContext) IsArray_pathContext() {} + +func NewArray_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_pathContext { + var p = new(Array_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_array_path + + return p +} + +func (s *Array_pathContext) GetParser() antlr.Parser { return s.parser } +func (s *Array_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterArray_path(s) + } +} + +func (s *Array_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitArray_path(s) + } +} + +func (s *Array_pathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitArray_path(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Array_path() (localctx IArray_pathContext) { + localctx = NewArray_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, BigQueryParserRULE_array_path) + p.EnterOuterAlt(localctx, 1) + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBool_expressionContext is an interface to support dynamic dispatch. +type IBool_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expr() IExprContext + + // IsBool_expressionContext differentiates from other interfaces. + IsBool_expressionContext() +} + +type Bool_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBool_expressionContext() *Bool_expressionContext { + var p = new(Bool_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_bool_expression + return p +} + +func InitEmptyBool_expressionContext(p *Bool_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_bool_expression +} + +func (*Bool_expressionContext) IsBool_expressionContext() {} + +func NewBool_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bool_expressionContext { + var p = new(Bool_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_bool_expression + + return p +} + +func (s *Bool_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bool_expressionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Bool_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bool_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bool_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterBool_expression(s) + } +} + +func (s *Bool_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitBool_expression(s) + } +} + +func (s *Bool_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitBool_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Bool_expression() (localctx IBool_expressionContext) { + localctx = NewBool_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, BigQueryParserRULE_bool_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(647) + p.expr(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_nameContext is an interface to support dynamic dispatch. +type IWindow_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsWindow_nameContext differentiates from other interfaces. + IsWindow_nameContext() +} + +type Window_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_nameContext() *Window_nameContext { + var p = new(Window_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_window_name + return p +} + +func InitEmptyWindow_nameContext(p *Window_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_window_name +} + +func (*Window_nameContext) IsWindow_nameContext() {} + +func NewWindow_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_nameContext { + var p = new(Window_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_window_name + + return p +} + +func (s *Window_nameContext) GetParser() antlr.Parser { return s.parser } +func (s *Window_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterWindow_name(s) + } +} + +func (s *Window_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitWindow_name(s) + } +} + +func (s *Window_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitWindow_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Window_name() (localctx IWindow_nameContext) { + localctx = NewWindow_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, BigQueryParserRULE_window_name) + p.EnterOuterAlt(localctx, 1) + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_definitionContext is an interface to support dynamic dispatch. +type IWindow_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsWindow_definitionContext differentiates from other interfaces. + IsWindow_definitionContext() +} + +type Window_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_definitionContext() *Window_definitionContext { + var p = new(Window_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_window_definition + return p +} + +func InitEmptyWindow_definitionContext(p *Window_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_window_definition +} + +func (*Window_definitionContext) IsWindow_definitionContext() {} + +func NewWindow_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definitionContext { + var p = new(Window_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_window_definition + + return p +} + +func (s *Window_definitionContext) GetParser() antlr.Parser { return s.parser } +func (s *Window_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterWindow_definition(s) + } +} + +func (s *Window_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitWindow_definition(s) + } +} + +func (s *Window_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitWindow_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Window_definition() (localctx IWindow_definitionContext) { + localctx = NewWindow_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, BigQueryParserRULE_window_definition) + p.EnterOuterAlt(localctx, 1) + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICountContext is an interface to support dynamic dispatch. +type ICountContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Number() INumberContext + + // IsCountContext differentiates from other interfaces. + IsCountContext() +} + +type CountContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCountContext() *CountContext { + var p = new(CountContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_count + return p +} + +func InitEmptyCountContext(p *CountContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_count +} + +func (*CountContext) IsCountContext() {} + +func NewCountContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CountContext { + var p = new(CountContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_count + + return p +} + +func (s *CountContext) GetParser() antlr.Parser { return s.parser } + +func (s *CountContext) Number() INumberContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumberContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumberContext) +} + +func (s *CountContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CountContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CountContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterCount(s) + } +} + +func (s *CountContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitCount(s) + } +} + +func (s *CountContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitCount(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Count() (localctx ICountContext) { + localctx = NewCountContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, BigQueryParserRULE_count) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(653) + p.Number() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISkip_rowsContext is an interface to support dynamic dispatch. +type ISkip_rowsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Number() INumberContext + + // IsSkip_rowsContext differentiates from other interfaces. + IsSkip_rowsContext() +} + +type Skip_rowsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySkip_rowsContext() *Skip_rowsContext { + var p = new(Skip_rowsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_skip_rows + return p +} + +func InitEmptySkip_rowsContext(p *Skip_rowsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_skip_rows +} + +func (*Skip_rowsContext) IsSkip_rowsContext() {} + +func NewSkip_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Skip_rowsContext { + var p = new(Skip_rowsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_skip_rows + + return p +} + +func (s *Skip_rowsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Skip_rowsContext) Number() INumberContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumberContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumberContext) +} + +func (s *Skip_rowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Skip_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Skip_rowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterSkip_rows(s) + } +} + +func (s *Skip_rowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitSkip_rows(s) + } +} + +func (s *Skip_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitSkip_rows(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Skip_rows() (localctx ISkip_rowsContext) { + localctx = NewSkip_rowsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, BigQueryParserRULE_skip_rows) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(655) + p.Number() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_statementContext is an interface to support dynamic dispatch. +type IWith_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + AllCte_name() []ICte_nameContext + Cte_name(i int) ICte_nameContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllQuery_expr() []IQuery_exprContext + Query_expr(i int) IQuery_exprContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWith_statementContext differentiates from other interfaces. + IsWith_statementContext() +} + +type With_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_statementContext() *With_statementContext { + var p = new(With_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_with_statement + return p +} + +func InitEmptyWith_statementContext(p *With_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_with_statement +} + +func (*With_statementContext) IsWith_statementContext() {} + +func NewWith_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_statementContext { + var p = new(With_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_with_statement + + return p +} + +func (s *With_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_statementContext) WITH() antlr.TerminalNode { + return s.GetToken(BigQueryParserWITH, 0) +} + +func (s *With_statementContext) AllCte_name() []ICte_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICte_nameContext); ok { + len++ + } + } + + tst := make([]ICte_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICte_nameContext); ok { + tst[i] = t.(ICte_nameContext) + i++ + } + } + + return tst +} + +func (s *With_statementContext) Cte_name(i int) ICte_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICte_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICte_nameContext) +} + +func (s *With_statementContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserAS) +} + +func (s *With_statementContext) AS(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserAS, i) +} + +func (s *With_statementContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserLR_BRACKET) +} + +func (s *With_statementContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserLR_BRACKET, i) +} + +func (s *With_statementContext) AllQuery_expr() []IQuery_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuery_exprContext); ok { + len++ + } + } + + tst := make([]IQuery_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuery_exprContext); ok { + tst[i] = t.(IQuery_exprContext) + i++ + } + } + + return tst +} + +func (s *With_statementContext) Query_expr(i int) IQuery_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuery_exprContext) +} + +func (s *With_statementContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserRR_BRACKET) +} + +func (s *With_statementContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserRR_BRACKET, i) +} + +func (s *With_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserCOMMA) +} + +func (s *With_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserCOMMA, i) +} + +func (s *With_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterWith_statement(s) + } +} + +func (s *With_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitWith_statement(s) + } +} + +func (s *With_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitWith_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) With_statement() (localctx IWith_statementContext) { + localctx = NewWith_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, BigQueryParserRULE_with_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(657) + p.Match(BigQueryParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(658) + p.Cte_name() + } + { + p.SetState(659) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(660) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(661) + p.query_expr(0) + } + { + p.SetState(662) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == BigQueryParserCOMMA { + { + p.SetState(663) + p.Match(BigQueryParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(664) + p.Cte_name() + } + { + p.SetState(665) + p.Match(BigQueryParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(666) + p.Match(BigQueryParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(667) + p.query_expr(0) + } + { + p.SetState(668) + p.Match(BigQueryParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INameContext is an interface to support dynamic dispatch. +type INameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ID() antlr.TerminalNode + QUOTED_ID() antlr.TerminalNode + + // IsNameContext differentiates from other interfaces. + IsNameContext() +} + +type NameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNameContext() *NameContext { + var p = new(NameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_name + return p +} + +func InitEmptyNameContext(p *NameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_name +} + +func (*NameContext) IsNameContext() {} + +func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext { + var p = new(NameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_name + + return p +} + +func (s *NameContext) GetParser() antlr.Parser { return s.parser } + +func (s *NameContext) ID() antlr.TerminalNode { + return s.GetToken(BigQueryParserID, 0) +} + +func (s *NameContext) QUOTED_ID() antlr.TerminalNode { + return s.GetToken(BigQueryParserQUOTED_ID, 0) +} + +func (s *NameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterName(s) + } +} + +func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitName(s) + } +} + +func (s *NameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Name() (localctx INameContext) { + localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, BigQueryParserRULE_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(675) + _la = p.GetTokenStream().LA(1) + + if !(_la == BigQueryParserQUOTED_ID || _la == BigQueryParserID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDot_nameContext is an interface to support dynamic dispatch. +type IDot_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOT() antlr.TerminalNode + Name() INameContext + Keyword() IKeywordContext + + // IsDot_nameContext differentiates from other interfaces. + IsDot_nameContext() +} + +type Dot_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDot_nameContext() *Dot_nameContext { + var p = new(Dot_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_dot_name + return p +} + +func InitEmptyDot_nameContext(p *Dot_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_dot_name +} + +func (*Dot_nameContext) IsDot_nameContext() {} + +func NewDot_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dot_nameContext { + var p = new(Dot_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_dot_name + + return p +} + +func (s *Dot_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dot_nameContext) DOT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDOT, 0) +} + +func (s *Dot_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Dot_nameContext) Keyword() IKeywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeywordContext) +} + +func (s *Dot_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dot_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dot_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterDot_name(s) + } +} + +func (s *Dot_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitDot_name(s) + } +} + +func (s *Dot_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitDot_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Dot_name() (localctx IDot_nameContext) { + localctx = NewDot_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, BigQueryParserRULE_dot_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(677) + p.Match(BigQueryParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserQUOTED_ID, BigQueryParserID: + { + p.SetState(678) + p.Name() + } + + case BigQueryParserALL, BigQueryParserAND, BigQueryParserANY, BigQueryParserARRAY, BigQueryParserAS, BigQueryParserASC, BigQueryParserASSERT_ROWS_MODIFIED, BigQueryParserAT, BigQueryParserBETWEEN, BigQueryParserBY, BigQueryParserCASE, BigQueryParserCAST, BigQueryParserCOLLATE, BigQueryParserCONTAINS, BigQueryParserCREATE, BigQueryParserCROSS, BigQueryParserCUBE, BigQueryParserCURRENT, BigQueryParserDEFAULT, BigQueryParserDEFINE, BigQueryParserDESC, BigQueryParserDISTINCT, BigQueryParserELSE, BigQueryParserEND, BigQueryParserENUM, BigQueryParserESCAPE, BigQueryParserEXCEPT, BigQueryParserEXCLUDE, BigQueryParserEXISTS, BigQueryParserEXTRACT, BigQueryParserFALSE, BigQueryParserFETCH, BigQueryParserFOLLOWING, BigQueryParserFOR, BigQueryParserFROM, BigQueryParserFULL, BigQueryParserGROUP, BigQueryParserGROUPING, BigQueryParserGROUPS, BigQueryParserHASH, BigQueryParserHAVING, BigQueryParserIF, BigQueryParserIGNORE, BigQueryParserIN, BigQueryParserINNER, BigQueryParserINTERSECT, BigQueryParserINTERVAL, BigQueryParserINTO, BigQueryParserIS, BigQueryParserJOIN, BigQueryParserLATERAL, BigQueryParserLEFT, BigQueryParserLIKE, BigQueryParserLIMIT, BigQueryParserLOOKUP, BigQueryParserMERGE, BigQueryParserNATURAL, BigQueryParserNEW, BigQueryParserNO, BigQueryParserNOT, BigQueryParserS_NULL, BigQueryParserNULLS, BigQueryParserOF, BigQueryParserOFFSET, BigQueryParserON, BigQueryParserOR, BigQueryParserORDER, BigQueryParserORDINAL, BigQueryParserOUTER, BigQueryParserOVER, BigQueryParserPARTITION, BigQueryParserPRECEDING, BigQueryParserPROTO, BigQueryParserRANGE, BigQueryParserRECURSIVE, BigQueryParserREPLACE, BigQueryParserRESPECT, BigQueryParserRIGHT, BigQueryParserROLLUP, BigQueryParserROWS, BigQueryParserSAFE_OFFSET, BigQueryParserSAFE_ORDINAL, BigQueryParserSELECT, BigQueryParserSET, BigQueryParserSOME, BigQueryParserSSTRUCT, BigQueryParserSYSTEM, BigQueryParserTABLESAMPLE, BigQueryParserTHEN, BigQueryParserTIME, BigQueryParserTO, BigQueryParserTREAT, BigQueryParserTRUE, BigQueryParserUNBOUNDED, BigQueryParserUNION, BigQueryParserUNNEST, BigQueryParserUSING, BigQueryParserWHEN, BigQueryParserWHERE, BigQueryParserWINDOW, BigQueryParserWITH, BigQueryParserWITHIN: + { + p.SetState(679) + p.Keyword() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlias_nameContext is an interface to support dynamic dispatch. +type IAlias_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsAlias_nameContext differentiates from other interfaces. + IsAlias_nameContext() +} + +type Alias_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlias_nameContext() *Alias_nameContext { + var p = new(Alias_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_alias_name + return p +} + +func InitEmptyAlias_nameContext(p *Alias_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_alias_name +} + +func (*Alias_nameContext) IsAlias_nameContext() {} + +func NewAlias_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alias_nameContext { + var p = new(Alias_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_alias_name + + return p +} + +func (s *Alias_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alias_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Alias_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alias_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alias_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterAlias_name(s) + } +} + +func (s *Alias_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitAlias_name(s) + } +} + +func (s *Alias_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitAlias_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Alias_name() (localctx IAlias_nameContext) { + localctx = NewAlias_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, BigQueryParserRULE_alias_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(682) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_nameContext is an interface to support dynamic dispatch. +type IArray_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsArray_nameContext differentiates from other interfaces. + IsArray_nameContext() +} + +type Array_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_nameContext() *Array_nameContext { + var p = new(Array_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_array_name + return p +} + +func InitEmptyArray_nameContext(p *Array_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_array_name +} + +func (*Array_nameContext) IsArray_nameContext() {} + +func NewArray_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_nameContext { + var p = new(Array_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_array_name + + return p +} + +func (s *Array_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Array_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterArray_name(s) + } +} + +func (s *Array_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitArray_name(s) + } +} + +func (s *Array_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitArray_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Array_name() (localctx IArray_nameContext) { + localctx = NewArray_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, BigQueryParserRULE_array_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(684) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_nameContext is an interface to support dynamic dispatch. +type IColumn_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsColumn_nameContext differentiates from other interfaces. + IsColumn_nameContext() +} + +type Column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_nameContext() *Column_nameContext { + var p = new(Column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_column_name + return p +} + +func InitEmptyColumn_nameContext(p *Column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_column_name +} + +func (*Column_nameContext) IsColumn_nameContext() {} + +func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_nameContext { + var p = new(Column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_column_name + + return p +} + +func (s *Column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterColumn_name(s) + } +} + +func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitColumn_name(s) + } +} + +func (s *Column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitColumn_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Column_name() (localctx IColumn_nameContext) { + localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, BigQueryParserRULE_column_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(686) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICte_nameContext is an interface to support dynamic dispatch. +type ICte_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsCte_nameContext differentiates from other interfaces. + IsCte_nameContext() +} + +type Cte_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCte_nameContext() *Cte_nameContext { + var p = new(Cte_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_cte_name + return p +} + +func InitEmptyCte_nameContext(p *Cte_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_cte_name +} + +func (*Cte_nameContext) IsCte_nameContext() {} + +func NewCte_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cte_nameContext { + var p = new(Cte_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_cte_name + + return p +} + +func (s *Cte_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cte_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Cte_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cte_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cte_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterCte_name(s) + } +} + +func (s *Cte_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitCte_name(s) + } +} + +func (s *Cte_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitCte_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Cte_name() (localctx ICte_nameContext) { + localctx = NewCte_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, BigQueryParserRULE_cte_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(688) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDataset_nameContext is an interface to support dynamic dispatch. +type IDataset_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsDataset_nameContext differentiates from other interfaces. + IsDataset_nameContext() +} + +type Dataset_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDataset_nameContext() *Dataset_nameContext { + var p = new(Dataset_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_dataset_name + return p +} + +func InitEmptyDataset_nameContext(p *Dataset_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_dataset_name +} + +func (*Dataset_nameContext) IsDataset_nameContext() {} + +func NewDataset_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dataset_nameContext { + var p = new(Dataset_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_dataset_name + + return p +} + +func (s *Dataset_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dataset_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Dataset_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dataset_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dataset_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterDataset_name(s) + } +} + +func (s *Dataset_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitDataset_name(s) + } +} + +func (s *Dataset_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitDataset_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Dataset_name() (localctx IDataset_nameContext) { + localctx = NewDataset_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, BigQueryParserRULE_dataset_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(690) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatatype_nameContext is an interface to support dynamic dispatch. +type IDatatype_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsDatatype_nameContext differentiates from other interfaces. + IsDatatype_nameContext() +} + +type Datatype_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatatype_nameContext() *Datatype_nameContext { + var p = new(Datatype_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_datatype_name + return p +} + +func InitEmptyDatatype_nameContext(p *Datatype_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_datatype_name +} + +func (*Datatype_nameContext) IsDatatype_nameContext() {} + +func NewDatatype_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datatype_nameContext { + var p = new(Datatype_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_datatype_name + + return p +} + +func (s *Datatype_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datatype_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Datatype_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datatype_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datatype_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterDatatype_name(s) + } +} + +func (s *Datatype_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitDatatype_name(s) + } +} + +func (s *Datatype_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitDatatype_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Datatype_name() (localctx IDatatype_nameContext) { + localctx = NewDatatype_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, BigQueryParserRULE_datatype_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(692) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_nameContext is an interface to support dynamic dispatch. +type IFunction_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsFunction_nameContext differentiates from other interfaces. + IsFunction_nameContext() +} + +type Function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_nameContext() *Function_nameContext { + var p = new(Function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_function_name + return p +} + +func InitEmptyFunction_nameContext(p *Function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_function_name +} + +func (*Function_nameContext) IsFunction_nameContext() {} + +func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext { + var p = new(Function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_function_name + + return p +} + +func (s *Function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterFunction_name(s) + } +} + +func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitFunction_name(s) + } +} + +func (s *Function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitFunction_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Function_name() (localctx IFunction_nameContext) { + localctx = NewFunction_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, BigQueryParserRULE_function_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(694) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_nameContext is an interface to support dynamic dispatch. +type IJoin_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsJoin_nameContext differentiates from other interfaces. + IsJoin_nameContext() +} + +type Join_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_nameContext() *Join_nameContext { + var p = new(Join_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_join_name + return p +} + +func InitEmptyJoin_nameContext(p *Join_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_join_name +} + +func (*Join_nameContext) IsJoin_nameContext() {} + +func NewJoin_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_nameContext { + var p = new(Join_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_join_name + + return p +} + +func (s *Join_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Join_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterJoin_name(s) + } +} + +func (s *Join_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitJoin_name(s) + } +} + +func (s *Join_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitJoin_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Join_name() (localctx IJoin_nameContext) { + localctx = NewJoin_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, BigQueryParserRULE_join_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(696) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMember_nameContext is an interface to support dynamic dispatch. +type IMember_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsMember_nameContext differentiates from other interfaces. + IsMember_nameContext() +} + +type Member_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMember_nameContext() *Member_nameContext { + var p = new(Member_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_member_name + return p +} + +func InitEmptyMember_nameContext(p *Member_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_member_name +} + +func (*Member_nameContext) IsMember_nameContext() {} + +func NewMember_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Member_nameContext { + var p = new(Member_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_member_name + + return p +} + +func (s *Member_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Member_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Member_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Member_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Member_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterMember_name(s) + } +} + +func (s *Member_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitMember_name(s) + } +} + +func (s *Member_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitMember_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Member_name() (localctx IMember_nameContext) { + localctx = NewMember_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, BigQueryParserRULE_member_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(698) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProject_nameContext is an interface to support dynamic dispatch. +type IProject_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsProject_nameContext differentiates from other interfaces. + IsProject_nameContext() +} + +type Project_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProject_nameContext() *Project_nameContext { + var p = new(Project_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_project_name + return p +} + +func InitEmptyProject_nameContext(p *Project_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_project_name +} + +func (*Project_nameContext) IsProject_nameContext() {} + +func NewProject_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Project_nameContext { + var p = new(Project_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_project_name + + return p +} + +func (s *Project_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Project_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Project_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Project_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Project_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterProject_name(s) + } +} + +func (s *Project_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitProject_name(s) + } +} + +func (s *Project_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitProject_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Project_name() (localctx IProject_nameContext) { + localctx = NewProject_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, BigQueryParserRULE_project_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(700) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStruct_nameContext is an interface to support dynamic dispatch. +type IStruct_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsStruct_nameContext differentiates from other interfaces. + IsStruct_nameContext() +} + +type Struct_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStruct_nameContext() *Struct_nameContext { + var p = new(Struct_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_struct_name + return p +} + +func InitEmptyStruct_nameContext(p *Struct_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_struct_name +} + +func (*Struct_nameContext) IsStruct_nameContext() {} + +func NewStruct_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Struct_nameContext { + var p = new(Struct_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_struct_name + + return p +} + +func (s *Struct_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Struct_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Struct_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Struct_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Struct_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterStruct_name(s) + } +} + +func (s *Struct_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitStruct_name(s) + } +} + +func (s *Struct_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitStruct_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Struct_name() (localctx IStruct_nameContext) { + localctx = NewStruct_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, BigQueryParserRULE_struct_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(702) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_nameContext is an interface to support dynamic dispatch. +type ITable_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsTable_nameContext differentiates from other interfaces. + IsTable_nameContext() +} + +type Table_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_nameContext() *Table_nameContext { + var p = new(Table_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_table_name + return p +} + +func InitEmptyTable_nameContext(p *Table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_table_name +} + +func (*Table_nameContext) IsTable_nameContext() {} + +func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext { + var p = new(Table_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_table_name + + return p +} + +func (s *Table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Table_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterTable_name(s) + } +} + +func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitTable_name(s) + } +} + +func (s *Table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitTable_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Table_name() (localctx ITable_nameContext) { + localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, BigQueryParserRULE_table_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(704) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_exprContext is an interface to support dynamic dispatch. +type ITable_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_name() ITable_nameContext + Dataset_name() IDataset_nameContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + Project_name() IProject_nameContext + AllBACKTICK() []antlr.TerminalNode + BACKTICK(i int) antlr.TerminalNode + Table_expr() ITable_exprContext + + // IsTable_exprContext differentiates from other interfaces. + IsTable_exprContext() +} + +type Table_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_exprContext() *Table_exprContext { + var p = new(Table_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_table_expr + return p +} + +func InitEmptyTable_exprContext(p *Table_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_table_expr +} + +func (*Table_exprContext) IsTable_exprContext() {} + +func NewTable_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_exprContext { + var p = new(Table_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_table_expr + + return p +} + +func (s *Table_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_exprContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Table_exprContext) Dataset_name() IDataset_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDataset_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDataset_nameContext) +} + +func (s *Table_exprContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserDOT) +} + +func (s *Table_exprContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserDOT, i) +} + +func (s *Table_exprContext) Project_name() IProject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProject_nameContext) +} + +func (s *Table_exprContext) AllBACKTICK() []antlr.TerminalNode { + return s.GetTokens(BigQueryParserBACKTICK) +} + +func (s *Table_exprContext) BACKTICK(i int) antlr.TerminalNode { + return s.GetToken(BigQueryParserBACKTICK, i) +} + +func (s *Table_exprContext) Table_expr() ITable_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_exprContext) +} + +func (s *Table_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterTable_expr(s) + } +} + +func (s *Table_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitTable_expr(s) + } +} + +func (s *Table_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitTable_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Table_expr() (localctx ITable_exprContext) { + localctx = NewTable_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, BigQueryParserRULE_table_expr) + p.SetState(721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserQUOTED_ID, BigQueryParserID: + p.EnterOuterAlt(localctx, 1) + p.SetState(714) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 91, p.GetParserRuleContext()) == 1 { + p.SetState(709) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 90, p.GetParserRuleContext()) == 1 { + { + p.SetState(706) + p.Project_name() + } + { + p.SetState(707) + p.Match(BigQueryParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(711) + p.Dataset_name() + } + { + p.SetState(712) + p.Match(BigQueryParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(716) + p.Table_name() + } + + case BigQueryParserBACKTICK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(717) + p.Match(BigQueryParserBACKTICK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(718) + p.Table_expr() + } + { + p.SetState(719) + p.Match(BigQueryParserBACKTICK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumberContext is an interface to support dynamic dispatch. +type INumberContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Integer_type() IInteger_typeContext + Float_type() IFloat_typeContext + + // IsNumberContext differentiates from other interfaces. + IsNumberContext() +} + +type NumberContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumberContext() *NumberContext { + var p = new(NumberContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_number + return p +} + +func InitEmptyNumberContext(p *NumberContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_number +} + +func (*NumberContext) IsNumberContext() {} + +func NewNumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumberContext { + var p = new(NumberContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_number + + return p +} + +func (s *NumberContext) GetParser() antlr.Parser { return s.parser } + +func (s *NumberContext) Integer_type() IInteger_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInteger_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInteger_typeContext) +} + +func (s *NumberContext) Float_type() IFloat_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFloat_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFloat_typeContext) +} + +func (s *NumberContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NumberContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterNumber(s) + } +} + +func (s *NumberContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitNumber(s) + } +} + +func (s *NumberContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitNumber(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Number() (localctx INumberContext) { + localctx = NewNumberContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, BigQueryParserRULE_number) + p.SetState(725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserINT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(723) + p.Integer_type() + } + + case BigQueryParserFLOAT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(724) + p.Float_type() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInteger_typeContext is an interface to support dynamic dispatch. +type IInteger_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INT() antlr.TerminalNode + + // IsInteger_typeContext differentiates from other interfaces. + IsInteger_typeContext() +} + +type Integer_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInteger_typeContext() *Integer_typeContext { + var p = new(Integer_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_integer_type + return p +} + +func InitEmptyInteger_typeContext(p *Integer_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_integer_type +} + +func (*Integer_typeContext) IsInteger_typeContext() {} + +func NewInteger_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Integer_typeContext { + var p = new(Integer_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_integer_type + + return p +} + +func (s *Integer_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Integer_typeContext) INT() antlr.TerminalNode { + return s.GetToken(BigQueryParserINT, 0) +} + +func (s *Integer_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Integer_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Integer_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterInteger_type(s) + } +} + +func (s *Integer_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitInteger_type(s) + } +} + +func (s *Integer_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitInteger_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Integer_type() (localctx IInteger_typeContext) { + localctx = NewInteger_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, BigQueryParserRULE_integer_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(727) + p.Match(BigQueryParserINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFloat_typeContext is an interface to support dynamic dispatch. +type IFloat_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FLOAT() antlr.TerminalNode + + // IsFloat_typeContext differentiates from other interfaces. + IsFloat_typeContext() +} + +type Float_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFloat_typeContext() *Float_typeContext { + var p = new(Float_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_float_type + return p +} + +func InitEmptyFloat_typeContext(p *Float_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_float_type +} + +func (*Float_typeContext) IsFloat_typeContext() {} + +func NewFloat_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Float_typeContext { + var p = new(Float_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_float_type + + return p +} + +func (s *Float_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Float_typeContext) FLOAT() antlr.TerminalNode { + return s.GetToken(BigQueryParserFLOAT, 0) +} + +func (s *Float_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Float_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Float_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterFloat_type(s) + } +} + +func (s *Float_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitFloat_type(s) + } +} + +func (s *Float_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitFloat_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Float_type() (localctx IFloat_typeContext) { + localctx = NewFloat_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, BigQueryParserRULE_float_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(729) + p.Match(BigQueryParserFLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStringContext is an interface to support dynamic dispatch. +type IStringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Quoted_string() IQuoted_stringContext + Triple_quoted_string() ITriple_quoted_stringContext + Raw_string() IRaw_stringContext + Byte_string() IByte_stringContext + Raw_byte_string() IRaw_byte_stringContext + Special_string() ISpecial_stringContext + + // IsStringContext differentiates from other interfaces. + IsStringContext() +} + +type StringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStringContext() *StringContext { + var p = new(StringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_string + return p +} + +func InitEmptyStringContext(p *StringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_string +} + +func (*StringContext) IsStringContext() {} + +func NewStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringContext { + var p = new(StringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_string + + return p +} + +func (s *StringContext) GetParser() antlr.Parser { return s.parser } + +func (s *StringContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *StringContext) Triple_quoted_string() ITriple_quoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriple_quoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriple_quoted_stringContext) +} + +func (s *StringContext) Raw_string() IRaw_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaw_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaw_stringContext) +} + +func (s *StringContext) Byte_string() IByte_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IByte_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IByte_stringContext) +} + +func (s *StringContext) Raw_byte_string() IRaw_byte_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaw_byte_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaw_byte_stringContext) +} + +func (s *StringContext) Special_string() ISpecial_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpecial_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpecial_stringContext) +} + +func (s *StringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterString(s) + } +} + +func (s *StringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitString(s) + } +} + +func (s *StringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitString(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) String_() (localctx IStringContext) { + localctx = NewStringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, BigQueryParserRULE_string) + p.SetState(737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case BigQueryParserQUOTED_STRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(731) + p.Quoted_string() + } + + case BigQueryParserTRIPLE_QUOTED_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(732) + p.Triple_quoted_string() + } + + case BigQueryParserRAW_STRING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(733) + p.Raw_string() + } + + case BigQueryParserBYTE_STRING: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(734) + p.Byte_string() + } + + case BigQueryParserRAW_BYTE_STRING: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(735) + p.Raw_byte_string() + } + + case BigQueryParserQUOTED_ID, BigQueryParserID: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(736) + p.Special_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuoted_stringContext is an interface to support dynamic dispatch. +type IQuoted_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUOTED_STRING() antlr.TerminalNode + + // IsQuoted_stringContext differentiates from other interfaces. + IsQuoted_stringContext() +} + +type Quoted_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuoted_stringContext() *Quoted_stringContext { + var p = new(Quoted_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_quoted_string + return p +} + +func InitEmptyQuoted_stringContext(p *Quoted_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_quoted_string +} + +func (*Quoted_stringContext) IsQuoted_stringContext() {} + +func NewQuoted_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quoted_stringContext { + var p = new(Quoted_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_quoted_string + + return p +} + +func (s *Quoted_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quoted_stringContext) QUOTED_STRING() antlr.TerminalNode { + return s.GetToken(BigQueryParserQUOTED_STRING, 0) +} + +func (s *Quoted_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quoted_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quoted_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterQuoted_string(s) + } +} + +func (s *Quoted_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitQuoted_string(s) + } +} + +func (s *Quoted_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitQuoted_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Quoted_string() (localctx IQuoted_stringContext) { + localctx = NewQuoted_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, BigQueryParserRULE_quoted_string) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(739) + p.Match(BigQueryParserQUOTED_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriple_quoted_stringContext is an interface to support dynamic dispatch. +type ITriple_quoted_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRIPLE_QUOTED_STRING() antlr.TerminalNode + + // IsTriple_quoted_stringContext differentiates from other interfaces. + IsTriple_quoted_stringContext() +} + +type Triple_quoted_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriple_quoted_stringContext() *Triple_quoted_stringContext { + var p = new(Triple_quoted_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_triple_quoted_string + return p +} + +func InitEmptyTriple_quoted_stringContext(p *Triple_quoted_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_triple_quoted_string +} + +func (*Triple_quoted_stringContext) IsTriple_quoted_stringContext() {} + +func NewTriple_quoted_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Triple_quoted_stringContext { + var p = new(Triple_quoted_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_triple_quoted_string + + return p +} + +func (s *Triple_quoted_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Triple_quoted_stringContext) TRIPLE_QUOTED_STRING() antlr.TerminalNode { + return s.GetToken(BigQueryParserTRIPLE_QUOTED_STRING, 0) +} + +func (s *Triple_quoted_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Triple_quoted_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Triple_quoted_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterTriple_quoted_string(s) + } +} + +func (s *Triple_quoted_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitTriple_quoted_string(s) + } +} + +func (s *Triple_quoted_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitTriple_quoted_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Triple_quoted_string() (localctx ITriple_quoted_stringContext) { + localctx = NewTriple_quoted_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, BigQueryParserRULE_triple_quoted_string) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(741) + p.Match(BigQueryParserTRIPLE_QUOTED_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRaw_stringContext is an interface to support dynamic dispatch. +type IRaw_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RAW_STRING() antlr.TerminalNode + + // IsRaw_stringContext differentiates from other interfaces. + IsRaw_stringContext() +} + +type Raw_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRaw_stringContext() *Raw_stringContext { + var p = new(Raw_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_raw_string + return p +} + +func InitEmptyRaw_stringContext(p *Raw_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_raw_string +} + +func (*Raw_stringContext) IsRaw_stringContext() {} + +func NewRaw_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raw_stringContext { + var p = new(Raw_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_raw_string + + return p +} + +func (s *Raw_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raw_stringContext) RAW_STRING() antlr.TerminalNode { + return s.GetToken(BigQueryParserRAW_STRING, 0) +} + +func (s *Raw_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raw_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raw_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterRaw_string(s) + } +} + +func (s *Raw_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitRaw_string(s) + } +} + +func (s *Raw_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitRaw_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Raw_string() (localctx IRaw_stringContext) { + localctx = NewRaw_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, BigQueryParserRULE_raw_string) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(743) + p.Match(BigQueryParserRAW_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IByte_stringContext is an interface to support dynamic dispatch. +type IByte_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BYTE_STRING() antlr.TerminalNode + + // IsByte_stringContext differentiates from other interfaces. + IsByte_stringContext() +} + +type Byte_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyByte_stringContext() *Byte_stringContext { + var p = new(Byte_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_byte_string + return p +} + +func InitEmptyByte_stringContext(p *Byte_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_byte_string +} + +func (*Byte_stringContext) IsByte_stringContext() {} + +func NewByte_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Byte_stringContext { + var p = new(Byte_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_byte_string + + return p +} + +func (s *Byte_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Byte_stringContext) BYTE_STRING() antlr.TerminalNode { + return s.GetToken(BigQueryParserBYTE_STRING, 0) +} + +func (s *Byte_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Byte_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Byte_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterByte_string(s) + } +} + +func (s *Byte_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitByte_string(s) + } +} + +func (s *Byte_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitByte_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Byte_string() (localctx IByte_stringContext) { + localctx = NewByte_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, BigQueryParserRULE_byte_string) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(745) + p.Match(BigQueryParserBYTE_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRaw_byte_stringContext is an interface to support dynamic dispatch. +type IRaw_byte_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RAW_BYTE_STRING() antlr.TerminalNode + + // IsRaw_byte_stringContext differentiates from other interfaces. + IsRaw_byte_stringContext() +} + +type Raw_byte_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRaw_byte_stringContext() *Raw_byte_stringContext { + var p = new(Raw_byte_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_raw_byte_string + return p +} + +func InitEmptyRaw_byte_stringContext(p *Raw_byte_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_raw_byte_string +} + +func (*Raw_byte_stringContext) IsRaw_byte_stringContext() {} + +func NewRaw_byte_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raw_byte_stringContext { + var p = new(Raw_byte_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_raw_byte_string + + return p +} + +func (s *Raw_byte_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raw_byte_stringContext) RAW_BYTE_STRING() antlr.TerminalNode { + return s.GetToken(BigQueryParserRAW_BYTE_STRING, 0) +} + +func (s *Raw_byte_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raw_byte_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raw_byte_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterRaw_byte_string(s) + } +} + +func (s *Raw_byte_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitRaw_byte_string(s) + } +} + +func (s *Raw_byte_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitRaw_byte_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Raw_byte_string() (localctx IRaw_byte_stringContext) { + localctx = NewRaw_byte_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, BigQueryParserRULE_raw_byte_string) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(747) + p.Match(BigQueryParserRAW_BYTE_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpecial_stringContext is an interface to support dynamic dispatch. +type ISpecial_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Datatype_name() IDatatype_nameContext + QUOTED_STRING() antlr.TerminalNode + + // IsSpecial_stringContext differentiates from other interfaces. + IsSpecial_stringContext() +} + +type Special_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpecial_stringContext() *Special_stringContext { + var p = new(Special_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_special_string + return p +} + +func InitEmptySpecial_stringContext(p *Special_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_special_string +} + +func (*Special_stringContext) IsSpecial_stringContext() {} + +func NewSpecial_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Special_stringContext { + var p = new(Special_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_special_string + + return p +} + +func (s *Special_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Special_stringContext) Datatype_name() IDatatype_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatype_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatype_nameContext) +} + +func (s *Special_stringContext) QUOTED_STRING() antlr.TerminalNode { + return s.GetToken(BigQueryParserQUOTED_STRING, 0) +} + +func (s *Special_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Special_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Special_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterSpecial_string(s) + } +} + +func (s *Special_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitSpecial_string(s) + } +} + +func (s *Special_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitSpecial_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Special_string() (localctx ISpecial_stringContext) { + localctx = NewSpecial_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, BigQueryParserRULE_special_string) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(749) + p.Datatype_name() + } + { + p.SetState(750) + p.Match(BigQueryParserQUOTED_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeywordContext is an interface to support dynamic dispatch. +type IKeywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + AND() antlr.TerminalNode + ANY() antlr.TerminalNode + ARRAY() antlr.TerminalNode + AS() antlr.TerminalNode + ASC() antlr.TerminalNode + ASSERT_ROWS_MODIFIED() antlr.TerminalNode + AT() antlr.TerminalNode + BETWEEN() antlr.TerminalNode + BY() antlr.TerminalNode + CASE() antlr.TerminalNode + CAST() antlr.TerminalNode + COLLATE() antlr.TerminalNode + CONTAINS() antlr.TerminalNode + CREATE() antlr.TerminalNode + CROSS() antlr.TerminalNode + CUBE() antlr.TerminalNode + CURRENT() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + DEFINE() antlr.TerminalNode + DESC() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + ELSE() antlr.TerminalNode + END() antlr.TerminalNode + ENUM() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + EXISTS() antlr.TerminalNode + EXTRACT() antlr.TerminalNode + FALSE() antlr.TerminalNode + FETCH() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + FOR() antlr.TerminalNode + FROM() antlr.TerminalNode + FULL() antlr.TerminalNode + GROUP() antlr.TerminalNode + GROUPING() antlr.TerminalNode + GROUPS() antlr.TerminalNode + HASH() antlr.TerminalNode + HAVING() antlr.TerminalNode + IF() antlr.TerminalNode + IGNORE() antlr.TerminalNode + IN() antlr.TerminalNode + INNER() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + INTO() antlr.TerminalNode + IS() antlr.TerminalNode + JOIN() antlr.TerminalNode + LATERAL() antlr.TerminalNode + LEFT() antlr.TerminalNode + LIKE() antlr.TerminalNode + LIMIT() antlr.TerminalNode + LOOKUP() antlr.TerminalNode + MERGE() antlr.TerminalNode + NATURAL() antlr.TerminalNode + NEW() antlr.TerminalNode + NO() antlr.TerminalNode + NOT() antlr.TerminalNode + S_NULL() antlr.TerminalNode + NULLS() antlr.TerminalNode + OF() antlr.TerminalNode + OFFSET() antlr.TerminalNode + ON() antlr.TerminalNode + OR() antlr.TerminalNode + ORDER() antlr.TerminalNode + ORDINAL() antlr.TerminalNode + OUTER() antlr.TerminalNode + OVER() antlr.TerminalNode + PARTITION() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + PROTO() antlr.TerminalNode + RANGE() antlr.TerminalNode + RECURSIVE() antlr.TerminalNode + REPLACE() antlr.TerminalNode + RESPECT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + ROWS() antlr.TerminalNode + SAFE_OFFSET() antlr.TerminalNode + SAFE_ORDINAL() antlr.TerminalNode + SELECT() antlr.TerminalNode + SET() antlr.TerminalNode + SOME() antlr.TerminalNode + SSTRUCT() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + TABLESAMPLE() antlr.TerminalNode + THEN() antlr.TerminalNode + TIME() antlr.TerminalNode + TO() antlr.TerminalNode + TREAT() antlr.TerminalNode + TRUE() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + UNION() antlr.TerminalNode + UNNEST() antlr.TerminalNode + USING() antlr.TerminalNode + WHEN() antlr.TerminalNode + WHERE() antlr.TerminalNode + WINDOW() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHIN() antlr.TerminalNode + + // IsKeywordContext differentiates from other interfaces. + IsKeywordContext() +} + +type KeywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeywordContext() *KeywordContext { + var p = new(KeywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_keyword + return p +} + +func InitEmptyKeywordContext(p *KeywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = BigQueryParserRULE_keyword +} + +func (*KeywordContext) IsKeywordContext() {} + +func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext { + var p = new(KeywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = BigQueryParserRULE_keyword + + return p +} + +func (s *KeywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *KeywordContext) ALL() antlr.TerminalNode { + return s.GetToken(BigQueryParserALL, 0) +} + +func (s *KeywordContext) AND() antlr.TerminalNode { + return s.GetToken(BigQueryParserAND, 0) +} + +func (s *KeywordContext) ANY() antlr.TerminalNode { + return s.GetToken(BigQueryParserANY, 0) +} + +func (s *KeywordContext) ARRAY() antlr.TerminalNode { + return s.GetToken(BigQueryParserARRAY, 0) +} + +func (s *KeywordContext) AS() antlr.TerminalNode { + return s.GetToken(BigQueryParserAS, 0) +} + +func (s *KeywordContext) ASC() antlr.TerminalNode { + return s.GetToken(BigQueryParserASC, 0) +} + +func (s *KeywordContext) ASSERT_ROWS_MODIFIED() antlr.TerminalNode { + return s.GetToken(BigQueryParserASSERT_ROWS_MODIFIED, 0) +} + +func (s *KeywordContext) AT() antlr.TerminalNode { + return s.GetToken(BigQueryParserAT, 0) +} + +func (s *KeywordContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(BigQueryParserBETWEEN, 0) +} + +func (s *KeywordContext) BY() antlr.TerminalNode { + return s.GetToken(BigQueryParserBY, 0) +} + +func (s *KeywordContext) CASE() antlr.TerminalNode { + return s.GetToken(BigQueryParserCASE, 0) +} + +func (s *KeywordContext) CAST() antlr.TerminalNode { + return s.GetToken(BigQueryParserCAST, 0) +} + +func (s *KeywordContext) COLLATE() antlr.TerminalNode { + return s.GetToken(BigQueryParserCOLLATE, 0) +} + +func (s *KeywordContext) CONTAINS() antlr.TerminalNode { + return s.GetToken(BigQueryParserCONTAINS, 0) +} + +func (s *KeywordContext) CREATE() antlr.TerminalNode { + return s.GetToken(BigQueryParserCREATE, 0) +} + +func (s *KeywordContext) CROSS() antlr.TerminalNode { + return s.GetToken(BigQueryParserCROSS, 0) +} + +func (s *KeywordContext) CUBE() antlr.TerminalNode { + return s.GetToken(BigQueryParserCUBE, 0) +} + +func (s *KeywordContext) CURRENT() antlr.TerminalNode { + return s.GetToken(BigQueryParserCURRENT, 0) +} + +func (s *KeywordContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDEFAULT, 0) +} + +func (s *KeywordContext) DEFINE() antlr.TerminalNode { + return s.GetToken(BigQueryParserDEFINE, 0) +} + +func (s *KeywordContext) DESC() antlr.TerminalNode { + return s.GetToken(BigQueryParserDESC, 0) +} + +func (s *KeywordContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(BigQueryParserDISTINCT, 0) +} + +func (s *KeywordContext) ELSE() antlr.TerminalNode { + return s.GetToken(BigQueryParserELSE, 0) +} + +func (s *KeywordContext) END() antlr.TerminalNode { + return s.GetToken(BigQueryParserEND, 0) +} + +func (s *KeywordContext) ENUM() antlr.TerminalNode { + return s.GetToken(BigQueryParserENUM, 0) +} + +func (s *KeywordContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(BigQueryParserESCAPE, 0) +} + +func (s *KeywordContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(BigQueryParserEXCEPT, 0) +} + +func (s *KeywordContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(BigQueryParserEXCLUDE, 0) +} + +func (s *KeywordContext) EXISTS() antlr.TerminalNode { + return s.GetToken(BigQueryParserEXISTS, 0) +} + +func (s *KeywordContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(BigQueryParserEXTRACT, 0) +} + +func (s *KeywordContext) FALSE() antlr.TerminalNode { + return s.GetToken(BigQueryParserFALSE, 0) +} + +func (s *KeywordContext) FETCH() antlr.TerminalNode { + return s.GetToken(BigQueryParserFETCH, 0) +} + +func (s *KeywordContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(BigQueryParserFOLLOWING, 0) +} + +func (s *KeywordContext) FOR() antlr.TerminalNode { + return s.GetToken(BigQueryParserFOR, 0) +} + +func (s *KeywordContext) FROM() antlr.TerminalNode { + return s.GetToken(BigQueryParserFROM, 0) +} + +func (s *KeywordContext) FULL() antlr.TerminalNode { + return s.GetToken(BigQueryParserFULL, 0) +} + +func (s *KeywordContext) GROUP() antlr.TerminalNode { + return s.GetToken(BigQueryParserGROUP, 0) +} + +func (s *KeywordContext) GROUPING() antlr.TerminalNode { + return s.GetToken(BigQueryParserGROUPING, 0) +} + +func (s *KeywordContext) GROUPS() antlr.TerminalNode { + return s.GetToken(BigQueryParserGROUPS, 0) +} + +func (s *KeywordContext) HASH() antlr.TerminalNode { + return s.GetToken(BigQueryParserHASH, 0) +} + +func (s *KeywordContext) HAVING() antlr.TerminalNode { + return s.GetToken(BigQueryParserHAVING, 0) +} + +func (s *KeywordContext) IF() antlr.TerminalNode { + return s.GetToken(BigQueryParserIF, 0) +} + +func (s *KeywordContext) IGNORE() antlr.TerminalNode { + return s.GetToken(BigQueryParserIGNORE, 0) +} + +func (s *KeywordContext) IN() antlr.TerminalNode { + return s.GetToken(BigQueryParserIN, 0) +} + +func (s *KeywordContext) INNER() antlr.TerminalNode { + return s.GetToken(BigQueryParserINNER, 0) +} + +func (s *KeywordContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(BigQueryParserINTERSECT, 0) +} + +func (s *KeywordContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(BigQueryParserINTERVAL, 0) +} + +func (s *KeywordContext) INTO() antlr.TerminalNode { + return s.GetToken(BigQueryParserINTO, 0) +} + +func (s *KeywordContext) IS() antlr.TerminalNode { + return s.GetToken(BigQueryParserIS, 0) +} + +func (s *KeywordContext) JOIN() antlr.TerminalNode { + return s.GetToken(BigQueryParserJOIN, 0) +} + +func (s *KeywordContext) LATERAL() antlr.TerminalNode { + return s.GetToken(BigQueryParserLATERAL, 0) +} + +func (s *KeywordContext) LEFT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLEFT, 0) +} + +func (s *KeywordContext) LIKE() antlr.TerminalNode { + return s.GetToken(BigQueryParserLIKE, 0) +} + +func (s *KeywordContext) LIMIT() antlr.TerminalNode { + return s.GetToken(BigQueryParserLIMIT, 0) +} + +func (s *KeywordContext) LOOKUP() antlr.TerminalNode { + return s.GetToken(BigQueryParserLOOKUP, 0) +} + +func (s *KeywordContext) MERGE() antlr.TerminalNode { + return s.GetToken(BigQueryParserMERGE, 0) +} + +func (s *KeywordContext) NATURAL() antlr.TerminalNode { + return s.GetToken(BigQueryParserNATURAL, 0) +} + +func (s *KeywordContext) NEW() antlr.TerminalNode { + return s.GetToken(BigQueryParserNEW, 0) +} + +func (s *KeywordContext) NO() antlr.TerminalNode { + return s.GetToken(BigQueryParserNO, 0) +} + +func (s *KeywordContext) NOT() antlr.TerminalNode { + return s.GetToken(BigQueryParserNOT, 0) +} + +func (s *KeywordContext) S_NULL() antlr.TerminalNode { + return s.GetToken(BigQueryParserS_NULL, 0) +} + +func (s *KeywordContext) NULLS() antlr.TerminalNode { + return s.GetToken(BigQueryParserNULLS, 0) +} + +func (s *KeywordContext) OF() antlr.TerminalNode { + return s.GetToken(BigQueryParserOF, 0) +} + +func (s *KeywordContext) OFFSET() antlr.TerminalNode { + return s.GetToken(BigQueryParserOFFSET, 0) +} + +func (s *KeywordContext) ON() antlr.TerminalNode { + return s.GetToken(BigQueryParserON, 0) +} + +func (s *KeywordContext) OR() antlr.TerminalNode { + return s.GetToken(BigQueryParserOR, 0) +} + +func (s *KeywordContext) ORDER() antlr.TerminalNode { + return s.GetToken(BigQueryParserORDER, 0) +} + +func (s *KeywordContext) ORDINAL() antlr.TerminalNode { + return s.GetToken(BigQueryParserORDINAL, 0) +} + +func (s *KeywordContext) OUTER() antlr.TerminalNode { + return s.GetToken(BigQueryParserOUTER, 0) +} + +func (s *KeywordContext) OVER() antlr.TerminalNode { + return s.GetToken(BigQueryParserOVER, 0) +} + +func (s *KeywordContext) PARTITION() antlr.TerminalNode { + return s.GetToken(BigQueryParserPARTITION, 0) +} + +func (s *KeywordContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(BigQueryParserPRECEDING, 0) +} + +func (s *KeywordContext) PROTO() antlr.TerminalNode { + return s.GetToken(BigQueryParserPROTO, 0) +} + +func (s *KeywordContext) RANGE() antlr.TerminalNode { + return s.GetToken(BigQueryParserRANGE, 0) +} + +func (s *KeywordContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(BigQueryParserRECURSIVE, 0) +} + +func (s *KeywordContext) REPLACE() antlr.TerminalNode { + return s.GetToken(BigQueryParserREPLACE, 0) +} + +func (s *KeywordContext) RESPECT() antlr.TerminalNode { + return s.GetToken(BigQueryParserRESPECT, 0) +} + +func (s *KeywordContext) RIGHT() antlr.TerminalNode { + return s.GetToken(BigQueryParserRIGHT, 0) +} + +func (s *KeywordContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(BigQueryParserROLLUP, 0) +} + +func (s *KeywordContext) ROWS() antlr.TerminalNode { + return s.GetToken(BigQueryParserROWS, 0) +} + +func (s *KeywordContext) SAFE_OFFSET() antlr.TerminalNode { + return s.GetToken(BigQueryParserSAFE_OFFSET, 0) +} + +func (s *KeywordContext) SAFE_ORDINAL() antlr.TerminalNode { + return s.GetToken(BigQueryParserSAFE_ORDINAL, 0) +} + +func (s *KeywordContext) SELECT() antlr.TerminalNode { + return s.GetToken(BigQueryParserSELECT, 0) +} + +func (s *KeywordContext) SET() antlr.TerminalNode { + return s.GetToken(BigQueryParserSET, 0) +} + +func (s *KeywordContext) SOME() antlr.TerminalNode { + return s.GetToken(BigQueryParserSOME, 0) +} + +func (s *KeywordContext) SSTRUCT() antlr.TerminalNode { + return s.GetToken(BigQueryParserSSTRUCT, 0) +} + +func (s *KeywordContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(BigQueryParserSYSTEM, 0) +} + +func (s *KeywordContext) TABLESAMPLE() antlr.TerminalNode { + return s.GetToken(BigQueryParserTABLESAMPLE, 0) +} + +func (s *KeywordContext) THEN() antlr.TerminalNode { + return s.GetToken(BigQueryParserTHEN, 0) +} + +func (s *KeywordContext) TIME() antlr.TerminalNode { + return s.GetToken(BigQueryParserTIME, 0) +} + +func (s *KeywordContext) TO() antlr.TerminalNode { + return s.GetToken(BigQueryParserTO, 0) +} + +func (s *KeywordContext) TREAT() antlr.TerminalNode { + return s.GetToken(BigQueryParserTREAT, 0) +} + +func (s *KeywordContext) TRUE() antlr.TerminalNode { + return s.GetToken(BigQueryParserTRUE, 0) +} + +func (s *KeywordContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(BigQueryParserUNBOUNDED, 0) +} + +func (s *KeywordContext) UNION() antlr.TerminalNode { + return s.GetToken(BigQueryParserUNION, 0) +} + +func (s *KeywordContext) UNNEST() antlr.TerminalNode { + return s.GetToken(BigQueryParserUNNEST, 0) +} + +func (s *KeywordContext) USING() antlr.TerminalNode { + return s.GetToken(BigQueryParserUSING, 0) +} + +func (s *KeywordContext) WHEN() antlr.TerminalNode { + return s.GetToken(BigQueryParserWHEN, 0) +} + +func (s *KeywordContext) WHERE() antlr.TerminalNode { + return s.GetToken(BigQueryParserWHERE, 0) +} + +func (s *KeywordContext) WINDOW() antlr.TerminalNode { + return s.GetToken(BigQueryParserWINDOW, 0) +} + +func (s *KeywordContext) WITH() antlr.TerminalNode { + return s.GetToken(BigQueryParserWITH, 0) +} + +func (s *KeywordContext) WITHIN() antlr.TerminalNode { + return s.GetToken(BigQueryParserWITHIN, 0) +} + +func (s *KeywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.EnterKeyword(s) + } +} + +func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(BigQueryParserListener); ok { + listenerT.ExitKeyword(s) + } +} + +func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case BigQueryParserVisitor: + return t.VisitKeyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *BigQueryParser) Keyword() (localctx IKeywordContext) { + localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, BigQueryParserRULE_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(752) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-16) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&4398046511103) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +func (p *BigQueryParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 4: + var t *Query_exprContext = nil + if localctx != nil { + t = localctx.(*Query_exprContext) + } + return p.Query_expr_Sempred(t, predIndex) + + case 7: + var t *From_itemContext = nil + if localctx != nil { + t = localctx.(*From_itemContext) + } + return p.From_item_Sempred(t, predIndex) + + case 15: + var t *ExprContext = nil + if localctx != nil { + t = localctx.(*ExprContext) + } + return p.Expr_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *BigQueryParser) Query_expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *BigQueryParser) From_item_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 1: + return p.Precpred(p.GetParserRuleContext(), 6) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *BigQueryParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 2: + return p.Precpred(p.GetParserRuleContext(), 19) + + case 3: + return p.Precpred(p.GetParserRuleContext(), 18) + + case 4: + return p.Precpred(p.GetParserRuleContext(), 17) + + case 5: + return p.Precpred(p.GetParserRuleContext(), 16) + + case 6: + return p.Precpred(p.GetParserRuleContext(), 15) + + case 7: + return p.Precpred(p.GetParserRuleContext(), 14) + + case 8: + return p.Precpred(p.GetParserRuleContext(), 13) + + case 9: + return p.Precpred(p.GetParserRuleContext(), 8) + + case 10: + return p.Precpred(p.GetParserRuleContext(), 7) + + case 11: + return p.Precpred(p.GetParserRuleContext(), 12) + + case 12: + return p.Precpred(p.GetParserRuleContext(), 9) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/bq/bigqueryparser_base_listener.go b/bq/bigqueryparser_base_listener.go new file mode 100644 index 0000000..9a07fff --- /dev/null +++ b/bq/bigqueryparser_base_listener.go @@ -0,0 +1,381 @@ +// Code generated from BigQueryParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package bq // BigQueryParser +import "github.com/antlr4-go/antlr/v4" + +// BaseBigQueryParserListener is a complete listener for a parse tree produced by BigQueryParser. +type BaseBigQueryParserListener struct{} + +var _ BigQueryParserListener = &BaseBigQueryParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseBigQueryParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseBigQueryParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseBigQueryParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseBigQueryParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterRoot is called when production root is entered. +func (s *BaseBigQueryParserListener) EnterRoot(ctx *RootContext) {} + +// ExitRoot is called when production root is exited. +func (s *BaseBigQueryParserListener) ExitRoot(ctx *RootContext) {} + +// EnterStmtmulti is called when production stmtmulti is entered. +func (s *BaseBigQueryParserListener) EnterStmtmulti(ctx *StmtmultiContext) {} + +// ExitStmtmulti is called when production stmtmulti is exited. +func (s *BaseBigQueryParserListener) ExitStmtmulti(ctx *StmtmultiContext) {} + +// EnterStmt is called when production stmt is entered. +func (s *BaseBigQueryParserListener) EnterStmt(ctx *StmtContext) {} + +// ExitStmt is called when production stmt is exited. +func (s *BaseBigQueryParserListener) ExitStmt(ctx *StmtContext) {} + +// EnterQuery_statement is called when production query_statement is entered. +func (s *BaseBigQueryParserListener) EnterQuery_statement(ctx *Query_statementContext) {} + +// ExitQuery_statement is called when production query_statement is exited. +func (s *BaseBigQueryParserListener) ExitQuery_statement(ctx *Query_statementContext) {} + +// EnterQuery_expr is called when production query_expr is entered. +func (s *BaseBigQueryParserListener) EnterQuery_expr(ctx *Query_exprContext) {} + +// ExitQuery_expr is called when production query_expr is exited. +func (s *BaseBigQueryParserListener) ExitQuery_expr(ctx *Query_exprContext) {} + +// EnterSelect_statement is called when production select_statement is entered. +func (s *BaseBigQueryParserListener) EnterSelect_statement(ctx *Select_statementContext) {} + +// ExitSelect_statement is called when production select_statement is exited. +func (s *BaseBigQueryParserListener) ExitSelect_statement(ctx *Select_statementContext) {} + +// EnterFrom_statement is called when production from_statement is entered. +func (s *BaseBigQueryParserListener) EnterFrom_statement(ctx *From_statementContext) {} + +// ExitFrom_statement is called when production from_statement is exited. +func (s *BaseBigQueryParserListener) ExitFrom_statement(ctx *From_statementContext) {} + +// EnterFrom_item is called when production from_item is entered. +func (s *BaseBigQueryParserListener) EnterFrom_item(ctx *From_itemContext) {} + +// ExitFrom_item is called when production from_item is exited. +func (s *BaseBigQueryParserListener) ExitFrom_item(ctx *From_itemContext) {} + +// EnterWhere_statement is called when production where_statement is entered. +func (s *BaseBigQueryParserListener) EnterWhere_statement(ctx *Where_statementContext) {} + +// ExitWhere_statement is called when production where_statement is exited. +func (s *BaseBigQueryParserListener) ExitWhere_statement(ctx *Where_statementContext) {} + +// EnterGroup_statement is called when production group_statement is entered. +func (s *BaseBigQueryParserListener) EnterGroup_statement(ctx *Group_statementContext) {} + +// ExitGroup_statement is called when production group_statement is exited. +func (s *BaseBigQueryParserListener) ExitGroup_statement(ctx *Group_statementContext) {} + +// EnterHaving_statement is called when production having_statement is entered. +func (s *BaseBigQueryParserListener) EnterHaving_statement(ctx *Having_statementContext) {} + +// ExitHaving_statement is called when production having_statement is exited. +func (s *BaseBigQueryParserListener) ExitHaving_statement(ctx *Having_statementContext) {} + +// EnterWindow_statement is called when production window_statement is entered. +func (s *BaseBigQueryParserListener) EnterWindow_statement(ctx *Window_statementContext) {} + +// ExitWindow_statement is called when production window_statement is exited. +func (s *BaseBigQueryParserListener) ExitWindow_statement(ctx *Window_statementContext) {} + +// EnterOrder_clause is called when production order_clause is entered. +func (s *BaseBigQueryParserListener) EnterOrder_clause(ctx *Order_clauseContext) {} + +// ExitOrder_clause is called when production order_clause is exited. +func (s *BaseBigQueryParserListener) ExitOrder_clause(ctx *Order_clauseContext) {} + +// EnterLimit_clause is called when production limit_clause is entered. +func (s *BaseBigQueryParserListener) EnterLimit_clause(ctx *Limit_clauseContext) {} + +// ExitLimit_clause is called when production limit_clause is exited. +func (s *BaseBigQueryParserListener) ExitLimit_clause(ctx *Limit_clauseContext) {} + +// EnterUnary_operator is called when production unary_operator is entered. +func (s *BaseBigQueryParserListener) EnterUnary_operator(ctx *Unary_operatorContext) {} + +// ExitUnary_operator is called when production unary_operator is exited. +func (s *BaseBigQueryParserListener) ExitUnary_operator(ctx *Unary_operatorContext) {} + +// EnterExpr is called when production expr is entered. +func (s *BaseBigQueryParserListener) EnterExpr(ctx *ExprContext) {} + +// ExitExpr is called when production expr is exited. +func (s *BaseBigQueryParserListener) ExitExpr(ctx *ExprContext) {} + +// EnterCast_expr is called when production cast_expr is entered. +func (s *BaseBigQueryParserListener) EnterCast_expr(ctx *Cast_exprContext) {} + +// ExitCast_expr is called when production cast_expr is exited. +func (s *BaseBigQueryParserListener) ExitCast_expr(ctx *Cast_exprContext) {} + +// EnterColumn_expr is called when production column_expr is entered. +func (s *BaseBigQueryParserListener) EnterColumn_expr(ctx *Column_exprContext) {} + +// ExitColumn_expr is called when production column_expr is exited. +func (s *BaseBigQueryParserListener) ExitColumn_expr(ctx *Column_exprContext) {} + +// EnterExcept_statement is called when production except_statement is entered. +func (s *BaseBigQueryParserListener) EnterExcept_statement(ctx *Except_statementContext) {} + +// ExitExcept_statement is called when production except_statement is exited. +func (s *BaseBigQueryParserListener) ExitExcept_statement(ctx *Except_statementContext) {} + +// EnterReplace_statement is called when production replace_statement is entered. +func (s *BaseBigQueryParserListener) EnterReplace_statement(ctx *Replace_statementContext) {} + +// ExitReplace_statement is called when production replace_statement is exited. +func (s *BaseBigQueryParserListener) ExitReplace_statement(ctx *Replace_statementContext) {} + +// EnterJoin_type is called when production join_type is entered. +func (s *BaseBigQueryParserListener) EnterJoin_type(ctx *Join_typeContext) {} + +// ExitJoin_type is called when production join_type is exited. +func (s *BaseBigQueryParserListener) ExitJoin_type(ctx *Join_typeContext) {} + +// EnterOn_clause is called when production on_clause is entered. +func (s *BaseBigQueryParserListener) EnterOn_clause(ctx *On_clauseContext) {} + +// ExitOn_clause is called when production on_clause is exited. +func (s *BaseBigQueryParserListener) ExitOn_clause(ctx *On_clauseContext) {} + +// EnterSet_op is called when production set_op is entered. +func (s *BaseBigQueryParserListener) EnterSet_op(ctx *Set_opContext) {} + +// ExitSet_op is called when production set_op is exited. +func (s *BaseBigQueryParserListener) ExitSet_op(ctx *Set_opContext) {} + +// EnterUsing_clause is called when production using_clause is entered. +func (s *BaseBigQueryParserListener) EnterUsing_clause(ctx *Using_clauseContext) {} + +// ExitUsing_clause is called when production using_clause is exited. +func (s *BaseBigQueryParserListener) ExitUsing_clause(ctx *Using_clauseContext) {} + +// EnterField_path is called when production field_path is entered. +func (s *BaseBigQueryParserListener) EnterField_path(ctx *Field_pathContext) {} + +// ExitField_path is called when production field_path is exited. +func (s *BaseBigQueryParserListener) ExitField_path(ctx *Field_pathContext) {} + +// EnterSstruct is called when production sstruct is entered. +func (s *BaseBigQueryParserListener) EnterSstruct(ctx *SstructContext) {} + +// ExitSstruct is called when production sstruct is exited. +func (s *BaseBigQueryParserListener) ExitSstruct(ctx *SstructContext) {} + +// EnterArray_expr is called when production array_expr is entered. +func (s *BaseBigQueryParserListener) EnterArray_expr(ctx *Array_exprContext) {} + +// ExitArray_expr is called when production array_expr is exited. +func (s *BaseBigQueryParserListener) ExitArray_expr(ctx *Array_exprContext) {} + +// EnterArray_path is called when production array_path is entered. +func (s *BaseBigQueryParserListener) EnterArray_path(ctx *Array_pathContext) {} + +// ExitArray_path is called when production array_path is exited. +func (s *BaseBigQueryParserListener) ExitArray_path(ctx *Array_pathContext) {} + +// EnterBool_expression is called when production bool_expression is entered. +func (s *BaseBigQueryParserListener) EnterBool_expression(ctx *Bool_expressionContext) {} + +// ExitBool_expression is called when production bool_expression is exited. +func (s *BaseBigQueryParserListener) ExitBool_expression(ctx *Bool_expressionContext) {} + +// EnterWindow_name is called when production window_name is entered. +func (s *BaseBigQueryParserListener) EnterWindow_name(ctx *Window_nameContext) {} + +// ExitWindow_name is called when production window_name is exited. +func (s *BaseBigQueryParserListener) ExitWindow_name(ctx *Window_nameContext) {} + +// EnterWindow_definition is called when production window_definition is entered. +func (s *BaseBigQueryParserListener) EnterWindow_definition(ctx *Window_definitionContext) {} + +// ExitWindow_definition is called when production window_definition is exited. +func (s *BaseBigQueryParserListener) ExitWindow_definition(ctx *Window_definitionContext) {} + +// EnterCount is called when production count is entered. +func (s *BaseBigQueryParserListener) EnterCount(ctx *CountContext) {} + +// ExitCount is called when production count is exited. +func (s *BaseBigQueryParserListener) ExitCount(ctx *CountContext) {} + +// EnterSkip_rows is called when production skip_rows is entered. +func (s *BaseBigQueryParserListener) EnterSkip_rows(ctx *Skip_rowsContext) {} + +// ExitSkip_rows is called when production skip_rows is exited. +func (s *BaseBigQueryParserListener) ExitSkip_rows(ctx *Skip_rowsContext) {} + +// EnterWith_statement is called when production with_statement is entered. +func (s *BaseBigQueryParserListener) EnterWith_statement(ctx *With_statementContext) {} + +// ExitWith_statement is called when production with_statement is exited. +func (s *BaseBigQueryParserListener) ExitWith_statement(ctx *With_statementContext) {} + +// EnterName is called when production name is entered. +func (s *BaseBigQueryParserListener) EnterName(ctx *NameContext) {} + +// ExitName is called when production name is exited. +func (s *BaseBigQueryParserListener) ExitName(ctx *NameContext) {} + +// EnterDot_name is called when production dot_name is entered. +func (s *BaseBigQueryParserListener) EnterDot_name(ctx *Dot_nameContext) {} + +// ExitDot_name is called when production dot_name is exited. +func (s *BaseBigQueryParserListener) ExitDot_name(ctx *Dot_nameContext) {} + +// EnterAlias_name is called when production alias_name is entered. +func (s *BaseBigQueryParserListener) EnterAlias_name(ctx *Alias_nameContext) {} + +// ExitAlias_name is called when production alias_name is exited. +func (s *BaseBigQueryParserListener) ExitAlias_name(ctx *Alias_nameContext) {} + +// EnterArray_name is called when production array_name is entered. +func (s *BaseBigQueryParserListener) EnterArray_name(ctx *Array_nameContext) {} + +// ExitArray_name is called when production array_name is exited. +func (s *BaseBigQueryParserListener) ExitArray_name(ctx *Array_nameContext) {} + +// EnterColumn_name is called when production column_name is entered. +func (s *BaseBigQueryParserListener) EnterColumn_name(ctx *Column_nameContext) {} + +// ExitColumn_name is called when production column_name is exited. +func (s *BaseBigQueryParserListener) ExitColumn_name(ctx *Column_nameContext) {} + +// EnterCte_name is called when production cte_name is entered. +func (s *BaseBigQueryParserListener) EnterCte_name(ctx *Cte_nameContext) {} + +// ExitCte_name is called when production cte_name is exited. +func (s *BaseBigQueryParserListener) ExitCte_name(ctx *Cte_nameContext) {} + +// EnterDataset_name is called when production dataset_name is entered. +func (s *BaseBigQueryParserListener) EnterDataset_name(ctx *Dataset_nameContext) {} + +// ExitDataset_name is called when production dataset_name is exited. +func (s *BaseBigQueryParserListener) ExitDataset_name(ctx *Dataset_nameContext) {} + +// EnterDatatype_name is called when production datatype_name is entered. +func (s *BaseBigQueryParserListener) EnterDatatype_name(ctx *Datatype_nameContext) {} + +// ExitDatatype_name is called when production datatype_name is exited. +func (s *BaseBigQueryParserListener) ExitDatatype_name(ctx *Datatype_nameContext) {} + +// EnterFunction_name is called when production function_name is entered. +func (s *BaseBigQueryParserListener) EnterFunction_name(ctx *Function_nameContext) {} + +// ExitFunction_name is called when production function_name is exited. +func (s *BaseBigQueryParserListener) ExitFunction_name(ctx *Function_nameContext) {} + +// EnterJoin_name is called when production join_name is entered. +func (s *BaseBigQueryParserListener) EnterJoin_name(ctx *Join_nameContext) {} + +// ExitJoin_name is called when production join_name is exited. +func (s *BaseBigQueryParserListener) ExitJoin_name(ctx *Join_nameContext) {} + +// EnterMember_name is called when production member_name is entered. +func (s *BaseBigQueryParserListener) EnterMember_name(ctx *Member_nameContext) {} + +// ExitMember_name is called when production member_name is exited. +func (s *BaseBigQueryParserListener) ExitMember_name(ctx *Member_nameContext) {} + +// EnterProject_name is called when production project_name is entered. +func (s *BaseBigQueryParserListener) EnterProject_name(ctx *Project_nameContext) {} + +// ExitProject_name is called when production project_name is exited. +func (s *BaseBigQueryParserListener) ExitProject_name(ctx *Project_nameContext) {} + +// EnterStruct_name is called when production struct_name is entered. +func (s *BaseBigQueryParserListener) EnterStruct_name(ctx *Struct_nameContext) {} + +// ExitStruct_name is called when production struct_name is exited. +func (s *BaseBigQueryParserListener) ExitStruct_name(ctx *Struct_nameContext) {} + +// EnterTable_name is called when production table_name is entered. +func (s *BaseBigQueryParserListener) EnterTable_name(ctx *Table_nameContext) {} + +// ExitTable_name is called when production table_name is exited. +func (s *BaseBigQueryParserListener) ExitTable_name(ctx *Table_nameContext) {} + +// EnterTable_expr is called when production table_expr is entered. +func (s *BaseBigQueryParserListener) EnterTable_expr(ctx *Table_exprContext) {} + +// ExitTable_expr is called when production table_expr is exited. +func (s *BaseBigQueryParserListener) ExitTable_expr(ctx *Table_exprContext) {} + +// EnterNumber is called when production number is entered. +func (s *BaseBigQueryParserListener) EnterNumber(ctx *NumberContext) {} + +// ExitNumber is called when production number is exited. +func (s *BaseBigQueryParserListener) ExitNumber(ctx *NumberContext) {} + +// EnterInteger_type is called when production integer_type is entered. +func (s *BaseBigQueryParserListener) EnterInteger_type(ctx *Integer_typeContext) {} + +// ExitInteger_type is called when production integer_type is exited. +func (s *BaseBigQueryParserListener) ExitInteger_type(ctx *Integer_typeContext) {} + +// EnterFloat_type is called when production float_type is entered. +func (s *BaseBigQueryParserListener) EnterFloat_type(ctx *Float_typeContext) {} + +// ExitFloat_type is called when production float_type is exited. +func (s *BaseBigQueryParserListener) ExitFloat_type(ctx *Float_typeContext) {} + +// EnterString is called when production string is entered. +func (s *BaseBigQueryParserListener) EnterString(ctx *StringContext) {} + +// ExitString is called when production string is exited. +func (s *BaseBigQueryParserListener) ExitString(ctx *StringContext) {} + +// EnterQuoted_string is called when production quoted_string is entered. +func (s *BaseBigQueryParserListener) EnterQuoted_string(ctx *Quoted_stringContext) {} + +// ExitQuoted_string is called when production quoted_string is exited. +func (s *BaseBigQueryParserListener) ExitQuoted_string(ctx *Quoted_stringContext) {} + +// EnterTriple_quoted_string is called when production triple_quoted_string is entered. +func (s *BaseBigQueryParserListener) EnterTriple_quoted_string(ctx *Triple_quoted_stringContext) {} + +// ExitTriple_quoted_string is called when production triple_quoted_string is exited. +func (s *BaseBigQueryParserListener) ExitTriple_quoted_string(ctx *Triple_quoted_stringContext) {} + +// EnterRaw_string is called when production raw_string is entered. +func (s *BaseBigQueryParserListener) EnterRaw_string(ctx *Raw_stringContext) {} + +// ExitRaw_string is called when production raw_string is exited. +func (s *BaseBigQueryParserListener) ExitRaw_string(ctx *Raw_stringContext) {} + +// EnterByte_string is called when production byte_string is entered. +func (s *BaseBigQueryParserListener) EnterByte_string(ctx *Byte_stringContext) {} + +// ExitByte_string is called when production byte_string is exited. +func (s *BaseBigQueryParserListener) ExitByte_string(ctx *Byte_stringContext) {} + +// EnterRaw_byte_string is called when production raw_byte_string is entered. +func (s *BaseBigQueryParserListener) EnterRaw_byte_string(ctx *Raw_byte_stringContext) {} + +// ExitRaw_byte_string is called when production raw_byte_string is exited. +func (s *BaseBigQueryParserListener) ExitRaw_byte_string(ctx *Raw_byte_stringContext) {} + +// EnterSpecial_string is called when production special_string is entered. +func (s *BaseBigQueryParserListener) EnterSpecial_string(ctx *Special_stringContext) {} + +// ExitSpecial_string is called when production special_string is exited. +func (s *BaseBigQueryParserListener) ExitSpecial_string(ctx *Special_stringContext) {} + +// EnterKeyword is called when production keyword is entered. +func (s *BaseBigQueryParserListener) EnterKeyword(ctx *KeywordContext) {} + +// ExitKeyword is called when production keyword is exited. +func (s *BaseBigQueryParserListener) ExitKeyword(ctx *KeywordContext) {} diff --git a/bq/bigqueryparser_base_visitor.go b/bq/bigqueryparser_base_visitor.go new file mode 100644 index 0000000..1520e34 --- /dev/null +++ b/bq/bigqueryparser_base_visitor.go @@ -0,0 +1,248 @@ +// Code generated from BigQueryParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package bq // BigQueryParser +import "github.com/antlr4-go/antlr/v4" + +type BaseBigQueryParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseBigQueryParserVisitor) VisitRoot(ctx *RootContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitStmtmulti(ctx *StmtmultiContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitStmt(ctx *StmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitQuery_statement(ctx *Query_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitQuery_expr(ctx *Query_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitSelect_statement(ctx *Select_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitFrom_statement(ctx *From_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitFrom_item(ctx *From_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitWhere_statement(ctx *Where_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitGroup_statement(ctx *Group_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitHaving_statement(ctx *Having_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitWindow_statement(ctx *Window_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitOrder_clause(ctx *Order_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitLimit_clause(ctx *Limit_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitUnary_operator(ctx *Unary_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitExpr(ctx *ExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitCast_expr(ctx *Cast_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitColumn_expr(ctx *Column_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitExcept_statement(ctx *Except_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitReplace_statement(ctx *Replace_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitJoin_type(ctx *Join_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitOn_clause(ctx *On_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitSet_op(ctx *Set_opContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitUsing_clause(ctx *Using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitField_path(ctx *Field_pathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitSstruct(ctx *SstructContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitArray_expr(ctx *Array_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitArray_path(ctx *Array_pathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitBool_expression(ctx *Bool_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitWindow_name(ctx *Window_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitWindow_definition(ctx *Window_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitCount(ctx *CountContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitSkip_rows(ctx *Skip_rowsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitWith_statement(ctx *With_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitName(ctx *NameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitDot_name(ctx *Dot_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitAlias_name(ctx *Alias_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitArray_name(ctx *Array_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitColumn_name(ctx *Column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitCte_name(ctx *Cte_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitDataset_name(ctx *Dataset_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitDatatype_name(ctx *Datatype_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitFunction_name(ctx *Function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitJoin_name(ctx *Join_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitMember_name(ctx *Member_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitProject_name(ctx *Project_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitStruct_name(ctx *Struct_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitTable_name(ctx *Table_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitTable_expr(ctx *Table_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitNumber(ctx *NumberContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitInteger_type(ctx *Integer_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitFloat_type(ctx *Float_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitString(ctx *StringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitQuoted_string(ctx *Quoted_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitTriple_quoted_string(ctx *Triple_quoted_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitRaw_string(ctx *Raw_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitByte_string(ctx *Byte_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitRaw_byte_string(ctx *Raw_byte_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitSpecial_string(ctx *Special_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseBigQueryParserVisitor) VisitKeyword(ctx *KeywordContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/bq/bigqueryparser_listener.go b/bq/bigqueryparser_listener.go new file mode 100644 index 0000000..24bf8b8 --- /dev/null +++ b/bq/bigqueryparser_listener.go @@ -0,0 +1,369 @@ +// Code generated from BigQueryParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package bq // BigQueryParser +import "github.com/antlr4-go/antlr/v4" + +// BigQueryParserListener is a complete listener for a parse tree produced by BigQueryParser. +type BigQueryParserListener interface { + antlr.ParseTreeListener + + // EnterRoot is called when entering the root production. + EnterRoot(c *RootContext) + + // EnterStmtmulti is called when entering the stmtmulti production. + EnterStmtmulti(c *StmtmultiContext) + + // EnterStmt is called when entering the stmt production. + EnterStmt(c *StmtContext) + + // EnterQuery_statement is called when entering the query_statement production. + EnterQuery_statement(c *Query_statementContext) + + // EnterQuery_expr is called when entering the query_expr production. + EnterQuery_expr(c *Query_exprContext) + + // EnterSelect_statement is called when entering the select_statement production. + EnterSelect_statement(c *Select_statementContext) + + // EnterFrom_statement is called when entering the from_statement production. + EnterFrom_statement(c *From_statementContext) + + // EnterFrom_item is called when entering the from_item production. + EnterFrom_item(c *From_itemContext) + + // EnterWhere_statement is called when entering the where_statement production. + EnterWhere_statement(c *Where_statementContext) + + // EnterGroup_statement is called when entering the group_statement production. + EnterGroup_statement(c *Group_statementContext) + + // EnterHaving_statement is called when entering the having_statement production. + EnterHaving_statement(c *Having_statementContext) + + // EnterWindow_statement is called when entering the window_statement production. + EnterWindow_statement(c *Window_statementContext) + + // EnterOrder_clause is called when entering the order_clause production. + EnterOrder_clause(c *Order_clauseContext) + + // EnterLimit_clause is called when entering the limit_clause production. + EnterLimit_clause(c *Limit_clauseContext) + + // EnterUnary_operator is called when entering the unary_operator production. + EnterUnary_operator(c *Unary_operatorContext) + + // EnterExpr is called when entering the expr production. + EnterExpr(c *ExprContext) + + // EnterCast_expr is called when entering the cast_expr production. + EnterCast_expr(c *Cast_exprContext) + + // EnterColumn_expr is called when entering the column_expr production. + EnterColumn_expr(c *Column_exprContext) + + // EnterExcept_statement is called when entering the except_statement production. + EnterExcept_statement(c *Except_statementContext) + + // EnterReplace_statement is called when entering the replace_statement production. + EnterReplace_statement(c *Replace_statementContext) + + // EnterJoin_type is called when entering the join_type production. + EnterJoin_type(c *Join_typeContext) + + // EnterOn_clause is called when entering the on_clause production. + EnterOn_clause(c *On_clauseContext) + + // EnterSet_op is called when entering the set_op production. + EnterSet_op(c *Set_opContext) + + // EnterUsing_clause is called when entering the using_clause production. + EnterUsing_clause(c *Using_clauseContext) + + // EnterField_path is called when entering the field_path production. + EnterField_path(c *Field_pathContext) + + // EnterSstruct is called when entering the sstruct production. + EnterSstruct(c *SstructContext) + + // EnterArray_expr is called when entering the array_expr production. + EnterArray_expr(c *Array_exprContext) + + // EnterArray_path is called when entering the array_path production. + EnterArray_path(c *Array_pathContext) + + // EnterBool_expression is called when entering the bool_expression production. + EnterBool_expression(c *Bool_expressionContext) + + // EnterWindow_name is called when entering the window_name production. + EnterWindow_name(c *Window_nameContext) + + // EnterWindow_definition is called when entering the window_definition production. + EnterWindow_definition(c *Window_definitionContext) + + // EnterCount is called when entering the count production. + EnterCount(c *CountContext) + + // EnterSkip_rows is called when entering the skip_rows production. + EnterSkip_rows(c *Skip_rowsContext) + + // EnterWith_statement is called when entering the with_statement production. + EnterWith_statement(c *With_statementContext) + + // EnterName is called when entering the name production. + EnterName(c *NameContext) + + // EnterDot_name is called when entering the dot_name production. + EnterDot_name(c *Dot_nameContext) + + // EnterAlias_name is called when entering the alias_name production. + EnterAlias_name(c *Alias_nameContext) + + // EnterArray_name is called when entering the array_name production. + EnterArray_name(c *Array_nameContext) + + // EnterColumn_name is called when entering the column_name production. + EnterColumn_name(c *Column_nameContext) + + // EnterCte_name is called when entering the cte_name production. + EnterCte_name(c *Cte_nameContext) + + // EnterDataset_name is called when entering the dataset_name production. + EnterDataset_name(c *Dataset_nameContext) + + // EnterDatatype_name is called when entering the datatype_name production. + EnterDatatype_name(c *Datatype_nameContext) + + // EnterFunction_name is called when entering the function_name production. + EnterFunction_name(c *Function_nameContext) + + // EnterJoin_name is called when entering the join_name production. + EnterJoin_name(c *Join_nameContext) + + // EnterMember_name is called when entering the member_name production. + EnterMember_name(c *Member_nameContext) + + // EnterProject_name is called when entering the project_name production. + EnterProject_name(c *Project_nameContext) + + // EnterStruct_name is called when entering the struct_name production. + EnterStruct_name(c *Struct_nameContext) + + // EnterTable_name is called when entering the table_name production. + EnterTable_name(c *Table_nameContext) + + // EnterTable_expr is called when entering the table_expr production. + EnterTable_expr(c *Table_exprContext) + + // EnterNumber is called when entering the number production. + EnterNumber(c *NumberContext) + + // EnterInteger_type is called when entering the integer_type production. + EnterInteger_type(c *Integer_typeContext) + + // EnterFloat_type is called when entering the float_type production. + EnterFloat_type(c *Float_typeContext) + + // EnterString is called when entering the string production. + EnterString(c *StringContext) + + // EnterQuoted_string is called when entering the quoted_string production. + EnterQuoted_string(c *Quoted_stringContext) + + // EnterTriple_quoted_string is called when entering the triple_quoted_string production. + EnterTriple_quoted_string(c *Triple_quoted_stringContext) + + // EnterRaw_string is called when entering the raw_string production. + EnterRaw_string(c *Raw_stringContext) + + // EnterByte_string is called when entering the byte_string production. + EnterByte_string(c *Byte_stringContext) + + // EnterRaw_byte_string is called when entering the raw_byte_string production. + EnterRaw_byte_string(c *Raw_byte_stringContext) + + // EnterSpecial_string is called when entering the special_string production. + EnterSpecial_string(c *Special_stringContext) + + // EnterKeyword is called when entering the keyword production. + EnterKeyword(c *KeywordContext) + + // ExitRoot is called when exiting the root production. + ExitRoot(c *RootContext) + + // ExitStmtmulti is called when exiting the stmtmulti production. + ExitStmtmulti(c *StmtmultiContext) + + // ExitStmt is called when exiting the stmt production. + ExitStmt(c *StmtContext) + + // ExitQuery_statement is called when exiting the query_statement production. + ExitQuery_statement(c *Query_statementContext) + + // ExitQuery_expr is called when exiting the query_expr production. + ExitQuery_expr(c *Query_exprContext) + + // ExitSelect_statement is called when exiting the select_statement production. + ExitSelect_statement(c *Select_statementContext) + + // ExitFrom_statement is called when exiting the from_statement production. + ExitFrom_statement(c *From_statementContext) + + // ExitFrom_item is called when exiting the from_item production. + ExitFrom_item(c *From_itemContext) + + // ExitWhere_statement is called when exiting the where_statement production. + ExitWhere_statement(c *Where_statementContext) + + // ExitGroup_statement is called when exiting the group_statement production. + ExitGroup_statement(c *Group_statementContext) + + // ExitHaving_statement is called when exiting the having_statement production. + ExitHaving_statement(c *Having_statementContext) + + // ExitWindow_statement is called when exiting the window_statement production. + ExitWindow_statement(c *Window_statementContext) + + // ExitOrder_clause is called when exiting the order_clause production. + ExitOrder_clause(c *Order_clauseContext) + + // ExitLimit_clause is called when exiting the limit_clause production. + ExitLimit_clause(c *Limit_clauseContext) + + // ExitUnary_operator is called when exiting the unary_operator production. + ExitUnary_operator(c *Unary_operatorContext) + + // ExitExpr is called when exiting the expr production. + ExitExpr(c *ExprContext) + + // ExitCast_expr is called when exiting the cast_expr production. + ExitCast_expr(c *Cast_exprContext) + + // ExitColumn_expr is called when exiting the column_expr production. + ExitColumn_expr(c *Column_exprContext) + + // ExitExcept_statement is called when exiting the except_statement production. + ExitExcept_statement(c *Except_statementContext) + + // ExitReplace_statement is called when exiting the replace_statement production. + ExitReplace_statement(c *Replace_statementContext) + + // ExitJoin_type is called when exiting the join_type production. + ExitJoin_type(c *Join_typeContext) + + // ExitOn_clause is called when exiting the on_clause production. + ExitOn_clause(c *On_clauseContext) + + // ExitSet_op is called when exiting the set_op production. + ExitSet_op(c *Set_opContext) + + // ExitUsing_clause is called when exiting the using_clause production. + ExitUsing_clause(c *Using_clauseContext) + + // ExitField_path is called when exiting the field_path production. + ExitField_path(c *Field_pathContext) + + // ExitSstruct is called when exiting the sstruct production. + ExitSstruct(c *SstructContext) + + // ExitArray_expr is called when exiting the array_expr production. + ExitArray_expr(c *Array_exprContext) + + // ExitArray_path is called when exiting the array_path production. + ExitArray_path(c *Array_pathContext) + + // ExitBool_expression is called when exiting the bool_expression production. + ExitBool_expression(c *Bool_expressionContext) + + // ExitWindow_name is called when exiting the window_name production. + ExitWindow_name(c *Window_nameContext) + + // ExitWindow_definition is called when exiting the window_definition production. + ExitWindow_definition(c *Window_definitionContext) + + // ExitCount is called when exiting the count production. + ExitCount(c *CountContext) + + // ExitSkip_rows is called when exiting the skip_rows production. + ExitSkip_rows(c *Skip_rowsContext) + + // ExitWith_statement is called when exiting the with_statement production. + ExitWith_statement(c *With_statementContext) + + // ExitName is called when exiting the name production. + ExitName(c *NameContext) + + // ExitDot_name is called when exiting the dot_name production. + ExitDot_name(c *Dot_nameContext) + + // ExitAlias_name is called when exiting the alias_name production. + ExitAlias_name(c *Alias_nameContext) + + // ExitArray_name is called when exiting the array_name production. + ExitArray_name(c *Array_nameContext) + + // ExitColumn_name is called when exiting the column_name production. + ExitColumn_name(c *Column_nameContext) + + // ExitCte_name is called when exiting the cte_name production. + ExitCte_name(c *Cte_nameContext) + + // ExitDataset_name is called when exiting the dataset_name production. + ExitDataset_name(c *Dataset_nameContext) + + // ExitDatatype_name is called when exiting the datatype_name production. + ExitDatatype_name(c *Datatype_nameContext) + + // ExitFunction_name is called when exiting the function_name production. + ExitFunction_name(c *Function_nameContext) + + // ExitJoin_name is called when exiting the join_name production. + ExitJoin_name(c *Join_nameContext) + + // ExitMember_name is called when exiting the member_name production. + ExitMember_name(c *Member_nameContext) + + // ExitProject_name is called when exiting the project_name production. + ExitProject_name(c *Project_nameContext) + + // ExitStruct_name is called when exiting the struct_name production. + ExitStruct_name(c *Struct_nameContext) + + // ExitTable_name is called when exiting the table_name production. + ExitTable_name(c *Table_nameContext) + + // ExitTable_expr is called when exiting the table_expr production. + ExitTable_expr(c *Table_exprContext) + + // ExitNumber is called when exiting the number production. + ExitNumber(c *NumberContext) + + // ExitInteger_type is called when exiting the integer_type production. + ExitInteger_type(c *Integer_typeContext) + + // ExitFloat_type is called when exiting the float_type production. + ExitFloat_type(c *Float_typeContext) + + // ExitString is called when exiting the string production. + ExitString(c *StringContext) + + // ExitQuoted_string is called when exiting the quoted_string production. + ExitQuoted_string(c *Quoted_stringContext) + + // ExitTriple_quoted_string is called when exiting the triple_quoted_string production. + ExitTriple_quoted_string(c *Triple_quoted_stringContext) + + // ExitRaw_string is called when exiting the raw_string production. + ExitRaw_string(c *Raw_stringContext) + + // ExitByte_string is called when exiting the byte_string production. + ExitByte_string(c *Byte_stringContext) + + // ExitRaw_byte_string is called when exiting the raw_byte_string production. + ExitRaw_byte_string(c *Raw_byte_stringContext) + + // ExitSpecial_string is called when exiting the special_string production. + ExitSpecial_string(c *Special_stringContext) + + // ExitKeyword is called when exiting the keyword production. + ExitKeyword(c *KeywordContext) +} diff --git a/bq/bigqueryparser_visitor.go b/bq/bigqueryparser_visitor.go new file mode 100644 index 0000000..e1d04f6 --- /dev/null +++ b/bq/bigqueryparser_visitor.go @@ -0,0 +1,189 @@ +// Code generated from BigQueryParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package bq // BigQueryParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by BigQueryParser. +type BigQueryParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by BigQueryParser#root. + VisitRoot(ctx *RootContext) interface{} + + // Visit a parse tree produced by BigQueryParser#stmtmulti. + VisitStmtmulti(ctx *StmtmultiContext) interface{} + + // Visit a parse tree produced by BigQueryParser#stmt. + VisitStmt(ctx *StmtContext) interface{} + + // Visit a parse tree produced by BigQueryParser#query_statement. + VisitQuery_statement(ctx *Query_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#query_expr. + VisitQuery_expr(ctx *Query_exprContext) interface{} + + // Visit a parse tree produced by BigQueryParser#select_statement. + VisitSelect_statement(ctx *Select_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#from_statement. + VisitFrom_statement(ctx *From_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#from_item. + VisitFrom_item(ctx *From_itemContext) interface{} + + // Visit a parse tree produced by BigQueryParser#where_statement. + VisitWhere_statement(ctx *Where_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#group_statement. + VisitGroup_statement(ctx *Group_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#having_statement. + VisitHaving_statement(ctx *Having_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#window_statement. + VisitWindow_statement(ctx *Window_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#order_clause. + VisitOrder_clause(ctx *Order_clauseContext) interface{} + + // Visit a parse tree produced by BigQueryParser#limit_clause. + VisitLimit_clause(ctx *Limit_clauseContext) interface{} + + // Visit a parse tree produced by BigQueryParser#unary_operator. + VisitUnary_operator(ctx *Unary_operatorContext) interface{} + + // Visit a parse tree produced by BigQueryParser#expr. + VisitExpr(ctx *ExprContext) interface{} + + // Visit a parse tree produced by BigQueryParser#cast_expr. + VisitCast_expr(ctx *Cast_exprContext) interface{} + + // Visit a parse tree produced by BigQueryParser#column_expr. + VisitColumn_expr(ctx *Column_exprContext) interface{} + + // Visit a parse tree produced by BigQueryParser#except_statement. + VisitExcept_statement(ctx *Except_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#replace_statement. + VisitReplace_statement(ctx *Replace_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#join_type. + VisitJoin_type(ctx *Join_typeContext) interface{} + + // Visit a parse tree produced by BigQueryParser#on_clause. + VisitOn_clause(ctx *On_clauseContext) interface{} + + // Visit a parse tree produced by BigQueryParser#set_op. + VisitSet_op(ctx *Set_opContext) interface{} + + // Visit a parse tree produced by BigQueryParser#using_clause. + VisitUsing_clause(ctx *Using_clauseContext) interface{} + + // Visit a parse tree produced by BigQueryParser#field_path. + VisitField_path(ctx *Field_pathContext) interface{} + + // Visit a parse tree produced by BigQueryParser#sstruct. + VisitSstruct(ctx *SstructContext) interface{} + + // Visit a parse tree produced by BigQueryParser#array_expr. + VisitArray_expr(ctx *Array_exprContext) interface{} + + // Visit a parse tree produced by BigQueryParser#array_path. + VisitArray_path(ctx *Array_pathContext) interface{} + + // Visit a parse tree produced by BigQueryParser#bool_expression. + VisitBool_expression(ctx *Bool_expressionContext) interface{} + + // Visit a parse tree produced by BigQueryParser#window_name. + VisitWindow_name(ctx *Window_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#window_definition. + VisitWindow_definition(ctx *Window_definitionContext) interface{} + + // Visit a parse tree produced by BigQueryParser#count. + VisitCount(ctx *CountContext) interface{} + + // Visit a parse tree produced by BigQueryParser#skip_rows. + VisitSkip_rows(ctx *Skip_rowsContext) interface{} + + // Visit a parse tree produced by BigQueryParser#with_statement. + VisitWith_statement(ctx *With_statementContext) interface{} + + // Visit a parse tree produced by BigQueryParser#name. + VisitName(ctx *NameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#dot_name. + VisitDot_name(ctx *Dot_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#alias_name. + VisitAlias_name(ctx *Alias_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#array_name. + VisitArray_name(ctx *Array_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#column_name. + VisitColumn_name(ctx *Column_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#cte_name. + VisitCte_name(ctx *Cte_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#dataset_name. + VisitDataset_name(ctx *Dataset_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#datatype_name. + VisitDatatype_name(ctx *Datatype_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#function_name. + VisitFunction_name(ctx *Function_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#join_name. + VisitJoin_name(ctx *Join_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#member_name. + VisitMember_name(ctx *Member_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#project_name. + VisitProject_name(ctx *Project_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#struct_name. + VisitStruct_name(ctx *Struct_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#table_name. + VisitTable_name(ctx *Table_nameContext) interface{} + + // Visit a parse tree produced by BigQueryParser#table_expr. + VisitTable_expr(ctx *Table_exprContext) interface{} + + // Visit a parse tree produced by BigQueryParser#number. + VisitNumber(ctx *NumberContext) interface{} + + // Visit a parse tree produced by BigQueryParser#integer_type. + VisitInteger_type(ctx *Integer_typeContext) interface{} + + // Visit a parse tree produced by BigQueryParser#float_type. + VisitFloat_type(ctx *Float_typeContext) interface{} + + // Visit a parse tree produced by BigQueryParser#string. + VisitString(ctx *StringContext) interface{} + + // Visit a parse tree produced by BigQueryParser#quoted_string. + VisitQuoted_string(ctx *Quoted_stringContext) interface{} + + // Visit a parse tree produced by BigQueryParser#triple_quoted_string. + VisitTriple_quoted_string(ctx *Triple_quoted_stringContext) interface{} + + // Visit a parse tree produced by BigQueryParser#raw_string. + VisitRaw_string(ctx *Raw_stringContext) interface{} + + // Visit a parse tree produced by BigQueryParser#byte_string. + VisitByte_string(ctx *Byte_stringContext) interface{} + + // Visit a parse tree produced by BigQueryParser#raw_byte_string. + VisitRaw_byte_string(ctx *Raw_byte_stringContext) interface{} + + // Visit a parse tree produced by BigQueryParser#special_string. + VisitSpecial_string(ctx *Special_stringContext) interface{} + + // Visit a parse tree produced by BigQueryParser#keyword. + VisitKeyword(ctx *KeywordContext) interface{} +} diff --git a/bq/examples/id.sql b/bq/examples/id.sql new file mode 100644 index 0000000..39eb91f --- /dev/null +++ b/bq/examples/id.sql @@ -0,0 +1,26 @@ +-- Valid. _5abc and dataField are valid identifiers. +SELECT _5abc.dataField FROM _5abc; + +-- Valid. `5abc` and dataField are valid identifiers. +SELECT `5abc`.dataField FROM `5abc`; + +-- Invalid. 5abc is an invalid identifier because it is unquoted and starts +-- with a number rather than a letter or underscore. +-- SELECT 5abc.dataField FROM 5abc; + +-- Valid. abc5 and dataField are valid identifiers. +SELECT abc5.dataField FROM abc5; + +-- Invalid. abc5! is an invalid identifier because it is unquoted and contains +-- a character that is not a letter, number, or underscore. +-- SELECT abc5!.dataField FROM abc5!; + +-- Valid. `GROUP` and dataField are valid identifiers. +SELECT `GROUP`.dataField FROM `GROUP`; + +-- Invalid. GROUP is an invalid identifier because it is unquoted and is a +-- stand-alone reserved keyword. +-- SELECT GROUP.dataField FROM GROUP; + +-- Valid. abc5 and GROUP are valid identifiers. +SELECT abc5.GROUP FROM abc5; \ No newline at end of file diff --git a/bq/examples/select1.sql b/bq/examples/select1.sql new file mode 100644 index 0000000..b79eb49 --- /dev/null +++ b/bq/examples/select1.sql @@ -0,0 +1,2 @@ +SELECT * FROM hello; +SELECT * FROM (SELECT "apple" AS fruit, "carrot" AS vegetable) \ No newline at end of file diff --git a/bq/examples/select2.sql b/bq/examples/select2.sql new file mode 100644 index 0000000..a7cc8e7 --- /dev/null +++ b/bq/examples/select2.sql @@ -0,0 +1 @@ +SELECT * FROM (SELECT "apple" AS fruit, "carrot" AS vegetable) \ No newline at end of file diff --git a/bq/examples/select3.sql b/bq/examples/select3.sql new file mode 100644 index 0000000..559860a --- /dev/null +++ b/bq/examples/select3.sql @@ -0,0 +1,6 @@ +WITH groceries AS + (SELECT "milk" AS dairy, + "eggs" AS protein, + "bread" AS grain) +SELECT g.* +FROM groceries AS g \ No newline at end of file diff --git a/bq/examples/select4.sql b/bq/examples/select4.sql new file mode 100644 index 0000000..9a87888 --- /dev/null +++ b/bq/examples/select4.sql @@ -0,0 +1,6 @@ +WITH orders AS + (SELECT 5 as order_id, + "sprocket" as item_name, + 200 as quantity) +SELECT * REPLACE (quantity/2 AS quantity) +FROM orders \ No newline at end of file diff --git a/bq/examples/select5.sql b/bq/examples/select5.sql new file mode 100644 index 0000000..4af1649 --- /dev/null +++ b/bq/examples/select5.sql @@ -0,0 +1,9 @@ +-- SELECT * +-- FROM UNNEST( +-- ARRAY< +-- STRUCT< +-- x INT64, +-- y STRING, +-- z STRUCT>>[ +-- (1, 'foo', (10, 11)), +-- (3, 'bar', (20, 21))]) \ No newline at end of file diff --git a/bq/examples/select6.sql b/bq/examples/select6.sql new file mode 100644 index 0000000..99d0481 --- /dev/null +++ b/bq/examples/select6.sql @@ -0,0 +1,2 @@ +-- WITH Coordinates AS (SELECT [1,2] AS position) +-- SELECT results FROM Coordinates, UNNEST(Coordinates.position) AS results \ No newline at end of file diff --git a/bq/examples/select7.sql b/bq/examples/select7.sql new file mode 100644 index 0000000..8e05fca --- /dev/null +++ b/bq/examples/select7.sql @@ -0,0 +1 @@ +select 1;SELECT * FROM (SELECT "apple" AS fruit, "carrot" AS vegetable) \ No newline at end of file diff --git a/bq/parser_test.go b/bq/parser_test.go new file mode 100644 index 0000000..505d995 --- /dev/null +++ b/bq/parser_test.go @@ -0,0 +1,70 @@ +package bq_test + +import ( + "os" + "path" + "testing" + + "github.com/antlr4-go/antlr/v4" + bq "github.com/bytebase/parser/bq" + "github.com/stretchr/testify/require" +) + +type CustomErrorListener struct { + errors int +} + +func NewCustomErrorListener() *CustomErrorListener { + return new(CustomErrorListener) +} + +func (l *CustomErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.errors += 1 + antlr.ConsoleErrorListenerINSTANCE.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) +} + +func (l *CustomErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) +} + +func (l *CustomErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) +} + +func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) +} + +func TestBQParser(t *testing.T) { + examples, err := os.ReadDir("examples") + require.NoError(t, err) + + for _, file := range examples { + filePath := path.Join("examples", file.Name()) + t.Run(filePath, func(t *testing.T) { + t.Parallel() + input, err := antlr.NewFileStream(filePath) + require.NoError(t, err) + + lexer := bq.NewBigQueryLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := bq.NewBigQueryParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + _ = p.Root() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) + }) + } +}