From edbc87e8f1684992b1cc1167e3ff93cd9029eaef Mon Sep 17 00:00:00 2001 From: xigua Date: Thu, 17 Dec 2020 11:44:45 +0800 Subject: [PATCH] update sql parser name --- src/grammar/spark/{SqlBase.g4 => SparkSql.g4} | 2 +- .../spark/{SqlBase.interp => SparkSql.interp} | 0 .../spark/{SqlBase.tokens => SparkSql.tokens} | 0 ...lBaseLexer.interp => SparkSqlLexer.interp} | 0 .../{SqlBaseLexer.js => SparkSqlLexer.js} | 1131 +-- ...lBaseLexer.tokens => SparkSqlLexer.tokens} | 0 src/lib/spark/SparkSqlListener.js | 2445 +++++ .../{SqlBaseParser.js => SparkSqlParser.js} | 8770 ++++++++--------- src/lib/spark/SparkSqlVisitor.js | 1636 +++ src/lib/spark/SqlBaseListener.js | 2445 ----- src/lib/spark/SqlBaseVisitor.js | 1636 --- src/parser/spark.ts | 12 +- test/parser/spark/listener.test.ts | 4 +- test/parser/spark/syntax.test.ts | 1 - test/parser/spark/visitor.test.ts | 4 +- 15 files changed, 9046 insertions(+), 9040 deletions(-) rename src/grammar/spark/{SqlBase.g4 => SparkSql.g4} (99%) rename src/lib/spark/{SqlBase.interp => SparkSql.interp} (100%) rename src/lib/spark/{SqlBase.tokens => SparkSql.tokens} (100%) rename src/lib/spark/{SqlBaseLexer.interp => SparkSqlLexer.interp} (100%) rename src/lib/spark/{SqlBaseLexer.js => SparkSqlLexer.js} (82%) rename src/lib/spark/{SqlBaseLexer.tokens => SparkSqlLexer.tokens} (100%) create mode 100644 src/lib/spark/SparkSqlListener.js rename src/lib/spark/{SqlBaseParser.js => SparkSqlParser.js} (77%) create mode 100644 src/lib/spark/SparkSqlVisitor.js delete mode 100644 src/lib/spark/SqlBaseListener.js delete mode 100644 src/lib/spark/SqlBaseVisitor.js diff --git a/src/grammar/spark/SqlBase.g4 b/src/grammar/spark/SparkSql.g4 similarity index 99% rename from src/grammar/spark/SqlBase.g4 rename to src/grammar/spark/SparkSql.g4 index 7c51982..e0fa27e 100644 --- a/src/grammar/spark/SqlBase.g4 +++ b/src/grammar/spark/SparkSql.g4 @@ -14,7 +14,7 @@ * This file is an adaptation of Presto's presto-parser/src/main/antlr4/com/facebook/presto/sql/parser/SqlBase.g4 grammar. */ -grammar SqlBase; +grammar SparkSql; @parser::members { /** diff --git a/src/lib/spark/SqlBase.interp b/src/lib/spark/SparkSql.interp similarity index 100% rename from src/lib/spark/SqlBase.interp rename to src/lib/spark/SparkSql.interp diff --git a/src/lib/spark/SqlBase.tokens b/src/lib/spark/SparkSql.tokens similarity index 100% rename from src/lib/spark/SqlBase.tokens rename to src/lib/spark/SparkSql.tokens diff --git a/src/lib/spark/SqlBaseLexer.interp b/src/lib/spark/SparkSqlLexer.interp similarity index 100% rename from src/lib/spark/SqlBaseLexer.interp rename to src/lib/spark/SparkSqlLexer.interp diff --git a/src/lib/spark/SqlBaseLexer.js b/src/lib/spark/SparkSqlLexer.js similarity index 82% rename from src/lib/spark/SqlBaseLexer.js rename to src/lib/spark/SparkSqlLexer.js index aa2b36e..921269a 100644 --- a/src/lib/spark/SqlBaseLexer.js +++ b/src/lib/spark/SparkSqlLexer.js @@ -1,4 +1,4 @@ -// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SqlBase.g4 by ANTLR 4.8 +// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SparkSql.g4 by ANTLR 4.8 // jshint ignore: start var antlr4 = require('antlr4/index'); @@ -1755,7 +1755,7 @@ var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN); var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); }); -function SqlBaseLexer(input) { +function SparkSqlLexer(input) { antlr4.Lexer.call(this, input); this._interp = new antlr4.atn.LexerATNSimulator(this, atn, decisionsToDFA, new antlr4.PredictionContextCache()); @@ -1792,572 +1792,579 @@ function SqlBaseLexer(input) { return this; } -SqlBaseLexer.prototype = Object.create(antlr4.Lexer.prototype); -SqlBaseLexer.prototype.constructor = SqlBaseLexer; +SparkSqlLexer.prototype = Object.create(antlr4.Lexer.prototype); +SparkSqlLexer.prototype.constructor = SparkSqlLexer; -Object.defineProperty(SqlBaseLexer.prototype, "atn", { +Object.defineProperty(SparkSqlLexer.prototype, "atn", { get : function() { return atn; } }); -SqlBaseLexer.EOF = antlr4.Token.EOF; -SqlBaseLexer.T__0 = 1; -SqlBaseLexer.T__1 = 2; -SqlBaseLexer.T__2 = 3; -SqlBaseLexer.T__3 = 4; -SqlBaseLexer.T__4 = 5; -SqlBaseLexer.T__5 = 6; -SqlBaseLexer.T__6 = 7; -SqlBaseLexer.T__7 = 8; -SqlBaseLexer.T__8 = 9; -SqlBaseLexer.T__9 = 10; -SqlBaseLexer.T__10 = 11; -SqlBaseLexer.ADD = 12; -SqlBaseLexer.AFTER = 13; -SqlBaseLexer.ALL = 14; -SqlBaseLexer.ALTER = 15; -SqlBaseLexer.ANALYZE = 16; -SqlBaseLexer.AND = 17; -SqlBaseLexer.ANTI = 18; -SqlBaseLexer.ANY = 19; -SqlBaseLexer.ARCHIVE = 20; -SqlBaseLexer.ARRAY = 21; -SqlBaseLexer.AS = 22; -SqlBaseLexer.ASC = 23; -SqlBaseLexer.AT = 24; -SqlBaseLexer.AUTHORIZATION = 25; -SqlBaseLexer.BETWEEN = 26; -SqlBaseLexer.BOTH = 27; -SqlBaseLexer.BUCKET = 28; -SqlBaseLexer.BUCKETS = 29; -SqlBaseLexer.BY = 30; -SqlBaseLexer.CACHE = 31; -SqlBaseLexer.CASCADE = 32; -SqlBaseLexer.CASE = 33; -SqlBaseLexer.CAST = 34; -SqlBaseLexer.CHANGE = 35; -SqlBaseLexer.CHECK = 36; -SqlBaseLexer.CLEAR = 37; -SqlBaseLexer.CLUSTER = 38; -SqlBaseLexer.CLUSTERED = 39; -SqlBaseLexer.CODEGEN = 40; -SqlBaseLexer.COLLATE = 41; -SqlBaseLexer.COLLECTION = 42; -SqlBaseLexer.COLUMN = 43; -SqlBaseLexer.COLUMNS = 44; -SqlBaseLexer.COMMENT = 45; -SqlBaseLexer.COMMIT = 46; -SqlBaseLexer.COMPACT = 47; -SqlBaseLexer.COMPACTIONS = 48; -SqlBaseLexer.COMPUTE = 49; -SqlBaseLexer.CONCATENATE = 50; -SqlBaseLexer.CONSTRAINT = 51; -SqlBaseLexer.COST = 52; -SqlBaseLexer.CREATE = 53; -SqlBaseLexer.CROSS = 54; -SqlBaseLexer.CUBE = 55; -SqlBaseLexer.CURRENT = 56; -SqlBaseLexer.CURRENT_DATE = 57; -SqlBaseLexer.CURRENT_TIME = 58; -SqlBaseLexer.CURRENT_TIMESTAMP = 59; -SqlBaseLexer.CURRENT_USER = 60; -SqlBaseLexer.DATA = 61; -SqlBaseLexer.DATABASE = 62; -SqlBaseLexer.DATABASES = 63; -SqlBaseLexer.DBPROPERTIES = 64; -SqlBaseLexer.DEFINED = 65; -SqlBaseLexer.DELETE = 66; -SqlBaseLexer.DELIMITED = 67; -SqlBaseLexer.DESC = 68; -SqlBaseLexer.DESCRIBE = 69; -SqlBaseLexer.DFS = 70; -SqlBaseLexer.DIRECTORIES = 71; -SqlBaseLexer.DIRECTORY = 72; -SqlBaseLexer.DISTINCT = 73; -SqlBaseLexer.DISTRIBUTE = 74; -SqlBaseLexer.DIV = 75; -SqlBaseLexer.DROP = 76; -SqlBaseLexer.ELSE = 77; -SqlBaseLexer.END = 78; -SqlBaseLexer.ESCAPE = 79; -SqlBaseLexer.ESCAPED = 80; -SqlBaseLexer.EXCEPT = 81; -SqlBaseLexer.EXCHANGE = 82; -SqlBaseLexer.EXISTS = 83; -SqlBaseLexer.EXPLAIN = 84; -SqlBaseLexer.EXPORT = 85; -SqlBaseLexer.EXTENDED = 86; -SqlBaseLexer.EXTERNAL = 87; -SqlBaseLexer.EXTRACT = 88; -SqlBaseLexer.FALSE = 89; -SqlBaseLexer.FETCH = 90; -SqlBaseLexer.FIELDS = 91; -SqlBaseLexer.FILTER = 92; -SqlBaseLexer.FILEFORMAT = 93; -SqlBaseLexer.FIRST = 94; -SqlBaseLexer.FOLLOWING = 95; -SqlBaseLexer.FOR = 96; -SqlBaseLexer.FOREIGN = 97; -SqlBaseLexer.FORMAT = 98; -SqlBaseLexer.FORMATTED = 99; -SqlBaseLexer.FROM = 100; -SqlBaseLexer.FULL = 101; -SqlBaseLexer.FUNCTION = 102; -SqlBaseLexer.FUNCTIONS = 103; -SqlBaseLexer.GLOBAL = 104; -SqlBaseLexer.GRANT = 105; -SqlBaseLexer.GROUP = 106; -SqlBaseLexer.GROUPING = 107; -SqlBaseLexer.HAVING = 108; -SqlBaseLexer.IF = 109; -SqlBaseLexer.IGNORE = 110; -SqlBaseLexer.IMPORT = 111; -SqlBaseLexer.IN = 112; -SqlBaseLexer.INDEX = 113; -SqlBaseLexer.INDEXES = 114; -SqlBaseLexer.INNER = 115; -SqlBaseLexer.INPATH = 116; -SqlBaseLexer.INPUTFORMAT = 117; -SqlBaseLexer.INSERT = 118; -SqlBaseLexer.INTERSECT = 119; -SqlBaseLexer.INTERVAL = 120; -SqlBaseLexer.INTO = 121; -SqlBaseLexer.IS = 122; -SqlBaseLexer.ITEMS = 123; -SqlBaseLexer.JOIN = 124; -SqlBaseLexer.KEYS = 125; -SqlBaseLexer.LAST = 126; -SqlBaseLexer.LATERAL = 127; -SqlBaseLexer.LAZY = 128; -SqlBaseLexer.LEADING = 129; -SqlBaseLexer.LEFT = 130; -SqlBaseLexer.LIKE = 131; -SqlBaseLexer.LIMIT = 132; -SqlBaseLexer.LINES = 133; -SqlBaseLexer.LIST = 134; -SqlBaseLexer.LOAD = 135; -SqlBaseLexer.LOCAL = 136; -SqlBaseLexer.LOCATION = 137; -SqlBaseLexer.LOCK = 138; -SqlBaseLexer.LOCKS = 139; -SqlBaseLexer.LOGICAL = 140; -SqlBaseLexer.MACRO = 141; -SqlBaseLexer.MAP = 142; -SqlBaseLexer.MATCHED = 143; -SqlBaseLexer.MERGE = 144; -SqlBaseLexer.MSCK = 145; -SqlBaseLexer.NAMESPACE = 146; -SqlBaseLexer.NAMESPACES = 147; -SqlBaseLexer.NATURAL = 148; -SqlBaseLexer.NO = 149; -SqlBaseLexer.NOT = 150; -SqlBaseLexer.NULL = 151; -SqlBaseLexer.NULLS = 152; -SqlBaseLexer.OF = 153; -SqlBaseLexer.ON = 154; -SqlBaseLexer.ONLY = 155; -SqlBaseLexer.OPTION = 156; -SqlBaseLexer.OPTIONS = 157; -SqlBaseLexer.OR = 158; -SqlBaseLexer.ORDER = 159; -SqlBaseLexer.OUT = 160; -SqlBaseLexer.OUTER = 161; -SqlBaseLexer.OUTPUTFORMAT = 162; -SqlBaseLexer.OVER = 163; -SqlBaseLexer.OVERLAPS = 164; -SqlBaseLexer.OVERLAY = 165; -SqlBaseLexer.OVERWRITE = 166; -SqlBaseLexer.PARTITION = 167; -SqlBaseLexer.PARTITIONED = 168; -SqlBaseLexer.PARTITIONS = 169; -SqlBaseLexer.PERCENTLIT = 170; -SqlBaseLexer.PIVOT = 171; -SqlBaseLexer.PLACING = 172; -SqlBaseLexer.POSITION = 173; -SqlBaseLexer.PRECEDING = 174; -SqlBaseLexer.PRIMARY = 175; -SqlBaseLexer.PRINCIPALS = 176; -SqlBaseLexer.PROPERTIES = 177; -SqlBaseLexer.PURGE = 178; -SqlBaseLexer.QUERY = 179; -SqlBaseLexer.RANGE = 180; -SqlBaseLexer.RECORDREADER = 181; -SqlBaseLexer.RECORDWRITER = 182; -SqlBaseLexer.RECOVER = 183; -SqlBaseLexer.REDUCE = 184; -SqlBaseLexer.REFERENCES = 185; -SqlBaseLexer.REFRESH = 186; -SqlBaseLexer.RENAME = 187; -SqlBaseLexer.REPAIR = 188; -SqlBaseLexer.REPLACE = 189; -SqlBaseLexer.RESET = 190; -SqlBaseLexer.RESTRICT = 191; -SqlBaseLexer.REVOKE = 192; -SqlBaseLexer.RIGHT = 193; -SqlBaseLexer.RLIKE = 194; -SqlBaseLexer.ROLE = 195; -SqlBaseLexer.ROLES = 196; -SqlBaseLexer.ROLLBACK = 197; -SqlBaseLexer.ROLLUP = 198; -SqlBaseLexer.ROW = 199; -SqlBaseLexer.ROWS = 200; -SqlBaseLexer.SCHEMA = 201; -SqlBaseLexer.SELECT = 202; -SqlBaseLexer.SEMI = 203; -SqlBaseLexer.SEPARATED = 204; -SqlBaseLexer.SERDE = 205; -SqlBaseLexer.SERDEPROPERTIES = 206; -SqlBaseLexer.SESSION_USER = 207; -SqlBaseLexer.SET = 208; -SqlBaseLexer.SETMINUS = 209; -SqlBaseLexer.SETS = 210; -SqlBaseLexer.SHOW = 211; -SqlBaseLexer.SKEWED = 212; -SqlBaseLexer.SOME = 213; -SqlBaseLexer.SORT = 214; -SqlBaseLexer.SORTED = 215; -SqlBaseLexer.START = 216; -SqlBaseLexer.STATISTICS = 217; -SqlBaseLexer.STORED = 218; -SqlBaseLexer.STRATIFY = 219; -SqlBaseLexer.STRUCT = 220; -SqlBaseLexer.SUBSTR = 221; -SqlBaseLexer.SUBSTRING = 222; -SqlBaseLexer.TABLE = 223; -SqlBaseLexer.TABLES = 224; -SqlBaseLexer.TABLESAMPLE = 225; -SqlBaseLexer.TBLPROPERTIES = 226; -SqlBaseLexer.TEMPORARY = 227; -SqlBaseLexer.TERMINATED = 228; -SqlBaseLexer.THEN = 229; -SqlBaseLexer.TIME = 230; -SqlBaseLexer.TO = 231; -SqlBaseLexer.TOUCH = 232; -SqlBaseLexer.TRAILING = 233; -SqlBaseLexer.TRANSACTION = 234; -SqlBaseLexer.TRANSACTIONS = 235; -SqlBaseLexer.TRANSFORM = 236; -SqlBaseLexer.TRIM = 237; -SqlBaseLexer.TRUE = 238; -SqlBaseLexer.TRUNCATE = 239; -SqlBaseLexer.TYPE = 240; -SqlBaseLexer.UNARCHIVE = 241; -SqlBaseLexer.UNBOUNDED = 242; -SqlBaseLexer.UNCACHE = 243; -SqlBaseLexer.UNION = 244; -SqlBaseLexer.UNIQUE = 245; -SqlBaseLexer.UNKNOWN = 246; -SqlBaseLexer.UNLOCK = 247; -SqlBaseLexer.UNSET = 248; -SqlBaseLexer.UPDATE = 249; -SqlBaseLexer.USE = 250; -SqlBaseLexer.USER = 251; -SqlBaseLexer.USING = 252; -SqlBaseLexer.VALUES = 253; -SqlBaseLexer.VIEW = 254; -SqlBaseLexer.VIEWS = 255; -SqlBaseLexer.WHEN = 256; -SqlBaseLexer.WHERE = 257; -SqlBaseLexer.WINDOW = 258; -SqlBaseLexer.WITH = 259; -SqlBaseLexer.ZONE = 260; -SqlBaseLexer.EQ = 261; -SqlBaseLexer.NSEQ = 262; -SqlBaseLexer.NEQ = 263; -SqlBaseLexer.NEQJ = 264; -SqlBaseLexer.LT = 265; -SqlBaseLexer.LTE = 266; -SqlBaseLexer.GT = 267; -SqlBaseLexer.GTE = 268; -SqlBaseLexer.PLUS = 269; -SqlBaseLexer.MINUS = 270; -SqlBaseLexer.ASTERISK = 271; -SqlBaseLexer.SLASH = 272; -SqlBaseLexer.PERCENT = 273; -SqlBaseLexer.TILDE = 274; -SqlBaseLexer.AMPERSAND = 275; -SqlBaseLexer.PIPE = 276; -SqlBaseLexer.CONCAT_PIPE = 277; -SqlBaseLexer.HAT = 278; -SqlBaseLexer.STRING = 279; -SqlBaseLexer.BIGINT_LITERAL = 280; -SqlBaseLexer.SMALLINT_LITERAL = 281; -SqlBaseLexer.TINYINT_LITERAL = 282; -SqlBaseLexer.INTEGER_VALUE = 283; -SqlBaseLexer.EXPONENT_VALUE = 284; -SqlBaseLexer.DECIMAL_VALUE = 285; -SqlBaseLexer.FLOAT_LITERAL = 286; -SqlBaseLexer.DOUBLE_LITERAL = 287; -SqlBaseLexer.BIGDECIMAL_LITERAL = 288; -SqlBaseLexer.IDENTIFIER = 289; -SqlBaseLexer.BACKQUOTED_IDENTIFIER = 290; -SqlBaseLexer.SIMPLE_COMMENT = 291; -SqlBaseLexer.BRACKETED_COMMENT = 292; -SqlBaseLexer.WS = 293; -SqlBaseLexer.UNRECOGNIZED = 294; +SparkSqlLexer.EOF = antlr4.Token.EOF; +SparkSqlLexer.T__0 = 1; +SparkSqlLexer.T__1 = 2; +SparkSqlLexer.T__2 = 3; +SparkSqlLexer.T__3 = 4; +SparkSqlLexer.T__4 = 5; +SparkSqlLexer.T__5 = 6; +SparkSqlLexer.T__6 = 7; +SparkSqlLexer.T__7 = 8; +SparkSqlLexer.T__8 = 9; +SparkSqlLexer.T__9 = 10; +SparkSqlLexer.T__10 = 11; +SparkSqlLexer.ADD = 12; +SparkSqlLexer.AFTER = 13; +SparkSqlLexer.ALL = 14; +SparkSqlLexer.ALTER = 15; +SparkSqlLexer.ANALYZE = 16; +SparkSqlLexer.AND = 17; +SparkSqlLexer.ANTI = 18; +SparkSqlLexer.ANY = 19; +SparkSqlLexer.ARCHIVE = 20; +SparkSqlLexer.ARRAY = 21; +SparkSqlLexer.AS = 22; +SparkSqlLexer.ASC = 23; +SparkSqlLexer.AT = 24; +SparkSqlLexer.AUTHORIZATION = 25; +SparkSqlLexer.BETWEEN = 26; +SparkSqlLexer.BOTH = 27; +SparkSqlLexer.BUCKET = 28; +SparkSqlLexer.BUCKETS = 29; +SparkSqlLexer.BY = 30; +SparkSqlLexer.CACHE = 31; +SparkSqlLexer.CASCADE = 32; +SparkSqlLexer.CASE = 33; +SparkSqlLexer.CAST = 34; +SparkSqlLexer.CHANGE = 35; +SparkSqlLexer.CHECK = 36; +SparkSqlLexer.CLEAR = 37; +SparkSqlLexer.CLUSTER = 38; +SparkSqlLexer.CLUSTERED = 39; +SparkSqlLexer.CODEGEN = 40; +SparkSqlLexer.COLLATE = 41; +SparkSqlLexer.COLLECTION = 42; +SparkSqlLexer.COLUMN = 43; +SparkSqlLexer.COLUMNS = 44; +SparkSqlLexer.COMMENT = 45; +SparkSqlLexer.COMMIT = 46; +SparkSqlLexer.COMPACT = 47; +SparkSqlLexer.COMPACTIONS = 48; +SparkSqlLexer.COMPUTE = 49; +SparkSqlLexer.CONCATENATE = 50; +SparkSqlLexer.CONSTRAINT = 51; +SparkSqlLexer.COST = 52; +SparkSqlLexer.CREATE = 53; +SparkSqlLexer.CROSS = 54; +SparkSqlLexer.CUBE = 55; +SparkSqlLexer.CURRENT = 56; +SparkSqlLexer.CURRENT_DATE = 57; +SparkSqlLexer.CURRENT_TIME = 58; +SparkSqlLexer.CURRENT_TIMESTAMP = 59; +SparkSqlLexer.CURRENT_USER = 60; +SparkSqlLexer.DATA = 61; +SparkSqlLexer.DATABASE = 62; +SparkSqlLexer.DATABASES = 63; +SparkSqlLexer.DBPROPERTIES = 64; +SparkSqlLexer.DEFINED = 65; +SparkSqlLexer.DELETE = 66; +SparkSqlLexer.DELIMITED = 67; +SparkSqlLexer.DESC = 68; +SparkSqlLexer.DESCRIBE = 69; +SparkSqlLexer.DFS = 70; +SparkSqlLexer.DIRECTORIES = 71; +SparkSqlLexer.DIRECTORY = 72; +SparkSqlLexer.DISTINCT = 73; +SparkSqlLexer.DISTRIBUTE = 74; +SparkSqlLexer.DIV = 75; +SparkSqlLexer.DROP = 76; +SparkSqlLexer.ELSE = 77; +SparkSqlLexer.END = 78; +SparkSqlLexer.ESCAPE = 79; +SparkSqlLexer.ESCAPED = 80; +SparkSqlLexer.EXCEPT = 81; +SparkSqlLexer.EXCHANGE = 82; +SparkSqlLexer.EXISTS = 83; +SparkSqlLexer.EXPLAIN = 84; +SparkSqlLexer.EXPORT = 85; +SparkSqlLexer.EXTENDED = 86; +SparkSqlLexer.EXTERNAL = 87; +SparkSqlLexer.EXTRACT = 88; +SparkSqlLexer.FALSE = 89; +SparkSqlLexer.FETCH = 90; +SparkSqlLexer.FIELDS = 91; +SparkSqlLexer.FILTER = 92; +SparkSqlLexer.FILEFORMAT = 93; +SparkSqlLexer.FIRST = 94; +SparkSqlLexer.FOLLOWING = 95; +SparkSqlLexer.FOR = 96; +SparkSqlLexer.FOREIGN = 97; +SparkSqlLexer.FORMAT = 98; +SparkSqlLexer.FORMATTED = 99; +SparkSqlLexer.FROM = 100; +SparkSqlLexer.FULL = 101; +SparkSqlLexer.FUNCTION = 102; +SparkSqlLexer.FUNCTIONS = 103; +SparkSqlLexer.GLOBAL = 104; +SparkSqlLexer.GRANT = 105; +SparkSqlLexer.GROUP = 106; +SparkSqlLexer.GROUPING = 107; +SparkSqlLexer.HAVING = 108; +SparkSqlLexer.IF = 109; +SparkSqlLexer.IGNORE = 110; +SparkSqlLexer.IMPORT = 111; +SparkSqlLexer.IN = 112; +SparkSqlLexer.INDEX = 113; +SparkSqlLexer.INDEXES = 114; +SparkSqlLexer.INNER = 115; +SparkSqlLexer.INPATH = 116; +SparkSqlLexer.INPUTFORMAT = 117; +SparkSqlLexer.INSERT = 118; +SparkSqlLexer.INTERSECT = 119; +SparkSqlLexer.INTERVAL = 120; +SparkSqlLexer.INTO = 121; +SparkSqlLexer.IS = 122; +SparkSqlLexer.ITEMS = 123; +SparkSqlLexer.JOIN = 124; +SparkSqlLexer.KEYS = 125; +SparkSqlLexer.LAST = 126; +SparkSqlLexer.LATERAL = 127; +SparkSqlLexer.LAZY = 128; +SparkSqlLexer.LEADING = 129; +SparkSqlLexer.LEFT = 130; +SparkSqlLexer.LIKE = 131; +SparkSqlLexer.LIMIT = 132; +SparkSqlLexer.LINES = 133; +SparkSqlLexer.LIST = 134; +SparkSqlLexer.LOAD = 135; +SparkSqlLexer.LOCAL = 136; +SparkSqlLexer.LOCATION = 137; +SparkSqlLexer.LOCK = 138; +SparkSqlLexer.LOCKS = 139; +SparkSqlLexer.LOGICAL = 140; +SparkSqlLexer.MACRO = 141; +SparkSqlLexer.MAP = 142; +SparkSqlLexer.MATCHED = 143; +SparkSqlLexer.MERGE = 144; +SparkSqlLexer.MSCK = 145; +SparkSqlLexer.NAMESPACE = 146; +SparkSqlLexer.NAMESPACES = 147; +SparkSqlLexer.NATURAL = 148; +SparkSqlLexer.NO = 149; +SparkSqlLexer.NOT = 150; +SparkSqlLexer.NULL = 151; +SparkSqlLexer.NULLS = 152; +SparkSqlLexer.OF = 153; +SparkSqlLexer.ON = 154; +SparkSqlLexer.ONLY = 155; +SparkSqlLexer.OPTION = 156; +SparkSqlLexer.OPTIONS = 157; +SparkSqlLexer.OR = 158; +SparkSqlLexer.ORDER = 159; +SparkSqlLexer.OUT = 160; +SparkSqlLexer.OUTER = 161; +SparkSqlLexer.OUTPUTFORMAT = 162; +SparkSqlLexer.OVER = 163; +SparkSqlLexer.OVERLAPS = 164; +SparkSqlLexer.OVERLAY = 165; +SparkSqlLexer.OVERWRITE = 166; +SparkSqlLexer.PARTITION = 167; +SparkSqlLexer.PARTITIONED = 168; +SparkSqlLexer.PARTITIONS = 169; +SparkSqlLexer.PERCENTLIT = 170; +SparkSqlLexer.PIVOT = 171; +SparkSqlLexer.PLACING = 172; +SparkSqlLexer.POSITION = 173; +SparkSqlLexer.PRECEDING = 174; +SparkSqlLexer.PRIMARY = 175; +SparkSqlLexer.PRINCIPALS = 176; +SparkSqlLexer.PROPERTIES = 177; +SparkSqlLexer.PURGE = 178; +SparkSqlLexer.QUERY = 179; +SparkSqlLexer.RANGE = 180; +SparkSqlLexer.RECORDREADER = 181; +SparkSqlLexer.RECORDWRITER = 182; +SparkSqlLexer.RECOVER = 183; +SparkSqlLexer.REDUCE = 184; +SparkSqlLexer.REFERENCES = 185; +SparkSqlLexer.REFRESH = 186; +SparkSqlLexer.RENAME = 187; +SparkSqlLexer.REPAIR = 188; +SparkSqlLexer.REPLACE = 189; +SparkSqlLexer.RESET = 190; +SparkSqlLexer.RESTRICT = 191; +SparkSqlLexer.REVOKE = 192; +SparkSqlLexer.RIGHT = 193; +SparkSqlLexer.RLIKE = 194; +SparkSqlLexer.ROLE = 195; +SparkSqlLexer.ROLES = 196; +SparkSqlLexer.ROLLBACK = 197; +SparkSqlLexer.ROLLUP = 198; +SparkSqlLexer.ROW = 199; +SparkSqlLexer.ROWS = 200; +SparkSqlLexer.SCHEMA = 201; +SparkSqlLexer.SELECT = 202; +SparkSqlLexer.SEMI = 203; +SparkSqlLexer.SEPARATED = 204; +SparkSqlLexer.SERDE = 205; +SparkSqlLexer.SERDEPROPERTIES = 206; +SparkSqlLexer.SESSION_USER = 207; +SparkSqlLexer.SET = 208; +SparkSqlLexer.SETMINUS = 209; +SparkSqlLexer.SETS = 210; +SparkSqlLexer.SHOW = 211; +SparkSqlLexer.SKEWED = 212; +SparkSqlLexer.SOME = 213; +SparkSqlLexer.SORT = 214; +SparkSqlLexer.SORTED = 215; +SparkSqlLexer.START = 216; +SparkSqlLexer.STATISTICS = 217; +SparkSqlLexer.STORED = 218; +SparkSqlLexer.STRATIFY = 219; +SparkSqlLexer.STRUCT = 220; +SparkSqlLexer.SUBSTR = 221; +SparkSqlLexer.SUBSTRING = 222; +SparkSqlLexer.TABLE = 223; +SparkSqlLexer.TABLES = 224; +SparkSqlLexer.TABLESAMPLE = 225; +SparkSqlLexer.TBLPROPERTIES = 226; +SparkSqlLexer.TEMPORARY = 227; +SparkSqlLexer.TERMINATED = 228; +SparkSqlLexer.THEN = 229; +SparkSqlLexer.TIME = 230; +SparkSqlLexer.TO = 231; +SparkSqlLexer.TOUCH = 232; +SparkSqlLexer.TRAILING = 233; +SparkSqlLexer.TRANSACTION = 234; +SparkSqlLexer.TRANSACTIONS = 235; +SparkSqlLexer.TRANSFORM = 236; +SparkSqlLexer.TRIM = 237; +SparkSqlLexer.TRUE = 238; +SparkSqlLexer.TRUNCATE = 239; +SparkSqlLexer.TYPE = 240; +SparkSqlLexer.UNARCHIVE = 241; +SparkSqlLexer.UNBOUNDED = 242; +SparkSqlLexer.UNCACHE = 243; +SparkSqlLexer.UNION = 244; +SparkSqlLexer.UNIQUE = 245; +SparkSqlLexer.UNKNOWN = 246; +SparkSqlLexer.UNLOCK = 247; +SparkSqlLexer.UNSET = 248; +SparkSqlLexer.UPDATE = 249; +SparkSqlLexer.USE = 250; +SparkSqlLexer.USER = 251; +SparkSqlLexer.USING = 252; +SparkSqlLexer.VALUES = 253; +SparkSqlLexer.VIEW = 254; +SparkSqlLexer.VIEWS = 255; +SparkSqlLexer.WHEN = 256; +SparkSqlLexer.WHERE = 257; +SparkSqlLexer.WINDOW = 258; +SparkSqlLexer.WITH = 259; +SparkSqlLexer.ZONE = 260; +SparkSqlLexer.EQ = 261; +SparkSqlLexer.NSEQ = 262; +SparkSqlLexer.NEQ = 263; +SparkSqlLexer.NEQJ = 264; +SparkSqlLexer.LT = 265; +SparkSqlLexer.LTE = 266; +SparkSqlLexer.GT = 267; +SparkSqlLexer.GTE = 268; +SparkSqlLexer.PLUS = 269; +SparkSqlLexer.MINUS = 270; +SparkSqlLexer.ASTERISK = 271; +SparkSqlLexer.SLASH = 272; +SparkSqlLexer.PERCENT = 273; +SparkSqlLexer.TILDE = 274; +SparkSqlLexer.AMPERSAND = 275; +SparkSqlLexer.PIPE = 276; +SparkSqlLexer.CONCAT_PIPE = 277; +SparkSqlLexer.HAT = 278; +SparkSqlLexer.STRING = 279; +SparkSqlLexer.BIGINT_LITERAL = 280; +SparkSqlLexer.SMALLINT_LITERAL = 281; +SparkSqlLexer.TINYINT_LITERAL = 282; +SparkSqlLexer.INTEGER_VALUE = 283; +SparkSqlLexer.EXPONENT_VALUE = 284; +SparkSqlLexer.DECIMAL_VALUE = 285; +SparkSqlLexer.FLOAT_LITERAL = 286; +SparkSqlLexer.DOUBLE_LITERAL = 287; +SparkSqlLexer.BIGDECIMAL_LITERAL = 288; +SparkSqlLexer.IDENTIFIER = 289; +SparkSqlLexer.BACKQUOTED_IDENTIFIER = 290; +SparkSqlLexer.SIMPLE_COMMENT = 291; +SparkSqlLexer.BRACKETED_COMMENT = 292; +SparkSqlLexer.WS = 293; +SparkSqlLexer.UNRECOGNIZED = 294; -SqlBaseLexer.prototype.channelNames = [ "DEFAULT_TOKEN_CHANNEL", "HIDDEN" ]; +SparkSqlLexer.prototype.channelNames = [ "DEFAULT_TOKEN_CHANNEL", "HIDDEN" ]; -SqlBaseLexer.prototype.modeNames = [ "DEFAULT_MODE" ]; +SparkSqlLexer.prototype.modeNames = [ "DEFAULT_MODE" ]; -SqlBaseLexer.prototype.literalNames = [ null, "';'", "'('", "')'", "','", - "'.'", "'/*+'", "'*/'", "'->'", - "'['", "']'", "':'", "'ADD'", "'AFTER'", - "'ALL'", "'ALTER'", "'ANALYZE'", - "'AND'", "'ANTI'", "'ANY'", "'ARCHIVE'", - "'ARRAY'", "'AS'", "'ASC'", "'AT'", - "'AUTHORIZATION'", "'BETWEEN'", - "'BOTH'", "'BUCKET'", "'BUCKETS'", - "'BY'", "'CACHE'", "'CASCADE'", - "'CASE'", "'CAST'", "'CHANGE'", - "'CHECK'", "'CLEAR'", "'CLUSTER'", - "'CLUSTERED'", "'CODEGEN'", "'COLLATE'", - "'COLLECTION'", "'COLUMN'", "'COLUMNS'", - "'COMMENT'", "'COMMIT'", "'COMPACT'", - "'COMPACTIONS'", "'COMPUTE'", "'CONCATENATE'", - "'CONSTRAINT'", "'COST'", "'CREATE'", - "'CROSS'", "'CUBE'", "'CURRENT'", - "'CURRENT_DATE'", "'CURRENT_TIME'", - "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", - "'DATA'", "'DATABASE'", null, "'DBPROPERTIES'", - "'DEFINED'", "'DELETE'", "'DELIMITED'", - "'DESC'", "'DESCRIBE'", "'DFS'", - "'DIRECTORIES'", "'DIRECTORY'", - "'DISTINCT'", "'DISTRIBUTE'", "'DIV'", - "'DROP'", "'ELSE'", "'END'", "'ESCAPE'", - "'ESCAPED'", "'EXCEPT'", "'EXCHANGE'", - "'EXISTS'", "'EXPLAIN'", "'EXPORT'", - "'EXTENDED'", "'EXTERNAL'", "'EXTRACT'", - "'FALSE'", "'FETCH'", "'FIELDS'", - "'FILTER'", "'FILEFORMAT'", "'FIRST'", - "'FOLLOWING'", "'FOR'", "'FOREIGN'", - "'FORMAT'", "'FORMATTED'", "'FROM'", - "'FULL'", "'FUNCTION'", "'FUNCTIONS'", - "'GLOBAL'", "'GRANT'", "'GROUP'", - "'GROUPING'", "'HAVING'", "'IF'", - "'IGNORE'", "'IMPORT'", "'IN'", - "'INDEX'", "'INDEXES'", "'INNER'", - "'INPATH'", "'INPUTFORMAT'", "'INSERT'", - "'INTERSECT'", "'INTERVAL'", "'INTO'", - "'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", - "'LAST'", "'LATERAL'", "'LAZY'", - "'LEADING'", "'LEFT'", "'LIKE'", - "'LIMIT'", "'LINES'", "'LIST'", - "'LOAD'", "'LOCAL'", "'LOCATION'", - "'LOCK'", "'LOCKS'", "'LOGICAL'", - "'MACRO'", "'MAP'", "'MATCHED'", - "'MERGE'", "'MSCK'", "'NAMESPACE'", - "'NAMESPACES'", "'NATURAL'", "'NO'", - null, "'NULL'", "'NULLS'", "'OF'", - "'ON'", "'ONLY'", "'OPTION'", "'OPTIONS'", - "'OR'", "'ORDER'", "'OUT'", "'OUTER'", - "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'", - "'OVERLAY'", "'OVERWRITE'", "'PARTITION'", - "'PARTITIONED'", "'PARTITIONS'", - "'PERCENT'", "'PIVOT'", "'PLACING'", - "'POSITION'", "'PRECEDING'", "'PRIMARY'", - "'PRINCIPALS'", "'PROPERTIES'", - "'PURGE'", "'QUERY'", "'RANGE'", - "'RECORDREADER'", "'RECORDWRITER'", - "'RECOVER'", "'REDUCE'", "'REFERENCES'", - "'REFRESH'", "'RENAME'", "'REPAIR'", - "'REPLACE'", "'RESET'", "'RESTRICT'", - "'REVOKE'", "'RIGHT'", null, "'ROLE'", - "'ROLES'", "'ROLLBACK'", "'ROLLUP'", - "'ROW'", "'ROWS'", "'SCHEMA'", "'SELECT'", - "'SEMI'", "'SEPARATED'", "'SERDE'", - "'SERDEPROPERTIES'", "'SESSION_USER'", - "'SET'", "'MINUS'", "'SETS'", "'SHOW'", - "'SKEWED'", "'SOME'", "'SORT'", - "'SORTED'", "'START'", "'STATISTICS'", - "'STORED'", "'STRATIFY'", "'STRUCT'", - "'SUBSTR'", "'SUBSTRING'", "'TABLE'", - "'TABLES'", "'TABLESAMPLE'", "'TBLPROPERTIES'", - null, "'TERMINATED'", "'THEN'", - "'TIME'", "'TO'", "'TOUCH'", "'TRAILING'", - "'TRANSACTION'", "'TRANSACTIONS'", - "'TRANSFORM'", "'TRIM'", "'TRUE'", - "'TRUNCATE'", "'TYPE'", "'UNARCHIVE'", - "'UNBOUNDED'", "'UNCACHE'", "'UNION'", - "'UNIQUE'", "'UNKNOWN'", "'UNLOCK'", - "'UNSET'", "'UPDATE'", "'USE'", - "'USER'", "'USING'", "'VALUES'", - "'VIEW'", "'VIEWS'", "'WHEN'", "'WHERE'", - "'WINDOW'", "'WITH'", "'ZONE'", - null, "'<=>'", "'<>'", "'!='", "'<'", - null, "'>'", null, "'+'", "'-'", - "'*'", "'/'", "'%'", "'~'", "'&'", - "'|'", "'||'", "'^'" ]; +SparkSqlLexer.prototype.literalNames = [ null, "';'", "'('", "')'", "','", + "'.'", "'/*+'", "'*/'", "'->'", + "'['", "']'", "':'", "'ADD'", "'AFTER'", + "'ALL'", "'ALTER'", "'ANALYZE'", + "'AND'", "'ANTI'", "'ANY'", "'ARCHIVE'", + "'ARRAY'", "'AS'", "'ASC'", "'AT'", + "'AUTHORIZATION'", "'BETWEEN'", + "'BOTH'", "'BUCKET'", "'BUCKETS'", + "'BY'", "'CACHE'", "'CASCADE'", + "'CASE'", "'CAST'", "'CHANGE'", + "'CHECK'", "'CLEAR'", "'CLUSTER'", + "'CLUSTERED'", "'CODEGEN'", "'COLLATE'", + "'COLLECTION'", "'COLUMN'", "'COLUMNS'", + "'COMMENT'", "'COMMIT'", "'COMPACT'", + "'COMPACTIONS'", "'COMPUTE'", "'CONCATENATE'", + "'CONSTRAINT'", "'COST'", "'CREATE'", + "'CROSS'", "'CUBE'", "'CURRENT'", + "'CURRENT_DATE'", "'CURRENT_TIME'", + "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", + "'DATA'", "'DATABASE'", null, "'DBPROPERTIES'", + "'DEFINED'", "'DELETE'", "'DELIMITED'", + "'DESC'", "'DESCRIBE'", "'DFS'", + "'DIRECTORIES'", "'DIRECTORY'", + "'DISTINCT'", "'DISTRIBUTE'", "'DIV'", + "'DROP'", "'ELSE'", "'END'", "'ESCAPE'", + "'ESCAPED'", "'EXCEPT'", "'EXCHANGE'", + "'EXISTS'", "'EXPLAIN'", "'EXPORT'", + "'EXTENDED'", "'EXTERNAL'", "'EXTRACT'", + "'FALSE'", "'FETCH'", "'FIELDS'", + "'FILTER'", "'FILEFORMAT'", "'FIRST'", + "'FOLLOWING'", "'FOR'", "'FOREIGN'", + "'FORMAT'", "'FORMATTED'", "'FROM'", + "'FULL'", "'FUNCTION'", "'FUNCTIONS'", + "'GLOBAL'", "'GRANT'", "'GROUP'", + "'GROUPING'", "'HAVING'", "'IF'", + "'IGNORE'", "'IMPORT'", "'IN'", + "'INDEX'", "'INDEXES'", "'INNER'", + "'INPATH'", "'INPUTFORMAT'", "'INSERT'", + "'INTERSECT'", "'INTERVAL'", "'INTO'", + "'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", + "'LAST'", "'LATERAL'", "'LAZY'", + "'LEADING'", "'LEFT'", "'LIKE'", + "'LIMIT'", "'LINES'", "'LIST'", + "'LOAD'", "'LOCAL'", "'LOCATION'", + "'LOCK'", "'LOCKS'", "'LOGICAL'", + "'MACRO'", "'MAP'", "'MATCHED'", + "'MERGE'", "'MSCK'", "'NAMESPACE'", + "'NAMESPACES'", "'NATURAL'", "'NO'", + null, "'NULL'", "'NULLS'", "'OF'", + "'ON'", "'ONLY'", "'OPTION'", "'OPTIONS'", + "'OR'", "'ORDER'", "'OUT'", "'OUTER'", + "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'", + "'OVERLAY'", "'OVERWRITE'", "'PARTITION'", + "'PARTITIONED'", "'PARTITIONS'", + "'PERCENT'", "'PIVOT'", "'PLACING'", + "'POSITION'", "'PRECEDING'", "'PRIMARY'", + "'PRINCIPALS'", "'PROPERTIES'", + "'PURGE'", "'QUERY'", "'RANGE'", + "'RECORDREADER'", "'RECORDWRITER'", + "'RECOVER'", "'REDUCE'", "'REFERENCES'", + "'REFRESH'", "'RENAME'", "'REPAIR'", + "'REPLACE'", "'RESET'", "'RESTRICT'", + "'REVOKE'", "'RIGHT'", null, "'ROLE'", + "'ROLES'", "'ROLLBACK'", "'ROLLUP'", + "'ROW'", "'ROWS'", "'SCHEMA'", + "'SELECT'", "'SEMI'", "'SEPARATED'", + "'SERDE'", "'SERDEPROPERTIES'", + "'SESSION_USER'", "'SET'", "'MINUS'", + "'SETS'", "'SHOW'", "'SKEWED'", + "'SOME'", "'SORT'", "'SORTED'", + "'START'", "'STATISTICS'", "'STORED'", + "'STRATIFY'", "'STRUCT'", "'SUBSTR'", + "'SUBSTRING'", "'TABLE'", "'TABLES'", + "'TABLESAMPLE'", "'TBLPROPERTIES'", + null, "'TERMINATED'", "'THEN'", + "'TIME'", "'TO'", "'TOUCH'", "'TRAILING'", + "'TRANSACTION'", "'TRANSACTIONS'", + "'TRANSFORM'", "'TRIM'", "'TRUE'", + "'TRUNCATE'", "'TYPE'", "'UNARCHIVE'", + "'UNBOUNDED'", "'UNCACHE'", "'UNION'", + "'UNIQUE'", "'UNKNOWN'", "'UNLOCK'", + "'UNSET'", "'UPDATE'", "'USE'", + "'USER'", "'USING'", "'VALUES'", + "'VIEW'", "'VIEWS'", "'WHEN'", + "'WHERE'", "'WINDOW'", "'WITH'", + "'ZONE'", null, "'<=>'", "'<>'", + "'!='", "'<'", null, "'>'", null, + "'+'", "'-'", "'*'", "'/'", "'%'", + "'~'", "'&'", "'|'", "'||'", "'^'" ]; -SqlBaseLexer.prototype.symbolicNames = [ null, null, null, null, null, null, - null, null, null, null, null, null, - "ADD", "AFTER", "ALL", "ALTER", - "ANALYZE", "AND", "ANTI", "ANY", - "ARCHIVE", "ARRAY", "AS", "ASC", - "AT", "AUTHORIZATION", "BETWEEN", - "BOTH", "BUCKET", "BUCKETS", "BY", - "CACHE", "CASCADE", "CASE", "CAST", - "CHANGE", "CHECK", "CLEAR", "CLUSTER", - "CLUSTERED", "CODEGEN", "COLLATE", - "COLLECTION", "COLUMN", "COLUMNS", - "COMMENT", "COMMIT", "COMPACT", - "COMPACTIONS", "COMPUTE", "CONCATENATE", - "CONSTRAINT", "COST", "CREATE", - "CROSS", "CUBE", "CURRENT", "CURRENT_DATE", - "CURRENT_TIME", "CURRENT_TIMESTAMP", - "CURRENT_USER", "DATA", "DATABASE", - "DATABASES", "DBPROPERTIES", "DEFINED", - "DELETE", "DELIMITED", "DESC", - "DESCRIBE", "DFS", "DIRECTORIES", - "DIRECTORY", "DISTINCT", "DISTRIBUTE", - "DIV", "DROP", "ELSE", "END", "ESCAPE", - "ESCAPED", "EXCEPT", "EXCHANGE", - "EXISTS", "EXPLAIN", "EXPORT", - "EXTENDED", "EXTERNAL", "EXTRACT", - "FALSE", "FETCH", "FIELDS", "FILTER", - "FILEFORMAT", "FIRST", "FOLLOWING", - "FOR", "FOREIGN", "FORMAT", "FORMATTED", - "FROM", "FULL", "FUNCTION", "FUNCTIONS", - "GLOBAL", "GRANT", "GROUP", "GROUPING", - "HAVING", "IF", "IGNORE", "IMPORT", - "IN", "INDEX", "INDEXES", "INNER", - "INPATH", "INPUTFORMAT", "INSERT", - "INTERSECT", "INTERVAL", "INTO", - "IS", "ITEMS", "JOIN", "KEYS", - "LAST", "LATERAL", "LAZY", "LEADING", - "LEFT", "LIKE", "LIMIT", "LINES", - "LIST", "LOAD", "LOCAL", "LOCATION", - "LOCK", "LOCKS", "LOGICAL", "MACRO", - "MAP", "MATCHED", "MERGE", "MSCK", - "NAMESPACE", "NAMESPACES", "NATURAL", - "NO", "NOT", "NULL", "NULLS", "OF", - "ON", "ONLY", "OPTION", "OPTIONS", - "OR", "ORDER", "OUT", "OUTER", - "OUTPUTFORMAT", "OVER", "OVERLAPS", - "OVERLAY", "OVERWRITE", "PARTITION", - "PARTITIONED", "PARTITIONS", "PERCENTLIT", - "PIVOT", "PLACING", "POSITION", - "PRECEDING", "PRIMARY", "PRINCIPALS", - "PROPERTIES", "PURGE", "QUERY", - "RANGE", "RECORDREADER", "RECORDWRITER", - "RECOVER", "REDUCE", "REFERENCES", - "REFRESH", "RENAME", "REPAIR", - "REPLACE", "RESET", "RESTRICT", - "REVOKE", "RIGHT", "RLIKE", "ROLE", - "ROLES", "ROLLBACK", "ROLLUP", - "ROW", "ROWS", "SCHEMA", "SELECT", - "SEMI", "SEPARATED", "SERDE", "SERDEPROPERTIES", - "SESSION_USER", "SET", "SETMINUS", - "SETS", "SHOW", "SKEWED", "SOME", - "SORT", "SORTED", "START", "STATISTICS", - "STORED", "STRATIFY", "STRUCT", - "SUBSTR", "SUBSTRING", "TABLE", - "TABLES", "TABLESAMPLE", "TBLPROPERTIES", - "TEMPORARY", "TERMINATED", "THEN", - "TIME", "TO", "TOUCH", "TRAILING", - "TRANSACTION", "TRANSACTIONS", - "TRANSFORM", "TRIM", "TRUE", "TRUNCATE", - "TYPE", "UNARCHIVE", "UNBOUNDED", - "UNCACHE", "UNION", "UNIQUE", "UNKNOWN", - "UNLOCK", "UNSET", "UPDATE", "USE", - "USER", "USING", "VALUES", "VIEW", - "VIEWS", "WHEN", "WHERE", "WINDOW", - "WITH", "ZONE", "EQ", "NSEQ", "NEQ", - "NEQJ", "LT", "LTE", "GT", "GTE", - "PLUS", "MINUS", "ASTERISK", "SLASH", - "PERCENT", "TILDE", "AMPERSAND", - "PIPE", "CONCAT_PIPE", "HAT", "STRING", - "BIGINT_LITERAL", "SMALLINT_LITERAL", - "TINYINT_LITERAL", "INTEGER_VALUE", - "EXPONENT_VALUE", "DECIMAL_VALUE", - "FLOAT_LITERAL", "DOUBLE_LITERAL", - "BIGDECIMAL_LITERAL", "IDENTIFIER", - "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", - "BRACKETED_COMMENT", "WS", "UNRECOGNIZED" ]; +SparkSqlLexer.prototype.symbolicNames = [ null, null, null, null, null, + null, null, null, null, null, + null, null, "ADD", "AFTER", "ALL", + "ALTER", "ANALYZE", "AND", "ANTI", + "ANY", "ARCHIVE", "ARRAY", "AS", + "ASC", "AT", "AUTHORIZATION", + "BETWEEN", "BOTH", "BUCKET", "BUCKETS", + "BY", "CACHE", "CASCADE", "CASE", + "CAST", "CHANGE", "CHECK", "CLEAR", + "CLUSTER", "CLUSTERED", "CODEGEN", + "COLLATE", "COLLECTION", "COLUMN", + "COLUMNS", "COMMENT", "COMMIT", + "COMPACT", "COMPACTIONS", "COMPUTE", + "CONCATENATE", "CONSTRAINT", "COST", + "CREATE", "CROSS", "CUBE", "CURRENT", + "CURRENT_DATE", "CURRENT_TIME", + "CURRENT_TIMESTAMP", "CURRENT_USER", + "DATA", "DATABASE", "DATABASES", + "DBPROPERTIES", "DEFINED", "DELETE", + "DELIMITED", "DESC", "DESCRIBE", + "DFS", "DIRECTORIES", "DIRECTORY", + "DISTINCT", "DISTRIBUTE", "DIV", + "DROP", "ELSE", "END", "ESCAPE", + "ESCAPED", "EXCEPT", "EXCHANGE", + "EXISTS", "EXPLAIN", "EXPORT", + "EXTENDED", "EXTERNAL", "EXTRACT", + "FALSE", "FETCH", "FIELDS", "FILTER", + "FILEFORMAT", "FIRST", "FOLLOWING", + "FOR", "FOREIGN", "FORMAT", "FORMATTED", + "FROM", "FULL", "FUNCTION", "FUNCTIONS", + "GLOBAL", "GRANT", "GROUP", "GROUPING", + "HAVING", "IF", "IGNORE", "IMPORT", + "IN", "INDEX", "INDEXES", "INNER", + "INPATH", "INPUTFORMAT", "INSERT", + "INTERSECT", "INTERVAL", "INTO", + "IS", "ITEMS", "JOIN", "KEYS", + "LAST", "LATERAL", "LAZY", "LEADING", + "LEFT", "LIKE", "LIMIT", "LINES", + "LIST", "LOAD", "LOCAL", "LOCATION", + "LOCK", "LOCKS", "LOGICAL", "MACRO", + "MAP", "MATCHED", "MERGE", "MSCK", + "NAMESPACE", "NAMESPACES", "NATURAL", + "NO", "NOT", "NULL", "NULLS", + "OF", "ON", "ONLY", "OPTION", + "OPTIONS", "OR", "ORDER", "OUT", + "OUTER", "OUTPUTFORMAT", "OVER", + "OVERLAPS", "OVERLAY", "OVERWRITE", + "PARTITION", "PARTITIONED", "PARTITIONS", + "PERCENTLIT", "PIVOT", "PLACING", + "POSITION", "PRECEDING", "PRIMARY", + "PRINCIPALS", "PROPERTIES", "PURGE", + "QUERY", "RANGE", "RECORDREADER", + "RECORDWRITER", "RECOVER", "REDUCE", + "REFERENCES", "REFRESH", "RENAME", + "REPAIR", "REPLACE", "RESET", + "RESTRICT", "REVOKE", "RIGHT", + "RLIKE", "ROLE", "ROLES", "ROLLBACK", + "ROLLUP", "ROW", "ROWS", "SCHEMA", + "SELECT", "SEMI", "SEPARATED", + "SERDE", "SERDEPROPERTIES", "SESSION_USER", + "SET", "SETMINUS", "SETS", "SHOW", + "SKEWED", "SOME", "SORT", "SORTED", + "START", "STATISTICS", "STORED", + "STRATIFY", "STRUCT", "SUBSTR", + "SUBSTRING", "TABLE", "TABLES", + "TABLESAMPLE", "TBLPROPERTIES", + "TEMPORARY", "TERMINATED", "THEN", + "TIME", "TO", "TOUCH", "TRAILING", + "TRANSACTION", "TRANSACTIONS", + "TRANSFORM", "TRIM", "TRUE", "TRUNCATE", + "TYPE", "UNARCHIVE", "UNBOUNDED", + "UNCACHE", "UNION", "UNIQUE", + "UNKNOWN", "UNLOCK", "UNSET", + "UPDATE", "USE", "USER", "USING", + "VALUES", "VIEW", "VIEWS", "WHEN", + "WHERE", "WINDOW", "WITH", "ZONE", + "EQ", "NSEQ", "NEQ", "NEQJ", "LT", + "LTE", "GT", "GTE", "PLUS", "MINUS", + "ASTERISK", "SLASH", "PERCENT", + "TILDE", "AMPERSAND", "PIPE", + "CONCAT_PIPE", "HAT", "STRING", + "BIGINT_LITERAL", "SMALLINT_LITERAL", + "TINYINT_LITERAL", "INTEGER_VALUE", + "EXPONENT_VALUE", "DECIMAL_VALUE", + "FLOAT_LITERAL", "DOUBLE_LITERAL", + "BIGDECIMAL_LITERAL", "IDENTIFIER", + "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", + "BRACKETED_COMMENT", "WS", "UNRECOGNIZED" ]; -SqlBaseLexer.prototype.ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", - "T__5", "T__6", "T__7", "T__8", "T__9", - "T__10", "ADD", "AFTER", "ALL", "ALTER", - "ANALYZE", "AND", "ANTI", "ANY", "ARCHIVE", - "ARRAY", "AS", "ASC", "AT", "AUTHORIZATION", - "BETWEEN", "BOTH", "BUCKET", "BUCKETS", - "BY", "CACHE", "CASCADE", "CASE", "CAST", - "CHANGE", "CHECK", "CLEAR", "CLUSTER", - "CLUSTERED", "CODEGEN", "COLLATE", - "COLLECTION", "COLUMN", "COLUMNS", - "COMMENT", "COMMIT", "COMPACT", "COMPACTIONS", - "COMPUTE", "CONCATENATE", "CONSTRAINT", - "COST", "CREATE", "CROSS", "CUBE", - "CURRENT", "CURRENT_DATE", "CURRENT_TIME", - "CURRENT_TIMESTAMP", "CURRENT_USER", - "DATA", "DATABASE", "DATABASES", "DBPROPERTIES", - "DEFINED", "DELETE", "DELIMITED", "DESC", - "DESCRIBE", "DFS", "DIRECTORIES", "DIRECTORY", - "DISTINCT", "DISTRIBUTE", "DIV", "DROP", - "ELSE", "END", "ESCAPE", "ESCAPED", - "EXCEPT", "EXCHANGE", "EXISTS", "EXPLAIN", - "EXPORT", "EXTENDED", "EXTERNAL", "EXTRACT", - "FALSE", "FETCH", "FIELDS", "FILTER", - "FILEFORMAT", "FIRST", "FOLLOWING", - "FOR", "FOREIGN", "FORMAT", "FORMATTED", - "FROM", "FULL", "FUNCTION", "FUNCTIONS", - "GLOBAL", "GRANT", "GROUP", "GROUPING", - "HAVING", "IF", "IGNORE", "IMPORT", - "IN", "INDEX", "INDEXES", "INNER", - "INPATH", "INPUTFORMAT", "INSERT", - "INTERSECT", "INTERVAL", "INTO", "IS", - "ITEMS", "JOIN", "KEYS", "LAST", "LATERAL", - "LAZY", "LEADING", "LEFT", "LIKE", - "LIMIT", "LINES", "LIST", "LOAD", "LOCAL", - "LOCATION", "LOCK", "LOCKS", "LOGICAL", - "MACRO", "MAP", "MATCHED", "MERGE", - "MSCK", "NAMESPACE", "NAMESPACES", - "NATURAL", "NO", "NOT", "NULL", "NULLS", - "OF", "ON", "ONLY", "OPTION", "OPTIONS", - "OR", "ORDER", "OUT", "OUTER", "OUTPUTFORMAT", - "OVER", "OVERLAPS", "OVERLAY", "OVERWRITE", - "PARTITION", "PARTITIONED", "PARTITIONS", - "PERCENTLIT", "PIVOT", "PLACING", "POSITION", - "PRECEDING", "PRIMARY", "PRINCIPALS", - "PROPERTIES", "PURGE", "QUERY", "RANGE", - "RECORDREADER", "RECORDWRITER", "RECOVER", - "REDUCE", "REFERENCES", "REFRESH", - "RENAME", "REPAIR", "REPLACE", "RESET", - "RESTRICT", "REVOKE", "RIGHT", "RLIKE", - "ROLE", "ROLES", "ROLLBACK", "ROLLUP", - "ROW", "ROWS", "SCHEMA", "SELECT", - "SEMI", "SEPARATED", "SERDE", "SERDEPROPERTIES", - "SESSION_USER", "SET", "SETMINUS", - "SETS", "SHOW", "SKEWED", "SOME", "SORT", - "SORTED", "START", "STATISTICS", "STORED", - "STRATIFY", "STRUCT", "SUBSTR", "SUBSTRING", - "TABLE", "TABLES", "TABLESAMPLE", "TBLPROPERTIES", - "TEMPORARY", "TERMINATED", "THEN", - "TIME", "TO", "TOUCH", "TRAILING", - "TRANSACTION", "TRANSACTIONS", "TRANSFORM", - "TRIM", "TRUE", "TRUNCATE", "TYPE", - "UNARCHIVE", "UNBOUNDED", "UNCACHE", - "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", - "UNSET", "UPDATE", "USE", "USER", "USING", - "VALUES", "VIEW", "VIEWS", "WHEN", - "WHERE", "WINDOW", "WITH", "ZONE", - "EQ", "NSEQ", "NEQ", "NEQJ", "LT", - "LTE", "GT", "GTE", "PLUS", "MINUS", - "ASTERISK", "SLASH", "PERCENT", "TILDE", - "AMPERSAND", "PIPE", "CONCAT_PIPE", - "HAT", "STRING", "BIGINT_LITERAL", - "SMALLINT_LITERAL", "TINYINT_LITERAL", - "INTEGER_VALUE", "EXPONENT_VALUE", - "DECIMAL_VALUE", "FLOAT_LITERAL", "DOUBLE_LITERAL", - "BIGDECIMAL_LITERAL", "IDENTIFIER", - "BACKQUOTED_IDENTIFIER", "DECIMAL_DIGITS", - "EXPONENT", "DIGIT", "LETTER", "SIMPLE_COMMENT", - "BRACKETED_COMMENT", "WS", "UNRECOGNIZED" ]; +SparkSqlLexer.prototype.ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", + "T__5", "T__6", "T__7", "T__8", "T__9", + "T__10", "ADD", "AFTER", "ALL", "ALTER", + "ANALYZE", "AND", "ANTI", "ANY", "ARCHIVE", + "ARRAY", "AS", "ASC", "AT", "AUTHORIZATION", + "BETWEEN", "BOTH", "BUCKET", "BUCKETS", + "BY", "CACHE", "CASCADE", "CASE", + "CAST", "CHANGE", "CHECK", "CLEAR", + "CLUSTER", "CLUSTERED", "CODEGEN", + "COLLATE", "COLLECTION", "COLUMN", + "COLUMNS", "COMMENT", "COMMIT", "COMPACT", + "COMPACTIONS", "COMPUTE", "CONCATENATE", + "CONSTRAINT", "COST", "CREATE", "CROSS", + "CUBE", "CURRENT", "CURRENT_DATE", + "CURRENT_TIME", "CURRENT_TIMESTAMP", + "CURRENT_USER", "DATA", "DATABASE", + "DATABASES", "DBPROPERTIES", "DEFINED", + "DELETE", "DELIMITED", "DESC", "DESCRIBE", + "DFS", "DIRECTORIES", "DIRECTORY", + "DISTINCT", "DISTRIBUTE", "DIV", "DROP", + "ELSE", "END", "ESCAPE", "ESCAPED", + "EXCEPT", "EXCHANGE", "EXISTS", "EXPLAIN", + "EXPORT", "EXTENDED", "EXTERNAL", + "EXTRACT", "FALSE", "FETCH", "FIELDS", + "FILTER", "FILEFORMAT", "FIRST", "FOLLOWING", + "FOR", "FOREIGN", "FORMAT", "FORMATTED", + "FROM", "FULL", "FUNCTION", "FUNCTIONS", + "GLOBAL", "GRANT", "GROUP", "GROUPING", + "HAVING", "IF", "IGNORE", "IMPORT", + "IN", "INDEX", "INDEXES", "INNER", + "INPATH", "INPUTFORMAT", "INSERT", + "INTERSECT", "INTERVAL", "INTO", "IS", + "ITEMS", "JOIN", "KEYS", "LAST", "LATERAL", + "LAZY", "LEADING", "LEFT", "LIKE", + "LIMIT", "LINES", "LIST", "LOAD", + "LOCAL", "LOCATION", "LOCK", "LOCKS", + "LOGICAL", "MACRO", "MAP", "MATCHED", + "MERGE", "MSCK", "NAMESPACE", "NAMESPACES", + "NATURAL", "NO", "NOT", "NULL", "NULLS", + "OF", "ON", "ONLY", "OPTION", "OPTIONS", + "OR", "ORDER", "OUT", "OUTER", "OUTPUTFORMAT", + "OVER", "OVERLAPS", "OVERLAY", "OVERWRITE", + "PARTITION", "PARTITIONED", "PARTITIONS", + "PERCENTLIT", "PIVOT", "PLACING", + "POSITION", "PRECEDING", "PRIMARY", + "PRINCIPALS", "PROPERTIES", "PURGE", + "QUERY", "RANGE", "RECORDREADER", + "RECORDWRITER", "RECOVER", "REDUCE", + "REFERENCES", "REFRESH", "RENAME", + "REPAIR", "REPLACE", "RESET", "RESTRICT", + "REVOKE", "RIGHT", "RLIKE", "ROLE", + "ROLES", "ROLLBACK", "ROLLUP", "ROW", + "ROWS", "SCHEMA", "SELECT", "SEMI", + "SEPARATED", "SERDE", "SERDEPROPERTIES", + "SESSION_USER", "SET", "SETMINUS", + "SETS", "SHOW", "SKEWED", "SOME", + "SORT", "SORTED", "START", "STATISTICS", + "STORED", "STRATIFY", "STRUCT", "SUBSTR", + "SUBSTRING", "TABLE", "TABLES", "TABLESAMPLE", + "TBLPROPERTIES", "TEMPORARY", "TERMINATED", + "THEN", "TIME", "TO", "TOUCH", "TRAILING", + "TRANSACTION", "TRANSACTIONS", "TRANSFORM", + "TRIM", "TRUE", "TRUNCATE", "TYPE", + "UNARCHIVE", "UNBOUNDED", "UNCACHE", + "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", + "UNSET", "UPDATE", "USE", "USER", + "USING", "VALUES", "VIEW", "VIEWS", + "WHEN", "WHERE", "WINDOW", "WITH", + "ZONE", "EQ", "NSEQ", "NEQ", "NEQJ", + "LT", "LTE", "GT", "GTE", "PLUS", + "MINUS", "ASTERISK", "SLASH", "PERCENT", + "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE", + "HAT", "STRING", "BIGINT_LITERAL", + "SMALLINT_LITERAL", "TINYINT_LITERAL", + "INTEGER_VALUE", "EXPONENT_VALUE", + "DECIMAL_VALUE", "FLOAT_LITERAL", + "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", + "IDENTIFIER", "BACKQUOTED_IDENTIFIER", + "DECIMAL_DIGITS", "EXPONENT", "DIGIT", + "LETTER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", + "WS", "UNRECOGNIZED" ]; -SqlBaseLexer.prototype.grammarFileName = "SqlBase.g4"; +SparkSqlLexer.prototype.grammarFileName = "SparkSql.g4"; -SqlBaseLexer.prototype.sempred = function(localctx, ruleIndex, predIndex) { +SparkSqlLexer.prototype.sempred = function(localctx, ruleIndex, predIndex) { switch (ruleIndex) { case 283: return this.EXPONENT_VALUE_sempred(localctx, predIndex); @@ -2376,7 +2383,7 @@ SqlBaseLexer.prototype.sempred = function(localctx, ruleIndex, predIndex) { } }; -SqlBaseLexer.prototype.EXPONENT_VALUE_sempred = function(localctx, predIndex) { +SparkSqlLexer.prototype.EXPONENT_VALUE_sempred = function(localctx, predIndex) { switch(predIndex) { case 0: return isValidDecimal(); @@ -2385,7 +2392,7 @@ SqlBaseLexer.prototype.EXPONENT_VALUE_sempred = function(localctx, predIndex) { } }; -SqlBaseLexer.prototype.DECIMAL_VALUE_sempred = function(localctx, predIndex) { +SparkSqlLexer.prototype.DECIMAL_VALUE_sempred = function(localctx, predIndex) { switch(predIndex) { case 1: return isValidDecimal(); @@ -2394,7 +2401,7 @@ SqlBaseLexer.prototype.DECIMAL_VALUE_sempred = function(localctx, predIndex) { } }; -SqlBaseLexer.prototype.FLOAT_LITERAL_sempred = function(localctx, predIndex) { +SparkSqlLexer.prototype.FLOAT_LITERAL_sempred = function(localctx, predIndex) { switch(predIndex) { case 2: return isValidDecimal(); @@ -2403,7 +2410,7 @@ SqlBaseLexer.prototype.FLOAT_LITERAL_sempred = function(localctx, predIndex) { } }; -SqlBaseLexer.prototype.DOUBLE_LITERAL_sempred = function(localctx, predIndex) { +SparkSqlLexer.prototype.DOUBLE_LITERAL_sempred = function(localctx, predIndex) { switch(predIndex) { case 3: return isValidDecimal(); @@ -2412,7 +2419,7 @@ SqlBaseLexer.prototype.DOUBLE_LITERAL_sempred = function(localctx, predIndex) { } }; -SqlBaseLexer.prototype.BIGDECIMAL_LITERAL_sempred = function(localctx, predIndex) { +SparkSqlLexer.prototype.BIGDECIMAL_LITERAL_sempred = function(localctx, predIndex) { switch(predIndex) { case 4: return isValidDecimal(); @@ -2421,7 +2428,7 @@ SqlBaseLexer.prototype.BIGDECIMAL_LITERAL_sempred = function(localctx, predIndex } }; -SqlBaseLexer.prototype.BRACKETED_COMMENT_sempred = function(localctx, predIndex) { +SparkSqlLexer.prototype.BRACKETED_COMMENT_sempred = function(localctx, predIndex) { switch(predIndex) { case 5: return !isHint(); @@ -2432,5 +2439,5 @@ SqlBaseLexer.prototype.BRACKETED_COMMENT_sempred = function(localctx, predIndex) -exports.SqlBaseLexer = SqlBaseLexer; +exports.SparkSqlLexer = SparkSqlLexer; diff --git a/src/lib/spark/SqlBaseLexer.tokens b/src/lib/spark/SparkSqlLexer.tokens similarity index 100% rename from src/lib/spark/SqlBaseLexer.tokens rename to src/lib/spark/SparkSqlLexer.tokens diff --git a/src/lib/spark/SparkSqlListener.js b/src/lib/spark/SparkSqlListener.js new file mode 100644 index 0000000..f1fa47b --- /dev/null +++ b/src/lib/spark/SparkSqlListener.js @@ -0,0 +1,2445 @@ +// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SparkSql.g4 by ANTLR 4.8 +// jshint ignore: start +var antlr4 = require('antlr4/index'); + +// This class defines a complete listener for a parse tree produced by SparkSqlParser. +function SparkSqlListener() { + antlr4.tree.ParseTreeListener.call(this); + return this; +} + +SparkSqlListener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype); +SparkSqlListener.prototype.constructor = SparkSqlListener; + +// Enter a parse tree produced by SparkSqlParser#program. +SparkSqlListener.prototype.enterProgram = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#program. +SparkSqlListener.prototype.exitProgram = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#singleStatement. +SparkSqlListener.prototype.enterSingleStatement = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#singleStatement. +SparkSqlListener.prototype.exitSingleStatement = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#singleExpression. +SparkSqlListener.prototype.enterSingleExpression = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#singleExpression. +SparkSqlListener.prototype.exitSingleExpression = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#singleTableIdentifier. +SparkSqlListener.prototype.enterSingleTableIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#singleTableIdentifier. +SparkSqlListener.prototype.exitSingleTableIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#singleMultipartIdentifier. +SparkSqlListener.prototype.enterSingleMultipartIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#singleMultipartIdentifier. +SparkSqlListener.prototype.exitSingleMultipartIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#singleDataType. +SparkSqlListener.prototype.enterSingleDataType = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#singleDataType. +SparkSqlListener.prototype.exitSingleDataType = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#singleTableSchema. +SparkSqlListener.prototype.enterSingleTableSchema = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#singleTableSchema. +SparkSqlListener.prototype.exitSingleTableSchema = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#statementDefault. +SparkSqlListener.prototype.enterStatementDefault = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#statementDefault. +SparkSqlListener.prototype.exitStatementDefault = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dmlStatement. +SparkSqlListener.prototype.enterDmlStatement = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dmlStatement. +SparkSqlListener.prototype.exitDmlStatement = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#use. +SparkSqlListener.prototype.enterUse = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#use. +SparkSqlListener.prototype.exitUse = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createNamespace. +SparkSqlListener.prototype.enterCreateNamespace = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createNamespace. +SparkSqlListener.prototype.exitCreateNamespace = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setNamespaceProperties. +SparkSqlListener.prototype.enterSetNamespaceProperties = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setNamespaceProperties. +SparkSqlListener.prototype.exitSetNamespaceProperties = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setNamespaceLocation. +SparkSqlListener.prototype.enterSetNamespaceLocation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setNamespaceLocation. +SparkSqlListener.prototype.exitSetNamespaceLocation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dropNamespace. +SparkSqlListener.prototype.enterDropNamespace = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dropNamespace. +SparkSqlListener.prototype.exitDropNamespace = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showNamespaces. +SparkSqlListener.prototype.enterShowNamespaces = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showNamespaces. +SparkSqlListener.prototype.exitShowNamespaces = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createTable. +SparkSqlListener.prototype.enterCreateTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createTable. +SparkSqlListener.prototype.exitCreateTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createHiveTable. +SparkSqlListener.prototype.enterCreateHiveTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createHiveTable. +SparkSqlListener.prototype.exitCreateHiveTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createTableLike. +SparkSqlListener.prototype.enterCreateTableLike = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createTableLike. +SparkSqlListener.prototype.exitCreateTableLike = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#replaceTable. +SparkSqlListener.prototype.enterReplaceTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#replaceTable. +SparkSqlListener.prototype.exitReplaceTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#analyze. +SparkSqlListener.prototype.enterAnalyze = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#analyze. +SparkSqlListener.prototype.exitAnalyze = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#addTableColumns. +SparkSqlListener.prototype.enterAddTableColumns = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#addTableColumns. +SparkSqlListener.prototype.exitAddTableColumns = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#renameTableColumn. +SparkSqlListener.prototype.enterRenameTableColumn = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#renameTableColumn. +SparkSqlListener.prototype.exitRenameTableColumn = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dropTableColumns. +SparkSqlListener.prototype.enterDropTableColumns = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dropTableColumns. +SparkSqlListener.prototype.exitDropTableColumns = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#renameTable. +SparkSqlListener.prototype.enterRenameTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#renameTable. +SparkSqlListener.prototype.exitRenameTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setTableProperties. +SparkSqlListener.prototype.enterSetTableProperties = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setTableProperties. +SparkSqlListener.prototype.exitSetTableProperties = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#unsetTableProperties. +SparkSqlListener.prototype.enterUnsetTableProperties = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#unsetTableProperties. +SparkSqlListener.prototype.exitUnsetTableProperties = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#alterTableAlterColumn. +SparkSqlListener.prototype.enterAlterTableAlterColumn = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#alterTableAlterColumn. +SparkSqlListener.prototype.exitAlterTableAlterColumn = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#hiveChangeColumn. +SparkSqlListener.prototype.enterHiveChangeColumn = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#hiveChangeColumn. +SparkSqlListener.prototype.exitHiveChangeColumn = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#hiveReplaceColumns. +SparkSqlListener.prototype.enterHiveReplaceColumns = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#hiveReplaceColumns. +SparkSqlListener.prototype.exitHiveReplaceColumns = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setTableSerDe. +SparkSqlListener.prototype.enterSetTableSerDe = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setTableSerDe. +SparkSqlListener.prototype.exitSetTableSerDe = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#addTablePartition. +SparkSqlListener.prototype.enterAddTablePartition = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#addTablePartition. +SparkSqlListener.prototype.exitAddTablePartition = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#renameTablePartition. +SparkSqlListener.prototype.enterRenameTablePartition = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#renameTablePartition. +SparkSqlListener.prototype.exitRenameTablePartition = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dropTablePartitions. +SparkSqlListener.prototype.enterDropTablePartitions = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dropTablePartitions. +SparkSqlListener.prototype.exitDropTablePartitions = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setTableLocation. +SparkSqlListener.prototype.enterSetTableLocation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setTableLocation. +SparkSqlListener.prototype.exitSetTableLocation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#recoverPartitions. +SparkSqlListener.prototype.enterRecoverPartitions = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#recoverPartitions. +SparkSqlListener.prototype.exitRecoverPartitions = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dropTable. +SparkSqlListener.prototype.enterDropTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dropTable. +SparkSqlListener.prototype.exitDropTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dropView. +SparkSqlListener.prototype.enterDropView = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dropView. +SparkSqlListener.prototype.exitDropView = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createView. +SparkSqlListener.prototype.enterCreateView = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createView. +SparkSqlListener.prototype.exitCreateView = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createTempViewUsing. +SparkSqlListener.prototype.enterCreateTempViewUsing = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createTempViewUsing. +SparkSqlListener.prototype.exitCreateTempViewUsing = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#alterViewQuery. +SparkSqlListener.prototype.enterAlterViewQuery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#alterViewQuery. +SparkSqlListener.prototype.exitAlterViewQuery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createFunction. +SparkSqlListener.prototype.enterCreateFunction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createFunction. +SparkSqlListener.prototype.exitCreateFunction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dropFunction. +SparkSqlListener.prototype.enterDropFunction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dropFunction. +SparkSqlListener.prototype.exitDropFunction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#explain. +SparkSqlListener.prototype.enterExplain = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#explain. +SparkSqlListener.prototype.exitExplain = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showTables. +SparkSqlListener.prototype.enterShowTables = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showTables. +SparkSqlListener.prototype.exitShowTables = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showTable. +SparkSqlListener.prototype.enterShowTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showTable. +SparkSqlListener.prototype.exitShowTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showTblProperties. +SparkSqlListener.prototype.enterShowTblProperties = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showTblProperties. +SparkSqlListener.prototype.exitShowTblProperties = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showColumns. +SparkSqlListener.prototype.enterShowColumns = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showColumns. +SparkSqlListener.prototype.exitShowColumns = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showViews. +SparkSqlListener.prototype.enterShowViews = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showViews. +SparkSqlListener.prototype.exitShowViews = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showPartitions. +SparkSqlListener.prototype.enterShowPartitions = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showPartitions. +SparkSqlListener.prototype.exitShowPartitions = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showFunctions. +SparkSqlListener.prototype.enterShowFunctions = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showFunctions. +SparkSqlListener.prototype.exitShowFunctions = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showCreateTable. +SparkSqlListener.prototype.enterShowCreateTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showCreateTable. +SparkSqlListener.prototype.exitShowCreateTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#showCurrentNamespace. +SparkSqlListener.prototype.enterShowCurrentNamespace = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#showCurrentNamespace. +SparkSqlListener.prototype.exitShowCurrentNamespace = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#describeFunction. +SparkSqlListener.prototype.enterDescribeFunction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#describeFunction. +SparkSqlListener.prototype.exitDescribeFunction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#describeNamespace. +SparkSqlListener.prototype.enterDescribeNamespace = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#describeNamespace. +SparkSqlListener.prototype.exitDescribeNamespace = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#describeRelation. +SparkSqlListener.prototype.enterDescribeRelation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#describeRelation. +SparkSqlListener.prototype.exitDescribeRelation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#describeQuery. +SparkSqlListener.prototype.enterDescribeQuery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#describeQuery. +SparkSqlListener.prototype.exitDescribeQuery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#commentNamespace. +SparkSqlListener.prototype.enterCommentNamespace = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#commentNamespace. +SparkSqlListener.prototype.exitCommentNamespace = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#commentTable. +SparkSqlListener.prototype.enterCommentTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#commentTable. +SparkSqlListener.prototype.exitCommentTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#refreshTable. +SparkSqlListener.prototype.enterRefreshTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#refreshTable. +SparkSqlListener.prototype.exitRefreshTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#refreshFunction. +SparkSqlListener.prototype.enterRefreshFunction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#refreshFunction. +SparkSqlListener.prototype.exitRefreshFunction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#refreshResource. +SparkSqlListener.prototype.enterRefreshResource = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#refreshResource. +SparkSqlListener.prototype.exitRefreshResource = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#cacheTable. +SparkSqlListener.prototype.enterCacheTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#cacheTable. +SparkSqlListener.prototype.exitCacheTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#uncacheTable. +SparkSqlListener.prototype.enterUncacheTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#uncacheTable. +SparkSqlListener.prototype.exitUncacheTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#clearCache. +SparkSqlListener.prototype.enterClearCache = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#clearCache. +SparkSqlListener.prototype.exitClearCache = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#loadData. +SparkSqlListener.prototype.enterLoadData = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#loadData. +SparkSqlListener.prototype.exitLoadData = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#truncateTable. +SparkSqlListener.prototype.enterTruncateTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#truncateTable. +SparkSqlListener.prototype.exitTruncateTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#repairTable. +SparkSqlListener.prototype.enterRepairTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#repairTable. +SparkSqlListener.prototype.exitRepairTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#manageResource. +SparkSqlListener.prototype.enterManageResource = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#manageResource. +SparkSqlListener.prototype.exitManageResource = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#failNativeCommand. +SparkSqlListener.prototype.enterFailNativeCommand = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#failNativeCommand. +SparkSqlListener.prototype.exitFailNativeCommand = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setTimeZone. +SparkSqlListener.prototype.enterSetTimeZone = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setTimeZone. +SparkSqlListener.prototype.exitSetTimeZone = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setQuotedConfiguration. +SparkSqlListener.prototype.enterSetQuotedConfiguration = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setQuotedConfiguration. +SparkSqlListener.prototype.exitSetQuotedConfiguration = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setConfiguration. +SparkSqlListener.prototype.enterSetConfiguration = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setConfiguration. +SparkSqlListener.prototype.exitSetConfiguration = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#resetQuotedConfiguration. +SparkSqlListener.prototype.enterResetQuotedConfiguration = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#resetQuotedConfiguration. +SparkSqlListener.prototype.exitResetQuotedConfiguration = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#resetConfiguration. +SparkSqlListener.prototype.enterResetConfiguration = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#resetConfiguration. +SparkSqlListener.prototype.exitResetConfiguration = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#configKey. +SparkSqlListener.prototype.enterConfigKey = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#configKey. +SparkSqlListener.prototype.exitConfigKey = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#unsupportedHiveNativeCommands. +SparkSqlListener.prototype.enterUnsupportedHiveNativeCommands = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#unsupportedHiveNativeCommands. +SparkSqlListener.prototype.exitUnsupportedHiveNativeCommands = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createTableHeader. +SparkSqlListener.prototype.enterCreateTableHeader = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createTableHeader. +SparkSqlListener.prototype.exitCreateTableHeader = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#replaceTableHeader. +SparkSqlListener.prototype.enterReplaceTableHeader = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#replaceTableHeader. +SparkSqlListener.prototype.exitReplaceTableHeader = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#bucketSpec. +SparkSqlListener.prototype.enterBucketSpec = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#bucketSpec. +SparkSqlListener.prototype.exitBucketSpec = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#skewSpec. +SparkSqlListener.prototype.enterSkewSpec = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#skewSpec. +SparkSqlListener.prototype.exitSkewSpec = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#locationSpec. +SparkSqlListener.prototype.enterLocationSpec = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#locationSpec. +SparkSqlListener.prototype.exitLocationSpec = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#commentSpec. +SparkSqlListener.prototype.enterCommentSpec = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#commentSpec. +SparkSqlListener.prototype.exitCommentSpec = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#query. +SparkSqlListener.prototype.enterQuery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#query. +SparkSqlListener.prototype.exitQuery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#insertOverwriteTable. +SparkSqlListener.prototype.enterInsertOverwriteTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#insertOverwriteTable. +SparkSqlListener.prototype.exitInsertOverwriteTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#insertIntoTable. +SparkSqlListener.prototype.enterInsertIntoTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#insertIntoTable. +SparkSqlListener.prototype.exitInsertIntoTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#insertOverwriteHiveDir. +SparkSqlListener.prototype.enterInsertOverwriteHiveDir = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#insertOverwriteHiveDir. +SparkSqlListener.prototype.exitInsertOverwriteHiveDir = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#insertOverwriteDir. +SparkSqlListener.prototype.enterInsertOverwriteDir = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#insertOverwriteDir. +SparkSqlListener.prototype.exitInsertOverwriteDir = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#partitionSpecLocation. +SparkSqlListener.prototype.enterPartitionSpecLocation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#partitionSpecLocation. +SparkSqlListener.prototype.exitPartitionSpecLocation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#partitionSpec. +SparkSqlListener.prototype.enterPartitionSpec = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#partitionSpec. +SparkSqlListener.prototype.exitPartitionSpec = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#partitionVal. +SparkSqlListener.prototype.enterPartitionVal = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#partitionVal. +SparkSqlListener.prototype.exitPartitionVal = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#namespace. +SparkSqlListener.prototype.enterNamespace = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#namespace. +SparkSqlListener.prototype.exitNamespace = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#describeFuncName. +SparkSqlListener.prototype.enterDescribeFuncName = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#describeFuncName. +SparkSqlListener.prototype.exitDescribeFuncName = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#describeColName. +SparkSqlListener.prototype.enterDescribeColName = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#describeColName. +SparkSqlListener.prototype.exitDescribeColName = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#ctes. +SparkSqlListener.prototype.enterCtes = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#ctes. +SparkSqlListener.prototype.exitCtes = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#namedQuery. +SparkSqlListener.prototype.enterNamedQuery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#namedQuery. +SparkSqlListener.prototype.exitNamedQuery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tableProvider. +SparkSqlListener.prototype.enterTableProvider = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tableProvider. +SparkSqlListener.prototype.exitTableProvider = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createTableClauses. +SparkSqlListener.prototype.enterCreateTableClauses = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createTableClauses. +SparkSqlListener.prototype.exitCreateTableClauses = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tablePropertyList. +SparkSqlListener.prototype.enterTablePropertyList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tablePropertyList. +SparkSqlListener.prototype.exitTablePropertyList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tableProperty. +SparkSqlListener.prototype.enterTableProperty = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tableProperty. +SparkSqlListener.prototype.exitTableProperty = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tablePropertyKey. +SparkSqlListener.prototype.enterTablePropertyKey = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tablePropertyKey. +SparkSqlListener.prototype.exitTablePropertyKey = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tablePropertyValue. +SparkSqlListener.prototype.enterTablePropertyValue = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tablePropertyValue. +SparkSqlListener.prototype.exitTablePropertyValue = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#constantList. +SparkSqlListener.prototype.enterConstantList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#constantList. +SparkSqlListener.prototype.exitConstantList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#nestedConstantList. +SparkSqlListener.prototype.enterNestedConstantList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#nestedConstantList. +SparkSqlListener.prototype.exitNestedConstantList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#createFileFormat. +SparkSqlListener.prototype.enterCreateFileFormat = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#createFileFormat. +SparkSqlListener.prototype.exitCreateFileFormat = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tableFileFormat. +SparkSqlListener.prototype.enterTableFileFormat = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tableFileFormat. +SparkSqlListener.prototype.exitTableFileFormat = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#genericFileFormat. +SparkSqlListener.prototype.enterGenericFileFormat = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#genericFileFormat. +SparkSqlListener.prototype.exitGenericFileFormat = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#storageHandler. +SparkSqlListener.prototype.enterStorageHandler = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#storageHandler. +SparkSqlListener.prototype.exitStorageHandler = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#resource. +SparkSqlListener.prototype.enterResource = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#resource. +SparkSqlListener.prototype.exitResource = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#singleInsertQuery. +SparkSqlListener.prototype.enterSingleInsertQuery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#singleInsertQuery. +SparkSqlListener.prototype.exitSingleInsertQuery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#multiInsertQuery. +SparkSqlListener.prototype.enterMultiInsertQuery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#multiInsertQuery. +SparkSqlListener.prototype.exitMultiInsertQuery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#deleteFromTable. +SparkSqlListener.prototype.enterDeleteFromTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#deleteFromTable. +SparkSqlListener.prototype.exitDeleteFromTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#updateTable. +SparkSqlListener.prototype.enterUpdateTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#updateTable. +SparkSqlListener.prototype.exitUpdateTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#mergeIntoTable. +SparkSqlListener.prototype.enterMergeIntoTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#mergeIntoTable. +SparkSqlListener.prototype.exitMergeIntoTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#queryOrganization. +SparkSqlListener.prototype.enterQueryOrganization = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#queryOrganization. +SparkSqlListener.prototype.exitQueryOrganization = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#multiInsertQueryBody. +SparkSqlListener.prototype.enterMultiInsertQueryBody = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#multiInsertQueryBody. +SparkSqlListener.prototype.exitMultiInsertQueryBody = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#queryTermDefault. +SparkSqlListener.prototype.enterQueryTermDefault = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#queryTermDefault. +SparkSqlListener.prototype.exitQueryTermDefault = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setOperation. +SparkSqlListener.prototype.enterSetOperation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setOperation. +SparkSqlListener.prototype.exitSetOperation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#queryPrimaryDefault. +SparkSqlListener.prototype.enterQueryPrimaryDefault = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#queryPrimaryDefault. +SparkSqlListener.prototype.exitQueryPrimaryDefault = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#fromStmt. +SparkSqlListener.prototype.enterFromStmt = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#fromStmt. +SparkSqlListener.prototype.exitFromStmt = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#table. +SparkSqlListener.prototype.enterTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#table. +SparkSqlListener.prototype.exitTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#inlineTableDefault1. +SparkSqlListener.prototype.enterInlineTableDefault1 = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#inlineTableDefault1. +SparkSqlListener.prototype.exitInlineTableDefault1 = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#subquery. +SparkSqlListener.prototype.enterSubquery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#subquery. +SparkSqlListener.prototype.exitSubquery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#sortItem. +SparkSqlListener.prototype.enterSortItem = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#sortItem. +SparkSqlListener.prototype.exitSortItem = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#fromStatement. +SparkSqlListener.prototype.enterFromStatement = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#fromStatement. +SparkSqlListener.prototype.exitFromStatement = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#fromStatementBody. +SparkSqlListener.prototype.enterFromStatementBody = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#fromStatementBody. +SparkSqlListener.prototype.exitFromStatementBody = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#transformQuerySpecification. +SparkSqlListener.prototype.enterTransformQuerySpecification = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#transformQuerySpecification. +SparkSqlListener.prototype.exitTransformQuerySpecification = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#regularQuerySpecification. +SparkSqlListener.prototype.enterRegularQuerySpecification = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#regularQuerySpecification. +SparkSqlListener.prototype.exitRegularQuerySpecification = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#transformClause. +SparkSqlListener.prototype.enterTransformClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#transformClause. +SparkSqlListener.prototype.exitTransformClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#selectClause. +SparkSqlListener.prototype.enterSelectClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#selectClause. +SparkSqlListener.prototype.exitSelectClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setClause. +SparkSqlListener.prototype.enterSetClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setClause. +SparkSqlListener.prototype.exitSetClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#matchedClause. +SparkSqlListener.prototype.enterMatchedClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#matchedClause. +SparkSqlListener.prototype.exitMatchedClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#notMatchedClause. +SparkSqlListener.prototype.enterNotMatchedClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#notMatchedClause. +SparkSqlListener.prototype.exitNotMatchedClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#matchedAction. +SparkSqlListener.prototype.enterMatchedAction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#matchedAction. +SparkSqlListener.prototype.exitMatchedAction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#notMatchedAction. +SparkSqlListener.prototype.enterNotMatchedAction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#notMatchedAction. +SparkSqlListener.prototype.exitNotMatchedAction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#assignmentList. +SparkSqlListener.prototype.enterAssignmentList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#assignmentList. +SparkSqlListener.prototype.exitAssignmentList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#assignment. +SparkSqlListener.prototype.enterAssignment = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#assignment. +SparkSqlListener.prototype.exitAssignment = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#whereClause. +SparkSqlListener.prototype.enterWhereClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#whereClause. +SparkSqlListener.prototype.exitWhereClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#havingClause. +SparkSqlListener.prototype.enterHavingClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#havingClause. +SparkSqlListener.prototype.exitHavingClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#hint. +SparkSqlListener.prototype.enterHint = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#hint. +SparkSqlListener.prototype.exitHint = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#hintStatement. +SparkSqlListener.prototype.enterHintStatement = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#hintStatement. +SparkSqlListener.prototype.exitHintStatement = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#fromClause. +SparkSqlListener.prototype.enterFromClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#fromClause. +SparkSqlListener.prototype.exitFromClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#aggregationClause. +SparkSqlListener.prototype.enterAggregationClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#aggregationClause. +SparkSqlListener.prototype.exitAggregationClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#groupingSet. +SparkSqlListener.prototype.enterGroupingSet = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#groupingSet. +SparkSqlListener.prototype.exitGroupingSet = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#pivotClause. +SparkSqlListener.prototype.enterPivotClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#pivotClause. +SparkSqlListener.prototype.exitPivotClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#pivotColumn. +SparkSqlListener.prototype.enterPivotColumn = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#pivotColumn. +SparkSqlListener.prototype.exitPivotColumn = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#pivotValue. +SparkSqlListener.prototype.enterPivotValue = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#pivotValue. +SparkSqlListener.prototype.exitPivotValue = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#lateralView. +SparkSqlListener.prototype.enterLateralView = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#lateralView. +SparkSqlListener.prototype.exitLateralView = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#setQuantifier. +SparkSqlListener.prototype.enterSetQuantifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#setQuantifier. +SparkSqlListener.prototype.exitSetQuantifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#relation. +SparkSqlListener.prototype.enterRelation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#relation. +SparkSqlListener.prototype.exitRelation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#joinRelation. +SparkSqlListener.prototype.enterJoinRelation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#joinRelation. +SparkSqlListener.prototype.exitJoinRelation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#joinType. +SparkSqlListener.prototype.enterJoinType = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#joinType. +SparkSqlListener.prototype.exitJoinType = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#joinCriteria. +SparkSqlListener.prototype.enterJoinCriteria = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#joinCriteria. +SparkSqlListener.prototype.exitJoinCriteria = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#sample. +SparkSqlListener.prototype.enterSample = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#sample. +SparkSqlListener.prototype.exitSample = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#sampleByPercentile. +SparkSqlListener.prototype.enterSampleByPercentile = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#sampleByPercentile. +SparkSqlListener.prototype.exitSampleByPercentile = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#sampleByRows. +SparkSqlListener.prototype.enterSampleByRows = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#sampleByRows. +SparkSqlListener.prototype.exitSampleByRows = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#sampleByBucket. +SparkSqlListener.prototype.enterSampleByBucket = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#sampleByBucket. +SparkSqlListener.prototype.exitSampleByBucket = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#sampleByBytes. +SparkSqlListener.prototype.enterSampleByBytes = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#sampleByBytes. +SparkSqlListener.prototype.exitSampleByBytes = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#identifierList. +SparkSqlListener.prototype.enterIdentifierList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#identifierList. +SparkSqlListener.prototype.exitIdentifierList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#identifierSeq. +SparkSqlListener.prototype.enterIdentifierSeq = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#identifierSeq. +SparkSqlListener.prototype.exitIdentifierSeq = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#orderedIdentifierList. +SparkSqlListener.prototype.enterOrderedIdentifierList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#orderedIdentifierList. +SparkSqlListener.prototype.exitOrderedIdentifierList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#orderedIdentifier. +SparkSqlListener.prototype.enterOrderedIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#orderedIdentifier. +SparkSqlListener.prototype.exitOrderedIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#identifierCommentList. +SparkSqlListener.prototype.enterIdentifierCommentList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#identifierCommentList. +SparkSqlListener.prototype.exitIdentifierCommentList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#identifierComment. +SparkSqlListener.prototype.enterIdentifierComment = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#identifierComment. +SparkSqlListener.prototype.exitIdentifierComment = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tableName. +SparkSqlListener.prototype.enterTableName = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tableName. +SparkSqlListener.prototype.exitTableName = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#aliasedQuery. +SparkSqlListener.prototype.enterAliasedQuery = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#aliasedQuery. +SparkSqlListener.prototype.exitAliasedQuery = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#aliasedRelation. +SparkSqlListener.prototype.enterAliasedRelation = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#aliasedRelation. +SparkSqlListener.prototype.exitAliasedRelation = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#inlineTableDefault2. +SparkSqlListener.prototype.enterInlineTableDefault2 = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#inlineTableDefault2. +SparkSqlListener.prototype.exitInlineTableDefault2 = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tableValuedFunction. +SparkSqlListener.prototype.enterTableValuedFunction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tableValuedFunction. +SparkSqlListener.prototype.exitTableValuedFunction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#inlineTable. +SparkSqlListener.prototype.enterInlineTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#inlineTable. +SparkSqlListener.prototype.exitInlineTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#functionTable. +SparkSqlListener.prototype.enterFunctionTable = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#functionTable. +SparkSqlListener.prototype.exitFunctionTable = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tableAlias. +SparkSqlListener.prototype.enterTableAlias = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tableAlias. +SparkSqlListener.prototype.exitTableAlias = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#rowFormatSerde. +SparkSqlListener.prototype.enterRowFormatSerde = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#rowFormatSerde. +SparkSqlListener.prototype.exitRowFormatSerde = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#rowFormatDelimited. +SparkSqlListener.prototype.enterRowFormatDelimited = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#rowFormatDelimited. +SparkSqlListener.prototype.exitRowFormatDelimited = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#multipartIdentifierList. +SparkSqlListener.prototype.enterMultipartIdentifierList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#multipartIdentifierList. +SparkSqlListener.prototype.exitMultipartIdentifierList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#multipartIdentifier. +SparkSqlListener.prototype.enterMultipartIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#multipartIdentifier. +SparkSqlListener.prototype.exitMultipartIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tableIdentifier. +SparkSqlListener.prototype.enterTableIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tableIdentifier. +SparkSqlListener.prototype.exitTableIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#namedExpression. +SparkSqlListener.prototype.enterNamedExpression = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#namedExpression. +SparkSqlListener.prototype.exitNamedExpression = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#namedExpressionSeq. +SparkSqlListener.prototype.enterNamedExpressionSeq = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#namedExpressionSeq. +SparkSqlListener.prototype.exitNamedExpressionSeq = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#transformList. +SparkSqlListener.prototype.enterTransformList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#transformList. +SparkSqlListener.prototype.exitTransformList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#identityTransform. +SparkSqlListener.prototype.enterIdentityTransform = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#identityTransform. +SparkSqlListener.prototype.exitIdentityTransform = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#applyTransform. +SparkSqlListener.prototype.enterApplyTransform = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#applyTransform. +SparkSqlListener.prototype.exitApplyTransform = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#transformArgument. +SparkSqlListener.prototype.enterTransformArgument = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#transformArgument. +SparkSqlListener.prototype.exitTransformArgument = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#expression. +SparkSqlListener.prototype.enterExpression = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#expression. +SparkSqlListener.prototype.exitExpression = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#logicalNot. +SparkSqlListener.prototype.enterLogicalNot = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#logicalNot. +SparkSqlListener.prototype.exitLogicalNot = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#predicated. +SparkSqlListener.prototype.enterPredicated = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#predicated. +SparkSqlListener.prototype.exitPredicated = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#exists. +SparkSqlListener.prototype.enterExists = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#exists. +SparkSqlListener.prototype.exitExists = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#logicalBinary. +SparkSqlListener.prototype.enterLogicalBinary = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#logicalBinary. +SparkSqlListener.prototype.exitLogicalBinary = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#predicate. +SparkSqlListener.prototype.enterPredicate = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#predicate. +SparkSqlListener.prototype.exitPredicate = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#valueExpressionDefault. +SparkSqlListener.prototype.enterValueExpressionDefault = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#valueExpressionDefault. +SparkSqlListener.prototype.exitValueExpressionDefault = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#comparison. +SparkSqlListener.prototype.enterComparison = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#comparison. +SparkSqlListener.prototype.exitComparison = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#arithmeticBinary. +SparkSqlListener.prototype.enterArithmeticBinary = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#arithmeticBinary. +SparkSqlListener.prototype.exitArithmeticBinary = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#arithmeticUnary. +SparkSqlListener.prototype.enterArithmeticUnary = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#arithmeticUnary. +SparkSqlListener.prototype.exitArithmeticUnary = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#struct. +SparkSqlListener.prototype.enterStruct = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#struct. +SparkSqlListener.prototype.exitStruct = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#dereference. +SparkSqlListener.prototype.enterDereference = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#dereference. +SparkSqlListener.prototype.exitDereference = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#simpleCase. +SparkSqlListener.prototype.enterSimpleCase = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#simpleCase. +SparkSqlListener.prototype.exitSimpleCase = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#columnReference. +SparkSqlListener.prototype.enterColumnReference = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#columnReference. +SparkSqlListener.prototype.exitColumnReference = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#rowConstructor. +SparkSqlListener.prototype.enterRowConstructor = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#rowConstructor. +SparkSqlListener.prototype.exitRowConstructor = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#last. +SparkSqlListener.prototype.enterLast = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#last. +SparkSqlListener.prototype.exitLast = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#star. +SparkSqlListener.prototype.enterStar = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#star. +SparkSqlListener.prototype.exitStar = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#overlay. +SparkSqlListener.prototype.enterOverlay = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#overlay. +SparkSqlListener.prototype.exitOverlay = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#subscript. +SparkSqlListener.prototype.enterSubscript = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#subscript. +SparkSqlListener.prototype.exitSubscript = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#subqueryExpression. +SparkSqlListener.prototype.enterSubqueryExpression = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#subqueryExpression. +SparkSqlListener.prototype.exitSubqueryExpression = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#substring. +SparkSqlListener.prototype.enterSubstring = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#substring. +SparkSqlListener.prototype.exitSubstring = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#currentDatetime. +SparkSqlListener.prototype.enterCurrentDatetime = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#currentDatetime. +SparkSqlListener.prototype.exitCurrentDatetime = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#cast. +SparkSqlListener.prototype.enterCast = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#cast. +SparkSqlListener.prototype.exitCast = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#constantDefault. +SparkSqlListener.prototype.enterConstantDefault = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#constantDefault. +SparkSqlListener.prototype.exitConstantDefault = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#lambda. +SparkSqlListener.prototype.enterLambda = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#lambda. +SparkSqlListener.prototype.exitLambda = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#parenthesizedExpression. +SparkSqlListener.prototype.enterParenthesizedExpression = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#parenthesizedExpression. +SparkSqlListener.prototype.exitParenthesizedExpression = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#extract. +SparkSqlListener.prototype.enterExtract = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#extract. +SparkSqlListener.prototype.exitExtract = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#trim. +SparkSqlListener.prototype.enterTrim = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#trim. +SparkSqlListener.prototype.exitTrim = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#functionCall. +SparkSqlListener.prototype.enterFunctionCall = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#functionCall. +SparkSqlListener.prototype.exitFunctionCall = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#searchedCase. +SparkSqlListener.prototype.enterSearchedCase = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#searchedCase. +SparkSqlListener.prototype.exitSearchedCase = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#position. +SparkSqlListener.prototype.enterPosition = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#position. +SparkSqlListener.prototype.exitPosition = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#first. +SparkSqlListener.prototype.enterFirst = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#first. +SparkSqlListener.prototype.exitFirst = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#nullLiteral. +SparkSqlListener.prototype.enterNullLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#nullLiteral. +SparkSqlListener.prototype.exitNullLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#intervalLiteral. +SparkSqlListener.prototype.enterIntervalLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#intervalLiteral. +SparkSqlListener.prototype.exitIntervalLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#typeConstructor. +SparkSqlListener.prototype.enterTypeConstructor = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#typeConstructor. +SparkSqlListener.prototype.exitTypeConstructor = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#numericLiteral. +SparkSqlListener.prototype.enterNumericLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#numericLiteral. +SparkSqlListener.prototype.exitNumericLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#booleanLiteral. +SparkSqlListener.prototype.enterBooleanLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#booleanLiteral. +SparkSqlListener.prototype.exitBooleanLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#stringLiteral. +SparkSqlListener.prototype.enterStringLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#stringLiteral. +SparkSqlListener.prototype.exitStringLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#comparisonOperator. +SparkSqlListener.prototype.enterComparisonOperator = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#comparisonOperator. +SparkSqlListener.prototype.exitComparisonOperator = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#arithmeticOperator. +SparkSqlListener.prototype.enterArithmeticOperator = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#arithmeticOperator. +SparkSqlListener.prototype.exitArithmeticOperator = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#predicateOperator. +SparkSqlListener.prototype.enterPredicateOperator = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#predicateOperator. +SparkSqlListener.prototype.exitPredicateOperator = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#booleanValue. +SparkSqlListener.prototype.enterBooleanValue = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#booleanValue. +SparkSqlListener.prototype.exitBooleanValue = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#interval. +SparkSqlListener.prototype.enterInterval = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#interval. +SparkSqlListener.prototype.exitInterval = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#errorCapturingMultiUnitsInterval. +SparkSqlListener.prototype.enterErrorCapturingMultiUnitsInterval = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#errorCapturingMultiUnitsInterval. +SparkSqlListener.prototype.exitErrorCapturingMultiUnitsInterval = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#multiUnitsInterval. +SparkSqlListener.prototype.enterMultiUnitsInterval = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#multiUnitsInterval. +SparkSqlListener.prototype.exitMultiUnitsInterval = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#errorCapturingUnitToUnitInterval. +SparkSqlListener.prototype.enterErrorCapturingUnitToUnitInterval = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#errorCapturingUnitToUnitInterval. +SparkSqlListener.prototype.exitErrorCapturingUnitToUnitInterval = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#unitToUnitInterval. +SparkSqlListener.prototype.enterUnitToUnitInterval = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#unitToUnitInterval. +SparkSqlListener.prototype.exitUnitToUnitInterval = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#intervalValue. +SparkSqlListener.prototype.enterIntervalValue = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#intervalValue. +SparkSqlListener.prototype.exitIntervalValue = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#colPosition. +SparkSqlListener.prototype.enterColPosition = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#colPosition. +SparkSqlListener.prototype.exitColPosition = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#complexDataType. +SparkSqlListener.prototype.enterComplexDataType = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#complexDataType. +SparkSqlListener.prototype.exitComplexDataType = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#primitiveDataType. +SparkSqlListener.prototype.enterPrimitiveDataType = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#primitiveDataType. +SparkSqlListener.prototype.exitPrimitiveDataType = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#qualifiedColTypeWithPositionList. +SparkSqlListener.prototype.enterQualifiedColTypeWithPositionList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#qualifiedColTypeWithPositionList. +SparkSqlListener.prototype.exitQualifiedColTypeWithPositionList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#qualifiedColTypeWithPosition. +SparkSqlListener.prototype.enterQualifiedColTypeWithPosition = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#qualifiedColTypeWithPosition. +SparkSqlListener.prototype.exitQualifiedColTypeWithPosition = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#colTypeList. +SparkSqlListener.prototype.enterColTypeList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#colTypeList. +SparkSqlListener.prototype.exitColTypeList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#colType. +SparkSqlListener.prototype.enterColType = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#colType. +SparkSqlListener.prototype.exitColType = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#complexColTypeList. +SparkSqlListener.prototype.enterComplexColTypeList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#complexColTypeList. +SparkSqlListener.prototype.exitComplexColTypeList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#complexColType. +SparkSqlListener.prototype.enterComplexColType = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#complexColType. +SparkSqlListener.prototype.exitComplexColType = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#whenClause. +SparkSqlListener.prototype.enterWhenClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#whenClause. +SparkSqlListener.prototype.exitWhenClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#windowClause. +SparkSqlListener.prototype.enterWindowClause = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#windowClause. +SparkSqlListener.prototype.exitWindowClause = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#namedWindow. +SparkSqlListener.prototype.enterNamedWindow = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#namedWindow. +SparkSqlListener.prototype.exitNamedWindow = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#windowRef. +SparkSqlListener.prototype.enterWindowRef = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#windowRef. +SparkSqlListener.prototype.exitWindowRef = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#windowDef. +SparkSqlListener.prototype.enterWindowDef = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#windowDef. +SparkSqlListener.prototype.exitWindowDef = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#windowFrame. +SparkSqlListener.prototype.enterWindowFrame = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#windowFrame. +SparkSqlListener.prototype.exitWindowFrame = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#frameBound. +SparkSqlListener.prototype.enterFrameBound = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#frameBound. +SparkSqlListener.prototype.exitFrameBound = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#qualifiedNameList. +SparkSqlListener.prototype.enterQualifiedNameList = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#qualifiedNameList. +SparkSqlListener.prototype.exitQualifiedNameList = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#functionName. +SparkSqlListener.prototype.enterFunctionName = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#functionName. +SparkSqlListener.prototype.exitFunctionName = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#qualifiedName. +SparkSqlListener.prototype.enterQualifiedName = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#qualifiedName. +SparkSqlListener.prototype.exitQualifiedName = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#errorCapturingIdentifier. +SparkSqlListener.prototype.enterErrorCapturingIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#errorCapturingIdentifier. +SparkSqlListener.prototype.exitErrorCapturingIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#errorIdent. +SparkSqlListener.prototype.enterErrorIdent = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#errorIdent. +SparkSqlListener.prototype.exitErrorIdent = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#realIdent. +SparkSqlListener.prototype.enterRealIdent = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#realIdent. +SparkSqlListener.prototype.exitRealIdent = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#identifier. +SparkSqlListener.prototype.enterIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#identifier. +SparkSqlListener.prototype.exitIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#unquotedIdentifier. +SparkSqlListener.prototype.enterUnquotedIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#unquotedIdentifier. +SparkSqlListener.prototype.exitUnquotedIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#quotedIdentifierAlternative. +SparkSqlListener.prototype.enterQuotedIdentifierAlternative = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#quotedIdentifierAlternative. +SparkSqlListener.prototype.exitQuotedIdentifierAlternative = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#quotedIdentifier. +SparkSqlListener.prototype.enterQuotedIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#quotedIdentifier. +SparkSqlListener.prototype.exitQuotedIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#exponentLiteral. +SparkSqlListener.prototype.enterExponentLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#exponentLiteral. +SparkSqlListener.prototype.exitExponentLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#decimalLiteral. +SparkSqlListener.prototype.enterDecimalLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#decimalLiteral. +SparkSqlListener.prototype.exitDecimalLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#legacyDecimalLiteral. +SparkSqlListener.prototype.enterLegacyDecimalLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#legacyDecimalLiteral. +SparkSqlListener.prototype.exitLegacyDecimalLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#integerLiteral. +SparkSqlListener.prototype.enterIntegerLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#integerLiteral. +SparkSqlListener.prototype.exitIntegerLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#bigIntLiteral. +SparkSqlListener.prototype.enterBigIntLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#bigIntLiteral. +SparkSqlListener.prototype.exitBigIntLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#smallIntLiteral. +SparkSqlListener.prototype.enterSmallIntLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#smallIntLiteral. +SparkSqlListener.prototype.exitSmallIntLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#tinyIntLiteral. +SparkSqlListener.prototype.enterTinyIntLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#tinyIntLiteral. +SparkSqlListener.prototype.exitTinyIntLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#doubleLiteral. +SparkSqlListener.prototype.enterDoubleLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#doubleLiteral. +SparkSqlListener.prototype.exitDoubleLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#floatLiteral. +SparkSqlListener.prototype.enterFloatLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#floatLiteral. +SparkSqlListener.prototype.exitFloatLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#bigDecimalLiteral. +SparkSqlListener.prototype.enterBigDecimalLiteral = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#bigDecimalLiteral. +SparkSqlListener.prototype.exitBigDecimalLiteral = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#alterColumnAction. +SparkSqlListener.prototype.enterAlterColumnAction = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#alterColumnAction. +SparkSqlListener.prototype.exitAlterColumnAction = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#ansiNonReserved. +SparkSqlListener.prototype.enterAnsiNonReserved = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#ansiNonReserved. +SparkSqlListener.prototype.exitAnsiNonReserved = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#strictNonReserved. +SparkSqlListener.prototype.enterStrictNonReserved = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#strictNonReserved. +SparkSqlListener.prototype.exitStrictNonReserved = function(ctx) { +}; + + +// Enter a parse tree produced by SparkSqlParser#nonReserved. +SparkSqlListener.prototype.enterNonReserved = function(ctx) { +}; + +// Exit a parse tree produced by SparkSqlParser#nonReserved. +SparkSqlListener.prototype.exitNonReserved = function(ctx) { +}; + + + +exports.SparkSqlListener = SparkSqlListener; \ No newline at end of file diff --git a/src/lib/spark/SqlBaseParser.js b/src/lib/spark/SparkSqlParser.js similarity index 77% rename from src/lib/spark/SqlBaseParser.js rename to src/lib/spark/SparkSqlParser.js index 7830678..8083cdb 100644 --- a/src/lib/spark/SqlBaseParser.js +++ b/src/lib/spark/SparkSqlParser.js @@ -1,10 +1,10 @@ -// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SqlBase.g4 by ANTLR 4.8 +// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SparkSql.g4 by ANTLR 4.8 // jshint ignore: start var antlr4 = require('antlr4/index'); -var SqlBaseListener = require('./SqlBaseListener').SqlBaseListener; -var SqlBaseVisitor = require('./SqlBaseVisitor').SqlBaseVisitor; +var SparkSqlListener = require('./SparkSqlListener').SparkSqlListener; +var SparkSqlVisitor = require('./SparkSqlVisitor').SparkSqlVisitor; -var grammarFileName = "SqlBase.g4"; +var grammarFileName = "SparkSql.g4"; var serializedATN = ["\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964", @@ -2331,7 +2331,7 @@ var ruleNames = [ "program", "singleStatement", "singleExpression", "singleTabl "number", "alterColumnAction", "ansiNonReserved", "strictNonReserved", "nonReserved" ]; -function SqlBaseParser (input) { +function SparkSqlParser (input) { antlr4.Parser.call(this, input); this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache); this.ruleNames = ruleNames; @@ -2361,447 +2361,447 @@ function SqlBaseParser (input) { return this; } -SqlBaseParser.prototype = Object.create(antlr4.Parser.prototype); -SqlBaseParser.prototype.constructor = SqlBaseParser; +SparkSqlParser.prototype = Object.create(antlr4.Parser.prototype); +SparkSqlParser.prototype.constructor = SparkSqlParser; -Object.defineProperty(SqlBaseParser.prototype, "atn", { +Object.defineProperty(SparkSqlParser.prototype, "atn", { get : function() { return atn; } }); -SqlBaseParser.EOF = antlr4.Token.EOF; -SqlBaseParser.T__0 = 1; -SqlBaseParser.T__1 = 2; -SqlBaseParser.T__2 = 3; -SqlBaseParser.T__3 = 4; -SqlBaseParser.T__4 = 5; -SqlBaseParser.T__5 = 6; -SqlBaseParser.T__6 = 7; -SqlBaseParser.T__7 = 8; -SqlBaseParser.T__8 = 9; -SqlBaseParser.T__9 = 10; -SqlBaseParser.T__10 = 11; -SqlBaseParser.ADD = 12; -SqlBaseParser.AFTER = 13; -SqlBaseParser.ALL = 14; -SqlBaseParser.ALTER = 15; -SqlBaseParser.ANALYZE = 16; -SqlBaseParser.AND = 17; -SqlBaseParser.ANTI = 18; -SqlBaseParser.ANY = 19; -SqlBaseParser.ARCHIVE = 20; -SqlBaseParser.ARRAY = 21; -SqlBaseParser.AS = 22; -SqlBaseParser.ASC = 23; -SqlBaseParser.AT = 24; -SqlBaseParser.AUTHORIZATION = 25; -SqlBaseParser.BETWEEN = 26; -SqlBaseParser.BOTH = 27; -SqlBaseParser.BUCKET = 28; -SqlBaseParser.BUCKETS = 29; -SqlBaseParser.BY = 30; -SqlBaseParser.CACHE = 31; -SqlBaseParser.CASCADE = 32; -SqlBaseParser.CASE = 33; -SqlBaseParser.CAST = 34; -SqlBaseParser.CHANGE = 35; -SqlBaseParser.CHECK = 36; -SqlBaseParser.CLEAR = 37; -SqlBaseParser.CLUSTER = 38; -SqlBaseParser.CLUSTERED = 39; -SqlBaseParser.CODEGEN = 40; -SqlBaseParser.COLLATE = 41; -SqlBaseParser.COLLECTION = 42; -SqlBaseParser.COLUMN = 43; -SqlBaseParser.COLUMNS = 44; -SqlBaseParser.COMMENT = 45; -SqlBaseParser.COMMIT = 46; -SqlBaseParser.COMPACT = 47; -SqlBaseParser.COMPACTIONS = 48; -SqlBaseParser.COMPUTE = 49; -SqlBaseParser.CONCATENATE = 50; -SqlBaseParser.CONSTRAINT = 51; -SqlBaseParser.COST = 52; -SqlBaseParser.CREATE = 53; -SqlBaseParser.CROSS = 54; -SqlBaseParser.CUBE = 55; -SqlBaseParser.CURRENT = 56; -SqlBaseParser.CURRENT_DATE = 57; -SqlBaseParser.CURRENT_TIME = 58; -SqlBaseParser.CURRENT_TIMESTAMP = 59; -SqlBaseParser.CURRENT_USER = 60; -SqlBaseParser.DATA = 61; -SqlBaseParser.DATABASE = 62; -SqlBaseParser.DATABASES = 63; -SqlBaseParser.DBPROPERTIES = 64; -SqlBaseParser.DEFINED = 65; -SqlBaseParser.DELETE = 66; -SqlBaseParser.DELIMITED = 67; -SqlBaseParser.DESC = 68; -SqlBaseParser.DESCRIBE = 69; -SqlBaseParser.DFS = 70; -SqlBaseParser.DIRECTORIES = 71; -SqlBaseParser.DIRECTORY = 72; -SqlBaseParser.DISTINCT = 73; -SqlBaseParser.DISTRIBUTE = 74; -SqlBaseParser.DIV = 75; -SqlBaseParser.DROP = 76; -SqlBaseParser.ELSE = 77; -SqlBaseParser.END = 78; -SqlBaseParser.ESCAPE = 79; -SqlBaseParser.ESCAPED = 80; -SqlBaseParser.EXCEPT = 81; -SqlBaseParser.EXCHANGE = 82; -SqlBaseParser.EXISTS = 83; -SqlBaseParser.EXPLAIN = 84; -SqlBaseParser.EXPORT = 85; -SqlBaseParser.EXTENDED = 86; -SqlBaseParser.EXTERNAL = 87; -SqlBaseParser.EXTRACT = 88; -SqlBaseParser.FALSE = 89; -SqlBaseParser.FETCH = 90; -SqlBaseParser.FIELDS = 91; -SqlBaseParser.FILTER = 92; -SqlBaseParser.FILEFORMAT = 93; -SqlBaseParser.FIRST = 94; -SqlBaseParser.FOLLOWING = 95; -SqlBaseParser.FOR = 96; -SqlBaseParser.FOREIGN = 97; -SqlBaseParser.FORMAT = 98; -SqlBaseParser.FORMATTED = 99; -SqlBaseParser.FROM = 100; -SqlBaseParser.FULL = 101; -SqlBaseParser.FUNCTION = 102; -SqlBaseParser.FUNCTIONS = 103; -SqlBaseParser.GLOBAL = 104; -SqlBaseParser.GRANT = 105; -SqlBaseParser.GROUP = 106; -SqlBaseParser.GROUPING = 107; -SqlBaseParser.HAVING = 108; -SqlBaseParser.IF = 109; -SqlBaseParser.IGNORE = 110; -SqlBaseParser.IMPORT = 111; -SqlBaseParser.IN = 112; -SqlBaseParser.INDEX = 113; -SqlBaseParser.INDEXES = 114; -SqlBaseParser.INNER = 115; -SqlBaseParser.INPATH = 116; -SqlBaseParser.INPUTFORMAT = 117; -SqlBaseParser.INSERT = 118; -SqlBaseParser.INTERSECT = 119; -SqlBaseParser.INTERVAL = 120; -SqlBaseParser.INTO = 121; -SqlBaseParser.IS = 122; -SqlBaseParser.ITEMS = 123; -SqlBaseParser.JOIN = 124; -SqlBaseParser.KEYS = 125; -SqlBaseParser.LAST = 126; -SqlBaseParser.LATERAL = 127; -SqlBaseParser.LAZY = 128; -SqlBaseParser.LEADING = 129; -SqlBaseParser.LEFT = 130; -SqlBaseParser.LIKE = 131; -SqlBaseParser.LIMIT = 132; -SqlBaseParser.LINES = 133; -SqlBaseParser.LIST = 134; -SqlBaseParser.LOAD = 135; -SqlBaseParser.LOCAL = 136; -SqlBaseParser.LOCATION = 137; -SqlBaseParser.LOCK = 138; -SqlBaseParser.LOCKS = 139; -SqlBaseParser.LOGICAL = 140; -SqlBaseParser.MACRO = 141; -SqlBaseParser.MAP = 142; -SqlBaseParser.MATCHED = 143; -SqlBaseParser.MERGE = 144; -SqlBaseParser.MSCK = 145; -SqlBaseParser.NAMESPACE = 146; -SqlBaseParser.NAMESPACES = 147; -SqlBaseParser.NATURAL = 148; -SqlBaseParser.NO = 149; -SqlBaseParser.NOT = 150; -SqlBaseParser.NULL = 151; -SqlBaseParser.NULLS = 152; -SqlBaseParser.OF = 153; -SqlBaseParser.ON = 154; -SqlBaseParser.ONLY = 155; -SqlBaseParser.OPTION = 156; -SqlBaseParser.OPTIONS = 157; -SqlBaseParser.OR = 158; -SqlBaseParser.ORDER = 159; -SqlBaseParser.OUT = 160; -SqlBaseParser.OUTER = 161; -SqlBaseParser.OUTPUTFORMAT = 162; -SqlBaseParser.OVER = 163; -SqlBaseParser.OVERLAPS = 164; -SqlBaseParser.OVERLAY = 165; -SqlBaseParser.OVERWRITE = 166; -SqlBaseParser.PARTITION = 167; -SqlBaseParser.PARTITIONED = 168; -SqlBaseParser.PARTITIONS = 169; -SqlBaseParser.PERCENTLIT = 170; -SqlBaseParser.PIVOT = 171; -SqlBaseParser.PLACING = 172; -SqlBaseParser.POSITION = 173; -SqlBaseParser.PRECEDING = 174; -SqlBaseParser.PRIMARY = 175; -SqlBaseParser.PRINCIPALS = 176; -SqlBaseParser.PROPERTIES = 177; -SqlBaseParser.PURGE = 178; -SqlBaseParser.QUERY = 179; -SqlBaseParser.RANGE = 180; -SqlBaseParser.RECORDREADER = 181; -SqlBaseParser.RECORDWRITER = 182; -SqlBaseParser.RECOVER = 183; -SqlBaseParser.REDUCE = 184; -SqlBaseParser.REFERENCES = 185; -SqlBaseParser.REFRESH = 186; -SqlBaseParser.RENAME = 187; -SqlBaseParser.REPAIR = 188; -SqlBaseParser.REPLACE = 189; -SqlBaseParser.RESET = 190; -SqlBaseParser.RESTRICT = 191; -SqlBaseParser.REVOKE = 192; -SqlBaseParser.RIGHT = 193; -SqlBaseParser.RLIKE = 194; -SqlBaseParser.ROLE = 195; -SqlBaseParser.ROLES = 196; -SqlBaseParser.ROLLBACK = 197; -SqlBaseParser.ROLLUP = 198; -SqlBaseParser.ROW = 199; -SqlBaseParser.ROWS = 200; -SqlBaseParser.SCHEMA = 201; -SqlBaseParser.SELECT = 202; -SqlBaseParser.SEMI = 203; -SqlBaseParser.SEPARATED = 204; -SqlBaseParser.SERDE = 205; -SqlBaseParser.SERDEPROPERTIES = 206; -SqlBaseParser.SESSION_USER = 207; -SqlBaseParser.SET = 208; -SqlBaseParser.SETMINUS = 209; -SqlBaseParser.SETS = 210; -SqlBaseParser.SHOW = 211; -SqlBaseParser.SKEWED = 212; -SqlBaseParser.SOME = 213; -SqlBaseParser.SORT = 214; -SqlBaseParser.SORTED = 215; -SqlBaseParser.START = 216; -SqlBaseParser.STATISTICS = 217; -SqlBaseParser.STORED = 218; -SqlBaseParser.STRATIFY = 219; -SqlBaseParser.STRUCT = 220; -SqlBaseParser.SUBSTR = 221; -SqlBaseParser.SUBSTRING = 222; -SqlBaseParser.TABLE = 223; -SqlBaseParser.TABLES = 224; -SqlBaseParser.TABLESAMPLE = 225; -SqlBaseParser.TBLPROPERTIES = 226; -SqlBaseParser.TEMPORARY = 227; -SqlBaseParser.TERMINATED = 228; -SqlBaseParser.THEN = 229; -SqlBaseParser.TIME = 230; -SqlBaseParser.TO = 231; -SqlBaseParser.TOUCH = 232; -SqlBaseParser.TRAILING = 233; -SqlBaseParser.TRANSACTION = 234; -SqlBaseParser.TRANSACTIONS = 235; -SqlBaseParser.TRANSFORM = 236; -SqlBaseParser.TRIM = 237; -SqlBaseParser.TRUE = 238; -SqlBaseParser.TRUNCATE = 239; -SqlBaseParser.TYPE = 240; -SqlBaseParser.UNARCHIVE = 241; -SqlBaseParser.UNBOUNDED = 242; -SqlBaseParser.UNCACHE = 243; -SqlBaseParser.UNION = 244; -SqlBaseParser.UNIQUE = 245; -SqlBaseParser.UNKNOWN = 246; -SqlBaseParser.UNLOCK = 247; -SqlBaseParser.UNSET = 248; -SqlBaseParser.UPDATE = 249; -SqlBaseParser.USE = 250; -SqlBaseParser.USER = 251; -SqlBaseParser.USING = 252; -SqlBaseParser.VALUES = 253; -SqlBaseParser.VIEW = 254; -SqlBaseParser.VIEWS = 255; -SqlBaseParser.WHEN = 256; -SqlBaseParser.WHERE = 257; -SqlBaseParser.WINDOW = 258; -SqlBaseParser.WITH = 259; -SqlBaseParser.ZONE = 260; -SqlBaseParser.EQ = 261; -SqlBaseParser.NSEQ = 262; -SqlBaseParser.NEQ = 263; -SqlBaseParser.NEQJ = 264; -SqlBaseParser.LT = 265; -SqlBaseParser.LTE = 266; -SqlBaseParser.GT = 267; -SqlBaseParser.GTE = 268; -SqlBaseParser.PLUS = 269; -SqlBaseParser.MINUS = 270; -SqlBaseParser.ASTERISK = 271; -SqlBaseParser.SLASH = 272; -SqlBaseParser.PERCENT = 273; -SqlBaseParser.TILDE = 274; -SqlBaseParser.AMPERSAND = 275; -SqlBaseParser.PIPE = 276; -SqlBaseParser.CONCAT_PIPE = 277; -SqlBaseParser.HAT = 278; -SqlBaseParser.STRING = 279; -SqlBaseParser.BIGINT_LITERAL = 280; -SqlBaseParser.SMALLINT_LITERAL = 281; -SqlBaseParser.TINYINT_LITERAL = 282; -SqlBaseParser.INTEGER_VALUE = 283; -SqlBaseParser.EXPONENT_VALUE = 284; -SqlBaseParser.DECIMAL_VALUE = 285; -SqlBaseParser.FLOAT_LITERAL = 286; -SqlBaseParser.DOUBLE_LITERAL = 287; -SqlBaseParser.BIGDECIMAL_LITERAL = 288; -SqlBaseParser.IDENTIFIER = 289; -SqlBaseParser.BACKQUOTED_IDENTIFIER = 290; -SqlBaseParser.SIMPLE_COMMENT = 291; -SqlBaseParser.BRACKETED_COMMENT = 292; -SqlBaseParser.WS = 293; -SqlBaseParser.UNRECOGNIZED = 294; +SparkSqlParser.EOF = antlr4.Token.EOF; +SparkSqlParser.T__0 = 1; +SparkSqlParser.T__1 = 2; +SparkSqlParser.T__2 = 3; +SparkSqlParser.T__3 = 4; +SparkSqlParser.T__4 = 5; +SparkSqlParser.T__5 = 6; +SparkSqlParser.T__6 = 7; +SparkSqlParser.T__7 = 8; +SparkSqlParser.T__8 = 9; +SparkSqlParser.T__9 = 10; +SparkSqlParser.T__10 = 11; +SparkSqlParser.ADD = 12; +SparkSqlParser.AFTER = 13; +SparkSqlParser.ALL = 14; +SparkSqlParser.ALTER = 15; +SparkSqlParser.ANALYZE = 16; +SparkSqlParser.AND = 17; +SparkSqlParser.ANTI = 18; +SparkSqlParser.ANY = 19; +SparkSqlParser.ARCHIVE = 20; +SparkSqlParser.ARRAY = 21; +SparkSqlParser.AS = 22; +SparkSqlParser.ASC = 23; +SparkSqlParser.AT = 24; +SparkSqlParser.AUTHORIZATION = 25; +SparkSqlParser.BETWEEN = 26; +SparkSqlParser.BOTH = 27; +SparkSqlParser.BUCKET = 28; +SparkSqlParser.BUCKETS = 29; +SparkSqlParser.BY = 30; +SparkSqlParser.CACHE = 31; +SparkSqlParser.CASCADE = 32; +SparkSqlParser.CASE = 33; +SparkSqlParser.CAST = 34; +SparkSqlParser.CHANGE = 35; +SparkSqlParser.CHECK = 36; +SparkSqlParser.CLEAR = 37; +SparkSqlParser.CLUSTER = 38; +SparkSqlParser.CLUSTERED = 39; +SparkSqlParser.CODEGEN = 40; +SparkSqlParser.COLLATE = 41; +SparkSqlParser.COLLECTION = 42; +SparkSqlParser.COLUMN = 43; +SparkSqlParser.COLUMNS = 44; +SparkSqlParser.COMMENT = 45; +SparkSqlParser.COMMIT = 46; +SparkSqlParser.COMPACT = 47; +SparkSqlParser.COMPACTIONS = 48; +SparkSqlParser.COMPUTE = 49; +SparkSqlParser.CONCATENATE = 50; +SparkSqlParser.CONSTRAINT = 51; +SparkSqlParser.COST = 52; +SparkSqlParser.CREATE = 53; +SparkSqlParser.CROSS = 54; +SparkSqlParser.CUBE = 55; +SparkSqlParser.CURRENT = 56; +SparkSqlParser.CURRENT_DATE = 57; +SparkSqlParser.CURRENT_TIME = 58; +SparkSqlParser.CURRENT_TIMESTAMP = 59; +SparkSqlParser.CURRENT_USER = 60; +SparkSqlParser.DATA = 61; +SparkSqlParser.DATABASE = 62; +SparkSqlParser.DATABASES = 63; +SparkSqlParser.DBPROPERTIES = 64; +SparkSqlParser.DEFINED = 65; +SparkSqlParser.DELETE = 66; +SparkSqlParser.DELIMITED = 67; +SparkSqlParser.DESC = 68; +SparkSqlParser.DESCRIBE = 69; +SparkSqlParser.DFS = 70; +SparkSqlParser.DIRECTORIES = 71; +SparkSqlParser.DIRECTORY = 72; +SparkSqlParser.DISTINCT = 73; +SparkSqlParser.DISTRIBUTE = 74; +SparkSqlParser.DIV = 75; +SparkSqlParser.DROP = 76; +SparkSqlParser.ELSE = 77; +SparkSqlParser.END = 78; +SparkSqlParser.ESCAPE = 79; +SparkSqlParser.ESCAPED = 80; +SparkSqlParser.EXCEPT = 81; +SparkSqlParser.EXCHANGE = 82; +SparkSqlParser.EXISTS = 83; +SparkSqlParser.EXPLAIN = 84; +SparkSqlParser.EXPORT = 85; +SparkSqlParser.EXTENDED = 86; +SparkSqlParser.EXTERNAL = 87; +SparkSqlParser.EXTRACT = 88; +SparkSqlParser.FALSE = 89; +SparkSqlParser.FETCH = 90; +SparkSqlParser.FIELDS = 91; +SparkSqlParser.FILTER = 92; +SparkSqlParser.FILEFORMAT = 93; +SparkSqlParser.FIRST = 94; +SparkSqlParser.FOLLOWING = 95; +SparkSqlParser.FOR = 96; +SparkSqlParser.FOREIGN = 97; +SparkSqlParser.FORMAT = 98; +SparkSqlParser.FORMATTED = 99; +SparkSqlParser.FROM = 100; +SparkSqlParser.FULL = 101; +SparkSqlParser.FUNCTION = 102; +SparkSqlParser.FUNCTIONS = 103; +SparkSqlParser.GLOBAL = 104; +SparkSqlParser.GRANT = 105; +SparkSqlParser.GROUP = 106; +SparkSqlParser.GROUPING = 107; +SparkSqlParser.HAVING = 108; +SparkSqlParser.IF = 109; +SparkSqlParser.IGNORE = 110; +SparkSqlParser.IMPORT = 111; +SparkSqlParser.IN = 112; +SparkSqlParser.INDEX = 113; +SparkSqlParser.INDEXES = 114; +SparkSqlParser.INNER = 115; +SparkSqlParser.INPATH = 116; +SparkSqlParser.INPUTFORMAT = 117; +SparkSqlParser.INSERT = 118; +SparkSqlParser.INTERSECT = 119; +SparkSqlParser.INTERVAL = 120; +SparkSqlParser.INTO = 121; +SparkSqlParser.IS = 122; +SparkSqlParser.ITEMS = 123; +SparkSqlParser.JOIN = 124; +SparkSqlParser.KEYS = 125; +SparkSqlParser.LAST = 126; +SparkSqlParser.LATERAL = 127; +SparkSqlParser.LAZY = 128; +SparkSqlParser.LEADING = 129; +SparkSqlParser.LEFT = 130; +SparkSqlParser.LIKE = 131; +SparkSqlParser.LIMIT = 132; +SparkSqlParser.LINES = 133; +SparkSqlParser.LIST = 134; +SparkSqlParser.LOAD = 135; +SparkSqlParser.LOCAL = 136; +SparkSqlParser.LOCATION = 137; +SparkSqlParser.LOCK = 138; +SparkSqlParser.LOCKS = 139; +SparkSqlParser.LOGICAL = 140; +SparkSqlParser.MACRO = 141; +SparkSqlParser.MAP = 142; +SparkSqlParser.MATCHED = 143; +SparkSqlParser.MERGE = 144; +SparkSqlParser.MSCK = 145; +SparkSqlParser.NAMESPACE = 146; +SparkSqlParser.NAMESPACES = 147; +SparkSqlParser.NATURAL = 148; +SparkSqlParser.NO = 149; +SparkSqlParser.NOT = 150; +SparkSqlParser.NULL = 151; +SparkSqlParser.NULLS = 152; +SparkSqlParser.OF = 153; +SparkSqlParser.ON = 154; +SparkSqlParser.ONLY = 155; +SparkSqlParser.OPTION = 156; +SparkSqlParser.OPTIONS = 157; +SparkSqlParser.OR = 158; +SparkSqlParser.ORDER = 159; +SparkSqlParser.OUT = 160; +SparkSqlParser.OUTER = 161; +SparkSqlParser.OUTPUTFORMAT = 162; +SparkSqlParser.OVER = 163; +SparkSqlParser.OVERLAPS = 164; +SparkSqlParser.OVERLAY = 165; +SparkSqlParser.OVERWRITE = 166; +SparkSqlParser.PARTITION = 167; +SparkSqlParser.PARTITIONED = 168; +SparkSqlParser.PARTITIONS = 169; +SparkSqlParser.PERCENTLIT = 170; +SparkSqlParser.PIVOT = 171; +SparkSqlParser.PLACING = 172; +SparkSqlParser.POSITION = 173; +SparkSqlParser.PRECEDING = 174; +SparkSqlParser.PRIMARY = 175; +SparkSqlParser.PRINCIPALS = 176; +SparkSqlParser.PROPERTIES = 177; +SparkSqlParser.PURGE = 178; +SparkSqlParser.QUERY = 179; +SparkSqlParser.RANGE = 180; +SparkSqlParser.RECORDREADER = 181; +SparkSqlParser.RECORDWRITER = 182; +SparkSqlParser.RECOVER = 183; +SparkSqlParser.REDUCE = 184; +SparkSqlParser.REFERENCES = 185; +SparkSqlParser.REFRESH = 186; +SparkSqlParser.RENAME = 187; +SparkSqlParser.REPAIR = 188; +SparkSqlParser.REPLACE = 189; +SparkSqlParser.RESET = 190; +SparkSqlParser.RESTRICT = 191; +SparkSqlParser.REVOKE = 192; +SparkSqlParser.RIGHT = 193; +SparkSqlParser.RLIKE = 194; +SparkSqlParser.ROLE = 195; +SparkSqlParser.ROLES = 196; +SparkSqlParser.ROLLBACK = 197; +SparkSqlParser.ROLLUP = 198; +SparkSqlParser.ROW = 199; +SparkSqlParser.ROWS = 200; +SparkSqlParser.SCHEMA = 201; +SparkSqlParser.SELECT = 202; +SparkSqlParser.SEMI = 203; +SparkSqlParser.SEPARATED = 204; +SparkSqlParser.SERDE = 205; +SparkSqlParser.SERDEPROPERTIES = 206; +SparkSqlParser.SESSION_USER = 207; +SparkSqlParser.SET = 208; +SparkSqlParser.SETMINUS = 209; +SparkSqlParser.SETS = 210; +SparkSqlParser.SHOW = 211; +SparkSqlParser.SKEWED = 212; +SparkSqlParser.SOME = 213; +SparkSqlParser.SORT = 214; +SparkSqlParser.SORTED = 215; +SparkSqlParser.START = 216; +SparkSqlParser.STATISTICS = 217; +SparkSqlParser.STORED = 218; +SparkSqlParser.STRATIFY = 219; +SparkSqlParser.STRUCT = 220; +SparkSqlParser.SUBSTR = 221; +SparkSqlParser.SUBSTRING = 222; +SparkSqlParser.TABLE = 223; +SparkSqlParser.TABLES = 224; +SparkSqlParser.TABLESAMPLE = 225; +SparkSqlParser.TBLPROPERTIES = 226; +SparkSqlParser.TEMPORARY = 227; +SparkSqlParser.TERMINATED = 228; +SparkSqlParser.THEN = 229; +SparkSqlParser.TIME = 230; +SparkSqlParser.TO = 231; +SparkSqlParser.TOUCH = 232; +SparkSqlParser.TRAILING = 233; +SparkSqlParser.TRANSACTION = 234; +SparkSqlParser.TRANSACTIONS = 235; +SparkSqlParser.TRANSFORM = 236; +SparkSqlParser.TRIM = 237; +SparkSqlParser.TRUE = 238; +SparkSqlParser.TRUNCATE = 239; +SparkSqlParser.TYPE = 240; +SparkSqlParser.UNARCHIVE = 241; +SparkSqlParser.UNBOUNDED = 242; +SparkSqlParser.UNCACHE = 243; +SparkSqlParser.UNION = 244; +SparkSqlParser.UNIQUE = 245; +SparkSqlParser.UNKNOWN = 246; +SparkSqlParser.UNLOCK = 247; +SparkSqlParser.UNSET = 248; +SparkSqlParser.UPDATE = 249; +SparkSqlParser.USE = 250; +SparkSqlParser.USER = 251; +SparkSqlParser.USING = 252; +SparkSqlParser.VALUES = 253; +SparkSqlParser.VIEW = 254; +SparkSqlParser.VIEWS = 255; +SparkSqlParser.WHEN = 256; +SparkSqlParser.WHERE = 257; +SparkSqlParser.WINDOW = 258; +SparkSqlParser.WITH = 259; +SparkSqlParser.ZONE = 260; +SparkSqlParser.EQ = 261; +SparkSqlParser.NSEQ = 262; +SparkSqlParser.NEQ = 263; +SparkSqlParser.NEQJ = 264; +SparkSqlParser.LT = 265; +SparkSqlParser.LTE = 266; +SparkSqlParser.GT = 267; +SparkSqlParser.GTE = 268; +SparkSqlParser.PLUS = 269; +SparkSqlParser.MINUS = 270; +SparkSqlParser.ASTERISK = 271; +SparkSqlParser.SLASH = 272; +SparkSqlParser.PERCENT = 273; +SparkSqlParser.TILDE = 274; +SparkSqlParser.AMPERSAND = 275; +SparkSqlParser.PIPE = 276; +SparkSqlParser.CONCAT_PIPE = 277; +SparkSqlParser.HAT = 278; +SparkSqlParser.STRING = 279; +SparkSqlParser.BIGINT_LITERAL = 280; +SparkSqlParser.SMALLINT_LITERAL = 281; +SparkSqlParser.TINYINT_LITERAL = 282; +SparkSqlParser.INTEGER_VALUE = 283; +SparkSqlParser.EXPONENT_VALUE = 284; +SparkSqlParser.DECIMAL_VALUE = 285; +SparkSqlParser.FLOAT_LITERAL = 286; +SparkSqlParser.DOUBLE_LITERAL = 287; +SparkSqlParser.BIGDECIMAL_LITERAL = 288; +SparkSqlParser.IDENTIFIER = 289; +SparkSqlParser.BACKQUOTED_IDENTIFIER = 290; +SparkSqlParser.SIMPLE_COMMENT = 291; +SparkSqlParser.BRACKETED_COMMENT = 292; +SparkSqlParser.WS = 293; +SparkSqlParser.UNRECOGNIZED = 294; -SqlBaseParser.RULE_program = 0; -SqlBaseParser.RULE_singleStatement = 1; -SqlBaseParser.RULE_singleExpression = 2; -SqlBaseParser.RULE_singleTableIdentifier = 3; -SqlBaseParser.RULE_singleMultipartIdentifier = 4; -SqlBaseParser.RULE_singleDataType = 5; -SqlBaseParser.RULE_singleTableSchema = 6; -SqlBaseParser.RULE_statement = 7; -SqlBaseParser.RULE_configKey = 8; -SqlBaseParser.RULE_unsupportedHiveNativeCommands = 9; -SqlBaseParser.RULE_createTableHeader = 10; -SqlBaseParser.RULE_replaceTableHeader = 11; -SqlBaseParser.RULE_bucketSpec = 12; -SqlBaseParser.RULE_skewSpec = 13; -SqlBaseParser.RULE_locationSpec = 14; -SqlBaseParser.RULE_commentSpec = 15; -SqlBaseParser.RULE_query = 16; -SqlBaseParser.RULE_insertInto = 17; -SqlBaseParser.RULE_partitionSpecLocation = 18; -SqlBaseParser.RULE_partitionSpec = 19; -SqlBaseParser.RULE_partitionVal = 20; -SqlBaseParser.RULE_namespace = 21; -SqlBaseParser.RULE_describeFuncName = 22; -SqlBaseParser.RULE_describeColName = 23; -SqlBaseParser.RULE_ctes = 24; -SqlBaseParser.RULE_namedQuery = 25; -SqlBaseParser.RULE_tableProvider = 26; -SqlBaseParser.RULE_createTableClauses = 27; -SqlBaseParser.RULE_tablePropertyList = 28; -SqlBaseParser.RULE_tableProperty = 29; -SqlBaseParser.RULE_tablePropertyKey = 30; -SqlBaseParser.RULE_tablePropertyValue = 31; -SqlBaseParser.RULE_constantList = 32; -SqlBaseParser.RULE_nestedConstantList = 33; -SqlBaseParser.RULE_createFileFormat = 34; -SqlBaseParser.RULE_fileFormat = 35; -SqlBaseParser.RULE_storageHandler = 36; -SqlBaseParser.RULE_resource = 37; -SqlBaseParser.RULE_dmlStatementNoWith = 38; -SqlBaseParser.RULE_queryOrganization = 39; -SqlBaseParser.RULE_multiInsertQueryBody = 40; -SqlBaseParser.RULE_queryTerm = 41; -SqlBaseParser.RULE_queryPrimary = 42; -SqlBaseParser.RULE_sortItem = 43; -SqlBaseParser.RULE_fromStatement = 44; -SqlBaseParser.RULE_fromStatementBody = 45; -SqlBaseParser.RULE_querySpecification = 46; -SqlBaseParser.RULE_transformClause = 47; -SqlBaseParser.RULE_selectClause = 48; -SqlBaseParser.RULE_setClause = 49; -SqlBaseParser.RULE_matchedClause = 50; -SqlBaseParser.RULE_notMatchedClause = 51; -SqlBaseParser.RULE_matchedAction = 52; -SqlBaseParser.RULE_notMatchedAction = 53; -SqlBaseParser.RULE_assignmentList = 54; -SqlBaseParser.RULE_assignment = 55; -SqlBaseParser.RULE_whereClause = 56; -SqlBaseParser.RULE_havingClause = 57; -SqlBaseParser.RULE_hint = 58; -SqlBaseParser.RULE_hintStatement = 59; -SqlBaseParser.RULE_fromClause = 60; -SqlBaseParser.RULE_aggregationClause = 61; -SqlBaseParser.RULE_groupingSet = 62; -SqlBaseParser.RULE_pivotClause = 63; -SqlBaseParser.RULE_pivotColumn = 64; -SqlBaseParser.RULE_pivotValue = 65; -SqlBaseParser.RULE_lateralView = 66; -SqlBaseParser.RULE_setQuantifier = 67; -SqlBaseParser.RULE_relation = 68; -SqlBaseParser.RULE_joinRelation = 69; -SqlBaseParser.RULE_joinType = 70; -SqlBaseParser.RULE_joinCriteria = 71; -SqlBaseParser.RULE_sample = 72; -SqlBaseParser.RULE_sampleMethod = 73; -SqlBaseParser.RULE_identifierList = 74; -SqlBaseParser.RULE_identifierSeq = 75; -SqlBaseParser.RULE_orderedIdentifierList = 76; -SqlBaseParser.RULE_orderedIdentifier = 77; -SqlBaseParser.RULE_identifierCommentList = 78; -SqlBaseParser.RULE_identifierComment = 79; -SqlBaseParser.RULE_relationPrimary = 80; -SqlBaseParser.RULE_inlineTable = 81; -SqlBaseParser.RULE_functionTable = 82; -SqlBaseParser.RULE_tableAlias = 83; -SqlBaseParser.RULE_rowFormat = 84; -SqlBaseParser.RULE_multipartIdentifierList = 85; -SqlBaseParser.RULE_multipartIdentifier = 86; -SqlBaseParser.RULE_tableIdentifier = 87; -SqlBaseParser.RULE_namedExpression = 88; -SqlBaseParser.RULE_namedExpressionSeq = 89; -SqlBaseParser.RULE_transformList = 90; -SqlBaseParser.RULE_transform = 91; -SqlBaseParser.RULE_transformArgument = 92; -SqlBaseParser.RULE_expression = 93; -SqlBaseParser.RULE_booleanExpression = 94; -SqlBaseParser.RULE_predicate = 95; -SqlBaseParser.RULE_valueExpression = 96; -SqlBaseParser.RULE_primaryExpression = 97; -SqlBaseParser.RULE_constant = 98; -SqlBaseParser.RULE_comparisonOperator = 99; -SqlBaseParser.RULE_arithmeticOperator = 100; -SqlBaseParser.RULE_predicateOperator = 101; -SqlBaseParser.RULE_booleanValue = 102; -SqlBaseParser.RULE_interval = 103; -SqlBaseParser.RULE_errorCapturingMultiUnitsInterval = 104; -SqlBaseParser.RULE_multiUnitsInterval = 105; -SqlBaseParser.RULE_errorCapturingUnitToUnitInterval = 106; -SqlBaseParser.RULE_unitToUnitInterval = 107; -SqlBaseParser.RULE_intervalValue = 108; -SqlBaseParser.RULE_colPosition = 109; -SqlBaseParser.RULE_dataType = 110; -SqlBaseParser.RULE_qualifiedColTypeWithPositionList = 111; -SqlBaseParser.RULE_qualifiedColTypeWithPosition = 112; -SqlBaseParser.RULE_colTypeList = 113; -SqlBaseParser.RULE_colType = 114; -SqlBaseParser.RULE_complexColTypeList = 115; -SqlBaseParser.RULE_complexColType = 116; -SqlBaseParser.RULE_whenClause = 117; -SqlBaseParser.RULE_windowClause = 118; -SqlBaseParser.RULE_namedWindow = 119; -SqlBaseParser.RULE_windowSpec = 120; -SqlBaseParser.RULE_windowFrame = 121; -SqlBaseParser.RULE_frameBound = 122; -SqlBaseParser.RULE_qualifiedNameList = 123; -SqlBaseParser.RULE_functionName = 124; -SqlBaseParser.RULE_qualifiedName = 125; -SqlBaseParser.RULE_errorCapturingIdentifier = 126; -SqlBaseParser.RULE_errorCapturingIdentifierExtra = 127; -SqlBaseParser.RULE_identifier = 128; -SqlBaseParser.RULE_strictIdentifier = 129; -SqlBaseParser.RULE_quotedIdentifier = 130; -SqlBaseParser.RULE_number = 131; -SqlBaseParser.RULE_alterColumnAction = 132; -SqlBaseParser.RULE_ansiNonReserved = 133; -SqlBaseParser.RULE_strictNonReserved = 134; -SqlBaseParser.RULE_nonReserved = 135; +SparkSqlParser.RULE_program = 0; +SparkSqlParser.RULE_singleStatement = 1; +SparkSqlParser.RULE_singleExpression = 2; +SparkSqlParser.RULE_singleTableIdentifier = 3; +SparkSqlParser.RULE_singleMultipartIdentifier = 4; +SparkSqlParser.RULE_singleDataType = 5; +SparkSqlParser.RULE_singleTableSchema = 6; +SparkSqlParser.RULE_statement = 7; +SparkSqlParser.RULE_configKey = 8; +SparkSqlParser.RULE_unsupportedHiveNativeCommands = 9; +SparkSqlParser.RULE_createTableHeader = 10; +SparkSqlParser.RULE_replaceTableHeader = 11; +SparkSqlParser.RULE_bucketSpec = 12; +SparkSqlParser.RULE_skewSpec = 13; +SparkSqlParser.RULE_locationSpec = 14; +SparkSqlParser.RULE_commentSpec = 15; +SparkSqlParser.RULE_query = 16; +SparkSqlParser.RULE_insertInto = 17; +SparkSqlParser.RULE_partitionSpecLocation = 18; +SparkSqlParser.RULE_partitionSpec = 19; +SparkSqlParser.RULE_partitionVal = 20; +SparkSqlParser.RULE_namespace = 21; +SparkSqlParser.RULE_describeFuncName = 22; +SparkSqlParser.RULE_describeColName = 23; +SparkSqlParser.RULE_ctes = 24; +SparkSqlParser.RULE_namedQuery = 25; +SparkSqlParser.RULE_tableProvider = 26; +SparkSqlParser.RULE_createTableClauses = 27; +SparkSqlParser.RULE_tablePropertyList = 28; +SparkSqlParser.RULE_tableProperty = 29; +SparkSqlParser.RULE_tablePropertyKey = 30; +SparkSqlParser.RULE_tablePropertyValue = 31; +SparkSqlParser.RULE_constantList = 32; +SparkSqlParser.RULE_nestedConstantList = 33; +SparkSqlParser.RULE_createFileFormat = 34; +SparkSqlParser.RULE_fileFormat = 35; +SparkSqlParser.RULE_storageHandler = 36; +SparkSqlParser.RULE_resource = 37; +SparkSqlParser.RULE_dmlStatementNoWith = 38; +SparkSqlParser.RULE_queryOrganization = 39; +SparkSqlParser.RULE_multiInsertQueryBody = 40; +SparkSqlParser.RULE_queryTerm = 41; +SparkSqlParser.RULE_queryPrimary = 42; +SparkSqlParser.RULE_sortItem = 43; +SparkSqlParser.RULE_fromStatement = 44; +SparkSqlParser.RULE_fromStatementBody = 45; +SparkSqlParser.RULE_querySpecification = 46; +SparkSqlParser.RULE_transformClause = 47; +SparkSqlParser.RULE_selectClause = 48; +SparkSqlParser.RULE_setClause = 49; +SparkSqlParser.RULE_matchedClause = 50; +SparkSqlParser.RULE_notMatchedClause = 51; +SparkSqlParser.RULE_matchedAction = 52; +SparkSqlParser.RULE_notMatchedAction = 53; +SparkSqlParser.RULE_assignmentList = 54; +SparkSqlParser.RULE_assignment = 55; +SparkSqlParser.RULE_whereClause = 56; +SparkSqlParser.RULE_havingClause = 57; +SparkSqlParser.RULE_hint = 58; +SparkSqlParser.RULE_hintStatement = 59; +SparkSqlParser.RULE_fromClause = 60; +SparkSqlParser.RULE_aggregationClause = 61; +SparkSqlParser.RULE_groupingSet = 62; +SparkSqlParser.RULE_pivotClause = 63; +SparkSqlParser.RULE_pivotColumn = 64; +SparkSqlParser.RULE_pivotValue = 65; +SparkSqlParser.RULE_lateralView = 66; +SparkSqlParser.RULE_setQuantifier = 67; +SparkSqlParser.RULE_relation = 68; +SparkSqlParser.RULE_joinRelation = 69; +SparkSqlParser.RULE_joinType = 70; +SparkSqlParser.RULE_joinCriteria = 71; +SparkSqlParser.RULE_sample = 72; +SparkSqlParser.RULE_sampleMethod = 73; +SparkSqlParser.RULE_identifierList = 74; +SparkSqlParser.RULE_identifierSeq = 75; +SparkSqlParser.RULE_orderedIdentifierList = 76; +SparkSqlParser.RULE_orderedIdentifier = 77; +SparkSqlParser.RULE_identifierCommentList = 78; +SparkSqlParser.RULE_identifierComment = 79; +SparkSqlParser.RULE_relationPrimary = 80; +SparkSqlParser.RULE_inlineTable = 81; +SparkSqlParser.RULE_functionTable = 82; +SparkSqlParser.RULE_tableAlias = 83; +SparkSqlParser.RULE_rowFormat = 84; +SparkSqlParser.RULE_multipartIdentifierList = 85; +SparkSqlParser.RULE_multipartIdentifier = 86; +SparkSqlParser.RULE_tableIdentifier = 87; +SparkSqlParser.RULE_namedExpression = 88; +SparkSqlParser.RULE_namedExpressionSeq = 89; +SparkSqlParser.RULE_transformList = 90; +SparkSqlParser.RULE_transform = 91; +SparkSqlParser.RULE_transformArgument = 92; +SparkSqlParser.RULE_expression = 93; +SparkSqlParser.RULE_booleanExpression = 94; +SparkSqlParser.RULE_predicate = 95; +SparkSqlParser.RULE_valueExpression = 96; +SparkSqlParser.RULE_primaryExpression = 97; +SparkSqlParser.RULE_constant = 98; +SparkSqlParser.RULE_comparisonOperator = 99; +SparkSqlParser.RULE_arithmeticOperator = 100; +SparkSqlParser.RULE_predicateOperator = 101; +SparkSqlParser.RULE_booleanValue = 102; +SparkSqlParser.RULE_interval = 103; +SparkSqlParser.RULE_errorCapturingMultiUnitsInterval = 104; +SparkSqlParser.RULE_multiUnitsInterval = 105; +SparkSqlParser.RULE_errorCapturingUnitToUnitInterval = 106; +SparkSqlParser.RULE_unitToUnitInterval = 107; +SparkSqlParser.RULE_intervalValue = 108; +SparkSqlParser.RULE_colPosition = 109; +SparkSqlParser.RULE_dataType = 110; +SparkSqlParser.RULE_qualifiedColTypeWithPositionList = 111; +SparkSqlParser.RULE_qualifiedColTypeWithPosition = 112; +SparkSqlParser.RULE_colTypeList = 113; +SparkSqlParser.RULE_colType = 114; +SparkSqlParser.RULE_complexColTypeList = 115; +SparkSqlParser.RULE_complexColType = 116; +SparkSqlParser.RULE_whenClause = 117; +SparkSqlParser.RULE_windowClause = 118; +SparkSqlParser.RULE_namedWindow = 119; +SparkSqlParser.RULE_windowSpec = 120; +SparkSqlParser.RULE_windowFrame = 121; +SparkSqlParser.RULE_frameBound = 122; +SparkSqlParser.RULE_qualifiedNameList = 123; +SparkSqlParser.RULE_functionName = 124; +SparkSqlParser.RULE_qualifiedName = 125; +SparkSqlParser.RULE_errorCapturingIdentifier = 126; +SparkSqlParser.RULE_errorCapturingIdentifierExtra = 127; +SparkSqlParser.RULE_identifier = 128; +SparkSqlParser.RULE_strictIdentifier = 129; +SparkSqlParser.RULE_quotedIdentifier = 130; +SparkSqlParser.RULE_number = 131; +SparkSqlParser.RULE_alterColumnAction = 132; +SparkSqlParser.RULE_ansiNonReserved = 133; +SparkSqlParser.RULE_strictNonReserved = 134; +SparkSqlParser.RULE_nonReserved = 135; function ProgramContext(parser, parent, invokingState) { @@ -2813,7 +2813,7 @@ function ProgramContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_program; + this.ruleIndex = SparkSqlParser.RULE_program; return this; } @@ -2825,23 +2825,23 @@ ProgramContext.prototype.singleStatement = function() { }; ProgramContext.prototype.EOF = function() { - return this.getToken(SqlBaseParser.EOF, 0); + return this.getToken(SparkSqlParser.EOF, 0); }; ProgramContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterProgram(this); } }; ProgramContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitProgram(this); } }; ProgramContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitProgram(this); } else { return visitor.visitChildren(this); @@ -2851,18 +2851,18 @@ ProgramContext.prototype.accept = function(visitor) { -SqlBaseParser.ProgramContext = ProgramContext; +SparkSqlParser.ProgramContext = ProgramContext; -SqlBaseParser.prototype.program = function() { +SparkSqlParser.prototype.program = function() { var localctx = new ProgramContext(this, this._ctx, this.state); - this.enterRule(localctx, 0, SqlBaseParser.RULE_program); + this.enterRule(localctx, 0, SparkSqlParser.RULE_program); try { this.enterOuterAlt(localctx, 1); this.state = 272; this.singleStatement(); this.state = 273; - this.match(SqlBaseParser.EOF); + this.match(SparkSqlParser.EOF); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -2887,7 +2887,7 @@ function SingleStatementContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_singleStatement; + this.ruleIndex = SparkSqlParser.RULE_singleStatement; return this; } @@ -2899,23 +2899,23 @@ SingleStatementContext.prototype.statement = function() { }; SingleStatementContext.prototype.EOF = function() { - return this.getToken(SqlBaseParser.EOF, 0); + return this.getToken(SparkSqlParser.EOF, 0); }; SingleStatementContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSingleStatement(this); } }; SingleStatementContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSingleStatement(this); } }; SingleStatementContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSingleStatement(this); } else { return visitor.visitChildren(this); @@ -2925,12 +2925,12 @@ SingleStatementContext.prototype.accept = function(visitor) { -SqlBaseParser.SingleStatementContext = SingleStatementContext; +SparkSqlParser.SingleStatementContext = SingleStatementContext; -SqlBaseParser.prototype.singleStatement = function() { +SparkSqlParser.prototype.singleStatement = function() { var localctx = new SingleStatementContext(this, this._ctx, this.state); - this.enterRule(localctx, 2, SqlBaseParser.RULE_singleStatement); + this.enterRule(localctx, 2, SparkSqlParser.RULE_singleStatement); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -2939,15 +2939,15 @@ SqlBaseParser.prototype.singleStatement = function() { this.state = 279; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__0) { + while(_la===SparkSqlParser.T__0) { this.state = 276; - this.match(SqlBaseParser.T__0); + this.match(SparkSqlParser.T__0); this.state = 281; this._errHandler.sync(this); _la = this._input.LA(1); } this.state = 282; - this.match(SqlBaseParser.EOF); + this.match(SparkSqlParser.EOF); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -2972,7 +2972,7 @@ function SingleExpressionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_singleExpression; + this.ruleIndex = SparkSqlParser.RULE_singleExpression; return this; } @@ -2984,23 +2984,23 @@ SingleExpressionContext.prototype.namedExpression = function() { }; SingleExpressionContext.prototype.EOF = function() { - return this.getToken(SqlBaseParser.EOF, 0); + return this.getToken(SparkSqlParser.EOF, 0); }; SingleExpressionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSingleExpression(this); } }; SingleExpressionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSingleExpression(this); } }; SingleExpressionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSingleExpression(this); } else { return visitor.visitChildren(this); @@ -3010,18 +3010,18 @@ SingleExpressionContext.prototype.accept = function(visitor) { -SqlBaseParser.SingleExpressionContext = SingleExpressionContext; +SparkSqlParser.SingleExpressionContext = SingleExpressionContext; -SqlBaseParser.prototype.singleExpression = function() { +SparkSqlParser.prototype.singleExpression = function() { var localctx = new SingleExpressionContext(this, this._ctx, this.state); - this.enterRule(localctx, 4, SqlBaseParser.RULE_singleExpression); + this.enterRule(localctx, 4, SparkSqlParser.RULE_singleExpression); try { this.enterOuterAlt(localctx, 1); this.state = 284; this.namedExpression(); this.state = 285; - this.match(SqlBaseParser.EOF); + this.match(SparkSqlParser.EOF); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -3046,7 +3046,7 @@ function SingleTableIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_singleTableIdentifier; + this.ruleIndex = SparkSqlParser.RULE_singleTableIdentifier; return this; } @@ -3058,23 +3058,23 @@ SingleTableIdentifierContext.prototype.tableIdentifier = function() { }; SingleTableIdentifierContext.prototype.EOF = function() { - return this.getToken(SqlBaseParser.EOF, 0); + return this.getToken(SparkSqlParser.EOF, 0); }; SingleTableIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSingleTableIdentifier(this); } }; SingleTableIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSingleTableIdentifier(this); } }; SingleTableIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSingleTableIdentifier(this); } else { return visitor.visitChildren(this); @@ -3084,18 +3084,18 @@ SingleTableIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.SingleTableIdentifierContext = SingleTableIdentifierContext; +SparkSqlParser.SingleTableIdentifierContext = SingleTableIdentifierContext; -SqlBaseParser.prototype.singleTableIdentifier = function() { +SparkSqlParser.prototype.singleTableIdentifier = function() { var localctx = new SingleTableIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 6, SqlBaseParser.RULE_singleTableIdentifier); + this.enterRule(localctx, 6, SparkSqlParser.RULE_singleTableIdentifier); try { this.enterOuterAlt(localctx, 1); this.state = 287; this.tableIdentifier(); this.state = 288; - this.match(SqlBaseParser.EOF); + this.match(SparkSqlParser.EOF); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -3120,7 +3120,7 @@ function SingleMultipartIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_singleMultipartIdentifier; + this.ruleIndex = SparkSqlParser.RULE_singleMultipartIdentifier; return this; } @@ -3132,23 +3132,23 @@ SingleMultipartIdentifierContext.prototype.multipartIdentifier = function() { }; SingleMultipartIdentifierContext.prototype.EOF = function() { - return this.getToken(SqlBaseParser.EOF, 0); + return this.getToken(SparkSqlParser.EOF, 0); }; SingleMultipartIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSingleMultipartIdentifier(this); } }; SingleMultipartIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSingleMultipartIdentifier(this); } }; SingleMultipartIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSingleMultipartIdentifier(this); } else { return visitor.visitChildren(this); @@ -3158,18 +3158,18 @@ SingleMultipartIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.SingleMultipartIdentifierContext = SingleMultipartIdentifierContext; +SparkSqlParser.SingleMultipartIdentifierContext = SingleMultipartIdentifierContext; -SqlBaseParser.prototype.singleMultipartIdentifier = function() { +SparkSqlParser.prototype.singleMultipartIdentifier = function() { var localctx = new SingleMultipartIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 8, SqlBaseParser.RULE_singleMultipartIdentifier); + this.enterRule(localctx, 8, SparkSqlParser.RULE_singleMultipartIdentifier); try { this.enterOuterAlt(localctx, 1); this.state = 290; this.multipartIdentifier(); this.state = 291; - this.match(SqlBaseParser.EOF); + this.match(SparkSqlParser.EOF); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -3194,7 +3194,7 @@ function SingleDataTypeContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_singleDataType; + this.ruleIndex = SparkSqlParser.RULE_singleDataType; return this; } @@ -3206,23 +3206,23 @@ SingleDataTypeContext.prototype.dataType = function() { }; SingleDataTypeContext.prototype.EOF = function() { - return this.getToken(SqlBaseParser.EOF, 0); + return this.getToken(SparkSqlParser.EOF, 0); }; SingleDataTypeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSingleDataType(this); } }; SingleDataTypeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSingleDataType(this); } }; SingleDataTypeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSingleDataType(this); } else { return visitor.visitChildren(this); @@ -3232,18 +3232,18 @@ SingleDataTypeContext.prototype.accept = function(visitor) { -SqlBaseParser.SingleDataTypeContext = SingleDataTypeContext; +SparkSqlParser.SingleDataTypeContext = SingleDataTypeContext; -SqlBaseParser.prototype.singleDataType = function() { +SparkSqlParser.prototype.singleDataType = function() { var localctx = new SingleDataTypeContext(this, this._ctx, this.state); - this.enterRule(localctx, 10, SqlBaseParser.RULE_singleDataType); + this.enterRule(localctx, 10, SparkSqlParser.RULE_singleDataType); try { this.enterOuterAlt(localctx, 1); this.state = 293; this.dataType(); this.state = 294; - this.match(SqlBaseParser.EOF); + this.match(SparkSqlParser.EOF); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -3268,7 +3268,7 @@ function SingleTableSchemaContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_singleTableSchema; + this.ruleIndex = SparkSqlParser.RULE_singleTableSchema; return this; } @@ -3280,23 +3280,23 @@ SingleTableSchemaContext.prototype.colTypeList = function() { }; SingleTableSchemaContext.prototype.EOF = function() { - return this.getToken(SqlBaseParser.EOF, 0); + return this.getToken(SparkSqlParser.EOF, 0); }; SingleTableSchemaContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSingleTableSchema(this); } }; SingleTableSchemaContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSingleTableSchema(this); } }; SingleTableSchemaContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSingleTableSchema(this); } else { return visitor.visitChildren(this); @@ -3306,18 +3306,18 @@ SingleTableSchemaContext.prototype.accept = function(visitor) { -SqlBaseParser.SingleTableSchemaContext = SingleTableSchemaContext; +SparkSqlParser.SingleTableSchemaContext = SingleTableSchemaContext; -SqlBaseParser.prototype.singleTableSchema = function() { +SparkSqlParser.prototype.singleTableSchema = function() { var localctx = new SingleTableSchemaContext(this, this._ctx, this.state); - this.enterRule(localctx, 12, SqlBaseParser.RULE_singleTableSchema); + this.enterRule(localctx, 12, SparkSqlParser.RULE_singleTableSchema); try { this.enterOuterAlt(localctx, 1); this.state = 296; this.colTypeList(); this.state = 297; - this.match(SqlBaseParser.EOF); + this.match(SparkSqlParser.EOF); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -3342,7 +3342,7 @@ function StatementContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_statement; + this.ruleIndex = SparkSqlParser.RULE_statement; return this; } @@ -3365,10 +3365,10 @@ function ExplainContext(parser, ctx) { ExplainContext.prototype = Object.create(StatementContext.prototype); ExplainContext.prototype.constructor = ExplainContext; -SqlBaseParser.ExplainContext = ExplainContext; +SparkSqlParser.ExplainContext = ExplainContext; ExplainContext.prototype.EXPLAIN = function() { - return this.getToken(SqlBaseParser.EXPLAIN, 0); + return this.getToken(SparkSqlParser.EXPLAIN, 0); }; ExplainContext.prototype.statement = function() { @@ -3376,38 +3376,38 @@ ExplainContext.prototype.statement = function() { }; ExplainContext.prototype.LOGICAL = function() { - return this.getToken(SqlBaseParser.LOGICAL, 0); + return this.getToken(SparkSqlParser.LOGICAL, 0); }; ExplainContext.prototype.FORMATTED = function() { - return this.getToken(SqlBaseParser.FORMATTED, 0); + return this.getToken(SparkSqlParser.FORMATTED, 0); }; ExplainContext.prototype.EXTENDED = function() { - return this.getToken(SqlBaseParser.EXTENDED, 0); + return this.getToken(SparkSqlParser.EXTENDED, 0); }; ExplainContext.prototype.CODEGEN = function() { - return this.getToken(SqlBaseParser.CODEGEN, 0); + return this.getToken(SparkSqlParser.CODEGEN, 0); }; ExplainContext.prototype.COST = function() { - return this.getToken(SqlBaseParser.COST, 0); + return this.getToken(SparkSqlParser.COST, 0); }; ExplainContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterExplain(this); } }; ExplainContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitExplain(this); } }; ExplainContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitExplain(this); } else { return visitor.visitChildren(this); @@ -3424,25 +3424,25 @@ function ResetConfigurationContext(parser, ctx) { ResetConfigurationContext.prototype = Object.create(StatementContext.prototype); ResetConfigurationContext.prototype.constructor = ResetConfigurationContext; -SqlBaseParser.ResetConfigurationContext = ResetConfigurationContext; +SparkSqlParser.ResetConfigurationContext = ResetConfigurationContext; ResetConfigurationContext.prototype.RESET = function() { - return this.getToken(SqlBaseParser.RESET, 0); + return this.getToken(SparkSqlParser.RESET, 0); }; ResetConfigurationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterResetConfiguration(this); } }; ResetConfigurationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitResetConfiguration(this); } }; ResetConfigurationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitResetConfiguration(this); } else { return visitor.visitChildren(this); @@ -3459,14 +3459,14 @@ function AlterViewQueryContext(parser, ctx) { AlterViewQueryContext.prototype = Object.create(StatementContext.prototype); AlterViewQueryContext.prototype.constructor = AlterViewQueryContext; -SqlBaseParser.AlterViewQueryContext = AlterViewQueryContext; +SparkSqlParser.AlterViewQueryContext = AlterViewQueryContext; AlterViewQueryContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; AlterViewQueryContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; AlterViewQueryContext.prototype.multipartIdentifier = function() { @@ -3478,22 +3478,22 @@ AlterViewQueryContext.prototype.query = function() { }; AlterViewQueryContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; AlterViewQueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAlterViewQuery(this); } }; AlterViewQueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAlterViewQuery(this); } }; AlterViewQueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAlterViewQuery(this); } else { return visitor.visitChildren(this); @@ -3510,10 +3510,10 @@ function UseContext(parser, ctx) { UseContext.prototype = Object.create(StatementContext.prototype); UseContext.prototype.constructor = UseContext; -SqlBaseParser.UseContext = UseContext; +SparkSqlParser.UseContext = UseContext; UseContext.prototype.USE = function() { - return this.getToken(SqlBaseParser.USE, 0); + return this.getToken(SparkSqlParser.USE, 0); }; UseContext.prototype.multipartIdentifier = function() { @@ -3521,22 +3521,22 @@ UseContext.prototype.multipartIdentifier = function() { }; UseContext.prototype.NAMESPACE = function() { - return this.getToken(SqlBaseParser.NAMESPACE, 0); + return this.getToken(SparkSqlParser.NAMESPACE, 0); }; UseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterUse(this); } }; UseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitUse(this); } }; UseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitUse(this); } else { return visitor.visitChildren(this); @@ -3553,10 +3553,10 @@ function DropNamespaceContext(parser, ctx) { DropNamespaceContext.prototype = Object.create(StatementContext.prototype); DropNamespaceContext.prototype.constructor = DropNamespaceContext; -SqlBaseParser.DropNamespaceContext = DropNamespaceContext; +SparkSqlParser.DropNamespaceContext = DropNamespaceContext; DropNamespaceContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; DropNamespaceContext.prototype.namespace = function() { @@ -3568,34 +3568,34 @@ DropNamespaceContext.prototype.multipartIdentifier = function() { }; DropNamespaceContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; DropNamespaceContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; DropNamespaceContext.prototype.RESTRICT = function() { - return this.getToken(SqlBaseParser.RESTRICT, 0); + return this.getToken(SparkSqlParser.RESTRICT, 0); }; DropNamespaceContext.prototype.CASCADE = function() { - return this.getToken(SqlBaseParser.CASCADE, 0); + return this.getToken(SparkSqlParser.CASCADE, 0); }; DropNamespaceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDropNamespace(this); } }; DropNamespaceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDropNamespace(this); } }; DropNamespaceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDropNamespace(this); } else { return visitor.visitChildren(this); @@ -3612,18 +3612,18 @@ function CreateTempViewUsingContext(parser, ctx) { CreateTempViewUsingContext.prototype = Object.create(StatementContext.prototype); CreateTempViewUsingContext.prototype.constructor = CreateTempViewUsingContext; -SqlBaseParser.CreateTempViewUsingContext = CreateTempViewUsingContext; +SparkSqlParser.CreateTempViewUsingContext = CreateTempViewUsingContext; CreateTempViewUsingContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; CreateTempViewUsingContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; CreateTempViewUsingContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; CreateTempViewUsingContext.prototype.tableIdentifier = function() { @@ -3635,15 +3635,15 @@ CreateTempViewUsingContext.prototype.tableProvider = function() { }; CreateTempViewUsingContext.prototype.OR = function() { - return this.getToken(SqlBaseParser.OR, 0); + return this.getToken(SparkSqlParser.OR, 0); }; CreateTempViewUsingContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; CreateTempViewUsingContext.prototype.GLOBAL = function() { - return this.getToken(SqlBaseParser.GLOBAL, 0); + return this.getToken(SparkSqlParser.GLOBAL, 0); }; CreateTempViewUsingContext.prototype.colTypeList = function() { @@ -3651,26 +3651,26 @@ CreateTempViewUsingContext.prototype.colTypeList = function() { }; CreateTempViewUsingContext.prototype.OPTIONS = function() { - return this.getToken(SqlBaseParser.OPTIONS, 0); + return this.getToken(SparkSqlParser.OPTIONS, 0); }; CreateTempViewUsingContext.prototype.tablePropertyList = function() { return this.getTypedRuleContext(TablePropertyListContext,0); }; CreateTempViewUsingContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateTempViewUsing(this); } }; CreateTempViewUsingContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateTempViewUsing(this); } }; CreateTempViewUsingContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateTempViewUsing(this); } else { return visitor.visitChildren(this); @@ -3689,26 +3689,26 @@ function RenameTableContext(parser, ctx) { RenameTableContext.prototype = Object.create(StatementContext.prototype); RenameTableContext.prototype.constructor = RenameTableContext; -SqlBaseParser.RenameTableContext = RenameTableContext; +SparkSqlParser.RenameTableContext = RenameTableContext; RenameTableContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; RenameTableContext.prototype.RENAME = function() { - return this.getToken(SqlBaseParser.RENAME, 0); + return this.getToken(SparkSqlParser.RENAME, 0); }; RenameTableContext.prototype.TO = function() { - return this.getToken(SqlBaseParser.TO, 0); + return this.getToken(SparkSqlParser.TO, 0); }; RenameTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; RenameTableContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; RenameTableContext.prototype.multipartIdentifier = function(i) { @@ -3722,19 +3722,19 @@ RenameTableContext.prototype.multipartIdentifier = function(i) { } }; RenameTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRenameTable(this); } }; RenameTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRenameTable(this); } }; RenameTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRenameTable(this); } else { return visitor.visitChildren(this); @@ -3751,33 +3751,33 @@ function FailNativeCommandContext(parser, ctx) { FailNativeCommandContext.prototype = Object.create(StatementContext.prototype); FailNativeCommandContext.prototype.constructor = FailNativeCommandContext; -SqlBaseParser.FailNativeCommandContext = FailNativeCommandContext; +SparkSqlParser.FailNativeCommandContext = FailNativeCommandContext; FailNativeCommandContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; FailNativeCommandContext.prototype.ROLE = function() { - return this.getToken(SqlBaseParser.ROLE, 0); + return this.getToken(SparkSqlParser.ROLE, 0); }; FailNativeCommandContext.prototype.unsupportedHiveNativeCommands = function() { return this.getTypedRuleContext(UnsupportedHiveNativeCommandsContext,0); }; FailNativeCommandContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFailNativeCommand(this); } }; FailNativeCommandContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFailNativeCommand(this); } }; FailNativeCommandContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFailNativeCommand(this); } else { return visitor.visitChildren(this); @@ -3794,29 +3794,29 @@ function ClearCacheContext(parser, ctx) { ClearCacheContext.prototype = Object.create(StatementContext.prototype); ClearCacheContext.prototype.constructor = ClearCacheContext; -SqlBaseParser.ClearCacheContext = ClearCacheContext; +SparkSqlParser.ClearCacheContext = ClearCacheContext; ClearCacheContext.prototype.CLEAR = function() { - return this.getToken(SqlBaseParser.CLEAR, 0); + return this.getToken(SparkSqlParser.CLEAR, 0); }; ClearCacheContext.prototype.CACHE = function() { - return this.getToken(SqlBaseParser.CACHE, 0); + return this.getToken(SparkSqlParser.CACHE, 0); }; ClearCacheContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterClearCache(this); } }; ClearCacheContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitClearCache(this); } }; ClearCacheContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitClearCache(this); } else { return visitor.visitChildren(this); @@ -3833,14 +3833,14 @@ function DropViewContext(parser, ctx) { DropViewContext.prototype = Object.create(StatementContext.prototype); DropViewContext.prototype.constructor = DropViewContext; -SqlBaseParser.DropViewContext = DropViewContext; +SparkSqlParser.DropViewContext = DropViewContext; DropViewContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; DropViewContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; DropViewContext.prototype.multipartIdentifier = function() { @@ -3848,26 +3848,26 @@ DropViewContext.prototype.multipartIdentifier = function() { }; DropViewContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; DropViewContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; DropViewContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDropView(this); } }; DropViewContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDropView(this); } }; DropViewContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDropView(this); } else { return visitor.visitChildren(this); @@ -3885,14 +3885,14 @@ function ShowTablesContext(parser, ctx) { ShowTablesContext.prototype = Object.create(StatementContext.prototype); ShowTablesContext.prototype.constructor = ShowTablesContext; -SqlBaseParser.ShowTablesContext = ShowTablesContext; +SparkSqlParser.ShowTablesContext = ShowTablesContext; ShowTablesContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowTablesContext.prototype.TABLES = function() { - return this.getToken(SqlBaseParser.TABLES, 0); + return this.getToken(SparkSqlParser.TABLES, 0); }; ShowTablesContext.prototype.multipartIdentifier = function() { @@ -3900,34 +3900,34 @@ ShowTablesContext.prototype.multipartIdentifier = function() { }; ShowTablesContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; ShowTablesContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; ShowTablesContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; ShowTablesContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; ShowTablesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowTables(this); } }; ShowTablesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowTables(this); } }; ShowTablesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowTables(this); } else { return visitor.visitChildren(this); @@ -3944,14 +3944,14 @@ function RecoverPartitionsContext(parser, ctx) { RecoverPartitionsContext.prototype = Object.create(StatementContext.prototype); RecoverPartitionsContext.prototype.constructor = RecoverPartitionsContext; -SqlBaseParser.RecoverPartitionsContext = RecoverPartitionsContext; +SparkSqlParser.RecoverPartitionsContext = RecoverPartitionsContext; RecoverPartitionsContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; RecoverPartitionsContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; RecoverPartitionsContext.prototype.multipartIdentifier = function() { @@ -3959,26 +3959,26 @@ RecoverPartitionsContext.prototype.multipartIdentifier = function() { }; RecoverPartitionsContext.prototype.RECOVER = function() { - return this.getToken(SqlBaseParser.RECOVER, 0); + return this.getToken(SparkSqlParser.RECOVER, 0); }; RecoverPartitionsContext.prototype.PARTITIONS = function() { - return this.getToken(SqlBaseParser.PARTITIONS, 0); + return this.getToken(SparkSqlParser.PARTITIONS, 0); }; RecoverPartitionsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRecoverPartitions(this); } }; RecoverPartitionsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRecoverPartitions(this); } }; RecoverPartitionsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRecoverPartitions(this); } else { return visitor.visitChildren(this); @@ -3995,33 +3995,33 @@ function ShowCurrentNamespaceContext(parser, ctx) { ShowCurrentNamespaceContext.prototype = Object.create(StatementContext.prototype); ShowCurrentNamespaceContext.prototype.constructor = ShowCurrentNamespaceContext; -SqlBaseParser.ShowCurrentNamespaceContext = ShowCurrentNamespaceContext; +SparkSqlParser.ShowCurrentNamespaceContext = ShowCurrentNamespaceContext; ShowCurrentNamespaceContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowCurrentNamespaceContext.prototype.CURRENT = function() { - return this.getToken(SqlBaseParser.CURRENT, 0); + return this.getToken(SparkSqlParser.CURRENT, 0); }; ShowCurrentNamespaceContext.prototype.NAMESPACE = function() { - return this.getToken(SqlBaseParser.NAMESPACE, 0); + return this.getToken(SparkSqlParser.NAMESPACE, 0); }; ShowCurrentNamespaceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowCurrentNamespace(this); } }; ShowCurrentNamespaceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowCurrentNamespace(this); } }; ShowCurrentNamespaceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowCurrentNamespace(this); } else { return visitor.visitChildren(this); @@ -4040,14 +4040,14 @@ function RenameTablePartitionContext(parser, ctx) { RenameTablePartitionContext.prototype = Object.create(StatementContext.prototype); RenameTablePartitionContext.prototype.constructor = RenameTablePartitionContext; -SqlBaseParser.RenameTablePartitionContext = RenameTablePartitionContext; +SparkSqlParser.RenameTablePartitionContext = RenameTablePartitionContext; RenameTablePartitionContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; RenameTablePartitionContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; RenameTablePartitionContext.prototype.multipartIdentifier = function() { @@ -4055,11 +4055,11 @@ RenameTablePartitionContext.prototype.multipartIdentifier = function() { }; RenameTablePartitionContext.prototype.RENAME = function() { - return this.getToken(SqlBaseParser.RENAME, 0); + return this.getToken(SparkSqlParser.RENAME, 0); }; RenameTablePartitionContext.prototype.TO = function() { - return this.getToken(SqlBaseParser.TO, 0); + return this.getToken(SparkSqlParser.TO, 0); }; RenameTablePartitionContext.prototype.partitionSpec = function(i) { @@ -4073,19 +4073,19 @@ RenameTablePartitionContext.prototype.partitionSpec = function(i) { } }; RenameTablePartitionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRenameTablePartition(this); } }; RenameTablePartitionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRenameTablePartition(this); } }; RenameTablePartitionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRenameTablePartition(this); } else { return visitor.visitChildren(this); @@ -4102,37 +4102,37 @@ function RepairTableContext(parser, ctx) { RepairTableContext.prototype = Object.create(StatementContext.prototype); RepairTableContext.prototype.constructor = RepairTableContext; -SqlBaseParser.RepairTableContext = RepairTableContext; +SparkSqlParser.RepairTableContext = RepairTableContext; RepairTableContext.prototype.MSCK = function() { - return this.getToken(SqlBaseParser.MSCK, 0); + return this.getToken(SparkSqlParser.MSCK, 0); }; RepairTableContext.prototype.REPAIR = function() { - return this.getToken(SqlBaseParser.REPAIR, 0); + return this.getToken(SparkSqlParser.REPAIR, 0); }; RepairTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; RepairTableContext.prototype.multipartIdentifier = function() { return this.getTypedRuleContext(MultipartIdentifierContext,0); }; RepairTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRepairTable(this); } }; RepairTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRepairTable(this); } }; RepairTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRepairTable(this); } else { return visitor.visitChildren(this); @@ -4149,29 +4149,29 @@ function RefreshResourceContext(parser, ctx) { RefreshResourceContext.prototype = Object.create(StatementContext.prototype); RefreshResourceContext.prototype.constructor = RefreshResourceContext; -SqlBaseParser.RefreshResourceContext = RefreshResourceContext; +SparkSqlParser.RefreshResourceContext = RefreshResourceContext; RefreshResourceContext.prototype.REFRESH = function() { - return this.getToken(SqlBaseParser.REFRESH, 0); + return this.getToken(SparkSqlParser.REFRESH, 0); }; RefreshResourceContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; RefreshResourceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRefreshResource(this); } }; RefreshResourceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRefreshResource(this); } }; RefreshResourceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRefreshResource(this); } else { return visitor.visitChildren(this); @@ -4188,18 +4188,18 @@ function ShowCreateTableContext(parser, ctx) { ShowCreateTableContext.prototype = Object.create(StatementContext.prototype); ShowCreateTableContext.prototype.constructor = ShowCreateTableContext; -SqlBaseParser.ShowCreateTableContext = ShowCreateTableContext; +SparkSqlParser.ShowCreateTableContext = ShowCreateTableContext; ShowCreateTableContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowCreateTableContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; ShowCreateTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; ShowCreateTableContext.prototype.multipartIdentifier = function() { @@ -4207,26 +4207,26 @@ ShowCreateTableContext.prototype.multipartIdentifier = function() { }; ShowCreateTableContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; ShowCreateTableContext.prototype.SERDE = function() { - return this.getToken(SqlBaseParser.SERDE, 0); + return this.getToken(SparkSqlParser.SERDE, 0); }; ShowCreateTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowCreateTable(this); } }; ShowCreateTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowCreateTable(this); } }; ShowCreateTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowCreateTable(this); } else { return visitor.visitChildren(this); @@ -4244,18 +4244,18 @@ function ShowNamespacesContext(parser, ctx) { ShowNamespacesContext.prototype = Object.create(StatementContext.prototype); ShowNamespacesContext.prototype.constructor = ShowNamespacesContext; -SqlBaseParser.ShowNamespacesContext = ShowNamespacesContext; +SparkSqlParser.ShowNamespacesContext = ShowNamespacesContext; ShowNamespacesContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowNamespacesContext.prototype.DATABASES = function() { - return this.getToken(SqlBaseParser.DATABASES, 0); + return this.getToken(SparkSqlParser.DATABASES, 0); }; ShowNamespacesContext.prototype.NAMESPACES = function() { - return this.getToken(SqlBaseParser.NAMESPACES, 0); + return this.getToken(SparkSqlParser.NAMESPACES, 0); }; ShowNamespacesContext.prototype.multipartIdentifier = function() { @@ -4263,34 +4263,34 @@ ShowNamespacesContext.prototype.multipartIdentifier = function() { }; ShowNamespacesContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; ShowNamespacesContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; ShowNamespacesContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; ShowNamespacesContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; ShowNamespacesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowNamespaces(this); } }; ShowNamespacesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowNamespaces(this); } }; ShowNamespacesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowNamespaces(this); } else { return visitor.visitChildren(this); @@ -4309,14 +4309,14 @@ function ShowColumnsContext(parser, ctx) { ShowColumnsContext.prototype = Object.create(StatementContext.prototype); ShowColumnsContext.prototype.constructor = ShowColumnsContext; -SqlBaseParser.ShowColumnsContext = ShowColumnsContext; +SparkSqlParser.ShowColumnsContext = ShowColumnsContext; ShowColumnsContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowColumnsContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; ShowColumnsContext.prototype.FROM = function(i) { @@ -4324,9 +4324,9 @@ ShowColumnsContext.prototype.FROM = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.FROM); + return this.getTokens(SparkSqlParser.FROM); } else { - return this.getToken(SqlBaseParser.FROM, i); + return this.getToken(SparkSqlParser.FROM, i); } }; @@ -4336,9 +4336,9 @@ ShowColumnsContext.prototype.IN = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.IN); + return this.getTokens(SparkSqlParser.IN); } else { - return this.getToken(SqlBaseParser.IN, i); + return this.getToken(SparkSqlParser.IN, i); } }; @@ -4354,19 +4354,19 @@ ShowColumnsContext.prototype.multipartIdentifier = function(i) { } }; ShowColumnsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowColumns(this); } }; ShowColumnsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowColumns(this); } }; ShowColumnsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowColumns(this); } else { return visitor.visitChildren(this); @@ -4383,7 +4383,7 @@ function ReplaceTableContext(parser, ctx) { ReplaceTableContext.prototype = Object.create(StatementContext.prototype); ReplaceTableContext.prototype.constructor = ReplaceTableContext; -SqlBaseParser.ReplaceTableContext = ReplaceTableContext; +SparkSqlParser.ReplaceTableContext = ReplaceTableContext; ReplaceTableContext.prototype.replaceTableHeader = function() { return this.getTypedRuleContext(ReplaceTableHeaderContext,0); @@ -4406,22 +4406,22 @@ ReplaceTableContext.prototype.query = function() { }; ReplaceTableContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; ReplaceTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterReplaceTable(this); } }; ReplaceTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitReplaceTable(this); } }; ReplaceTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitReplaceTable(this); } else { return visitor.visitChildren(this); @@ -4438,10 +4438,10 @@ function AddTablePartitionContext(parser, ctx) { AddTablePartitionContext.prototype = Object.create(StatementContext.prototype); AddTablePartitionContext.prototype.constructor = AddTablePartitionContext; -SqlBaseParser.AddTablePartitionContext = AddTablePartitionContext; +SparkSqlParser.AddTablePartitionContext = AddTablePartitionContext; AddTablePartitionContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; AddTablePartitionContext.prototype.multipartIdentifier = function() { @@ -4449,27 +4449,27 @@ AddTablePartitionContext.prototype.multipartIdentifier = function() { }; AddTablePartitionContext.prototype.ADD = function() { - return this.getToken(SqlBaseParser.ADD, 0); + return this.getToken(SparkSqlParser.ADD, 0); }; AddTablePartitionContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; AddTablePartitionContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; AddTablePartitionContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; AddTablePartitionContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; AddTablePartitionContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; AddTablePartitionContext.prototype.partitionSpecLocation = function(i) { @@ -4483,19 +4483,19 @@ AddTablePartitionContext.prototype.partitionSpecLocation = function(i) { } }; AddTablePartitionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAddTablePartition(this); } }; AddTablePartitionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAddTablePartition(this); } }; AddTablePartitionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAddTablePartition(this); } else { return visitor.visitChildren(this); @@ -4512,10 +4512,10 @@ function SetNamespaceLocationContext(parser, ctx) { SetNamespaceLocationContext.prototype = Object.create(StatementContext.prototype); SetNamespaceLocationContext.prototype.constructor = SetNamespaceLocationContext; -SqlBaseParser.SetNamespaceLocationContext = SetNamespaceLocationContext; +SparkSqlParser.SetNamespaceLocationContext = SetNamespaceLocationContext; SetNamespaceLocationContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; SetNamespaceLocationContext.prototype.namespace = function() { @@ -4527,26 +4527,26 @@ SetNamespaceLocationContext.prototype.multipartIdentifier = function() { }; SetNamespaceLocationContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetNamespaceLocationContext.prototype.locationSpec = function() { return this.getTypedRuleContext(LocationSpecContext,0); }; SetNamespaceLocationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetNamespaceLocation(this); } }; SetNamespaceLocationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetNamespaceLocation(this); } }; SetNamespaceLocationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetNamespaceLocation(this); } else { return visitor.visitChildren(this); @@ -4563,33 +4563,33 @@ function RefreshTableContext(parser, ctx) { RefreshTableContext.prototype = Object.create(StatementContext.prototype); RefreshTableContext.prototype.constructor = RefreshTableContext; -SqlBaseParser.RefreshTableContext = RefreshTableContext; +SparkSqlParser.RefreshTableContext = RefreshTableContext; RefreshTableContext.prototype.REFRESH = function() { - return this.getToken(SqlBaseParser.REFRESH, 0); + return this.getToken(SparkSqlParser.REFRESH, 0); }; RefreshTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; RefreshTableContext.prototype.multipartIdentifier = function() { return this.getTypedRuleContext(MultipartIdentifierContext,0); }; RefreshTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRefreshTable(this); } }; RefreshTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRefreshTable(this); } }; RefreshTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRefreshTable(this); } else { return visitor.visitChildren(this); @@ -4606,10 +4606,10 @@ function SetNamespacePropertiesContext(parser, ctx) { SetNamespacePropertiesContext.prototype = Object.create(StatementContext.prototype); SetNamespacePropertiesContext.prototype.constructor = SetNamespacePropertiesContext; -SqlBaseParser.SetNamespacePropertiesContext = SetNamespacePropertiesContext; +SparkSqlParser.SetNamespacePropertiesContext = SetNamespacePropertiesContext; SetNamespacePropertiesContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; SetNamespacePropertiesContext.prototype.namespace = function() { @@ -4621,7 +4621,7 @@ SetNamespacePropertiesContext.prototype.multipartIdentifier = function() { }; SetNamespacePropertiesContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetNamespacePropertiesContext.prototype.tablePropertyList = function() { @@ -4629,26 +4629,26 @@ SetNamespacePropertiesContext.prototype.tablePropertyList = function() { }; SetNamespacePropertiesContext.prototype.DBPROPERTIES = function() { - return this.getToken(SqlBaseParser.DBPROPERTIES, 0); + return this.getToken(SparkSqlParser.DBPROPERTIES, 0); }; SetNamespacePropertiesContext.prototype.PROPERTIES = function() { - return this.getToken(SqlBaseParser.PROPERTIES, 0); + return this.getToken(SparkSqlParser.PROPERTIES, 0); }; SetNamespacePropertiesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetNamespaceProperties(this); } }; SetNamespacePropertiesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetNamespaceProperties(this); } }; SetNamespacePropertiesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetNamespaceProperties(this); } else { return visitor.visitChildren(this); @@ -4666,37 +4666,37 @@ function ManageResourceContext(parser, ctx) { ManageResourceContext.prototype = Object.create(StatementContext.prototype); ManageResourceContext.prototype.constructor = ManageResourceContext; -SqlBaseParser.ManageResourceContext = ManageResourceContext; +SparkSqlParser.ManageResourceContext = ManageResourceContext; ManageResourceContext.prototype.identifier = function() { return this.getTypedRuleContext(IdentifierContext,0); }; ManageResourceContext.prototype.ADD = function() { - return this.getToken(SqlBaseParser.ADD, 0); + return this.getToken(SparkSqlParser.ADD, 0); }; ManageResourceContext.prototype.LIST = function() { - return this.getToken(SqlBaseParser.LIST, 0); + return this.getToken(SparkSqlParser.LIST, 0); }; ManageResourceContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; ManageResourceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterManageResource(this); } }; ManageResourceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitManageResource(this); } }; ManageResourceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitManageResource(this); } else { return visitor.visitChildren(this); @@ -4713,10 +4713,10 @@ function SetQuotedConfigurationContext(parser, ctx) { SetQuotedConfigurationContext.prototype = Object.create(StatementContext.prototype); SetQuotedConfigurationContext.prototype.constructor = SetQuotedConfigurationContext; -SqlBaseParser.SetQuotedConfigurationContext = SetQuotedConfigurationContext; +SparkSqlParser.SetQuotedConfigurationContext = SetQuotedConfigurationContext; SetQuotedConfigurationContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetQuotedConfigurationContext.prototype.configKey = function() { @@ -4724,22 +4724,22 @@ SetQuotedConfigurationContext.prototype.configKey = function() { }; SetQuotedConfigurationContext.prototype.EQ = function() { - return this.getToken(SqlBaseParser.EQ, 0); + return this.getToken(SparkSqlParser.EQ, 0); }; SetQuotedConfigurationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetQuotedConfiguration(this); } }; SetQuotedConfigurationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetQuotedConfiguration(this); } }; SetQuotedConfigurationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetQuotedConfiguration(this); } else { return visitor.visitChildren(this); @@ -4756,14 +4756,14 @@ function AnalyzeContext(parser, ctx) { AnalyzeContext.prototype = Object.create(StatementContext.prototype); AnalyzeContext.prototype.constructor = AnalyzeContext; -SqlBaseParser.AnalyzeContext = AnalyzeContext; +SparkSqlParser.AnalyzeContext = AnalyzeContext; AnalyzeContext.prototype.ANALYZE = function() { - return this.getToken(SqlBaseParser.ANALYZE, 0); + return this.getToken(SparkSqlParser.ANALYZE, 0); }; AnalyzeContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; AnalyzeContext.prototype.multipartIdentifier = function() { @@ -4771,11 +4771,11 @@ AnalyzeContext.prototype.multipartIdentifier = function() { }; AnalyzeContext.prototype.COMPUTE = function() { - return this.getToken(SqlBaseParser.COMPUTE, 0); + return this.getToken(SparkSqlParser.COMPUTE, 0); }; AnalyzeContext.prototype.STATISTICS = function() { - return this.getToken(SqlBaseParser.STATISTICS, 0); + return this.getToken(SparkSqlParser.STATISTICS, 0); }; AnalyzeContext.prototype.partitionSpec = function() { @@ -4787,11 +4787,11 @@ AnalyzeContext.prototype.identifier = function() { }; AnalyzeContext.prototype.FOR = function() { - return this.getToken(SqlBaseParser.FOR, 0); + return this.getToken(SparkSqlParser.FOR, 0); }; AnalyzeContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; AnalyzeContext.prototype.identifierSeq = function() { @@ -4799,22 +4799,22 @@ AnalyzeContext.prototype.identifierSeq = function() { }; AnalyzeContext.prototype.ALL = function() { - return this.getToken(SqlBaseParser.ALL, 0); + return this.getToken(SparkSqlParser.ALL, 0); }; AnalyzeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAnalyze(this); } }; AnalyzeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAnalyze(this); } }; AnalyzeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAnalyze(this); } else { return visitor.visitChildren(this); @@ -4835,7 +4835,7 @@ function CreateHiveTableContext(parser, ctx) { CreateHiveTableContext.prototype = Object.create(StatementContext.prototype); CreateHiveTableContext.prototype.constructor = CreateHiveTableContext; -SqlBaseParser.CreateHiveTableContext = CreateHiveTableContext; +SparkSqlParser.CreateHiveTableContext = CreateHiveTableContext; CreateHiveTableContext.prototype.createTableHeader = function() { return this.getTypedRuleContext(CreateTableHeaderContext,0); @@ -4927,9 +4927,9 @@ CreateHiveTableContext.prototype.PARTITIONED = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.PARTITIONED); + return this.getTokens(SparkSqlParser.PARTITIONED); } else { - return this.getToken(SqlBaseParser.PARTITIONED, i); + return this.getToken(SparkSqlParser.PARTITIONED, i); } }; @@ -4939,9 +4939,9 @@ CreateHiveTableContext.prototype.BY = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.BY); + return this.getTokens(SparkSqlParser.BY); } else { - return this.getToken(SqlBaseParser.BY, i); + return this.getToken(SparkSqlParser.BY, i); } }; @@ -4951,9 +4951,9 @@ CreateHiveTableContext.prototype.TBLPROPERTIES = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.TBLPROPERTIES); + return this.getTokens(SparkSqlParser.TBLPROPERTIES); } else { - return this.getToken(SqlBaseParser.TBLPROPERTIES, i); + return this.getToken(SparkSqlParser.TBLPROPERTIES, i); } }; @@ -4981,22 +4981,22 @@ CreateHiveTableContext.prototype.tablePropertyList = function(i) { }; CreateHiveTableContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; CreateHiveTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateHiveTable(this); } }; CreateHiveTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateHiveTable(this); } }; CreateHiveTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateHiveTable(this); } else { return visitor.visitChildren(this); @@ -5014,14 +5014,14 @@ function CreateFunctionContext(parser, ctx) { CreateFunctionContext.prototype = Object.create(StatementContext.prototype); CreateFunctionContext.prototype.constructor = CreateFunctionContext; -SqlBaseParser.CreateFunctionContext = CreateFunctionContext; +SparkSqlParser.CreateFunctionContext = CreateFunctionContext; CreateFunctionContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; CreateFunctionContext.prototype.FUNCTION = function() { - return this.getToken(SqlBaseParser.FUNCTION, 0); + return this.getToken(SparkSqlParser.FUNCTION, 0); }; CreateFunctionContext.prototype.multipartIdentifier = function() { @@ -5029,39 +5029,39 @@ CreateFunctionContext.prototype.multipartIdentifier = function() { }; CreateFunctionContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; CreateFunctionContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; CreateFunctionContext.prototype.OR = function() { - return this.getToken(SqlBaseParser.OR, 0); + return this.getToken(SparkSqlParser.OR, 0); }; CreateFunctionContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; CreateFunctionContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; CreateFunctionContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; CreateFunctionContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; CreateFunctionContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; CreateFunctionContext.prototype.USING = function() { - return this.getToken(SqlBaseParser.USING, 0); + return this.getToken(SparkSqlParser.USING, 0); }; CreateFunctionContext.prototype.resource = function(i) { @@ -5075,19 +5075,19 @@ CreateFunctionContext.prototype.resource = function(i) { } }; CreateFunctionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateFunction(this); } }; CreateFunctionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateFunction(this); } }; CreateFunctionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateFunction(this); } else { return visitor.visitChildren(this); @@ -5106,26 +5106,26 @@ function ShowTableContext(parser, ctx) { ShowTableContext.prototype = Object.create(StatementContext.prototype); ShowTableContext.prototype.constructor = ShowTableContext; -SqlBaseParser.ShowTableContext = ShowTableContext; +SparkSqlParser.ShowTableContext = ShowTableContext; ShowTableContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; ShowTableContext.prototype.EXTENDED = function() { - return this.getToken(SqlBaseParser.EXTENDED, 0); + return this.getToken(SparkSqlParser.EXTENDED, 0); }; ShowTableContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; ShowTableContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; ShowTableContext.prototype.partitionSpec = function() { @@ -5133,30 +5133,30 @@ ShowTableContext.prototype.partitionSpec = function() { }; ShowTableContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; ShowTableContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; ShowTableContext.prototype.multipartIdentifier = function() { return this.getTypedRuleContext(MultipartIdentifierContext,0); }; ShowTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowTable(this); } }; ShowTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowTable(this); } }; ShowTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowTable(this); } else { return visitor.visitChildren(this); @@ -5175,22 +5175,22 @@ function HiveReplaceColumnsContext(parser, ctx) { HiveReplaceColumnsContext.prototype = Object.create(StatementContext.prototype); HiveReplaceColumnsContext.prototype.constructor = HiveReplaceColumnsContext; -SqlBaseParser.HiveReplaceColumnsContext = HiveReplaceColumnsContext; +SparkSqlParser.HiveReplaceColumnsContext = HiveReplaceColumnsContext; HiveReplaceColumnsContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; HiveReplaceColumnsContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; HiveReplaceColumnsContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; HiveReplaceColumnsContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; HiveReplaceColumnsContext.prototype.multipartIdentifier = function() { @@ -5205,19 +5205,19 @@ HiveReplaceColumnsContext.prototype.partitionSpec = function() { return this.getTypedRuleContext(PartitionSpecContext,0); }; HiveReplaceColumnsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterHiveReplaceColumns(this); } }; HiveReplaceColumnsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitHiveReplaceColumns(this); } }; HiveReplaceColumnsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitHiveReplaceColumns(this); } else { return visitor.visitChildren(this); @@ -5235,14 +5235,14 @@ function CommentNamespaceContext(parser, ctx) { CommentNamespaceContext.prototype = Object.create(StatementContext.prototype); CommentNamespaceContext.prototype.constructor = CommentNamespaceContext; -SqlBaseParser.CommentNamespaceContext = CommentNamespaceContext; +SparkSqlParser.CommentNamespaceContext = CommentNamespaceContext; CommentNamespaceContext.prototype.COMMENT = function() { - return this.getToken(SqlBaseParser.COMMENT, 0); + return this.getToken(SparkSqlParser.COMMENT, 0); }; CommentNamespaceContext.prototype.ON = function() { - return this.getToken(SqlBaseParser.ON, 0); + return this.getToken(SparkSqlParser.ON, 0); }; CommentNamespaceContext.prototype.namespace = function() { @@ -5254,30 +5254,30 @@ CommentNamespaceContext.prototype.multipartIdentifier = function() { }; CommentNamespaceContext.prototype.IS = function() { - return this.getToken(SqlBaseParser.IS, 0); + return this.getToken(SparkSqlParser.IS, 0); }; CommentNamespaceContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; CommentNamespaceContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; CommentNamespaceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCommentNamespace(this); } }; CommentNamespaceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCommentNamespace(this); } }; CommentNamespaceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCommentNamespace(this); } else { return visitor.visitChildren(this); @@ -5294,29 +5294,29 @@ function ResetQuotedConfigurationContext(parser, ctx) { ResetQuotedConfigurationContext.prototype = Object.create(StatementContext.prototype); ResetQuotedConfigurationContext.prototype.constructor = ResetQuotedConfigurationContext; -SqlBaseParser.ResetQuotedConfigurationContext = ResetQuotedConfigurationContext; +SparkSqlParser.ResetQuotedConfigurationContext = ResetQuotedConfigurationContext; ResetQuotedConfigurationContext.prototype.RESET = function() { - return this.getToken(SqlBaseParser.RESET, 0); + return this.getToken(SparkSqlParser.RESET, 0); }; ResetQuotedConfigurationContext.prototype.configKey = function() { return this.getTypedRuleContext(ConfigKeyContext,0); }; ResetQuotedConfigurationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterResetQuotedConfiguration(this); } }; ResetQuotedConfigurationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitResetQuotedConfiguration(this); } }; ResetQuotedConfigurationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitResetQuotedConfiguration(this); } else { return visitor.visitChildren(this); @@ -5333,7 +5333,7 @@ function CreateTableContext(parser, ctx) { CreateTableContext.prototype = Object.create(StatementContext.prototype); CreateTableContext.prototype.constructor = CreateTableContext; -SqlBaseParser.CreateTableContext = CreateTableContext; +SparkSqlParser.CreateTableContext = CreateTableContext; CreateTableContext.prototype.createTableHeader = function() { return this.getTypedRuleContext(CreateTableHeaderContext,0); @@ -5356,22 +5356,22 @@ CreateTableContext.prototype.query = function() { }; CreateTableContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; CreateTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateTable(this); } }; CreateTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateTable(this); } }; CreateTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateTable(this); } else { return visitor.visitChildren(this); @@ -5388,7 +5388,7 @@ function DmlStatementContext(parser, ctx) { DmlStatementContext.prototype = Object.create(StatementContext.prototype); DmlStatementContext.prototype.constructor = DmlStatementContext; -SqlBaseParser.DmlStatementContext = DmlStatementContext; +SparkSqlParser.DmlStatementContext = DmlStatementContext; DmlStatementContext.prototype.dmlStatementNoWith = function() { return this.getTypedRuleContext(DmlStatementNoWithContext,0); @@ -5398,19 +5398,19 @@ DmlStatementContext.prototype.ctes = function() { return this.getTypedRuleContext(CtesContext,0); }; DmlStatementContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDmlStatement(this); } }; DmlStatementContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDmlStatement(this); } }; DmlStatementContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDmlStatement(this); } else { return visitor.visitChildren(this); @@ -5430,18 +5430,18 @@ function CreateTableLikeContext(parser, ctx) { CreateTableLikeContext.prototype = Object.create(StatementContext.prototype); CreateTableLikeContext.prototype.constructor = CreateTableLikeContext; -SqlBaseParser.CreateTableLikeContext = CreateTableLikeContext; +SparkSqlParser.CreateTableLikeContext = CreateTableLikeContext; CreateTableLikeContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; CreateTableLikeContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; CreateTableLikeContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; CreateTableLikeContext.prototype.tableIdentifier = function(i) { @@ -5456,15 +5456,15 @@ CreateTableLikeContext.prototype.tableIdentifier = function(i) { }; CreateTableLikeContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; CreateTableLikeContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; CreateTableLikeContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; CreateTableLikeContext.prototype.tableProvider = function(i) { @@ -5516,9 +5516,9 @@ CreateTableLikeContext.prototype.TBLPROPERTIES = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.TBLPROPERTIES); + return this.getTokens(SparkSqlParser.TBLPROPERTIES); } else { - return this.getToken(SqlBaseParser.TBLPROPERTIES, i); + return this.getToken(SparkSqlParser.TBLPROPERTIES, i); } }; @@ -5534,19 +5534,19 @@ CreateTableLikeContext.prototype.tablePropertyList = function(i) { } }; CreateTableLikeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateTableLike(this); } }; CreateTableLikeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateTableLike(this); } }; CreateTableLikeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateTableLike(this); } else { return visitor.visitChildren(this); @@ -5563,14 +5563,14 @@ function UncacheTableContext(parser, ctx) { UncacheTableContext.prototype = Object.create(StatementContext.prototype); UncacheTableContext.prototype.constructor = UncacheTableContext; -SqlBaseParser.UncacheTableContext = UncacheTableContext; +SparkSqlParser.UncacheTableContext = UncacheTableContext; UncacheTableContext.prototype.UNCACHE = function() { - return this.getToken(SqlBaseParser.UNCACHE, 0); + return this.getToken(SparkSqlParser.UNCACHE, 0); }; UncacheTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; UncacheTableContext.prototype.multipartIdentifier = function() { @@ -5578,26 +5578,26 @@ UncacheTableContext.prototype.multipartIdentifier = function() { }; UncacheTableContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; UncacheTableContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; UncacheTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterUncacheTable(this); } }; UncacheTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitUncacheTable(this); } }; UncacheTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitUncacheTable(this); } else { return visitor.visitChildren(this); @@ -5614,14 +5614,14 @@ function DropFunctionContext(parser, ctx) { DropFunctionContext.prototype = Object.create(StatementContext.prototype); DropFunctionContext.prototype.constructor = DropFunctionContext; -SqlBaseParser.DropFunctionContext = DropFunctionContext; +SparkSqlParser.DropFunctionContext = DropFunctionContext; DropFunctionContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; DropFunctionContext.prototype.FUNCTION = function() { - return this.getToken(SqlBaseParser.FUNCTION, 0); + return this.getToken(SparkSqlParser.FUNCTION, 0); }; DropFunctionContext.prototype.multipartIdentifier = function() { @@ -5629,30 +5629,30 @@ DropFunctionContext.prototype.multipartIdentifier = function() { }; DropFunctionContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; DropFunctionContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; DropFunctionContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; DropFunctionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDropFunction(this); } }; DropFunctionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDropFunction(this); } }; DropFunctionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDropFunction(this); } else { return visitor.visitChildren(this); @@ -5670,22 +5670,22 @@ function DescribeRelationContext(parser, ctx) { DescribeRelationContext.prototype = Object.create(StatementContext.prototype); DescribeRelationContext.prototype.constructor = DescribeRelationContext; -SqlBaseParser.DescribeRelationContext = DescribeRelationContext; +SparkSqlParser.DescribeRelationContext = DescribeRelationContext; DescribeRelationContext.prototype.multipartIdentifier = function() { return this.getTypedRuleContext(MultipartIdentifierContext,0); }; DescribeRelationContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; DescribeRelationContext.prototype.DESCRIBE = function() { - return this.getToken(SqlBaseParser.DESCRIBE, 0); + return this.getToken(SparkSqlParser.DESCRIBE, 0); }; DescribeRelationContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; DescribeRelationContext.prototype.partitionSpec = function() { @@ -5697,26 +5697,26 @@ DescribeRelationContext.prototype.describeColName = function() { }; DescribeRelationContext.prototype.EXTENDED = function() { - return this.getToken(SqlBaseParser.EXTENDED, 0); + return this.getToken(SparkSqlParser.EXTENDED, 0); }; DescribeRelationContext.prototype.FORMATTED = function() { - return this.getToken(SqlBaseParser.FORMATTED, 0); + return this.getToken(SparkSqlParser.FORMATTED, 0); }; DescribeRelationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDescribeRelation(this); } }; DescribeRelationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDescribeRelation(this); } }; DescribeRelationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDescribeRelation(this); } else { return visitor.visitChildren(this); @@ -5734,26 +5734,26 @@ function LoadDataContext(parser, ctx) { LoadDataContext.prototype = Object.create(StatementContext.prototype); LoadDataContext.prototype.constructor = LoadDataContext; -SqlBaseParser.LoadDataContext = LoadDataContext; +SparkSqlParser.LoadDataContext = LoadDataContext; LoadDataContext.prototype.LOAD = function() { - return this.getToken(SqlBaseParser.LOAD, 0); + return this.getToken(SparkSqlParser.LOAD, 0); }; LoadDataContext.prototype.DATA = function() { - return this.getToken(SqlBaseParser.DATA, 0); + return this.getToken(SparkSqlParser.DATA, 0); }; LoadDataContext.prototype.INPATH = function() { - return this.getToken(SqlBaseParser.INPATH, 0); + return this.getToken(SparkSqlParser.INPATH, 0); }; LoadDataContext.prototype.INTO = function() { - return this.getToken(SqlBaseParser.INTO, 0); + return this.getToken(SparkSqlParser.INTO, 0); }; LoadDataContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; LoadDataContext.prototype.multipartIdentifier = function() { @@ -5761,34 +5761,34 @@ LoadDataContext.prototype.multipartIdentifier = function() { }; LoadDataContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; LoadDataContext.prototype.LOCAL = function() { - return this.getToken(SqlBaseParser.LOCAL, 0); + return this.getToken(SparkSqlParser.LOCAL, 0); }; LoadDataContext.prototype.OVERWRITE = function() { - return this.getToken(SqlBaseParser.OVERWRITE, 0); + return this.getToken(SparkSqlParser.OVERWRITE, 0); }; LoadDataContext.prototype.partitionSpec = function() { return this.getTypedRuleContext(PartitionSpecContext,0); }; LoadDataContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLoadData(this); } }; LoadDataContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLoadData(this); } }; LoadDataContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLoadData(this); } else { return visitor.visitChildren(this); @@ -5805,14 +5805,14 @@ function ShowPartitionsContext(parser, ctx) { ShowPartitionsContext.prototype = Object.create(StatementContext.prototype); ShowPartitionsContext.prototype.constructor = ShowPartitionsContext; -SqlBaseParser.ShowPartitionsContext = ShowPartitionsContext; +SparkSqlParser.ShowPartitionsContext = ShowPartitionsContext; ShowPartitionsContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowPartitionsContext.prototype.PARTITIONS = function() { - return this.getToken(SqlBaseParser.PARTITIONS, 0); + return this.getToken(SparkSqlParser.PARTITIONS, 0); }; ShowPartitionsContext.prototype.multipartIdentifier = function() { @@ -5823,19 +5823,19 @@ ShowPartitionsContext.prototype.partitionSpec = function() { return this.getTypedRuleContext(PartitionSpecContext,0); }; ShowPartitionsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowPartitions(this); } }; ShowPartitionsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowPartitions(this); } }; ShowPartitionsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowPartitions(this); } else { return visitor.visitChildren(this); @@ -5852,10 +5852,10 @@ function DescribeFunctionContext(parser, ctx) { DescribeFunctionContext.prototype = Object.create(StatementContext.prototype); DescribeFunctionContext.prototype.constructor = DescribeFunctionContext; -SqlBaseParser.DescribeFunctionContext = DescribeFunctionContext; +SparkSqlParser.DescribeFunctionContext = DescribeFunctionContext; DescribeFunctionContext.prototype.FUNCTION = function() { - return this.getToken(SqlBaseParser.FUNCTION, 0); + return this.getToken(SparkSqlParser.FUNCTION, 0); }; DescribeFunctionContext.prototype.describeFuncName = function() { @@ -5863,30 +5863,30 @@ DescribeFunctionContext.prototype.describeFuncName = function() { }; DescribeFunctionContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; DescribeFunctionContext.prototype.DESCRIBE = function() { - return this.getToken(SqlBaseParser.DESCRIBE, 0); + return this.getToken(SparkSqlParser.DESCRIBE, 0); }; DescribeFunctionContext.prototype.EXTENDED = function() { - return this.getToken(SqlBaseParser.EXTENDED, 0); + return this.getToken(SparkSqlParser.EXTENDED, 0); }; DescribeFunctionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDescribeFunction(this); } }; DescribeFunctionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDescribeFunction(this); } }; DescribeFunctionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDescribeFunction(this); } else { return visitor.visitChildren(this); @@ -5906,26 +5906,26 @@ function RenameTableColumnContext(parser, ctx) { RenameTableColumnContext.prototype = Object.create(StatementContext.prototype); RenameTableColumnContext.prototype.constructor = RenameTableColumnContext; -SqlBaseParser.RenameTableColumnContext = RenameTableColumnContext; +SparkSqlParser.RenameTableColumnContext = RenameTableColumnContext; RenameTableColumnContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; RenameTableColumnContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; RenameTableColumnContext.prototype.RENAME = function() { - return this.getToken(SqlBaseParser.RENAME, 0); + return this.getToken(SparkSqlParser.RENAME, 0); }; RenameTableColumnContext.prototype.COLUMN = function() { - return this.getToken(SqlBaseParser.COLUMN, 0); + return this.getToken(SparkSqlParser.COLUMN, 0); }; RenameTableColumnContext.prototype.TO = function() { - return this.getToken(SqlBaseParser.TO, 0); + return this.getToken(SparkSqlParser.TO, 0); }; RenameTableColumnContext.prototype.multipartIdentifier = function(i) { @@ -5943,19 +5943,19 @@ RenameTableColumnContext.prototype.errorCapturingIdentifier = function() { return this.getTypedRuleContext(ErrorCapturingIdentifierContext,0); }; RenameTableColumnContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRenameTableColumn(this); } }; RenameTableColumnContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRenameTableColumn(this); } }; RenameTableColumnContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRenameTableColumn(this); } else { return visitor.visitChildren(this); @@ -5972,25 +5972,25 @@ function StatementDefaultContext(parser, ctx) { StatementDefaultContext.prototype = Object.create(StatementContext.prototype); StatementDefaultContext.prototype.constructor = StatementDefaultContext; -SqlBaseParser.StatementDefaultContext = StatementDefaultContext; +SparkSqlParser.StatementDefaultContext = StatementDefaultContext; StatementDefaultContext.prototype.query = function() { return this.getTypedRuleContext(QueryContext,0); }; StatementDefaultContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterStatementDefault(this); } }; StatementDefaultContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitStatementDefault(this); } }; StatementDefaultContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitStatementDefault(this); } else { return visitor.visitChildren(this); @@ -6009,18 +6009,18 @@ function HiveChangeColumnContext(parser, ctx) { HiveChangeColumnContext.prototype = Object.create(StatementContext.prototype); HiveChangeColumnContext.prototype.constructor = HiveChangeColumnContext; -SqlBaseParser.HiveChangeColumnContext = HiveChangeColumnContext; +SparkSqlParser.HiveChangeColumnContext = HiveChangeColumnContext; HiveChangeColumnContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; HiveChangeColumnContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; HiveChangeColumnContext.prototype.CHANGE = function() { - return this.getToken(SqlBaseParser.CHANGE, 0); + return this.getToken(SparkSqlParser.CHANGE, 0); }; HiveChangeColumnContext.prototype.colType = function() { @@ -6043,26 +6043,26 @@ HiveChangeColumnContext.prototype.partitionSpec = function() { }; HiveChangeColumnContext.prototype.COLUMN = function() { - return this.getToken(SqlBaseParser.COLUMN, 0); + return this.getToken(SparkSqlParser.COLUMN, 0); }; HiveChangeColumnContext.prototype.colPosition = function() { return this.getTypedRuleContext(ColPositionContext,0); }; HiveChangeColumnContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterHiveChangeColumn(this); } }; HiveChangeColumnContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitHiveChangeColumn(this); } }; HiveChangeColumnContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitHiveChangeColumn(this); } else { return visitor.visitChildren(this); @@ -6080,18 +6080,18 @@ function SetTimeZoneContext(parser, ctx) { SetTimeZoneContext.prototype = Object.create(StatementContext.prototype); SetTimeZoneContext.prototype.constructor = SetTimeZoneContext; -SqlBaseParser.SetTimeZoneContext = SetTimeZoneContext; +SparkSqlParser.SetTimeZoneContext = SetTimeZoneContext; SetTimeZoneContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetTimeZoneContext.prototype.TIME = function() { - return this.getToken(SqlBaseParser.TIME, 0); + return this.getToken(SparkSqlParser.TIME, 0); }; SetTimeZoneContext.prototype.ZONE = function() { - return this.getToken(SqlBaseParser.ZONE, 0); + return this.getToken(SparkSqlParser.ZONE, 0); }; SetTimeZoneContext.prototype.interval = function() { @@ -6099,26 +6099,26 @@ SetTimeZoneContext.prototype.interval = function() { }; SetTimeZoneContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; SetTimeZoneContext.prototype.LOCAL = function() { - return this.getToken(SqlBaseParser.LOCAL, 0); + return this.getToken(SparkSqlParser.LOCAL, 0); }; SetTimeZoneContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetTimeZone(this); } }; SetTimeZoneContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetTimeZone(this); } }; SetTimeZoneContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetTimeZone(this); } else { return visitor.visitChildren(this); @@ -6135,37 +6135,37 @@ function DescribeQueryContext(parser, ctx) { DescribeQueryContext.prototype = Object.create(StatementContext.prototype); DescribeQueryContext.prototype.constructor = DescribeQueryContext; -SqlBaseParser.DescribeQueryContext = DescribeQueryContext; +SparkSqlParser.DescribeQueryContext = DescribeQueryContext; DescribeQueryContext.prototype.query = function() { return this.getTypedRuleContext(QueryContext,0); }; DescribeQueryContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; DescribeQueryContext.prototype.DESCRIBE = function() { - return this.getToken(SqlBaseParser.DESCRIBE, 0); + return this.getToken(SparkSqlParser.DESCRIBE, 0); }; DescribeQueryContext.prototype.QUERY = function() { - return this.getToken(SqlBaseParser.QUERY, 0); + return this.getToken(SparkSqlParser.QUERY, 0); }; DescribeQueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDescribeQuery(this); } }; DescribeQueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDescribeQuery(this); } }; DescribeQueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDescribeQuery(this); } else { return visitor.visitChildren(this); @@ -6182,14 +6182,14 @@ function TruncateTableContext(parser, ctx) { TruncateTableContext.prototype = Object.create(StatementContext.prototype); TruncateTableContext.prototype.constructor = TruncateTableContext; -SqlBaseParser.TruncateTableContext = TruncateTableContext; +SparkSqlParser.TruncateTableContext = TruncateTableContext; TruncateTableContext.prototype.TRUNCATE = function() { - return this.getToken(SqlBaseParser.TRUNCATE, 0); + return this.getToken(SparkSqlParser.TRUNCATE, 0); }; TruncateTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; TruncateTableContext.prototype.multipartIdentifier = function() { @@ -6200,19 +6200,19 @@ TruncateTableContext.prototype.partitionSpec = function() { return this.getTypedRuleContext(PartitionSpecContext,0); }; TruncateTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTruncateTable(this); } }; TruncateTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTruncateTable(this); } }; TruncateTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTruncateTable(this); } else { return visitor.visitChildren(this); @@ -6229,14 +6229,14 @@ function SetTableSerDeContext(parser, ctx) { SetTableSerDeContext.prototype = Object.create(StatementContext.prototype); SetTableSerDeContext.prototype.constructor = SetTableSerDeContext; -SqlBaseParser.SetTableSerDeContext = SetTableSerDeContext; +SparkSqlParser.SetTableSerDeContext = SetTableSerDeContext; SetTableSerDeContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; SetTableSerDeContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; SetTableSerDeContext.prototype.multipartIdentifier = function() { @@ -6244,15 +6244,15 @@ SetTableSerDeContext.prototype.multipartIdentifier = function() { }; SetTableSerDeContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetTableSerDeContext.prototype.SERDE = function() { - return this.getToken(SqlBaseParser.SERDE, 0); + return this.getToken(SparkSqlParser.SERDE, 0); }; SetTableSerDeContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; SetTableSerDeContext.prototype.partitionSpec = function() { @@ -6260,30 +6260,30 @@ SetTableSerDeContext.prototype.partitionSpec = function() { }; SetTableSerDeContext.prototype.WITH = function() { - return this.getToken(SqlBaseParser.WITH, 0); + return this.getToken(SparkSqlParser.WITH, 0); }; SetTableSerDeContext.prototype.SERDEPROPERTIES = function() { - return this.getToken(SqlBaseParser.SERDEPROPERTIES, 0); + return this.getToken(SparkSqlParser.SERDEPROPERTIES, 0); }; SetTableSerDeContext.prototype.tablePropertyList = function() { return this.getTypedRuleContext(TablePropertyListContext,0); }; SetTableSerDeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetTableSerDe(this); } }; SetTableSerDeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetTableSerDe(this); } }; SetTableSerDeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetTableSerDe(this); } else { return visitor.visitChildren(this); @@ -6300,14 +6300,14 @@ function CreateViewContext(parser, ctx) { CreateViewContext.prototype = Object.create(StatementContext.prototype); CreateViewContext.prototype.constructor = CreateViewContext; -SqlBaseParser.CreateViewContext = CreateViewContext; +SparkSqlParser.CreateViewContext = CreateViewContext; CreateViewContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; CreateViewContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; CreateViewContext.prototype.multipartIdentifier = function() { @@ -6315,7 +6315,7 @@ CreateViewContext.prototype.multipartIdentifier = function() { }; CreateViewContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; CreateViewContext.prototype.query = function() { @@ -6323,27 +6323,27 @@ CreateViewContext.prototype.query = function() { }; CreateViewContext.prototype.OR = function() { - return this.getToken(SqlBaseParser.OR, 0); + return this.getToken(SparkSqlParser.OR, 0); }; CreateViewContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; CreateViewContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; CreateViewContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; CreateViewContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; CreateViewContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; CreateViewContext.prototype.identifierCommentList = function() { @@ -6366,9 +6366,9 @@ CreateViewContext.prototype.PARTITIONED = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.PARTITIONED); + return this.getTokens(SparkSqlParser.PARTITIONED); } else { - return this.getToken(SqlBaseParser.PARTITIONED, i); + return this.getToken(SparkSqlParser.PARTITIONED, i); } }; @@ -6378,9 +6378,9 @@ CreateViewContext.prototype.ON = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.ON); + return this.getTokens(SparkSqlParser.ON); } else { - return this.getToken(SqlBaseParser.ON, i); + return this.getToken(SparkSqlParser.ON, i); } }; @@ -6401,9 +6401,9 @@ CreateViewContext.prototype.TBLPROPERTIES = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.TBLPROPERTIES); + return this.getTokens(SparkSqlParser.TBLPROPERTIES); } else { - return this.getToken(SqlBaseParser.TBLPROPERTIES, i); + return this.getToken(SparkSqlParser.TBLPROPERTIES, i); } }; @@ -6420,22 +6420,22 @@ CreateViewContext.prototype.tablePropertyList = function(i) { }; CreateViewContext.prototype.GLOBAL = function() { - return this.getToken(SqlBaseParser.GLOBAL, 0); + return this.getToken(SparkSqlParser.GLOBAL, 0); }; CreateViewContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateView(this); } }; CreateViewContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateView(this); } }; CreateViewContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateView(this); } else { return visitor.visitChildren(this); @@ -6452,10 +6452,10 @@ function DropTablePartitionsContext(parser, ctx) { DropTablePartitionsContext.prototype = Object.create(StatementContext.prototype); DropTablePartitionsContext.prototype.constructor = DropTablePartitionsContext; -SqlBaseParser.DropTablePartitionsContext = DropTablePartitionsContext; +SparkSqlParser.DropTablePartitionsContext = DropTablePartitionsContext; DropTablePartitionsContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; DropTablePartitionsContext.prototype.multipartIdentifier = function() { @@ -6463,7 +6463,7 @@ DropTablePartitionsContext.prototype.multipartIdentifier = function() { }; DropTablePartitionsContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; DropTablePartitionsContext.prototype.partitionSpec = function(i) { @@ -6478,38 +6478,38 @@ DropTablePartitionsContext.prototype.partitionSpec = function(i) { }; DropTablePartitionsContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; DropTablePartitionsContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; DropTablePartitionsContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; DropTablePartitionsContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; DropTablePartitionsContext.prototype.PURGE = function() { - return this.getToken(SqlBaseParser.PURGE, 0); + return this.getToken(SparkSqlParser.PURGE, 0); }; DropTablePartitionsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDropTablePartitions(this); } }; DropTablePartitionsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDropTablePartitions(this); } }; DropTablePartitionsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDropTablePartitions(this); } else { return visitor.visitChildren(this); @@ -6526,25 +6526,25 @@ function SetConfigurationContext(parser, ctx) { SetConfigurationContext.prototype = Object.create(StatementContext.prototype); SetConfigurationContext.prototype.constructor = SetConfigurationContext; -SqlBaseParser.SetConfigurationContext = SetConfigurationContext; +SparkSqlParser.SetConfigurationContext = SetConfigurationContext; SetConfigurationContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetConfigurationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetConfiguration(this); } }; SetConfigurationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetConfiguration(this); } }; SetConfigurationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetConfiguration(this); } else { return visitor.visitChildren(this); @@ -6561,14 +6561,14 @@ function DropTableContext(parser, ctx) { DropTableContext.prototype = Object.create(StatementContext.prototype); DropTableContext.prototype.constructor = DropTableContext; -SqlBaseParser.DropTableContext = DropTableContext; +SparkSqlParser.DropTableContext = DropTableContext; DropTableContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; DropTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; DropTableContext.prototype.multipartIdentifier = function() { @@ -6576,30 +6576,30 @@ DropTableContext.prototype.multipartIdentifier = function() { }; DropTableContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; DropTableContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; DropTableContext.prototype.PURGE = function() { - return this.getToken(SqlBaseParser.PURGE, 0); + return this.getToken(SparkSqlParser.PURGE, 0); }; DropTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDropTable(this); } }; DropTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDropTable(this); } }; DropTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDropTable(this); } else { return visitor.visitChildren(this); @@ -6616,7 +6616,7 @@ function DescribeNamespaceContext(parser, ctx) { DescribeNamespaceContext.prototype = Object.create(StatementContext.prototype); DescribeNamespaceContext.prototype.constructor = DescribeNamespaceContext; -SqlBaseParser.DescribeNamespaceContext = DescribeNamespaceContext; +SparkSqlParser.DescribeNamespaceContext = DescribeNamespaceContext; DescribeNamespaceContext.prototype.namespace = function() { return this.getTypedRuleContext(NamespaceContext,0); @@ -6627,30 +6627,30 @@ DescribeNamespaceContext.prototype.multipartIdentifier = function() { }; DescribeNamespaceContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; DescribeNamespaceContext.prototype.DESCRIBE = function() { - return this.getToken(SqlBaseParser.DESCRIBE, 0); + return this.getToken(SparkSqlParser.DESCRIBE, 0); }; DescribeNamespaceContext.prototype.EXTENDED = function() { - return this.getToken(SqlBaseParser.EXTENDED, 0); + return this.getToken(SparkSqlParser.EXTENDED, 0); }; DescribeNamespaceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDescribeNamespace(this); } }; DescribeNamespaceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDescribeNamespace(this); } }; DescribeNamespaceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDescribeNamespace(this); } else { return visitor.visitChildren(this); @@ -6669,22 +6669,22 @@ function AlterTableAlterColumnContext(parser, ctx) { AlterTableAlterColumnContext.prototype = Object.create(StatementContext.prototype); AlterTableAlterColumnContext.prototype.constructor = AlterTableAlterColumnContext; -SqlBaseParser.AlterTableAlterColumnContext = AlterTableAlterColumnContext; +SparkSqlParser.AlterTableAlterColumnContext = AlterTableAlterColumnContext; AlterTableAlterColumnContext.prototype.ALTER = function(i) { if(i===undefined) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.ALTER); + return this.getTokens(SparkSqlParser.ALTER); } else { - return this.getToken(SqlBaseParser.ALTER, i); + return this.getToken(SparkSqlParser.ALTER, i); } }; AlterTableAlterColumnContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; AlterTableAlterColumnContext.prototype.multipartIdentifier = function(i) { @@ -6699,30 +6699,30 @@ AlterTableAlterColumnContext.prototype.multipartIdentifier = function(i) { }; AlterTableAlterColumnContext.prototype.CHANGE = function() { - return this.getToken(SqlBaseParser.CHANGE, 0); + return this.getToken(SparkSqlParser.CHANGE, 0); }; AlterTableAlterColumnContext.prototype.COLUMN = function() { - return this.getToken(SqlBaseParser.COLUMN, 0); + return this.getToken(SparkSqlParser.COLUMN, 0); }; AlterTableAlterColumnContext.prototype.alterColumnAction = function() { return this.getTypedRuleContext(AlterColumnActionContext,0); }; AlterTableAlterColumnContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAlterTableAlterColumn(this); } }; AlterTableAlterColumnContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAlterTableAlterColumn(this); } }; AlterTableAlterColumnContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAlterTableAlterColumn(this); } else { return visitor.visitChildren(this); @@ -6739,33 +6739,33 @@ function RefreshFunctionContext(parser, ctx) { RefreshFunctionContext.prototype = Object.create(StatementContext.prototype); RefreshFunctionContext.prototype.constructor = RefreshFunctionContext; -SqlBaseParser.RefreshFunctionContext = RefreshFunctionContext; +SparkSqlParser.RefreshFunctionContext = RefreshFunctionContext; RefreshFunctionContext.prototype.REFRESH = function() { - return this.getToken(SqlBaseParser.REFRESH, 0); + return this.getToken(SparkSqlParser.REFRESH, 0); }; RefreshFunctionContext.prototype.FUNCTION = function() { - return this.getToken(SqlBaseParser.FUNCTION, 0); + return this.getToken(SparkSqlParser.FUNCTION, 0); }; RefreshFunctionContext.prototype.multipartIdentifier = function() { return this.getTypedRuleContext(MultipartIdentifierContext,0); }; RefreshFunctionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRefreshFunction(this); } }; RefreshFunctionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRefreshFunction(this); } }; RefreshFunctionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRefreshFunction(this); } else { return visitor.visitChildren(this); @@ -6783,18 +6783,18 @@ function CommentTableContext(parser, ctx) { CommentTableContext.prototype = Object.create(StatementContext.prototype); CommentTableContext.prototype.constructor = CommentTableContext; -SqlBaseParser.CommentTableContext = CommentTableContext; +SparkSqlParser.CommentTableContext = CommentTableContext; CommentTableContext.prototype.COMMENT = function() { - return this.getToken(SqlBaseParser.COMMENT, 0); + return this.getToken(SparkSqlParser.COMMENT, 0); }; CommentTableContext.prototype.ON = function() { - return this.getToken(SqlBaseParser.ON, 0); + return this.getToken(SparkSqlParser.ON, 0); }; CommentTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; CommentTableContext.prototype.multipartIdentifier = function() { @@ -6802,30 +6802,30 @@ CommentTableContext.prototype.multipartIdentifier = function() { }; CommentTableContext.prototype.IS = function() { - return this.getToken(SqlBaseParser.IS, 0); + return this.getToken(SparkSqlParser.IS, 0); }; CommentTableContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; CommentTableContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; CommentTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCommentTable(this); } }; CommentTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCommentTable(this); } }; CommentTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCommentTable(this); } else { return visitor.visitChildren(this); @@ -6842,10 +6842,10 @@ function CreateNamespaceContext(parser, ctx) { CreateNamespaceContext.prototype = Object.create(StatementContext.prototype); CreateNamespaceContext.prototype.constructor = CreateNamespaceContext; -SqlBaseParser.CreateNamespaceContext = CreateNamespaceContext; +SparkSqlParser.CreateNamespaceContext = CreateNamespaceContext; CreateNamespaceContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; CreateNamespaceContext.prototype.namespace = function() { @@ -6857,15 +6857,15 @@ CreateNamespaceContext.prototype.multipartIdentifier = function() { }; CreateNamespaceContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; CreateNamespaceContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; CreateNamespaceContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; CreateNamespaceContext.prototype.commentSpec = function(i) { @@ -6895,9 +6895,9 @@ CreateNamespaceContext.prototype.WITH = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.WITH); + return this.getTokens(SparkSqlParser.WITH); } else { - return this.getToken(SqlBaseParser.WITH, i); + return this.getToken(SparkSqlParser.WITH, i); } }; @@ -6918,9 +6918,9 @@ CreateNamespaceContext.prototype.DBPROPERTIES = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.DBPROPERTIES); + return this.getTokens(SparkSqlParser.DBPROPERTIES); } else { - return this.getToken(SqlBaseParser.DBPROPERTIES, i); + return this.getToken(SparkSqlParser.DBPROPERTIES, i); } }; @@ -6930,26 +6930,26 @@ CreateNamespaceContext.prototype.PROPERTIES = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.PROPERTIES); + return this.getTokens(SparkSqlParser.PROPERTIES); } else { - return this.getToken(SqlBaseParser.PROPERTIES, i); + return this.getToken(SparkSqlParser.PROPERTIES, i); } }; CreateNamespaceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateNamespace(this); } }; CreateNamespaceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateNamespace(this); } }; CreateNamespaceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateNamespace(this); } else { return visitor.visitChildren(this); @@ -6968,14 +6968,14 @@ function ShowTblPropertiesContext(parser, ctx) { ShowTblPropertiesContext.prototype = Object.create(StatementContext.prototype); ShowTblPropertiesContext.prototype.constructor = ShowTblPropertiesContext; -SqlBaseParser.ShowTblPropertiesContext = ShowTblPropertiesContext; +SparkSqlParser.ShowTblPropertiesContext = ShowTblPropertiesContext; ShowTblPropertiesContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowTblPropertiesContext.prototype.TBLPROPERTIES = function() { - return this.getToken(SqlBaseParser.TBLPROPERTIES, 0); + return this.getToken(SparkSqlParser.TBLPROPERTIES, 0); }; ShowTblPropertiesContext.prototype.multipartIdentifier = function() { @@ -6986,19 +6986,19 @@ ShowTblPropertiesContext.prototype.tablePropertyKey = function() { return this.getTypedRuleContext(TablePropertyKeyContext,0); }; ShowTblPropertiesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowTblProperties(this); } }; ShowTblPropertiesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowTblProperties(this); } }; ShowTblPropertiesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowTblProperties(this); } else { return visitor.visitChildren(this); @@ -7015,10 +7015,10 @@ function UnsetTablePropertiesContext(parser, ctx) { UnsetTablePropertiesContext.prototype = Object.create(StatementContext.prototype); UnsetTablePropertiesContext.prototype.constructor = UnsetTablePropertiesContext; -SqlBaseParser.UnsetTablePropertiesContext = UnsetTablePropertiesContext; +SparkSqlParser.UnsetTablePropertiesContext = UnsetTablePropertiesContext; UnsetTablePropertiesContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; UnsetTablePropertiesContext.prototype.multipartIdentifier = function() { @@ -7026,11 +7026,11 @@ UnsetTablePropertiesContext.prototype.multipartIdentifier = function() { }; UnsetTablePropertiesContext.prototype.UNSET = function() { - return this.getToken(SqlBaseParser.UNSET, 0); + return this.getToken(SparkSqlParser.UNSET, 0); }; UnsetTablePropertiesContext.prototype.TBLPROPERTIES = function() { - return this.getToken(SqlBaseParser.TBLPROPERTIES, 0); + return this.getToken(SparkSqlParser.TBLPROPERTIES, 0); }; UnsetTablePropertiesContext.prototype.tablePropertyList = function() { @@ -7038,34 +7038,34 @@ UnsetTablePropertiesContext.prototype.tablePropertyList = function() { }; UnsetTablePropertiesContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; UnsetTablePropertiesContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; UnsetTablePropertiesContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; UnsetTablePropertiesContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; UnsetTablePropertiesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterUnsetTableProperties(this); } }; UnsetTablePropertiesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitUnsetTableProperties(this); } }; UnsetTablePropertiesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitUnsetTableProperties(this); } else { return visitor.visitChildren(this); @@ -7082,14 +7082,14 @@ function SetTableLocationContext(parser, ctx) { SetTableLocationContext.prototype = Object.create(StatementContext.prototype); SetTableLocationContext.prototype.constructor = SetTableLocationContext; -SqlBaseParser.SetTableLocationContext = SetTableLocationContext; +SparkSqlParser.SetTableLocationContext = SetTableLocationContext; SetTableLocationContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; SetTableLocationContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; SetTableLocationContext.prototype.multipartIdentifier = function() { @@ -7097,7 +7097,7 @@ SetTableLocationContext.prototype.multipartIdentifier = function() { }; SetTableLocationContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetTableLocationContext.prototype.locationSpec = function() { @@ -7108,19 +7108,19 @@ SetTableLocationContext.prototype.partitionSpec = function() { return this.getTypedRuleContext(PartitionSpecContext,0); }; SetTableLocationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetTableLocation(this); } }; SetTableLocationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetTableLocation(this); } }; SetTableLocationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetTableLocation(this); } else { return visitor.visitChildren(this); @@ -7138,14 +7138,14 @@ function DropTableColumnsContext(parser, ctx) { DropTableColumnsContext.prototype = Object.create(StatementContext.prototype); DropTableColumnsContext.prototype.constructor = DropTableColumnsContext; -SqlBaseParser.DropTableColumnsContext = DropTableColumnsContext; +SparkSqlParser.DropTableColumnsContext = DropTableColumnsContext; DropTableColumnsContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; DropTableColumnsContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; DropTableColumnsContext.prototype.multipartIdentifier = function() { @@ -7153,34 +7153,34 @@ DropTableColumnsContext.prototype.multipartIdentifier = function() { }; DropTableColumnsContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; DropTableColumnsContext.prototype.COLUMN = function() { - return this.getToken(SqlBaseParser.COLUMN, 0); + return this.getToken(SparkSqlParser.COLUMN, 0); }; DropTableColumnsContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; DropTableColumnsContext.prototype.multipartIdentifierList = function() { return this.getTypedRuleContext(MultipartIdentifierListContext,0); }; DropTableColumnsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDropTableColumns(this); } }; DropTableColumnsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDropTableColumns(this); } }; DropTableColumnsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDropTableColumns(this); } else { return visitor.visitChildren(this); @@ -7198,14 +7198,14 @@ function ShowViewsContext(parser, ctx) { ShowViewsContext.prototype = Object.create(StatementContext.prototype); ShowViewsContext.prototype.constructor = ShowViewsContext; -SqlBaseParser.ShowViewsContext = ShowViewsContext; +SparkSqlParser.ShowViewsContext = ShowViewsContext; ShowViewsContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowViewsContext.prototype.VIEWS = function() { - return this.getToken(SqlBaseParser.VIEWS, 0); + return this.getToken(SparkSqlParser.VIEWS, 0); }; ShowViewsContext.prototype.multipartIdentifier = function() { @@ -7213,34 +7213,34 @@ ShowViewsContext.prototype.multipartIdentifier = function() { }; ShowViewsContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; ShowViewsContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; ShowViewsContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; ShowViewsContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; ShowViewsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowViews(this); } }; ShowViewsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowViews(this); } }; ShowViewsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowViews(this); } else { return visitor.visitChildren(this); @@ -7258,14 +7258,14 @@ function ShowFunctionsContext(parser, ctx) { ShowFunctionsContext.prototype = Object.create(StatementContext.prototype); ShowFunctionsContext.prototype.constructor = ShowFunctionsContext; -SqlBaseParser.ShowFunctionsContext = ShowFunctionsContext; +SparkSqlParser.ShowFunctionsContext = ShowFunctionsContext; ShowFunctionsContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; ShowFunctionsContext.prototype.FUNCTIONS = function() { - return this.getToken(SqlBaseParser.FUNCTIONS, 0); + return this.getToken(SparkSqlParser.FUNCTIONS, 0); }; ShowFunctionsContext.prototype.identifier = function() { @@ -7277,26 +7277,26 @@ ShowFunctionsContext.prototype.multipartIdentifier = function() { }; ShowFunctionsContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; ShowFunctionsContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; ShowFunctionsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterShowFunctions(this); } }; ShowFunctionsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitShowFunctions(this); } }; ShowFunctionsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitShowFunctions(this); } else { return visitor.visitChildren(this); @@ -7313,14 +7313,14 @@ function CacheTableContext(parser, ctx) { CacheTableContext.prototype = Object.create(StatementContext.prototype); CacheTableContext.prototype.constructor = CacheTableContext; -SqlBaseParser.CacheTableContext = CacheTableContext; +SparkSqlParser.CacheTableContext = CacheTableContext; CacheTableContext.prototype.CACHE = function() { - return this.getToken(SqlBaseParser.CACHE, 0); + return this.getToken(SparkSqlParser.CACHE, 0); }; CacheTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; CacheTableContext.prototype.multipartIdentifier = function() { @@ -7328,11 +7328,11 @@ CacheTableContext.prototype.multipartIdentifier = function() { }; CacheTableContext.prototype.LAZY = function() { - return this.getToken(SqlBaseParser.LAZY, 0); + return this.getToken(SparkSqlParser.LAZY, 0); }; CacheTableContext.prototype.OPTIONS = function() { - return this.getToken(SqlBaseParser.OPTIONS, 0); + return this.getToken(SparkSqlParser.OPTIONS, 0); }; CacheTableContext.prototype.tablePropertyList = function() { @@ -7344,22 +7344,22 @@ CacheTableContext.prototype.query = function() { }; CacheTableContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; CacheTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCacheTable(this); } }; CacheTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCacheTable(this); } }; CacheTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCacheTable(this); } else { return visitor.visitChildren(this); @@ -7377,14 +7377,14 @@ function AddTableColumnsContext(parser, ctx) { AddTableColumnsContext.prototype = Object.create(StatementContext.prototype); AddTableColumnsContext.prototype.constructor = AddTableColumnsContext; -SqlBaseParser.AddTableColumnsContext = AddTableColumnsContext; +SparkSqlParser.AddTableColumnsContext = AddTableColumnsContext; AddTableColumnsContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; AddTableColumnsContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; AddTableColumnsContext.prototype.multipartIdentifier = function() { @@ -7392,34 +7392,34 @@ AddTableColumnsContext.prototype.multipartIdentifier = function() { }; AddTableColumnsContext.prototype.ADD = function() { - return this.getToken(SqlBaseParser.ADD, 0); + return this.getToken(SparkSqlParser.ADD, 0); }; AddTableColumnsContext.prototype.COLUMN = function() { - return this.getToken(SqlBaseParser.COLUMN, 0); + return this.getToken(SparkSqlParser.COLUMN, 0); }; AddTableColumnsContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; AddTableColumnsContext.prototype.qualifiedColTypeWithPositionList = function() { return this.getTypedRuleContext(QualifiedColTypeWithPositionListContext,0); }; AddTableColumnsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAddTableColumns(this); } }; AddTableColumnsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAddTableColumns(this); } }; AddTableColumnsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAddTableColumns(this); } else { return visitor.visitChildren(this); @@ -7436,10 +7436,10 @@ function SetTablePropertiesContext(parser, ctx) { SetTablePropertiesContext.prototype = Object.create(StatementContext.prototype); SetTablePropertiesContext.prototype.constructor = SetTablePropertiesContext; -SqlBaseParser.SetTablePropertiesContext = SetTablePropertiesContext; +SparkSqlParser.SetTablePropertiesContext = SetTablePropertiesContext; SetTablePropertiesContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; SetTablePropertiesContext.prototype.multipartIdentifier = function() { @@ -7447,11 +7447,11 @@ SetTablePropertiesContext.prototype.multipartIdentifier = function() { }; SetTablePropertiesContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetTablePropertiesContext.prototype.TBLPROPERTIES = function() { - return this.getToken(SqlBaseParser.TBLPROPERTIES, 0); + return this.getToken(SparkSqlParser.TBLPROPERTIES, 0); }; SetTablePropertiesContext.prototype.tablePropertyList = function() { @@ -7459,26 +7459,26 @@ SetTablePropertiesContext.prototype.tablePropertyList = function() { }; SetTablePropertiesContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; SetTablePropertiesContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; SetTablePropertiesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetTableProperties(this); } }; SetTablePropertiesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetTableProperties(this); } }; SetTablePropertiesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetTableProperties(this); } else { return visitor.visitChildren(this); @@ -7487,12 +7487,12 @@ SetTablePropertiesContext.prototype.accept = function(visitor) { -SqlBaseParser.StatementContext = StatementContext; +SparkSqlParser.StatementContext = StatementContext; -SqlBaseParser.prototype.statement = function() { +SparkSqlParser.prototype.statement = function() { var localctx = new StatementContext(this, this._ctx, this.state); - this.enterRule(localctx, 14, SqlBaseParser.RULE_statement); + this.enterRule(localctx, 14, SparkSqlParser.RULE_statement); var _la = 0; // Token type try { this.state = 1043; @@ -7512,7 +7512,7 @@ SqlBaseParser.prototype.statement = function() { this.state = 301; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.WITH) { + if(_la===SparkSqlParser.WITH) { this.state = 300; this.ctes(); } @@ -7525,13 +7525,13 @@ SqlBaseParser.prototype.statement = function() { localctx = new UseContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 304; - this.match(SqlBaseParser.USE); + this.match(SparkSqlParser.USE); this.state = 306; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,2,this._ctx); if(la_===1) { this.state = 305; - this.match(SqlBaseParser.NAMESPACE); + this.match(SparkSqlParser.NAMESPACE); } this.state = 308; @@ -7542,7 +7542,7 @@ SqlBaseParser.prototype.statement = function() { localctx = new CreateNamespaceContext(this, localctx); this.enterOuterAlt(localctx, 4); this.state = 309; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 310; this.namespace(); this.state = 314; @@ -7550,11 +7550,11 @@ SqlBaseParser.prototype.statement = function() { var la_ = this._interp.adaptivePredict(this._input,3,this._ctx); if(la_===1) { this.state = 311; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 312; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 313; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 316; @@ -7562,24 +7562,24 @@ SqlBaseParser.prototype.statement = function() { this.state = 324; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.COMMENT || _la===SqlBaseParser.LOCATION || _la===SqlBaseParser.WITH) { + while(_la===SparkSqlParser.COMMENT || _la===SparkSqlParser.LOCATION || _la===SparkSqlParser.WITH) { this.state = 322; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.COMMENT: + case SparkSqlParser.COMMENT: this.state = 317; this.commentSpec(); break; - case SqlBaseParser.LOCATION: + case SparkSqlParser.LOCATION: this.state = 318; this.locationSpec(); break; - case SqlBaseParser.WITH: + case SparkSqlParser.WITH: this.state = 319; - this.match(SqlBaseParser.WITH); + this.match(SparkSqlParser.WITH); this.state = 320; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DBPROPERTIES || _la===SqlBaseParser.PROPERTIES)) { + if(!(_la===SparkSqlParser.DBPROPERTIES || _la===SparkSqlParser.PROPERTIES)) { this._errHandler.recoverInline(this); } else { @@ -7602,16 +7602,16 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetNamespacePropertiesContext(this, localctx); this.enterOuterAlt(localctx, 5); this.state = 327; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 328; this.namespace(); this.state = 329; this.multipartIdentifier(); this.state = 330; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 331; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DBPROPERTIES || _la===SqlBaseParser.PROPERTIES)) { + if(!(_la===SparkSqlParser.DBPROPERTIES || _la===SparkSqlParser.PROPERTIES)) { this._errHandler.recoverInline(this); } else { @@ -7626,13 +7626,13 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetNamespaceLocationContext(this, localctx); this.enterOuterAlt(localctx, 6); this.state = 334; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 335; this.namespace(); this.state = 336; this.multipartIdentifier(); this.state = 337; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 338; this.locationSpec(); break; @@ -7641,7 +7641,7 @@ SqlBaseParser.prototype.statement = function() { localctx = new DropNamespaceContext(this, localctx); this.enterOuterAlt(localctx, 7); this.state = 340; - this.match(SqlBaseParser.DROP); + this.match(SparkSqlParser.DROP); this.state = 341; this.namespace(); this.state = 344; @@ -7649,9 +7649,9 @@ SqlBaseParser.prototype.statement = function() { var la_ = this._interp.adaptivePredict(this._input,6,this._ctx); if(la_===1) { this.state = 342; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 343; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 346; @@ -7659,10 +7659,10 @@ SqlBaseParser.prototype.statement = function() { this.state = 348; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.CASCADE || _la===SqlBaseParser.RESTRICT) { + if(_la===SparkSqlParser.CASCADE || _la===SparkSqlParser.RESTRICT) { this.state = 347; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.CASCADE || _la===SqlBaseParser.RESTRICT)) { + if(!(_la===SparkSqlParser.CASCADE || _la===SparkSqlParser.RESTRICT)) { this._errHandler.recoverInline(this); } else { @@ -7677,10 +7677,10 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowNamespacesContext(this, localctx); this.enterOuterAlt(localctx, 8); this.state = 350; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 351; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DATABASES || _la===SqlBaseParser.NAMESPACES)) { + if(!(_la===SparkSqlParser.DATABASES || _la===SparkSqlParser.NAMESPACES)) { this._errHandler.recoverInline(this); } else { @@ -7690,10 +7690,10 @@ SqlBaseParser.prototype.statement = function() { this.state = 354; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN) { + if(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN) { this.state = 352; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN)) { + if(!(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN)) { this._errHandler.recoverInline(this); } else { @@ -7707,17 +7707,17 @@ SqlBaseParser.prototype.statement = function() { this.state = 360; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LIKE || _la===SqlBaseParser.STRING) { + if(_la===SparkSqlParser.LIKE || _la===SparkSqlParser.STRING) { this.state = 357; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LIKE) { + if(_la===SparkSqlParser.LIKE) { this.state = 356; - this.match(SqlBaseParser.LIKE); + this.match(SparkSqlParser.LIKE); } this.state = 359; - localctx.pattern = this.match(SqlBaseParser.STRING); + localctx.pattern = this.match(SparkSqlParser.STRING); } break; @@ -7730,13 +7730,13 @@ SqlBaseParser.prototype.statement = function() { this.state = 367; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1) { + if(_la===SparkSqlParser.T__1) { this.state = 363; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 364; this.colTypeList(); this.state = 365; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } this.state = 369; @@ -7746,13 +7746,13 @@ SqlBaseParser.prototype.statement = function() { this.state = 375; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1 || _la===SqlBaseParser.AS || _la===SqlBaseParser.FROM || _la===SqlBaseParser.MAP || _la===SqlBaseParser.REDUCE || _la===SqlBaseParser.SELECT || _la===SqlBaseParser.TABLE || _la===SqlBaseParser.VALUES || _la===SqlBaseParser.WITH) { + if(_la===SparkSqlParser.T__1 || _la===SparkSqlParser.AS || _la===SparkSqlParser.FROM || _la===SparkSqlParser.MAP || _la===SparkSqlParser.REDUCE || _la===SparkSqlParser.SELECT || _la===SparkSqlParser.TABLE || _la===SparkSqlParser.VALUES || _la===SparkSqlParser.WITH) { this.state = 372; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AS) { + if(_la===SparkSqlParser.AS) { this.state = 371; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 374; @@ -7771,76 +7771,76 @@ SqlBaseParser.prototype.statement = function() { var la_ = this._interp.adaptivePredict(this._input,14,this._ctx); if(la_===1) { this.state = 378; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 379; localctx.columns = this.colTypeList(); this.state = 380; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } this.state = 405; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.CLUSTERED || _la===SqlBaseParser.COMMENT || _la===SqlBaseParser.LOCATION || _la===SqlBaseParser.PARTITIONED || ((((_la - 199)) & ~0x1f) == 0 && ((1 << (_la - 199)) & ((1 << (SqlBaseParser.ROW - 199)) | (1 << (SqlBaseParser.SKEWED - 199)) | (1 << (SqlBaseParser.STORED - 199)) | (1 << (SqlBaseParser.TBLPROPERTIES - 199)))) !== 0)) { + while(_la===SparkSqlParser.CLUSTERED || _la===SparkSqlParser.COMMENT || _la===SparkSqlParser.LOCATION || _la===SparkSqlParser.PARTITIONED || ((((_la - 199)) & ~0x1f) == 0 && ((1 << (_la - 199)) & ((1 << (SparkSqlParser.ROW - 199)) | (1 << (SparkSqlParser.SKEWED - 199)) | (1 << (SparkSqlParser.STORED - 199)) | (1 << (SparkSqlParser.TBLPROPERTIES - 199)))) !== 0)) { this.state = 403; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.COMMENT: + case SparkSqlParser.COMMENT: this.state = 384; this.commentSpec(); break; - case SqlBaseParser.PARTITIONED: + case SparkSqlParser.PARTITIONED: this.state = 394; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,15,this._ctx); switch(la_) { case 1: this.state = 385; - this.match(SqlBaseParser.PARTITIONED); + this.match(SparkSqlParser.PARTITIONED); this.state = 386; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 387; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 388; localctx.partitionColumns = this.colTypeList(); this.state = 389; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 2: this.state = 391; - this.match(SqlBaseParser.PARTITIONED); + this.match(SparkSqlParser.PARTITIONED); this.state = 392; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 393; localctx.partitionColumnNames = this.identifierList(); break; } break; - case SqlBaseParser.CLUSTERED: + case SparkSqlParser.CLUSTERED: this.state = 396; this.bucketSpec(); break; - case SqlBaseParser.SKEWED: + case SparkSqlParser.SKEWED: this.state = 397; this.skewSpec(); break; - case SqlBaseParser.ROW: + case SparkSqlParser.ROW: this.state = 398; this.rowFormat(); break; - case SqlBaseParser.STORED: + case SparkSqlParser.STORED: this.state = 399; this.createFileFormat(); break; - case SqlBaseParser.LOCATION: + case SparkSqlParser.LOCATION: this.state = 400; this.locationSpec(); break; - case SqlBaseParser.TBLPROPERTIES: + case SparkSqlParser.TBLPROPERTIES: this.state = 401; - this.match(SqlBaseParser.TBLPROPERTIES); + this.match(SparkSqlParser.TBLPROPERTIES); this.state = 402; localctx.tableProps = this.tablePropertyList(); break; @@ -7854,13 +7854,13 @@ SqlBaseParser.prototype.statement = function() { this.state = 412; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1 || _la===SqlBaseParser.AS || _la===SqlBaseParser.FROM || _la===SqlBaseParser.MAP || _la===SqlBaseParser.REDUCE || _la===SqlBaseParser.SELECT || _la===SqlBaseParser.TABLE || _la===SqlBaseParser.VALUES || _la===SqlBaseParser.WITH) { + if(_la===SparkSqlParser.T__1 || _la===SparkSqlParser.AS || _la===SparkSqlParser.FROM || _la===SparkSqlParser.MAP || _la===SparkSqlParser.REDUCE || _la===SparkSqlParser.SELECT || _la===SparkSqlParser.TABLE || _la===SparkSqlParser.VALUES || _la===SparkSqlParser.WITH) { this.state = 409; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AS) { + if(_la===SparkSqlParser.AS) { this.state = 408; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 411; @@ -7873,53 +7873,53 @@ SqlBaseParser.prototype.statement = function() { localctx = new CreateTableLikeContext(this, localctx); this.enterOuterAlt(localctx, 11); this.state = 414; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 415; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 419; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,20,this._ctx); if(la_===1) { this.state = 416; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 417; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 418; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 421; localctx.target = this.tableIdentifier(); this.state = 422; - this.match(SqlBaseParser.LIKE); + this.match(SparkSqlParser.LIKE); this.state = 423; localctx.source = this.tableIdentifier(); this.state = 432; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.LOCATION || ((((_la - 199)) & ~0x1f) == 0 && ((1 << (_la - 199)) & ((1 << (SqlBaseParser.ROW - 199)) | (1 << (SqlBaseParser.STORED - 199)) | (1 << (SqlBaseParser.TBLPROPERTIES - 199)))) !== 0) || _la===SqlBaseParser.USING) { + while(_la===SparkSqlParser.LOCATION || ((((_la - 199)) & ~0x1f) == 0 && ((1 << (_la - 199)) & ((1 << (SparkSqlParser.ROW - 199)) | (1 << (SparkSqlParser.STORED - 199)) | (1 << (SparkSqlParser.TBLPROPERTIES - 199)))) !== 0) || _la===SparkSqlParser.USING) { this.state = 430; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.USING: + case SparkSqlParser.USING: this.state = 424; this.tableProvider(); break; - case SqlBaseParser.ROW: + case SparkSqlParser.ROW: this.state = 425; this.rowFormat(); break; - case SqlBaseParser.STORED: + case SparkSqlParser.STORED: this.state = 426; this.createFileFormat(); break; - case SqlBaseParser.LOCATION: + case SparkSqlParser.LOCATION: this.state = 427; this.locationSpec(); break; - case SqlBaseParser.TBLPROPERTIES: + case SparkSqlParser.TBLPROPERTIES: this.state = 428; - this.match(SqlBaseParser.TBLPROPERTIES); + this.match(SparkSqlParser.TBLPROPERTIES); this.state = 429; localctx.tableProps = this.tablePropertyList(); break; @@ -7940,13 +7940,13 @@ SqlBaseParser.prototype.statement = function() { this.state = 440; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1) { + if(_la===SparkSqlParser.T__1) { this.state = 436; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 437; this.colTypeList(); this.state = 438; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } this.state = 442; @@ -7956,13 +7956,13 @@ SqlBaseParser.prototype.statement = function() { this.state = 448; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1 || _la===SqlBaseParser.AS || _la===SqlBaseParser.FROM || _la===SqlBaseParser.MAP || _la===SqlBaseParser.REDUCE || _la===SqlBaseParser.SELECT || _la===SqlBaseParser.TABLE || _la===SqlBaseParser.VALUES || _la===SqlBaseParser.WITH) { + if(_la===SparkSqlParser.T__1 || _la===SparkSqlParser.AS || _la===SparkSqlParser.FROM || _la===SparkSqlParser.MAP || _la===SparkSqlParser.REDUCE || _la===SparkSqlParser.SELECT || _la===SparkSqlParser.TABLE || _la===SparkSqlParser.VALUES || _la===SparkSqlParser.WITH) { this.state = 445; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AS) { + if(_la===SparkSqlParser.AS) { this.state = 444; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 447; @@ -7975,23 +7975,23 @@ SqlBaseParser.prototype.statement = function() { localctx = new AnalyzeContext(this, localctx); this.enterOuterAlt(localctx, 13); this.state = 450; - this.match(SqlBaseParser.ANALYZE); + this.match(SparkSqlParser.ANALYZE); this.state = 451; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 452; this.multipartIdentifier(); this.state = 454; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 453; this.partitionSpec(); } this.state = 456; - this.match(SqlBaseParser.COMPUTE); + this.match(SparkSqlParser.COMPUTE); this.state = 457; - this.match(SqlBaseParser.STATISTICS); + this.match(SparkSqlParser.STATISTICS); this.state = 465; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,27,this._ctx); @@ -8001,19 +8001,19 @@ SqlBaseParser.prototype.statement = function() { } else if(la_===2) { this.state = 459; - this.match(SqlBaseParser.FOR); + this.match(SparkSqlParser.FOR); this.state = 460; - this.match(SqlBaseParser.COLUMNS); + this.match(SparkSqlParser.COLUMNS); this.state = 461; this.identifierSeq(); } else if(la_===3) { this.state = 462; - this.match(SqlBaseParser.FOR); + this.match(SparkSqlParser.FOR); this.state = 463; - this.match(SqlBaseParser.ALL); + this.match(SparkSqlParser.ALL); this.state = 464; - this.match(SqlBaseParser.COLUMNS); + this.match(SparkSqlParser.COLUMNS); } break; @@ -8022,16 +8022,16 @@ SqlBaseParser.prototype.statement = function() { localctx = new AddTableColumnsContext(this, localctx); this.enterOuterAlt(localctx, 14); this.state = 467; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 468; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 469; this.multipartIdentifier(); this.state = 470; - this.match(SqlBaseParser.ADD); + this.match(SparkSqlParser.ADD); this.state = 471; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.COLUMN || _la===SqlBaseParser.COLUMNS)) { + if(!(_la===SparkSqlParser.COLUMN || _la===SparkSqlParser.COLUMNS)) { this._errHandler.recoverInline(this); } else { @@ -8046,16 +8046,16 @@ SqlBaseParser.prototype.statement = function() { localctx = new AddTableColumnsContext(this, localctx); this.enterOuterAlt(localctx, 15); this.state = 474; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 475; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 476; this.multipartIdentifier(); this.state = 477; - this.match(SqlBaseParser.ADD); + this.match(SparkSqlParser.ADD); this.state = 478; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.COLUMN || _la===SqlBaseParser.COLUMNS)) { + if(!(_la===SparkSqlParser.COLUMN || _la===SparkSqlParser.COLUMNS)) { this._errHandler.recoverInline(this); } else { @@ -8063,30 +8063,30 @@ SqlBaseParser.prototype.statement = function() { this.consume(); } this.state = 479; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 480; localctx.columns = this.qualifiedColTypeWithPositionList(); this.state = 481; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 16: localctx = new RenameTableColumnContext(this, localctx); this.enterOuterAlt(localctx, 16); this.state = 483; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 484; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 485; localctx.table = this.multipartIdentifier(); this.state = 486; - this.match(SqlBaseParser.RENAME); + this.match(SparkSqlParser.RENAME); this.state = 487; - this.match(SqlBaseParser.COLUMN); + this.match(SparkSqlParser.COLUMN); this.state = 488; localctx.from = this.multipartIdentifier(); this.state = 489; - this.match(SqlBaseParser.TO); + this.match(SparkSqlParser.TO); this.state = 490; localctx.to = this.errorCapturingIdentifier(); break; @@ -8095,16 +8095,16 @@ SqlBaseParser.prototype.statement = function() { localctx = new DropTableColumnsContext(this, localctx); this.enterOuterAlt(localctx, 17); this.state = 492; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 493; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 494; this.multipartIdentifier(); this.state = 495; - this.match(SqlBaseParser.DROP); + this.match(SparkSqlParser.DROP); this.state = 496; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.COLUMN || _la===SqlBaseParser.COLUMNS)) { + if(!(_la===SparkSqlParser.COLUMN || _la===SparkSqlParser.COLUMNS)) { this._errHandler.recoverInline(this); } else { @@ -8112,27 +8112,27 @@ SqlBaseParser.prototype.statement = function() { this.consume(); } this.state = 497; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 498; localctx.columns = this.multipartIdentifierList(); this.state = 499; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 18: localctx = new DropTableColumnsContext(this, localctx); this.enterOuterAlt(localctx, 18); this.state = 501; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 502; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 503; this.multipartIdentifier(); this.state = 504; - this.match(SqlBaseParser.DROP); + this.match(SparkSqlParser.DROP); this.state = 505; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.COLUMN || _la===SqlBaseParser.COLUMNS)) { + if(!(_la===SparkSqlParser.COLUMN || _la===SparkSqlParser.COLUMNS)) { this._errHandler.recoverInline(this); } else { @@ -8147,10 +8147,10 @@ SqlBaseParser.prototype.statement = function() { localctx = new RenameTableContext(this, localctx); this.enterOuterAlt(localctx, 19); this.state = 508; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 509; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.TABLE || _la===SqlBaseParser.VIEW)) { + if(!(_la===SparkSqlParser.TABLE || _la===SparkSqlParser.VIEW)) { this._errHandler.recoverInline(this); } else { @@ -8160,9 +8160,9 @@ SqlBaseParser.prototype.statement = function() { this.state = 510; localctx.from = this.multipartIdentifier(); this.state = 511; - this.match(SqlBaseParser.RENAME); + this.match(SparkSqlParser.RENAME); this.state = 512; - this.match(SqlBaseParser.TO); + this.match(SparkSqlParser.TO); this.state = 513; localctx.to = this.multipartIdentifier(); break; @@ -8171,10 +8171,10 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetTablePropertiesContext(this, localctx); this.enterOuterAlt(localctx, 20); this.state = 515; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 516; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.TABLE || _la===SqlBaseParser.VIEW)) { + if(!(_la===SparkSqlParser.TABLE || _la===SparkSqlParser.VIEW)) { this._errHandler.recoverInline(this); } else { @@ -8184,9 +8184,9 @@ SqlBaseParser.prototype.statement = function() { this.state = 517; this.multipartIdentifier(); this.state = 518; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 519; - this.match(SqlBaseParser.TBLPROPERTIES); + this.match(SparkSqlParser.TBLPROPERTIES); this.state = 520; this.tablePropertyList(); break; @@ -8195,10 +8195,10 @@ SqlBaseParser.prototype.statement = function() { localctx = new UnsetTablePropertiesContext(this, localctx); this.enterOuterAlt(localctx, 21); this.state = 522; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 523; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.TABLE || _la===SqlBaseParser.VIEW)) { + if(!(_la===SparkSqlParser.TABLE || _la===SparkSqlParser.VIEW)) { this._errHandler.recoverInline(this); } else { @@ -8208,17 +8208,17 @@ SqlBaseParser.prototype.statement = function() { this.state = 524; this.multipartIdentifier(); this.state = 525; - this.match(SqlBaseParser.UNSET); + this.match(SparkSqlParser.UNSET); this.state = 526; - this.match(SqlBaseParser.TBLPROPERTIES); + this.match(SparkSqlParser.TBLPROPERTIES); this.state = 529; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.IF) { + if(_la===SparkSqlParser.IF) { this.state = 527; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 528; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 531; @@ -8229,14 +8229,14 @@ SqlBaseParser.prototype.statement = function() { localctx = new AlterTableAlterColumnContext(this, localctx); this.enterOuterAlt(localctx, 22); this.state = 533; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 534; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 535; localctx.table = this.multipartIdentifier(); this.state = 536; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ALTER || _la===SqlBaseParser.CHANGE)) { + if(!(_la===SparkSqlParser.ALTER || _la===SparkSqlParser.CHANGE)) { this._errHandler.recoverInline(this); } else { @@ -8248,7 +8248,7 @@ SqlBaseParser.prototype.statement = function() { var la_ = this._interp.adaptivePredict(this._input,29,this._ctx); if(la_===1) { this.state = 537; - this.match(SqlBaseParser.COLUMN); + this.match(SparkSqlParser.COLUMN); } this.state = 540; @@ -8256,7 +8256,7 @@ SqlBaseParser.prototype.statement = function() { this.state = 542; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AFTER || _la===SqlBaseParser.COMMENT || _la===SqlBaseParser.DROP || _la===SqlBaseParser.FIRST || _la===SqlBaseParser.SET || _la===SqlBaseParser.TYPE) { + if(_la===SparkSqlParser.AFTER || _la===SparkSqlParser.COMMENT || _la===SparkSqlParser.DROP || _la===SparkSqlParser.FIRST || _la===SparkSqlParser.SET || _la===SparkSqlParser.TYPE) { this.state = 541; this.alterColumnAction(); } @@ -8267,27 +8267,27 @@ SqlBaseParser.prototype.statement = function() { localctx = new HiveChangeColumnContext(this, localctx); this.enterOuterAlt(localctx, 23); this.state = 544; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 545; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 546; localctx.table = this.multipartIdentifier(); this.state = 548; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 547; this.partitionSpec(); } this.state = 550; - this.match(SqlBaseParser.CHANGE); + this.match(SparkSqlParser.CHANGE); this.state = 552; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,32,this._ctx); if(la_===1) { this.state = 551; - this.match(SqlBaseParser.COLUMN); + this.match(SparkSqlParser.COLUMN); } this.state = 554; @@ -8297,7 +8297,7 @@ SqlBaseParser.prototype.statement = function() { this.state = 557; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AFTER || _la===SqlBaseParser.FIRST) { + if(_la===SparkSqlParser.AFTER || _la===SparkSqlParser.FIRST) { this.state = 556; this.colPosition(); } @@ -8308,62 +8308,62 @@ SqlBaseParser.prototype.statement = function() { localctx = new HiveReplaceColumnsContext(this, localctx); this.enterOuterAlt(localctx, 24); this.state = 559; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 560; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 561; localctx.table = this.multipartIdentifier(); this.state = 563; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 562; this.partitionSpec(); } this.state = 565; - this.match(SqlBaseParser.REPLACE); + this.match(SparkSqlParser.REPLACE); this.state = 566; - this.match(SqlBaseParser.COLUMNS); + this.match(SparkSqlParser.COLUMNS); this.state = 567; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 568; localctx.columns = this.qualifiedColTypeWithPositionList(); this.state = 569; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 25: localctx = new SetTableSerDeContext(this, localctx); this.enterOuterAlt(localctx, 25); this.state = 571; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 572; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 573; this.multipartIdentifier(); this.state = 575; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 574; this.partitionSpec(); } this.state = 577; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 578; - this.match(SqlBaseParser.SERDE); + this.match(SparkSqlParser.SERDE); this.state = 579; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); this.state = 583; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.WITH) { + if(_la===SparkSqlParser.WITH) { this.state = 580; - this.match(SqlBaseParser.WITH); + this.match(SparkSqlParser.WITH); this.state = 581; - this.match(SqlBaseParser.SERDEPROPERTIES); + this.match(SparkSqlParser.SERDEPROPERTIES); this.state = 582; this.tablePropertyList(); } @@ -8374,23 +8374,23 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetTableSerDeContext(this, localctx); this.enterOuterAlt(localctx, 26); this.state = 585; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 586; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 587; this.multipartIdentifier(); this.state = 589; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 588; this.partitionSpec(); } this.state = 591; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 592; - this.match(SqlBaseParser.SERDEPROPERTIES); + this.match(SparkSqlParser.SERDEPROPERTIES); this.state = 593; this.tablePropertyList(); break; @@ -8399,10 +8399,10 @@ SqlBaseParser.prototype.statement = function() { localctx = new AddTablePartitionContext(this, localctx); this.enterOuterAlt(localctx, 27); this.state = 595; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 596; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.TABLE || _la===SqlBaseParser.VIEW)) { + if(!(_la===SparkSqlParser.TABLE || _la===SparkSqlParser.VIEW)) { this._errHandler.recoverInline(this); } else { @@ -8412,17 +8412,17 @@ SqlBaseParser.prototype.statement = function() { this.state = 597; this.multipartIdentifier(); this.state = 598; - this.match(SqlBaseParser.ADD); + this.match(SparkSqlParser.ADD); this.state = 602; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.IF) { + if(_la===SparkSqlParser.IF) { this.state = 599; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 600; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 601; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 605; @@ -8434,24 +8434,24 @@ SqlBaseParser.prototype.statement = function() { this.state = 607; this._errHandler.sync(this); _la = this._input.LA(1); - } while(_la===SqlBaseParser.PARTITION); + } while(_la===SparkSqlParser.PARTITION); break; case 28: localctx = new RenameTablePartitionContext(this, localctx); this.enterOuterAlt(localctx, 28); this.state = 609; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 610; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 611; this.multipartIdentifier(); this.state = 612; localctx.from = this.partitionSpec(); this.state = 613; - this.match(SqlBaseParser.RENAME); + this.match(SparkSqlParser.RENAME); this.state = 614; - this.match(SqlBaseParser.TO); + this.match(SparkSqlParser.TO); this.state = 615; localctx.to = this.partitionSpec(); break; @@ -8460,10 +8460,10 @@ SqlBaseParser.prototype.statement = function() { localctx = new DropTablePartitionsContext(this, localctx); this.enterOuterAlt(localctx, 29); this.state = 617; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 618; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.TABLE || _la===SqlBaseParser.VIEW)) { + if(!(_la===SparkSqlParser.TABLE || _la===SparkSqlParser.VIEW)) { this._errHandler.recoverInline(this); } else { @@ -8473,15 +8473,15 @@ SqlBaseParser.prototype.statement = function() { this.state = 619; this.multipartIdentifier(); this.state = 620; - this.match(SqlBaseParser.DROP); + this.match(SparkSqlParser.DROP); this.state = 623; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.IF) { + if(_la===SparkSqlParser.IF) { this.state = 621; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 622; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 625; @@ -8489,9 +8489,9 @@ SqlBaseParser.prototype.statement = function() { this.state = 630; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 626; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 627; this.partitionSpec(); this.state = 632; @@ -8501,9 +8501,9 @@ SqlBaseParser.prototype.statement = function() { this.state = 634; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PURGE) { + if(_la===SparkSqlParser.PURGE) { this.state = 633; - this.match(SqlBaseParser.PURGE); + this.match(SparkSqlParser.PURGE); } break; @@ -8512,21 +8512,21 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetTableLocationContext(this, localctx); this.enterOuterAlt(localctx, 30); this.state = 636; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 637; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 638; this.multipartIdentifier(); this.state = 640; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 639; this.partitionSpec(); } this.state = 642; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 643; this.locationSpec(); break; @@ -8535,32 +8535,32 @@ SqlBaseParser.prototype.statement = function() { localctx = new RecoverPartitionsContext(this, localctx); this.enterOuterAlt(localctx, 31); this.state = 645; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 646; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 647; this.multipartIdentifier(); this.state = 648; - this.match(SqlBaseParser.RECOVER); + this.match(SparkSqlParser.RECOVER); this.state = 649; - this.match(SqlBaseParser.PARTITIONS); + this.match(SparkSqlParser.PARTITIONS); break; case 32: localctx = new DropTableContext(this, localctx); this.enterOuterAlt(localctx, 32); this.state = 651; - this.match(SqlBaseParser.DROP); + this.match(SparkSqlParser.DROP); this.state = 652; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 655; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,44,this._ctx); if(la_===1) { this.state = 653; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 654; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 657; @@ -8568,9 +8568,9 @@ SqlBaseParser.prototype.statement = function() { this.state = 659; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PURGE) { + if(_la===SparkSqlParser.PURGE) { this.state = 658; - this.match(SqlBaseParser.PURGE); + this.match(SparkSqlParser.PURGE); } break; @@ -8579,17 +8579,17 @@ SqlBaseParser.prototype.statement = function() { localctx = new DropViewContext(this, localctx); this.enterOuterAlt(localctx, 33); this.state = 661; - this.match(SqlBaseParser.DROP); + this.match(SparkSqlParser.DROP); this.state = 662; - this.match(SqlBaseParser.VIEW); + this.match(SparkSqlParser.VIEW); this.state = 665; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,46,this._ctx); if(la_===1) { this.state = 663; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 664; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 667; @@ -8600,45 +8600,45 @@ SqlBaseParser.prototype.statement = function() { localctx = new CreateViewContext(this, localctx); this.enterOuterAlt(localctx, 34); this.state = 668; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 671; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OR) { + if(_la===SparkSqlParser.OR) { this.state = 669; - this.match(SqlBaseParser.OR); + this.match(SparkSqlParser.OR); this.state = 670; - this.match(SqlBaseParser.REPLACE); + this.match(SparkSqlParser.REPLACE); } this.state = 677; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.GLOBAL || _la===SqlBaseParser.TEMPORARY) { + if(_la===SparkSqlParser.GLOBAL || _la===SparkSqlParser.TEMPORARY) { this.state = 674; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.GLOBAL) { + if(_la===SparkSqlParser.GLOBAL) { this.state = 673; - this.match(SqlBaseParser.GLOBAL); + this.match(SparkSqlParser.GLOBAL); } this.state = 676; - this.match(SqlBaseParser.TEMPORARY); + this.match(SparkSqlParser.TEMPORARY); } this.state = 679; - this.match(SqlBaseParser.VIEW); + this.match(SparkSqlParser.VIEW); this.state = 683; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,50,this._ctx); if(la_===1) { this.state = 680; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 681; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 682; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 685; @@ -8646,7 +8646,7 @@ SqlBaseParser.prototype.statement = function() { this.state = 687; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1) { + if(_la===SparkSqlParser.T__1) { this.state = 686; this.identifierCommentList(); } @@ -8654,25 +8654,25 @@ SqlBaseParser.prototype.statement = function() { this.state = 697; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.COMMENT || _la===SqlBaseParser.PARTITIONED || _la===SqlBaseParser.TBLPROPERTIES) { + while(_la===SparkSqlParser.COMMENT || _la===SparkSqlParser.PARTITIONED || _la===SparkSqlParser.TBLPROPERTIES) { this.state = 695; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.COMMENT: + case SparkSqlParser.COMMENT: this.state = 689; this.commentSpec(); break; - case SqlBaseParser.PARTITIONED: + case SparkSqlParser.PARTITIONED: this.state = 690; - this.match(SqlBaseParser.PARTITIONED); + this.match(SparkSqlParser.PARTITIONED); this.state = 691; - this.match(SqlBaseParser.ON); + this.match(SparkSqlParser.ON); this.state = 692; this.identifierList(); break; - case SqlBaseParser.TBLPROPERTIES: + case SparkSqlParser.TBLPROPERTIES: this.state = 693; - this.match(SqlBaseParser.TBLPROPERTIES); + this.match(SparkSqlParser.TBLPROPERTIES); this.state = 694; this.tablePropertyList(); break; @@ -8684,7 +8684,7 @@ SqlBaseParser.prototype.statement = function() { _la = this._input.LA(1); } this.state = 700; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 701; this.query(); break; @@ -8693,41 +8693,41 @@ SqlBaseParser.prototype.statement = function() { localctx = new CreateTempViewUsingContext(this, localctx); this.enterOuterAlt(localctx, 35); this.state = 703; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 706; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OR) { + if(_la===SparkSqlParser.OR) { this.state = 704; - this.match(SqlBaseParser.OR); + this.match(SparkSqlParser.OR); this.state = 705; - this.match(SqlBaseParser.REPLACE); + this.match(SparkSqlParser.REPLACE); } this.state = 709; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.GLOBAL) { + if(_la===SparkSqlParser.GLOBAL) { this.state = 708; - this.match(SqlBaseParser.GLOBAL); + this.match(SparkSqlParser.GLOBAL); } this.state = 711; - this.match(SqlBaseParser.TEMPORARY); + this.match(SparkSqlParser.TEMPORARY); this.state = 712; - this.match(SqlBaseParser.VIEW); + this.match(SparkSqlParser.VIEW); this.state = 713; this.tableIdentifier(); this.state = 718; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1) { + if(_la===SparkSqlParser.T__1) { this.state = 714; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 715; this.colTypeList(); this.state = 716; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } this.state = 720; @@ -8735,9 +8735,9 @@ SqlBaseParser.prototype.statement = function() { this.state = 723; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OPTIONS) { + if(_la===SparkSqlParser.OPTIONS) { this.state = 721; - this.match(SqlBaseParser.OPTIONS); + this.match(SparkSqlParser.OPTIONS); this.state = 722; this.tablePropertyList(); } @@ -8748,17 +8748,17 @@ SqlBaseParser.prototype.statement = function() { localctx = new AlterViewQueryContext(this, localctx); this.enterOuterAlt(localctx, 36); this.state = 725; - this.match(SqlBaseParser.ALTER); + this.match(SparkSqlParser.ALTER); this.state = 726; - this.match(SqlBaseParser.VIEW); + this.match(SparkSqlParser.VIEW); this.state = 727; this.multipartIdentifier(); this.state = 729; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AS) { + if(_la===SparkSqlParser.AS) { this.state = 728; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 731; @@ -8769,59 +8769,59 @@ SqlBaseParser.prototype.statement = function() { localctx = new CreateFunctionContext(this, localctx); this.enterOuterAlt(localctx, 37); this.state = 733; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 736; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OR) { + if(_la===SparkSqlParser.OR) { this.state = 734; - this.match(SqlBaseParser.OR); + this.match(SparkSqlParser.OR); this.state = 735; - this.match(SqlBaseParser.REPLACE); + this.match(SparkSqlParser.REPLACE); } this.state = 739; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.TEMPORARY) { + if(_la===SparkSqlParser.TEMPORARY) { this.state = 738; - this.match(SqlBaseParser.TEMPORARY); + this.match(SparkSqlParser.TEMPORARY); } this.state = 741; - this.match(SqlBaseParser.FUNCTION); + this.match(SparkSqlParser.FUNCTION); this.state = 745; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,61,this._ctx); if(la_===1) { this.state = 742; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 743; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 744; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 747; this.multipartIdentifier(); this.state = 748; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 749; - localctx.className = this.match(SqlBaseParser.STRING); + localctx.className = this.match(SparkSqlParser.STRING); this.state = 759; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.USING) { + if(_la===SparkSqlParser.USING) { this.state = 750; - this.match(SqlBaseParser.USING); + this.match(SparkSqlParser.USING); this.state = 751; this.resource(); this.state = 756; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 752; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 753; this.resource(); this.state = 758; @@ -8836,25 +8836,25 @@ SqlBaseParser.prototype.statement = function() { localctx = new DropFunctionContext(this, localctx); this.enterOuterAlt(localctx, 38); this.state = 761; - this.match(SqlBaseParser.DROP); + this.match(SparkSqlParser.DROP); this.state = 763; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.TEMPORARY) { + if(_la===SparkSqlParser.TEMPORARY) { this.state = 762; - this.match(SqlBaseParser.TEMPORARY); + this.match(SparkSqlParser.TEMPORARY); } this.state = 765; - this.match(SqlBaseParser.FUNCTION); + this.match(SparkSqlParser.FUNCTION); this.state = 768; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,65,this._ctx); if(la_===1) { this.state = 766; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 767; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 770; @@ -8865,14 +8865,14 @@ SqlBaseParser.prototype.statement = function() { localctx = new ExplainContext(this, localctx); this.enterOuterAlt(localctx, 39); this.state = 771; - this.match(SqlBaseParser.EXPLAIN); + this.match(SparkSqlParser.EXPLAIN); this.state = 773; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.CODEGEN || _la===SqlBaseParser.COST || _la===SqlBaseParser.EXTENDED || _la===SqlBaseParser.FORMATTED || _la===SqlBaseParser.LOGICAL) { + if(_la===SparkSqlParser.CODEGEN || _la===SparkSqlParser.COST || _la===SparkSqlParser.EXTENDED || _la===SparkSqlParser.FORMATTED || _la===SparkSqlParser.LOGICAL) { this.state = 772; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.CODEGEN || _la===SqlBaseParser.COST || _la===SqlBaseParser.EXTENDED || _la===SqlBaseParser.FORMATTED || _la===SqlBaseParser.LOGICAL)) { + if(!(_la===SparkSqlParser.CODEGEN || _la===SparkSqlParser.COST || _la===SparkSqlParser.EXTENDED || _la===SparkSqlParser.FORMATTED || _la===SparkSqlParser.LOGICAL)) { this._errHandler.recoverInline(this); } else { @@ -8889,16 +8889,16 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowTablesContext(this, localctx); this.enterOuterAlt(localctx, 40); this.state = 776; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 777; - this.match(SqlBaseParser.TABLES); + this.match(SparkSqlParser.TABLES); this.state = 780; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN) { + if(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN) { this.state = 778; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN)) { + if(!(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN)) { this._errHandler.recoverInline(this); } else { @@ -8912,17 +8912,17 @@ SqlBaseParser.prototype.statement = function() { this.state = 786; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LIKE || _la===SqlBaseParser.STRING) { + if(_la===SparkSqlParser.LIKE || _la===SparkSqlParser.STRING) { this.state = 783; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LIKE) { + if(_la===SparkSqlParser.LIKE) { this.state = 782; - this.match(SqlBaseParser.LIKE); + this.match(SparkSqlParser.LIKE); } this.state = 785; - localctx.pattern = this.match(SqlBaseParser.STRING); + localctx.pattern = this.match(SparkSqlParser.STRING); } break; @@ -8931,18 +8931,18 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowTableContext(this, localctx); this.enterOuterAlt(localctx, 41); this.state = 788; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 789; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 790; - this.match(SqlBaseParser.EXTENDED); + this.match(SparkSqlParser.EXTENDED); this.state = 793; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN) { + if(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN) { this.state = 791; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN)) { + if(!(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN)) { this._errHandler.recoverInline(this); } else { @@ -8954,13 +8954,13 @@ SqlBaseParser.prototype.statement = function() { } this.state = 795; - this.match(SqlBaseParser.LIKE); + this.match(SparkSqlParser.LIKE); this.state = 796; - localctx.pattern = this.match(SqlBaseParser.STRING); + localctx.pattern = this.match(SparkSqlParser.STRING); this.state = 798; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 797; this.partitionSpec(); } @@ -8971,21 +8971,21 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowTblPropertiesContext(this, localctx); this.enterOuterAlt(localctx, 42); this.state = 800; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 801; - this.match(SqlBaseParser.TBLPROPERTIES); + this.match(SparkSqlParser.TBLPROPERTIES); this.state = 802; localctx.table = this.multipartIdentifier(); this.state = 807; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1) { + if(_la===SparkSqlParser.T__1) { this.state = 803; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 804; localctx.key = this.tablePropertyKey(); this.state = 805; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } break; @@ -8994,12 +8994,12 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowColumnsContext(this, localctx); this.enterOuterAlt(localctx, 43); this.state = 809; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 810; - this.match(SqlBaseParser.COLUMNS); + this.match(SparkSqlParser.COLUMNS); this.state = 811; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN)) { + if(!(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN)) { this._errHandler.recoverInline(this); } else { @@ -9011,10 +9011,10 @@ SqlBaseParser.prototype.statement = function() { this.state = 815; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN) { + if(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN) { this.state = 813; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN)) { + if(!(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN)) { this._errHandler.recoverInline(this); } else { @@ -9031,16 +9031,16 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowViewsContext(this, localctx); this.enterOuterAlt(localctx, 44); this.state = 817; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 818; - this.match(SqlBaseParser.VIEWS); + this.match(SparkSqlParser.VIEWS); this.state = 821; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN) { + if(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN) { this.state = 819; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FROM || _la===SqlBaseParser.IN)) { + if(!(_la===SparkSqlParser.FROM || _la===SparkSqlParser.IN)) { this._errHandler.recoverInline(this); } else { @@ -9054,17 +9054,17 @@ SqlBaseParser.prototype.statement = function() { this.state = 827; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LIKE || _la===SqlBaseParser.STRING) { + if(_la===SparkSqlParser.LIKE || _la===SparkSqlParser.STRING) { this.state = 824; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LIKE) { + if(_la===SparkSqlParser.LIKE) { this.state = 823; - this.match(SqlBaseParser.LIKE); + this.match(SparkSqlParser.LIKE); } this.state = 826; - localctx.pattern = this.match(SqlBaseParser.STRING); + localctx.pattern = this.match(SparkSqlParser.STRING); } break; @@ -9073,15 +9073,15 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowPartitionsContext(this, localctx); this.enterOuterAlt(localctx, 45); this.state = 829; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 830; - this.match(SqlBaseParser.PARTITIONS); + this.match(SparkSqlParser.PARTITIONS); this.state = 831; this.multipartIdentifier(); this.state = 833; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 832; this.partitionSpec(); } @@ -9092,7 +9092,7 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowFunctionsContext(this, localctx); this.enterOuterAlt(localctx, 46); this.state = 835; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 837; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,78,this._ctx); @@ -9102,7 +9102,7 @@ SqlBaseParser.prototype.statement = function() { } this.state = 839; - this.match(SqlBaseParser.FUNCTIONS); + this.match(SparkSqlParser.FUNCTIONS); this.state = 847; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,81,this._ctx); @@ -9112,7 +9112,7 @@ SqlBaseParser.prototype.statement = function() { var la_ = this._interp.adaptivePredict(this._input,79,this._ctx); if(la_===1) { this.state = 840; - this.match(SqlBaseParser.LIKE); + this.match(SparkSqlParser.LIKE); } this.state = 845; @@ -9126,7 +9126,7 @@ SqlBaseParser.prototype.statement = function() { case 2: this.state = 844; - localctx.pattern = this.match(SqlBaseParser.STRING); + localctx.pattern = this.match(SparkSqlParser.STRING); break; } @@ -9138,21 +9138,21 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowCreateTableContext(this, localctx); this.enterOuterAlt(localctx, 47); this.state = 849; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 850; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 851; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 852; this.multipartIdentifier(); this.state = 855; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AS) { + if(_la===SparkSqlParser.AS) { this.state = 853; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 854; - this.match(SqlBaseParser.SERDE); + this.match(SparkSqlParser.SERDE); } break; @@ -9161,11 +9161,11 @@ SqlBaseParser.prototype.statement = function() { localctx = new ShowCurrentNamespaceContext(this, localctx); this.enterOuterAlt(localctx, 48); this.state = 857; - this.match(SqlBaseParser.SHOW); + this.match(SparkSqlParser.SHOW); this.state = 858; - this.match(SqlBaseParser.CURRENT); + this.match(SparkSqlParser.CURRENT); this.state = 859; - this.match(SqlBaseParser.NAMESPACE); + this.match(SparkSqlParser.NAMESPACE); break; case 49: @@ -9173,7 +9173,7 @@ SqlBaseParser.prototype.statement = function() { this.enterOuterAlt(localctx, 49); this.state = 860; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DESC || _la===SqlBaseParser.DESCRIBE)) { + if(!(_la===SparkSqlParser.DESC || _la===SparkSqlParser.DESCRIBE)) { this._errHandler.recoverInline(this); } else { @@ -9181,13 +9181,13 @@ SqlBaseParser.prototype.statement = function() { this.consume(); } this.state = 861; - this.match(SqlBaseParser.FUNCTION); + this.match(SparkSqlParser.FUNCTION); this.state = 863; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,83,this._ctx); if(la_===1) { this.state = 862; - this.match(SqlBaseParser.EXTENDED); + this.match(SparkSqlParser.EXTENDED); } this.state = 865; @@ -9199,7 +9199,7 @@ SqlBaseParser.prototype.statement = function() { this.enterOuterAlt(localctx, 50); this.state = 866; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DESC || _la===SqlBaseParser.DESCRIBE)) { + if(!(_la===SparkSqlParser.DESC || _la===SparkSqlParser.DESCRIBE)) { this._errHandler.recoverInline(this); } else { @@ -9213,7 +9213,7 @@ SqlBaseParser.prototype.statement = function() { var la_ = this._interp.adaptivePredict(this._input,84,this._ctx); if(la_===1) { this.state = 868; - this.match(SqlBaseParser.EXTENDED); + this.match(SparkSqlParser.EXTENDED); } this.state = 871; @@ -9225,7 +9225,7 @@ SqlBaseParser.prototype.statement = function() { this.enterOuterAlt(localctx, 51); this.state = 873; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DESC || _la===SqlBaseParser.DESCRIBE)) { + if(!(_la===SparkSqlParser.DESC || _la===SparkSqlParser.DESCRIBE)) { this._errHandler.recoverInline(this); } else { @@ -9237,7 +9237,7 @@ SqlBaseParser.prototype.statement = function() { var la_ = this._interp.adaptivePredict(this._input,85,this._ctx); if(la_===1) { this.state = 874; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); } this.state = 878; @@ -9247,7 +9247,7 @@ SqlBaseParser.prototype.statement = function() { this.state = 877; localctx.option = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.EXTENDED || _la===SqlBaseParser.FORMATTED)) { + if(!(_la===SparkSqlParser.EXTENDED || _la===SparkSqlParser.FORMATTED)) { localctx.option = this._errHandler.recoverInline(this); } else { @@ -9281,7 +9281,7 @@ SqlBaseParser.prototype.statement = function() { this.enterOuterAlt(localctx, 52); this.state = 887; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DESC || _la===SqlBaseParser.DESCRIBE)) { + if(!(_la===SparkSqlParser.DESC || _la===SparkSqlParser.DESCRIBE)) { this._errHandler.recoverInline(this); } else { @@ -9291,9 +9291,9 @@ SqlBaseParser.prototype.statement = function() { this.state = 889; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.QUERY) { + if(_la===SparkSqlParser.QUERY) { this.state = 888; - this.match(SqlBaseParser.QUERY); + this.match(SparkSqlParser.QUERY); } this.state = 891; @@ -9304,19 +9304,19 @@ SqlBaseParser.prototype.statement = function() { localctx = new CommentNamespaceContext(this, localctx); this.enterOuterAlt(localctx, 53); this.state = 892; - this.match(SqlBaseParser.COMMENT); + this.match(SparkSqlParser.COMMENT); this.state = 893; - this.match(SqlBaseParser.ON); + this.match(SparkSqlParser.ON); this.state = 894; this.namespace(); this.state = 895; this.multipartIdentifier(); this.state = 896; - this.match(SqlBaseParser.IS); + this.match(SparkSqlParser.IS); this.state = 897; localctx.comment = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.NULL || _la===SqlBaseParser.STRING)) { + if(!(_la===SparkSqlParser.NULL || _la===SparkSqlParser.STRING)) { localctx.comment = this._errHandler.recoverInline(this); } else { @@ -9329,19 +9329,19 @@ SqlBaseParser.prototype.statement = function() { localctx = new CommentTableContext(this, localctx); this.enterOuterAlt(localctx, 54); this.state = 899; - this.match(SqlBaseParser.COMMENT); + this.match(SparkSqlParser.COMMENT); this.state = 900; - this.match(SqlBaseParser.ON); + this.match(SparkSqlParser.ON); this.state = 901; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 902; this.multipartIdentifier(); this.state = 903; - this.match(SqlBaseParser.IS); + this.match(SparkSqlParser.IS); this.state = 904; localctx.comment = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.NULL || _la===SqlBaseParser.STRING)) { + if(!(_la===SparkSqlParser.NULL || _la===SparkSqlParser.STRING)) { localctx.comment = this._errHandler.recoverInline(this); } else { @@ -9354,9 +9354,9 @@ SqlBaseParser.prototype.statement = function() { localctx = new RefreshTableContext(this, localctx); this.enterOuterAlt(localctx, 55); this.state = 906; - this.match(SqlBaseParser.REFRESH); + this.match(SparkSqlParser.REFRESH); this.state = 907; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 908; this.multipartIdentifier(); break; @@ -9365,9 +9365,9 @@ SqlBaseParser.prototype.statement = function() { localctx = new RefreshFunctionContext(this, localctx); this.enterOuterAlt(localctx, 56); this.state = 909; - this.match(SqlBaseParser.REFRESH); + this.match(SparkSqlParser.REFRESH); this.state = 910; - this.match(SqlBaseParser.FUNCTION); + this.match(SparkSqlParser.FUNCTION); this.state = 911; this.multipartIdentifier(); break; @@ -9376,14 +9376,14 @@ SqlBaseParser.prototype.statement = function() { localctx = new RefreshResourceContext(this, localctx); this.enterOuterAlt(localctx, 57); this.state = 912; - this.match(SqlBaseParser.REFRESH); + this.match(SparkSqlParser.REFRESH); this.state = 920; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,91,this._ctx); switch(la_) { case 1: this.state = 913; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; case 2: @@ -9409,25 +9409,25 @@ SqlBaseParser.prototype.statement = function() { localctx = new CacheTableContext(this, localctx); this.enterOuterAlt(localctx, 58); this.state = 922; - this.match(SqlBaseParser.CACHE); + this.match(SparkSqlParser.CACHE); this.state = 924; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LAZY) { + if(_la===SparkSqlParser.LAZY) { this.state = 923; - this.match(SqlBaseParser.LAZY); + this.match(SparkSqlParser.LAZY); } this.state = 926; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 927; this.multipartIdentifier(); this.state = 930; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OPTIONS) { + if(_la===SparkSqlParser.OPTIONS) { this.state = 928; - this.match(SqlBaseParser.OPTIONS); + this.match(SparkSqlParser.OPTIONS); this.state = 929; this.tablePropertyList(); } @@ -9435,13 +9435,13 @@ SqlBaseParser.prototype.statement = function() { this.state = 936; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__1 || _la===SqlBaseParser.AS || _la===SqlBaseParser.FROM || _la===SqlBaseParser.MAP || _la===SqlBaseParser.REDUCE || _la===SqlBaseParser.SELECT || _la===SqlBaseParser.TABLE || _la===SqlBaseParser.VALUES || _la===SqlBaseParser.WITH) { + if(_la===SparkSqlParser.T__1 || _la===SparkSqlParser.AS || _la===SparkSqlParser.FROM || _la===SparkSqlParser.MAP || _la===SparkSqlParser.REDUCE || _la===SparkSqlParser.SELECT || _la===SparkSqlParser.TABLE || _la===SparkSqlParser.VALUES || _la===SparkSqlParser.WITH) { this.state = 933; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AS) { + if(_la===SparkSqlParser.AS) { this.state = 932; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 935; @@ -9454,17 +9454,17 @@ SqlBaseParser.prototype.statement = function() { localctx = new UncacheTableContext(this, localctx); this.enterOuterAlt(localctx, 59); this.state = 938; - this.match(SqlBaseParser.UNCACHE); + this.match(SparkSqlParser.UNCACHE); this.state = 939; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 942; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,96,this._ctx); if(la_===1) { this.state = 940; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 941; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 944; @@ -9475,48 +9475,48 @@ SqlBaseParser.prototype.statement = function() { localctx = new ClearCacheContext(this, localctx); this.enterOuterAlt(localctx, 60); this.state = 945; - this.match(SqlBaseParser.CLEAR); + this.match(SparkSqlParser.CLEAR); this.state = 946; - this.match(SqlBaseParser.CACHE); + this.match(SparkSqlParser.CACHE); break; case 61: localctx = new LoadDataContext(this, localctx); this.enterOuterAlt(localctx, 61); this.state = 947; - this.match(SqlBaseParser.LOAD); + this.match(SparkSqlParser.LOAD); this.state = 948; - this.match(SqlBaseParser.DATA); + this.match(SparkSqlParser.DATA); this.state = 950; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LOCAL) { + if(_la===SparkSqlParser.LOCAL) { this.state = 949; - this.match(SqlBaseParser.LOCAL); + this.match(SparkSqlParser.LOCAL); } this.state = 952; - this.match(SqlBaseParser.INPATH); + this.match(SparkSqlParser.INPATH); this.state = 953; - localctx.path = this.match(SqlBaseParser.STRING); + localctx.path = this.match(SparkSqlParser.STRING); this.state = 955; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OVERWRITE) { + if(_la===SparkSqlParser.OVERWRITE) { this.state = 954; - this.match(SqlBaseParser.OVERWRITE); + this.match(SparkSqlParser.OVERWRITE); } this.state = 957; - this.match(SqlBaseParser.INTO); + this.match(SparkSqlParser.INTO); this.state = 958; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 959; this.multipartIdentifier(); this.state = 961; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 960; this.partitionSpec(); } @@ -9527,15 +9527,15 @@ SqlBaseParser.prototype.statement = function() { localctx = new TruncateTableContext(this, localctx); this.enterOuterAlt(localctx, 62); this.state = 963; - this.match(SqlBaseParser.TRUNCATE); + this.match(SparkSqlParser.TRUNCATE); this.state = 964; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 965; this.multipartIdentifier(); this.state = 967; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 966; this.partitionSpec(); } @@ -9546,11 +9546,11 @@ SqlBaseParser.prototype.statement = function() { localctx = new RepairTableContext(this, localctx); this.enterOuterAlt(localctx, 63); this.state = 969; - this.match(SqlBaseParser.MSCK); + this.match(SparkSqlParser.MSCK); this.state = 970; - this.match(SqlBaseParser.REPAIR); + this.match(SparkSqlParser.REPAIR); this.state = 971; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 972; this.multipartIdentifier(); break; @@ -9561,7 +9561,7 @@ SqlBaseParser.prototype.statement = function() { this.state = 973; localctx.op = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ADD || _la===SqlBaseParser.LIST)) { + if(!(_la===SparkSqlParser.ADD || _la===SparkSqlParser.LIST)) { localctx.op = this._errHandler.recoverInline(this); } else { @@ -9576,7 +9576,7 @@ SqlBaseParser.prototype.statement = function() { switch(la_) { case 1: this.state = 975; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; case 2: @@ -9602,9 +9602,9 @@ SqlBaseParser.prototype.statement = function() { localctx = new FailNativeCommandContext(this, localctx); this.enterOuterAlt(localctx, 65); this.state = 984; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 985; - this.match(SqlBaseParser.ROLE); + this.match(SparkSqlParser.ROLE); this.state = 989; this._errHandler.sync(this); var _alt = this._interp.adaptivePredict(this._input,103,this._ctx) @@ -9624,11 +9624,11 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetTimeZoneContext(this, localctx); this.enterOuterAlt(localctx, 66); this.state = 992; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 993; - this.match(SqlBaseParser.TIME); + this.match(SparkSqlParser.TIME); this.state = 994; - this.match(SqlBaseParser.ZONE); + this.match(SparkSqlParser.ZONE); this.state = 995; this.interval(); break; @@ -9637,15 +9637,15 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetTimeZoneContext(this, localctx); this.enterOuterAlt(localctx, 67); this.state = 996; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 997; - this.match(SqlBaseParser.TIME); + this.match(SparkSqlParser.TIME); this.state = 998; - this.match(SqlBaseParser.ZONE); + this.match(SparkSqlParser.ZONE); this.state = 999; localctx.timezone = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.LOCAL || _la===SqlBaseParser.STRING)) { + if(!(_la===SparkSqlParser.LOCAL || _la===SparkSqlParser.STRING)) { localctx.timezone = this._errHandler.recoverInline(this); } else { @@ -9658,11 +9658,11 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetTimeZoneContext(this, localctx); this.enterOuterAlt(localctx, 68); this.state = 1000; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 1001; - this.match(SqlBaseParser.TIME); + this.match(SparkSqlParser.TIME); this.state = 1002; - this.match(SqlBaseParser.ZONE); + this.match(SparkSqlParser.ZONE); this.state = 1006; this._errHandler.sync(this); var _alt = this._interp.adaptivePredict(this._input,104,this._ctx) @@ -9682,15 +9682,15 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetQuotedConfigurationContext(this, localctx); this.enterOuterAlt(localctx, 69); this.state = 1009; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 1010; this.configKey(); this.state = 1018; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.EQ) { + if(_la===SparkSqlParser.EQ) { this.state = 1011; - this.match(SqlBaseParser.EQ); + this.match(SparkSqlParser.EQ); this.state = 1015; this._errHandler.sync(this); var _alt = this._interp.adaptivePredict(this._input,105,this._ctx) @@ -9712,7 +9712,7 @@ SqlBaseParser.prototype.statement = function() { localctx = new SetConfigurationContext(this, localctx); this.enterOuterAlt(localctx, 70); this.state = 1020; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 1024; this._errHandler.sync(this); var _alt = this._interp.adaptivePredict(this._input,107,this._ctx) @@ -9732,7 +9732,7 @@ SqlBaseParser.prototype.statement = function() { localctx = new ResetQuotedConfigurationContext(this, localctx); this.enterOuterAlt(localctx, 71); this.state = 1027; - this.match(SqlBaseParser.RESET); + this.match(SparkSqlParser.RESET); this.state = 1028; this.configKey(); break; @@ -9741,7 +9741,7 @@ SqlBaseParser.prototype.statement = function() { localctx = new ResetConfigurationContext(this, localctx); this.enterOuterAlt(localctx, 72); this.state = 1029; - this.match(SqlBaseParser.RESET); + this.match(SparkSqlParser.RESET); this.state = 1033; this._errHandler.sync(this); var _alt = this._interp.adaptivePredict(this._input,108,this._ctx) @@ -9802,7 +9802,7 @@ function ConfigKeyContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_configKey; + this.ruleIndex = SparkSqlParser.RULE_configKey; return this; } @@ -9814,19 +9814,19 @@ ConfigKeyContext.prototype.quotedIdentifier = function() { }; ConfigKeyContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterConfigKey(this); } }; ConfigKeyContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitConfigKey(this); } }; ConfigKeyContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitConfigKey(this); } else { return visitor.visitChildren(this); @@ -9836,12 +9836,12 @@ ConfigKeyContext.prototype.accept = function(visitor) { -SqlBaseParser.ConfigKeyContext = ConfigKeyContext; +SparkSqlParser.ConfigKeyContext = ConfigKeyContext; -SqlBaseParser.prototype.configKey = function() { +SparkSqlParser.prototype.configKey = function() { var localctx = new ConfigKeyContext(this, this._ctx, this.state); - this.enterRule(localctx, 16, SqlBaseParser.RULE_configKey); + this.enterRule(localctx, 16, SparkSqlParser.RULE_configKey); try { this.enterOuterAlt(localctx, 1); this.state = 1045; @@ -9870,7 +9870,7 @@ function UnsupportedHiveNativeCommandsContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_unsupportedHiveNativeCommands; + this.ruleIndex = SparkSqlParser.RULE_unsupportedHiveNativeCommands; this.kw1 = null; // Token this.kw2 = null; // Token this.kw3 = null; // Token @@ -9884,95 +9884,95 @@ UnsupportedHiveNativeCommandsContext.prototype = Object.create(antlr4.ParserRule UnsupportedHiveNativeCommandsContext.prototype.constructor = UnsupportedHiveNativeCommandsContext; UnsupportedHiveNativeCommandsContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.ROLE = function() { - return this.getToken(SqlBaseParser.ROLE, 0); + return this.getToken(SparkSqlParser.ROLE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; UnsupportedHiveNativeCommandsContext.prototype.GRANT = function() { - return this.getToken(SqlBaseParser.GRANT, 0); + return this.getToken(SparkSqlParser.GRANT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.REVOKE = function() { - return this.getToken(SqlBaseParser.REVOKE, 0); + return this.getToken(SparkSqlParser.REVOKE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; UnsupportedHiveNativeCommandsContext.prototype.PRINCIPALS = function() { - return this.getToken(SqlBaseParser.PRINCIPALS, 0); + return this.getToken(SparkSqlParser.PRINCIPALS, 0); }; UnsupportedHiveNativeCommandsContext.prototype.ROLES = function() { - return this.getToken(SqlBaseParser.ROLES, 0); + return this.getToken(SparkSqlParser.ROLES, 0); }; UnsupportedHiveNativeCommandsContext.prototype.CURRENT = function() { - return this.getToken(SqlBaseParser.CURRENT, 0); + return this.getToken(SparkSqlParser.CURRENT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.EXPORT = function() { - return this.getToken(SqlBaseParser.EXPORT, 0); + return this.getToken(SparkSqlParser.EXPORT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.IMPORT = function() { - return this.getToken(SqlBaseParser.IMPORT, 0); + return this.getToken(SparkSqlParser.IMPORT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.COMPACTIONS = function() { - return this.getToken(SqlBaseParser.COMPACTIONS, 0); + return this.getToken(SparkSqlParser.COMPACTIONS, 0); }; UnsupportedHiveNativeCommandsContext.prototype.TRANSACTIONS = function() { - return this.getToken(SqlBaseParser.TRANSACTIONS, 0); + return this.getToken(SparkSqlParser.TRANSACTIONS, 0); }; UnsupportedHiveNativeCommandsContext.prototype.INDEXES = function() { - return this.getToken(SqlBaseParser.INDEXES, 0); + return this.getToken(SparkSqlParser.INDEXES, 0); }; UnsupportedHiveNativeCommandsContext.prototype.LOCKS = function() { - return this.getToken(SqlBaseParser.LOCKS, 0); + return this.getToken(SparkSqlParser.LOCKS, 0); }; UnsupportedHiveNativeCommandsContext.prototype.INDEX = function() { - return this.getToken(SqlBaseParser.INDEX, 0); + return this.getToken(SparkSqlParser.INDEX, 0); }; UnsupportedHiveNativeCommandsContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; UnsupportedHiveNativeCommandsContext.prototype.LOCK = function() { - return this.getToken(SqlBaseParser.LOCK, 0); + return this.getToken(SparkSqlParser.LOCK, 0); }; UnsupportedHiveNativeCommandsContext.prototype.DATABASE = function() { - return this.getToken(SqlBaseParser.DATABASE, 0); + return this.getToken(SparkSqlParser.DATABASE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.UNLOCK = function() { - return this.getToken(SqlBaseParser.UNLOCK, 0); + return this.getToken(SparkSqlParser.UNLOCK, 0); }; UnsupportedHiveNativeCommandsContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; UnsupportedHiveNativeCommandsContext.prototype.MACRO = function() { - return this.getToken(SqlBaseParser.MACRO, 0); + return this.getToken(SparkSqlParser.MACRO, 0); }; UnsupportedHiveNativeCommandsContext.prototype.tableIdentifier = function() { @@ -9980,67 +9980,67 @@ UnsupportedHiveNativeCommandsContext.prototype.tableIdentifier = function() { }; UnsupportedHiveNativeCommandsContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.CLUSTERED = function() { - return this.getToken(SqlBaseParser.CLUSTERED, 0); + return this.getToken(SparkSqlParser.CLUSTERED, 0); }; UnsupportedHiveNativeCommandsContext.prototype.BY = function() { - return this.getToken(SqlBaseParser.BY, 0); + return this.getToken(SparkSqlParser.BY, 0); }; UnsupportedHiveNativeCommandsContext.prototype.SORTED = function() { - return this.getToken(SqlBaseParser.SORTED, 0); + return this.getToken(SparkSqlParser.SORTED, 0); }; UnsupportedHiveNativeCommandsContext.prototype.SKEWED = function() { - return this.getToken(SqlBaseParser.SKEWED, 0); + return this.getToken(SparkSqlParser.SKEWED, 0); }; UnsupportedHiveNativeCommandsContext.prototype.STORED = function() { - return this.getToken(SqlBaseParser.STORED, 0); + return this.getToken(SparkSqlParser.STORED, 0); }; UnsupportedHiveNativeCommandsContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; UnsupportedHiveNativeCommandsContext.prototype.DIRECTORIES = function() { - return this.getToken(SqlBaseParser.DIRECTORIES, 0); + return this.getToken(SparkSqlParser.DIRECTORIES, 0); }; UnsupportedHiveNativeCommandsContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; UnsupportedHiveNativeCommandsContext.prototype.LOCATION = function() { - return this.getToken(SqlBaseParser.LOCATION, 0); + return this.getToken(SparkSqlParser.LOCATION, 0); }; UnsupportedHiveNativeCommandsContext.prototype.EXCHANGE = function() { - return this.getToken(SqlBaseParser.EXCHANGE, 0); + return this.getToken(SparkSqlParser.EXCHANGE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.PARTITION = function() { - return this.getToken(SqlBaseParser.PARTITION, 0); + return this.getToken(SparkSqlParser.PARTITION, 0); }; UnsupportedHiveNativeCommandsContext.prototype.ARCHIVE = function() { - return this.getToken(SqlBaseParser.ARCHIVE, 0); + return this.getToken(SparkSqlParser.ARCHIVE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.UNARCHIVE = function() { - return this.getToken(SqlBaseParser.UNARCHIVE, 0); + return this.getToken(SparkSqlParser.UNARCHIVE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.TOUCH = function() { - return this.getToken(SqlBaseParser.TOUCH, 0); + return this.getToken(SparkSqlParser.TOUCH, 0); }; UnsupportedHiveNativeCommandsContext.prototype.COMPACT = function() { - return this.getToken(SqlBaseParser.COMPACT, 0); + return this.getToken(SparkSqlParser.COMPACT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.partitionSpec = function() { @@ -10048,55 +10048,55 @@ UnsupportedHiveNativeCommandsContext.prototype.partitionSpec = function() { }; UnsupportedHiveNativeCommandsContext.prototype.CONCATENATE = function() { - return this.getToken(SqlBaseParser.CONCATENATE, 0); + return this.getToken(SparkSqlParser.CONCATENATE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.FILEFORMAT = function() { - return this.getToken(SqlBaseParser.FILEFORMAT, 0); + return this.getToken(SparkSqlParser.FILEFORMAT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; UnsupportedHiveNativeCommandsContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; UnsupportedHiveNativeCommandsContext.prototype.START = function() { - return this.getToken(SqlBaseParser.START, 0); + return this.getToken(SparkSqlParser.START, 0); }; UnsupportedHiveNativeCommandsContext.prototype.TRANSACTION = function() { - return this.getToken(SqlBaseParser.TRANSACTION, 0); + return this.getToken(SparkSqlParser.TRANSACTION, 0); }; UnsupportedHiveNativeCommandsContext.prototype.COMMIT = function() { - return this.getToken(SqlBaseParser.COMMIT, 0); + return this.getToken(SparkSqlParser.COMMIT, 0); }; UnsupportedHiveNativeCommandsContext.prototype.ROLLBACK = function() { - return this.getToken(SqlBaseParser.ROLLBACK, 0); + return this.getToken(SparkSqlParser.ROLLBACK, 0); }; UnsupportedHiveNativeCommandsContext.prototype.DFS = function() { - return this.getToken(SqlBaseParser.DFS, 0); + return this.getToken(SparkSqlParser.DFS, 0); }; UnsupportedHiveNativeCommandsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterUnsupportedHiveNativeCommands(this); } }; UnsupportedHiveNativeCommandsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitUnsupportedHiveNativeCommands(this); } }; UnsupportedHiveNativeCommandsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitUnsupportedHiveNativeCommands(this); } else { return visitor.visitChildren(this); @@ -10106,12 +10106,12 @@ UnsupportedHiveNativeCommandsContext.prototype.accept = function(visitor) { -SqlBaseParser.UnsupportedHiveNativeCommandsContext = UnsupportedHiveNativeCommandsContext; +SparkSqlParser.UnsupportedHiveNativeCommandsContext = UnsupportedHiveNativeCommandsContext; -SqlBaseParser.prototype.unsupportedHiveNativeCommands = function() { +SparkSqlParser.prototype.unsupportedHiveNativeCommands = function() { var localctx = new UnsupportedHiveNativeCommandsContext(this, this._ctx, this.state); - this.enterRule(localctx, 18, SqlBaseParser.RULE_unsupportedHiveNativeCommands); + this.enterRule(localctx, 18, SparkSqlParser.RULE_unsupportedHiveNativeCommands); var _la = 0; // Token type try { this.state = 1215; @@ -10121,29 +10121,29 @@ SqlBaseParser.prototype.unsupportedHiveNativeCommands = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 1047; - localctx.kw1 = this.match(SqlBaseParser.CREATE); + localctx.kw1 = this.match(SparkSqlParser.CREATE); this.state = 1048; - localctx.kw2 = this.match(SqlBaseParser.ROLE); + localctx.kw2 = this.match(SparkSqlParser.ROLE); break; case 2: this.enterOuterAlt(localctx, 2); this.state = 1049; - localctx.kw1 = this.match(SqlBaseParser.DROP); + localctx.kw1 = this.match(SparkSqlParser.DROP); this.state = 1050; - localctx.kw2 = this.match(SqlBaseParser.ROLE); + localctx.kw2 = this.match(SparkSqlParser.ROLE); break; case 3: this.enterOuterAlt(localctx, 3); this.state = 1051; - localctx.kw1 = this.match(SqlBaseParser.GRANT); + localctx.kw1 = this.match(SparkSqlParser.GRANT); this.state = 1053; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,111,this._ctx); if(la_===1) { this.state = 1052; - localctx.kw2 = this.match(SqlBaseParser.ROLE); + localctx.kw2 = this.match(SparkSqlParser.ROLE); } break; @@ -10151,13 +10151,13 @@ SqlBaseParser.prototype.unsupportedHiveNativeCommands = function() { case 4: this.enterOuterAlt(localctx, 4); this.state = 1055; - localctx.kw1 = this.match(SqlBaseParser.REVOKE); + localctx.kw1 = this.match(SparkSqlParser.REVOKE); this.state = 1057; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,112,this._ctx); if(la_===1) { this.state = 1056; - localctx.kw2 = this.match(SqlBaseParser.ROLE); + localctx.kw2 = this.match(SparkSqlParser.ROLE); } break; @@ -10165,23 +10165,23 @@ SqlBaseParser.prototype.unsupportedHiveNativeCommands = function() { case 5: this.enterOuterAlt(localctx, 5); this.state = 1059; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1060; - localctx.kw2 = this.match(SqlBaseParser.GRANT); + localctx.kw2 = this.match(SparkSqlParser.GRANT); break; case 6: this.enterOuterAlt(localctx, 6); this.state = 1061; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1062; - localctx.kw2 = this.match(SqlBaseParser.ROLE); + localctx.kw2 = this.match(SparkSqlParser.ROLE); this.state = 1064; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,113,this._ctx); if(la_===1) { this.state = 1063; - localctx.kw3 = this.match(SqlBaseParser.GRANT); + localctx.kw3 = this.match(SparkSqlParser.GRANT); } break; @@ -10189,429 +10189,429 @@ SqlBaseParser.prototype.unsupportedHiveNativeCommands = function() { case 7: this.enterOuterAlt(localctx, 7); this.state = 1066; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1067; - localctx.kw2 = this.match(SqlBaseParser.PRINCIPALS); + localctx.kw2 = this.match(SparkSqlParser.PRINCIPALS); break; case 8: this.enterOuterAlt(localctx, 8); this.state = 1068; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1069; - localctx.kw2 = this.match(SqlBaseParser.ROLES); + localctx.kw2 = this.match(SparkSqlParser.ROLES); break; case 9: this.enterOuterAlt(localctx, 9); this.state = 1070; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1071; - localctx.kw2 = this.match(SqlBaseParser.CURRENT); + localctx.kw2 = this.match(SparkSqlParser.CURRENT); this.state = 1072; - localctx.kw3 = this.match(SqlBaseParser.ROLES); + localctx.kw3 = this.match(SparkSqlParser.ROLES); break; case 10: this.enterOuterAlt(localctx, 10); this.state = 1073; - localctx.kw1 = this.match(SqlBaseParser.EXPORT); + localctx.kw1 = this.match(SparkSqlParser.EXPORT); this.state = 1074; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); break; case 11: this.enterOuterAlt(localctx, 11); this.state = 1075; - localctx.kw1 = this.match(SqlBaseParser.IMPORT); + localctx.kw1 = this.match(SparkSqlParser.IMPORT); this.state = 1076; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); break; case 12: this.enterOuterAlt(localctx, 12); this.state = 1077; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1078; - localctx.kw2 = this.match(SqlBaseParser.COMPACTIONS); + localctx.kw2 = this.match(SparkSqlParser.COMPACTIONS); break; case 13: this.enterOuterAlt(localctx, 13); this.state = 1079; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1080; - localctx.kw2 = this.match(SqlBaseParser.CREATE); + localctx.kw2 = this.match(SparkSqlParser.CREATE); this.state = 1081; - localctx.kw3 = this.match(SqlBaseParser.TABLE); + localctx.kw3 = this.match(SparkSqlParser.TABLE); break; case 14: this.enterOuterAlt(localctx, 14); this.state = 1082; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1083; - localctx.kw2 = this.match(SqlBaseParser.TRANSACTIONS); + localctx.kw2 = this.match(SparkSqlParser.TRANSACTIONS); break; case 15: this.enterOuterAlt(localctx, 15); this.state = 1084; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1085; - localctx.kw2 = this.match(SqlBaseParser.INDEXES); + localctx.kw2 = this.match(SparkSqlParser.INDEXES); break; case 16: this.enterOuterAlt(localctx, 16); this.state = 1086; - localctx.kw1 = this.match(SqlBaseParser.SHOW); + localctx.kw1 = this.match(SparkSqlParser.SHOW); this.state = 1087; - localctx.kw2 = this.match(SqlBaseParser.LOCKS); + localctx.kw2 = this.match(SparkSqlParser.LOCKS); break; case 17: this.enterOuterAlt(localctx, 17); this.state = 1088; - localctx.kw1 = this.match(SqlBaseParser.CREATE); + localctx.kw1 = this.match(SparkSqlParser.CREATE); this.state = 1089; - localctx.kw2 = this.match(SqlBaseParser.INDEX); + localctx.kw2 = this.match(SparkSqlParser.INDEX); break; case 18: this.enterOuterAlt(localctx, 18); this.state = 1090; - localctx.kw1 = this.match(SqlBaseParser.DROP); + localctx.kw1 = this.match(SparkSqlParser.DROP); this.state = 1091; - localctx.kw2 = this.match(SqlBaseParser.INDEX); + localctx.kw2 = this.match(SparkSqlParser.INDEX); break; case 19: this.enterOuterAlt(localctx, 19); this.state = 1092; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1093; - localctx.kw2 = this.match(SqlBaseParser.INDEX); + localctx.kw2 = this.match(SparkSqlParser.INDEX); break; case 20: this.enterOuterAlt(localctx, 20); this.state = 1094; - localctx.kw1 = this.match(SqlBaseParser.LOCK); + localctx.kw1 = this.match(SparkSqlParser.LOCK); this.state = 1095; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); break; case 21: this.enterOuterAlt(localctx, 21); this.state = 1096; - localctx.kw1 = this.match(SqlBaseParser.LOCK); + localctx.kw1 = this.match(SparkSqlParser.LOCK); this.state = 1097; - localctx.kw2 = this.match(SqlBaseParser.DATABASE); + localctx.kw2 = this.match(SparkSqlParser.DATABASE); break; case 22: this.enterOuterAlt(localctx, 22); this.state = 1098; - localctx.kw1 = this.match(SqlBaseParser.UNLOCK); + localctx.kw1 = this.match(SparkSqlParser.UNLOCK); this.state = 1099; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); break; case 23: this.enterOuterAlt(localctx, 23); this.state = 1100; - localctx.kw1 = this.match(SqlBaseParser.UNLOCK); + localctx.kw1 = this.match(SparkSqlParser.UNLOCK); this.state = 1101; - localctx.kw2 = this.match(SqlBaseParser.DATABASE); + localctx.kw2 = this.match(SparkSqlParser.DATABASE); break; case 24: this.enterOuterAlt(localctx, 24); this.state = 1102; - localctx.kw1 = this.match(SqlBaseParser.CREATE); + localctx.kw1 = this.match(SparkSqlParser.CREATE); this.state = 1103; - localctx.kw2 = this.match(SqlBaseParser.TEMPORARY); + localctx.kw2 = this.match(SparkSqlParser.TEMPORARY); this.state = 1104; - localctx.kw3 = this.match(SqlBaseParser.MACRO); + localctx.kw3 = this.match(SparkSqlParser.MACRO); break; case 25: this.enterOuterAlt(localctx, 25); this.state = 1105; - localctx.kw1 = this.match(SqlBaseParser.DROP); + localctx.kw1 = this.match(SparkSqlParser.DROP); this.state = 1106; - localctx.kw2 = this.match(SqlBaseParser.TEMPORARY); + localctx.kw2 = this.match(SparkSqlParser.TEMPORARY); this.state = 1107; - localctx.kw3 = this.match(SqlBaseParser.MACRO); + localctx.kw3 = this.match(SparkSqlParser.MACRO); break; case 26: this.enterOuterAlt(localctx, 26); this.state = 1108; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1109; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1110; this.tableIdentifier(); this.state = 1111; - localctx.kw3 = this.match(SqlBaseParser.NOT); + localctx.kw3 = this.match(SparkSqlParser.NOT); this.state = 1112; - localctx.kw4 = this.match(SqlBaseParser.CLUSTERED); + localctx.kw4 = this.match(SparkSqlParser.CLUSTERED); break; case 27: this.enterOuterAlt(localctx, 27); this.state = 1114; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1115; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1116; this.tableIdentifier(); this.state = 1117; - localctx.kw3 = this.match(SqlBaseParser.CLUSTERED); + localctx.kw3 = this.match(SparkSqlParser.CLUSTERED); this.state = 1118; - localctx.kw4 = this.match(SqlBaseParser.BY); + localctx.kw4 = this.match(SparkSqlParser.BY); break; case 28: this.enterOuterAlt(localctx, 28); this.state = 1120; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1121; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1122; this.tableIdentifier(); this.state = 1123; - localctx.kw3 = this.match(SqlBaseParser.NOT); + localctx.kw3 = this.match(SparkSqlParser.NOT); this.state = 1124; - localctx.kw4 = this.match(SqlBaseParser.SORTED); + localctx.kw4 = this.match(SparkSqlParser.SORTED); break; case 29: this.enterOuterAlt(localctx, 29); this.state = 1126; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1127; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1128; this.tableIdentifier(); this.state = 1129; - localctx.kw3 = this.match(SqlBaseParser.SKEWED); + localctx.kw3 = this.match(SparkSqlParser.SKEWED); this.state = 1130; - localctx.kw4 = this.match(SqlBaseParser.BY); + localctx.kw4 = this.match(SparkSqlParser.BY); break; case 30: this.enterOuterAlt(localctx, 30); this.state = 1132; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1133; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1134; this.tableIdentifier(); this.state = 1135; - localctx.kw3 = this.match(SqlBaseParser.NOT); + localctx.kw3 = this.match(SparkSqlParser.NOT); this.state = 1136; - localctx.kw4 = this.match(SqlBaseParser.SKEWED); + localctx.kw4 = this.match(SparkSqlParser.SKEWED); break; case 31: this.enterOuterAlt(localctx, 31); this.state = 1138; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1139; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1140; this.tableIdentifier(); this.state = 1141; - localctx.kw3 = this.match(SqlBaseParser.NOT); + localctx.kw3 = this.match(SparkSqlParser.NOT); this.state = 1142; - localctx.kw4 = this.match(SqlBaseParser.STORED); + localctx.kw4 = this.match(SparkSqlParser.STORED); this.state = 1143; - localctx.kw5 = this.match(SqlBaseParser.AS); + localctx.kw5 = this.match(SparkSqlParser.AS); this.state = 1144; - localctx.kw6 = this.match(SqlBaseParser.DIRECTORIES); + localctx.kw6 = this.match(SparkSqlParser.DIRECTORIES); break; case 32: this.enterOuterAlt(localctx, 32); this.state = 1146; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1147; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1148; this.tableIdentifier(); this.state = 1149; - localctx.kw3 = this.match(SqlBaseParser.SET); + localctx.kw3 = this.match(SparkSqlParser.SET); this.state = 1150; - localctx.kw4 = this.match(SqlBaseParser.SKEWED); + localctx.kw4 = this.match(SparkSqlParser.SKEWED); this.state = 1151; - localctx.kw5 = this.match(SqlBaseParser.LOCATION); + localctx.kw5 = this.match(SparkSqlParser.LOCATION); break; case 33: this.enterOuterAlt(localctx, 33); this.state = 1153; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1154; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1155; this.tableIdentifier(); this.state = 1156; - localctx.kw3 = this.match(SqlBaseParser.EXCHANGE); + localctx.kw3 = this.match(SparkSqlParser.EXCHANGE); this.state = 1157; - localctx.kw4 = this.match(SqlBaseParser.PARTITION); + localctx.kw4 = this.match(SparkSqlParser.PARTITION); break; case 34: this.enterOuterAlt(localctx, 34); this.state = 1159; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1160; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1161; this.tableIdentifier(); this.state = 1162; - localctx.kw3 = this.match(SqlBaseParser.ARCHIVE); + localctx.kw3 = this.match(SparkSqlParser.ARCHIVE); this.state = 1163; - localctx.kw4 = this.match(SqlBaseParser.PARTITION); + localctx.kw4 = this.match(SparkSqlParser.PARTITION); break; case 35: this.enterOuterAlt(localctx, 35); this.state = 1165; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1166; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1167; this.tableIdentifier(); this.state = 1168; - localctx.kw3 = this.match(SqlBaseParser.UNARCHIVE); + localctx.kw3 = this.match(SparkSqlParser.UNARCHIVE); this.state = 1169; - localctx.kw4 = this.match(SqlBaseParser.PARTITION); + localctx.kw4 = this.match(SparkSqlParser.PARTITION); break; case 36: this.enterOuterAlt(localctx, 36); this.state = 1171; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1172; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1173; this.tableIdentifier(); this.state = 1174; - localctx.kw3 = this.match(SqlBaseParser.TOUCH); + localctx.kw3 = this.match(SparkSqlParser.TOUCH); break; case 37: this.enterOuterAlt(localctx, 37); this.state = 1176; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1177; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1178; this.tableIdentifier(); this.state = 1180; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 1179; this.partitionSpec(); } this.state = 1182; - localctx.kw3 = this.match(SqlBaseParser.COMPACT); + localctx.kw3 = this.match(SparkSqlParser.COMPACT); break; case 38: this.enterOuterAlt(localctx, 38); this.state = 1184; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1185; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1186; this.tableIdentifier(); this.state = 1188; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 1187; this.partitionSpec(); } this.state = 1190; - localctx.kw3 = this.match(SqlBaseParser.CONCATENATE); + localctx.kw3 = this.match(SparkSqlParser.CONCATENATE); break; case 39: this.enterOuterAlt(localctx, 39); this.state = 1192; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1193; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1194; this.tableIdentifier(); this.state = 1196; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 1195; this.partitionSpec(); } this.state = 1198; - localctx.kw3 = this.match(SqlBaseParser.SET); + localctx.kw3 = this.match(SparkSqlParser.SET); this.state = 1199; - localctx.kw4 = this.match(SqlBaseParser.FILEFORMAT); + localctx.kw4 = this.match(SparkSqlParser.FILEFORMAT); break; case 40: this.enterOuterAlt(localctx, 40); this.state = 1201; - localctx.kw1 = this.match(SqlBaseParser.ALTER); + localctx.kw1 = this.match(SparkSqlParser.ALTER); this.state = 1202; - localctx.kw2 = this.match(SqlBaseParser.TABLE); + localctx.kw2 = this.match(SparkSqlParser.TABLE); this.state = 1203; this.tableIdentifier(); this.state = 1205; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 1204; this.partitionSpec(); } this.state = 1207; - localctx.kw3 = this.match(SqlBaseParser.REPLACE); + localctx.kw3 = this.match(SparkSqlParser.REPLACE); this.state = 1208; - localctx.kw4 = this.match(SqlBaseParser.COLUMNS); + localctx.kw4 = this.match(SparkSqlParser.COLUMNS); break; case 41: this.enterOuterAlt(localctx, 41); this.state = 1210; - localctx.kw1 = this.match(SqlBaseParser.START); + localctx.kw1 = this.match(SparkSqlParser.START); this.state = 1211; - localctx.kw2 = this.match(SqlBaseParser.TRANSACTION); + localctx.kw2 = this.match(SparkSqlParser.TRANSACTION); break; case 42: this.enterOuterAlt(localctx, 42); this.state = 1212; - localctx.kw1 = this.match(SqlBaseParser.COMMIT); + localctx.kw1 = this.match(SparkSqlParser.COMMIT); break; case 43: this.enterOuterAlt(localctx, 43); this.state = 1213; - localctx.kw1 = this.match(SqlBaseParser.ROLLBACK); + localctx.kw1 = this.match(SparkSqlParser.ROLLBACK); break; case 44: this.enterOuterAlt(localctx, 44); this.state = 1214; - localctx.kw1 = this.match(SqlBaseParser.DFS); + localctx.kw1 = this.match(SparkSqlParser.DFS); break; } @@ -10639,7 +10639,7 @@ function CreateTableHeaderContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_createTableHeader; + this.ruleIndex = SparkSqlParser.RULE_createTableHeader; return this; } @@ -10647,11 +10647,11 @@ CreateTableHeaderContext.prototype = Object.create(antlr4.ParserRuleContext.prot CreateTableHeaderContext.prototype.constructor = CreateTableHeaderContext; CreateTableHeaderContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; CreateTableHeaderContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; CreateTableHeaderContext.prototype.multipartIdentifier = function() { @@ -10659,39 +10659,39 @@ CreateTableHeaderContext.prototype.multipartIdentifier = function() { }; CreateTableHeaderContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; CreateTableHeaderContext.prototype.EXTERNAL = function() { - return this.getToken(SqlBaseParser.EXTERNAL, 0); + return this.getToken(SparkSqlParser.EXTERNAL, 0); }; CreateTableHeaderContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; CreateTableHeaderContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; CreateTableHeaderContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; CreateTableHeaderContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateTableHeader(this); } }; CreateTableHeaderContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateTableHeader(this); } }; CreateTableHeaderContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateTableHeader(this); } else { return visitor.visitChildren(this); @@ -10701,45 +10701,45 @@ CreateTableHeaderContext.prototype.accept = function(visitor) { -SqlBaseParser.CreateTableHeaderContext = CreateTableHeaderContext; +SparkSqlParser.CreateTableHeaderContext = CreateTableHeaderContext; -SqlBaseParser.prototype.createTableHeader = function() { +SparkSqlParser.prototype.createTableHeader = function() { var localctx = new CreateTableHeaderContext(this, this._ctx, this.state); - this.enterRule(localctx, 20, SqlBaseParser.RULE_createTableHeader); + this.enterRule(localctx, 20, SparkSqlParser.RULE_createTableHeader); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1217; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 1219; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.TEMPORARY) { + if(_la===SparkSqlParser.TEMPORARY) { this.state = 1218; - this.match(SqlBaseParser.TEMPORARY); + this.match(SparkSqlParser.TEMPORARY); } this.state = 1222; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.EXTERNAL) { + if(_la===SparkSqlParser.EXTERNAL) { this.state = 1221; - this.match(SqlBaseParser.EXTERNAL); + this.match(SparkSqlParser.EXTERNAL); } this.state = 1224; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 1228; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,121,this._ctx); if(la_===1) { this.state = 1225; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 1226; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 1227; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } this.state = 1230; @@ -10768,7 +10768,7 @@ function ReplaceTableHeaderContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_replaceTableHeader; + this.ruleIndex = SparkSqlParser.RULE_replaceTableHeader; return this; } @@ -10776,11 +10776,11 @@ ReplaceTableHeaderContext.prototype = Object.create(antlr4.ParserRuleContext.pro ReplaceTableHeaderContext.prototype.constructor = ReplaceTableHeaderContext; ReplaceTableHeaderContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; ReplaceTableHeaderContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; ReplaceTableHeaderContext.prototype.multipartIdentifier = function() { @@ -10788,27 +10788,27 @@ ReplaceTableHeaderContext.prototype.multipartIdentifier = function() { }; ReplaceTableHeaderContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; ReplaceTableHeaderContext.prototype.OR = function() { - return this.getToken(SqlBaseParser.OR, 0); + return this.getToken(SparkSqlParser.OR, 0); }; ReplaceTableHeaderContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterReplaceTableHeader(this); } }; ReplaceTableHeaderContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitReplaceTableHeader(this); } }; ReplaceTableHeaderContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitReplaceTableHeader(this); } else { return visitor.visitChildren(this); @@ -10818,29 +10818,29 @@ ReplaceTableHeaderContext.prototype.accept = function(visitor) { -SqlBaseParser.ReplaceTableHeaderContext = ReplaceTableHeaderContext; +SparkSqlParser.ReplaceTableHeaderContext = ReplaceTableHeaderContext; -SqlBaseParser.prototype.replaceTableHeader = function() { +SparkSqlParser.prototype.replaceTableHeader = function() { var localctx = new ReplaceTableHeaderContext(this, this._ctx, this.state); - this.enterRule(localctx, 22, SqlBaseParser.RULE_replaceTableHeader); + this.enterRule(localctx, 22, SparkSqlParser.RULE_replaceTableHeader); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1234; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.CREATE) { + if(_la===SparkSqlParser.CREATE) { this.state = 1232; - this.match(SqlBaseParser.CREATE); + this.match(SparkSqlParser.CREATE); this.state = 1233; - this.match(SqlBaseParser.OR); + this.match(SparkSqlParser.OR); } this.state = 1236; - this.match(SqlBaseParser.REPLACE); + this.match(SparkSqlParser.REPLACE); this.state = 1237; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 1238; this.multipartIdentifier(); } catch (re) { @@ -10867,7 +10867,7 @@ function BucketSpecContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_bucketSpec; + this.ruleIndex = SparkSqlParser.RULE_bucketSpec; return this; } @@ -10875,7 +10875,7 @@ BucketSpecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); BucketSpecContext.prototype.constructor = BucketSpecContext; BucketSpecContext.prototype.CLUSTERED = function() { - return this.getToken(SqlBaseParser.CLUSTERED, 0); + return this.getToken(SparkSqlParser.CLUSTERED, 0); }; BucketSpecContext.prototype.BY = function(i) { @@ -10883,9 +10883,9 @@ BucketSpecContext.prototype.BY = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.BY); + return this.getTokens(SparkSqlParser.BY); } else { - return this.getToken(SqlBaseParser.BY, i); + return this.getToken(SparkSqlParser.BY, i); } }; @@ -10895,19 +10895,19 @@ BucketSpecContext.prototype.identifierList = function() { }; BucketSpecContext.prototype.INTO = function() { - return this.getToken(SqlBaseParser.INTO, 0); + return this.getToken(SparkSqlParser.INTO, 0); }; BucketSpecContext.prototype.INTEGER_VALUE = function() { - return this.getToken(SqlBaseParser.INTEGER_VALUE, 0); + return this.getToken(SparkSqlParser.INTEGER_VALUE, 0); }; BucketSpecContext.prototype.BUCKETS = function() { - return this.getToken(SqlBaseParser.BUCKETS, 0); + return this.getToken(SparkSqlParser.BUCKETS, 0); }; BucketSpecContext.prototype.SORTED = function() { - return this.getToken(SqlBaseParser.SORTED, 0); + return this.getToken(SparkSqlParser.SORTED, 0); }; BucketSpecContext.prototype.orderedIdentifierList = function() { @@ -10915,19 +10915,19 @@ BucketSpecContext.prototype.orderedIdentifierList = function() { }; BucketSpecContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterBucketSpec(this); } }; BucketSpecContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitBucketSpec(this); } }; BucketSpecContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitBucketSpec(this); } else { return visitor.visitChildren(this); @@ -10937,39 +10937,39 @@ BucketSpecContext.prototype.accept = function(visitor) { -SqlBaseParser.BucketSpecContext = BucketSpecContext; +SparkSqlParser.BucketSpecContext = BucketSpecContext; -SqlBaseParser.prototype.bucketSpec = function() { +SparkSqlParser.prototype.bucketSpec = function() { var localctx = new BucketSpecContext(this, this._ctx, this.state); - this.enterRule(localctx, 24, SqlBaseParser.RULE_bucketSpec); + this.enterRule(localctx, 24, SparkSqlParser.RULE_bucketSpec); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1240; - this.match(SqlBaseParser.CLUSTERED); + this.match(SparkSqlParser.CLUSTERED); this.state = 1241; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1242; this.identifierList(); this.state = 1246; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.SORTED) { + if(_la===SparkSqlParser.SORTED) { this.state = 1243; - this.match(SqlBaseParser.SORTED); + this.match(SparkSqlParser.SORTED); this.state = 1244; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1245; this.orderedIdentifierList(); } this.state = 1248; - this.match(SqlBaseParser.INTO); + this.match(SparkSqlParser.INTO); this.state = 1249; - this.match(SqlBaseParser.INTEGER_VALUE); + this.match(SparkSqlParser.INTEGER_VALUE); this.state = 1250; - this.match(SqlBaseParser.BUCKETS); + this.match(SparkSqlParser.BUCKETS); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -10994,7 +10994,7 @@ function SkewSpecContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_skewSpec; + this.ruleIndex = SparkSqlParser.RULE_skewSpec; return this; } @@ -11002,11 +11002,11 @@ SkewSpecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); SkewSpecContext.prototype.constructor = SkewSpecContext; SkewSpecContext.prototype.SKEWED = function() { - return this.getToken(SqlBaseParser.SKEWED, 0); + return this.getToken(SparkSqlParser.SKEWED, 0); }; SkewSpecContext.prototype.BY = function() { - return this.getToken(SqlBaseParser.BY, 0); + return this.getToken(SparkSqlParser.BY, 0); }; SkewSpecContext.prototype.identifierList = function() { @@ -11014,7 +11014,7 @@ SkewSpecContext.prototype.identifierList = function() { }; SkewSpecContext.prototype.ON = function() { - return this.getToken(SqlBaseParser.ON, 0); + return this.getToken(SparkSqlParser.ON, 0); }; SkewSpecContext.prototype.constantList = function() { @@ -11026,31 +11026,31 @@ SkewSpecContext.prototype.nestedConstantList = function() { }; SkewSpecContext.prototype.STORED = function() { - return this.getToken(SqlBaseParser.STORED, 0); + return this.getToken(SparkSqlParser.STORED, 0); }; SkewSpecContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; SkewSpecContext.prototype.DIRECTORIES = function() { - return this.getToken(SqlBaseParser.DIRECTORIES, 0); + return this.getToken(SparkSqlParser.DIRECTORIES, 0); }; SkewSpecContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSkewSpec(this); } }; SkewSpecContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSkewSpec(this); } }; SkewSpecContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSkewSpec(this); } else { return visitor.visitChildren(this); @@ -11060,22 +11060,22 @@ SkewSpecContext.prototype.accept = function(visitor) { -SqlBaseParser.SkewSpecContext = SkewSpecContext; +SparkSqlParser.SkewSpecContext = SkewSpecContext; -SqlBaseParser.prototype.skewSpec = function() { +SparkSqlParser.prototype.skewSpec = function() { var localctx = new SkewSpecContext(this, this._ctx, this.state); - this.enterRule(localctx, 26, SqlBaseParser.RULE_skewSpec); + this.enterRule(localctx, 26, SparkSqlParser.RULE_skewSpec); try { this.enterOuterAlt(localctx, 1); this.state = 1252; - this.match(SqlBaseParser.SKEWED); + this.match(SparkSqlParser.SKEWED); this.state = 1253; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1254; this.identifierList(); this.state = 1255; - this.match(SqlBaseParser.ON); + this.match(SparkSqlParser.ON); this.state = 1258; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,124,this._ctx); @@ -11096,11 +11096,11 @@ SqlBaseParser.prototype.skewSpec = function() { var la_ = this._interp.adaptivePredict(this._input,125,this._ctx); if(la_===1) { this.state = 1260; - this.match(SqlBaseParser.STORED); + this.match(SparkSqlParser.STORED); this.state = 1261; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 1262; - this.match(SqlBaseParser.DIRECTORIES); + this.match(SparkSqlParser.DIRECTORIES); } } catch (re) { @@ -11127,7 +11127,7 @@ function LocationSpecContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_locationSpec; + this.ruleIndex = SparkSqlParser.RULE_locationSpec; return this; } @@ -11135,27 +11135,27 @@ LocationSpecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype LocationSpecContext.prototype.constructor = LocationSpecContext; LocationSpecContext.prototype.LOCATION = function() { - return this.getToken(SqlBaseParser.LOCATION, 0); + return this.getToken(SparkSqlParser.LOCATION, 0); }; LocationSpecContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; LocationSpecContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLocationSpec(this); } }; LocationSpecContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLocationSpec(this); } }; LocationSpecContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLocationSpec(this); } else { return visitor.visitChildren(this); @@ -11165,18 +11165,18 @@ LocationSpecContext.prototype.accept = function(visitor) { -SqlBaseParser.LocationSpecContext = LocationSpecContext; +SparkSqlParser.LocationSpecContext = LocationSpecContext; -SqlBaseParser.prototype.locationSpec = function() { +SparkSqlParser.prototype.locationSpec = function() { var localctx = new LocationSpecContext(this, this._ctx, this.state); - this.enterRule(localctx, 28, SqlBaseParser.RULE_locationSpec); + this.enterRule(localctx, 28, SparkSqlParser.RULE_locationSpec); try { this.enterOuterAlt(localctx, 1); this.state = 1265; - this.match(SqlBaseParser.LOCATION); + this.match(SparkSqlParser.LOCATION); this.state = 1266; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -11201,7 +11201,7 @@ function CommentSpecContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_commentSpec; + this.ruleIndex = SparkSqlParser.RULE_commentSpec; return this; } @@ -11209,27 +11209,27 @@ CommentSpecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) CommentSpecContext.prototype.constructor = CommentSpecContext; CommentSpecContext.prototype.COMMENT = function() { - return this.getToken(SqlBaseParser.COMMENT, 0); + return this.getToken(SparkSqlParser.COMMENT, 0); }; CommentSpecContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; CommentSpecContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCommentSpec(this); } }; CommentSpecContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCommentSpec(this); } }; CommentSpecContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCommentSpec(this); } else { return visitor.visitChildren(this); @@ -11239,18 +11239,18 @@ CommentSpecContext.prototype.accept = function(visitor) { -SqlBaseParser.CommentSpecContext = CommentSpecContext; +SparkSqlParser.CommentSpecContext = CommentSpecContext; -SqlBaseParser.prototype.commentSpec = function() { +SparkSqlParser.prototype.commentSpec = function() { var localctx = new CommentSpecContext(this, this._ctx, this.state); - this.enterRule(localctx, 30, SqlBaseParser.RULE_commentSpec); + this.enterRule(localctx, 30, SparkSqlParser.RULE_commentSpec); try { this.enterOuterAlt(localctx, 1); this.state = 1268; - this.match(SqlBaseParser.COMMENT); + this.match(SparkSqlParser.COMMENT); this.state = 1269; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -11275,7 +11275,7 @@ function QueryContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_query; + this.ruleIndex = SparkSqlParser.RULE_query; return this; } @@ -11295,19 +11295,19 @@ QueryContext.prototype.ctes = function() { }; QueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQuery(this); } }; QueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQuery(this); } }; QueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQuery(this); } else { return visitor.visitChildren(this); @@ -11317,19 +11317,19 @@ QueryContext.prototype.accept = function(visitor) { -SqlBaseParser.QueryContext = QueryContext; +SparkSqlParser.QueryContext = QueryContext; -SqlBaseParser.prototype.query = function() { +SparkSqlParser.prototype.query = function() { var localctx = new QueryContext(this, this._ctx, this.state); - this.enterRule(localctx, 32, SqlBaseParser.RULE_query); + this.enterRule(localctx, 32, SparkSqlParser.RULE_query); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1272; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.WITH) { + if(_la===SparkSqlParser.WITH) { this.state = 1271; this.ctes(); } @@ -11362,7 +11362,7 @@ function InsertIntoContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_insertInto; + this.ruleIndex = SparkSqlParser.RULE_insertInto; return this; } @@ -11386,26 +11386,26 @@ function InsertOverwriteHiveDirContext(parser, ctx) { InsertOverwriteHiveDirContext.prototype = Object.create(InsertIntoContext.prototype); InsertOverwriteHiveDirContext.prototype.constructor = InsertOverwriteHiveDirContext; -SqlBaseParser.InsertOverwriteHiveDirContext = InsertOverwriteHiveDirContext; +SparkSqlParser.InsertOverwriteHiveDirContext = InsertOverwriteHiveDirContext; InsertOverwriteHiveDirContext.prototype.INSERT = function() { - return this.getToken(SqlBaseParser.INSERT, 0); + return this.getToken(SparkSqlParser.INSERT, 0); }; InsertOverwriteHiveDirContext.prototype.OVERWRITE = function() { - return this.getToken(SqlBaseParser.OVERWRITE, 0); + return this.getToken(SparkSqlParser.OVERWRITE, 0); }; InsertOverwriteHiveDirContext.prototype.DIRECTORY = function() { - return this.getToken(SqlBaseParser.DIRECTORY, 0); + return this.getToken(SparkSqlParser.DIRECTORY, 0); }; InsertOverwriteHiveDirContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; InsertOverwriteHiveDirContext.prototype.LOCAL = function() { - return this.getToken(SqlBaseParser.LOCAL, 0); + return this.getToken(SparkSqlParser.LOCAL, 0); }; InsertOverwriteHiveDirContext.prototype.rowFormat = function() { @@ -11416,19 +11416,19 @@ InsertOverwriteHiveDirContext.prototype.createFileFormat = function() { return this.getTypedRuleContext(CreateFileFormatContext,0); }; InsertOverwriteHiveDirContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInsertOverwriteHiveDir(this); } }; InsertOverwriteHiveDirContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInsertOverwriteHiveDir(this); } }; InsertOverwriteHiveDirContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInsertOverwriteHiveDir(this); } else { return visitor.visitChildren(this); @@ -11446,18 +11446,18 @@ function InsertOverwriteDirContext(parser, ctx) { InsertOverwriteDirContext.prototype = Object.create(InsertIntoContext.prototype); InsertOverwriteDirContext.prototype.constructor = InsertOverwriteDirContext; -SqlBaseParser.InsertOverwriteDirContext = InsertOverwriteDirContext; +SparkSqlParser.InsertOverwriteDirContext = InsertOverwriteDirContext; InsertOverwriteDirContext.prototype.INSERT = function() { - return this.getToken(SqlBaseParser.INSERT, 0); + return this.getToken(SparkSqlParser.INSERT, 0); }; InsertOverwriteDirContext.prototype.OVERWRITE = function() { - return this.getToken(SqlBaseParser.OVERWRITE, 0); + return this.getToken(SparkSqlParser.OVERWRITE, 0); }; InsertOverwriteDirContext.prototype.DIRECTORY = function() { - return this.getToken(SqlBaseParser.DIRECTORY, 0); + return this.getToken(SparkSqlParser.DIRECTORY, 0); }; InsertOverwriteDirContext.prototype.tableProvider = function() { @@ -11465,11 +11465,11 @@ InsertOverwriteDirContext.prototype.tableProvider = function() { }; InsertOverwriteDirContext.prototype.LOCAL = function() { - return this.getToken(SqlBaseParser.LOCAL, 0); + return this.getToken(SparkSqlParser.LOCAL, 0); }; InsertOverwriteDirContext.prototype.OPTIONS = function() { - return this.getToken(SqlBaseParser.OPTIONS, 0); + return this.getToken(SparkSqlParser.OPTIONS, 0); }; InsertOverwriteDirContext.prototype.tablePropertyList = function() { @@ -11477,22 +11477,22 @@ InsertOverwriteDirContext.prototype.tablePropertyList = function() { }; InsertOverwriteDirContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; InsertOverwriteDirContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInsertOverwriteDir(this); } }; InsertOverwriteDirContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInsertOverwriteDir(this); } }; InsertOverwriteDirContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInsertOverwriteDir(this); } else { return visitor.visitChildren(this); @@ -11509,14 +11509,14 @@ function InsertOverwriteTableContext(parser, ctx) { InsertOverwriteTableContext.prototype = Object.create(InsertIntoContext.prototype); InsertOverwriteTableContext.prototype.constructor = InsertOverwriteTableContext; -SqlBaseParser.InsertOverwriteTableContext = InsertOverwriteTableContext; +SparkSqlParser.InsertOverwriteTableContext = InsertOverwriteTableContext; InsertOverwriteTableContext.prototype.INSERT = function() { - return this.getToken(SqlBaseParser.INSERT, 0); + return this.getToken(SparkSqlParser.INSERT, 0); }; InsertOverwriteTableContext.prototype.OVERWRITE = function() { - return this.getToken(SqlBaseParser.OVERWRITE, 0); + return this.getToken(SparkSqlParser.OVERWRITE, 0); }; InsertOverwriteTableContext.prototype.multipartIdentifier = function() { @@ -11524,7 +11524,7 @@ InsertOverwriteTableContext.prototype.multipartIdentifier = function() { }; InsertOverwriteTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; InsertOverwriteTableContext.prototype.partitionSpec = function() { @@ -11532,30 +11532,30 @@ InsertOverwriteTableContext.prototype.partitionSpec = function() { }; InsertOverwriteTableContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; InsertOverwriteTableContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; InsertOverwriteTableContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; InsertOverwriteTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInsertOverwriteTable(this); } }; InsertOverwriteTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInsertOverwriteTable(this); } }; InsertOverwriteTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInsertOverwriteTable(this); } else { return visitor.visitChildren(this); @@ -11572,14 +11572,14 @@ function InsertIntoTableContext(parser, ctx) { InsertIntoTableContext.prototype = Object.create(InsertIntoContext.prototype); InsertIntoTableContext.prototype.constructor = InsertIntoTableContext; -SqlBaseParser.InsertIntoTableContext = InsertIntoTableContext; +SparkSqlParser.InsertIntoTableContext = InsertIntoTableContext; InsertIntoTableContext.prototype.INSERT = function() { - return this.getToken(SqlBaseParser.INSERT, 0); + return this.getToken(SparkSqlParser.INSERT, 0); }; InsertIntoTableContext.prototype.INTO = function() { - return this.getToken(SqlBaseParser.INTO, 0); + return this.getToken(SparkSqlParser.INTO, 0); }; InsertIntoTableContext.prototype.multipartIdentifier = function() { @@ -11587,7 +11587,7 @@ InsertIntoTableContext.prototype.multipartIdentifier = function() { }; InsertIntoTableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; InsertIntoTableContext.prototype.partitionSpec = function() { @@ -11595,30 +11595,30 @@ InsertIntoTableContext.prototype.partitionSpec = function() { }; InsertIntoTableContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; InsertIntoTableContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; InsertIntoTableContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; InsertIntoTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInsertIntoTable(this); } }; InsertIntoTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInsertIntoTable(this); } }; InsertIntoTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInsertIntoTable(this); } else { return visitor.visitChildren(this); @@ -11627,12 +11627,12 @@ InsertIntoTableContext.prototype.accept = function(visitor) { -SqlBaseParser.InsertIntoContext = InsertIntoContext; +SparkSqlParser.InsertIntoContext = InsertIntoContext; -SqlBaseParser.prototype.insertInto = function() { +SparkSqlParser.prototype.insertInto = function() { var localctx = new InsertIntoContext(this, this._ctx, this.state); - this.enterRule(localctx, 34, SqlBaseParser.RULE_insertInto); + this.enterRule(localctx, 34, SparkSqlParser.RULE_insertInto); var _la = 0; // Token type try { this.state = 1332; @@ -11643,15 +11643,15 @@ SqlBaseParser.prototype.insertInto = function() { localctx = new InsertOverwriteTableContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 1277; - this.match(SqlBaseParser.INSERT); + this.match(SparkSqlParser.INSERT); this.state = 1278; - this.match(SqlBaseParser.OVERWRITE); + this.match(SparkSqlParser.OVERWRITE); this.state = 1280; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,127,this._ctx); if(la_===1) { this.state = 1279; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); } this.state = 1282; @@ -11659,19 +11659,19 @@ SqlBaseParser.prototype.insertInto = function() { this.state = 1289; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 1283; this.partitionSpec(); this.state = 1287; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.IF) { + if(_la===SparkSqlParser.IF) { this.state = 1284; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 1285; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 1286; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } } @@ -11682,15 +11682,15 @@ SqlBaseParser.prototype.insertInto = function() { localctx = new InsertIntoTableContext(this, localctx); this.enterOuterAlt(localctx, 2); this.state = 1291; - this.match(SqlBaseParser.INSERT); + this.match(SparkSqlParser.INSERT); this.state = 1292; - this.match(SqlBaseParser.INTO); + this.match(SparkSqlParser.INTO); this.state = 1294; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,130,this._ctx); if(la_===1) { this.state = 1293; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); } this.state = 1296; @@ -11698,7 +11698,7 @@ SqlBaseParser.prototype.insertInto = function() { this.state = 1298; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.PARTITION) { this.state = 1297; this.partitionSpec(); } @@ -11706,13 +11706,13 @@ SqlBaseParser.prototype.insertInto = function() { this.state = 1303; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.IF) { + if(_la===SparkSqlParser.IF) { this.state = 1300; - this.match(SqlBaseParser.IF); + this.match(SparkSqlParser.IF); this.state = 1301; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 1302; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); } break; @@ -11721,25 +11721,25 @@ SqlBaseParser.prototype.insertInto = function() { localctx = new InsertOverwriteHiveDirContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 1305; - this.match(SqlBaseParser.INSERT); + this.match(SparkSqlParser.INSERT); this.state = 1306; - this.match(SqlBaseParser.OVERWRITE); + this.match(SparkSqlParser.OVERWRITE); this.state = 1308; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LOCAL) { + if(_la===SparkSqlParser.LOCAL) { this.state = 1307; - this.match(SqlBaseParser.LOCAL); + this.match(SparkSqlParser.LOCAL); } this.state = 1310; - this.match(SqlBaseParser.DIRECTORY); + this.match(SparkSqlParser.DIRECTORY); this.state = 1311; - localctx.path = this.match(SqlBaseParser.STRING); + localctx.path = this.match(SparkSqlParser.STRING); this.state = 1313; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ROW) { + if(_la===SparkSqlParser.ROW) { this.state = 1312; this.rowFormat(); } @@ -11747,7 +11747,7 @@ SqlBaseParser.prototype.insertInto = function() { this.state = 1316; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.STORED) { + if(_la===SparkSqlParser.STORED) { this.state = 1315; this.createFileFormat(); } @@ -11758,25 +11758,25 @@ SqlBaseParser.prototype.insertInto = function() { localctx = new InsertOverwriteDirContext(this, localctx); this.enterOuterAlt(localctx, 4); this.state = 1318; - this.match(SqlBaseParser.INSERT); + this.match(SparkSqlParser.INSERT); this.state = 1319; - this.match(SqlBaseParser.OVERWRITE); + this.match(SparkSqlParser.OVERWRITE); this.state = 1321; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LOCAL) { + if(_la===SparkSqlParser.LOCAL) { this.state = 1320; - this.match(SqlBaseParser.LOCAL); + this.match(SparkSqlParser.LOCAL); } this.state = 1323; - this.match(SqlBaseParser.DIRECTORY); + this.match(SparkSqlParser.DIRECTORY); this.state = 1325; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.STRING) { + if(_la===SparkSqlParser.STRING) { this.state = 1324; - localctx.path = this.match(SqlBaseParser.STRING); + localctx.path = this.match(SparkSqlParser.STRING); } this.state = 1327; @@ -11784,9 +11784,9 @@ SqlBaseParser.prototype.insertInto = function() { this.state = 1330; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OPTIONS) { + if(_la===SparkSqlParser.OPTIONS) { this.state = 1328; - this.match(SqlBaseParser.OPTIONS); + this.match(SparkSqlParser.OPTIONS); this.state = 1329; this.tablePropertyList(); } @@ -11818,7 +11818,7 @@ function PartitionSpecLocationContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_partitionSpecLocation; + this.ruleIndex = SparkSqlParser.RULE_partitionSpecLocation; return this; } @@ -11834,19 +11834,19 @@ PartitionSpecLocationContext.prototype.locationSpec = function() { }; PartitionSpecLocationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPartitionSpecLocation(this); } }; PartitionSpecLocationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPartitionSpecLocation(this); } }; PartitionSpecLocationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPartitionSpecLocation(this); } else { return visitor.visitChildren(this); @@ -11856,12 +11856,12 @@ PartitionSpecLocationContext.prototype.accept = function(visitor) { -SqlBaseParser.PartitionSpecLocationContext = PartitionSpecLocationContext; +SparkSqlParser.PartitionSpecLocationContext = PartitionSpecLocationContext; -SqlBaseParser.prototype.partitionSpecLocation = function() { +SparkSqlParser.prototype.partitionSpecLocation = function() { var localctx = new PartitionSpecLocationContext(this, this._ctx, this.state); - this.enterRule(localctx, 36, SqlBaseParser.RULE_partitionSpecLocation); + this.enterRule(localctx, 36, SparkSqlParser.RULE_partitionSpecLocation); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -11870,7 +11870,7 @@ SqlBaseParser.prototype.partitionSpecLocation = function() { this.state = 1336; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LOCATION) { + if(_la===SparkSqlParser.LOCATION) { this.state = 1335; this.locationSpec(); } @@ -11899,7 +11899,7 @@ function PartitionSpecContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_partitionSpec; + this.ruleIndex = SparkSqlParser.RULE_partitionSpec; return this; } @@ -11907,7 +11907,7 @@ PartitionSpecContext.prototype = Object.create(antlr4.ParserRuleContext.prototyp PartitionSpecContext.prototype.constructor = PartitionSpecContext; PartitionSpecContext.prototype.PARTITION = function() { - return this.getToken(SqlBaseParser.PARTITION, 0); + return this.getToken(SparkSqlParser.PARTITION, 0); }; PartitionSpecContext.prototype.partitionVal = function(i) { @@ -11922,19 +11922,19 @@ PartitionSpecContext.prototype.partitionVal = function(i) { }; PartitionSpecContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPartitionSpec(this); } }; PartitionSpecContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPartitionSpec(this); } }; PartitionSpecContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPartitionSpec(this); } else { return visitor.visitChildren(this); @@ -11944,27 +11944,27 @@ PartitionSpecContext.prototype.accept = function(visitor) { -SqlBaseParser.PartitionSpecContext = PartitionSpecContext; +SparkSqlParser.PartitionSpecContext = PartitionSpecContext; -SqlBaseParser.prototype.partitionSpec = function() { +SparkSqlParser.prototype.partitionSpec = function() { var localctx = new PartitionSpecContext(this, this._ctx, this.state); - this.enterRule(localctx, 38, SqlBaseParser.RULE_partitionSpec); + this.enterRule(localctx, 38, SparkSqlParser.RULE_partitionSpec); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1338; - this.match(SqlBaseParser.PARTITION); + this.match(SparkSqlParser.PARTITION); this.state = 1339; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1340; this.partitionVal(); this.state = 1345; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1341; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1342; this.partitionVal(); this.state = 1347; @@ -11972,7 +11972,7 @@ SqlBaseParser.prototype.partitionSpec = function() { _la = this._input.LA(1); } this.state = 1348; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -11997,7 +11997,7 @@ function PartitionValContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_partitionVal; + this.ruleIndex = SparkSqlParser.RULE_partitionVal; return this; } @@ -12009,7 +12009,7 @@ PartitionValContext.prototype.identifier = function() { }; PartitionValContext.prototype.EQ = function() { - return this.getToken(SqlBaseParser.EQ, 0); + return this.getToken(SparkSqlParser.EQ, 0); }; PartitionValContext.prototype.constant = function() { @@ -12017,19 +12017,19 @@ PartitionValContext.prototype.constant = function() { }; PartitionValContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPartitionVal(this); } }; PartitionValContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPartitionVal(this); } }; PartitionValContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPartitionVal(this); } else { return visitor.visitChildren(this); @@ -12039,12 +12039,12 @@ PartitionValContext.prototype.accept = function(visitor) { -SqlBaseParser.PartitionValContext = PartitionValContext; +SparkSqlParser.PartitionValContext = PartitionValContext; -SqlBaseParser.prototype.partitionVal = function() { +SparkSqlParser.prototype.partitionVal = function() { var localctx = new PartitionValContext(this, this._ctx, this.state); - this.enterRule(localctx, 40, SqlBaseParser.RULE_partitionVal); + this.enterRule(localctx, 40, SparkSqlParser.RULE_partitionVal); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -12053,9 +12053,9 @@ SqlBaseParser.prototype.partitionVal = function() { this.state = 1353; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.EQ) { + if(_la===SparkSqlParser.EQ) { this.state = 1351; - this.match(SqlBaseParser.EQ); + this.match(SparkSqlParser.EQ); this.state = 1352; this.constant(); } @@ -12084,7 +12084,7 @@ function NamespaceContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_namespace; + this.ruleIndex = SparkSqlParser.RULE_namespace; return this; } @@ -12092,31 +12092,31 @@ NamespaceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); NamespaceContext.prototype.constructor = NamespaceContext; NamespaceContext.prototype.NAMESPACE = function() { - return this.getToken(SqlBaseParser.NAMESPACE, 0); + return this.getToken(SparkSqlParser.NAMESPACE, 0); }; NamespaceContext.prototype.DATABASE = function() { - return this.getToken(SqlBaseParser.DATABASE, 0); + return this.getToken(SparkSqlParser.DATABASE, 0); }; NamespaceContext.prototype.SCHEMA = function() { - return this.getToken(SqlBaseParser.SCHEMA, 0); + return this.getToken(SparkSqlParser.SCHEMA, 0); }; NamespaceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNamespace(this); } }; NamespaceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNamespace(this); } }; NamespaceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNamespace(this); } else { return visitor.visitChildren(this); @@ -12126,18 +12126,18 @@ NamespaceContext.prototype.accept = function(visitor) { -SqlBaseParser.NamespaceContext = NamespaceContext; +SparkSqlParser.NamespaceContext = NamespaceContext; -SqlBaseParser.prototype.namespace = function() { +SparkSqlParser.prototype.namespace = function() { var localctx = new NamespaceContext(this, this._ctx, this.state); - this.enterRule(localctx, 42, SqlBaseParser.RULE_namespace); + this.enterRule(localctx, 42, SparkSqlParser.RULE_namespace); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1355; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DATABASE || _la===SqlBaseParser.NAMESPACE || _la===SqlBaseParser.SCHEMA)) { + if(!(_la===SparkSqlParser.DATABASE || _la===SparkSqlParser.NAMESPACE || _la===SparkSqlParser.SCHEMA)) { this._errHandler.recoverInline(this); } else { @@ -12168,7 +12168,7 @@ function DescribeFuncNameContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_describeFuncName; + this.ruleIndex = SparkSqlParser.RULE_describeFuncName; return this; } @@ -12180,7 +12180,7 @@ DescribeFuncNameContext.prototype.qualifiedName = function() { }; DescribeFuncNameContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; DescribeFuncNameContext.prototype.comparisonOperator = function() { @@ -12196,19 +12196,19 @@ DescribeFuncNameContext.prototype.predicateOperator = function() { }; DescribeFuncNameContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDescribeFuncName(this); } }; DescribeFuncNameContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDescribeFuncName(this); } }; DescribeFuncNameContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDescribeFuncName(this); } else { return visitor.visitChildren(this); @@ -12218,12 +12218,12 @@ DescribeFuncNameContext.prototype.accept = function(visitor) { -SqlBaseParser.DescribeFuncNameContext = DescribeFuncNameContext; +SparkSqlParser.DescribeFuncNameContext = DescribeFuncNameContext; -SqlBaseParser.prototype.describeFuncName = function() { +SparkSqlParser.prototype.describeFuncName = function() { var localctx = new DescribeFuncNameContext(this, this._ctx, this.state); - this.enterRule(localctx, 44, SqlBaseParser.RULE_describeFuncName); + this.enterRule(localctx, 44, SparkSqlParser.RULE_describeFuncName); try { this.state = 1362; this._errHandler.sync(this); @@ -12238,7 +12238,7 @@ SqlBaseParser.prototype.describeFuncName = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 1358; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; case 3: @@ -12284,7 +12284,7 @@ function DescribeColNameContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_describeColName; + this.ruleIndex = SparkSqlParser.RULE_describeColName; this._identifier = null; // IdentifierContext this.nameParts = []; // of IdentifierContexts return this; @@ -12305,19 +12305,19 @@ DescribeColNameContext.prototype.identifier = function(i) { }; DescribeColNameContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDescribeColName(this); } }; DescribeColNameContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDescribeColName(this); } }; DescribeColNameContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDescribeColName(this); } else { return visitor.visitChildren(this); @@ -12327,12 +12327,12 @@ DescribeColNameContext.prototype.accept = function(visitor) { -SqlBaseParser.DescribeColNameContext = DescribeColNameContext; +SparkSqlParser.DescribeColNameContext = DescribeColNameContext; -SqlBaseParser.prototype.describeColName = function() { +SparkSqlParser.prototype.describeColName = function() { var localctx = new DescribeColNameContext(this, this._ctx, this.state); - this.enterRule(localctx, 46, SqlBaseParser.RULE_describeColName); + this.enterRule(localctx, 46, SparkSqlParser.RULE_describeColName); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -12342,9 +12342,9 @@ SqlBaseParser.prototype.describeColName = function() { this.state = 1369; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__4) { + while(_la===SparkSqlParser.T__4) { this.state = 1365; - this.match(SqlBaseParser.T__4); + this.match(SparkSqlParser.T__4); this.state = 1366; localctx._identifier = this.identifier(); localctx.nameParts.push(localctx._identifier); @@ -12376,7 +12376,7 @@ function CtesContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_ctes; + this.ruleIndex = SparkSqlParser.RULE_ctes; return this; } @@ -12384,7 +12384,7 @@ CtesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); CtesContext.prototype.constructor = CtesContext; CtesContext.prototype.WITH = function() { - return this.getToken(SqlBaseParser.WITH, 0); + return this.getToken(SparkSqlParser.WITH, 0); }; CtesContext.prototype.namedQuery = function(i) { @@ -12399,19 +12399,19 @@ CtesContext.prototype.namedQuery = function(i) { }; CtesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCtes(this); } }; CtesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCtes(this); } }; CtesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCtes(this); } else { return visitor.visitChildren(this); @@ -12421,25 +12421,25 @@ CtesContext.prototype.accept = function(visitor) { -SqlBaseParser.CtesContext = CtesContext; +SparkSqlParser.CtesContext = CtesContext; -SqlBaseParser.prototype.ctes = function() { +SparkSqlParser.prototype.ctes = function() { var localctx = new CtesContext(this, this._ctx, this.state); - this.enterRule(localctx, 48, SqlBaseParser.RULE_ctes); + this.enterRule(localctx, 48, SparkSqlParser.RULE_ctes); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1372; - this.match(SqlBaseParser.WITH); + this.match(SparkSqlParser.WITH); this.state = 1373; this.namedQuery(); this.state = 1378; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1374; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1375; this.namedQuery(); this.state = 1380; @@ -12470,7 +12470,7 @@ function NamedQueryContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_namedQuery; + this.ruleIndex = SparkSqlParser.RULE_namedQuery; this.name = null; // ErrorCapturingIdentifierContext this.columnAliases = null; // IdentifierListContext return this; @@ -12488,7 +12488,7 @@ NamedQueryContext.prototype.errorCapturingIdentifier = function() { }; NamedQueryContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; NamedQueryContext.prototype.identifierList = function() { @@ -12496,19 +12496,19 @@ NamedQueryContext.prototype.identifierList = function() { }; NamedQueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNamedQuery(this); } }; NamedQueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNamedQuery(this); } }; NamedQueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNamedQuery(this); } else { return visitor.visitChildren(this); @@ -12518,12 +12518,12 @@ NamedQueryContext.prototype.accept = function(visitor) { -SqlBaseParser.NamedQueryContext = NamedQueryContext; +SparkSqlParser.NamedQueryContext = NamedQueryContext; -SqlBaseParser.prototype.namedQuery = function() { +SparkSqlParser.prototype.namedQuery = function() { var localctx = new NamedQueryContext(this, this._ctx, this.state); - this.enterRule(localctx, 50, SqlBaseParser.RULE_namedQuery); + this.enterRule(localctx, 50, SparkSqlParser.RULE_namedQuery); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -12540,17 +12540,17 @@ SqlBaseParser.prototype.namedQuery = function() { this.state = 1386; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AS) { + if(_la===SparkSqlParser.AS) { this.state = 1385; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 1388; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1389; this.query(); this.state = 1390; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -12575,7 +12575,7 @@ function TableProviderContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_tableProvider; + this.ruleIndex = SparkSqlParser.RULE_tableProvider; return this; } @@ -12583,7 +12583,7 @@ TableProviderContext.prototype = Object.create(antlr4.ParserRuleContext.prototyp TableProviderContext.prototype.constructor = TableProviderContext; TableProviderContext.prototype.USING = function() { - return this.getToken(SqlBaseParser.USING, 0); + return this.getToken(SparkSqlParser.USING, 0); }; TableProviderContext.prototype.multipartIdentifier = function() { @@ -12591,19 +12591,19 @@ TableProviderContext.prototype.multipartIdentifier = function() { }; TableProviderContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTableProvider(this); } }; TableProviderContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTableProvider(this); } }; TableProviderContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTableProvider(this); } else { return visitor.visitChildren(this); @@ -12613,16 +12613,16 @@ TableProviderContext.prototype.accept = function(visitor) { -SqlBaseParser.TableProviderContext = TableProviderContext; +SparkSqlParser.TableProviderContext = TableProviderContext; -SqlBaseParser.prototype.tableProvider = function() { +SparkSqlParser.prototype.tableProvider = function() { var localctx = new TableProviderContext(this, this._ctx, this.state); - this.enterRule(localctx, 52, SqlBaseParser.RULE_tableProvider); + this.enterRule(localctx, 52, SparkSqlParser.RULE_tableProvider); try { this.enterOuterAlt(localctx, 1); this.state = 1392; - this.match(SqlBaseParser.USING); + this.match(SparkSqlParser.USING); this.state = 1393; this.multipartIdentifier(); } catch (re) { @@ -12649,7 +12649,7 @@ function CreateTableClausesContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_createTableClauses; + this.ruleIndex = SparkSqlParser.RULE_createTableClauses; this.partitioning = null; // TransformListContext this.tableProps = null; // TablePropertyListContext return this; @@ -12696,9 +12696,9 @@ CreateTableClausesContext.prototype.OPTIONS = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.OPTIONS); + return this.getTokens(SparkSqlParser.OPTIONS); } else { - return this.getToken(SqlBaseParser.OPTIONS, i); + return this.getToken(SparkSqlParser.OPTIONS, i); } }; @@ -12719,9 +12719,9 @@ CreateTableClausesContext.prototype.PARTITIONED = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.PARTITIONED); + return this.getTokens(SparkSqlParser.PARTITIONED); } else { - return this.getToken(SqlBaseParser.PARTITIONED, i); + return this.getToken(SparkSqlParser.PARTITIONED, i); } }; @@ -12731,9 +12731,9 @@ CreateTableClausesContext.prototype.BY = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.BY); + return this.getTokens(SparkSqlParser.BY); } else { - return this.getToken(SqlBaseParser.BY, i); + return this.getToken(SparkSqlParser.BY, i); } }; @@ -12743,9 +12743,9 @@ CreateTableClausesContext.prototype.TBLPROPERTIES = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.TBLPROPERTIES); + return this.getTokens(SparkSqlParser.TBLPROPERTIES); } else { - return this.getToken(SqlBaseParser.TBLPROPERTIES, i); + return this.getToken(SparkSqlParser.TBLPROPERTIES, i); } }; @@ -12762,19 +12762,19 @@ CreateTableClausesContext.prototype.transformList = function(i) { }; CreateTableClausesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateTableClauses(this); } }; CreateTableClausesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateTableClauses(this); } }; CreateTableClausesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateTableClauses(this); } else { return visitor.visitChildren(this); @@ -12784,51 +12784,51 @@ CreateTableClausesContext.prototype.accept = function(visitor) { -SqlBaseParser.CreateTableClausesContext = CreateTableClausesContext; +SparkSqlParser.CreateTableClausesContext = CreateTableClausesContext; -SqlBaseParser.prototype.createTableClauses = function() { +SparkSqlParser.prototype.createTableClauses = function() { var localctx = new CreateTableClausesContext(this, this._ctx, this.state); - this.enterRule(localctx, 54, SqlBaseParser.RULE_createTableClauses); + this.enterRule(localctx, 54, SparkSqlParser.RULE_createTableClauses); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1407; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.CLUSTERED || _la===SqlBaseParser.COMMENT || ((((_la - 137)) & ~0x1f) == 0 && ((1 << (_la - 137)) & ((1 << (SqlBaseParser.LOCATION - 137)) | (1 << (SqlBaseParser.OPTIONS - 137)) | (1 << (SqlBaseParser.PARTITIONED - 137)))) !== 0) || _la===SqlBaseParser.TBLPROPERTIES) { + while(_la===SparkSqlParser.CLUSTERED || _la===SparkSqlParser.COMMENT || ((((_la - 137)) & ~0x1f) == 0 && ((1 << (_la - 137)) & ((1 << (SparkSqlParser.LOCATION - 137)) | (1 << (SparkSqlParser.OPTIONS - 137)) | (1 << (SparkSqlParser.PARTITIONED - 137)))) !== 0) || _la===SparkSqlParser.TBLPROPERTIES) { this.state = 1405; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.OPTIONS: + case SparkSqlParser.OPTIONS: this.state = 1395; - this.match(SqlBaseParser.OPTIONS); + this.match(SparkSqlParser.OPTIONS); this.state = 1396; this.tablePropertyList(); break; - case SqlBaseParser.PARTITIONED: + case SparkSqlParser.PARTITIONED: this.state = 1397; - this.match(SqlBaseParser.PARTITIONED); + this.match(SparkSqlParser.PARTITIONED); this.state = 1398; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1399; localctx.partitioning = this.transformList(); break; - case SqlBaseParser.CLUSTERED: + case SparkSqlParser.CLUSTERED: this.state = 1400; this.bucketSpec(); break; - case SqlBaseParser.LOCATION: + case SparkSqlParser.LOCATION: this.state = 1401; this.locationSpec(); break; - case SqlBaseParser.COMMENT: + case SparkSqlParser.COMMENT: this.state = 1402; this.commentSpec(); break; - case SqlBaseParser.TBLPROPERTIES: + case SparkSqlParser.TBLPROPERTIES: this.state = 1403; - this.match(SqlBaseParser.TBLPROPERTIES); + this.match(SparkSqlParser.TBLPROPERTIES); this.state = 1404; localctx.tableProps = this.tablePropertyList(); break; @@ -12863,7 +12863,7 @@ function TablePropertyListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_tablePropertyList; + this.ruleIndex = SparkSqlParser.RULE_tablePropertyList; return this; } @@ -12882,19 +12882,19 @@ TablePropertyListContext.prototype.tableProperty = function(i) { }; TablePropertyListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTablePropertyList(this); } }; TablePropertyListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTablePropertyList(this); } }; TablePropertyListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTablePropertyList(this); } else { return visitor.visitChildren(this); @@ -12904,25 +12904,25 @@ TablePropertyListContext.prototype.accept = function(visitor) { -SqlBaseParser.TablePropertyListContext = TablePropertyListContext; +SparkSqlParser.TablePropertyListContext = TablePropertyListContext; -SqlBaseParser.prototype.tablePropertyList = function() { +SparkSqlParser.prototype.tablePropertyList = function() { var localctx = new TablePropertyListContext(this, this._ctx, this.state); - this.enterRule(localctx, 56, SqlBaseParser.RULE_tablePropertyList); + this.enterRule(localctx, 56, SparkSqlParser.RULE_tablePropertyList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1410; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1411; this.tableProperty(); this.state = 1416; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1412; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1413; this.tableProperty(); this.state = 1418; @@ -12930,7 +12930,7 @@ SqlBaseParser.prototype.tablePropertyList = function() { _la = this._input.LA(1); } this.state = 1419; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -12955,7 +12955,7 @@ function TablePropertyContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_tableProperty; + this.ruleIndex = SparkSqlParser.RULE_tableProperty; this.key = null; // TablePropertyKeyContext this.value = null; // TablePropertyValueContext return this; @@ -12973,23 +12973,23 @@ TablePropertyContext.prototype.tablePropertyValue = function() { }; TablePropertyContext.prototype.EQ = function() { - return this.getToken(SqlBaseParser.EQ, 0); + return this.getToken(SparkSqlParser.EQ, 0); }; TablePropertyContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTableProperty(this); } }; TablePropertyContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTableProperty(this); } }; TablePropertyContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTableProperty(this); } else { return visitor.visitChildren(this); @@ -12999,12 +12999,12 @@ TablePropertyContext.prototype.accept = function(visitor) { -SqlBaseParser.TablePropertyContext = TablePropertyContext; +SparkSqlParser.TablePropertyContext = TablePropertyContext; -SqlBaseParser.prototype.tableProperty = function() { +SparkSqlParser.prototype.tableProperty = function() { var localctx = new TablePropertyContext(this, this._ctx, this.state); - this.enterRule(localctx, 58, SqlBaseParser.RULE_tableProperty); + this.enterRule(localctx, 58, SparkSqlParser.RULE_tableProperty); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -13013,13 +13013,13 @@ SqlBaseParser.prototype.tableProperty = function() { this.state = 1426; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.FALSE || _la===SqlBaseParser.TRUE || _la===SqlBaseParser.EQ || ((((_la - 279)) & ~0x1f) == 0 && ((1 << (_la - 279)) & ((1 << (SqlBaseParser.STRING - 279)) | (1 << (SqlBaseParser.INTEGER_VALUE - 279)) | (1 << (SqlBaseParser.DECIMAL_VALUE - 279)))) !== 0)) { + if(_la===SparkSqlParser.FALSE || _la===SparkSqlParser.TRUE || _la===SparkSqlParser.EQ || ((((_la - 279)) & ~0x1f) == 0 && ((1 << (_la - 279)) & ((1 << (SparkSqlParser.STRING - 279)) | (1 << (SparkSqlParser.INTEGER_VALUE - 279)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 279)))) !== 0)) { this.state = 1423; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.EQ) { + if(_la===SparkSqlParser.EQ) { this.state = 1422; - this.match(SqlBaseParser.EQ); + this.match(SparkSqlParser.EQ); } this.state = 1425; @@ -13050,7 +13050,7 @@ function TablePropertyKeyContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_tablePropertyKey; + this.ruleIndex = SparkSqlParser.RULE_tablePropertyKey; return this; } @@ -13069,23 +13069,23 @@ TablePropertyKeyContext.prototype.identifier = function(i) { }; TablePropertyKeyContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; TablePropertyKeyContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTablePropertyKey(this); } }; TablePropertyKeyContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTablePropertyKey(this); } }; TablePropertyKeyContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTablePropertyKey(this); } else { return visitor.visitChildren(this); @@ -13095,12 +13095,12 @@ TablePropertyKeyContext.prototype.accept = function(visitor) { -SqlBaseParser.TablePropertyKeyContext = TablePropertyKeyContext; +SparkSqlParser.TablePropertyKeyContext = TablePropertyKeyContext; -SqlBaseParser.prototype.tablePropertyKey = function() { +SparkSqlParser.prototype.tablePropertyKey = function() { var localctx = new TablePropertyKeyContext(this, this._ctx, this.state); - this.enterRule(localctx, 60, SqlBaseParser.RULE_tablePropertyKey); + this.enterRule(localctx, 60, SparkSqlParser.RULE_tablePropertyKey); var _la = 0; // Token type try { this.state = 1437; @@ -13114,9 +13114,9 @@ SqlBaseParser.prototype.tablePropertyKey = function() { this.state = 1433; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__4) { + while(_la===SparkSqlParser.T__4) { this.state = 1429; - this.match(SqlBaseParser.T__4); + this.match(SparkSqlParser.T__4); this.state = 1430; this.identifier(); this.state = 1435; @@ -13128,7 +13128,7 @@ SqlBaseParser.prototype.tablePropertyKey = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 1436; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; } @@ -13156,7 +13156,7 @@ function TablePropertyValueContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_tablePropertyValue; + this.ruleIndex = SparkSqlParser.RULE_tablePropertyValue; return this; } @@ -13164,11 +13164,11 @@ TablePropertyValueContext.prototype = Object.create(antlr4.ParserRuleContext.pro TablePropertyValueContext.prototype.constructor = TablePropertyValueContext; TablePropertyValueContext.prototype.INTEGER_VALUE = function() { - return this.getToken(SqlBaseParser.INTEGER_VALUE, 0); + return this.getToken(SparkSqlParser.INTEGER_VALUE, 0); }; TablePropertyValueContext.prototype.DECIMAL_VALUE = function() { - return this.getToken(SqlBaseParser.DECIMAL_VALUE, 0); + return this.getToken(SparkSqlParser.DECIMAL_VALUE, 0); }; TablePropertyValueContext.prototype.booleanValue = function() { @@ -13176,23 +13176,23 @@ TablePropertyValueContext.prototype.booleanValue = function() { }; TablePropertyValueContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; TablePropertyValueContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTablePropertyValue(this); } }; TablePropertyValueContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTablePropertyValue(this); } }; TablePropertyValueContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTablePropertyValue(this); } else { return visitor.visitChildren(this); @@ -13202,36 +13202,36 @@ TablePropertyValueContext.prototype.accept = function(visitor) { -SqlBaseParser.TablePropertyValueContext = TablePropertyValueContext; +SparkSqlParser.TablePropertyValueContext = TablePropertyValueContext; -SqlBaseParser.prototype.tablePropertyValue = function() { +SparkSqlParser.prototype.tablePropertyValue = function() { var localctx = new TablePropertyValueContext(this, this._ctx, this.state); - this.enterRule(localctx, 62, SqlBaseParser.RULE_tablePropertyValue); + this.enterRule(localctx, 62, SparkSqlParser.RULE_tablePropertyValue); try { this.state = 1443; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.INTEGER_VALUE: + case SparkSqlParser.INTEGER_VALUE: this.enterOuterAlt(localctx, 1); this.state = 1439; - this.match(SqlBaseParser.INTEGER_VALUE); + this.match(SparkSqlParser.INTEGER_VALUE); break; - case SqlBaseParser.DECIMAL_VALUE: + case SparkSqlParser.DECIMAL_VALUE: this.enterOuterAlt(localctx, 2); this.state = 1440; - this.match(SqlBaseParser.DECIMAL_VALUE); + this.match(SparkSqlParser.DECIMAL_VALUE); break; - case SqlBaseParser.FALSE: - case SqlBaseParser.TRUE: + case SparkSqlParser.FALSE: + case SparkSqlParser.TRUE: this.enterOuterAlt(localctx, 3); this.state = 1441; this.booleanValue(); break; - case SqlBaseParser.STRING: + case SparkSqlParser.STRING: this.enterOuterAlt(localctx, 4); this.state = 1442; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; default: throw new antlr4.error.NoViableAltException(this); @@ -13260,7 +13260,7 @@ function ConstantListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_constantList; + this.ruleIndex = SparkSqlParser.RULE_constantList; return this; } @@ -13279,19 +13279,19 @@ ConstantListContext.prototype.constant = function(i) { }; ConstantListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterConstantList(this); } }; ConstantListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitConstantList(this); } }; ConstantListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitConstantList(this); } else { return visitor.visitChildren(this); @@ -13301,25 +13301,25 @@ ConstantListContext.prototype.accept = function(visitor) { -SqlBaseParser.ConstantListContext = ConstantListContext; +SparkSqlParser.ConstantListContext = ConstantListContext; -SqlBaseParser.prototype.constantList = function() { +SparkSqlParser.prototype.constantList = function() { var localctx = new ConstantListContext(this, this._ctx, this.state); - this.enterRule(localctx, 64, SqlBaseParser.RULE_constantList); + this.enterRule(localctx, 64, SparkSqlParser.RULE_constantList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1445; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1446; this.constant(); this.state = 1451; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1447; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1448; this.constant(); this.state = 1453; @@ -13327,7 +13327,7 @@ SqlBaseParser.prototype.constantList = function() { _la = this._input.LA(1); } this.state = 1454; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -13352,7 +13352,7 @@ function NestedConstantListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_nestedConstantList; + this.ruleIndex = SparkSqlParser.RULE_nestedConstantList; return this; } @@ -13371,19 +13371,19 @@ NestedConstantListContext.prototype.constantList = function(i) { }; NestedConstantListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNestedConstantList(this); } }; NestedConstantListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNestedConstantList(this); } }; NestedConstantListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNestedConstantList(this); } else { return visitor.visitChildren(this); @@ -13393,25 +13393,25 @@ NestedConstantListContext.prototype.accept = function(visitor) { -SqlBaseParser.NestedConstantListContext = NestedConstantListContext; +SparkSqlParser.NestedConstantListContext = NestedConstantListContext; -SqlBaseParser.prototype.nestedConstantList = function() { +SparkSqlParser.prototype.nestedConstantList = function() { var localctx = new NestedConstantListContext(this, this._ctx, this.state); - this.enterRule(localctx, 66, SqlBaseParser.RULE_nestedConstantList); + this.enterRule(localctx, 66, SparkSqlParser.RULE_nestedConstantList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1456; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1457; this.constantList(); this.state = 1462; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1458; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1459; this.constantList(); this.state = 1464; @@ -13419,7 +13419,7 @@ SqlBaseParser.prototype.nestedConstantList = function() { _la = this._input.LA(1); } this.state = 1465; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -13444,7 +13444,7 @@ function CreateFileFormatContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_createFileFormat; + this.ruleIndex = SparkSqlParser.RULE_createFileFormat; return this; } @@ -13452,11 +13452,11 @@ CreateFileFormatContext.prototype = Object.create(antlr4.ParserRuleContext.proto CreateFileFormatContext.prototype.constructor = CreateFileFormatContext; CreateFileFormatContext.prototype.STORED = function() { - return this.getToken(SqlBaseParser.STORED, 0); + return this.getToken(SparkSqlParser.STORED, 0); }; CreateFileFormatContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; CreateFileFormatContext.prototype.fileFormat = function() { @@ -13464,7 +13464,7 @@ CreateFileFormatContext.prototype.fileFormat = function() { }; CreateFileFormatContext.prototype.BY = function() { - return this.getToken(SqlBaseParser.BY, 0); + return this.getToken(SparkSqlParser.BY, 0); }; CreateFileFormatContext.prototype.storageHandler = function() { @@ -13472,19 +13472,19 @@ CreateFileFormatContext.prototype.storageHandler = function() { }; CreateFileFormatContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCreateFileFormat(this); } }; CreateFileFormatContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCreateFileFormat(this); } }; CreateFileFormatContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCreateFileFormat(this); } else { return visitor.visitChildren(this); @@ -13494,12 +13494,12 @@ CreateFileFormatContext.prototype.accept = function(visitor) { -SqlBaseParser.CreateFileFormatContext = CreateFileFormatContext; +SparkSqlParser.CreateFileFormatContext = CreateFileFormatContext; -SqlBaseParser.prototype.createFileFormat = function() { +SparkSqlParser.prototype.createFileFormat = function() { var localctx = new CreateFileFormatContext(this, this._ctx, this.state); - this.enterRule(localctx, 68, SqlBaseParser.RULE_createFileFormat); + this.enterRule(localctx, 68, SparkSqlParser.RULE_createFileFormat); try { this.state = 1473; this._errHandler.sync(this); @@ -13508,9 +13508,9 @@ SqlBaseParser.prototype.createFileFormat = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 1467; - this.match(SqlBaseParser.STORED); + this.match(SparkSqlParser.STORED); this.state = 1468; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 1469; this.fileFormat(); break; @@ -13518,9 +13518,9 @@ SqlBaseParser.prototype.createFileFormat = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 1470; - this.match(SqlBaseParser.STORED); + this.match(SparkSqlParser.STORED); this.state = 1471; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1472; this.storageHandler(); break; @@ -13550,7 +13550,7 @@ function FileFormatContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_fileFormat; + this.ruleIndex = SparkSqlParser.RULE_fileFormat; return this; } @@ -13575,14 +13575,14 @@ function TableFileFormatContext(parser, ctx) { TableFileFormatContext.prototype = Object.create(FileFormatContext.prototype); TableFileFormatContext.prototype.constructor = TableFileFormatContext; -SqlBaseParser.TableFileFormatContext = TableFileFormatContext; +SparkSqlParser.TableFileFormatContext = TableFileFormatContext; TableFileFormatContext.prototype.INPUTFORMAT = function() { - return this.getToken(SqlBaseParser.INPUTFORMAT, 0); + return this.getToken(SparkSqlParser.INPUTFORMAT, 0); }; TableFileFormatContext.prototype.OUTPUTFORMAT = function() { - return this.getToken(SqlBaseParser.OUTPUTFORMAT, 0); + return this.getToken(SparkSqlParser.OUTPUTFORMAT, 0); }; TableFileFormatContext.prototype.STRING = function(i) { @@ -13590,26 +13590,26 @@ TableFileFormatContext.prototype.STRING = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.STRING); + return this.getTokens(SparkSqlParser.STRING); } else { - return this.getToken(SqlBaseParser.STRING, i); + return this.getToken(SparkSqlParser.STRING, i); } }; TableFileFormatContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTableFileFormat(this); } }; TableFileFormatContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTableFileFormat(this); } }; TableFileFormatContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTableFileFormat(this); } else { return visitor.visitChildren(this); @@ -13626,25 +13626,25 @@ function GenericFileFormatContext(parser, ctx) { GenericFileFormatContext.prototype = Object.create(FileFormatContext.prototype); GenericFileFormatContext.prototype.constructor = GenericFileFormatContext; -SqlBaseParser.GenericFileFormatContext = GenericFileFormatContext; +SparkSqlParser.GenericFileFormatContext = GenericFileFormatContext; GenericFileFormatContext.prototype.identifier = function() { return this.getTypedRuleContext(IdentifierContext,0); }; GenericFileFormatContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterGenericFileFormat(this); } }; GenericFileFormatContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitGenericFileFormat(this); } }; GenericFileFormatContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitGenericFileFormat(this); } else { return visitor.visitChildren(this); @@ -13653,12 +13653,12 @@ GenericFileFormatContext.prototype.accept = function(visitor) { -SqlBaseParser.FileFormatContext = FileFormatContext; +SparkSqlParser.FileFormatContext = FileFormatContext; -SqlBaseParser.prototype.fileFormat = function() { +SparkSqlParser.prototype.fileFormat = function() { var localctx = new FileFormatContext(this, this._ctx, this.state); - this.enterRule(localctx, 70, SqlBaseParser.RULE_fileFormat); + this.enterRule(localctx, 70, SparkSqlParser.RULE_fileFormat); try { this.state = 1480; this._errHandler.sync(this); @@ -13668,13 +13668,13 @@ SqlBaseParser.prototype.fileFormat = function() { localctx = new TableFileFormatContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 1475; - this.match(SqlBaseParser.INPUTFORMAT); + this.match(SparkSqlParser.INPUTFORMAT); this.state = 1476; - localctx.inFmt = this.match(SqlBaseParser.STRING); + localctx.inFmt = this.match(SparkSqlParser.STRING); this.state = 1477; - this.match(SqlBaseParser.OUTPUTFORMAT); + this.match(SparkSqlParser.OUTPUTFORMAT); this.state = 1478; - localctx.outFmt = this.match(SqlBaseParser.STRING); + localctx.outFmt = this.match(SparkSqlParser.STRING); break; case 2: @@ -13709,7 +13709,7 @@ function StorageHandlerContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_storageHandler; + this.ruleIndex = SparkSqlParser.RULE_storageHandler; return this; } @@ -13717,15 +13717,15 @@ StorageHandlerContext.prototype = Object.create(antlr4.ParserRuleContext.prototy StorageHandlerContext.prototype.constructor = StorageHandlerContext; StorageHandlerContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; StorageHandlerContext.prototype.WITH = function() { - return this.getToken(SqlBaseParser.WITH, 0); + return this.getToken(SparkSqlParser.WITH, 0); }; StorageHandlerContext.prototype.SERDEPROPERTIES = function() { - return this.getToken(SqlBaseParser.SERDEPROPERTIES, 0); + return this.getToken(SparkSqlParser.SERDEPROPERTIES, 0); }; StorageHandlerContext.prototype.tablePropertyList = function() { @@ -13733,19 +13733,19 @@ StorageHandlerContext.prototype.tablePropertyList = function() { }; StorageHandlerContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterStorageHandler(this); } }; StorageHandlerContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitStorageHandler(this); } }; StorageHandlerContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitStorageHandler(this); } else { return visitor.visitChildren(this); @@ -13755,24 +13755,24 @@ StorageHandlerContext.prototype.accept = function(visitor) { -SqlBaseParser.StorageHandlerContext = StorageHandlerContext; +SparkSqlParser.StorageHandlerContext = StorageHandlerContext; -SqlBaseParser.prototype.storageHandler = function() { +SparkSqlParser.prototype.storageHandler = function() { var localctx = new StorageHandlerContext(this, this._ctx, this.state); - this.enterRule(localctx, 72, SqlBaseParser.RULE_storageHandler); + this.enterRule(localctx, 72, SparkSqlParser.RULE_storageHandler); try { this.enterOuterAlt(localctx, 1); this.state = 1482; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); this.state = 1486; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,160,this._ctx); if(la_===1) { this.state = 1483; - this.match(SqlBaseParser.WITH); + this.match(SparkSqlParser.WITH); this.state = 1484; - this.match(SqlBaseParser.SERDEPROPERTIES); + this.match(SparkSqlParser.SERDEPROPERTIES); this.state = 1485; this.tablePropertyList(); @@ -13801,7 +13801,7 @@ function ResourceContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_resource; + this.ruleIndex = SparkSqlParser.RULE_resource; return this; } @@ -13813,23 +13813,23 @@ ResourceContext.prototype.identifier = function() { }; ResourceContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; ResourceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterResource(this); } }; ResourceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitResource(this); } }; ResourceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitResource(this); } else { return visitor.visitChildren(this); @@ -13839,18 +13839,18 @@ ResourceContext.prototype.accept = function(visitor) { -SqlBaseParser.ResourceContext = ResourceContext; +SparkSqlParser.ResourceContext = ResourceContext; -SqlBaseParser.prototype.resource = function() { +SparkSqlParser.prototype.resource = function() { var localctx = new ResourceContext(this, this._ctx, this.state); - this.enterRule(localctx, 74, SqlBaseParser.RULE_resource); + this.enterRule(localctx, 74, SparkSqlParser.RULE_resource); try { this.enterOuterAlt(localctx, 1); this.state = 1488; this.identifier(); this.state = 1489; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -13875,7 +13875,7 @@ function DmlStatementNoWithContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_dmlStatementNoWith; + this.ruleIndex = SparkSqlParser.RULE_dmlStatementNoWith; return this; } @@ -13898,14 +13898,14 @@ function DeleteFromTableContext(parser, ctx) { DeleteFromTableContext.prototype = Object.create(DmlStatementNoWithContext.prototype); DeleteFromTableContext.prototype.constructor = DeleteFromTableContext; -SqlBaseParser.DeleteFromTableContext = DeleteFromTableContext; +SparkSqlParser.DeleteFromTableContext = DeleteFromTableContext; DeleteFromTableContext.prototype.DELETE = function() { - return this.getToken(SqlBaseParser.DELETE, 0); + return this.getToken(SparkSqlParser.DELETE, 0); }; DeleteFromTableContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; DeleteFromTableContext.prototype.multipartIdentifier = function() { @@ -13920,19 +13920,19 @@ DeleteFromTableContext.prototype.whereClause = function() { return this.getTypedRuleContext(WhereClauseContext,0); }; DeleteFromTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDeleteFromTable(this); } }; DeleteFromTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDeleteFromTable(this); } }; DeleteFromTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDeleteFromTable(this); } else { return visitor.visitChildren(this); @@ -13949,7 +13949,7 @@ function SingleInsertQueryContext(parser, ctx) { SingleInsertQueryContext.prototype = Object.create(DmlStatementNoWithContext.prototype); SingleInsertQueryContext.prototype.constructor = SingleInsertQueryContext; -SqlBaseParser.SingleInsertQueryContext = SingleInsertQueryContext; +SparkSqlParser.SingleInsertQueryContext = SingleInsertQueryContext; SingleInsertQueryContext.prototype.insertInto = function() { return this.getTypedRuleContext(InsertIntoContext,0); @@ -13963,19 +13963,19 @@ SingleInsertQueryContext.prototype.queryOrganization = function() { return this.getTypedRuleContext(QueryOrganizationContext,0); }; SingleInsertQueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSingleInsertQuery(this); } }; SingleInsertQueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSingleInsertQuery(this); } }; SingleInsertQueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSingleInsertQuery(this); } else { return visitor.visitChildren(this); @@ -13992,7 +13992,7 @@ function MultiInsertQueryContext(parser, ctx) { MultiInsertQueryContext.prototype = Object.create(DmlStatementNoWithContext.prototype); MultiInsertQueryContext.prototype.constructor = MultiInsertQueryContext; -SqlBaseParser.MultiInsertQueryContext = MultiInsertQueryContext; +SparkSqlParser.MultiInsertQueryContext = MultiInsertQueryContext; MultiInsertQueryContext.prototype.fromClause = function() { return this.getTypedRuleContext(FromClauseContext,0); @@ -14009,19 +14009,19 @@ MultiInsertQueryContext.prototype.multiInsertQueryBody = function(i) { } }; MultiInsertQueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMultiInsertQuery(this); } }; MultiInsertQueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMultiInsertQuery(this); } }; MultiInsertQueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMultiInsertQuery(this); } else { return visitor.visitChildren(this); @@ -14038,10 +14038,10 @@ function UpdateTableContext(parser, ctx) { UpdateTableContext.prototype = Object.create(DmlStatementNoWithContext.prototype); UpdateTableContext.prototype.constructor = UpdateTableContext; -SqlBaseParser.UpdateTableContext = UpdateTableContext; +SparkSqlParser.UpdateTableContext = UpdateTableContext; UpdateTableContext.prototype.UPDATE = function() { - return this.getToken(SqlBaseParser.UPDATE, 0); + return this.getToken(SparkSqlParser.UPDATE, 0); }; UpdateTableContext.prototype.multipartIdentifier = function() { @@ -14060,19 +14060,19 @@ UpdateTableContext.prototype.whereClause = function() { return this.getTypedRuleContext(WhereClauseContext,0); }; UpdateTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterUpdateTable(this); } }; UpdateTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitUpdateTable(this); } }; UpdateTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitUpdateTable(this); } else { return visitor.visitChildren(this); @@ -14095,22 +14095,22 @@ function MergeIntoTableContext(parser, ctx) { MergeIntoTableContext.prototype = Object.create(DmlStatementNoWithContext.prototype); MergeIntoTableContext.prototype.constructor = MergeIntoTableContext; -SqlBaseParser.MergeIntoTableContext = MergeIntoTableContext; +SparkSqlParser.MergeIntoTableContext = MergeIntoTableContext; MergeIntoTableContext.prototype.MERGE = function() { - return this.getToken(SqlBaseParser.MERGE, 0); + return this.getToken(SparkSqlParser.MERGE, 0); }; MergeIntoTableContext.prototype.INTO = function() { - return this.getToken(SqlBaseParser.INTO, 0); + return this.getToken(SparkSqlParser.INTO, 0); }; MergeIntoTableContext.prototype.USING = function() { - return this.getToken(SqlBaseParser.USING, 0); + return this.getToken(SparkSqlParser.USING, 0); }; MergeIntoTableContext.prototype.ON = function() { - return this.getToken(SqlBaseParser.ON, 0); + return this.getToken(SparkSqlParser.ON, 0); }; MergeIntoTableContext.prototype.multipartIdentifier = function(i) { @@ -14165,19 +14165,19 @@ MergeIntoTableContext.prototype.notMatchedClause = function(i) { } }; MergeIntoTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMergeIntoTable(this); } }; MergeIntoTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMergeIntoTable(this); } }; MergeIntoTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMergeIntoTable(this); } else { return visitor.visitChildren(this); @@ -14186,18 +14186,18 @@ MergeIntoTableContext.prototype.accept = function(visitor) { -SqlBaseParser.DmlStatementNoWithContext = DmlStatementNoWithContext; +SparkSqlParser.DmlStatementNoWithContext = DmlStatementNoWithContext; -SqlBaseParser.prototype.dmlStatementNoWith = function() { +SparkSqlParser.prototype.dmlStatementNoWith = function() { var localctx = new DmlStatementNoWithContext(this, this._ctx, this.state); - this.enterRule(localctx, 76, SqlBaseParser.RULE_dmlStatementNoWith); + this.enterRule(localctx, 76, SparkSqlParser.RULE_dmlStatementNoWith); var _la = 0; // Token type try { this.state = 1542; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.INSERT: + case SparkSqlParser.INSERT: localctx = new SingleInsertQueryContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 1491; @@ -14207,7 +14207,7 @@ SqlBaseParser.prototype.dmlStatementNoWith = function() { this.state = 1493; this.queryOrganization(); break; - case SqlBaseParser.FROM: + case SparkSqlParser.FROM: localctx = new MultiInsertQueryContext(this, localctx); this.enterOuterAlt(localctx, 2); this.state = 1495; @@ -14221,15 +14221,15 @@ SqlBaseParser.prototype.dmlStatementNoWith = function() { this.state = 1499; this._errHandler.sync(this); _la = this._input.LA(1); - } while(_la===SqlBaseParser.INSERT); + } while(_la===SparkSqlParser.INSERT); break; - case SqlBaseParser.DELETE: + case SparkSqlParser.DELETE: localctx = new DeleteFromTableContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 1501; - this.match(SqlBaseParser.DELETE); + this.match(SparkSqlParser.DELETE); this.state = 1502; - this.match(SqlBaseParser.FROM); + this.match(SparkSqlParser.FROM); this.state = 1503; this.multipartIdentifier(); this.state = 1504; @@ -14237,17 +14237,17 @@ SqlBaseParser.prototype.dmlStatementNoWith = function() { this.state = 1506; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.WHERE) { + if(_la===SparkSqlParser.WHERE) { this.state = 1505; this.whereClause(); } break; - case SqlBaseParser.UPDATE: + case SparkSqlParser.UPDATE: localctx = new UpdateTableContext(this, localctx); this.enterOuterAlt(localctx, 4); this.state = 1508; - this.match(SqlBaseParser.UPDATE); + this.match(SparkSqlParser.UPDATE); this.state = 1509; this.multipartIdentifier(); this.state = 1510; @@ -14257,25 +14257,25 @@ SqlBaseParser.prototype.dmlStatementNoWith = function() { this.state = 1513; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.WHERE) { + if(_la===SparkSqlParser.WHERE) { this.state = 1512; this.whereClause(); } break; - case SqlBaseParser.MERGE: + case SparkSqlParser.MERGE: localctx = new MergeIntoTableContext(this, localctx); this.enterOuterAlt(localctx, 5); this.state = 1515; - this.match(SqlBaseParser.MERGE); + this.match(SparkSqlParser.MERGE); this.state = 1516; - this.match(SqlBaseParser.INTO); + this.match(SparkSqlParser.INTO); this.state = 1517; localctx.target = this.multipartIdentifier(); this.state = 1518; localctx.targetAlias = this.tableAlias(); this.state = 1519; - this.match(SqlBaseParser.USING); + this.match(SparkSqlParser.USING); this.state = 1525; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,164,this._ctx); @@ -14287,18 +14287,18 @@ SqlBaseParser.prototype.dmlStatementNoWith = function() { case 2: this.state = 1521; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1522; localctx.sourceQuery = this.query(); this.state = 1523; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } this.state = 1527; localctx.sourceAlias = this.tableAlias(); this.state = 1528; - this.match(SqlBaseParser.ON); + this.match(SparkSqlParser.ON); this.state = 1529; localctx.mergeCondition = this.booleanExpression(0); this.state = 1533; @@ -14317,7 +14317,7 @@ SqlBaseParser.prototype.dmlStatementNoWith = function() { this.state = 1539; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.WHEN) { + while(_la===SparkSqlParser.WHEN) { this.state = 1536; this.notMatchedClause(); this.state = 1541; @@ -14352,7 +14352,7 @@ function QueryOrganizationContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_queryOrganization; + this.ruleIndex = SparkSqlParser.RULE_queryOrganization; this._sortItem = null; // SortItemContext this.order = []; // of SortItemContexts this._expression = null; // ExpressionContext @@ -14367,7 +14367,7 @@ QueryOrganizationContext.prototype = Object.create(antlr4.ParserRuleContext.prot QueryOrganizationContext.prototype.constructor = QueryOrganizationContext; QueryOrganizationContext.prototype.ORDER = function() { - return this.getToken(SqlBaseParser.ORDER, 0); + return this.getToken(SparkSqlParser.ORDER, 0); }; QueryOrganizationContext.prototype.BY = function(i) { @@ -14375,23 +14375,23 @@ QueryOrganizationContext.prototype.BY = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.BY); + return this.getTokens(SparkSqlParser.BY); } else { - return this.getToken(SqlBaseParser.BY, i); + return this.getToken(SparkSqlParser.BY, i); } }; QueryOrganizationContext.prototype.CLUSTER = function() { - return this.getToken(SqlBaseParser.CLUSTER, 0); + return this.getToken(SparkSqlParser.CLUSTER, 0); }; QueryOrganizationContext.prototype.DISTRIBUTE = function() { - return this.getToken(SqlBaseParser.DISTRIBUTE, 0); + return this.getToken(SparkSqlParser.DISTRIBUTE, 0); }; QueryOrganizationContext.prototype.SORT = function() { - return this.getToken(SqlBaseParser.SORT, 0); + return this.getToken(SparkSqlParser.SORT, 0); }; QueryOrganizationContext.prototype.windowClause = function() { @@ -14399,7 +14399,7 @@ QueryOrganizationContext.prototype.windowClause = function() { }; QueryOrganizationContext.prototype.LIMIT = function() { - return this.getToken(SqlBaseParser.LIMIT, 0); + return this.getToken(SparkSqlParser.LIMIT, 0); }; QueryOrganizationContext.prototype.sortItem = function(i) { @@ -14425,23 +14425,23 @@ QueryOrganizationContext.prototype.expression = function(i) { }; QueryOrganizationContext.prototype.ALL = function() { - return this.getToken(SqlBaseParser.ALL, 0); + return this.getToken(SparkSqlParser.ALL, 0); }; QueryOrganizationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQueryOrganization(this); } }; QueryOrganizationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQueryOrganization(this); } }; QueryOrganizationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQueryOrganization(this); } else { return visitor.visitChildren(this); @@ -14451,12 +14451,12 @@ QueryOrganizationContext.prototype.accept = function(visitor) { -SqlBaseParser.QueryOrganizationContext = QueryOrganizationContext; +SparkSqlParser.QueryOrganizationContext = QueryOrganizationContext; -SqlBaseParser.prototype.queryOrganization = function() { +SparkSqlParser.prototype.queryOrganization = function() { var localctx = new QueryOrganizationContext(this, this._ctx, this.state); - this.enterRule(localctx, 78, SqlBaseParser.RULE_queryOrganization); + this.enterRule(localctx, 78, SparkSqlParser.RULE_queryOrganization); try { this.enterOuterAlt(localctx, 1); this.state = 1554; @@ -14464,9 +14464,9 @@ SqlBaseParser.prototype.queryOrganization = function() { var la_ = this._interp.adaptivePredict(this._input,169,this._ctx); if(la_===1) { this.state = 1544; - this.match(SqlBaseParser.ORDER); + this.match(SparkSqlParser.ORDER); this.state = 1545; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1546; localctx._sortItem = this.sortItem(); localctx.order.push(localctx._sortItem); @@ -14476,7 +14476,7 @@ SqlBaseParser.prototype.queryOrganization = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 1547; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1548; localctx._sortItem = this.sortItem(); localctx.order.push(localctx._sortItem); @@ -14493,9 +14493,9 @@ SqlBaseParser.prototype.queryOrganization = function() { var la_ = this._interp.adaptivePredict(this._input,171,this._ctx); if(la_===1) { this.state = 1556; - this.match(SqlBaseParser.CLUSTER); + this.match(SparkSqlParser.CLUSTER); this.state = 1557; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1558; localctx._expression = this.expression(); localctx.clusterBy.push(localctx._expression); @@ -14505,7 +14505,7 @@ SqlBaseParser.prototype.queryOrganization = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 1559; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1560; localctx._expression = this.expression(); localctx.clusterBy.push(localctx._expression); @@ -14522,9 +14522,9 @@ SqlBaseParser.prototype.queryOrganization = function() { var la_ = this._interp.adaptivePredict(this._input,173,this._ctx); if(la_===1) { this.state = 1568; - this.match(SqlBaseParser.DISTRIBUTE); + this.match(SparkSqlParser.DISTRIBUTE); this.state = 1569; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1570; localctx._expression = this.expression(); localctx.distributeBy.push(localctx._expression); @@ -14534,7 +14534,7 @@ SqlBaseParser.prototype.queryOrganization = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 1571; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1572; localctx._expression = this.expression(); localctx.distributeBy.push(localctx._expression); @@ -14551,9 +14551,9 @@ SqlBaseParser.prototype.queryOrganization = function() { var la_ = this._interp.adaptivePredict(this._input,175,this._ctx); if(la_===1) { this.state = 1580; - this.match(SqlBaseParser.SORT); + this.match(SparkSqlParser.SORT); this.state = 1581; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1582; localctx._sortItem = this.sortItem(); localctx.sort.push(localctx._sortItem); @@ -14563,7 +14563,7 @@ SqlBaseParser.prototype.queryOrganization = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 1583; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1584; localctx._sortItem = this.sortItem(); localctx.sort.push(localctx._sortItem); @@ -14588,14 +14588,14 @@ SqlBaseParser.prototype.queryOrganization = function() { var la_ = this._interp.adaptivePredict(this._input,178,this._ctx); if(la_===1) { this.state = 1595; - this.match(SqlBaseParser.LIMIT); + this.match(SparkSqlParser.LIMIT); this.state = 1598; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,177,this._ctx); switch(la_) { case 1: this.state = 1596; - this.match(SqlBaseParser.ALL); + this.match(SparkSqlParser.ALL); break; case 2: @@ -14630,7 +14630,7 @@ function MultiInsertQueryBodyContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_multiInsertQueryBody; + this.ruleIndex = SparkSqlParser.RULE_multiInsertQueryBody; return this; } @@ -14646,19 +14646,19 @@ MultiInsertQueryBodyContext.prototype.fromStatementBody = function() { }; MultiInsertQueryBodyContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMultiInsertQueryBody(this); } }; MultiInsertQueryBodyContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMultiInsertQueryBody(this); } }; MultiInsertQueryBodyContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMultiInsertQueryBody(this); } else { return visitor.visitChildren(this); @@ -14668,12 +14668,12 @@ MultiInsertQueryBodyContext.prototype.accept = function(visitor) { -SqlBaseParser.MultiInsertQueryBodyContext = MultiInsertQueryBodyContext; +SparkSqlParser.MultiInsertQueryBodyContext = MultiInsertQueryBodyContext; -SqlBaseParser.prototype.multiInsertQueryBody = function() { +SparkSqlParser.prototype.multiInsertQueryBody = function() { var localctx = new MultiInsertQueryBodyContext(this, this._ctx, this.state); - this.enterRule(localctx, 80, SqlBaseParser.RULE_multiInsertQueryBody); + this.enterRule(localctx, 80, SparkSqlParser.RULE_multiInsertQueryBody); try { this.enterOuterAlt(localctx, 1); this.state = 1602; @@ -14704,7 +14704,7 @@ function QueryTermContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_queryTerm; + this.ruleIndex = SparkSqlParser.RULE_queryTerm; return this; } @@ -14726,25 +14726,25 @@ function QueryTermDefaultContext(parser, ctx) { QueryTermDefaultContext.prototype = Object.create(QueryTermContext.prototype); QueryTermDefaultContext.prototype.constructor = QueryTermDefaultContext; -SqlBaseParser.QueryTermDefaultContext = QueryTermDefaultContext; +SparkSqlParser.QueryTermDefaultContext = QueryTermDefaultContext; QueryTermDefaultContext.prototype.queryPrimary = function() { return this.getTypedRuleContext(QueryPrimaryContext,0); }; QueryTermDefaultContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQueryTermDefault(this); } }; QueryTermDefaultContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQueryTermDefault(this); } }; QueryTermDefaultContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQueryTermDefault(this); } else { return visitor.visitChildren(this); @@ -14764,7 +14764,7 @@ function SetOperationContext(parser, ctx) { SetOperationContext.prototype = Object.create(QueryTermContext.prototype); SetOperationContext.prototype.constructor = SetOperationContext; -SqlBaseParser.SetOperationContext = SetOperationContext; +SparkSqlParser.SetOperationContext = SetOperationContext; SetOperationContext.prototype.queryTerm = function(i) { if(i===undefined) { @@ -14778,38 +14778,38 @@ SetOperationContext.prototype.queryTerm = function(i) { }; SetOperationContext.prototype.INTERSECT = function() { - return this.getToken(SqlBaseParser.INTERSECT, 0); + return this.getToken(SparkSqlParser.INTERSECT, 0); }; SetOperationContext.prototype.UNION = function() { - return this.getToken(SqlBaseParser.UNION, 0); + return this.getToken(SparkSqlParser.UNION, 0); }; SetOperationContext.prototype.EXCEPT = function() { - return this.getToken(SqlBaseParser.EXCEPT, 0); + return this.getToken(SparkSqlParser.EXCEPT, 0); }; SetOperationContext.prototype.SETMINUS = function() { - return this.getToken(SqlBaseParser.SETMINUS, 0); + return this.getToken(SparkSqlParser.SETMINUS, 0); }; SetOperationContext.prototype.setQuantifier = function() { return this.getTypedRuleContext(SetQuantifierContext,0); }; SetOperationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetOperation(this); } }; SetOperationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetOperation(this); } }; SetOperationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetOperation(this); } else { return visitor.visitChildren(this); @@ -14818,7 +14818,7 @@ SetOperationContext.prototype.accept = function(visitor) { -SqlBaseParser.prototype.queryTerm = function(_p) { +SparkSqlParser.prototype.queryTerm = function(_p) { if(_p===undefined) { _p = 0; } @@ -14827,7 +14827,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { var localctx = new QueryTermContext(this, this._ctx, _parentState); var _prevctx = localctx; var _startState = 82; - this.enterRecursionRule(localctx, 82, SqlBaseParser.RULE_queryTerm, _p); + this.enterRecursionRule(localctx, 82, SparkSqlParser.RULE_queryTerm, _p); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -14854,7 +14854,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { case 1: localctx = new SetOperationContext(this, new QueryTermContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_queryTerm); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_queryTerm); this.state = 1608; if (!( this.precpred(this._ctx, 3))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 3)"); @@ -14866,7 +14866,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { this.state = 1610; localctx.operator = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.EXCEPT || _la===SqlBaseParser.INTERSECT || _la===SqlBaseParser.SETMINUS || _la===SqlBaseParser.UNION)) { + if(!(_la===SparkSqlParser.EXCEPT || _la===SparkSqlParser.INTERSECT || _la===SparkSqlParser.SETMINUS || _la===SparkSqlParser.UNION)) { localctx.operator = this._errHandler.recoverInline(this); } else { @@ -14876,7 +14876,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { this.state = 1612; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ALL || _la===SqlBaseParser.DISTINCT) { + if(_la===SparkSqlParser.ALL || _la===SparkSqlParser.DISTINCT) { this.state = 1611; this.setQuantifier(); } @@ -14888,7 +14888,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { case 2: localctx = new SetOperationContext(this, new QueryTermContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_queryTerm); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_queryTerm); this.state = 1615; if (!( this.precpred(this._ctx, 2))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)"); @@ -14898,11 +14898,11 @@ SqlBaseParser.prototype.queryTerm = function(_p) { throw new antlr4.error.FailedPredicateException(this, "!legacy_setops_precedence_enbled"); } this.state = 1617; - localctx.operator = this.match(SqlBaseParser.INTERSECT); + localctx.operator = this.match(SparkSqlParser.INTERSECT); this.state = 1619; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ALL || _la===SqlBaseParser.DISTINCT) { + if(_la===SparkSqlParser.ALL || _la===SparkSqlParser.DISTINCT) { this.state = 1618; this.setQuantifier(); } @@ -14914,7 +14914,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { case 3: localctx = new SetOperationContext(this, new QueryTermContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_queryTerm); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_queryTerm); this.state = 1622; if (!( this.precpred(this._ctx, 1))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)"); @@ -14926,7 +14926,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { this.state = 1624; localctx.operator = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.EXCEPT || _la===SqlBaseParser.SETMINUS || _la===SqlBaseParser.UNION)) { + if(!(_la===SparkSqlParser.EXCEPT || _la===SparkSqlParser.SETMINUS || _la===SparkSqlParser.UNION)) { localctx.operator = this._errHandler.recoverInline(this); } else { @@ -14936,7 +14936,7 @@ SqlBaseParser.prototype.queryTerm = function(_p) { this.state = 1626; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ALL || _la===SqlBaseParser.DISTINCT) { + if(_la===SparkSqlParser.ALL || _la===SparkSqlParser.DISTINCT) { this.state = 1625; this.setQuantifier(); } @@ -14976,7 +14976,7 @@ function QueryPrimaryContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_queryPrimary; + this.ruleIndex = SparkSqlParser.RULE_queryPrimary; return this; } @@ -14999,25 +14999,25 @@ function SubqueryContext(parser, ctx) { SubqueryContext.prototype = Object.create(QueryPrimaryContext.prototype); SubqueryContext.prototype.constructor = SubqueryContext; -SqlBaseParser.SubqueryContext = SubqueryContext; +SparkSqlParser.SubqueryContext = SubqueryContext; SubqueryContext.prototype.query = function() { return this.getTypedRuleContext(QueryContext,0); }; SubqueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSubquery(this); } }; SubqueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSubquery(this); } }; SubqueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSubquery(this); } else { return visitor.visitChildren(this); @@ -15034,25 +15034,25 @@ function QueryPrimaryDefaultContext(parser, ctx) { QueryPrimaryDefaultContext.prototype = Object.create(QueryPrimaryContext.prototype); QueryPrimaryDefaultContext.prototype.constructor = QueryPrimaryDefaultContext; -SqlBaseParser.QueryPrimaryDefaultContext = QueryPrimaryDefaultContext; +SparkSqlParser.QueryPrimaryDefaultContext = QueryPrimaryDefaultContext; QueryPrimaryDefaultContext.prototype.querySpecification = function() { return this.getTypedRuleContext(QuerySpecificationContext,0); }; QueryPrimaryDefaultContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQueryPrimaryDefault(this); } }; QueryPrimaryDefaultContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQueryPrimaryDefault(this); } }; QueryPrimaryDefaultContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQueryPrimaryDefault(this); } else { return visitor.visitChildren(this); @@ -15069,25 +15069,25 @@ function InlineTableDefault1Context(parser, ctx) { InlineTableDefault1Context.prototype = Object.create(QueryPrimaryContext.prototype); InlineTableDefault1Context.prototype.constructor = InlineTableDefault1Context; -SqlBaseParser.InlineTableDefault1Context = InlineTableDefault1Context; +SparkSqlParser.InlineTableDefault1Context = InlineTableDefault1Context; InlineTableDefault1Context.prototype.inlineTable = function() { return this.getTypedRuleContext(InlineTableContext,0); }; InlineTableDefault1Context.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInlineTableDefault1(this); } }; InlineTableDefault1Context.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInlineTableDefault1(this); } }; InlineTableDefault1Context.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInlineTableDefault1(this); } else { return visitor.visitChildren(this); @@ -15104,25 +15104,25 @@ function FromStmtContext(parser, ctx) { FromStmtContext.prototype = Object.create(QueryPrimaryContext.prototype); FromStmtContext.prototype.constructor = FromStmtContext; -SqlBaseParser.FromStmtContext = FromStmtContext; +SparkSqlParser.FromStmtContext = FromStmtContext; FromStmtContext.prototype.fromStatement = function() { return this.getTypedRuleContext(FromStatementContext,0); }; FromStmtContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFromStmt(this); } }; FromStmtContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFromStmt(this); } }; FromStmtContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFromStmt(this); } else { return visitor.visitChildren(this); @@ -15139,29 +15139,29 @@ function TableContext(parser, ctx) { TableContext.prototype = Object.create(QueryPrimaryContext.prototype); TableContext.prototype.constructor = TableContext; -SqlBaseParser.TableContext = TableContext; +SparkSqlParser.TableContext = TableContext; TableContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; TableContext.prototype.multipartIdentifier = function() { return this.getTypedRuleContext(MultipartIdentifierContext,0); }; TableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTable(this); } }; TableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTable(this); } }; TableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTable(this); } else { return visitor.visitChildren(this); @@ -15170,53 +15170,53 @@ TableContext.prototype.accept = function(visitor) { -SqlBaseParser.QueryPrimaryContext = QueryPrimaryContext; +SparkSqlParser.QueryPrimaryContext = QueryPrimaryContext; -SqlBaseParser.prototype.queryPrimary = function() { +SparkSqlParser.prototype.queryPrimary = function() { var localctx = new QueryPrimaryContext(this, this._ctx, this.state); - this.enterRule(localctx, 84, SqlBaseParser.RULE_queryPrimary); + this.enterRule(localctx, 84, SparkSqlParser.RULE_queryPrimary); try { this.state = 1643; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.MAP: - case SqlBaseParser.REDUCE: - case SqlBaseParser.SELECT: + case SparkSqlParser.MAP: + case SparkSqlParser.REDUCE: + case SparkSqlParser.SELECT: localctx = new QueryPrimaryDefaultContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 1634; this.querySpecification(); break; - case SqlBaseParser.FROM: + case SparkSqlParser.FROM: localctx = new FromStmtContext(this, localctx); this.enterOuterAlt(localctx, 2); this.state = 1635; this.fromStatement(); break; - case SqlBaseParser.TABLE: + case SparkSqlParser.TABLE: localctx = new TableContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 1636; - this.match(SqlBaseParser.TABLE); + this.match(SparkSqlParser.TABLE); this.state = 1637; this.multipartIdentifier(); break; - case SqlBaseParser.VALUES: + case SparkSqlParser.VALUES: localctx = new InlineTableDefault1Context(this, localctx); this.enterOuterAlt(localctx, 4); this.state = 1638; this.inlineTable(); break; - case SqlBaseParser.T__1: + case SparkSqlParser.T__1: localctx = new SubqueryContext(this, localctx); this.enterOuterAlt(localctx, 5); this.state = 1639; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1640; this.query(); this.state = 1641; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; default: throw new antlr4.error.NoViableAltException(this); @@ -15245,7 +15245,7 @@ function SortItemContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_sortItem; + this.ruleIndex = SparkSqlParser.RULE_sortItem; this.ordering = null; // Token this.nullOrder = null; // Token return this; @@ -15259,39 +15259,39 @@ SortItemContext.prototype.expression = function() { }; SortItemContext.prototype.NULLS = function() { - return this.getToken(SqlBaseParser.NULLS, 0); + return this.getToken(SparkSqlParser.NULLS, 0); }; SortItemContext.prototype.ASC = function() { - return this.getToken(SqlBaseParser.ASC, 0); + return this.getToken(SparkSqlParser.ASC, 0); }; SortItemContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; SortItemContext.prototype.LAST = function() { - return this.getToken(SqlBaseParser.LAST, 0); + return this.getToken(SparkSqlParser.LAST, 0); }; SortItemContext.prototype.FIRST = function() { - return this.getToken(SqlBaseParser.FIRST, 0); + return this.getToken(SparkSqlParser.FIRST, 0); }; SortItemContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSortItem(this); } }; SortItemContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSortItem(this); } }; SortItemContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSortItem(this); } else { return visitor.visitChildren(this); @@ -15301,12 +15301,12 @@ SortItemContext.prototype.accept = function(visitor) { -SqlBaseParser.SortItemContext = SortItemContext; +SparkSqlParser.SortItemContext = SortItemContext; -SqlBaseParser.prototype.sortItem = function() { +SparkSqlParser.prototype.sortItem = function() { var localctx = new SortItemContext(this, this._ctx, this.state); - this.enterRule(localctx, 86, SqlBaseParser.RULE_sortItem); + this.enterRule(localctx, 86, SparkSqlParser.RULE_sortItem); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -15319,7 +15319,7 @@ SqlBaseParser.prototype.sortItem = function() { this.state = 1646; localctx.ordering = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ASC || _la===SqlBaseParser.DESC)) { + if(!(_la===SparkSqlParser.ASC || _la===SparkSqlParser.DESC)) { localctx.ordering = this._errHandler.recoverInline(this); } else { @@ -15333,11 +15333,11 @@ SqlBaseParser.prototype.sortItem = function() { var la_ = this._interp.adaptivePredict(this._input,186,this._ctx); if(la_===1) { this.state = 1649; - this.match(SqlBaseParser.NULLS); + this.match(SparkSqlParser.NULLS); this.state = 1650; localctx.nullOrder = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FIRST || _la===SqlBaseParser.LAST)) { + if(!(_la===SparkSqlParser.FIRST || _la===SparkSqlParser.LAST)) { localctx.nullOrder = this._errHandler.recoverInline(this); } else { @@ -15370,7 +15370,7 @@ function FromStatementContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_fromStatement; + this.ruleIndex = SparkSqlParser.RULE_fromStatement; return this; } @@ -15393,19 +15393,19 @@ FromStatementContext.prototype.fromStatementBody = function(i) { }; FromStatementContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFromStatement(this); } }; FromStatementContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFromStatement(this); } }; FromStatementContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFromStatement(this); } else { return visitor.visitChildren(this); @@ -15415,12 +15415,12 @@ FromStatementContext.prototype.accept = function(visitor) { -SqlBaseParser.FromStatementContext = FromStatementContext; +SparkSqlParser.FromStatementContext = FromStatementContext; -SqlBaseParser.prototype.fromStatement = function() { +SparkSqlParser.prototype.fromStatement = function() { var localctx = new FromStatementContext(this, this._ctx, this.state); - this.enterRule(localctx, 88, SqlBaseParser.RULE_fromStatement); + this.enterRule(localctx, 88, SparkSqlParser.RULE_fromStatement); try { this.enterOuterAlt(localctx, 1); this.state = 1653; @@ -15465,7 +15465,7 @@ function FromStatementBodyContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_fromStatementBody; + this.ruleIndex = SparkSqlParser.RULE_fromStatementBody; return this; } @@ -15512,19 +15512,19 @@ FromStatementBodyContext.prototype.windowClause = function() { }; FromStatementBodyContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFromStatementBody(this); } }; FromStatementBodyContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFromStatementBody(this); } }; FromStatementBodyContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFromStatementBody(this); } else { return visitor.visitChildren(this); @@ -15534,12 +15534,12 @@ FromStatementBodyContext.prototype.accept = function(visitor) { -SqlBaseParser.FromStatementBodyContext = FromStatementBodyContext; +SparkSqlParser.FromStatementBodyContext = FromStatementBodyContext; -SqlBaseParser.prototype.fromStatementBody = function() { +SparkSqlParser.prototype.fromStatementBody = function() { var localctx = new FromStatementBodyContext(this, this._ctx, this.state); - this.enterRule(localctx, 90, SqlBaseParser.RULE_fromStatementBody); + this.enterRule(localctx, 90, SparkSqlParser.RULE_fromStatementBody); try { this.state = 1686; this._errHandler.sync(this); @@ -15639,7 +15639,7 @@ function QuerySpecificationContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_querySpecification; + this.ruleIndex = SparkSqlParser.RULE_querySpecification; return this; } @@ -15662,7 +15662,7 @@ function RegularQuerySpecificationContext(parser, ctx) { RegularQuerySpecificationContext.prototype = Object.create(QuerySpecificationContext.prototype); RegularQuerySpecificationContext.prototype.constructor = RegularQuerySpecificationContext; -SqlBaseParser.RegularQuerySpecificationContext = RegularQuerySpecificationContext; +SparkSqlParser.RegularQuerySpecificationContext = RegularQuerySpecificationContext; RegularQuerySpecificationContext.prototype.selectClause = function() { return this.getTypedRuleContext(SelectClauseContext,0); @@ -15699,19 +15699,19 @@ RegularQuerySpecificationContext.prototype.windowClause = function() { return this.getTypedRuleContext(WindowClauseContext,0); }; RegularQuerySpecificationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRegularQuerySpecification(this); } }; RegularQuerySpecificationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRegularQuerySpecification(this); } }; RegularQuerySpecificationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRegularQuerySpecification(this); } else { return visitor.visitChildren(this); @@ -15728,7 +15728,7 @@ function TransformQuerySpecificationContext(parser, ctx) { TransformQuerySpecificationContext.prototype = Object.create(QuerySpecificationContext.prototype); TransformQuerySpecificationContext.prototype.constructor = TransformQuerySpecificationContext; -SqlBaseParser.TransformQuerySpecificationContext = TransformQuerySpecificationContext; +SparkSqlParser.TransformQuerySpecificationContext = TransformQuerySpecificationContext; TransformQuerySpecificationContext.prototype.transformClause = function() { return this.getTypedRuleContext(TransformClauseContext,0); @@ -15742,19 +15742,19 @@ TransformQuerySpecificationContext.prototype.whereClause = function() { return this.getTypedRuleContext(WhereClauseContext,0); }; TransformQuerySpecificationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTransformQuerySpecification(this); } }; TransformQuerySpecificationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTransformQuerySpecification(this); } }; TransformQuerySpecificationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTransformQuerySpecification(this); } else { return visitor.visitChildren(this); @@ -15763,12 +15763,12 @@ TransformQuerySpecificationContext.prototype.accept = function(visitor) { -SqlBaseParser.QuerySpecificationContext = QuerySpecificationContext; +SparkSqlParser.QuerySpecificationContext = QuerySpecificationContext; -SqlBaseParser.prototype.querySpecification = function() { +SparkSqlParser.prototype.querySpecification = function() { var localctx = new QuerySpecificationContext(this, this._ctx, this.state); - this.enterRule(localctx, 92, SqlBaseParser.RULE_querySpecification); + this.enterRule(localctx, 92, SparkSqlParser.RULE_querySpecification); try { this.state = 1717; this._errHandler.sync(this); @@ -15882,7 +15882,7 @@ function TransformClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_transformClause; + this.ruleIndex = SparkSqlParser.RULE_transformClause; this.kind = null; // Token this.inRowFormat = null; // RowFormatContext this.recordWriter = null; // Token @@ -15896,7 +15896,7 @@ TransformClauseContext.prototype = Object.create(antlr4.ParserRuleContext.protot TransformClauseContext.prototype.constructor = TransformClauseContext; TransformClauseContext.prototype.USING = function() { - return this.getToken(SqlBaseParser.USING, 0); + return this.getToken(SparkSqlParser.USING, 0); }; TransformClauseContext.prototype.STRING = function(i) { @@ -15904,15 +15904,15 @@ TransformClauseContext.prototype.STRING = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.STRING); + return this.getTokens(SparkSqlParser.STRING); } else { - return this.getToken(SqlBaseParser.STRING, i); + return this.getToken(SparkSqlParser.STRING, i); } }; TransformClauseContext.prototype.SELECT = function() { - return this.getToken(SqlBaseParser.SELECT, 0); + return this.getToken(SparkSqlParser.SELECT, 0); }; TransformClauseContext.prototype.namedExpressionSeq = function() { @@ -15920,27 +15920,27 @@ TransformClauseContext.prototype.namedExpressionSeq = function() { }; TransformClauseContext.prototype.TRANSFORM = function() { - return this.getToken(SqlBaseParser.TRANSFORM, 0); + return this.getToken(SparkSqlParser.TRANSFORM, 0); }; TransformClauseContext.prototype.MAP = function() { - return this.getToken(SqlBaseParser.MAP, 0); + return this.getToken(SparkSqlParser.MAP, 0); }; TransformClauseContext.prototype.REDUCE = function() { - return this.getToken(SqlBaseParser.REDUCE, 0); + return this.getToken(SparkSqlParser.REDUCE, 0); }; TransformClauseContext.prototype.RECORDWRITER = function() { - return this.getToken(SqlBaseParser.RECORDWRITER, 0); + return this.getToken(SparkSqlParser.RECORDWRITER, 0); }; TransformClauseContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; TransformClauseContext.prototype.RECORDREADER = function() { - return this.getToken(SqlBaseParser.RECORDREADER, 0); + return this.getToken(SparkSqlParser.RECORDREADER, 0); }; TransformClauseContext.prototype.rowFormat = function(i) { @@ -15963,19 +15963,19 @@ TransformClauseContext.prototype.colTypeList = function() { }; TransformClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTransformClause(this); } }; TransformClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTransformClause(this); } }; TransformClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTransformClause(this); } else { return visitor.visitChildren(this); @@ -15985,39 +15985,39 @@ TransformClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.TransformClauseContext = TransformClauseContext; +SparkSqlParser.TransformClauseContext = TransformClauseContext; -SqlBaseParser.prototype.transformClause = function() { +SparkSqlParser.prototype.transformClause = function() { var localctx = new TransformClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 94, SqlBaseParser.RULE_transformClause); + this.enterRule(localctx, 94, SparkSqlParser.RULE_transformClause); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1729; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.SELECT: + case SparkSqlParser.SELECT: this.state = 1719; - this.match(SqlBaseParser.SELECT); + this.match(SparkSqlParser.SELECT); this.state = 1720; - localctx.kind = this.match(SqlBaseParser.TRANSFORM); + localctx.kind = this.match(SparkSqlParser.TRANSFORM); this.state = 1721; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1722; this.namedExpressionSeq(); this.state = 1723; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; - case SqlBaseParser.MAP: + case SparkSqlParser.MAP: this.state = 1725; - localctx.kind = this.match(SqlBaseParser.MAP); + localctx.kind = this.match(SparkSqlParser.MAP); this.state = 1726; this.namedExpressionSeq(); break; - case SqlBaseParser.REDUCE: + case SparkSqlParser.REDUCE: this.state = 1727; - localctx.kind = this.match(SqlBaseParser.REDUCE); + localctx.kind = this.match(SparkSqlParser.REDUCE); this.state = 1728; this.namedExpressionSeq(); break; @@ -16027,7 +16027,7 @@ SqlBaseParser.prototype.transformClause = function() { this.state = 1732; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ROW) { + if(_la===SparkSqlParser.ROW) { this.state = 1731; localctx.inRowFormat = this.rowFormat(); } @@ -16035,23 +16035,23 @@ SqlBaseParser.prototype.transformClause = function() { this.state = 1736; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.RECORDWRITER) { + if(_la===SparkSqlParser.RECORDWRITER) { this.state = 1734; - this.match(SqlBaseParser.RECORDWRITER); + this.match(SparkSqlParser.RECORDWRITER); this.state = 1735; - localctx.recordWriter = this.match(SqlBaseParser.STRING); + localctx.recordWriter = this.match(SparkSqlParser.STRING); } this.state = 1738; - this.match(SqlBaseParser.USING); + this.match(SparkSqlParser.USING); this.state = 1739; - localctx.script = this.match(SqlBaseParser.STRING); + localctx.script = this.match(SparkSqlParser.STRING); this.state = 1752; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,209,this._ctx); if(la_===1) { this.state = 1740; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 1750; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,208,this._ctx); @@ -16068,7 +16068,7 @@ SqlBaseParser.prototype.transformClause = function() { case 3: this.state = 1743; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1746; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,207,this._ctx); @@ -16085,7 +16085,7 @@ SqlBaseParser.prototype.transformClause = function() { } this.state = 1748; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -16104,9 +16104,9 @@ SqlBaseParser.prototype.transformClause = function() { var la_ = this._interp.adaptivePredict(this._input,211,this._ctx); if(la_===1) { this.state = 1757; - this.match(SqlBaseParser.RECORDREADER); + this.match(SparkSqlParser.RECORDREADER); this.state = 1758; - localctx.recordReader = this.match(SqlBaseParser.STRING); + localctx.recordReader = this.match(SparkSqlParser.STRING); } } catch (re) { @@ -16133,7 +16133,7 @@ function SelectClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_selectClause; + this.ruleIndex = SparkSqlParser.RULE_selectClause; this._hint = null; // HintContext this.hints = []; // of HintContexts return this; @@ -16143,7 +16143,7 @@ SelectClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype SelectClauseContext.prototype.constructor = SelectClauseContext; SelectClauseContext.prototype.SELECT = function() { - return this.getToken(SqlBaseParser.SELECT, 0); + return this.getToken(SparkSqlParser.SELECT, 0); }; SelectClauseContext.prototype.namedExpressionSeq = function() { @@ -16166,19 +16166,19 @@ SelectClauseContext.prototype.hint = function(i) { }; SelectClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSelectClause(this); } }; SelectClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSelectClause(this); } }; SelectClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSelectClause(this); } else { return visitor.visitChildren(this); @@ -16188,16 +16188,16 @@ SelectClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.SelectClauseContext = SelectClauseContext; +SparkSqlParser.SelectClauseContext = SelectClauseContext; -SqlBaseParser.prototype.selectClause = function() { +SparkSqlParser.prototype.selectClause = function() { var localctx = new SelectClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 96, SqlBaseParser.RULE_selectClause); + this.enterRule(localctx, 96, SparkSqlParser.RULE_selectClause); try { this.enterOuterAlt(localctx, 1); this.state = 1761; - this.match(SqlBaseParser.SELECT); + this.match(SparkSqlParser.SELECT); this.state = 1765; this._errHandler.sync(this); var _alt = this._interp.adaptivePredict(this._input,212,this._ctx) @@ -16246,7 +16246,7 @@ function SetClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_setClause; + this.ruleIndex = SparkSqlParser.RULE_setClause; return this; } @@ -16254,7 +16254,7 @@ SetClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); SetClauseContext.prototype.constructor = SetClauseContext; SetClauseContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; SetClauseContext.prototype.assignmentList = function() { @@ -16262,19 +16262,19 @@ SetClauseContext.prototype.assignmentList = function() { }; SetClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetClause(this); } }; SetClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetClause(this); } }; SetClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetClause(this); } else { return visitor.visitChildren(this); @@ -16284,16 +16284,16 @@ SetClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.SetClauseContext = SetClauseContext; +SparkSqlParser.SetClauseContext = SetClauseContext; -SqlBaseParser.prototype.setClause = function() { +SparkSqlParser.prototype.setClause = function() { var localctx = new SetClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 98, SqlBaseParser.RULE_setClause); + this.enterRule(localctx, 98, SparkSqlParser.RULE_setClause); try { this.enterOuterAlt(localctx, 1); this.state = 1773; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 1774; this.assignmentList(); } catch (re) { @@ -16320,7 +16320,7 @@ function MatchedClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_matchedClause; + this.ruleIndex = SparkSqlParser.RULE_matchedClause; this.matchedCond = null; // BooleanExpressionContext return this; } @@ -16329,15 +16329,15 @@ MatchedClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototyp MatchedClauseContext.prototype.constructor = MatchedClauseContext; MatchedClauseContext.prototype.WHEN = function() { - return this.getToken(SqlBaseParser.WHEN, 0); + return this.getToken(SparkSqlParser.WHEN, 0); }; MatchedClauseContext.prototype.MATCHED = function() { - return this.getToken(SqlBaseParser.MATCHED, 0); + return this.getToken(SparkSqlParser.MATCHED, 0); }; MatchedClauseContext.prototype.THEN = function() { - return this.getToken(SqlBaseParser.THEN, 0); + return this.getToken(SparkSqlParser.THEN, 0); }; MatchedClauseContext.prototype.matchedAction = function() { @@ -16345,7 +16345,7 @@ MatchedClauseContext.prototype.matchedAction = function() { }; MatchedClauseContext.prototype.AND = function() { - return this.getToken(SqlBaseParser.AND, 0); + return this.getToken(SparkSqlParser.AND, 0); }; MatchedClauseContext.prototype.booleanExpression = function() { @@ -16353,19 +16353,19 @@ MatchedClauseContext.prototype.booleanExpression = function() { }; MatchedClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMatchedClause(this); } }; MatchedClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMatchedClause(this); } }; MatchedClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMatchedClause(this); } else { return visitor.visitChildren(this); @@ -16375,31 +16375,31 @@ MatchedClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.MatchedClauseContext = MatchedClauseContext; +SparkSqlParser.MatchedClauseContext = MatchedClauseContext; -SqlBaseParser.prototype.matchedClause = function() { +SparkSqlParser.prototype.matchedClause = function() { var localctx = new MatchedClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 100, SqlBaseParser.RULE_matchedClause); + this.enterRule(localctx, 100, SparkSqlParser.RULE_matchedClause); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1776; - this.match(SqlBaseParser.WHEN); + this.match(SparkSqlParser.WHEN); this.state = 1777; - this.match(SqlBaseParser.MATCHED); + this.match(SparkSqlParser.MATCHED); this.state = 1780; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AND) { + if(_la===SparkSqlParser.AND) { this.state = 1778; - this.match(SqlBaseParser.AND); + this.match(SparkSqlParser.AND); this.state = 1779; localctx.matchedCond = this.booleanExpression(0); } this.state = 1782; - this.match(SqlBaseParser.THEN); + this.match(SparkSqlParser.THEN); this.state = 1783; this.matchedAction(); } catch (re) { @@ -16426,7 +16426,7 @@ function NotMatchedClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_notMatchedClause; + this.ruleIndex = SparkSqlParser.RULE_notMatchedClause; this.notMatchedCond = null; // BooleanExpressionContext return this; } @@ -16435,19 +16435,19 @@ NotMatchedClauseContext.prototype = Object.create(antlr4.ParserRuleContext.proto NotMatchedClauseContext.prototype.constructor = NotMatchedClauseContext; NotMatchedClauseContext.prototype.WHEN = function() { - return this.getToken(SqlBaseParser.WHEN, 0); + return this.getToken(SparkSqlParser.WHEN, 0); }; NotMatchedClauseContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; NotMatchedClauseContext.prototype.MATCHED = function() { - return this.getToken(SqlBaseParser.MATCHED, 0); + return this.getToken(SparkSqlParser.MATCHED, 0); }; NotMatchedClauseContext.prototype.THEN = function() { - return this.getToken(SqlBaseParser.THEN, 0); + return this.getToken(SparkSqlParser.THEN, 0); }; NotMatchedClauseContext.prototype.notMatchedAction = function() { @@ -16455,7 +16455,7 @@ NotMatchedClauseContext.prototype.notMatchedAction = function() { }; NotMatchedClauseContext.prototype.AND = function() { - return this.getToken(SqlBaseParser.AND, 0); + return this.getToken(SparkSqlParser.AND, 0); }; NotMatchedClauseContext.prototype.booleanExpression = function() { @@ -16463,19 +16463,19 @@ NotMatchedClauseContext.prototype.booleanExpression = function() { }; NotMatchedClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNotMatchedClause(this); } }; NotMatchedClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNotMatchedClause(this); } }; NotMatchedClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNotMatchedClause(this); } else { return visitor.visitChildren(this); @@ -16485,33 +16485,33 @@ NotMatchedClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.NotMatchedClauseContext = NotMatchedClauseContext; +SparkSqlParser.NotMatchedClauseContext = NotMatchedClauseContext; -SqlBaseParser.prototype.notMatchedClause = function() { +SparkSqlParser.prototype.notMatchedClause = function() { var localctx = new NotMatchedClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 102, SqlBaseParser.RULE_notMatchedClause); + this.enterRule(localctx, 102, SparkSqlParser.RULE_notMatchedClause); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1785; - this.match(SqlBaseParser.WHEN); + this.match(SparkSqlParser.WHEN); this.state = 1786; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 1787; - this.match(SqlBaseParser.MATCHED); + this.match(SparkSqlParser.MATCHED); this.state = 1790; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AND) { + if(_la===SparkSqlParser.AND) { this.state = 1788; - this.match(SqlBaseParser.AND); + this.match(SparkSqlParser.AND); this.state = 1789; localctx.notMatchedCond = this.booleanExpression(0); } this.state = 1792; - this.match(SqlBaseParser.THEN); + this.match(SparkSqlParser.THEN); this.state = 1793; this.notMatchedAction(); } catch (re) { @@ -16538,7 +16538,7 @@ function MatchedActionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_matchedAction; + this.ruleIndex = SparkSqlParser.RULE_matchedAction; return this; } @@ -16546,19 +16546,19 @@ MatchedActionContext.prototype = Object.create(antlr4.ParserRuleContext.prototyp MatchedActionContext.prototype.constructor = MatchedActionContext; MatchedActionContext.prototype.DELETE = function() { - return this.getToken(SqlBaseParser.DELETE, 0); + return this.getToken(SparkSqlParser.DELETE, 0); }; MatchedActionContext.prototype.UPDATE = function() { - return this.getToken(SqlBaseParser.UPDATE, 0); + return this.getToken(SparkSqlParser.UPDATE, 0); }; MatchedActionContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; MatchedActionContext.prototype.ASTERISK = function() { - return this.getToken(SqlBaseParser.ASTERISK, 0); + return this.getToken(SparkSqlParser.ASTERISK, 0); }; MatchedActionContext.prototype.assignmentList = function() { @@ -16566,19 +16566,19 @@ MatchedActionContext.prototype.assignmentList = function() { }; MatchedActionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMatchedAction(this); } }; MatchedActionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMatchedAction(this); } }; MatchedActionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMatchedAction(this); } else { return visitor.visitChildren(this); @@ -16588,12 +16588,12 @@ MatchedActionContext.prototype.accept = function(visitor) { -SqlBaseParser.MatchedActionContext = MatchedActionContext; +SparkSqlParser.MatchedActionContext = MatchedActionContext; -SqlBaseParser.prototype.matchedAction = function() { +SparkSqlParser.prototype.matchedAction = function() { var localctx = new MatchedActionContext(this, this._ctx, this.state); - this.enterRule(localctx, 104, SqlBaseParser.RULE_matchedAction); + this.enterRule(localctx, 104, SparkSqlParser.RULE_matchedAction); try { this.state = 1802; this._errHandler.sync(this); @@ -16602,25 +16602,25 @@ SqlBaseParser.prototype.matchedAction = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 1795; - this.match(SqlBaseParser.DELETE); + this.match(SparkSqlParser.DELETE); break; case 2: this.enterOuterAlt(localctx, 2); this.state = 1796; - this.match(SqlBaseParser.UPDATE); + this.match(SparkSqlParser.UPDATE); this.state = 1797; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 1798; - this.match(SqlBaseParser.ASTERISK); + this.match(SparkSqlParser.ASTERISK); break; case 3: this.enterOuterAlt(localctx, 3); this.state = 1799; - this.match(SqlBaseParser.UPDATE); + this.match(SparkSqlParser.UPDATE); this.state = 1800; - this.match(SqlBaseParser.SET); + this.match(SparkSqlParser.SET); this.state = 1801; this.assignmentList(); break; @@ -16650,7 +16650,7 @@ function NotMatchedActionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_notMatchedAction; + this.ruleIndex = SparkSqlParser.RULE_notMatchedAction; this.columns = null; // MultipartIdentifierListContext return this; } @@ -16659,15 +16659,15 @@ NotMatchedActionContext.prototype = Object.create(antlr4.ParserRuleContext.proto NotMatchedActionContext.prototype.constructor = NotMatchedActionContext; NotMatchedActionContext.prototype.INSERT = function() { - return this.getToken(SqlBaseParser.INSERT, 0); + return this.getToken(SparkSqlParser.INSERT, 0); }; NotMatchedActionContext.prototype.ASTERISK = function() { - return this.getToken(SqlBaseParser.ASTERISK, 0); + return this.getToken(SparkSqlParser.ASTERISK, 0); }; NotMatchedActionContext.prototype.VALUES = function() { - return this.getToken(SqlBaseParser.VALUES, 0); + return this.getToken(SparkSqlParser.VALUES, 0); }; NotMatchedActionContext.prototype.expression = function(i) { @@ -16686,19 +16686,19 @@ NotMatchedActionContext.prototype.multipartIdentifierList = function() { }; NotMatchedActionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNotMatchedAction(this); } }; NotMatchedActionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNotMatchedAction(this); } }; NotMatchedActionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNotMatchedAction(this); } else { return visitor.visitChildren(this); @@ -16708,12 +16708,12 @@ NotMatchedActionContext.prototype.accept = function(visitor) { -SqlBaseParser.NotMatchedActionContext = NotMatchedActionContext; +SparkSqlParser.NotMatchedActionContext = NotMatchedActionContext; -SqlBaseParser.prototype.notMatchedAction = function() { +SparkSqlParser.prototype.notMatchedAction = function() { var localctx = new NotMatchedActionContext(this, this._ctx, this.state); - this.enterRule(localctx, 106, SqlBaseParser.RULE_notMatchedAction); + this.enterRule(localctx, 106, SparkSqlParser.RULE_notMatchedAction); var _la = 0; // Token type try { this.state = 1822; @@ -16723,33 +16723,33 @@ SqlBaseParser.prototype.notMatchedAction = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 1804; - this.match(SqlBaseParser.INSERT); + this.match(SparkSqlParser.INSERT); this.state = 1805; - this.match(SqlBaseParser.ASTERISK); + this.match(SparkSqlParser.ASTERISK); break; case 2: this.enterOuterAlt(localctx, 2); this.state = 1806; - this.match(SqlBaseParser.INSERT); + this.match(SparkSqlParser.INSERT); this.state = 1807; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1808; localctx.columns = this.multipartIdentifierList(); this.state = 1809; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 1810; - this.match(SqlBaseParser.VALUES); + this.match(SparkSqlParser.VALUES); this.state = 1811; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1812; this.expression(); this.state = 1817; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1813; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1814; this.expression(); this.state = 1819; @@ -16757,7 +16757,7 @@ SqlBaseParser.prototype.notMatchedAction = function() { _la = this._input.LA(1); } this.state = 1820; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -16785,7 +16785,7 @@ function AssignmentListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_assignmentList; + this.ruleIndex = SparkSqlParser.RULE_assignmentList; return this; } @@ -16804,19 +16804,19 @@ AssignmentListContext.prototype.assignment = function(i) { }; AssignmentListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAssignmentList(this); } }; AssignmentListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAssignmentList(this); } }; AssignmentListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAssignmentList(this); } else { return visitor.visitChildren(this); @@ -16826,12 +16826,12 @@ AssignmentListContext.prototype.accept = function(visitor) { -SqlBaseParser.AssignmentListContext = AssignmentListContext; +SparkSqlParser.AssignmentListContext = AssignmentListContext; -SqlBaseParser.prototype.assignmentList = function() { +SparkSqlParser.prototype.assignmentList = function() { var localctx = new AssignmentListContext(this, this._ctx, this.state); - this.enterRule(localctx, 108, SqlBaseParser.RULE_assignmentList); + this.enterRule(localctx, 108, SparkSqlParser.RULE_assignmentList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -16840,9 +16840,9 @@ SqlBaseParser.prototype.assignmentList = function() { this.state = 1829; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1825; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1826; this.assignment(); this.state = 1831; @@ -16873,7 +16873,7 @@ function AssignmentContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_assignment; + this.ruleIndex = SparkSqlParser.RULE_assignment; this.key = null; // MultipartIdentifierContext this.value = null; // ExpressionContext return this; @@ -16883,7 +16883,7 @@ AssignmentContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); AssignmentContext.prototype.constructor = AssignmentContext; AssignmentContext.prototype.EQ = function() { - return this.getToken(SqlBaseParser.EQ, 0); + return this.getToken(SparkSqlParser.EQ, 0); }; AssignmentContext.prototype.multipartIdentifier = function() { @@ -16895,19 +16895,19 @@ AssignmentContext.prototype.expression = function() { }; AssignmentContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAssignment(this); } }; AssignmentContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAssignment(this); } }; AssignmentContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAssignment(this); } else { return visitor.visitChildren(this); @@ -16917,18 +16917,18 @@ AssignmentContext.prototype.accept = function(visitor) { -SqlBaseParser.AssignmentContext = AssignmentContext; +SparkSqlParser.AssignmentContext = AssignmentContext; -SqlBaseParser.prototype.assignment = function() { +SparkSqlParser.prototype.assignment = function() { var localctx = new AssignmentContext(this, this._ctx, this.state); - this.enterRule(localctx, 110, SqlBaseParser.RULE_assignment); + this.enterRule(localctx, 110, SparkSqlParser.RULE_assignment); try { this.enterOuterAlt(localctx, 1); this.state = 1832; localctx.key = this.multipartIdentifier(); this.state = 1833; - this.match(SqlBaseParser.EQ); + this.match(SparkSqlParser.EQ); this.state = 1834; localctx.value = this.expression(); } catch (re) { @@ -16955,7 +16955,7 @@ function WhereClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_whereClause; + this.ruleIndex = SparkSqlParser.RULE_whereClause; return this; } @@ -16963,7 +16963,7 @@ WhereClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) WhereClauseContext.prototype.constructor = WhereClauseContext; WhereClauseContext.prototype.WHERE = function() { - return this.getToken(SqlBaseParser.WHERE, 0); + return this.getToken(SparkSqlParser.WHERE, 0); }; WhereClauseContext.prototype.booleanExpression = function() { @@ -16971,19 +16971,19 @@ WhereClauseContext.prototype.booleanExpression = function() { }; WhereClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterWhereClause(this); } }; WhereClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitWhereClause(this); } }; WhereClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitWhereClause(this); } else { return visitor.visitChildren(this); @@ -16993,16 +16993,16 @@ WhereClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.WhereClauseContext = WhereClauseContext; +SparkSqlParser.WhereClauseContext = WhereClauseContext; -SqlBaseParser.prototype.whereClause = function() { +SparkSqlParser.prototype.whereClause = function() { var localctx = new WhereClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 112, SqlBaseParser.RULE_whereClause); + this.enterRule(localctx, 112, SparkSqlParser.RULE_whereClause); try { this.enterOuterAlt(localctx, 1); this.state = 1836; - this.match(SqlBaseParser.WHERE); + this.match(SparkSqlParser.WHERE); this.state = 1837; this.booleanExpression(0); } catch (re) { @@ -17029,7 +17029,7 @@ function HavingClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_havingClause; + this.ruleIndex = SparkSqlParser.RULE_havingClause; return this; } @@ -17037,7 +17037,7 @@ HavingClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype HavingClauseContext.prototype.constructor = HavingClauseContext; HavingClauseContext.prototype.HAVING = function() { - return this.getToken(SqlBaseParser.HAVING, 0); + return this.getToken(SparkSqlParser.HAVING, 0); }; HavingClauseContext.prototype.booleanExpression = function() { @@ -17045,19 +17045,19 @@ HavingClauseContext.prototype.booleanExpression = function() { }; HavingClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterHavingClause(this); } }; HavingClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitHavingClause(this); } }; HavingClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitHavingClause(this); } else { return visitor.visitChildren(this); @@ -17067,16 +17067,16 @@ HavingClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.HavingClauseContext = HavingClauseContext; +SparkSqlParser.HavingClauseContext = HavingClauseContext; -SqlBaseParser.prototype.havingClause = function() { +SparkSqlParser.prototype.havingClause = function() { var localctx = new HavingClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 114, SqlBaseParser.RULE_havingClause); + this.enterRule(localctx, 114, SparkSqlParser.RULE_havingClause); try { this.enterOuterAlt(localctx, 1); this.state = 1839; - this.match(SqlBaseParser.HAVING); + this.match(SparkSqlParser.HAVING); this.state = 1840; this.booleanExpression(0); } catch (re) { @@ -17103,7 +17103,7 @@ function HintContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_hint; + this.ruleIndex = SparkSqlParser.RULE_hint; this._hintStatement = null; // HintStatementContext this.hintStatements = []; // of HintStatementContexts return this; @@ -17124,19 +17124,19 @@ HintContext.prototype.hintStatement = function(i) { }; HintContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterHint(this); } }; HintContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitHint(this); } }; HintContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitHint(this); } else { return visitor.visitChildren(this); @@ -17146,16 +17146,16 @@ HintContext.prototype.accept = function(visitor) { -SqlBaseParser.HintContext = HintContext; +SparkSqlParser.HintContext = HintContext; -SqlBaseParser.prototype.hint = function() { +SparkSqlParser.prototype.hint = function() { var localctx = new HintContext(this, this._ctx, this.state); - this.enterRule(localctx, 116, SqlBaseParser.RULE_hint); + this.enterRule(localctx, 116, SparkSqlParser.RULE_hint); try { this.enterOuterAlt(localctx, 1); this.state = 1842; - this.match(SqlBaseParser.T__5); + this.match(SparkSqlParser.T__5); this.state = 1843; localctx._hintStatement = this.hintStatement(); localctx.hintStatements.push(localctx._hintStatement); @@ -17169,7 +17169,7 @@ SqlBaseParser.prototype.hint = function() { var la_ = this._interp.adaptivePredict(this._input,220,this._ctx); if(la_===1) { this.state = 1844; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); } this.state = 1847; @@ -17182,7 +17182,7 @@ SqlBaseParser.prototype.hint = function() { } this.state = 1853; - this.match(SqlBaseParser.T__6); + this.match(SparkSqlParser.T__6); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -17207,7 +17207,7 @@ function HintStatementContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_hintStatement; + this.ruleIndex = SparkSqlParser.RULE_hintStatement; this.hintName = null; // IdentifierContext this._primaryExpression = null; // PrimaryExpressionContext this.parameters = []; // of PrimaryExpressionContexts @@ -17233,19 +17233,19 @@ HintStatementContext.prototype.primaryExpression = function(i) { }; HintStatementContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterHintStatement(this); } }; HintStatementContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitHintStatement(this); } }; HintStatementContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitHintStatement(this); } else { return visitor.visitChildren(this); @@ -17255,12 +17255,12 @@ HintStatementContext.prototype.accept = function(visitor) { -SqlBaseParser.HintStatementContext = HintStatementContext; +SparkSqlParser.HintStatementContext = HintStatementContext; -SqlBaseParser.prototype.hintStatement = function() { +SparkSqlParser.prototype.hintStatement = function() { var localctx = new HintStatementContext(this, this._ctx, this.state); - this.enterRule(localctx, 118, SqlBaseParser.RULE_hintStatement); + this.enterRule(localctx, 118, SparkSqlParser.RULE_hintStatement); var _la = 0; // Token type try { this.state = 1868; @@ -17278,16 +17278,16 @@ SqlBaseParser.prototype.hintStatement = function() { this.state = 1856; localctx.hintName = this.identifier(); this.state = 1857; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1858; localctx._primaryExpression = this.primaryExpression(0); localctx.parameters.push(localctx._primaryExpression); this.state = 1863; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1859; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1860; localctx._primaryExpression = this.primaryExpression(0); localctx.parameters.push(localctx._primaryExpression); @@ -17296,7 +17296,7 @@ SqlBaseParser.prototype.hintStatement = function() { _la = this._input.LA(1); } this.state = 1866; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -17324,7 +17324,7 @@ function FromClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_fromClause; + this.ruleIndex = SparkSqlParser.RULE_fromClause; return this; } @@ -17332,7 +17332,7 @@ FromClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); FromClauseContext.prototype.constructor = FromClauseContext; FromClauseContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; FromClauseContext.prototype.relation = function(i) { @@ -17362,19 +17362,19 @@ FromClauseContext.prototype.pivotClause = function() { }; FromClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFromClause(this); } }; FromClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFromClause(this); } }; FromClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFromClause(this); } else { return visitor.visitChildren(this); @@ -17384,16 +17384,16 @@ FromClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.FromClauseContext = FromClauseContext; +SparkSqlParser.FromClauseContext = FromClauseContext; -SqlBaseParser.prototype.fromClause = function() { +SparkSqlParser.prototype.fromClause = function() { var localctx = new FromClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 120, SqlBaseParser.RULE_fromClause); + this.enterRule(localctx, 120, SparkSqlParser.RULE_fromClause); try { this.enterOuterAlt(localctx, 1); this.state = 1870; - this.match(SqlBaseParser.FROM); + this.match(SparkSqlParser.FROM); this.state = 1871; this.relation(); this.state = 1876; @@ -17402,7 +17402,7 @@ SqlBaseParser.prototype.fromClause = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 1872; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1873; this.relation(); } @@ -17456,7 +17456,7 @@ function AggregationClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_aggregationClause; + this.ruleIndex = SparkSqlParser.RULE_aggregationClause; this._expression = null; // ExpressionContext this.groupingExpressions = []; // of ExpressionContexts this.kind = null; // Token @@ -17467,11 +17467,11 @@ AggregationClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prot AggregationClauseContext.prototype.constructor = AggregationClauseContext; AggregationClauseContext.prototype.GROUP = function() { - return this.getToken(SqlBaseParser.GROUP, 0); + return this.getToken(SparkSqlParser.GROUP, 0); }; AggregationClauseContext.prototype.BY = function() { - return this.getToken(SqlBaseParser.BY, 0); + return this.getToken(SparkSqlParser.BY, 0); }; AggregationClauseContext.prototype.expression = function(i) { @@ -17486,11 +17486,11 @@ AggregationClauseContext.prototype.expression = function(i) { }; AggregationClauseContext.prototype.WITH = function() { - return this.getToken(SqlBaseParser.WITH, 0); + return this.getToken(SparkSqlParser.WITH, 0); }; AggregationClauseContext.prototype.SETS = function() { - return this.getToken(SqlBaseParser.SETS, 0); + return this.getToken(SparkSqlParser.SETS, 0); }; AggregationClauseContext.prototype.groupingSet = function(i) { @@ -17505,31 +17505,31 @@ AggregationClauseContext.prototype.groupingSet = function(i) { }; AggregationClauseContext.prototype.ROLLUP = function() { - return this.getToken(SqlBaseParser.ROLLUP, 0); + return this.getToken(SparkSqlParser.ROLLUP, 0); }; AggregationClauseContext.prototype.CUBE = function() { - return this.getToken(SqlBaseParser.CUBE, 0); + return this.getToken(SparkSqlParser.CUBE, 0); }; AggregationClauseContext.prototype.GROUPING = function() { - return this.getToken(SqlBaseParser.GROUPING, 0); + return this.getToken(SparkSqlParser.GROUPING, 0); }; AggregationClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAggregationClause(this); } }; AggregationClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAggregationClause(this); } }; AggregationClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAggregationClause(this); } else { return visitor.visitChildren(this); @@ -17539,12 +17539,12 @@ AggregationClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.AggregationClauseContext = AggregationClauseContext; +SparkSqlParser.AggregationClauseContext = AggregationClauseContext; -SqlBaseParser.prototype.aggregationClause = function() { +SparkSqlParser.prototype.aggregationClause = function() { var localctx = new AggregationClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 122, SqlBaseParser.RULE_aggregationClause); + this.enterRule(localctx, 122, SparkSqlParser.RULE_aggregationClause); var _la = 0; // Token type try { this.state = 1932; @@ -17554,9 +17554,9 @@ SqlBaseParser.prototype.aggregationClause = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 1888; - this.match(SqlBaseParser.GROUP); + this.match(SparkSqlParser.GROUP); this.state = 1889; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1890; localctx._expression = this.expression(); localctx.groupingExpressions.push(localctx._expression); @@ -17566,7 +17566,7 @@ SqlBaseParser.prototype.aggregationClause = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 1891; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1892; localctx._expression = this.expression(); localctx.groupingExpressions.push(localctx._expression); @@ -17581,31 +17581,31 @@ SqlBaseParser.prototype.aggregationClause = function() { var la_ = this._interp.adaptivePredict(this._input,229,this._ctx); if(la_===1) { this.state = 1898; - this.match(SqlBaseParser.WITH); + this.match(SparkSqlParser.WITH); this.state = 1899; - localctx.kind = this.match(SqlBaseParser.ROLLUP); + localctx.kind = this.match(SparkSqlParser.ROLLUP); } else if(la_===2) { this.state = 1900; - this.match(SqlBaseParser.WITH); + this.match(SparkSqlParser.WITH); this.state = 1901; - localctx.kind = this.match(SqlBaseParser.CUBE); + localctx.kind = this.match(SparkSqlParser.CUBE); } else if(la_===3) { this.state = 1902; - localctx.kind = this.match(SqlBaseParser.GROUPING); + localctx.kind = this.match(SparkSqlParser.GROUPING); this.state = 1903; - this.match(SqlBaseParser.SETS); + this.match(SparkSqlParser.SETS); this.state = 1904; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1905; this.groupingSet(); this.state = 1910; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1906; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1907; this.groupingSet(); this.state = 1912; @@ -17613,7 +17613,7 @@ SqlBaseParser.prototype.aggregationClause = function() { _la = this._input.LA(1); } this.state = 1913; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } break; @@ -17621,23 +17621,23 @@ SqlBaseParser.prototype.aggregationClause = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 1917; - this.match(SqlBaseParser.GROUP); + this.match(SparkSqlParser.GROUP); this.state = 1918; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 1919; - localctx.kind = this.match(SqlBaseParser.GROUPING); + localctx.kind = this.match(SparkSqlParser.GROUPING); this.state = 1920; - this.match(SqlBaseParser.SETS); + this.match(SparkSqlParser.SETS); this.state = 1921; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1922; this.groupingSet(); this.state = 1927; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1923; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1924; this.groupingSet(); this.state = 1929; @@ -17645,7 +17645,7 @@ SqlBaseParser.prototype.aggregationClause = function() { _la = this._input.LA(1); } this.state = 1930; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -17673,7 +17673,7 @@ function GroupingSetContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_groupingSet; + this.ruleIndex = SparkSqlParser.RULE_groupingSet; return this; } @@ -17692,19 +17692,19 @@ GroupingSetContext.prototype.expression = function(i) { }; GroupingSetContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterGroupingSet(this); } }; GroupingSetContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitGroupingSet(this); } }; GroupingSetContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitGroupingSet(this); } else { return visitor.visitChildren(this); @@ -17714,12 +17714,12 @@ GroupingSetContext.prototype.accept = function(visitor) { -SqlBaseParser.GroupingSetContext = GroupingSetContext; +SparkSqlParser.GroupingSetContext = GroupingSetContext; -SqlBaseParser.prototype.groupingSet = function() { +SparkSqlParser.prototype.groupingSet = function() { var localctx = new GroupingSetContext(this, this._ctx, this.state); - this.enterRule(localctx, 124, SqlBaseParser.RULE_groupingSet); + this.enterRule(localctx, 124, SparkSqlParser.RULE_groupingSet); var _la = 0; // Token type try { this.state = 1947; @@ -17729,7 +17729,7 @@ SqlBaseParser.prototype.groupingSet = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 1934; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1943; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,233,this._ctx); @@ -17739,9 +17739,9 @@ SqlBaseParser.prototype.groupingSet = function() { this.state = 1940; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1936; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1937; this.expression(); this.state = 1942; @@ -17751,7 +17751,7 @@ SqlBaseParser.prototype.groupingSet = function() { } this.state = 1945; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 2: @@ -17785,7 +17785,7 @@ function PivotClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_pivotClause; + this.ruleIndex = SparkSqlParser.RULE_pivotClause; this.aggregates = null; // NamedExpressionSeqContext this._pivotValue = null; // PivotValueContext this.pivotValues = []; // of PivotValueContexts @@ -17796,11 +17796,11 @@ PivotClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) PivotClauseContext.prototype.constructor = PivotClauseContext; PivotClauseContext.prototype.PIVOT = function() { - return this.getToken(SqlBaseParser.PIVOT, 0); + return this.getToken(SparkSqlParser.PIVOT, 0); }; PivotClauseContext.prototype.FOR = function() { - return this.getToken(SqlBaseParser.FOR, 0); + return this.getToken(SparkSqlParser.FOR, 0); }; PivotClauseContext.prototype.pivotColumn = function() { @@ -17808,7 +17808,7 @@ PivotClauseContext.prototype.pivotColumn = function() { }; PivotClauseContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; PivotClauseContext.prototype.namedExpressionSeq = function() { @@ -17827,19 +17827,19 @@ PivotClauseContext.prototype.pivotValue = function(i) { }; PivotClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPivotClause(this); } }; PivotClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPivotClause(this); } }; PivotClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPivotClause(this); } else { return visitor.visitChildren(this); @@ -17849,38 +17849,38 @@ PivotClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.PivotClauseContext = PivotClauseContext; +SparkSqlParser.PivotClauseContext = PivotClauseContext; -SqlBaseParser.prototype.pivotClause = function() { +SparkSqlParser.prototype.pivotClause = function() { var localctx = new PivotClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 126, SqlBaseParser.RULE_pivotClause); + this.enterRule(localctx, 126, SparkSqlParser.RULE_pivotClause); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1949; - this.match(SqlBaseParser.PIVOT); + this.match(SparkSqlParser.PIVOT); this.state = 1950; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1951; localctx.aggregates = this.namedExpressionSeq(); this.state = 1952; - this.match(SqlBaseParser.FOR); + this.match(SparkSqlParser.FOR); this.state = 1953; this.pivotColumn(); this.state = 1954; - this.match(SqlBaseParser.IN); + this.match(SparkSqlParser.IN); this.state = 1955; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1956; localctx._pivotValue = this.pivotValue(); localctx.pivotValues.push(localctx._pivotValue); this.state = 1961; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1957; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1958; localctx._pivotValue = this.pivotValue(); localctx.pivotValues.push(localctx._pivotValue); @@ -17889,9 +17889,9 @@ SqlBaseParser.prototype.pivotClause = function() { _la = this._input.LA(1); } this.state = 1964; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 1965; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -17916,7 +17916,7 @@ function PivotColumnContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_pivotColumn; + this.ruleIndex = SparkSqlParser.RULE_pivotColumn; this._identifier = null; // IdentifierContext this.identifiers = []; // of IdentifierContexts return this; @@ -17937,19 +17937,19 @@ PivotColumnContext.prototype.identifier = function(i) { }; PivotColumnContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPivotColumn(this); } }; PivotColumnContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPivotColumn(this); } }; PivotColumnContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPivotColumn(this); } else { return visitor.visitChildren(this); @@ -17959,12 +17959,12 @@ PivotColumnContext.prototype.accept = function(visitor) { -SqlBaseParser.PivotColumnContext = PivotColumnContext; +SparkSqlParser.PivotColumnContext = PivotColumnContext; -SqlBaseParser.prototype.pivotColumn = function() { +SparkSqlParser.prototype.pivotColumn = function() { var localctx = new PivotColumnContext(this, this._ctx, this.state); - this.enterRule(localctx, 128, SqlBaseParser.RULE_pivotColumn); + this.enterRule(localctx, 128, SparkSqlParser.RULE_pivotColumn); var _la = 0; // Token type try { this.state = 1979; @@ -17981,16 +17981,16 @@ SqlBaseParser.prototype.pivotColumn = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 1968; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 1969; localctx._identifier = this.identifier(); localctx.identifiers.push(localctx._identifier); this.state = 1974; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1970; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1971; localctx._identifier = this.identifier(); localctx.identifiers.push(localctx._identifier); @@ -17999,7 +17999,7 @@ SqlBaseParser.prototype.pivotColumn = function() { _la = this._input.LA(1); } this.state = 1977; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -18027,7 +18027,7 @@ function PivotValueContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_pivotValue; + this.ruleIndex = SparkSqlParser.RULE_pivotValue; return this; } @@ -18043,23 +18043,23 @@ PivotValueContext.prototype.identifier = function() { }; PivotValueContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; PivotValueContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPivotValue(this); } }; PivotValueContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPivotValue(this); } }; PivotValueContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPivotValue(this); } else { return visitor.visitChildren(this); @@ -18069,12 +18069,12 @@ PivotValueContext.prototype.accept = function(visitor) { -SqlBaseParser.PivotValueContext = PivotValueContext; +SparkSqlParser.PivotValueContext = PivotValueContext; -SqlBaseParser.prototype.pivotValue = function() { +SparkSqlParser.prototype.pivotValue = function() { var localctx = new PivotValueContext(this, this._ctx, this.state); - this.enterRule(localctx, 130, SqlBaseParser.RULE_pivotValue); + this.enterRule(localctx, 130, SparkSqlParser.RULE_pivotValue); try { this.enterOuterAlt(localctx, 1); this.state = 1981; @@ -18088,7 +18088,7 @@ SqlBaseParser.prototype.pivotValue = function() { var la_ = this._interp.adaptivePredict(this._input,238,this._ctx); if(la_===1) { this.state = 1982; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 1985; @@ -18119,7 +18119,7 @@ function LateralViewContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_lateralView; + this.ruleIndex = SparkSqlParser.RULE_lateralView; this.tblName = null; // IdentifierContext this._identifier = null; // IdentifierContext this.colName = []; // of IdentifierContexts @@ -18130,11 +18130,11 @@ LateralViewContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) LateralViewContext.prototype.constructor = LateralViewContext; LateralViewContext.prototype.LATERAL = function() { - return this.getToken(SqlBaseParser.LATERAL, 0); + return this.getToken(SparkSqlParser.LATERAL, 0); }; LateralViewContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; LateralViewContext.prototype.qualifiedName = function() { @@ -18153,7 +18153,7 @@ LateralViewContext.prototype.identifier = function(i) { }; LateralViewContext.prototype.OUTER = function() { - return this.getToken(SqlBaseParser.OUTER, 0); + return this.getToken(SparkSqlParser.OUTER, 0); }; LateralViewContext.prototype.expression = function(i) { @@ -18168,23 +18168,23 @@ LateralViewContext.prototype.expression = function(i) { }; LateralViewContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; LateralViewContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLateralView(this); } }; LateralViewContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLateralView(this); } }; LateralViewContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLateralView(this); } else { return visitor.visitChildren(this); @@ -18194,31 +18194,31 @@ LateralViewContext.prototype.accept = function(visitor) { -SqlBaseParser.LateralViewContext = LateralViewContext; +SparkSqlParser.LateralViewContext = LateralViewContext; -SqlBaseParser.prototype.lateralView = function() { +SparkSqlParser.prototype.lateralView = function() { var localctx = new LateralViewContext(this, this._ctx, this.state); - this.enterRule(localctx, 132, SqlBaseParser.RULE_lateralView); + this.enterRule(localctx, 132, SparkSqlParser.RULE_lateralView); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 1988; - this.match(SqlBaseParser.LATERAL); + this.match(SparkSqlParser.LATERAL); this.state = 1989; - this.match(SqlBaseParser.VIEW); + this.match(SparkSqlParser.VIEW); this.state = 1991; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,240,this._ctx); if(la_===1) { this.state = 1990; - this.match(SqlBaseParser.OUTER); + this.match(SparkSqlParser.OUTER); } this.state = 1993; this.qualifiedName(); this.state = 1994; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2003; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,242,this._ctx); @@ -18228,9 +18228,9 @@ SqlBaseParser.prototype.lateralView = function() { this.state = 2000; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 1996; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 1997; this.expression(); this.state = 2002; @@ -18240,7 +18240,7 @@ SqlBaseParser.prototype.lateralView = function() { } this.state = 2005; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 2006; localctx.tblName = this.identifier(); this.state = 2018; @@ -18252,7 +18252,7 @@ SqlBaseParser.prototype.lateralView = function() { var la_ = this._interp.adaptivePredict(this._input,243,this._ctx); if(la_===1) { this.state = 2007; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 2010; @@ -18264,7 +18264,7 @@ SqlBaseParser.prototype.lateralView = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2011; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2012; localctx._identifier = this.identifier(); localctx.colName.push(localctx._identifier); @@ -18300,7 +18300,7 @@ function SetQuantifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_setQuantifier; + this.ruleIndex = SparkSqlParser.RULE_setQuantifier; return this; } @@ -18308,27 +18308,27 @@ SetQuantifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototyp SetQuantifierContext.prototype.constructor = SetQuantifierContext; SetQuantifierContext.prototype.DISTINCT = function() { - return this.getToken(SqlBaseParser.DISTINCT, 0); + return this.getToken(SparkSqlParser.DISTINCT, 0); }; SetQuantifierContext.prototype.ALL = function() { - return this.getToken(SqlBaseParser.ALL, 0); + return this.getToken(SparkSqlParser.ALL, 0); }; SetQuantifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSetQuantifier(this); } }; SetQuantifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSetQuantifier(this); } }; SetQuantifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSetQuantifier(this); } else { return visitor.visitChildren(this); @@ -18338,18 +18338,18 @@ SetQuantifierContext.prototype.accept = function(visitor) { -SqlBaseParser.SetQuantifierContext = SetQuantifierContext; +SparkSqlParser.SetQuantifierContext = SetQuantifierContext; -SqlBaseParser.prototype.setQuantifier = function() { +SparkSqlParser.prototype.setQuantifier = function() { var localctx = new SetQuantifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 134, SqlBaseParser.RULE_setQuantifier); + this.enterRule(localctx, 134, SparkSqlParser.RULE_setQuantifier); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2020; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ALL || _la===SqlBaseParser.DISTINCT)) { + if(!(_la===SparkSqlParser.ALL || _la===SparkSqlParser.DISTINCT)) { this._errHandler.recoverInline(this); } else { @@ -18380,7 +18380,7 @@ function RelationContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_relation; + this.ruleIndex = SparkSqlParser.RULE_relation; return this; } @@ -18403,19 +18403,19 @@ RelationContext.prototype.joinRelation = function(i) { }; RelationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRelation(this); } }; RelationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRelation(this); } }; RelationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRelation(this); } else { return visitor.visitChildren(this); @@ -18425,12 +18425,12 @@ RelationContext.prototype.accept = function(visitor) { -SqlBaseParser.RelationContext = RelationContext; +SparkSqlParser.RelationContext = RelationContext; -SqlBaseParser.prototype.relation = function() { +SparkSqlParser.prototype.relation = function() { var localctx = new RelationContext(this, this._ctx, this.state); - this.enterRule(localctx, 136, SqlBaseParser.RULE_relation); + this.enterRule(localctx, 136, SparkSqlParser.RULE_relation); try { this.enterOuterAlt(localctx, 1); this.state = 2022; @@ -18472,7 +18472,7 @@ function JoinRelationContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_joinRelation; + this.ruleIndex = SparkSqlParser.RULE_joinRelation; this.right = null; // RelationPrimaryContext return this; } @@ -18481,7 +18481,7 @@ JoinRelationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype JoinRelationContext.prototype.constructor = JoinRelationContext; JoinRelationContext.prototype.JOIN = function() { - return this.getToken(SqlBaseParser.JOIN, 0); + return this.getToken(SparkSqlParser.JOIN, 0); }; JoinRelationContext.prototype.relationPrimary = function() { @@ -18497,23 +18497,23 @@ JoinRelationContext.prototype.joinCriteria = function() { }; JoinRelationContext.prototype.NATURAL = function() { - return this.getToken(SqlBaseParser.NATURAL, 0); + return this.getToken(SparkSqlParser.NATURAL, 0); }; JoinRelationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterJoinRelation(this); } }; JoinRelationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitJoinRelation(this); } }; JoinRelationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitJoinRelation(this); } else { return visitor.visitChildren(this); @@ -18523,29 +18523,29 @@ JoinRelationContext.prototype.accept = function(visitor) { -SqlBaseParser.JoinRelationContext = JoinRelationContext; +SparkSqlParser.JoinRelationContext = JoinRelationContext; -SqlBaseParser.prototype.joinRelation = function() { +SparkSqlParser.prototype.joinRelation = function() { var localctx = new JoinRelationContext(this, this._ctx, this.state); - this.enterRule(localctx, 138, SqlBaseParser.RULE_joinRelation); + this.enterRule(localctx, 138, SparkSqlParser.RULE_joinRelation); try { this.state = 2040; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.ANTI: - case SqlBaseParser.CROSS: - case SqlBaseParser.FULL: - case SqlBaseParser.INNER: - case SqlBaseParser.JOIN: - case SqlBaseParser.LEFT: - case SqlBaseParser.RIGHT: - case SqlBaseParser.SEMI: + case SparkSqlParser.ANTI: + case SparkSqlParser.CROSS: + case SparkSqlParser.FULL: + case SparkSqlParser.INNER: + case SparkSqlParser.JOIN: + case SparkSqlParser.LEFT: + case SparkSqlParser.RIGHT: + case SparkSqlParser.SEMI: this.enterOuterAlt(localctx, 1); this.state = 2029; this.joinType(); this.state = 2030; - this.match(SqlBaseParser.JOIN); + this.match(SparkSqlParser.JOIN); this.state = 2031; localctx.right = this.relationPrimary(); this.state = 2033; @@ -18557,14 +18557,14 @@ SqlBaseParser.prototype.joinRelation = function() { } break; - case SqlBaseParser.NATURAL: + case SparkSqlParser.NATURAL: this.enterOuterAlt(localctx, 2); this.state = 2035; - this.match(SqlBaseParser.NATURAL); + this.match(SparkSqlParser.NATURAL); this.state = 2036; this.joinType(); this.state = 2037; - this.match(SqlBaseParser.JOIN); + this.match(SparkSqlParser.JOIN); this.state = 2038; localctx.right = this.relationPrimary(); break; @@ -18595,7 +18595,7 @@ function JoinTypeContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_joinType; + this.ruleIndex = SparkSqlParser.RULE_joinType; return this; } @@ -18603,51 +18603,51 @@ JoinTypeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); JoinTypeContext.prototype.constructor = JoinTypeContext; JoinTypeContext.prototype.INNER = function() { - return this.getToken(SqlBaseParser.INNER, 0); + return this.getToken(SparkSqlParser.INNER, 0); }; JoinTypeContext.prototype.CROSS = function() { - return this.getToken(SqlBaseParser.CROSS, 0); + return this.getToken(SparkSqlParser.CROSS, 0); }; JoinTypeContext.prototype.LEFT = function() { - return this.getToken(SqlBaseParser.LEFT, 0); + return this.getToken(SparkSqlParser.LEFT, 0); }; JoinTypeContext.prototype.OUTER = function() { - return this.getToken(SqlBaseParser.OUTER, 0); + return this.getToken(SparkSqlParser.OUTER, 0); }; JoinTypeContext.prototype.SEMI = function() { - return this.getToken(SqlBaseParser.SEMI, 0); + return this.getToken(SparkSqlParser.SEMI, 0); }; JoinTypeContext.prototype.RIGHT = function() { - return this.getToken(SqlBaseParser.RIGHT, 0); + return this.getToken(SparkSqlParser.RIGHT, 0); }; JoinTypeContext.prototype.FULL = function() { - return this.getToken(SqlBaseParser.FULL, 0); + return this.getToken(SparkSqlParser.FULL, 0); }; JoinTypeContext.prototype.ANTI = function() { - return this.getToken(SqlBaseParser.ANTI, 0); + return this.getToken(SparkSqlParser.ANTI, 0); }; JoinTypeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterJoinType(this); } }; JoinTypeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitJoinType(this); } }; JoinTypeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitJoinType(this); } else { return visitor.visitChildren(this); @@ -18657,12 +18657,12 @@ JoinTypeContext.prototype.accept = function(visitor) { -SqlBaseParser.JoinTypeContext = JoinTypeContext; +SparkSqlParser.JoinTypeContext = JoinTypeContext; -SqlBaseParser.prototype.joinType = function() { +SparkSqlParser.prototype.joinType = function() { var localctx = new JoinTypeContext(this, this._ctx, this.state); - this.enterRule(localctx, 140, SqlBaseParser.RULE_joinType); + this.enterRule(localctx, 140, SparkSqlParser.RULE_joinType); var _la = 0; // Token type try { this.state = 2066; @@ -18674,9 +18674,9 @@ SqlBaseParser.prototype.joinType = function() { this.state = 2043; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.INNER) { + if(_la===SparkSqlParser.INNER) { this.state = 2042; - this.match(SqlBaseParser.INNER); + this.match(SparkSqlParser.INNER); } break; @@ -18684,19 +18684,19 @@ SqlBaseParser.prototype.joinType = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 2045; - this.match(SqlBaseParser.CROSS); + this.match(SparkSqlParser.CROSS); break; case 3: this.enterOuterAlt(localctx, 3); this.state = 2046; - this.match(SqlBaseParser.LEFT); + this.match(SparkSqlParser.LEFT); this.state = 2048; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OUTER) { + if(_la===SparkSqlParser.OUTER) { this.state = 2047; - this.match(SqlBaseParser.OUTER); + this.match(SparkSqlParser.OUTER); } break; @@ -18706,25 +18706,25 @@ SqlBaseParser.prototype.joinType = function() { this.state = 2051; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LEFT) { + if(_la===SparkSqlParser.LEFT) { this.state = 2050; - this.match(SqlBaseParser.LEFT); + this.match(SparkSqlParser.LEFT); } this.state = 2053; - this.match(SqlBaseParser.SEMI); + this.match(SparkSqlParser.SEMI); break; case 5: this.enterOuterAlt(localctx, 5); this.state = 2054; - this.match(SqlBaseParser.RIGHT); + this.match(SparkSqlParser.RIGHT); this.state = 2056; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OUTER) { + if(_la===SparkSqlParser.OUTER) { this.state = 2055; - this.match(SqlBaseParser.OUTER); + this.match(SparkSqlParser.OUTER); } break; @@ -18732,13 +18732,13 @@ SqlBaseParser.prototype.joinType = function() { case 6: this.enterOuterAlt(localctx, 6); this.state = 2058; - this.match(SqlBaseParser.FULL); + this.match(SparkSqlParser.FULL); this.state = 2060; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.OUTER) { + if(_la===SparkSqlParser.OUTER) { this.state = 2059; - this.match(SqlBaseParser.OUTER); + this.match(SparkSqlParser.OUTER); } break; @@ -18748,13 +18748,13 @@ SqlBaseParser.prototype.joinType = function() { this.state = 2063; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.LEFT) { + if(_la===SparkSqlParser.LEFT) { this.state = 2062; - this.match(SqlBaseParser.LEFT); + this.match(SparkSqlParser.LEFT); } this.state = 2065; - this.match(SqlBaseParser.ANTI); + this.match(SparkSqlParser.ANTI); break; } @@ -18782,7 +18782,7 @@ function JoinCriteriaContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_joinCriteria; + this.ruleIndex = SparkSqlParser.RULE_joinCriteria; return this; } @@ -18790,7 +18790,7 @@ JoinCriteriaContext.prototype = Object.create(antlr4.ParserRuleContext.prototype JoinCriteriaContext.prototype.constructor = JoinCriteriaContext; JoinCriteriaContext.prototype.ON = function() { - return this.getToken(SqlBaseParser.ON, 0); + return this.getToken(SparkSqlParser.ON, 0); }; JoinCriteriaContext.prototype.booleanExpression = function() { @@ -18798,7 +18798,7 @@ JoinCriteriaContext.prototype.booleanExpression = function() { }; JoinCriteriaContext.prototype.USING = function() { - return this.getToken(SqlBaseParser.USING, 0); + return this.getToken(SparkSqlParser.USING, 0); }; JoinCriteriaContext.prototype.identifierList = function() { @@ -18806,19 +18806,19 @@ JoinCriteriaContext.prototype.identifierList = function() { }; JoinCriteriaContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterJoinCriteria(this); } }; JoinCriteriaContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitJoinCriteria(this); } }; JoinCriteriaContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitJoinCriteria(this); } else { return visitor.visitChildren(this); @@ -18828,27 +18828,27 @@ JoinCriteriaContext.prototype.accept = function(visitor) { -SqlBaseParser.JoinCriteriaContext = JoinCriteriaContext; +SparkSqlParser.JoinCriteriaContext = JoinCriteriaContext; -SqlBaseParser.prototype.joinCriteria = function() { +SparkSqlParser.prototype.joinCriteria = function() { var localctx = new JoinCriteriaContext(this, this._ctx, this.state); - this.enterRule(localctx, 142, SqlBaseParser.RULE_joinCriteria); + this.enterRule(localctx, 142, SparkSqlParser.RULE_joinCriteria); try { this.state = 2072; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.ON: + case SparkSqlParser.ON: this.enterOuterAlt(localctx, 1); this.state = 2068; - this.match(SqlBaseParser.ON); + this.match(SparkSqlParser.ON); this.state = 2069; this.booleanExpression(0); break; - case SqlBaseParser.USING: + case SparkSqlParser.USING: this.enterOuterAlt(localctx, 2); this.state = 2070; - this.match(SqlBaseParser.USING); + this.match(SparkSqlParser.USING); this.state = 2071; this.identifierList(); break; @@ -18879,7 +18879,7 @@ function SampleContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_sample; + this.ruleIndex = SparkSqlParser.RULE_sample; return this; } @@ -18887,7 +18887,7 @@ SampleContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); SampleContext.prototype.constructor = SampleContext; SampleContext.prototype.TABLESAMPLE = function() { - return this.getToken(SqlBaseParser.TABLESAMPLE, 0); + return this.getToken(SparkSqlParser.TABLESAMPLE, 0); }; SampleContext.prototype.sampleMethod = function() { @@ -18895,19 +18895,19 @@ SampleContext.prototype.sampleMethod = function() { }; SampleContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSample(this); } }; SampleContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSample(this); } }; SampleContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSample(this); } else { return visitor.visitChildren(this); @@ -18917,18 +18917,18 @@ SampleContext.prototype.accept = function(visitor) { -SqlBaseParser.SampleContext = SampleContext; +SparkSqlParser.SampleContext = SampleContext; -SqlBaseParser.prototype.sample = function() { +SparkSqlParser.prototype.sample = function() { var localctx = new SampleContext(this, this._ctx, this.state); - this.enterRule(localctx, 144, SqlBaseParser.RULE_sample); + this.enterRule(localctx, 144, SparkSqlParser.RULE_sample); try { this.enterOuterAlt(localctx, 1); this.state = 2074; - this.match(SqlBaseParser.TABLESAMPLE); + this.match(SparkSqlParser.TABLESAMPLE); this.state = 2075; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2077; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,257,this._ctx); @@ -18938,7 +18938,7 @@ SqlBaseParser.prototype.sample = function() { } this.state = 2079; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -18963,7 +18963,7 @@ function SampleMethodContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_sampleMethod; + this.ruleIndex = SparkSqlParser.RULE_sampleMethod; return this; } @@ -18986,29 +18986,29 @@ function SampleByRowsContext(parser, ctx) { SampleByRowsContext.prototype = Object.create(SampleMethodContext.prototype); SampleByRowsContext.prototype.constructor = SampleByRowsContext; -SqlBaseParser.SampleByRowsContext = SampleByRowsContext; +SparkSqlParser.SampleByRowsContext = SampleByRowsContext; SampleByRowsContext.prototype.expression = function() { return this.getTypedRuleContext(ExpressionContext,0); }; SampleByRowsContext.prototype.ROWS = function() { - return this.getToken(SqlBaseParser.ROWS, 0); + return this.getToken(SparkSqlParser.ROWS, 0); }; SampleByRowsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSampleByRows(this); } }; SampleByRowsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSampleByRows(this); } }; SampleByRowsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSampleByRows(this); } else { return visitor.visitChildren(this); @@ -19027,37 +19027,37 @@ function SampleByPercentileContext(parser, ctx) { SampleByPercentileContext.prototype = Object.create(SampleMethodContext.prototype); SampleByPercentileContext.prototype.constructor = SampleByPercentileContext; -SqlBaseParser.SampleByPercentileContext = SampleByPercentileContext; +SparkSqlParser.SampleByPercentileContext = SampleByPercentileContext; SampleByPercentileContext.prototype.PERCENTLIT = function() { - return this.getToken(SqlBaseParser.PERCENTLIT, 0); + return this.getToken(SparkSqlParser.PERCENTLIT, 0); }; SampleByPercentileContext.prototype.INTEGER_VALUE = function() { - return this.getToken(SqlBaseParser.INTEGER_VALUE, 0); + return this.getToken(SparkSqlParser.INTEGER_VALUE, 0); }; SampleByPercentileContext.prototype.DECIMAL_VALUE = function() { - return this.getToken(SqlBaseParser.DECIMAL_VALUE, 0); + return this.getToken(SparkSqlParser.DECIMAL_VALUE, 0); }; SampleByPercentileContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; SampleByPercentileContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSampleByPercentile(this); } }; SampleByPercentileContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSampleByPercentile(this); } }; SampleByPercentileContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSampleByPercentile(this); } else { return visitor.visitChildren(this); @@ -19077,18 +19077,18 @@ function SampleByBucketContext(parser, ctx) { SampleByBucketContext.prototype = Object.create(SampleMethodContext.prototype); SampleByBucketContext.prototype.constructor = SampleByBucketContext; -SqlBaseParser.SampleByBucketContext = SampleByBucketContext; +SparkSqlParser.SampleByBucketContext = SampleByBucketContext; SampleByBucketContext.prototype.OUT = function() { - return this.getToken(SqlBaseParser.OUT, 0); + return this.getToken(SparkSqlParser.OUT, 0); }; SampleByBucketContext.prototype.OF = function() { - return this.getToken(SqlBaseParser.OF, 0); + return this.getToken(SparkSqlParser.OF, 0); }; SampleByBucketContext.prototype.BUCKET = function() { - return this.getToken(SqlBaseParser.BUCKET, 0); + return this.getToken(SparkSqlParser.BUCKET, 0); }; SampleByBucketContext.prototype.INTEGER_VALUE = function(i) { @@ -19096,15 +19096,15 @@ SampleByBucketContext.prototype.INTEGER_VALUE = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.INTEGER_VALUE); + return this.getTokens(SparkSqlParser.INTEGER_VALUE); } else { - return this.getToken(SqlBaseParser.INTEGER_VALUE, i); + return this.getToken(SparkSqlParser.INTEGER_VALUE, i); } }; SampleByBucketContext.prototype.ON = function() { - return this.getToken(SqlBaseParser.ON, 0); + return this.getToken(SparkSqlParser.ON, 0); }; SampleByBucketContext.prototype.identifier = function() { @@ -19115,19 +19115,19 @@ SampleByBucketContext.prototype.qualifiedName = function() { return this.getTypedRuleContext(QualifiedNameContext,0); }; SampleByBucketContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSampleByBucket(this); } }; SampleByBucketContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSampleByBucket(this); } }; SampleByBucketContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSampleByBucket(this); } else { return visitor.visitChildren(this); @@ -19145,25 +19145,25 @@ function SampleByBytesContext(parser, ctx) { SampleByBytesContext.prototype = Object.create(SampleMethodContext.prototype); SampleByBytesContext.prototype.constructor = SampleByBytesContext; -SqlBaseParser.SampleByBytesContext = SampleByBytesContext; +SparkSqlParser.SampleByBytesContext = SampleByBytesContext; SampleByBytesContext.prototype.expression = function() { return this.getTypedRuleContext(ExpressionContext,0); }; SampleByBytesContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSampleByBytes(this); } }; SampleByBytesContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSampleByBytes(this); } }; SampleByBytesContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSampleByBytes(this); } else { return visitor.visitChildren(this); @@ -19172,12 +19172,12 @@ SampleByBytesContext.prototype.accept = function(visitor) { -SqlBaseParser.SampleMethodContext = SampleMethodContext; +SparkSqlParser.SampleMethodContext = SampleMethodContext; -SqlBaseParser.prototype.sampleMethod = function() { +SparkSqlParser.prototype.sampleMethod = function() { var localctx = new SampleMethodContext(this, this._ctx, this.state); - this.enterRule(localctx, 146, SqlBaseParser.RULE_sampleMethod); + this.enterRule(localctx, 146, SparkSqlParser.RULE_sampleMethod); var _la = 0; // Token type try { this.state = 2105; @@ -19190,15 +19190,15 @@ SqlBaseParser.prototype.sampleMethod = function() { this.state = 2082; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2081; - localctx.negativeSign = this.match(SqlBaseParser.MINUS); + localctx.negativeSign = this.match(SparkSqlParser.MINUS); } this.state = 2084; localctx.percentage = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.INTEGER_VALUE || _la===SqlBaseParser.DECIMAL_VALUE)) { + if(!(_la===SparkSqlParser.INTEGER_VALUE || _la===SparkSqlParser.DECIMAL_VALUE)) { localctx.percentage = this._errHandler.recoverInline(this); } else { @@ -19206,7 +19206,7 @@ SqlBaseParser.prototype.sampleMethod = function() { this.consume(); } this.state = 2085; - this.match(SqlBaseParser.PERCENTLIT); + this.match(SparkSqlParser.PERCENTLIT); break; case 2: @@ -19215,28 +19215,28 @@ SqlBaseParser.prototype.sampleMethod = function() { this.state = 2086; this.expression(); this.state = 2087; - this.match(SqlBaseParser.ROWS); + this.match(SparkSqlParser.ROWS); break; case 3: localctx = new SampleByBucketContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 2089; - localctx.sampleType = this.match(SqlBaseParser.BUCKET); + localctx.sampleType = this.match(SparkSqlParser.BUCKET); this.state = 2090; - localctx.numerator = this.match(SqlBaseParser.INTEGER_VALUE); + localctx.numerator = this.match(SparkSqlParser.INTEGER_VALUE); this.state = 2091; - this.match(SqlBaseParser.OUT); + this.match(SparkSqlParser.OUT); this.state = 2092; - this.match(SqlBaseParser.OF); + this.match(SparkSqlParser.OF); this.state = 2093; - localctx.denominator = this.match(SqlBaseParser.INTEGER_VALUE); + localctx.denominator = this.match(SparkSqlParser.INTEGER_VALUE); this.state = 2102; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ON) { + if(_la===SparkSqlParser.ON) { this.state = 2094; - this.match(SqlBaseParser.ON); + this.match(SparkSqlParser.ON); this.state = 2100; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,259,this._ctx); @@ -19250,9 +19250,9 @@ SqlBaseParser.prototype.sampleMethod = function() { this.state = 2096; this.qualifiedName(); this.state = 2097; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2098; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -19292,7 +19292,7 @@ function IdentifierListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_identifierList; + this.ruleIndex = SparkSqlParser.RULE_identifierList; return this; } @@ -19304,19 +19304,19 @@ IdentifierListContext.prototype.identifierSeq = function() { }; IdentifierListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIdentifierList(this); } }; IdentifierListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIdentifierList(this); } }; IdentifierListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIdentifierList(this); } else { return visitor.visitChildren(this); @@ -19326,20 +19326,20 @@ IdentifierListContext.prototype.accept = function(visitor) { -SqlBaseParser.IdentifierListContext = IdentifierListContext; +SparkSqlParser.IdentifierListContext = IdentifierListContext; -SqlBaseParser.prototype.identifierList = function() { +SparkSqlParser.prototype.identifierList = function() { var localctx = new IdentifierListContext(this, this._ctx, this.state); - this.enterRule(localctx, 148, SqlBaseParser.RULE_identifierList); + this.enterRule(localctx, 148, SparkSqlParser.RULE_identifierList); try { this.enterOuterAlt(localctx, 1); this.state = 2107; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2108; this.identifierSeq(); this.state = 2109; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -19364,7 +19364,7 @@ function IdentifierSeqContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_identifierSeq; + this.ruleIndex = SparkSqlParser.RULE_identifierSeq; this._errorCapturingIdentifier = null; // ErrorCapturingIdentifierContext this.ident = []; // of ErrorCapturingIdentifierContexts return this; @@ -19385,19 +19385,19 @@ IdentifierSeqContext.prototype.errorCapturingIdentifier = function(i) { }; IdentifierSeqContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIdentifierSeq(this); } }; IdentifierSeqContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIdentifierSeq(this); } }; IdentifierSeqContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIdentifierSeq(this); } else { return visitor.visitChildren(this); @@ -19407,12 +19407,12 @@ IdentifierSeqContext.prototype.accept = function(visitor) { -SqlBaseParser.IdentifierSeqContext = IdentifierSeqContext; +SparkSqlParser.IdentifierSeqContext = IdentifierSeqContext; -SqlBaseParser.prototype.identifierSeq = function() { +SparkSqlParser.prototype.identifierSeq = function() { var localctx = new IdentifierSeqContext(this, this._ctx, this.state); - this.enterRule(localctx, 150, SqlBaseParser.RULE_identifierSeq); + this.enterRule(localctx, 150, SparkSqlParser.RULE_identifierSeq); try { this.enterOuterAlt(localctx, 1); this.state = 2111; @@ -19424,7 +19424,7 @@ SqlBaseParser.prototype.identifierSeq = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2112; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2113; localctx._errorCapturingIdentifier = this.errorCapturingIdentifier(); localctx.ident.push(localctx._errorCapturingIdentifier); @@ -19458,7 +19458,7 @@ function OrderedIdentifierListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_orderedIdentifierList; + this.ruleIndex = SparkSqlParser.RULE_orderedIdentifierList; return this; } @@ -19477,19 +19477,19 @@ OrderedIdentifierListContext.prototype.orderedIdentifier = function(i) { }; OrderedIdentifierListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterOrderedIdentifierList(this); } }; OrderedIdentifierListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitOrderedIdentifierList(this); } }; OrderedIdentifierListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitOrderedIdentifierList(this); } else { return visitor.visitChildren(this); @@ -19499,25 +19499,25 @@ OrderedIdentifierListContext.prototype.accept = function(visitor) { -SqlBaseParser.OrderedIdentifierListContext = OrderedIdentifierListContext; +SparkSqlParser.OrderedIdentifierListContext = OrderedIdentifierListContext; -SqlBaseParser.prototype.orderedIdentifierList = function() { +SparkSqlParser.prototype.orderedIdentifierList = function() { var localctx = new OrderedIdentifierListContext(this, this._ctx, this.state); - this.enterRule(localctx, 152, SqlBaseParser.RULE_orderedIdentifierList); + this.enterRule(localctx, 152, SparkSqlParser.RULE_orderedIdentifierList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2119; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2120; this.orderedIdentifier(); this.state = 2125; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2121; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2122; this.orderedIdentifier(); this.state = 2127; @@ -19525,7 +19525,7 @@ SqlBaseParser.prototype.orderedIdentifierList = function() { _la = this._input.LA(1); } this.state = 2128; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -19550,7 +19550,7 @@ function OrderedIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_orderedIdentifier; + this.ruleIndex = SparkSqlParser.RULE_orderedIdentifier; this.ident = null; // ErrorCapturingIdentifierContext this.ordering = null; // Token return this; @@ -19564,27 +19564,27 @@ OrderedIdentifierContext.prototype.errorCapturingIdentifier = function() { }; OrderedIdentifierContext.prototype.ASC = function() { - return this.getToken(SqlBaseParser.ASC, 0); + return this.getToken(SparkSqlParser.ASC, 0); }; OrderedIdentifierContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; OrderedIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterOrderedIdentifier(this); } }; OrderedIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitOrderedIdentifier(this); } }; OrderedIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitOrderedIdentifier(this); } else { return visitor.visitChildren(this); @@ -19594,12 +19594,12 @@ OrderedIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.OrderedIdentifierContext = OrderedIdentifierContext; +SparkSqlParser.OrderedIdentifierContext = OrderedIdentifierContext; -SqlBaseParser.prototype.orderedIdentifier = function() { +SparkSqlParser.prototype.orderedIdentifier = function() { var localctx = new OrderedIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 154, SqlBaseParser.RULE_orderedIdentifier); + this.enterRule(localctx, 154, SparkSqlParser.RULE_orderedIdentifier); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -19608,11 +19608,11 @@ SqlBaseParser.prototype.orderedIdentifier = function() { this.state = 2132; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ASC || _la===SqlBaseParser.DESC) { + if(_la===SparkSqlParser.ASC || _la===SparkSqlParser.DESC) { this.state = 2131; localctx.ordering = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ASC || _la===SqlBaseParser.DESC)) { + if(!(_la===SparkSqlParser.ASC || _la===SparkSqlParser.DESC)) { localctx.ordering = this._errHandler.recoverInline(this); } else { @@ -19645,7 +19645,7 @@ function IdentifierCommentListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_identifierCommentList; + this.ruleIndex = SparkSqlParser.RULE_identifierCommentList; return this; } @@ -19664,19 +19664,19 @@ IdentifierCommentListContext.prototype.identifierComment = function(i) { }; IdentifierCommentListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIdentifierCommentList(this); } }; IdentifierCommentListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIdentifierCommentList(this); } }; IdentifierCommentListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIdentifierCommentList(this); } else { return visitor.visitChildren(this); @@ -19686,25 +19686,25 @@ IdentifierCommentListContext.prototype.accept = function(visitor) { -SqlBaseParser.IdentifierCommentListContext = IdentifierCommentListContext; +SparkSqlParser.IdentifierCommentListContext = IdentifierCommentListContext; -SqlBaseParser.prototype.identifierCommentList = function() { +SparkSqlParser.prototype.identifierCommentList = function() { var localctx = new IdentifierCommentListContext(this, this._ctx, this.state); - this.enterRule(localctx, 156, SqlBaseParser.RULE_identifierCommentList); + this.enterRule(localctx, 156, SparkSqlParser.RULE_identifierCommentList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2134; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2135; this.identifierComment(); this.state = 2140; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2136; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2137; this.identifierComment(); this.state = 2142; @@ -19712,7 +19712,7 @@ SqlBaseParser.prototype.identifierCommentList = function() { _la = this._input.LA(1); } this.state = 2143; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -19737,7 +19737,7 @@ function IdentifierCommentContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_identifierComment; + this.ruleIndex = SparkSqlParser.RULE_identifierComment; return this; } @@ -19753,19 +19753,19 @@ IdentifierCommentContext.prototype.commentSpec = function() { }; IdentifierCommentContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIdentifierComment(this); } }; IdentifierCommentContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIdentifierComment(this); } }; IdentifierCommentContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIdentifierComment(this); } else { return visitor.visitChildren(this); @@ -19775,12 +19775,12 @@ IdentifierCommentContext.prototype.accept = function(visitor) { -SqlBaseParser.IdentifierCommentContext = IdentifierCommentContext; +SparkSqlParser.IdentifierCommentContext = IdentifierCommentContext; -SqlBaseParser.prototype.identifierComment = function() { +SparkSqlParser.prototype.identifierComment = function() { var localctx = new IdentifierCommentContext(this, this._ctx, this.state); - this.enterRule(localctx, 158, SqlBaseParser.RULE_identifierComment); + this.enterRule(localctx, 158, SparkSqlParser.RULE_identifierComment); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -19789,7 +19789,7 @@ SqlBaseParser.prototype.identifierComment = function() { this.state = 2147; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.COMMENT) { + if(_la===SparkSqlParser.COMMENT) { this.state = 2146; this.commentSpec(); } @@ -19818,7 +19818,7 @@ function RelationPrimaryContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_relationPrimary; + this.ruleIndex = SparkSqlParser.RULE_relationPrimary; return this; } @@ -19841,25 +19841,25 @@ function TableValuedFunctionContext(parser, ctx) { TableValuedFunctionContext.prototype = Object.create(RelationPrimaryContext.prototype); TableValuedFunctionContext.prototype.constructor = TableValuedFunctionContext; -SqlBaseParser.TableValuedFunctionContext = TableValuedFunctionContext; +SparkSqlParser.TableValuedFunctionContext = TableValuedFunctionContext; TableValuedFunctionContext.prototype.functionTable = function() { return this.getTypedRuleContext(FunctionTableContext,0); }; TableValuedFunctionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTableValuedFunction(this); } }; TableValuedFunctionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTableValuedFunction(this); } }; TableValuedFunctionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTableValuedFunction(this); } else { return visitor.visitChildren(this); @@ -19876,25 +19876,25 @@ function InlineTableDefault2Context(parser, ctx) { InlineTableDefault2Context.prototype = Object.create(RelationPrimaryContext.prototype); InlineTableDefault2Context.prototype.constructor = InlineTableDefault2Context; -SqlBaseParser.InlineTableDefault2Context = InlineTableDefault2Context; +SparkSqlParser.InlineTableDefault2Context = InlineTableDefault2Context; InlineTableDefault2Context.prototype.inlineTable = function() { return this.getTypedRuleContext(InlineTableContext,0); }; InlineTableDefault2Context.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInlineTableDefault2(this); } }; InlineTableDefault2Context.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInlineTableDefault2(this); } }; InlineTableDefault2Context.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInlineTableDefault2(this); } else { return visitor.visitChildren(this); @@ -19911,7 +19911,7 @@ function AliasedRelationContext(parser, ctx) { AliasedRelationContext.prototype = Object.create(RelationPrimaryContext.prototype); AliasedRelationContext.prototype.constructor = AliasedRelationContext; -SqlBaseParser.AliasedRelationContext = AliasedRelationContext; +SparkSqlParser.AliasedRelationContext = AliasedRelationContext; AliasedRelationContext.prototype.relation = function() { return this.getTypedRuleContext(RelationContext,0); @@ -19925,19 +19925,19 @@ AliasedRelationContext.prototype.sample = function() { return this.getTypedRuleContext(SampleContext,0); }; AliasedRelationContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAliasedRelation(this); } }; AliasedRelationContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAliasedRelation(this); } }; AliasedRelationContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAliasedRelation(this); } else { return visitor.visitChildren(this); @@ -19954,7 +19954,7 @@ function AliasedQueryContext(parser, ctx) { AliasedQueryContext.prototype = Object.create(RelationPrimaryContext.prototype); AliasedQueryContext.prototype.constructor = AliasedQueryContext; -SqlBaseParser.AliasedQueryContext = AliasedQueryContext; +SparkSqlParser.AliasedQueryContext = AliasedQueryContext; AliasedQueryContext.prototype.query = function() { return this.getTypedRuleContext(QueryContext,0); @@ -19968,19 +19968,19 @@ AliasedQueryContext.prototype.sample = function() { return this.getTypedRuleContext(SampleContext,0); }; AliasedQueryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAliasedQuery(this); } }; AliasedQueryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAliasedQuery(this); } }; AliasedQueryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAliasedQuery(this); } else { return visitor.visitChildren(this); @@ -19997,7 +19997,7 @@ function TableNameContext(parser, ctx) { TableNameContext.prototype = Object.create(RelationPrimaryContext.prototype); TableNameContext.prototype.constructor = TableNameContext; -SqlBaseParser.TableNameContext = TableNameContext; +SparkSqlParser.TableNameContext = TableNameContext; TableNameContext.prototype.multipartIdentifier = function() { return this.getTypedRuleContext(MultipartIdentifierContext,0); @@ -20011,19 +20011,19 @@ TableNameContext.prototype.sample = function() { return this.getTypedRuleContext(SampleContext,0); }; TableNameContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTableName(this); } }; TableNameContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTableName(this); } }; TableNameContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTableName(this); } else { return visitor.visitChildren(this); @@ -20032,12 +20032,12 @@ TableNameContext.prototype.accept = function(visitor) { -SqlBaseParser.RelationPrimaryContext = RelationPrimaryContext; +SparkSqlParser.RelationPrimaryContext = RelationPrimaryContext; -SqlBaseParser.prototype.relationPrimary = function() { +SparkSqlParser.prototype.relationPrimary = function() { var localctx = new RelationPrimaryContext(this, this._ctx, this.state); - this.enterRule(localctx, 160, SqlBaseParser.RULE_relationPrimary); + this.enterRule(localctx, 160, SparkSqlParser.RULE_relationPrimary); try { this.state = 2173; this._errHandler.sync(this); @@ -20064,11 +20064,11 @@ SqlBaseParser.prototype.relationPrimary = function() { localctx = new AliasedQueryContext(this, localctx); this.enterOuterAlt(localctx, 2); this.state = 2155; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2156; this.query(); this.state = 2157; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 2159; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,268,this._ctx); @@ -20085,11 +20085,11 @@ SqlBaseParser.prototype.relationPrimary = function() { localctx = new AliasedRelationContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 2163; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2164; this.relation(); this.state = 2165; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 2167; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,269,this._ctx); @@ -20141,7 +20141,7 @@ function InlineTableContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_inlineTable; + this.ruleIndex = SparkSqlParser.RULE_inlineTable; return this; } @@ -20149,7 +20149,7 @@ InlineTableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) InlineTableContext.prototype.constructor = InlineTableContext; InlineTableContext.prototype.VALUES = function() { - return this.getToken(SqlBaseParser.VALUES, 0); + return this.getToken(SparkSqlParser.VALUES, 0); }; InlineTableContext.prototype.expression = function(i) { @@ -20168,19 +20168,19 @@ InlineTableContext.prototype.tableAlias = function() { }; InlineTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInlineTable(this); } }; InlineTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInlineTable(this); } }; InlineTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInlineTable(this); } else { return visitor.visitChildren(this); @@ -20190,16 +20190,16 @@ InlineTableContext.prototype.accept = function(visitor) { -SqlBaseParser.InlineTableContext = InlineTableContext; +SparkSqlParser.InlineTableContext = InlineTableContext; -SqlBaseParser.prototype.inlineTable = function() { +SparkSqlParser.prototype.inlineTable = function() { var localctx = new InlineTableContext(this, this._ctx, this.state); - this.enterRule(localctx, 162, SqlBaseParser.RULE_inlineTable); + this.enterRule(localctx, 162, SparkSqlParser.RULE_inlineTable); try { this.enterOuterAlt(localctx, 1); this.state = 2175; - this.match(SqlBaseParser.VALUES); + this.match(SparkSqlParser.VALUES); this.state = 2176; this.expression(); this.state = 2181; @@ -20208,7 +20208,7 @@ SqlBaseParser.prototype.inlineTable = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2177; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2178; this.expression(); } @@ -20243,7 +20243,7 @@ function FunctionTableContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_functionTable; + this.ruleIndex = SparkSqlParser.RULE_functionTable; this.funcName = null; // ErrorCapturingIdentifierContext return this; } @@ -20271,19 +20271,19 @@ FunctionTableContext.prototype.expression = function(i) { }; FunctionTableContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFunctionTable(this); } }; FunctionTableContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFunctionTable(this); } }; FunctionTableContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFunctionTable(this); } else { return visitor.visitChildren(this); @@ -20293,19 +20293,19 @@ FunctionTableContext.prototype.accept = function(visitor) { -SqlBaseParser.FunctionTableContext = FunctionTableContext; +SparkSqlParser.FunctionTableContext = FunctionTableContext; -SqlBaseParser.prototype.functionTable = function() { +SparkSqlParser.prototype.functionTable = function() { var localctx = new FunctionTableContext(this, this._ctx, this.state); - this.enterRule(localctx, 164, SqlBaseParser.RULE_functionTable); + this.enterRule(localctx, 164, SparkSqlParser.RULE_functionTable); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2186; localctx.funcName = this.errorCapturingIdentifier(); this.state = 2187; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2196; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,273,this._ctx); @@ -20315,9 +20315,9 @@ SqlBaseParser.prototype.functionTable = function() { this.state = 2193; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2189; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2190; this.expression(); this.state = 2195; @@ -20327,7 +20327,7 @@ SqlBaseParser.prototype.functionTable = function() { } this.state = 2198; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 2199; this.tableAlias(); } catch (re) { @@ -20354,7 +20354,7 @@ function TableAliasContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_tableAlias; + this.ruleIndex = SparkSqlParser.RULE_tableAlias; return this; } @@ -20366,7 +20366,7 @@ TableAliasContext.prototype.strictIdentifier = function() { }; TableAliasContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; TableAliasContext.prototype.identifierList = function() { @@ -20374,19 +20374,19 @@ TableAliasContext.prototype.identifierList = function() { }; TableAliasContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTableAlias(this); } }; TableAliasContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTableAlias(this); } }; TableAliasContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTableAlias(this); } else { return visitor.visitChildren(this); @@ -20396,12 +20396,12 @@ TableAliasContext.prototype.accept = function(visitor) { -SqlBaseParser.TableAliasContext = TableAliasContext; +SparkSqlParser.TableAliasContext = TableAliasContext; -SqlBaseParser.prototype.tableAlias = function() { +SparkSqlParser.prototype.tableAlias = function() { var localctx = new TableAliasContext(this, this._ctx, this.state); - this.enterRule(localctx, 166, SqlBaseParser.RULE_tableAlias); + this.enterRule(localctx, 166, SparkSqlParser.RULE_tableAlias); try { this.enterOuterAlt(localctx, 1); this.state = 2208; @@ -20413,7 +20413,7 @@ SqlBaseParser.prototype.tableAlias = function() { var la_ = this._interp.adaptivePredict(this._input,274,this._ctx); if(la_===1) { this.state = 2201; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 2204; @@ -20452,7 +20452,7 @@ function RowFormatContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_rowFormat; + this.ruleIndex = SparkSqlParser.RULE_rowFormat; return this; } @@ -20477,49 +20477,49 @@ function RowFormatSerdeContext(parser, ctx) { RowFormatSerdeContext.prototype = Object.create(RowFormatContext.prototype); RowFormatSerdeContext.prototype.constructor = RowFormatSerdeContext; -SqlBaseParser.RowFormatSerdeContext = RowFormatSerdeContext; +SparkSqlParser.RowFormatSerdeContext = RowFormatSerdeContext; RowFormatSerdeContext.prototype.ROW = function() { - return this.getToken(SqlBaseParser.ROW, 0); + return this.getToken(SparkSqlParser.ROW, 0); }; RowFormatSerdeContext.prototype.FORMAT = function() { - return this.getToken(SqlBaseParser.FORMAT, 0); + return this.getToken(SparkSqlParser.FORMAT, 0); }; RowFormatSerdeContext.prototype.SERDE = function() { - return this.getToken(SqlBaseParser.SERDE, 0); + return this.getToken(SparkSqlParser.SERDE, 0); }; RowFormatSerdeContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; RowFormatSerdeContext.prototype.WITH = function() { - return this.getToken(SqlBaseParser.WITH, 0); + return this.getToken(SparkSqlParser.WITH, 0); }; RowFormatSerdeContext.prototype.SERDEPROPERTIES = function() { - return this.getToken(SqlBaseParser.SERDEPROPERTIES, 0); + return this.getToken(SparkSqlParser.SERDEPROPERTIES, 0); }; RowFormatSerdeContext.prototype.tablePropertyList = function() { return this.getTypedRuleContext(TablePropertyListContext,0); }; RowFormatSerdeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRowFormatSerde(this); } }; RowFormatSerdeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRowFormatSerde(this); } }; RowFormatSerdeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRowFormatSerde(this); } else { return visitor.visitChildren(this); @@ -20542,22 +20542,22 @@ function RowFormatDelimitedContext(parser, ctx) { RowFormatDelimitedContext.prototype = Object.create(RowFormatContext.prototype); RowFormatDelimitedContext.prototype.constructor = RowFormatDelimitedContext; -SqlBaseParser.RowFormatDelimitedContext = RowFormatDelimitedContext; +SparkSqlParser.RowFormatDelimitedContext = RowFormatDelimitedContext; RowFormatDelimitedContext.prototype.ROW = function() { - return this.getToken(SqlBaseParser.ROW, 0); + return this.getToken(SparkSqlParser.ROW, 0); }; RowFormatDelimitedContext.prototype.FORMAT = function() { - return this.getToken(SqlBaseParser.FORMAT, 0); + return this.getToken(SparkSqlParser.FORMAT, 0); }; RowFormatDelimitedContext.prototype.DELIMITED = function() { - return this.getToken(SqlBaseParser.DELIMITED, 0); + return this.getToken(SparkSqlParser.DELIMITED, 0); }; RowFormatDelimitedContext.prototype.FIELDS = function() { - return this.getToken(SqlBaseParser.FIELDS, 0); + return this.getToken(SparkSqlParser.FIELDS, 0); }; RowFormatDelimitedContext.prototype.TERMINATED = function(i) { @@ -20565,9 +20565,9 @@ RowFormatDelimitedContext.prototype.TERMINATED = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.TERMINATED); + return this.getTokens(SparkSqlParser.TERMINATED); } else { - return this.getToken(SqlBaseParser.TERMINATED, i); + return this.getToken(SparkSqlParser.TERMINATED, i); } }; @@ -20577,43 +20577,43 @@ RowFormatDelimitedContext.prototype.BY = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.BY); + return this.getTokens(SparkSqlParser.BY); } else { - return this.getToken(SqlBaseParser.BY, i); + return this.getToken(SparkSqlParser.BY, i); } }; RowFormatDelimitedContext.prototype.COLLECTION = function() { - return this.getToken(SqlBaseParser.COLLECTION, 0); + return this.getToken(SparkSqlParser.COLLECTION, 0); }; RowFormatDelimitedContext.prototype.ITEMS = function() { - return this.getToken(SqlBaseParser.ITEMS, 0); + return this.getToken(SparkSqlParser.ITEMS, 0); }; RowFormatDelimitedContext.prototype.MAP = function() { - return this.getToken(SqlBaseParser.MAP, 0); + return this.getToken(SparkSqlParser.MAP, 0); }; RowFormatDelimitedContext.prototype.KEYS = function() { - return this.getToken(SqlBaseParser.KEYS, 0); + return this.getToken(SparkSqlParser.KEYS, 0); }; RowFormatDelimitedContext.prototype.LINES = function() { - return this.getToken(SqlBaseParser.LINES, 0); + return this.getToken(SparkSqlParser.LINES, 0); }; RowFormatDelimitedContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; RowFormatDelimitedContext.prototype.DEFINED = function() { - return this.getToken(SqlBaseParser.DEFINED, 0); + return this.getToken(SparkSqlParser.DEFINED, 0); }; RowFormatDelimitedContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; RowFormatDelimitedContext.prototype.STRING = function(i) { @@ -20621,30 +20621,30 @@ RowFormatDelimitedContext.prototype.STRING = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.STRING); + return this.getTokens(SparkSqlParser.STRING); } else { - return this.getToken(SqlBaseParser.STRING, i); + return this.getToken(SparkSqlParser.STRING, i); } }; RowFormatDelimitedContext.prototype.ESCAPED = function() { - return this.getToken(SqlBaseParser.ESCAPED, 0); + return this.getToken(SparkSqlParser.ESCAPED, 0); }; RowFormatDelimitedContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRowFormatDelimited(this); } }; RowFormatDelimitedContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRowFormatDelimited(this); } }; RowFormatDelimitedContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRowFormatDelimited(this); } else { return visitor.visitChildren(this); @@ -20653,12 +20653,12 @@ RowFormatDelimitedContext.prototype.accept = function(visitor) { -SqlBaseParser.RowFormatContext = RowFormatContext; +SparkSqlParser.RowFormatContext = RowFormatContext; -SqlBaseParser.prototype.rowFormat = function() { +SparkSqlParser.prototype.rowFormat = function() { var localctx = new RowFormatContext(this, this._ctx, this.state); - this.enterRule(localctx, 168, SqlBaseParser.RULE_rowFormat); + this.enterRule(localctx, 168, SparkSqlParser.RULE_rowFormat); try { this.state = 2259; this._errHandler.sync(this); @@ -20668,21 +20668,21 @@ SqlBaseParser.prototype.rowFormat = function() { localctx = new RowFormatSerdeContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 2210; - this.match(SqlBaseParser.ROW); + this.match(SparkSqlParser.ROW); this.state = 2211; - this.match(SqlBaseParser.FORMAT); + this.match(SparkSqlParser.FORMAT); this.state = 2212; - this.match(SqlBaseParser.SERDE); + this.match(SparkSqlParser.SERDE); this.state = 2213; - localctx.name = this.match(SqlBaseParser.STRING); + localctx.name = this.match(SparkSqlParser.STRING); this.state = 2217; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,277,this._ctx); if(la_===1) { this.state = 2214; - this.match(SqlBaseParser.WITH); + this.match(SparkSqlParser.WITH); this.state = 2215; - this.match(SqlBaseParser.SERDEPROPERTIES); + this.match(SparkSqlParser.SERDEPROPERTIES); this.state = 2216; localctx.props = this.tablePropertyList(); @@ -20693,33 +20693,33 @@ SqlBaseParser.prototype.rowFormat = function() { localctx = new RowFormatDelimitedContext(this, localctx); this.enterOuterAlt(localctx, 2); this.state = 2219; - this.match(SqlBaseParser.ROW); + this.match(SparkSqlParser.ROW); this.state = 2220; - this.match(SqlBaseParser.FORMAT); + this.match(SparkSqlParser.FORMAT); this.state = 2221; - this.match(SqlBaseParser.DELIMITED); + this.match(SparkSqlParser.DELIMITED); this.state = 2231; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,279,this._ctx); if(la_===1) { this.state = 2222; - this.match(SqlBaseParser.FIELDS); + this.match(SparkSqlParser.FIELDS); this.state = 2223; - this.match(SqlBaseParser.TERMINATED); + this.match(SparkSqlParser.TERMINATED); this.state = 2224; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2225; - localctx.fieldsTerminatedBy = this.match(SqlBaseParser.STRING); + localctx.fieldsTerminatedBy = this.match(SparkSqlParser.STRING); this.state = 2229; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,278,this._ctx); if(la_===1) { this.state = 2226; - this.match(SqlBaseParser.ESCAPED); + this.match(SparkSqlParser.ESCAPED); this.state = 2227; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2228; - localctx.escapedBy = this.match(SqlBaseParser.STRING); + localctx.escapedBy = this.match(SparkSqlParser.STRING); } @@ -20729,15 +20729,15 @@ SqlBaseParser.prototype.rowFormat = function() { var la_ = this._interp.adaptivePredict(this._input,280,this._ctx); if(la_===1) { this.state = 2233; - this.match(SqlBaseParser.COLLECTION); + this.match(SparkSqlParser.COLLECTION); this.state = 2234; - this.match(SqlBaseParser.ITEMS); + this.match(SparkSqlParser.ITEMS); this.state = 2235; - this.match(SqlBaseParser.TERMINATED); + this.match(SparkSqlParser.TERMINATED); this.state = 2236; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2237; - localctx.collectionItemsTerminatedBy = this.match(SqlBaseParser.STRING); + localctx.collectionItemsTerminatedBy = this.match(SparkSqlParser.STRING); } this.state = 2245; @@ -20745,15 +20745,15 @@ SqlBaseParser.prototype.rowFormat = function() { var la_ = this._interp.adaptivePredict(this._input,281,this._ctx); if(la_===1) { this.state = 2240; - this.match(SqlBaseParser.MAP); + this.match(SparkSqlParser.MAP); this.state = 2241; - this.match(SqlBaseParser.KEYS); + this.match(SparkSqlParser.KEYS); this.state = 2242; - this.match(SqlBaseParser.TERMINATED); + this.match(SparkSqlParser.TERMINATED); this.state = 2243; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2244; - localctx.keysTerminatedBy = this.match(SqlBaseParser.STRING); + localctx.keysTerminatedBy = this.match(SparkSqlParser.STRING); } this.state = 2251; @@ -20761,13 +20761,13 @@ SqlBaseParser.prototype.rowFormat = function() { var la_ = this._interp.adaptivePredict(this._input,282,this._ctx); if(la_===1) { this.state = 2247; - this.match(SqlBaseParser.LINES); + this.match(SparkSqlParser.LINES); this.state = 2248; - this.match(SqlBaseParser.TERMINATED); + this.match(SparkSqlParser.TERMINATED); this.state = 2249; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2250; - localctx.linesSeparatedBy = this.match(SqlBaseParser.STRING); + localctx.linesSeparatedBy = this.match(SparkSqlParser.STRING); } this.state = 2257; @@ -20775,13 +20775,13 @@ SqlBaseParser.prototype.rowFormat = function() { var la_ = this._interp.adaptivePredict(this._input,283,this._ctx); if(la_===1) { this.state = 2253; - this.match(SqlBaseParser.NULL); + this.match(SparkSqlParser.NULL); this.state = 2254; - this.match(SqlBaseParser.DEFINED); + this.match(SparkSqlParser.DEFINED); this.state = 2255; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 2256; - localctx.nullDefinedAs = this.match(SqlBaseParser.STRING); + localctx.nullDefinedAs = this.match(SparkSqlParser.STRING); } break; @@ -20811,7 +20811,7 @@ function MultipartIdentifierListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_multipartIdentifierList; + this.ruleIndex = SparkSqlParser.RULE_multipartIdentifierList; return this; } @@ -20830,19 +20830,19 @@ MultipartIdentifierListContext.prototype.multipartIdentifier = function(i) { }; MultipartIdentifierListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMultipartIdentifierList(this); } }; MultipartIdentifierListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMultipartIdentifierList(this); } }; MultipartIdentifierListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMultipartIdentifierList(this); } else { return visitor.visitChildren(this); @@ -20852,12 +20852,12 @@ MultipartIdentifierListContext.prototype.accept = function(visitor) { -SqlBaseParser.MultipartIdentifierListContext = MultipartIdentifierListContext; +SparkSqlParser.MultipartIdentifierListContext = MultipartIdentifierListContext; -SqlBaseParser.prototype.multipartIdentifierList = function() { +SparkSqlParser.prototype.multipartIdentifierList = function() { var localctx = new MultipartIdentifierListContext(this, this._ctx, this.state); - this.enterRule(localctx, 170, SqlBaseParser.RULE_multipartIdentifierList); + this.enterRule(localctx, 170, SparkSqlParser.RULE_multipartIdentifierList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -20866,9 +20866,9 @@ SqlBaseParser.prototype.multipartIdentifierList = function() { this.state = 2266; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2262; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2263; this.multipartIdentifier(); this.state = 2268; @@ -20899,7 +20899,7 @@ function MultipartIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_multipartIdentifier; + this.ruleIndex = SparkSqlParser.RULE_multipartIdentifier; this._errorCapturingIdentifier = null; // ErrorCapturingIdentifierContext this.parts = []; // of ErrorCapturingIdentifierContexts return this; @@ -20920,19 +20920,19 @@ MultipartIdentifierContext.prototype.errorCapturingIdentifier = function(i) { }; MultipartIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMultipartIdentifier(this); } }; MultipartIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMultipartIdentifier(this); } }; MultipartIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMultipartIdentifier(this); } else { return visitor.visitChildren(this); @@ -20942,12 +20942,12 @@ MultipartIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.MultipartIdentifierContext = MultipartIdentifierContext; +SparkSqlParser.MultipartIdentifierContext = MultipartIdentifierContext; -SqlBaseParser.prototype.multipartIdentifier = function() { +SparkSqlParser.prototype.multipartIdentifier = function() { var localctx = new MultipartIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 172, SqlBaseParser.RULE_multipartIdentifier); + this.enterRule(localctx, 172, SparkSqlParser.RULE_multipartIdentifier); try { this.enterOuterAlt(localctx, 1); this.state = 2269; @@ -20959,7 +20959,7 @@ SqlBaseParser.prototype.multipartIdentifier = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2270; - this.match(SqlBaseParser.T__4); + this.match(SparkSqlParser.T__4); this.state = 2271; localctx._errorCapturingIdentifier = this.errorCapturingIdentifier(); localctx.parts.push(localctx._errorCapturingIdentifier); @@ -20993,7 +20993,7 @@ function TableIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_tableIdentifier; + this.ruleIndex = SparkSqlParser.RULE_tableIdentifier; this.db = null; // ErrorCapturingIdentifierContext this.table = null; // ErrorCapturingIdentifierContext return this; @@ -21014,19 +21014,19 @@ TableIdentifierContext.prototype.errorCapturingIdentifier = function(i) { }; TableIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTableIdentifier(this); } }; TableIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTableIdentifier(this); } }; TableIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTableIdentifier(this); } else { return visitor.visitChildren(this); @@ -21036,12 +21036,12 @@ TableIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.TableIdentifierContext = TableIdentifierContext; +SparkSqlParser.TableIdentifierContext = TableIdentifierContext; -SqlBaseParser.prototype.tableIdentifier = function() { +SparkSqlParser.prototype.tableIdentifier = function() { var localctx = new TableIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 174, SqlBaseParser.RULE_tableIdentifier); + this.enterRule(localctx, 174, SparkSqlParser.RULE_tableIdentifier); try { this.enterOuterAlt(localctx, 1); this.state = 2280; @@ -21051,7 +21051,7 @@ SqlBaseParser.prototype.tableIdentifier = function() { this.state = 2277; localctx.db = this.errorCapturingIdentifier(); this.state = 2278; - this.match(SqlBaseParser.T__4); + this.match(SparkSqlParser.T__4); } this.state = 2282; @@ -21080,7 +21080,7 @@ function NamedExpressionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_namedExpression; + this.ruleIndex = SparkSqlParser.RULE_namedExpression; this.name = null; // ErrorCapturingIdentifierContext return this; } @@ -21097,7 +21097,7 @@ NamedExpressionContext.prototype.identifierList = function() { }; NamedExpressionContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; NamedExpressionContext.prototype.errorCapturingIdentifier = function() { @@ -21105,19 +21105,19 @@ NamedExpressionContext.prototype.errorCapturingIdentifier = function() { }; NamedExpressionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNamedExpression(this); } }; NamedExpressionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNamedExpression(this); } }; NamedExpressionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNamedExpression(this); } else { return visitor.visitChildren(this); @@ -21127,12 +21127,12 @@ NamedExpressionContext.prototype.accept = function(visitor) { -SqlBaseParser.NamedExpressionContext = NamedExpressionContext; +SparkSqlParser.NamedExpressionContext = NamedExpressionContext; -SqlBaseParser.prototype.namedExpression = function() { +SparkSqlParser.prototype.namedExpression = function() { var localctx = new NamedExpressionContext(this, this._ctx, this.state); - this.enterRule(localctx, 176, SqlBaseParser.RULE_namedExpression); + this.enterRule(localctx, 176, SparkSqlParser.RULE_namedExpression); try { this.enterOuterAlt(localctx, 1); this.state = 2284; @@ -21146,7 +21146,7 @@ SqlBaseParser.prototype.namedExpression = function() { var la_ = this._interp.adaptivePredict(this._input,288,this._ctx); if(la_===1) { this.state = 2285; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); } this.state = 2290; @@ -21190,7 +21190,7 @@ function NamedExpressionSeqContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_namedExpressionSeq; + this.ruleIndex = SparkSqlParser.RULE_namedExpressionSeq; return this; } @@ -21209,19 +21209,19 @@ NamedExpressionSeqContext.prototype.namedExpression = function(i) { }; NamedExpressionSeqContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNamedExpressionSeq(this); } }; NamedExpressionSeqContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNamedExpressionSeq(this); } }; NamedExpressionSeqContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNamedExpressionSeq(this); } else { return visitor.visitChildren(this); @@ -21231,12 +21231,12 @@ NamedExpressionSeqContext.prototype.accept = function(visitor) { -SqlBaseParser.NamedExpressionSeqContext = NamedExpressionSeqContext; +SparkSqlParser.NamedExpressionSeqContext = NamedExpressionSeqContext; -SqlBaseParser.prototype.namedExpressionSeq = function() { +SparkSqlParser.prototype.namedExpressionSeq = function() { var localctx = new NamedExpressionSeqContext(this, this._ctx, this.state); - this.enterRule(localctx, 178, SqlBaseParser.RULE_namedExpressionSeq); + this.enterRule(localctx, 178, SparkSqlParser.RULE_namedExpressionSeq); try { this.enterOuterAlt(localctx, 1); this.state = 2294; @@ -21247,7 +21247,7 @@ SqlBaseParser.prototype.namedExpressionSeq = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2295; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2296; this.namedExpression(); } @@ -21280,7 +21280,7 @@ function TransformListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_transformList; + this.ruleIndex = SparkSqlParser.RULE_transformList; this._transform = null; // TransformContext this.transforms = []; // of TransformContexts return this; @@ -21301,19 +21301,19 @@ TransformListContext.prototype.transform = function(i) { }; TransformListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTransformList(this); } }; TransformListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTransformList(this); } }; TransformListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTransformList(this); } else { return visitor.visitChildren(this); @@ -21323,26 +21323,26 @@ TransformListContext.prototype.accept = function(visitor) { -SqlBaseParser.TransformListContext = TransformListContext; +SparkSqlParser.TransformListContext = TransformListContext; -SqlBaseParser.prototype.transformList = function() { +SparkSqlParser.prototype.transformList = function() { var localctx = new TransformListContext(this, this._ctx, this.state); - this.enterRule(localctx, 180, SqlBaseParser.RULE_transformList); + this.enterRule(localctx, 180, SparkSqlParser.RULE_transformList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2302; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2303; localctx._transform = this.transform(); localctx.transforms.push(localctx._transform); this.state = 2308; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2304; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2305; localctx._transform = this.transform(); localctx.transforms.push(localctx._transform); @@ -21351,7 +21351,7 @@ SqlBaseParser.prototype.transformList = function() { _la = this._input.LA(1); } this.state = 2311; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -21376,7 +21376,7 @@ function TransformContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_transform; + this.ruleIndex = SparkSqlParser.RULE_transform; return this; } @@ -21399,25 +21399,25 @@ function IdentityTransformContext(parser, ctx) { IdentityTransformContext.prototype = Object.create(TransformContext.prototype); IdentityTransformContext.prototype.constructor = IdentityTransformContext; -SqlBaseParser.IdentityTransformContext = IdentityTransformContext; +SparkSqlParser.IdentityTransformContext = IdentityTransformContext; IdentityTransformContext.prototype.qualifiedName = function() { return this.getTypedRuleContext(QualifiedNameContext,0); }; IdentityTransformContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIdentityTransform(this); } }; IdentityTransformContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIdentityTransform(this); } }; IdentityTransformContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIdentityTransform(this); } else { return visitor.visitChildren(this); @@ -21437,7 +21437,7 @@ function ApplyTransformContext(parser, ctx) { ApplyTransformContext.prototype = Object.create(TransformContext.prototype); ApplyTransformContext.prototype.constructor = ApplyTransformContext; -SqlBaseParser.ApplyTransformContext = ApplyTransformContext; +SparkSqlParser.ApplyTransformContext = ApplyTransformContext; ApplyTransformContext.prototype.identifier = function() { return this.getTypedRuleContext(IdentifierContext,0); @@ -21454,19 +21454,19 @@ ApplyTransformContext.prototype.transformArgument = function(i) { } }; ApplyTransformContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterApplyTransform(this); } }; ApplyTransformContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitApplyTransform(this); } }; ApplyTransformContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitApplyTransform(this); } else { return visitor.visitChildren(this); @@ -21475,12 +21475,12 @@ ApplyTransformContext.prototype.accept = function(visitor) { -SqlBaseParser.TransformContext = TransformContext; +SparkSqlParser.TransformContext = TransformContext; -SqlBaseParser.prototype.transform = function() { +SparkSqlParser.prototype.transform = function() { var localctx = new TransformContext(this, this._ctx, this.state); - this.enterRule(localctx, 182, SqlBaseParser.RULE_transform); + this.enterRule(localctx, 182, SparkSqlParser.RULE_transform); var _la = 0; // Token type try { this.state = 2326; @@ -21500,16 +21500,16 @@ SqlBaseParser.prototype.transform = function() { this.state = 2314; localctx.transformName = this.identifier(); this.state = 2315; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2316; localctx._transformArgument = this.transformArgument(); localctx.argument.push(localctx._transformArgument); this.state = 2321; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2317; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2318; localctx._transformArgument = this.transformArgument(); localctx.argument.push(localctx._transformArgument); @@ -21518,7 +21518,7 @@ SqlBaseParser.prototype.transform = function() { _la = this._input.LA(1); } this.state = 2324; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -21546,7 +21546,7 @@ function TransformArgumentContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_transformArgument; + this.ruleIndex = SparkSqlParser.RULE_transformArgument; return this; } @@ -21562,19 +21562,19 @@ TransformArgumentContext.prototype.constant = function() { }; TransformArgumentContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTransformArgument(this); } }; TransformArgumentContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTransformArgument(this); } }; TransformArgumentContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTransformArgument(this); } else { return visitor.visitChildren(this); @@ -21584,12 +21584,12 @@ TransformArgumentContext.prototype.accept = function(visitor) { -SqlBaseParser.TransformArgumentContext = TransformArgumentContext; +SparkSqlParser.TransformArgumentContext = TransformArgumentContext; -SqlBaseParser.prototype.transformArgument = function() { +SparkSqlParser.prototype.transformArgument = function() { var localctx = new TransformArgumentContext(this, this._ctx, this.state); - this.enterRule(localctx, 184, SqlBaseParser.RULE_transformArgument); + this.enterRule(localctx, 184, SparkSqlParser.RULE_transformArgument); try { this.state = 2330; this._errHandler.sync(this); @@ -21632,7 +21632,7 @@ function ExpressionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_expression; + this.ruleIndex = SparkSqlParser.RULE_expression; return this; } @@ -21644,19 +21644,19 @@ ExpressionContext.prototype.booleanExpression = function() { }; ExpressionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterExpression(this); } }; ExpressionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitExpression(this); } }; ExpressionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitExpression(this); } else { return visitor.visitChildren(this); @@ -21666,12 +21666,12 @@ ExpressionContext.prototype.accept = function(visitor) { -SqlBaseParser.ExpressionContext = ExpressionContext; +SparkSqlParser.ExpressionContext = ExpressionContext; -SqlBaseParser.prototype.expression = function() { +SparkSqlParser.prototype.expression = function() { var localctx = new ExpressionContext(this, this._ctx, this.state); - this.enterRule(localctx, 186, SqlBaseParser.RULE_expression); + this.enterRule(localctx, 186, SparkSqlParser.RULE_expression); try { this.enterOuterAlt(localctx, 1); this.state = 2332; @@ -21700,7 +21700,7 @@ function BooleanExpressionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_booleanExpression; + this.ruleIndex = SparkSqlParser.RULE_booleanExpression; return this; } @@ -21722,29 +21722,29 @@ function LogicalNotContext(parser, ctx) { LogicalNotContext.prototype = Object.create(BooleanExpressionContext.prototype); LogicalNotContext.prototype.constructor = LogicalNotContext; -SqlBaseParser.LogicalNotContext = LogicalNotContext; +SparkSqlParser.LogicalNotContext = LogicalNotContext; LogicalNotContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; LogicalNotContext.prototype.booleanExpression = function() { return this.getTypedRuleContext(BooleanExpressionContext,0); }; LogicalNotContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLogicalNot(this); } }; LogicalNotContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLogicalNot(this); } }; LogicalNotContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLogicalNot(this); } else { return visitor.visitChildren(this); @@ -21761,7 +21761,7 @@ function PredicatedContext(parser, ctx) { PredicatedContext.prototype = Object.create(BooleanExpressionContext.prototype); PredicatedContext.prototype.constructor = PredicatedContext; -SqlBaseParser.PredicatedContext = PredicatedContext; +SparkSqlParser.PredicatedContext = PredicatedContext; PredicatedContext.prototype.valueExpression = function() { return this.getTypedRuleContext(ValueExpressionContext,0); @@ -21771,19 +21771,19 @@ PredicatedContext.prototype.predicate = function() { return this.getTypedRuleContext(PredicateContext,0); }; PredicatedContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPredicated(this); } }; PredicatedContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPredicated(this); } }; PredicatedContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPredicated(this); } else { return visitor.visitChildren(this); @@ -21800,29 +21800,29 @@ function ExistsContext(parser, ctx) { ExistsContext.prototype = Object.create(BooleanExpressionContext.prototype); ExistsContext.prototype.constructor = ExistsContext; -SqlBaseParser.ExistsContext = ExistsContext; +SparkSqlParser.ExistsContext = ExistsContext; ExistsContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; ExistsContext.prototype.query = function() { return this.getTypedRuleContext(QueryContext,0); }; ExistsContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterExists(this); } }; ExistsContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitExists(this); } }; ExistsContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitExists(this); } else { return visitor.visitChildren(this); @@ -21842,7 +21842,7 @@ function LogicalBinaryContext(parser, ctx) { LogicalBinaryContext.prototype = Object.create(BooleanExpressionContext.prototype); LogicalBinaryContext.prototype.constructor = LogicalBinaryContext; -SqlBaseParser.LogicalBinaryContext = LogicalBinaryContext; +SparkSqlParser.LogicalBinaryContext = LogicalBinaryContext; LogicalBinaryContext.prototype.booleanExpression = function(i) { if(i===undefined) { @@ -21856,26 +21856,26 @@ LogicalBinaryContext.prototype.booleanExpression = function(i) { }; LogicalBinaryContext.prototype.AND = function() { - return this.getToken(SqlBaseParser.AND, 0); + return this.getToken(SparkSqlParser.AND, 0); }; LogicalBinaryContext.prototype.OR = function() { - return this.getToken(SqlBaseParser.OR, 0); + return this.getToken(SparkSqlParser.OR, 0); }; LogicalBinaryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLogicalBinary(this); } }; LogicalBinaryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLogicalBinary(this); } }; LogicalBinaryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLogicalBinary(this); } else { return visitor.visitChildren(this); @@ -21884,7 +21884,7 @@ LogicalBinaryContext.prototype.accept = function(visitor) { -SqlBaseParser.prototype.booleanExpression = function(_p) { +SparkSqlParser.prototype.booleanExpression = function(_p) { if(_p===undefined) { _p = 0; } @@ -21893,7 +21893,7 @@ SqlBaseParser.prototype.booleanExpression = function(_p) { var localctx = new BooleanExpressionContext(this, this._ctx, _parentState); var _prevctx = localctx; var _startState = 188; - this.enterRecursionRule(localctx, 188, SqlBaseParser.RULE_booleanExpression, _p); + this.enterRecursionRule(localctx, 188, SparkSqlParser.RULE_booleanExpression, _p); try { this.enterOuterAlt(localctx, 1); this.state = 2346; @@ -21906,7 +21906,7 @@ SqlBaseParser.prototype.booleanExpression = function(_p) { _prevctx = localctx; this.state = 2335; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 2336; this.booleanExpression(5); break; @@ -21916,13 +21916,13 @@ SqlBaseParser.prototype.booleanExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2337; - this.match(SqlBaseParser.EXISTS); + this.match(SparkSqlParser.EXISTS); this.state = 2338; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2339; this.query(); this.state = 2340; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 3: @@ -21959,13 +21959,13 @@ SqlBaseParser.prototype.booleanExpression = function(_p) { case 1: localctx = new LogicalBinaryContext(this, new BooleanExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_booleanExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_booleanExpression); this.state = 2348; if (!( this.precpred(this._ctx, 2))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)"); } this.state = 2349; - localctx.operator = this.match(SqlBaseParser.AND); + localctx.operator = this.match(SparkSqlParser.AND); this.state = 2350; localctx.right = this.booleanExpression(3); break; @@ -21973,13 +21973,13 @@ SqlBaseParser.prototype.booleanExpression = function(_p) { case 2: localctx = new LogicalBinaryContext(this, new BooleanExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_booleanExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_booleanExpression); this.state = 2351; if (!( this.precpred(this._ctx, 1))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)"); } this.state = 2352; - localctx.operator = this.match(SqlBaseParser.OR); + localctx.operator = this.match(SparkSqlParser.OR); this.state = 2353; localctx.right = this.booleanExpression(2); break; @@ -22015,7 +22015,7 @@ function PredicateContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_predicate; + this.ruleIndex = SparkSqlParser.RULE_predicate; this.kind = null; // Token this.lower = null; // ValueExpressionContext this.upper = null; // ValueExpressionContext @@ -22030,11 +22030,11 @@ PredicateContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); PredicateContext.prototype.constructor = PredicateContext; PredicateContext.prototype.AND = function() { - return this.getToken(SqlBaseParser.AND, 0); + return this.getToken(SparkSqlParser.AND, 0); }; PredicateContext.prototype.BETWEEN = function() { - return this.getToken(SqlBaseParser.BETWEEN, 0); + return this.getToken(SparkSqlParser.BETWEEN, 0); }; PredicateContext.prototype.valueExpression = function(i) { @@ -22049,7 +22049,7 @@ PredicateContext.prototype.valueExpression = function(i) { }; PredicateContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; PredicateContext.prototype.expression = function(i) { @@ -22064,7 +22064,7 @@ PredicateContext.prototype.expression = function(i) { }; PredicateContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; PredicateContext.prototype.query = function() { @@ -22072,75 +22072,75 @@ PredicateContext.prototype.query = function() { }; PredicateContext.prototype.RLIKE = function() { - return this.getToken(SqlBaseParser.RLIKE, 0); + return this.getToken(SparkSqlParser.RLIKE, 0); }; PredicateContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; PredicateContext.prototype.ANY = function() { - return this.getToken(SqlBaseParser.ANY, 0); + return this.getToken(SparkSqlParser.ANY, 0); }; PredicateContext.prototype.SOME = function() { - return this.getToken(SqlBaseParser.SOME, 0); + return this.getToken(SparkSqlParser.SOME, 0); }; PredicateContext.prototype.ALL = function() { - return this.getToken(SqlBaseParser.ALL, 0); + return this.getToken(SparkSqlParser.ALL, 0); }; PredicateContext.prototype.ESCAPE = function() { - return this.getToken(SqlBaseParser.ESCAPE, 0); + return this.getToken(SparkSqlParser.ESCAPE, 0); }; PredicateContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; PredicateContext.prototype.IS = function() { - return this.getToken(SqlBaseParser.IS, 0); + return this.getToken(SparkSqlParser.IS, 0); }; PredicateContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; PredicateContext.prototype.TRUE = function() { - return this.getToken(SqlBaseParser.TRUE, 0); + return this.getToken(SparkSqlParser.TRUE, 0); }; PredicateContext.prototype.FALSE = function() { - return this.getToken(SqlBaseParser.FALSE, 0); + return this.getToken(SparkSqlParser.FALSE, 0); }; PredicateContext.prototype.UNKNOWN = function() { - return this.getToken(SqlBaseParser.UNKNOWN, 0); + return this.getToken(SparkSqlParser.UNKNOWN, 0); }; PredicateContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; PredicateContext.prototype.DISTINCT = function() { - return this.getToken(SqlBaseParser.DISTINCT, 0); + return this.getToken(SparkSqlParser.DISTINCT, 0); }; PredicateContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPredicate(this); } }; PredicateContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPredicate(this); } }; PredicateContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPredicate(this); } else { return visitor.visitChildren(this); @@ -22150,12 +22150,12 @@ PredicateContext.prototype.accept = function(visitor) { -SqlBaseParser.PredicateContext = PredicateContext; +SparkSqlParser.PredicateContext = PredicateContext; -SqlBaseParser.prototype.predicate = function() { +SparkSqlParser.prototype.predicate = function() { var localctx = new PredicateContext(this, this._ctx, this.state); - this.enterRule(localctx, 190, SqlBaseParser.RULE_predicate); + this.enterRule(localctx, 190, SparkSqlParser.RULE_predicate); var _la = 0; // Token type try { this.state = 2441; @@ -22167,17 +22167,17 @@ SqlBaseParser.prototype.predicate = function() { this.state = 2360; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2359; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2362; - localctx.kind = this.match(SqlBaseParser.BETWEEN); + localctx.kind = this.match(SparkSqlParser.BETWEEN); this.state = 2363; localctx.lower = this.valueExpression(0); this.state = 2364; - this.match(SqlBaseParser.AND); + this.match(SparkSqlParser.AND); this.state = 2365; localctx.upper = this.valueExpression(0); break; @@ -22187,23 +22187,23 @@ SqlBaseParser.prototype.predicate = function() { this.state = 2368; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2367; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2370; - localctx.kind = this.match(SqlBaseParser.IN); + localctx.kind = this.match(SparkSqlParser.IN); this.state = 2371; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2372; this.expression(); this.state = 2377; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2373; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2374; this.expression(); this.state = 2379; @@ -22211,7 +22211,7 @@ SqlBaseParser.prototype.predicate = function() { _la = this._input.LA(1); } this.state = 2380; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 3: @@ -22219,19 +22219,19 @@ SqlBaseParser.prototype.predicate = function() { this.state = 2383; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2382; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2385; - localctx.kind = this.match(SqlBaseParser.IN); + localctx.kind = this.match(SparkSqlParser.IN); this.state = 2386; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2387; this.query(); this.state = 2388; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 4: @@ -22239,13 +22239,13 @@ SqlBaseParser.prototype.predicate = function() { this.state = 2391; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2390; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2393; - localctx.kind = this.match(SqlBaseParser.RLIKE); + localctx.kind = this.match(SparkSqlParser.RLIKE); this.state = 2394; localctx.pattern = this.valueExpression(0); break; @@ -22255,17 +22255,17 @@ SqlBaseParser.prototype.predicate = function() { this.state = 2396; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2395; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2398; - localctx.kind = this.match(SqlBaseParser.LIKE); + localctx.kind = this.match(SparkSqlParser.LIKE); this.state = 2399; localctx.quantifier = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ALL || _la===SqlBaseParser.ANY || _la===SqlBaseParser.SOME)) { + if(!(_la===SparkSqlParser.ALL || _la===SparkSqlParser.ANY || _la===SparkSqlParser.SOME)) { localctx.quantifier = this._errHandler.recoverInline(this); } else { @@ -22278,22 +22278,22 @@ SqlBaseParser.prototype.predicate = function() { switch(la_) { case 1: this.state = 2400; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2401; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 2: this.state = 2402; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2403; this.expression(); this.state = 2408; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2404; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2405; this.expression(); this.state = 2410; @@ -22301,7 +22301,7 @@ SqlBaseParser.prototype.predicate = function() { _la = this._input.LA(1); } this.state = 2411; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -22312,13 +22312,13 @@ SqlBaseParser.prototype.predicate = function() { this.state = 2416; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2415; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2418; - localctx.kind = this.match(SqlBaseParser.LIKE); + localctx.kind = this.match(SparkSqlParser.LIKE); this.state = 2419; localctx.pattern = this.valueExpression(0); this.state = 2422; @@ -22326,9 +22326,9 @@ SqlBaseParser.prototype.predicate = function() { var la_ = this._interp.adaptivePredict(this._input,309,this._ctx); if(la_===1) { this.state = 2420; - this.match(SqlBaseParser.ESCAPE); + this.match(SparkSqlParser.ESCAPE); this.state = 2421; - localctx.escapeChar = this.match(SqlBaseParser.STRING); + localctx.escapeChar = this.match(SparkSqlParser.STRING); } break; @@ -22336,35 +22336,35 @@ SqlBaseParser.prototype.predicate = function() { case 7: this.enterOuterAlt(localctx, 7); this.state = 2424; - this.match(SqlBaseParser.IS); + this.match(SparkSqlParser.IS); this.state = 2426; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2425; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2428; - localctx.kind = this.match(SqlBaseParser.NULL); + localctx.kind = this.match(SparkSqlParser.NULL); break; case 8: this.enterOuterAlt(localctx, 8); this.state = 2429; - this.match(SqlBaseParser.IS); + this.match(SparkSqlParser.IS); this.state = 2431; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2430; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2433; localctx.kind = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FALSE || _la===SqlBaseParser.TRUE || _la===SqlBaseParser.UNKNOWN)) { + if(!(_la===SparkSqlParser.FALSE || _la===SparkSqlParser.TRUE || _la===SparkSqlParser.UNKNOWN)) { localctx.kind = this._errHandler.recoverInline(this); } else { @@ -22376,19 +22376,19 @@ SqlBaseParser.prototype.predicate = function() { case 9: this.enterOuterAlt(localctx, 9); this.state = 2434; - this.match(SqlBaseParser.IS); + this.match(SparkSqlParser.IS); this.state = 2436; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2435; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); } this.state = 2438; - localctx.kind = this.match(SqlBaseParser.DISTINCT); + localctx.kind = this.match(SparkSqlParser.DISTINCT); this.state = 2439; - this.match(SqlBaseParser.FROM); + this.match(SparkSqlParser.FROM); this.state = 2440; localctx.right = this.valueExpression(0); break; @@ -22418,7 +22418,7 @@ function ValueExpressionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_valueExpression; + this.ruleIndex = SparkSqlParser.RULE_valueExpression; return this; } @@ -22440,25 +22440,25 @@ function ValueExpressionDefaultContext(parser, ctx) { ValueExpressionDefaultContext.prototype = Object.create(ValueExpressionContext.prototype); ValueExpressionDefaultContext.prototype.constructor = ValueExpressionDefaultContext; -SqlBaseParser.ValueExpressionDefaultContext = ValueExpressionDefaultContext; +SparkSqlParser.ValueExpressionDefaultContext = ValueExpressionDefaultContext; ValueExpressionDefaultContext.prototype.primaryExpression = function() { return this.getTypedRuleContext(PrimaryExpressionContext,0); }; ValueExpressionDefaultContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterValueExpressionDefault(this); } }; ValueExpressionDefaultContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitValueExpressionDefault(this); } }; ValueExpressionDefaultContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitValueExpressionDefault(this); } else { return visitor.visitChildren(this); @@ -22477,7 +22477,7 @@ function ComparisonContext(parser, ctx) { ComparisonContext.prototype = Object.create(ValueExpressionContext.prototype); ComparisonContext.prototype.constructor = ComparisonContext; -SqlBaseParser.ComparisonContext = ComparisonContext; +SparkSqlParser.ComparisonContext = ComparisonContext; ComparisonContext.prototype.comparisonOperator = function() { return this.getTypedRuleContext(ComparisonOperatorContext,0); @@ -22494,19 +22494,19 @@ ComparisonContext.prototype.valueExpression = function(i) { } }; ComparisonContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterComparison(this); } }; ComparisonContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitComparison(this); } }; ComparisonContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitComparison(this); } else { return visitor.visitChildren(this); @@ -22526,7 +22526,7 @@ function ArithmeticBinaryContext(parser, ctx) { ArithmeticBinaryContext.prototype = Object.create(ValueExpressionContext.prototype); ArithmeticBinaryContext.prototype.constructor = ArithmeticBinaryContext; -SqlBaseParser.ArithmeticBinaryContext = ArithmeticBinaryContext; +SparkSqlParser.ArithmeticBinaryContext = ArithmeticBinaryContext; ArithmeticBinaryContext.prototype.valueExpression = function(i) { if(i===undefined) { @@ -22540,58 +22540,58 @@ ArithmeticBinaryContext.prototype.valueExpression = function(i) { }; ArithmeticBinaryContext.prototype.ASTERISK = function() { - return this.getToken(SqlBaseParser.ASTERISK, 0); + return this.getToken(SparkSqlParser.ASTERISK, 0); }; ArithmeticBinaryContext.prototype.SLASH = function() { - return this.getToken(SqlBaseParser.SLASH, 0); + return this.getToken(SparkSqlParser.SLASH, 0); }; ArithmeticBinaryContext.prototype.PERCENT = function() { - return this.getToken(SqlBaseParser.PERCENT, 0); + return this.getToken(SparkSqlParser.PERCENT, 0); }; ArithmeticBinaryContext.prototype.DIV = function() { - return this.getToken(SqlBaseParser.DIV, 0); + return this.getToken(SparkSqlParser.DIV, 0); }; ArithmeticBinaryContext.prototype.PLUS = function() { - return this.getToken(SqlBaseParser.PLUS, 0); + return this.getToken(SparkSqlParser.PLUS, 0); }; ArithmeticBinaryContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; ArithmeticBinaryContext.prototype.CONCAT_PIPE = function() { - return this.getToken(SqlBaseParser.CONCAT_PIPE, 0); + return this.getToken(SparkSqlParser.CONCAT_PIPE, 0); }; ArithmeticBinaryContext.prototype.AMPERSAND = function() { - return this.getToken(SqlBaseParser.AMPERSAND, 0); + return this.getToken(SparkSqlParser.AMPERSAND, 0); }; ArithmeticBinaryContext.prototype.HAT = function() { - return this.getToken(SqlBaseParser.HAT, 0); + return this.getToken(SparkSqlParser.HAT, 0); }; ArithmeticBinaryContext.prototype.PIPE = function() { - return this.getToken(SqlBaseParser.PIPE, 0); + return this.getToken(SparkSqlParser.PIPE, 0); }; ArithmeticBinaryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterArithmeticBinary(this); } }; ArithmeticBinaryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitArithmeticBinary(this); } }; ArithmeticBinaryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitArithmeticBinary(this); } else { return visitor.visitChildren(this); @@ -22609,37 +22609,37 @@ function ArithmeticUnaryContext(parser, ctx) { ArithmeticUnaryContext.prototype = Object.create(ValueExpressionContext.prototype); ArithmeticUnaryContext.prototype.constructor = ArithmeticUnaryContext; -SqlBaseParser.ArithmeticUnaryContext = ArithmeticUnaryContext; +SparkSqlParser.ArithmeticUnaryContext = ArithmeticUnaryContext; ArithmeticUnaryContext.prototype.valueExpression = function() { return this.getTypedRuleContext(ValueExpressionContext,0); }; ArithmeticUnaryContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; ArithmeticUnaryContext.prototype.PLUS = function() { - return this.getToken(SqlBaseParser.PLUS, 0); + return this.getToken(SparkSqlParser.PLUS, 0); }; ArithmeticUnaryContext.prototype.TILDE = function() { - return this.getToken(SqlBaseParser.TILDE, 0); + return this.getToken(SparkSqlParser.TILDE, 0); }; ArithmeticUnaryContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterArithmeticUnary(this); } }; ArithmeticUnaryContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitArithmeticUnary(this); } }; ArithmeticUnaryContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitArithmeticUnary(this); } else { return visitor.visitChildren(this); @@ -22648,7 +22648,7 @@ ArithmeticUnaryContext.prototype.accept = function(visitor) { -SqlBaseParser.prototype.valueExpression = function(_p) { +SparkSqlParser.prototype.valueExpression = function(_p) { if(_p===undefined) { _p = 0; } @@ -22657,7 +22657,7 @@ SqlBaseParser.prototype.valueExpression = function(_p) { var localctx = new ValueExpressionContext(this, this._ctx, _parentState); var _prevctx = localctx; var _startState = 192; - this.enterRecursionRule(localctx, 192, SqlBaseParser.RULE_valueExpression, _p); + this.enterRecursionRule(localctx, 192, SparkSqlParser.RULE_valueExpression, _p); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -22681,7 +22681,7 @@ SqlBaseParser.prototype.valueExpression = function(_p) { this.state = 2445; localctx.operator = this._input.LT(1); _la = this._input.LA(1); - if(!(((((_la - 269)) & ~0x1f) == 0 && ((1 << (_la - 269)) & ((1 << (SqlBaseParser.PLUS - 269)) | (1 << (SqlBaseParser.MINUS - 269)) | (1 << (SqlBaseParser.TILDE - 269)))) !== 0))) { + if(!(((((_la - 269)) & ~0x1f) == 0 && ((1 << (_la - 269)) & ((1 << (SparkSqlParser.PLUS - 269)) | (1 << (SparkSqlParser.MINUS - 269)) | (1 << (SparkSqlParser.TILDE - 269)))) !== 0))) { localctx.operator = this._errHandler.recoverInline(this); } else { @@ -22710,7 +22710,7 @@ SqlBaseParser.prototype.valueExpression = function(_p) { case 1: localctx = new ArithmeticBinaryContext(this, new ValueExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_valueExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_valueExpression); this.state = 2449; if (!( this.precpred(this._ctx, 6))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)"); @@ -22718,7 +22718,7 @@ SqlBaseParser.prototype.valueExpression = function(_p) { this.state = 2450; localctx.operator = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DIV || ((((_la - 271)) & ~0x1f) == 0 && ((1 << (_la - 271)) & ((1 << (SqlBaseParser.ASTERISK - 271)) | (1 << (SqlBaseParser.SLASH - 271)) | (1 << (SqlBaseParser.PERCENT - 271)))) !== 0))) { + if(!(_la===SparkSqlParser.DIV || ((((_la - 271)) & ~0x1f) == 0 && ((1 << (_la - 271)) & ((1 << (SparkSqlParser.ASTERISK - 271)) | (1 << (SparkSqlParser.SLASH - 271)) | (1 << (SparkSqlParser.PERCENT - 271)))) !== 0))) { localctx.operator = this._errHandler.recoverInline(this); } else { @@ -22732,7 +22732,7 @@ SqlBaseParser.prototype.valueExpression = function(_p) { case 2: localctx = new ArithmeticBinaryContext(this, new ValueExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_valueExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_valueExpression); this.state = 2452; if (!( this.precpred(this._ctx, 5))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)"); @@ -22740,7 +22740,7 @@ SqlBaseParser.prototype.valueExpression = function(_p) { this.state = 2453; localctx.operator = this._input.LT(1); _la = this._input.LA(1); - if(!(((((_la - 269)) & ~0x1f) == 0 && ((1 << (_la - 269)) & ((1 << (SqlBaseParser.PLUS - 269)) | (1 << (SqlBaseParser.MINUS - 269)) | (1 << (SqlBaseParser.CONCAT_PIPE - 269)))) !== 0))) { + if(!(((((_la - 269)) & ~0x1f) == 0 && ((1 << (_la - 269)) & ((1 << (SparkSqlParser.PLUS - 269)) | (1 << (SparkSqlParser.MINUS - 269)) | (1 << (SparkSqlParser.CONCAT_PIPE - 269)))) !== 0))) { localctx.operator = this._errHandler.recoverInline(this); } else { @@ -22754,13 +22754,13 @@ SqlBaseParser.prototype.valueExpression = function(_p) { case 3: localctx = new ArithmeticBinaryContext(this, new ValueExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_valueExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_valueExpression); this.state = 2455; if (!( this.precpred(this._ctx, 4))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 4)"); } this.state = 2456; - localctx.operator = this.match(SqlBaseParser.AMPERSAND); + localctx.operator = this.match(SparkSqlParser.AMPERSAND); this.state = 2457; localctx.right = this.valueExpression(5); break; @@ -22768,13 +22768,13 @@ SqlBaseParser.prototype.valueExpression = function(_p) { case 4: localctx = new ArithmeticBinaryContext(this, new ValueExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_valueExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_valueExpression); this.state = 2458; if (!( this.precpred(this._ctx, 3))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 3)"); } this.state = 2459; - localctx.operator = this.match(SqlBaseParser.HAT); + localctx.operator = this.match(SparkSqlParser.HAT); this.state = 2460; localctx.right = this.valueExpression(4); break; @@ -22782,13 +22782,13 @@ SqlBaseParser.prototype.valueExpression = function(_p) { case 5: localctx = new ArithmeticBinaryContext(this, new ValueExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_valueExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_valueExpression); this.state = 2461; if (!( this.precpred(this._ctx, 2))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)"); } this.state = 2462; - localctx.operator = this.match(SqlBaseParser.PIPE); + localctx.operator = this.match(SparkSqlParser.PIPE); this.state = 2463; localctx.right = this.valueExpression(3); break; @@ -22796,7 +22796,7 @@ SqlBaseParser.prototype.valueExpression = function(_p) { case 6: localctx = new ComparisonContext(this, new ValueExpressionContext(this, _parentctx, _parentState)); localctx.left = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_valueExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_valueExpression); this.state = 2464; if (!( this.precpred(this._ctx, 1))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)"); @@ -22838,7 +22838,7 @@ function PrimaryExpressionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_primaryExpression; + this.ruleIndex = SparkSqlParser.RULE_primaryExpression; return this; } @@ -22862,10 +22862,10 @@ function StructContext(parser, ctx) { StructContext.prototype = Object.create(PrimaryExpressionContext.prototype); StructContext.prototype.constructor = StructContext; -SqlBaseParser.StructContext = StructContext; +SparkSqlParser.StructContext = StructContext; StructContext.prototype.STRUCT = function() { - return this.getToken(SqlBaseParser.STRUCT, 0); + return this.getToken(SparkSqlParser.STRUCT, 0); }; StructContext.prototype.namedExpression = function(i) { @@ -22879,19 +22879,19 @@ StructContext.prototype.namedExpression = function(i) { } }; StructContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterStruct(this); } }; StructContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitStruct(this); } }; StructContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitStruct(this); } else { return visitor.visitChildren(this); @@ -22910,7 +22910,7 @@ function DereferenceContext(parser, ctx) { DereferenceContext.prototype = Object.create(PrimaryExpressionContext.prototype); DereferenceContext.prototype.constructor = DereferenceContext; -SqlBaseParser.DereferenceContext = DereferenceContext; +SparkSqlParser.DereferenceContext = DereferenceContext; DereferenceContext.prototype.primaryExpression = function() { return this.getTypedRuleContext(PrimaryExpressionContext,0); @@ -22920,19 +22920,19 @@ DereferenceContext.prototype.identifier = function() { return this.getTypedRuleContext(IdentifierContext,0); }; DereferenceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDereference(this); } }; DereferenceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDereference(this); } }; DereferenceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDereference(this); } else { return visitor.visitChildren(this); @@ -22951,14 +22951,14 @@ function SimpleCaseContext(parser, ctx) { SimpleCaseContext.prototype = Object.create(PrimaryExpressionContext.prototype); SimpleCaseContext.prototype.constructor = SimpleCaseContext; -SqlBaseParser.SimpleCaseContext = SimpleCaseContext; +SparkSqlParser.SimpleCaseContext = SimpleCaseContext; SimpleCaseContext.prototype.CASE = function() { - return this.getToken(SqlBaseParser.CASE, 0); + return this.getToken(SparkSqlParser.CASE, 0); }; SimpleCaseContext.prototype.END = function() { - return this.getToken(SqlBaseParser.END, 0); + return this.getToken(SparkSqlParser.END, 0); }; SimpleCaseContext.prototype.expression = function(i) { @@ -22984,22 +22984,22 @@ SimpleCaseContext.prototype.whenClause = function(i) { }; SimpleCaseContext.prototype.ELSE = function() { - return this.getToken(SqlBaseParser.ELSE, 0); + return this.getToken(SparkSqlParser.ELSE, 0); }; SimpleCaseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSimpleCase(this); } }; SimpleCaseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSimpleCase(this); } }; SimpleCaseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSimpleCase(this); } else { return visitor.visitChildren(this); @@ -23016,25 +23016,25 @@ function ColumnReferenceContext(parser, ctx) { ColumnReferenceContext.prototype = Object.create(PrimaryExpressionContext.prototype); ColumnReferenceContext.prototype.constructor = ColumnReferenceContext; -SqlBaseParser.ColumnReferenceContext = ColumnReferenceContext; +SparkSqlParser.ColumnReferenceContext = ColumnReferenceContext; ColumnReferenceContext.prototype.identifier = function() { return this.getTypedRuleContext(IdentifierContext,0); }; ColumnReferenceContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterColumnReference(this); } }; ColumnReferenceContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitColumnReference(this); } }; ColumnReferenceContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitColumnReference(this); } else { return visitor.visitChildren(this); @@ -23051,7 +23051,7 @@ function RowConstructorContext(parser, ctx) { RowConstructorContext.prototype = Object.create(PrimaryExpressionContext.prototype); RowConstructorContext.prototype.constructor = RowConstructorContext; -SqlBaseParser.RowConstructorContext = RowConstructorContext; +SparkSqlParser.RowConstructorContext = RowConstructorContext; RowConstructorContext.prototype.namedExpression = function(i) { if(i===undefined) { @@ -23064,19 +23064,19 @@ RowConstructorContext.prototype.namedExpression = function(i) { } }; RowConstructorContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRowConstructor(this); } }; RowConstructorContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRowConstructor(this); } }; RowConstructorContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRowConstructor(this); } else { return visitor.visitChildren(this); @@ -23093,10 +23093,10 @@ function LastContext(parser, ctx) { LastContext.prototype = Object.create(PrimaryExpressionContext.prototype); LastContext.prototype.constructor = LastContext; -SqlBaseParser.LastContext = LastContext; +SparkSqlParser.LastContext = LastContext; LastContext.prototype.LAST = function() { - return this.getToken(SqlBaseParser.LAST, 0); + return this.getToken(SparkSqlParser.LAST, 0); }; LastContext.prototype.expression = function() { @@ -23104,26 +23104,26 @@ LastContext.prototype.expression = function() { }; LastContext.prototype.IGNORE = function() { - return this.getToken(SqlBaseParser.IGNORE, 0); + return this.getToken(SparkSqlParser.IGNORE, 0); }; LastContext.prototype.NULLS = function() { - return this.getToken(SqlBaseParser.NULLS, 0); + return this.getToken(SparkSqlParser.NULLS, 0); }; LastContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLast(this); } }; LastContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLast(this); } }; LastContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLast(this); } else { return visitor.visitChildren(this); @@ -23140,29 +23140,29 @@ function StarContext(parser, ctx) { StarContext.prototype = Object.create(PrimaryExpressionContext.prototype); StarContext.prototype.constructor = StarContext; -SqlBaseParser.StarContext = StarContext; +SparkSqlParser.StarContext = StarContext; StarContext.prototype.ASTERISK = function() { - return this.getToken(SqlBaseParser.ASTERISK, 0); + return this.getToken(SparkSqlParser.ASTERISK, 0); }; StarContext.prototype.qualifiedName = function() { return this.getTypedRuleContext(QualifiedNameContext,0); }; StarContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterStar(this); } }; StarContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitStar(this); } }; StarContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitStar(this); } else { return visitor.visitChildren(this); @@ -23183,18 +23183,18 @@ function OverlayContext(parser, ctx) { OverlayContext.prototype = Object.create(PrimaryExpressionContext.prototype); OverlayContext.prototype.constructor = OverlayContext; -SqlBaseParser.OverlayContext = OverlayContext; +SparkSqlParser.OverlayContext = OverlayContext; OverlayContext.prototype.OVERLAY = function() { - return this.getToken(SqlBaseParser.OVERLAY, 0); + return this.getToken(SparkSqlParser.OVERLAY, 0); }; OverlayContext.prototype.PLACING = function() { - return this.getToken(SqlBaseParser.PLACING, 0); + return this.getToken(SparkSqlParser.PLACING, 0); }; OverlayContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; OverlayContext.prototype.valueExpression = function(i) { @@ -23209,22 +23209,22 @@ OverlayContext.prototype.valueExpression = function(i) { }; OverlayContext.prototype.FOR = function() { - return this.getToken(SqlBaseParser.FOR, 0); + return this.getToken(SparkSqlParser.FOR, 0); }; OverlayContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterOverlay(this); } }; OverlayContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitOverlay(this); } }; OverlayContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitOverlay(this); } else { return visitor.visitChildren(this); @@ -23243,7 +23243,7 @@ function SubscriptContext(parser, ctx) { SubscriptContext.prototype = Object.create(PrimaryExpressionContext.prototype); SubscriptContext.prototype.constructor = SubscriptContext; -SqlBaseParser.SubscriptContext = SubscriptContext; +SparkSqlParser.SubscriptContext = SubscriptContext; SubscriptContext.prototype.primaryExpression = function() { return this.getTypedRuleContext(PrimaryExpressionContext,0); @@ -23253,19 +23253,19 @@ SubscriptContext.prototype.valueExpression = function() { return this.getTypedRuleContext(ValueExpressionContext,0); }; SubscriptContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSubscript(this); } }; SubscriptContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSubscript(this); } }; SubscriptContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSubscript(this); } else { return visitor.visitChildren(this); @@ -23282,25 +23282,25 @@ function SubqueryExpressionContext(parser, ctx) { SubqueryExpressionContext.prototype = Object.create(PrimaryExpressionContext.prototype); SubqueryExpressionContext.prototype.constructor = SubqueryExpressionContext; -SqlBaseParser.SubqueryExpressionContext = SubqueryExpressionContext; +SparkSqlParser.SubqueryExpressionContext = SubqueryExpressionContext; SubqueryExpressionContext.prototype.query = function() { return this.getTypedRuleContext(QueryContext,0); }; SubqueryExpressionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSubqueryExpression(this); } }; SubqueryExpressionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSubqueryExpression(this); } }; SubqueryExpressionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSubqueryExpression(this); } else { return visitor.visitChildren(this); @@ -23320,14 +23320,14 @@ function SubstringContext(parser, ctx) { SubstringContext.prototype = Object.create(PrimaryExpressionContext.prototype); SubstringContext.prototype.constructor = SubstringContext; -SqlBaseParser.SubstringContext = SubstringContext; +SparkSqlParser.SubstringContext = SubstringContext; SubstringContext.prototype.SUBSTR = function() { - return this.getToken(SqlBaseParser.SUBSTR, 0); + return this.getToken(SparkSqlParser.SUBSTR, 0); }; SubstringContext.prototype.SUBSTRING = function() { - return this.getToken(SqlBaseParser.SUBSTRING, 0); + return this.getToken(SparkSqlParser.SUBSTRING, 0); }; SubstringContext.prototype.valueExpression = function(i) { @@ -23342,26 +23342,26 @@ SubstringContext.prototype.valueExpression = function(i) { }; SubstringContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; SubstringContext.prototype.FOR = function() { - return this.getToken(SqlBaseParser.FOR, 0); + return this.getToken(SparkSqlParser.FOR, 0); }; SubstringContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSubstring(this); } }; SubstringContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSubstring(this); } }; SubstringContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSubstring(this); } else { return visitor.visitChildren(this); @@ -23379,29 +23379,29 @@ function CurrentDatetimeContext(parser, ctx) { CurrentDatetimeContext.prototype = Object.create(PrimaryExpressionContext.prototype); CurrentDatetimeContext.prototype.constructor = CurrentDatetimeContext; -SqlBaseParser.CurrentDatetimeContext = CurrentDatetimeContext; +SparkSqlParser.CurrentDatetimeContext = CurrentDatetimeContext; CurrentDatetimeContext.prototype.CURRENT_DATE = function() { - return this.getToken(SqlBaseParser.CURRENT_DATE, 0); + return this.getToken(SparkSqlParser.CURRENT_DATE, 0); }; CurrentDatetimeContext.prototype.CURRENT_TIMESTAMP = function() { - return this.getToken(SqlBaseParser.CURRENT_TIMESTAMP, 0); + return this.getToken(SparkSqlParser.CURRENT_TIMESTAMP, 0); }; CurrentDatetimeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCurrentDatetime(this); } }; CurrentDatetimeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCurrentDatetime(this); } }; CurrentDatetimeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCurrentDatetime(this); } else { return visitor.visitChildren(this); @@ -23418,10 +23418,10 @@ function CastContext(parser, ctx) { CastContext.prototype = Object.create(PrimaryExpressionContext.prototype); CastContext.prototype.constructor = CastContext; -SqlBaseParser.CastContext = CastContext; +SparkSqlParser.CastContext = CastContext; CastContext.prototype.CAST = function() { - return this.getToken(SqlBaseParser.CAST, 0); + return this.getToken(SparkSqlParser.CAST, 0); }; CastContext.prototype.expression = function() { @@ -23429,26 +23429,26 @@ CastContext.prototype.expression = function() { }; CastContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; CastContext.prototype.dataType = function() { return this.getTypedRuleContext(DataTypeContext,0); }; CastContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterCast(this); } }; CastContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitCast(this); } }; CastContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitCast(this); } else { return visitor.visitChildren(this); @@ -23465,25 +23465,25 @@ function ConstantDefaultContext(parser, ctx) { ConstantDefaultContext.prototype = Object.create(PrimaryExpressionContext.prototype); ConstantDefaultContext.prototype.constructor = ConstantDefaultContext; -SqlBaseParser.ConstantDefaultContext = ConstantDefaultContext; +SparkSqlParser.ConstantDefaultContext = ConstantDefaultContext; ConstantDefaultContext.prototype.constant = function() { return this.getTypedRuleContext(ConstantContext,0); }; ConstantDefaultContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterConstantDefault(this); } }; ConstantDefaultContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitConstantDefault(this); } }; ConstantDefaultContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitConstantDefault(this); } else { return visitor.visitChildren(this); @@ -23500,7 +23500,7 @@ function LambdaContext(parser, ctx) { LambdaContext.prototype = Object.create(PrimaryExpressionContext.prototype); LambdaContext.prototype.constructor = LambdaContext; -SqlBaseParser.LambdaContext = LambdaContext; +SparkSqlParser.LambdaContext = LambdaContext; LambdaContext.prototype.identifier = function(i) { if(i===undefined) { @@ -23517,19 +23517,19 @@ LambdaContext.prototype.expression = function() { return this.getTypedRuleContext(ExpressionContext,0); }; LambdaContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLambda(this); } }; LambdaContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLambda(this); } }; LambdaContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLambda(this); } else { return visitor.visitChildren(this); @@ -23546,25 +23546,25 @@ function ParenthesizedExpressionContext(parser, ctx) { ParenthesizedExpressionContext.prototype = Object.create(PrimaryExpressionContext.prototype); ParenthesizedExpressionContext.prototype.constructor = ParenthesizedExpressionContext; -SqlBaseParser.ParenthesizedExpressionContext = ParenthesizedExpressionContext; +SparkSqlParser.ParenthesizedExpressionContext = ParenthesizedExpressionContext; ParenthesizedExpressionContext.prototype.expression = function() { return this.getTypedRuleContext(ExpressionContext,0); }; ParenthesizedExpressionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterParenthesizedExpression(this); } }; ParenthesizedExpressionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitParenthesizedExpression(this); } }; ParenthesizedExpressionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitParenthesizedExpression(this); } else { return visitor.visitChildren(this); @@ -23583,14 +23583,14 @@ function ExtractContext(parser, ctx) { ExtractContext.prototype = Object.create(PrimaryExpressionContext.prototype); ExtractContext.prototype.constructor = ExtractContext; -SqlBaseParser.ExtractContext = ExtractContext; +SparkSqlParser.ExtractContext = ExtractContext; ExtractContext.prototype.EXTRACT = function() { - return this.getToken(SqlBaseParser.EXTRACT, 0); + return this.getToken(SparkSqlParser.EXTRACT, 0); }; ExtractContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; ExtractContext.prototype.identifier = function() { @@ -23601,19 +23601,19 @@ ExtractContext.prototype.valueExpression = function() { return this.getTypedRuleContext(ValueExpressionContext,0); }; ExtractContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterExtract(this); } }; ExtractContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitExtract(this); } }; ExtractContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitExtract(this); } else { return visitor.visitChildren(this); @@ -23633,14 +23633,14 @@ function TrimContext(parser, ctx) { TrimContext.prototype = Object.create(PrimaryExpressionContext.prototype); TrimContext.prototype.constructor = TrimContext; -SqlBaseParser.TrimContext = TrimContext; +SparkSqlParser.TrimContext = TrimContext; TrimContext.prototype.TRIM = function() { - return this.getToken(SqlBaseParser.TRIM, 0); + return this.getToken(SparkSqlParser.TRIM, 0); }; TrimContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; TrimContext.prototype.valueExpression = function(i) { @@ -23655,30 +23655,30 @@ TrimContext.prototype.valueExpression = function(i) { }; TrimContext.prototype.BOTH = function() { - return this.getToken(SqlBaseParser.BOTH, 0); + return this.getToken(SparkSqlParser.BOTH, 0); }; TrimContext.prototype.LEADING = function() { - return this.getToken(SqlBaseParser.LEADING, 0); + return this.getToken(SparkSqlParser.LEADING, 0); }; TrimContext.prototype.TRAILING = function() { - return this.getToken(SqlBaseParser.TRAILING, 0); + return this.getToken(SparkSqlParser.TRAILING, 0); }; TrimContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTrim(this); } }; TrimContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTrim(this); } }; TrimContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTrim(this); } else { return visitor.visitChildren(this); @@ -23698,22 +23698,22 @@ function FunctionCallContext(parser, ctx) { FunctionCallContext.prototype = Object.create(PrimaryExpressionContext.prototype); FunctionCallContext.prototype.constructor = FunctionCallContext; -SqlBaseParser.FunctionCallContext = FunctionCallContext; +SparkSqlParser.FunctionCallContext = FunctionCallContext; FunctionCallContext.prototype.functionName = function() { return this.getTypedRuleContext(FunctionNameContext,0); }; FunctionCallContext.prototype.FILTER = function() { - return this.getToken(SqlBaseParser.FILTER, 0); + return this.getToken(SparkSqlParser.FILTER, 0); }; FunctionCallContext.prototype.WHERE = function() { - return this.getToken(SqlBaseParser.WHERE, 0); + return this.getToken(SparkSqlParser.WHERE, 0); }; FunctionCallContext.prototype.OVER = function() { - return this.getToken(SqlBaseParser.OVER, 0); + return this.getToken(SparkSqlParser.OVER, 0); }; FunctionCallContext.prototype.windowSpec = function() { @@ -23739,19 +23739,19 @@ FunctionCallContext.prototype.setQuantifier = function() { return this.getTypedRuleContext(SetQuantifierContext,0); }; FunctionCallContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFunctionCall(this); } }; FunctionCallContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFunctionCall(this); } }; FunctionCallContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFunctionCall(this); } else { return visitor.visitChildren(this); @@ -23769,14 +23769,14 @@ function SearchedCaseContext(parser, ctx) { SearchedCaseContext.prototype = Object.create(PrimaryExpressionContext.prototype); SearchedCaseContext.prototype.constructor = SearchedCaseContext; -SqlBaseParser.SearchedCaseContext = SearchedCaseContext; +SparkSqlParser.SearchedCaseContext = SearchedCaseContext; SearchedCaseContext.prototype.CASE = function() { - return this.getToken(SqlBaseParser.CASE, 0); + return this.getToken(SparkSqlParser.CASE, 0); }; SearchedCaseContext.prototype.END = function() { - return this.getToken(SqlBaseParser.END, 0); + return this.getToken(SparkSqlParser.END, 0); }; SearchedCaseContext.prototype.whenClause = function(i) { @@ -23791,26 +23791,26 @@ SearchedCaseContext.prototype.whenClause = function(i) { }; SearchedCaseContext.prototype.ELSE = function() { - return this.getToken(SqlBaseParser.ELSE, 0); + return this.getToken(SparkSqlParser.ELSE, 0); }; SearchedCaseContext.prototype.expression = function() { return this.getTypedRuleContext(ExpressionContext,0); }; SearchedCaseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSearchedCase(this); } }; SearchedCaseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSearchedCase(this); } }; SearchedCaseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSearchedCase(this); } else { return visitor.visitChildren(this); @@ -23829,14 +23829,14 @@ function PositionContext(parser, ctx) { PositionContext.prototype = Object.create(PrimaryExpressionContext.prototype); PositionContext.prototype.constructor = PositionContext; -SqlBaseParser.PositionContext = PositionContext; +SparkSqlParser.PositionContext = PositionContext; PositionContext.prototype.POSITION = function() { - return this.getToken(SqlBaseParser.POSITION, 0); + return this.getToken(SparkSqlParser.POSITION, 0); }; PositionContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; PositionContext.prototype.valueExpression = function(i) { @@ -23850,19 +23850,19 @@ PositionContext.prototype.valueExpression = function(i) { } }; PositionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPosition(this); } }; PositionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPosition(this); } }; PositionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPosition(this); } else { return visitor.visitChildren(this); @@ -23879,10 +23879,10 @@ function FirstContext(parser, ctx) { FirstContext.prototype = Object.create(PrimaryExpressionContext.prototype); FirstContext.prototype.constructor = FirstContext; -SqlBaseParser.FirstContext = FirstContext; +SparkSqlParser.FirstContext = FirstContext; FirstContext.prototype.FIRST = function() { - return this.getToken(SqlBaseParser.FIRST, 0); + return this.getToken(SparkSqlParser.FIRST, 0); }; FirstContext.prototype.expression = function() { @@ -23890,26 +23890,26 @@ FirstContext.prototype.expression = function() { }; FirstContext.prototype.IGNORE = function() { - return this.getToken(SqlBaseParser.IGNORE, 0); + return this.getToken(SparkSqlParser.IGNORE, 0); }; FirstContext.prototype.NULLS = function() { - return this.getToken(SqlBaseParser.NULLS, 0); + return this.getToken(SparkSqlParser.NULLS, 0); }; FirstContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFirst(this); } }; FirstContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFirst(this); } }; FirstContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFirst(this); } else { return visitor.visitChildren(this); @@ -23918,7 +23918,7 @@ FirstContext.prototype.accept = function(visitor) { -SqlBaseParser.prototype.primaryExpression = function(_p) { +SparkSqlParser.prototype.primaryExpression = function(_p) { if(_p===undefined) { _p = 0; } @@ -23927,7 +23927,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { var localctx = new PrimaryExpressionContext(this, this._ctx, _parentState); var _prevctx = localctx; var _startState = 194; - this.enterRecursionRule(localctx, 194, SqlBaseParser.RULE_primaryExpression, _p); + this.enterRecursionRule(localctx, 194, SparkSqlParser.RULE_primaryExpression, _p); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -23943,7 +23943,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2474; localctx.name = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.CURRENT_DATE || _la===SqlBaseParser.CURRENT_TIMESTAMP)) { + if(!(_la===SparkSqlParser.CURRENT_DATE || _la===SparkSqlParser.CURRENT_TIMESTAMP)) { localctx.name = this._errHandler.recoverInline(this); } else { @@ -23957,7 +23957,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2475; - this.match(SqlBaseParser.CASE); + this.match(SparkSqlParser.CASE); this.state = 2477; this._errHandler.sync(this); _la = this._input.LA(1); @@ -23967,19 +23967,19 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2479; this._errHandler.sync(this); _la = this._input.LA(1); - } while(_la===SqlBaseParser.WHEN); + } while(_la===SparkSqlParser.WHEN); this.state = 2483; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ELSE) { + if(_la===SparkSqlParser.ELSE) { this.state = 2481; - this.match(SqlBaseParser.ELSE); + this.match(SparkSqlParser.ELSE); this.state = 2482; localctx.elseExpression = this.expression(); } this.state = 2485; - this.match(SqlBaseParser.END); + this.match(SparkSqlParser.END); break; case 3: @@ -23987,7 +23987,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2487; - this.match(SqlBaseParser.CASE); + this.match(SparkSqlParser.CASE); this.state = 2488; localctx.value = this.expression(); this.state = 2490; @@ -23999,19 +23999,19 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2492; this._errHandler.sync(this); _la = this._input.LA(1); - } while(_la===SqlBaseParser.WHEN); + } while(_la===SparkSqlParser.WHEN); this.state = 2496; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ELSE) { + if(_la===SparkSqlParser.ELSE) { this.state = 2494; - this.match(SqlBaseParser.ELSE); + this.match(SparkSqlParser.ELSE); this.state = 2495; localctx.elseExpression = this.expression(); } this.state = 2498; - this.match(SqlBaseParser.END); + this.match(SparkSqlParser.END); break; case 4: @@ -24019,17 +24019,17 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2500; - this.match(SqlBaseParser.CAST); + this.match(SparkSqlParser.CAST); this.state = 2501; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2502; this.expression(); this.state = 2503; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 2504; this.dataType(); this.state = 2505; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 5: @@ -24037,9 +24037,9 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2507; - this.match(SqlBaseParser.STRUCT); + this.match(SparkSqlParser.STRUCT); this.state = 2508; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2517; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,322,this._ctx); @@ -24050,9 +24050,9 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2514; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2510; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2511; localctx._namedExpression = this.namedExpression(); localctx.argument.push(localctx._namedExpression); @@ -24063,7 +24063,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { } this.state = 2519; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 6: @@ -24071,23 +24071,23 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2520; - this.match(SqlBaseParser.FIRST); + this.match(SparkSqlParser.FIRST); this.state = 2521; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2522; this.expression(); this.state = 2525; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.IGNORE) { + if(_la===SparkSqlParser.IGNORE) { this.state = 2523; - this.match(SqlBaseParser.IGNORE); + this.match(SparkSqlParser.IGNORE); this.state = 2524; - this.match(SqlBaseParser.NULLS); + this.match(SparkSqlParser.NULLS); } this.state = 2527; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 7: @@ -24095,23 +24095,23 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2529; - this.match(SqlBaseParser.LAST); + this.match(SparkSqlParser.LAST); this.state = 2530; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2531; this.expression(); this.state = 2534; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.IGNORE) { + if(_la===SparkSqlParser.IGNORE) { this.state = 2532; - this.match(SqlBaseParser.IGNORE); + this.match(SparkSqlParser.IGNORE); this.state = 2533; - this.match(SqlBaseParser.NULLS); + this.match(SparkSqlParser.NULLS); } this.state = 2536; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 8: @@ -24119,17 +24119,17 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2538; - this.match(SqlBaseParser.POSITION); + this.match(SparkSqlParser.POSITION); this.state = 2539; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2540; localctx.substr = this.valueExpression(0); this.state = 2541; - this.match(SqlBaseParser.IN); + this.match(SparkSqlParser.IN); this.state = 2542; localctx.str = this.valueExpression(0); this.state = 2543; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 9: @@ -24145,7 +24145,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2546; - this.match(SqlBaseParser.ASTERISK); + this.match(SparkSqlParser.ASTERISK); break; case 11: @@ -24155,9 +24155,9 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2547; this.qualifiedName(); this.state = 2548; - this.match(SqlBaseParser.T__4); + this.match(SparkSqlParser.T__4); this.state = 2549; - this.match(SqlBaseParser.ASTERISK); + this.match(SparkSqlParser.ASTERISK); break; case 12: @@ -24165,7 +24165,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2551; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2552; this.namedExpression(); this.state = 2555; @@ -24173,15 +24173,15 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { _la = this._input.LA(1); do { this.state = 2553; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2554; this.namedExpression(); this.state = 2557; this._errHandler.sync(this); _la = this._input.LA(1); - } while(_la===SqlBaseParser.T__3); + } while(_la===SparkSqlParser.T__3); this.state = 2559; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 13: @@ -24189,11 +24189,11 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2561; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2562; this.query(); this.state = 2563; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 14: @@ -24203,7 +24203,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2565; this.functionName(); this.state = 2566; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2578; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,328,this._ctx); @@ -24222,9 +24222,9 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2575; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2571; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2572; localctx._expression = this.expression(); localctx.argument.push(localctx._expression); @@ -24235,21 +24235,21 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { } this.state = 2580; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 2587; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,329,this._ctx); if(la_===1) { this.state = 2581; - this.match(SqlBaseParser.FILTER); + this.match(SparkSqlParser.FILTER); this.state = 2582; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2583; - this.match(SqlBaseParser.WHERE); + this.match(SparkSqlParser.WHERE); this.state = 2584; localctx.where = this.booleanExpression(0); this.state = 2585; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } this.state = 2591; @@ -24257,7 +24257,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { var la_ = this._interp.adaptivePredict(this._input,330,this._ctx); if(la_===1) { this.state = 2589; - this.match(SqlBaseParser.OVER); + this.match(SparkSqlParser.OVER); this.state = 2590; this.windowSpec(); @@ -24271,7 +24271,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2593; this.identifier(); this.state = 2594; - this.match(SqlBaseParser.T__7); + this.match(SparkSqlParser.T__7); this.state = 2595; this.expression(); break; @@ -24281,7 +24281,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2597; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2598; this.identifier(); this.state = 2601; @@ -24289,17 +24289,17 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { _la = this._input.LA(1); do { this.state = 2599; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2600; this.identifier(); this.state = 2603; this._errHandler.sync(this); _la = this._input.LA(1); - } while(_la===SqlBaseParser.T__3); + } while(_la===SparkSqlParser.T__3); this.state = 2605; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); this.state = 2606; - this.match(SqlBaseParser.T__7); + this.match(SparkSqlParser.T__7); this.state = 2607; this.expression(); break; @@ -24317,11 +24317,11 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2610; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2611; this.expression(); this.state = 2612; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 19: @@ -24329,17 +24329,17 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2614; - this.match(SqlBaseParser.EXTRACT); + this.match(SparkSqlParser.EXTRACT); this.state = 2615; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2616; localctx.field = this.identifier(); this.state = 2617; - this.match(SqlBaseParser.FROM); + this.match(SparkSqlParser.FROM); this.state = 2618; localctx.source = this.valueExpression(0); this.state = 2619; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 20: @@ -24348,7 +24348,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { _prevctx = localctx; this.state = 2621; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.SUBSTR || _la===SqlBaseParser.SUBSTRING)) { + if(!(_la===SparkSqlParser.SUBSTR || _la===SparkSqlParser.SUBSTRING)) { this._errHandler.recoverInline(this); } else { @@ -24356,12 +24356,12 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.consume(); } this.state = 2622; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2623; localctx.str = this.valueExpression(0); this.state = 2624; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.T__3 || _la===SqlBaseParser.FROM)) { + if(!(_la===SparkSqlParser.T__3 || _la===SparkSqlParser.FROM)) { this._errHandler.recoverInline(this); } else { @@ -24373,10 +24373,10 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2628; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.T__3 || _la===SqlBaseParser.FOR) { + if(_la===SparkSqlParser.T__3 || _la===SparkSqlParser.FOR) { this.state = 2626; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.T__3 || _la===SqlBaseParser.FOR)) { + if(!(_la===SparkSqlParser.T__3 || _la===SparkSqlParser.FOR)) { this._errHandler.recoverInline(this); } else { @@ -24388,7 +24388,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { } this.state = 2630; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 21: @@ -24396,9 +24396,9 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2632; - this.match(SqlBaseParser.TRIM); + this.match(SparkSqlParser.TRIM); this.state = 2633; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2635; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,333,this._ctx); @@ -24406,7 +24406,7 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this.state = 2634; localctx.trimOption = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.BOTH || _la===SqlBaseParser.LEADING || _la===SqlBaseParser.TRAILING)) { + if(!(_la===SparkSqlParser.BOTH || _la===SparkSqlParser.LEADING || _la===SparkSqlParser.TRAILING)) { localctx.trimOption = this._errHandler.recoverInline(this); } else { @@ -24424,11 +24424,11 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { } this.state = 2640; - this.match(SqlBaseParser.FROM); + this.match(SparkSqlParser.FROM); this.state = 2641; localctx.srcStr = this.valueExpression(0); this.state = 2642; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 22: @@ -24436,31 +24436,31 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { this._ctx = localctx; _prevctx = localctx; this.state = 2644; - this.match(SqlBaseParser.OVERLAY); + this.match(SparkSqlParser.OVERLAY); this.state = 2645; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2646; localctx.input = this.valueExpression(0); this.state = 2647; - this.match(SqlBaseParser.PLACING); + this.match(SparkSqlParser.PLACING); this.state = 2648; localctx.replace = this.valueExpression(0); this.state = 2649; - this.match(SqlBaseParser.FROM); + this.match(SparkSqlParser.FROM); this.state = 2650; localctx.position = this.valueExpression(0); this.state = 2653; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.FOR) { + if(_la===SparkSqlParser.FOR) { this.state = 2651; - this.match(SqlBaseParser.FOR); + this.match(SparkSqlParser.FOR); this.state = 2652; localctx.length = this.valueExpression(0); } this.state = 2655; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -24481,29 +24481,29 @@ SqlBaseParser.prototype.primaryExpression = function(_p) { case 1: localctx = new SubscriptContext(this, new PrimaryExpressionContext(this, _parentctx, _parentState)); localctx.value = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_primaryExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_primaryExpression); this.state = 2659; if (!( this.precpred(this._ctx, 8))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 8)"); } this.state = 2660; - this.match(SqlBaseParser.T__8); + this.match(SparkSqlParser.T__8); this.state = 2661; localctx.index = this.valueExpression(0); this.state = 2662; - this.match(SqlBaseParser.T__9); + this.match(SparkSqlParser.T__9); break; case 2: localctx = new DereferenceContext(this, new PrimaryExpressionContext(this, _parentctx, _parentState)); localctx.base = _prevctx; - this.pushNewRecursionContext(localctx, _startState, SqlBaseParser.RULE_primaryExpression); + this.pushNewRecursionContext(localctx, _startState, SparkSqlParser.RULE_primaryExpression); this.state = 2664; if (!( this.precpred(this._ctx, 6))) { throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)"); } this.state = 2665; - this.match(SqlBaseParser.T__4); + this.match(SparkSqlParser.T__4); this.state = 2666; localctx.fieldName = this.identifier(); break; @@ -24539,7 +24539,7 @@ function ConstantContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_constant; + this.ruleIndex = SparkSqlParser.RULE_constant; return this; } @@ -24562,25 +24562,25 @@ function NullLiteralContext(parser, ctx) { NullLiteralContext.prototype = Object.create(ConstantContext.prototype); NullLiteralContext.prototype.constructor = NullLiteralContext; -SqlBaseParser.NullLiteralContext = NullLiteralContext; +SparkSqlParser.NullLiteralContext = NullLiteralContext; NullLiteralContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; NullLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNullLiteral(this); } }; NullLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNullLiteral(this); } }; NullLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNullLiteral(this); } else { return visitor.visitChildren(this); @@ -24597,33 +24597,33 @@ function StringLiteralContext(parser, ctx) { StringLiteralContext.prototype = Object.create(ConstantContext.prototype); StringLiteralContext.prototype.constructor = StringLiteralContext; -SqlBaseParser.StringLiteralContext = StringLiteralContext; +SparkSqlParser.StringLiteralContext = StringLiteralContext; StringLiteralContext.prototype.STRING = function(i) { if(i===undefined) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.STRING); + return this.getTokens(SparkSqlParser.STRING); } else { - return this.getToken(SqlBaseParser.STRING, i); + return this.getToken(SparkSqlParser.STRING, i); } }; StringLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterStringLiteral(this); } }; StringLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitStringLiteral(this); } }; StringLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitStringLiteral(this); } else { return visitor.visitChildren(this); @@ -24640,29 +24640,29 @@ function TypeConstructorContext(parser, ctx) { TypeConstructorContext.prototype = Object.create(ConstantContext.prototype); TypeConstructorContext.prototype.constructor = TypeConstructorContext; -SqlBaseParser.TypeConstructorContext = TypeConstructorContext; +SparkSqlParser.TypeConstructorContext = TypeConstructorContext; TypeConstructorContext.prototype.identifier = function() { return this.getTypedRuleContext(IdentifierContext,0); }; TypeConstructorContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; TypeConstructorContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTypeConstructor(this); } }; TypeConstructorContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTypeConstructor(this); } }; TypeConstructorContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTypeConstructor(this); } else { return visitor.visitChildren(this); @@ -24679,25 +24679,25 @@ function IntervalLiteralContext(parser, ctx) { IntervalLiteralContext.prototype = Object.create(ConstantContext.prototype); IntervalLiteralContext.prototype.constructor = IntervalLiteralContext; -SqlBaseParser.IntervalLiteralContext = IntervalLiteralContext; +SparkSqlParser.IntervalLiteralContext = IntervalLiteralContext; IntervalLiteralContext.prototype.interval = function() { return this.getTypedRuleContext(IntervalContext,0); }; IntervalLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIntervalLiteral(this); } }; IntervalLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIntervalLiteral(this); } }; IntervalLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIntervalLiteral(this); } else { return visitor.visitChildren(this); @@ -24714,25 +24714,25 @@ function NumericLiteralContext(parser, ctx) { NumericLiteralContext.prototype = Object.create(ConstantContext.prototype); NumericLiteralContext.prototype.constructor = NumericLiteralContext; -SqlBaseParser.NumericLiteralContext = NumericLiteralContext; +SparkSqlParser.NumericLiteralContext = NumericLiteralContext; NumericLiteralContext.prototype.number = function() { return this.getTypedRuleContext(NumberContext,0); }; NumericLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNumericLiteral(this); } }; NumericLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNumericLiteral(this); } }; NumericLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNumericLiteral(this); } else { return visitor.visitChildren(this); @@ -24749,25 +24749,25 @@ function BooleanLiteralContext(parser, ctx) { BooleanLiteralContext.prototype = Object.create(ConstantContext.prototype); BooleanLiteralContext.prototype.constructor = BooleanLiteralContext; -SqlBaseParser.BooleanLiteralContext = BooleanLiteralContext; +SparkSqlParser.BooleanLiteralContext = BooleanLiteralContext; BooleanLiteralContext.prototype.booleanValue = function() { return this.getTypedRuleContext(BooleanValueContext,0); }; BooleanLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterBooleanLiteral(this); } }; BooleanLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitBooleanLiteral(this); } }; BooleanLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitBooleanLiteral(this); } else { return visitor.visitChildren(this); @@ -24776,12 +24776,12 @@ BooleanLiteralContext.prototype.accept = function(visitor) { -SqlBaseParser.ConstantContext = ConstantContext; +SparkSqlParser.ConstantContext = ConstantContext; -SqlBaseParser.prototype.constant = function() { +SparkSqlParser.prototype.constant = function() { var localctx = new ConstantContext(this, this._ctx, this.state); - this.enterRule(localctx, 196, SqlBaseParser.RULE_constant); + this.enterRule(localctx, 196, SparkSqlParser.RULE_constant); try { this.state = 2684; this._errHandler.sync(this); @@ -24791,7 +24791,7 @@ SqlBaseParser.prototype.constant = function() { localctx = new NullLiteralContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 2672; - this.match(SqlBaseParser.NULL); + this.match(SparkSqlParser.NULL); break; case 2: @@ -24807,7 +24807,7 @@ SqlBaseParser.prototype.constant = function() { this.state = 2674; this.identifier(); this.state = 2675; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; case 4: @@ -24834,7 +24834,7 @@ SqlBaseParser.prototype.constant = function() { switch (_alt) { case 1: this.state = 2679; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; default: throw new antlr4.error.NoViableAltException(this); @@ -24870,7 +24870,7 @@ function ComparisonOperatorContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_comparisonOperator; + this.ruleIndex = SparkSqlParser.RULE_comparisonOperator; return this; } @@ -24878,51 +24878,51 @@ ComparisonOperatorContext.prototype = Object.create(antlr4.ParserRuleContext.pro ComparisonOperatorContext.prototype.constructor = ComparisonOperatorContext; ComparisonOperatorContext.prototype.EQ = function() { - return this.getToken(SqlBaseParser.EQ, 0); + return this.getToken(SparkSqlParser.EQ, 0); }; ComparisonOperatorContext.prototype.NEQ = function() { - return this.getToken(SqlBaseParser.NEQ, 0); + return this.getToken(SparkSqlParser.NEQ, 0); }; ComparisonOperatorContext.prototype.NEQJ = function() { - return this.getToken(SqlBaseParser.NEQJ, 0); + return this.getToken(SparkSqlParser.NEQJ, 0); }; ComparisonOperatorContext.prototype.LT = function() { - return this.getToken(SqlBaseParser.LT, 0); + return this.getToken(SparkSqlParser.LT, 0); }; ComparisonOperatorContext.prototype.LTE = function() { - return this.getToken(SqlBaseParser.LTE, 0); + return this.getToken(SparkSqlParser.LTE, 0); }; ComparisonOperatorContext.prototype.GT = function() { - return this.getToken(SqlBaseParser.GT, 0); + return this.getToken(SparkSqlParser.GT, 0); }; ComparisonOperatorContext.prototype.GTE = function() { - return this.getToken(SqlBaseParser.GTE, 0); + return this.getToken(SparkSqlParser.GTE, 0); }; ComparisonOperatorContext.prototype.NSEQ = function() { - return this.getToken(SqlBaseParser.NSEQ, 0); + return this.getToken(SparkSqlParser.NSEQ, 0); }; ComparisonOperatorContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterComparisonOperator(this); } }; ComparisonOperatorContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitComparisonOperator(this); } }; ComparisonOperatorContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitComparisonOperator(this); } else { return visitor.visitChildren(this); @@ -24932,18 +24932,18 @@ ComparisonOperatorContext.prototype.accept = function(visitor) { -SqlBaseParser.ComparisonOperatorContext = ComparisonOperatorContext; +SparkSqlParser.ComparisonOperatorContext = ComparisonOperatorContext; -SqlBaseParser.prototype.comparisonOperator = function() { +SparkSqlParser.prototype.comparisonOperator = function() { var localctx = new ComparisonOperatorContext(this, this._ctx, this.state); - this.enterRule(localctx, 198, SqlBaseParser.RULE_comparisonOperator); + this.enterRule(localctx, 198, SparkSqlParser.RULE_comparisonOperator); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2686; _la = this._input.LA(1); - if(!(((((_la - 261)) & ~0x1f) == 0 && ((1 << (_la - 261)) & ((1 << (SqlBaseParser.EQ - 261)) | (1 << (SqlBaseParser.NSEQ - 261)) | (1 << (SqlBaseParser.NEQ - 261)) | (1 << (SqlBaseParser.NEQJ - 261)) | (1 << (SqlBaseParser.LT - 261)) | (1 << (SqlBaseParser.LTE - 261)) | (1 << (SqlBaseParser.GT - 261)) | (1 << (SqlBaseParser.GTE - 261)))) !== 0))) { + if(!(((((_la - 261)) & ~0x1f) == 0 && ((1 << (_la - 261)) & ((1 << (SparkSqlParser.EQ - 261)) | (1 << (SparkSqlParser.NSEQ - 261)) | (1 << (SparkSqlParser.NEQ - 261)) | (1 << (SparkSqlParser.NEQJ - 261)) | (1 << (SparkSqlParser.LT - 261)) | (1 << (SparkSqlParser.LTE - 261)) | (1 << (SparkSqlParser.GT - 261)) | (1 << (SparkSqlParser.GTE - 261)))) !== 0))) { this._errHandler.recoverInline(this); } else { @@ -24974,7 +24974,7 @@ function ArithmeticOperatorContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_arithmeticOperator; + this.ruleIndex = SparkSqlParser.RULE_arithmeticOperator; return this; } @@ -24982,63 +24982,63 @@ ArithmeticOperatorContext.prototype = Object.create(antlr4.ParserRuleContext.pro ArithmeticOperatorContext.prototype.constructor = ArithmeticOperatorContext; ArithmeticOperatorContext.prototype.PLUS = function() { - return this.getToken(SqlBaseParser.PLUS, 0); + return this.getToken(SparkSqlParser.PLUS, 0); }; ArithmeticOperatorContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; ArithmeticOperatorContext.prototype.ASTERISK = function() { - return this.getToken(SqlBaseParser.ASTERISK, 0); + return this.getToken(SparkSqlParser.ASTERISK, 0); }; ArithmeticOperatorContext.prototype.SLASH = function() { - return this.getToken(SqlBaseParser.SLASH, 0); + return this.getToken(SparkSqlParser.SLASH, 0); }; ArithmeticOperatorContext.prototype.PERCENT = function() { - return this.getToken(SqlBaseParser.PERCENT, 0); + return this.getToken(SparkSqlParser.PERCENT, 0); }; ArithmeticOperatorContext.prototype.DIV = function() { - return this.getToken(SqlBaseParser.DIV, 0); + return this.getToken(SparkSqlParser.DIV, 0); }; ArithmeticOperatorContext.prototype.TILDE = function() { - return this.getToken(SqlBaseParser.TILDE, 0); + return this.getToken(SparkSqlParser.TILDE, 0); }; ArithmeticOperatorContext.prototype.AMPERSAND = function() { - return this.getToken(SqlBaseParser.AMPERSAND, 0); + return this.getToken(SparkSqlParser.AMPERSAND, 0); }; ArithmeticOperatorContext.prototype.PIPE = function() { - return this.getToken(SqlBaseParser.PIPE, 0); + return this.getToken(SparkSqlParser.PIPE, 0); }; ArithmeticOperatorContext.prototype.CONCAT_PIPE = function() { - return this.getToken(SqlBaseParser.CONCAT_PIPE, 0); + return this.getToken(SparkSqlParser.CONCAT_PIPE, 0); }; ArithmeticOperatorContext.prototype.HAT = function() { - return this.getToken(SqlBaseParser.HAT, 0); + return this.getToken(SparkSqlParser.HAT, 0); }; ArithmeticOperatorContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterArithmeticOperator(this); } }; ArithmeticOperatorContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitArithmeticOperator(this); } }; ArithmeticOperatorContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitArithmeticOperator(this); } else { return visitor.visitChildren(this); @@ -25048,18 +25048,18 @@ ArithmeticOperatorContext.prototype.accept = function(visitor) { -SqlBaseParser.ArithmeticOperatorContext = ArithmeticOperatorContext; +SparkSqlParser.ArithmeticOperatorContext = ArithmeticOperatorContext; -SqlBaseParser.prototype.arithmeticOperator = function() { +SparkSqlParser.prototype.arithmeticOperator = function() { var localctx = new ArithmeticOperatorContext(this, this._ctx, this.state); - this.enterRule(localctx, 200, SqlBaseParser.RULE_arithmeticOperator); + this.enterRule(localctx, 200, SparkSqlParser.RULE_arithmeticOperator); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2688; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DIV || ((((_la - 269)) & ~0x1f) == 0 && ((1 << (_la - 269)) & ((1 << (SqlBaseParser.PLUS - 269)) | (1 << (SqlBaseParser.MINUS - 269)) | (1 << (SqlBaseParser.ASTERISK - 269)) | (1 << (SqlBaseParser.SLASH - 269)) | (1 << (SqlBaseParser.PERCENT - 269)) | (1 << (SqlBaseParser.TILDE - 269)) | (1 << (SqlBaseParser.AMPERSAND - 269)) | (1 << (SqlBaseParser.PIPE - 269)) | (1 << (SqlBaseParser.CONCAT_PIPE - 269)) | (1 << (SqlBaseParser.HAT - 269)))) !== 0))) { + if(!(_la===SparkSqlParser.DIV || ((((_la - 269)) & ~0x1f) == 0 && ((1 << (_la - 269)) & ((1 << (SparkSqlParser.PLUS - 269)) | (1 << (SparkSqlParser.MINUS - 269)) | (1 << (SparkSqlParser.ASTERISK - 269)) | (1 << (SparkSqlParser.SLASH - 269)) | (1 << (SparkSqlParser.PERCENT - 269)) | (1 << (SparkSqlParser.TILDE - 269)) | (1 << (SparkSqlParser.AMPERSAND - 269)) | (1 << (SparkSqlParser.PIPE - 269)) | (1 << (SparkSqlParser.CONCAT_PIPE - 269)) | (1 << (SparkSqlParser.HAT - 269)))) !== 0))) { this._errHandler.recoverInline(this); } else { @@ -25090,7 +25090,7 @@ function PredicateOperatorContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_predicateOperator; + this.ruleIndex = SparkSqlParser.RULE_predicateOperator; return this; } @@ -25098,35 +25098,35 @@ PredicateOperatorContext.prototype = Object.create(antlr4.ParserRuleContext.prot PredicateOperatorContext.prototype.constructor = PredicateOperatorContext; PredicateOperatorContext.prototype.OR = function() { - return this.getToken(SqlBaseParser.OR, 0); + return this.getToken(SparkSqlParser.OR, 0); }; PredicateOperatorContext.prototype.AND = function() { - return this.getToken(SqlBaseParser.AND, 0); + return this.getToken(SparkSqlParser.AND, 0); }; PredicateOperatorContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; PredicateOperatorContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; PredicateOperatorContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPredicateOperator(this); } }; PredicateOperatorContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPredicateOperator(this); } }; PredicateOperatorContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPredicateOperator(this); } else { return visitor.visitChildren(this); @@ -25136,18 +25136,18 @@ PredicateOperatorContext.prototype.accept = function(visitor) { -SqlBaseParser.PredicateOperatorContext = PredicateOperatorContext; +SparkSqlParser.PredicateOperatorContext = PredicateOperatorContext; -SqlBaseParser.prototype.predicateOperator = function() { +SparkSqlParser.prototype.predicateOperator = function() { var localctx = new PredicateOperatorContext(this, this._ctx, this.state); - this.enterRule(localctx, 202, SqlBaseParser.RULE_predicateOperator); + this.enterRule(localctx, 202, SparkSqlParser.RULE_predicateOperator); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2690; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.AND || _la===SqlBaseParser.IN || _la===SqlBaseParser.NOT || _la===SqlBaseParser.OR)) { + if(!(_la===SparkSqlParser.AND || _la===SparkSqlParser.IN || _la===SparkSqlParser.NOT || _la===SparkSqlParser.OR)) { this._errHandler.recoverInline(this); } else { @@ -25178,7 +25178,7 @@ function BooleanValueContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_booleanValue; + this.ruleIndex = SparkSqlParser.RULE_booleanValue; return this; } @@ -25186,27 +25186,27 @@ BooleanValueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype BooleanValueContext.prototype.constructor = BooleanValueContext; BooleanValueContext.prototype.TRUE = function() { - return this.getToken(SqlBaseParser.TRUE, 0); + return this.getToken(SparkSqlParser.TRUE, 0); }; BooleanValueContext.prototype.FALSE = function() { - return this.getToken(SqlBaseParser.FALSE, 0); + return this.getToken(SparkSqlParser.FALSE, 0); }; BooleanValueContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterBooleanValue(this); } }; BooleanValueContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitBooleanValue(this); } }; BooleanValueContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitBooleanValue(this); } else { return visitor.visitChildren(this); @@ -25216,18 +25216,18 @@ BooleanValueContext.prototype.accept = function(visitor) { -SqlBaseParser.BooleanValueContext = BooleanValueContext; +SparkSqlParser.BooleanValueContext = BooleanValueContext; -SqlBaseParser.prototype.booleanValue = function() { +SparkSqlParser.prototype.booleanValue = function() { var localctx = new BooleanValueContext(this, this._ctx, this.state); - this.enterRule(localctx, 204, SqlBaseParser.RULE_booleanValue); + this.enterRule(localctx, 204, SparkSqlParser.RULE_booleanValue); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2692; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FALSE || _la===SqlBaseParser.TRUE)) { + if(!(_la===SparkSqlParser.FALSE || _la===SparkSqlParser.TRUE)) { this._errHandler.recoverInline(this); } else { @@ -25258,7 +25258,7 @@ function IntervalContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_interval; + this.ruleIndex = SparkSqlParser.RULE_interval; return this; } @@ -25266,7 +25266,7 @@ IntervalContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); IntervalContext.prototype.constructor = IntervalContext; IntervalContext.prototype.INTERVAL = function() { - return this.getToken(SqlBaseParser.INTERVAL, 0); + return this.getToken(SparkSqlParser.INTERVAL, 0); }; IntervalContext.prototype.errorCapturingMultiUnitsInterval = function() { @@ -25278,19 +25278,19 @@ IntervalContext.prototype.errorCapturingUnitToUnitInterval = function() { }; IntervalContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterInterval(this); } }; IntervalContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitInterval(this); } }; IntervalContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitInterval(this); } else { return visitor.visitChildren(this); @@ -25300,16 +25300,16 @@ IntervalContext.prototype.accept = function(visitor) { -SqlBaseParser.IntervalContext = IntervalContext; +SparkSqlParser.IntervalContext = IntervalContext; -SqlBaseParser.prototype.interval = function() { +SparkSqlParser.prototype.interval = function() { var localctx = new IntervalContext(this, this._ctx, this.state); - this.enterRule(localctx, 206, SqlBaseParser.RULE_interval); + this.enterRule(localctx, 206, SparkSqlParser.RULE_interval); try { this.enterOuterAlt(localctx, 1); this.state = 2694; - this.match(SqlBaseParser.INTERVAL); + this.match(SparkSqlParser.INTERVAL); this.state = 2697; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,341,this._ctx); @@ -25346,7 +25346,7 @@ function ErrorCapturingMultiUnitsIntervalContext(parser, parent, invokingState) } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_errorCapturingMultiUnitsInterval; + this.ruleIndex = SparkSqlParser.RULE_errorCapturingMultiUnitsInterval; return this; } @@ -25362,19 +25362,19 @@ ErrorCapturingMultiUnitsIntervalContext.prototype.unitToUnitInterval = function( }; ErrorCapturingMultiUnitsIntervalContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterErrorCapturingMultiUnitsInterval(this); } }; ErrorCapturingMultiUnitsIntervalContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitErrorCapturingMultiUnitsInterval(this); } }; ErrorCapturingMultiUnitsIntervalContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitErrorCapturingMultiUnitsInterval(this); } else { return visitor.visitChildren(this); @@ -25384,12 +25384,12 @@ ErrorCapturingMultiUnitsIntervalContext.prototype.accept = function(visitor) { -SqlBaseParser.ErrorCapturingMultiUnitsIntervalContext = ErrorCapturingMultiUnitsIntervalContext; +SparkSqlParser.ErrorCapturingMultiUnitsIntervalContext = ErrorCapturingMultiUnitsIntervalContext; -SqlBaseParser.prototype.errorCapturingMultiUnitsInterval = function() { +SparkSqlParser.prototype.errorCapturingMultiUnitsInterval = function() { var localctx = new ErrorCapturingMultiUnitsIntervalContext(this, this._ctx, this.state); - this.enterRule(localctx, 208, SqlBaseParser.RULE_errorCapturingMultiUnitsInterval); + this.enterRule(localctx, 208, SparkSqlParser.RULE_errorCapturingMultiUnitsInterval); try { this.enterOuterAlt(localctx, 1); this.state = 2699; @@ -25426,7 +25426,7 @@ function MultiUnitsIntervalContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_multiUnitsInterval; + this.ruleIndex = SparkSqlParser.RULE_multiUnitsInterval; this._identifier = null; // IdentifierContext this.unit = []; // of IdentifierContexts return this; @@ -25458,19 +25458,19 @@ MultiUnitsIntervalContext.prototype.identifier = function(i) { }; MultiUnitsIntervalContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterMultiUnitsInterval(this); } }; MultiUnitsIntervalContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitMultiUnitsInterval(this); } }; MultiUnitsIntervalContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitMultiUnitsInterval(this); } else { return visitor.visitChildren(this); @@ -25480,12 +25480,12 @@ MultiUnitsIntervalContext.prototype.accept = function(visitor) { -SqlBaseParser.MultiUnitsIntervalContext = MultiUnitsIntervalContext; +SparkSqlParser.MultiUnitsIntervalContext = MultiUnitsIntervalContext; -SqlBaseParser.prototype.multiUnitsInterval = function() { +SparkSqlParser.prototype.multiUnitsInterval = function() { var localctx = new MultiUnitsIntervalContext(this, this._ctx, this.state); - this.enterRule(localctx, 210, SqlBaseParser.RULE_multiUnitsInterval); + this.enterRule(localctx, 210, SparkSqlParser.RULE_multiUnitsInterval); try { this.enterOuterAlt(localctx, 1); this.state = 2706; @@ -25531,7 +25531,7 @@ function ErrorCapturingUnitToUnitIntervalContext(parser, parent, invokingState) } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_errorCapturingUnitToUnitInterval; + this.ruleIndex = SparkSqlParser.RULE_errorCapturingUnitToUnitInterval; this.body = null; // UnitToUnitIntervalContext this.error1 = null; // MultiUnitsIntervalContext this.error2 = null; // UnitToUnitIntervalContext @@ -25557,19 +25557,19 @@ ErrorCapturingUnitToUnitIntervalContext.prototype.multiUnitsInterval = function( }; ErrorCapturingUnitToUnitIntervalContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterErrorCapturingUnitToUnitInterval(this); } }; ErrorCapturingUnitToUnitIntervalContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitErrorCapturingUnitToUnitInterval(this); } }; ErrorCapturingUnitToUnitIntervalContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitErrorCapturingUnitToUnitInterval(this); } else { return visitor.visitChildren(this); @@ -25579,12 +25579,12 @@ ErrorCapturingUnitToUnitIntervalContext.prototype.accept = function(visitor) { -SqlBaseParser.ErrorCapturingUnitToUnitIntervalContext = ErrorCapturingUnitToUnitIntervalContext; +SparkSqlParser.ErrorCapturingUnitToUnitIntervalContext = ErrorCapturingUnitToUnitIntervalContext; -SqlBaseParser.prototype.errorCapturingUnitToUnitInterval = function() { +SparkSqlParser.prototype.errorCapturingUnitToUnitInterval = function() { var localctx = new ErrorCapturingUnitToUnitIntervalContext(this, this._ctx, this.state); - this.enterRule(localctx, 212, SqlBaseParser.RULE_errorCapturingUnitToUnitInterval); + this.enterRule(localctx, 212, SparkSqlParser.RULE_errorCapturingUnitToUnitInterval); try { this.enterOuterAlt(localctx, 1); this.state = 2710; @@ -25625,7 +25625,7 @@ function UnitToUnitIntervalContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_unitToUnitInterval; + this.ruleIndex = SparkSqlParser.RULE_unitToUnitInterval; this.value = null; // IntervalValueContext this.from = null; // IdentifierContext this.to = null; // IdentifierContext @@ -25636,7 +25636,7 @@ UnitToUnitIntervalContext.prototype = Object.create(antlr4.ParserRuleContext.pro UnitToUnitIntervalContext.prototype.constructor = UnitToUnitIntervalContext; UnitToUnitIntervalContext.prototype.TO = function() { - return this.getToken(SqlBaseParser.TO, 0); + return this.getToken(SparkSqlParser.TO, 0); }; UnitToUnitIntervalContext.prototype.intervalValue = function() { @@ -25655,19 +25655,19 @@ UnitToUnitIntervalContext.prototype.identifier = function(i) { }; UnitToUnitIntervalContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterUnitToUnitInterval(this); } }; UnitToUnitIntervalContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitUnitToUnitInterval(this); } }; UnitToUnitIntervalContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitUnitToUnitInterval(this); } else { return visitor.visitChildren(this); @@ -25677,12 +25677,12 @@ UnitToUnitIntervalContext.prototype.accept = function(visitor) { -SqlBaseParser.UnitToUnitIntervalContext = UnitToUnitIntervalContext; +SparkSqlParser.UnitToUnitIntervalContext = UnitToUnitIntervalContext; -SqlBaseParser.prototype.unitToUnitInterval = function() { +SparkSqlParser.prototype.unitToUnitInterval = function() { var localctx = new UnitToUnitIntervalContext(this, this._ctx, this.state); - this.enterRule(localctx, 214, SqlBaseParser.RULE_unitToUnitInterval); + this.enterRule(localctx, 214, SparkSqlParser.RULE_unitToUnitInterval); try { this.enterOuterAlt(localctx, 1); this.state = 2715; @@ -25690,7 +25690,7 @@ SqlBaseParser.prototype.unitToUnitInterval = function() { this.state = 2716; localctx.from = this.identifier(); this.state = 2717; - this.match(SqlBaseParser.TO); + this.match(SparkSqlParser.TO); this.state = 2718; localctx.to = this.identifier(); } catch (re) { @@ -25717,7 +25717,7 @@ function IntervalValueContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_intervalValue; + this.ruleIndex = SparkSqlParser.RULE_intervalValue; return this; } @@ -25725,39 +25725,39 @@ IntervalValueContext.prototype = Object.create(antlr4.ParserRuleContext.prototyp IntervalValueContext.prototype.constructor = IntervalValueContext; IntervalValueContext.prototype.INTEGER_VALUE = function() { - return this.getToken(SqlBaseParser.INTEGER_VALUE, 0); + return this.getToken(SparkSqlParser.INTEGER_VALUE, 0); }; IntervalValueContext.prototype.DECIMAL_VALUE = function() { - return this.getToken(SqlBaseParser.DECIMAL_VALUE, 0); + return this.getToken(SparkSqlParser.DECIMAL_VALUE, 0); }; IntervalValueContext.prototype.PLUS = function() { - return this.getToken(SqlBaseParser.PLUS, 0); + return this.getToken(SparkSqlParser.PLUS, 0); }; IntervalValueContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; IntervalValueContext.prototype.STRING = function() { - return this.getToken(SqlBaseParser.STRING, 0); + return this.getToken(SparkSqlParser.STRING, 0); }; IntervalValueContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIntervalValue(this); } }; IntervalValueContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIntervalValue(this); } }; IntervalValueContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIntervalValue(this); } else { return visitor.visitChildren(this); @@ -25767,29 +25767,29 @@ IntervalValueContext.prototype.accept = function(visitor) { -SqlBaseParser.IntervalValueContext = IntervalValueContext; +SparkSqlParser.IntervalValueContext = IntervalValueContext; -SqlBaseParser.prototype.intervalValue = function() { +SparkSqlParser.prototype.intervalValue = function() { var localctx = new IntervalValueContext(this, this._ctx, this.state); - this.enterRule(localctx, 216, SqlBaseParser.RULE_intervalValue); + this.enterRule(localctx, 216, SparkSqlParser.RULE_intervalValue); var _la = 0; // Token type try { this.state = 2725; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.PLUS: - case SqlBaseParser.MINUS: - case SqlBaseParser.INTEGER_VALUE: - case SqlBaseParser.DECIMAL_VALUE: + case SparkSqlParser.PLUS: + case SparkSqlParser.MINUS: + case SparkSqlParser.INTEGER_VALUE: + case SparkSqlParser.DECIMAL_VALUE: this.enterOuterAlt(localctx, 1); this.state = 2721; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.PLUS || _la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.PLUS || _la===SparkSqlParser.MINUS) { this.state = 2720; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.PLUS || _la===SqlBaseParser.MINUS)) { + if(!(_la===SparkSqlParser.PLUS || _la===SparkSqlParser.MINUS)) { this._errHandler.recoverInline(this); } else { @@ -25800,7 +25800,7 @@ SqlBaseParser.prototype.intervalValue = function() { this.state = 2723; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.INTEGER_VALUE || _la===SqlBaseParser.DECIMAL_VALUE)) { + if(!(_la===SparkSqlParser.INTEGER_VALUE || _la===SparkSqlParser.DECIMAL_VALUE)) { this._errHandler.recoverInline(this); } else { @@ -25808,10 +25808,10 @@ SqlBaseParser.prototype.intervalValue = function() { this.consume(); } break; - case SqlBaseParser.STRING: + case SparkSqlParser.STRING: this.enterOuterAlt(localctx, 2); this.state = 2724; - this.match(SqlBaseParser.STRING); + this.match(SparkSqlParser.STRING); break; default: throw new antlr4.error.NoViableAltException(this); @@ -25840,7 +25840,7 @@ function ColPositionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_colPosition; + this.ruleIndex = SparkSqlParser.RULE_colPosition; this.position = null; // Token this.afterCol = null; // ErrorCapturingIdentifierContext return this; @@ -25850,11 +25850,11 @@ ColPositionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) ColPositionContext.prototype.constructor = ColPositionContext; ColPositionContext.prototype.FIRST = function() { - return this.getToken(SqlBaseParser.FIRST, 0); + return this.getToken(SparkSqlParser.FIRST, 0); }; ColPositionContext.prototype.AFTER = function() { - return this.getToken(SqlBaseParser.AFTER, 0); + return this.getToken(SparkSqlParser.AFTER, 0); }; ColPositionContext.prototype.errorCapturingIdentifier = function() { @@ -25862,19 +25862,19 @@ ColPositionContext.prototype.errorCapturingIdentifier = function() { }; ColPositionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterColPosition(this); } }; ColPositionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitColPosition(this); } }; ColPositionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitColPosition(this); } else { return visitor.visitChildren(this); @@ -25884,25 +25884,25 @@ ColPositionContext.prototype.accept = function(visitor) { -SqlBaseParser.ColPositionContext = ColPositionContext; +SparkSqlParser.ColPositionContext = ColPositionContext; -SqlBaseParser.prototype.colPosition = function() { +SparkSqlParser.prototype.colPosition = function() { var localctx = new ColPositionContext(this, this._ctx, this.state); - this.enterRule(localctx, 218, SqlBaseParser.RULE_colPosition); + this.enterRule(localctx, 218, SparkSqlParser.RULE_colPosition); try { this.state = 2730; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.FIRST: + case SparkSqlParser.FIRST: this.enterOuterAlt(localctx, 1); this.state = 2727; - localctx.position = this.match(SqlBaseParser.FIRST); + localctx.position = this.match(SparkSqlParser.FIRST); break; - case SqlBaseParser.AFTER: + case SparkSqlParser.AFTER: this.enterOuterAlt(localctx, 2); this.state = 2728; - localctx.position = this.match(SqlBaseParser.AFTER); + localctx.position = this.match(SparkSqlParser.AFTER); this.state = 2729; localctx.afterCol = this.errorCapturingIdentifier(); break; @@ -25933,7 +25933,7 @@ function DataTypeContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_dataType; + this.ruleIndex = SparkSqlParser.RULE_dataType; return this; } @@ -25957,10 +25957,10 @@ function ComplexDataTypeContext(parser, ctx) { ComplexDataTypeContext.prototype = Object.create(DataTypeContext.prototype); ComplexDataTypeContext.prototype.constructor = ComplexDataTypeContext; -SqlBaseParser.ComplexDataTypeContext = ComplexDataTypeContext; +SparkSqlParser.ComplexDataTypeContext = ComplexDataTypeContext; ComplexDataTypeContext.prototype.LT = function() { - return this.getToken(SqlBaseParser.LT, 0); + return this.getToken(SparkSqlParser.LT, 0); }; ComplexDataTypeContext.prototype.dataType = function(i) { @@ -25975,42 +25975,42 @@ ComplexDataTypeContext.prototype.dataType = function(i) { }; ComplexDataTypeContext.prototype.GT = function() { - return this.getToken(SqlBaseParser.GT, 0); + return this.getToken(SparkSqlParser.GT, 0); }; ComplexDataTypeContext.prototype.ARRAY = function() { - return this.getToken(SqlBaseParser.ARRAY, 0); + return this.getToken(SparkSqlParser.ARRAY, 0); }; ComplexDataTypeContext.prototype.MAP = function() { - return this.getToken(SqlBaseParser.MAP, 0); + return this.getToken(SparkSqlParser.MAP, 0); }; ComplexDataTypeContext.prototype.STRUCT = function() { - return this.getToken(SqlBaseParser.STRUCT, 0); + return this.getToken(SparkSqlParser.STRUCT, 0); }; ComplexDataTypeContext.prototype.NEQ = function() { - return this.getToken(SqlBaseParser.NEQ, 0); + return this.getToken(SparkSqlParser.NEQ, 0); }; ComplexDataTypeContext.prototype.complexColTypeList = function() { return this.getTypedRuleContext(ComplexColTypeListContext,0); }; ComplexDataTypeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterComplexDataType(this); } }; ComplexDataTypeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitComplexDataType(this); } }; ComplexDataTypeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitComplexDataType(this); } else { return visitor.visitChildren(this); @@ -26027,7 +26027,7 @@ function PrimitiveDataTypeContext(parser, ctx) { PrimitiveDataTypeContext.prototype = Object.create(DataTypeContext.prototype); PrimitiveDataTypeContext.prototype.constructor = PrimitiveDataTypeContext; -SqlBaseParser.PrimitiveDataTypeContext = PrimitiveDataTypeContext; +SparkSqlParser.PrimitiveDataTypeContext = PrimitiveDataTypeContext; PrimitiveDataTypeContext.prototype.identifier = function() { return this.getTypedRuleContext(IdentifierContext,0); @@ -26038,26 +26038,26 @@ PrimitiveDataTypeContext.prototype.INTEGER_VALUE = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.INTEGER_VALUE); + return this.getTokens(SparkSqlParser.INTEGER_VALUE); } else { - return this.getToken(SqlBaseParser.INTEGER_VALUE, i); + return this.getToken(SparkSqlParser.INTEGER_VALUE, i); } }; PrimitiveDataTypeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterPrimitiveDataType(this); } }; PrimitiveDataTypeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitPrimitiveDataType(this); } }; PrimitiveDataTypeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitPrimitiveDataType(this); } else { return visitor.visitChildren(this); @@ -26066,12 +26066,12 @@ PrimitiveDataTypeContext.prototype.accept = function(visitor) { -SqlBaseParser.DataTypeContext = DataTypeContext; +SparkSqlParser.DataTypeContext = DataTypeContext; -SqlBaseParser.prototype.dataType = function() { +SparkSqlParser.prototype.dataType = function() { var localctx = new DataTypeContext(this, this._ctx, this.state); - this.enterRule(localctx, 220, SqlBaseParser.RULE_dataType); + this.enterRule(localctx, 220, SparkSqlParser.RULE_dataType); var _la = 0; // Token type try { this.state = 2766; @@ -26082,43 +26082,43 @@ SqlBaseParser.prototype.dataType = function() { localctx = new ComplexDataTypeContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 2732; - localctx.complex = this.match(SqlBaseParser.ARRAY); + localctx.complex = this.match(SparkSqlParser.ARRAY); this.state = 2733; - this.match(SqlBaseParser.LT); + this.match(SparkSqlParser.LT); this.state = 2734; this.dataType(); this.state = 2735; - this.match(SqlBaseParser.GT); + this.match(SparkSqlParser.GT); break; case 2: localctx = new ComplexDataTypeContext(this, localctx); this.enterOuterAlt(localctx, 2); this.state = 2737; - localctx.complex = this.match(SqlBaseParser.MAP); + localctx.complex = this.match(SparkSqlParser.MAP); this.state = 2738; - this.match(SqlBaseParser.LT); + this.match(SparkSqlParser.LT); this.state = 2739; this.dataType(); this.state = 2740; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2741; this.dataType(); this.state = 2742; - this.match(SqlBaseParser.GT); + this.match(SparkSqlParser.GT); break; case 3: localctx = new ComplexDataTypeContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 2744; - localctx.complex = this.match(SqlBaseParser.STRUCT); + localctx.complex = this.match(SparkSqlParser.STRUCT); this.state = 2751; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.LT: + case SparkSqlParser.LT: this.state = 2745; - this.match(SqlBaseParser.LT); + this.match(SparkSqlParser.LT); this.state = 2747; this._errHandler.sync(this); var la_ = this._interp.adaptivePredict(this._input,348,this._ctx); @@ -26128,11 +26128,11 @@ SqlBaseParser.prototype.dataType = function() { } this.state = 2749; - this.match(SqlBaseParser.GT); + this.match(SparkSqlParser.GT); break; - case SqlBaseParser.NEQ: + case SparkSqlParser.NEQ: this.state = 2750; - this.match(SqlBaseParser.NEQ); + this.match(SparkSqlParser.NEQ); break; default: throw new antlr4.error.NoViableAltException(this); @@ -26149,23 +26149,23 @@ SqlBaseParser.prototype.dataType = function() { var la_ = this._interp.adaptivePredict(this._input,351,this._ctx); if(la_===1) { this.state = 2754; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2755; - this.match(SqlBaseParser.INTEGER_VALUE); + this.match(SparkSqlParser.INTEGER_VALUE); this.state = 2760; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2756; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2757; - this.match(SqlBaseParser.INTEGER_VALUE); + this.match(SparkSqlParser.INTEGER_VALUE); this.state = 2762; this._errHandler.sync(this); _la = this._input.LA(1); } this.state = 2763; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); } break; @@ -26195,7 +26195,7 @@ function QualifiedColTypeWithPositionListContext(parser, parent, invokingState) } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_qualifiedColTypeWithPositionList; + this.ruleIndex = SparkSqlParser.RULE_qualifiedColTypeWithPositionList; return this; } @@ -26214,19 +26214,19 @@ QualifiedColTypeWithPositionListContext.prototype.qualifiedColTypeWithPosition = }; QualifiedColTypeWithPositionListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQualifiedColTypeWithPositionList(this); } }; QualifiedColTypeWithPositionListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQualifiedColTypeWithPositionList(this); } }; QualifiedColTypeWithPositionListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQualifiedColTypeWithPositionList(this); } else { return visitor.visitChildren(this); @@ -26236,12 +26236,12 @@ QualifiedColTypeWithPositionListContext.prototype.accept = function(visitor) { -SqlBaseParser.QualifiedColTypeWithPositionListContext = QualifiedColTypeWithPositionListContext; +SparkSqlParser.QualifiedColTypeWithPositionListContext = QualifiedColTypeWithPositionListContext; -SqlBaseParser.prototype.qualifiedColTypeWithPositionList = function() { +SparkSqlParser.prototype.qualifiedColTypeWithPositionList = function() { var localctx = new QualifiedColTypeWithPositionListContext(this, this._ctx, this.state); - this.enterRule(localctx, 222, SqlBaseParser.RULE_qualifiedColTypeWithPositionList); + this.enterRule(localctx, 222, SparkSqlParser.RULE_qualifiedColTypeWithPositionList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -26250,9 +26250,9 @@ SqlBaseParser.prototype.qualifiedColTypeWithPositionList = function() { this.state = 2773; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2769; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2770; this.qualifiedColTypeWithPosition(); this.state = 2775; @@ -26283,7 +26283,7 @@ function QualifiedColTypeWithPositionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_qualifiedColTypeWithPosition; + this.ruleIndex = SparkSqlParser.RULE_qualifiedColTypeWithPosition; this.name = null; // MultipartIdentifierContext return this; } @@ -26300,11 +26300,11 @@ QualifiedColTypeWithPositionContext.prototype.multipartIdentifier = function() { }; QualifiedColTypeWithPositionContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; QualifiedColTypeWithPositionContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; QualifiedColTypeWithPositionContext.prototype.commentSpec = function() { @@ -26316,19 +26316,19 @@ QualifiedColTypeWithPositionContext.prototype.colPosition = function() { }; QualifiedColTypeWithPositionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQualifiedColTypeWithPosition(this); } }; QualifiedColTypeWithPositionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQualifiedColTypeWithPosition(this); } }; QualifiedColTypeWithPositionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQualifiedColTypeWithPosition(this); } else { return visitor.visitChildren(this); @@ -26338,12 +26338,12 @@ QualifiedColTypeWithPositionContext.prototype.accept = function(visitor) { -SqlBaseParser.QualifiedColTypeWithPositionContext = QualifiedColTypeWithPositionContext; +SparkSqlParser.QualifiedColTypeWithPositionContext = QualifiedColTypeWithPositionContext; -SqlBaseParser.prototype.qualifiedColTypeWithPosition = function() { +SparkSqlParser.prototype.qualifiedColTypeWithPosition = function() { var localctx = new QualifiedColTypeWithPositionContext(this, this._ctx, this.state); - this.enterRule(localctx, 224, SqlBaseParser.RULE_qualifiedColTypeWithPosition); + this.enterRule(localctx, 224, SparkSqlParser.RULE_qualifiedColTypeWithPosition); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -26354,17 +26354,17 @@ SqlBaseParser.prototype.qualifiedColTypeWithPosition = function() { this.state = 2780; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2778; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 2779; - this.match(SqlBaseParser.NULL); + this.match(SparkSqlParser.NULL); } this.state = 2783; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.COMMENT) { + if(_la===SparkSqlParser.COMMENT) { this.state = 2782; this.commentSpec(); } @@ -26372,7 +26372,7 @@ SqlBaseParser.prototype.qualifiedColTypeWithPosition = function() { this.state = 2786; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.AFTER || _la===SqlBaseParser.FIRST) { + if(_la===SparkSqlParser.AFTER || _la===SparkSqlParser.FIRST) { this.state = 2785; this.colPosition(); } @@ -26401,7 +26401,7 @@ function ColTypeListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_colTypeList; + this.ruleIndex = SparkSqlParser.RULE_colTypeList; return this; } @@ -26420,19 +26420,19 @@ ColTypeListContext.prototype.colType = function(i) { }; ColTypeListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterColTypeList(this); } }; ColTypeListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitColTypeList(this); } }; ColTypeListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitColTypeList(this); } else { return visitor.visitChildren(this); @@ -26442,12 +26442,12 @@ ColTypeListContext.prototype.accept = function(visitor) { -SqlBaseParser.ColTypeListContext = ColTypeListContext; +SparkSqlParser.ColTypeListContext = ColTypeListContext; -SqlBaseParser.prototype.colTypeList = function() { +SparkSqlParser.prototype.colTypeList = function() { var localctx = new ColTypeListContext(this, this._ctx, this.state); - this.enterRule(localctx, 226, SqlBaseParser.RULE_colTypeList); + this.enterRule(localctx, 226, SparkSqlParser.RULE_colTypeList); try { this.enterOuterAlt(localctx, 1); this.state = 2788; @@ -26458,7 +26458,7 @@ SqlBaseParser.prototype.colTypeList = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2789; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2790; this.colType(); } @@ -26491,7 +26491,7 @@ function ColTypeContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_colType; + this.ruleIndex = SparkSqlParser.RULE_colType; this.colName = null; // ErrorCapturingIdentifierContext return this; } @@ -26508,11 +26508,11 @@ ColTypeContext.prototype.errorCapturingIdentifier = function() { }; ColTypeContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; ColTypeContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; ColTypeContext.prototype.commentSpec = function() { @@ -26520,19 +26520,19 @@ ColTypeContext.prototype.commentSpec = function() { }; ColTypeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterColType(this); } }; ColTypeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitColType(this); } }; ColTypeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitColType(this); } else { return visitor.visitChildren(this); @@ -26542,12 +26542,12 @@ ColTypeContext.prototype.accept = function(visitor) { -SqlBaseParser.ColTypeContext = ColTypeContext; +SparkSqlParser.ColTypeContext = ColTypeContext; -SqlBaseParser.prototype.colType = function() { +SparkSqlParser.prototype.colType = function() { var localctx = new ColTypeContext(this, this._ctx, this.state); - this.enterRule(localctx, 228, SqlBaseParser.RULE_colType); + this.enterRule(localctx, 228, SparkSqlParser.RULE_colType); try { this.enterOuterAlt(localctx, 1); this.state = 2796; @@ -26559,9 +26559,9 @@ SqlBaseParser.prototype.colType = function() { var la_ = this._interp.adaptivePredict(this._input,358,this._ctx); if(la_===1) { this.state = 2798; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 2799; - this.match(SqlBaseParser.NULL); + this.match(SparkSqlParser.NULL); } this.state = 2803; @@ -26596,7 +26596,7 @@ function ComplexColTypeListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_complexColTypeList; + this.ruleIndex = SparkSqlParser.RULE_complexColTypeList; return this; } @@ -26615,19 +26615,19 @@ ComplexColTypeListContext.prototype.complexColType = function(i) { }; ComplexColTypeListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterComplexColTypeList(this); } }; ComplexColTypeListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitComplexColTypeList(this); } }; ComplexColTypeListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitComplexColTypeList(this); } else { return visitor.visitChildren(this); @@ -26637,12 +26637,12 @@ ComplexColTypeListContext.prototype.accept = function(visitor) { -SqlBaseParser.ComplexColTypeListContext = ComplexColTypeListContext; +SparkSqlParser.ComplexColTypeListContext = ComplexColTypeListContext; -SqlBaseParser.prototype.complexColTypeList = function() { +SparkSqlParser.prototype.complexColTypeList = function() { var localctx = new ComplexColTypeListContext(this, this._ctx, this.state); - this.enterRule(localctx, 230, SqlBaseParser.RULE_complexColTypeList); + this.enterRule(localctx, 230, SparkSqlParser.RULE_complexColTypeList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -26651,9 +26651,9 @@ SqlBaseParser.prototype.complexColTypeList = function() { this.state = 2810; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2806; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2807; this.complexColType(); this.state = 2812; @@ -26684,7 +26684,7 @@ function ComplexColTypeContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_complexColType; + this.ruleIndex = SparkSqlParser.RULE_complexColType; return this; } @@ -26700,11 +26700,11 @@ ComplexColTypeContext.prototype.dataType = function() { }; ComplexColTypeContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; ComplexColTypeContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; ComplexColTypeContext.prototype.commentSpec = function() { @@ -26712,19 +26712,19 @@ ComplexColTypeContext.prototype.commentSpec = function() { }; ComplexColTypeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterComplexColType(this); } }; ComplexColTypeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitComplexColType(this); } }; ComplexColTypeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitComplexColType(this); } else { return visitor.visitChildren(this); @@ -26734,35 +26734,35 @@ ComplexColTypeContext.prototype.accept = function(visitor) { -SqlBaseParser.ComplexColTypeContext = ComplexColTypeContext; +SparkSqlParser.ComplexColTypeContext = ComplexColTypeContext; -SqlBaseParser.prototype.complexColType = function() { +SparkSqlParser.prototype.complexColType = function() { var localctx = new ComplexColTypeContext(this, this._ctx, this.state); - this.enterRule(localctx, 232, SqlBaseParser.RULE_complexColType); + this.enterRule(localctx, 232, SparkSqlParser.RULE_complexColType); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 2813; this.identifier(); this.state = 2814; - this.match(SqlBaseParser.T__10); + this.match(SparkSqlParser.T__10); this.state = 2815; this.dataType(); this.state = 2818; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.NOT) { + if(_la===SparkSqlParser.NOT) { this.state = 2816; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 2817; - this.match(SqlBaseParser.NULL); + this.match(SparkSqlParser.NULL); } this.state = 2821; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.COMMENT) { + if(_la===SparkSqlParser.COMMENT) { this.state = 2820; this.commentSpec(); } @@ -26791,7 +26791,7 @@ function WhenClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_whenClause; + this.ruleIndex = SparkSqlParser.RULE_whenClause; this.condition = null; // ExpressionContext this.result = null; // ExpressionContext return this; @@ -26801,11 +26801,11 @@ WhenClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); WhenClauseContext.prototype.constructor = WhenClauseContext; WhenClauseContext.prototype.WHEN = function() { - return this.getToken(SqlBaseParser.WHEN, 0); + return this.getToken(SparkSqlParser.WHEN, 0); }; WhenClauseContext.prototype.THEN = function() { - return this.getToken(SqlBaseParser.THEN, 0); + return this.getToken(SparkSqlParser.THEN, 0); }; WhenClauseContext.prototype.expression = function(i) { @@ -26820,19 +26820,19 @@ WhenClauseContext.prototype.expression = function(i) { }; WhenClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterWhenClause(this); } }; WhenClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitWhenClause(this); } }; WhenClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitWhenClause(this); } else { return visitor.visitChildren(this); @@ -26842,20 +26842,20 @@ WhenClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.WhenClauseContext = WhenClauseContext; +SparkSqlParser.WhenClauseContext = WhenClauseContext; -SqlBaseParser.prototype.whenClause = function() { +SparkSqlParser.prototype.whenClause = function() { var localctx = new WhenClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 234, SqlBaseParser.RULE_whenClause); + this.enterRule(localctx, 234, SparkSqlParser.RULE_whenClause); try { this.enterOuterAlt(localctx, 1); this.state = 2823; - this.match(SqlBaseParser.WHEN); + this.match(SparkSqlParser.WHEN); this.state = 2824; localctx.condition = this.expression(); this.state = 2825; - this.match(SqlBaseParser.THEN); + this.match(SparkSqlParser.THEN); this.state = 2826; localctx.result = this.expression(); } catch (re) { @@ -26882,7 +26882,7 @@ function WindowClauseContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_windowClause; + this.ruleIndex = SparkSqlParser.RULE_windowClause; return this; } @@ -26890,7 +26890,7 @@ WindowClauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype WindowClauseContext.prototype.constructor = WindowClauseContext; WindowClauseContext.prototype.WINDOW = function() { - return this.getToken(SqlBaseParser.WINDOW, 0); + return this.getToken(SparkSqlParser.WINDOW, 0); }; WindowClauseContext.prototype.namedWindow = function(i) { @@ -26905,19 +26905,19 @@ WindowClauseContext.prototype.namedWindow = function(i) { }; WindowClauseContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterWindowClause(this); } }; WindowClauseContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitWindowClause(this); } }; WindowClauseContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitWindowClause(this); } else { return visitor.visitChildren(this); @@ -26927,16 +26927,16 @@ WindowClauseContext.prototype.accept = function(visitor) { -SqlBaseParser.WindowClauseContext = WindowClauseContext; +SparkSqlParser.WindowClauseContext = WindowClauseContext; -SqlBaseParser.prototype.windowClause = function() { +SparkSqlParser.prototype.windowClause = function() { var localctx = new WindowClauseContext(this, this._ctx, this.state); - this.enterRule(localctx, 236, SqlBaseParser.RULE_windowClause); + this.enterRule(localctx, 236, SparkSqlParser.RULE_windowClause); try { this.enterOuterAlt(localctx, 1); this.state = 2828; - this.match(SqlBaseParser.WINDOW); + this.match(SparkSqlParser.WINDOW); this.state = 2829; this.namedWindow(); this.state = 2834; @@ -26945,7 +26945,7 @@ SqlBaseParser.prototype.windowClause = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2830; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2831; this.namedWindow(); } @@ -26978,7 +26978,7 @@ function NamedWindowContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_namedWindow; + this.ruleIndex = SparkSqlParser.RULE_namedWindow; this.name = null; // ErrorCapturingIdentifierContext return this; } @@ -26987,7 +26987,7 @@ NamedWindowContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) NamedWindowContext.prototype.constructor = NamedWindowContext; NamedWindowContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; NamedWindowContext.prototype.windowSpec = function() { @@ -26999,19 +26999,19 @@ NamedWindowContext.prototype.errorCapturingIdentifier = function() { }; NamedWindowContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNamedWindow(this); } }; NamedWindowContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNamedWindow(this); } }; NamedWindowContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNamedWindow(this); } else { return visitor.visitChildren(this); @@ -27021,18 +27021,18 @@ NamedWindowContext.prototype.accept = function(visitor) { -SqlBaseParser.NamedWindowContext = NamedWindowContext; +SparkSqlParser.NamedWindowContext = NamedWindowContext; -SqlBaseParser.prototype.namedWindow = function() { +SparkSqlParser.prototype.namedWindow = function() { var localctx = new NamedWindowContext(this, this._ctx, this.state); - this.enterRule(localctx, 238, SqlBaseParser.RULE_namedWindow); + this.enterRule(localctx, 238, SparkSqlParser.RULE_namedWindow); try { this.enterOuterAlt(localctx, 1); this.state = 2837; localctx.name = this.errorCapturingIdentifier(); this.state = 2838; - this.match(SqlBaseParser.AS); + this.match(SparkSqlParser.AS); this.state = 2839; this.windowSpec(); } catch (re) { @@ -27059,7 +27059,7 @@ function WindowSpecContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_windowSpec; + this.ruleIndex = SparkSqlParser.RULE_windowSpec; return this; } @@ -27083,25 +27083,25 @@ function WindowRefContext(parser, ctx) { WindowRefContext.prototype = Object.create(WindowSpecContext.prototype); WindowRefContext.prototype.constructor = WindowRefContext; -SqlBaseParser.WindowRefContext = WindowRefContext; +SparkSqlParser.WindowRefContext = WindowRefContext; WindowRefContext.prototype.errorCapturingIdentifier = function() { return this.getTypedRuleContext(ErrorCapturingIdentifierContext,0); }; WindowRefContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterWindowRef(this); } }; WindowRefContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitWindowRef(this); } }; WindowRefContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitWindowRef(this); } else { return visitor.visitChildren(this); @@ -27120,10 +27120,10 @@ function WindowDefContext(parser, ctx) { WindowDefContext.prototype = Object.create(WindowSpecContext.prototype); WindowDefContext.prototype.constructor = WindowDefContext; -SqlBaseParser.WindowDefContext = WindowDefContext; +SparkSqlParser.WindowDefContext = WindowDefContext; WindowDefContext.prototype.CLUSTER = function() { - return this.getToken(SqlBaseParser.CLUSTER, 0); + return this.getToken(SparkSqlParser.CLUSTER, 0); }; WindowDefContext.prototype.BY = function(i) { @@ -27131,9 +27131,9 @@ WindowDefContext.prototype.BY = function(i) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.BY); + return this.getTokens(SparkSqlParser.BY); } else { - return this.getToken(SqlBaseParser.BY, i); + return this.getToken(SparkSqlParser.BY, i); } }; @@ -27165,34 +27165,34 @@ WindowDefContext.prototype.sortItem = function(i) { }; WindowDefContext.prototype.PARTITION = function() { - return this.getToken(SqlBaseParser.PARTITION, 0); + return this.getToken(SparkSqlParser.PARTITION, 0); }; WindowDefContext.prototype.DISTRIBUTE = function() { - return this.getToken(SqlBaseParser.DISTRIBUTE, 0); + return this.getToken(SparkSqlParser.DISTRIBUTE, 0); }; WindowDefContext.prototype.ORDER = function() { - return this.getToken(SqlBaseParser.ORDER, 0); + return this.getToken(SparkSqlParser.ORDER, 0); }; WindowDefContext.prototype.SORT = function() { - return this.getToken(SqlBaseParser.SORT, 0); + return this.getToken(SparkSqlParser.SORT, 0); }; WindowDefContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterWindowDef(this); } }; WindowDefContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitWindowDef(this); } }; WindowDefContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitWindowDef(this); } else { return visitor.visitChildren(this); @@ -27201,12 +27201,12 @@ WindowDefContext.prototype.accept = function(visitor) { -SqlBaseParser.WindowSpecContext = WindowSpecContext; +SparkSqlParser.WindowSpecContext = WindowSpecContext; -SqlBaseParser.prototype.windowSpec = function() { +SparkSqlParser.prototype.windowSpec = function() { var localctx = new WindowSpecContext(this, this._ctx, this.state); - this.enterRule(localctx, 240, SqlBaseParser.RULE_windowSpec); + this.enterRule(localctx, 240, SparkSqlParser.RULE_windowSpec); var _la = 0; // Token type try { this.state = 2887; @@ -27224,35 +27224,35 @@ SqlBaseParser.prototype.windowSpec = function() { localctx = new WindowRefContext(this, localctx); this.enterOuterAlt(localctx, 2); this.state = 2842; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2843; localctx.name = this.errorCapturingIdentifier(); this.state = 2844; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; case 3: localctx = new WindowDefContext(this, localctx); this.enterOuterAlt(localctx, 3); this.state = 2846; - this.match(SqlBaseParser.T__1); + this.match(SparkSqlParser.T__1); this.state = 2881; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.CLUSTER: + case SparkSqlParser.CLUSTER: this.state = 2847; - this.match(SqlBaseParser.CLUSTER); + this.match(SparkSqlParser.CLUSTER); this.state = 2848; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2849; localctx._expression = this.expression(); localctx.partition.push(localctx._expression); this.state = 2854; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2850; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2851; localctx._expression = this.expression(); localctx.partition.push(localctx._expression); @@ -27261,20 +27261,20 @@ SqlBaseParser.prototype.windowSpec = function() { _la = this._input.LA(1); } break; - case SqlBaseParser.T__2: - case SqlBaseParser.DISTRIBUTE: - case SqlBaseParser.ORDER: - case SqlBaseParser.PARTITION: - case SqlBaseParser.RANGE: - case SqlBaseParser.ROWS: - case SqlBaseParser.SORT: + case SparkSqlParser.T__2: + case SparkSqlParser.DISTRIBUTE: + case SparkSqlParser.ORDER: + case SparkSqlParser.PARTITION: + case SparkSqlParser.RANGE: + case SparkSqlParser.ROWS: + case SparkSqlParser.SORT: this.state = 2867; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.DISTRIBUTE || _la===SqlBaseParser.PARTITION) { + if(_la===SparkSqlParser.DISTRIBUTE || _la===SparkSqlParser.PARTITION) { this.state = 2857; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DISTRIBUTE || _la===SqlBaseParser.PARTITION)) { + if(!(_la===SparkSqlParser.DISTRIBUTE || _la===SparkSqlParser.PARTITION)) { this._errHandler.recoverInline(this); } else { @@ -27282,16 +27282,16 @@ SqlBaseParser.prototype.windowSpec = function() { this.consume(); } this.state = 2858; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2859; localctx._expression = this.expression(); localctx.partition.push(localctx._expression); this.state = 2864; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2860; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2861; localctx._expression = this.expression(); localctx.partition.push(localctx._expression); @@ -27304,10 +27304,10 @@ SqlBaseParser.prototype.windowSpec = function() { this.state = 2879; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.ORDER || _la===SqlBaseParser.SORT) { + if(_la===SparkSqlParser.ORDER || _la===SparkSqlParser.SORT) { this.state = 2869; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ORDER || _la===SqlBaseParser.SORT)) { + if(!(_la===SparkSqlParser.ORDER || _la===SparkSqlParser.SORT)) { this._errHandler.recoverInline(this); } else { @@ -27315,15 +27315,15 @@ SqlBaseParser.prototype.windowSpec = function() { this.consume(); } this.state = 2870; - this.match(SqlBaseParser.BY); + this.match(SparkSqlParser.BY); this.state = 2871; this.sortItem(); this.state = 2876; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2872; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2873; this.sortItem(); this.state = 2878; @@ -27339,13 +27339,13 @@ SqlBaseParser.prototype.windowSpec = function() { this.state = 2884; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.RANGE || _la===SqlBaseParser.ROWS) { + if(_la===SparkSqlParser.RANGE || _la===SparkSqlParser.ROWS) { this.state = 2883; this.windowFrame(); } this.state = 2886; - this.match(SqlBaseParser.T__2); + this.match(SparkSqlParser.T__2); break; } @@ -27373,7 +27373,7 @@ function WindowFrameContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_windowFrame; + this.ruleIndex = SparkSqlParser.RULE_windowFrame; this.frameType = null; // Token this.start = null; // FrameBoundContext this.end = null; // FrameBoundContext @@ -27384,7 +27384,7 @@ WindowFrameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) WindowFrameContext.prototype.constructor = WindowFrameContext; WindowFrameContext.prototype.RANGE = function() { - return this.getToken(SqlBaseParser.RANGE, 0); + return this.getToken(SparkSqlParser.RANGE, 0); }; WindowFrameContext.prototype.frameBound = function(i) { @@ -27399,31 +27399,31 @@ WindowFrameContext.prototype.frameBound = function(i) { }; WindowFrameContext.prototype.ROWS = function() { - return this.getToken(SqlBaseParser.ROWS, 0); + return this.getToken(SparkSqlParser.ROWS, 0); }; WindowFrameContext.prototype.BETWEEN = function() { - return this.getToken(SqlBaseParser.BETWEEN, 0); + return this.getToken(SparkSqlParser.BETWEEN, 0); }; WindowFrameContext.prototype.AND = function() { - return this.getToken(SqlBaseParser.AND, 0); + return this.getToken(SparkSqlParser.AND, 0); }; WindowFrameContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterWindowFrame(this); } }; WindowFrameContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitWindowFrame(this); } }; WindowFrameContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitWindowFrame(this); } else { return visitor.visitChildren(this); @@ -27433,12 +27433,12 @@ WindowFrameContext.prototype.accept = function(visitor) { -SqlBaseParser.WindowFrameContext = WindowFrameContext; +SparkSqlParser.WindowFrameContext = WindowFrameContext; -SqlBaseParser.prototype.windowFrame = function() { +SparkSqlParser.prototype.windowFrame = function() { var localctx = new WindowFrameContext(this, this._ctx, this.state); - this.enterRule(localctx, 242, SqlBaseParser.RULE_windowFrame); + this.enterRule(localctx, 242, SparkSqlParser.RULE_windowFrame); try { this.state = 2905; this._errHandler.sync(this); @@ -27447,7 +27447,7 @@ SqlBaseParser.prototype.windowFrame = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 2889; - localctx.frameType = this.match(SqlBaseParser.RANGE); + localctx.frameType = this.match(SparkSqlParser.RANGE); this.state = 2890; localctx.start = this.frameBound(); break; @@ -27455,7 +27455,7 @@ SqlBaseParser.prototype.windowFrame = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 2891; - localctx.frameType = this.match(SqlBaseParser.ROWS); + localctx.frameType = this.match(SparkSqlParser.ROWS); this.state = 2892; localctx.start = this.frameBound(); break; @@ -27463,13 +27463,13 @@ SqlBaseParser.prototype.windowFrame = function() { case 3: this.enterOuterAlt(localctx, 3); this.state = 2893; - localctx.frameType = this.match(SqlBaseParser.RANGE); + localctx.frameType = this.match(SparkSqlParser.RANGE); this.state = 2894; - this.match(SqlBaseParser.BETWEEN); + this.match(SparkSqlParser.BETWEEN); this.state = 2895; localctx.start = this.frameBound(); this.state = 2896; - this.match(SqlBaseParser.AND); + this.match(SparkSqlParser.AND); this.state = 2897; localctx.end = this.frameBound(); break; @@ -27477,13 +27477,13 @@ SqlBaseParser.prototype.windowFrame = function() { case 4: this.enterOuterAlt(localctx, 4); this.state = 2899; - localctx.frameType = this.match(SqlBaseParser.ROWS); + localctx.frameType = this.match(SparkSqlParser.ROWS); this.state = 2900; - this.match(SqlBaseParser.BETWEEN); + this.match(SparkSqlParser.BETWEEN); this.state = 2901; localctx.start = this.frameBound(); this.state = 2902; - this.match(SqlBaseParser.AND); + this.match(SparkSqlParser.AND); this.state = 2903; localctx.end = this.frameBound(); break; @@ -27513,7 +27513,7 @@ function FrameBoundContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_frameBound; + this.ruleIndex = SparkSqlParser.RULE_frameBound; this.boundType = null; // Token return this; } @@ -27522,23 +27522,23 @@ FrameBoundContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); FrameBoundContext.prototype.constructor = FrameBoundContext; FrameBoundContext.prototype.UNBOUNDED = function() { - return this.getToken(SqlBaseParser.UNBOUNDED, 0); + return this.getToken(SparkSqlParser.UNBOUNDED, 0); }; FrameBoundContext.prototype.PRECEDING = function() { - return this.getToken(SqlBaseParser.PRECEDING, 0); + return this.getToken(SparkSqlParser.PRECEDING, 0); }; FrameBoundContext.prototype.FOLLOWING = function() { - return this.getToken(SqlBaseParser.FOLLOWING, 0); + return this.getToken(SparkSqlParser.FOLLOWING, 0); }; FrameBoundContext.prototype.ROW = function() { - return this.getToken(SqlBaseParser.ROW, 0); + return this.getToken(SparkSqlParser.ROW, 0); }; FrameBoundContext.prototype.CURRENT = function() { - return this.getToken(SqlBaseParser.CURRENT, 0); + return this.getToken(SparkSqlParser.CURRENT, 0); }; FrameBoundContext.prototype.expression = function() { @@ -27546,19 +27546,19 @@ FrameBoundContext.prototype.expression = function() { }; FrameBoundContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFrameBound(this); } }; FrameBoundContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFrameBound(this); } }; FrameBoundContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFrameBound(this); } else { return visitor.visitChildren(this); @@ -27568,12 +27568,12 @@ FrameBoundContext.prototype.accept = function(visitor) { -SqlBaseParser.FrameBoundContext = FrameBoundContext; +SparkSqlParser.FrameBoundContext = FrameBoundContext; -SqlBaseParser.prototype.frameBound = function() { +SparkSqlParser.prototype.frameBound = function() { var localctx = new FrameBoundContext(this, this._ctx, this.state); - this.enterRule(localctx, 244, SqlBaseParser.RULE_frameBound); + this.enterRule(localctx, 244, SparkSqlParser.RULE_frameBound); var _la = 0; // Token type try { this.state = 2914; @@ -27583,11 +27583,11 @@ SqlBaseParser.prototype.frameBound = function() { case 1: this.enterOuterAlt(localctx, 1); this.state = 2907; - this.match(SqlBaseParser.UNBOUNDED); + this.match(SparkSqlParser.UNBOUNDED); this.state = 2908; localctx.boundType = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FOLLOWING || _la===SqlBaseParser.PRECEDING)) { + if(!(_la===SparkSqlParser.FOLLOWING || _la===SparkSqlParser.PRECEDING)) { localctx.boundType = this._errHandler.recoverInline(this); } else { @@ -27599,9 +27599,9 @@ SqlBaseParser.prototype.frameBound = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 2909; - localctx.boundType = this.match(SqlBaseParser.CURRENT); + localctx.boundType = this.match(SparkSqlParser.CURRENT); this.state = 2910; - this.match(SqlBaseParser.ROW); + this.match(SparkSqlParser.ROW); break; case 3: @@ -27611,7 +27611,7 @@ SqlBaseParser.prototype.frameBound = function() { this.state = 2912; localctx.boundType = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.FOLLOWING || _la===SqlBaseParser.PRECEDING)) { + if(!(_la===SparkSqlParser.FOLLOWING || _la===SparkSqlParser.PRECEDING)) { localctx.boundType = this._errHandler.recoverInline(this); } else { @@ -27645,7 +27645,7 @@ function QualifiedNameListContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_qualifiedNameList; + this.ruleIndex = SparkSqlParser.RULE_qualifiedNameList; return this; } @@ -27664,19 +27664,19 @@ QualifiedNameListContext.prototype.qualifiedName = function(i) { }; QualifiedNameListContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQualifiedNameList(this); } }; QualifiedNameListContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQualifiedNameList(this); } }; QualifiedNameListContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQualifiedNameList(this); } else { return visitor.visitChildren(this); @@ -27686,12 +27686,12 @@ QualifiedNameListContext.prototype.accept = function(visitor) { -SqlBaseParser.QualifiedNameListContext = QualifiedNameListContext; +SparkSqlParser.QualifiedNameListContext = QualifiedNameListContext; -SqlBaseParser.prototype.qualifiedNameList = function() { +SparkSqlParser.prototype.qualifiedNameList = function() { var localctx = new QualifiedNameListContext(this, this._ctx, this.state); - this.enterRule(localctx, 246, SqlBaseParser.RULE_qualifiedNameList); + this.enterRule(localctx, 246, SparkSqlParser.RULE_qualifiedNameList); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); @@ -27700,9 +27700,9 @@ SqlBaseParser.prototype.qualifiedNameList = function() { this.state = 2921; this._errHandler.sync(this); _la = this._input.LA(1); - while(_la===SqlBaseParser.T__3) { + while(_la===SparkSqlParser.T__3) { this.state = 2917; - this.match(SqlBaseParser.T__3); + this.match(SparkSqlParser.T__3); this.state = 2918; this.qualifiedName(); this.state = 2923; @@ -27733,7 +27733,7 @@ function FunctionNameContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_functionName; + this.ruleIndex = SparkSqlParser.RULE_functionName; return this; } @@ -27745,31 +27745,31 @@ FunctionNameContext.prototype.qualifiedName = function() { }; FunctionNameContext.prototype.FILTER = function() { - return this.getToken(SqlBaseParser.FILTER, 0); + return this.getToken(SparkSqlParser.FILTER, 0); }; FunctionNameContext.prototype.LEFT = function() { - return this.getToken(SqlBaseParser.LEFT, 0); + return this.getToken(SparkSqlParser.LEFT, 0); }; FunctionNameContext.prototype.RIGHT = function() { - return this.getToken(SqlBaseParser.RIGHT, 0); + return this.getToken(SparkSqlParser.RIGHT, 0); }; FunctionNameContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFunctionName(this); } }; FunctionNameContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFunctionName(this); } }; FunctionNameContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFunctionName(this); } else { return visitor.visitChildren(this); @@ -27779,12 +27779,12 @@ FunctionNameContext.prototype.accept = function(visitor) { -SqlBaseParser.FunctionNameContext = FunctionNameContext; +SparkSqlParser.FunctionNameContext = FunctionNameContext; -SqlBaseParser.prototype.functionName = function() { +SparkSqlParser.prototype.functionName = function() { var localctx = new FunctionNameContext(this, this._ctx, this.state); - this.enterRule(localctx, 248, SqlBaseParser.RULE_functionName); + this.enterRule(localctx, 248, SparkSqlParser.RULE_functionName); try { this.state = 2928; this._errHandler.sync(this); @@ -27799,19 +27799,19 @@ SqlBaseParser.prototype.functionName = function() { case 2: this.enterOuterAlt(localctx, 2); this.state = 2925; - this.match(SqlBaseParser.FILTER); + this.match(SparkSqlParser.FILTER); break; case 3: this.enterOuterAlt(localctx, 3); this.state = 2926; - this.match(SqlBaseParser.LEFT); + this.match(SparkSqlParser.LEFT); break; case 4: this.enterOuterAlt(localctx, 4); this.state = 2927; - this.match(SqlBaseParser.RIGHT); + this.match(SparkSqlParser.RIGHT); break; } @@ -27839,7 +27839,7 @@ function QualifiedNameContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_qualifiedName; + this.ruleIndex = SparkSqlParser.RULE_qualifiedName; return this; } @@ -27858,19 +27858,19 @@ QualifiedNameContext.prototype.identifier = function(i) { }; QualifiedNameContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQualifiedName(this); } }; QualifiedNameContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQualifiedName(this); } }; QualifiedNameContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQualifiedName(this); } else { return visitor.visitChildren(this); @@ -27880,12 +27880,12 @@ QualifiedNameContext.prototype.accept = function(visitor) { -SqlBaseParser.QualifiedNameContext = QualifiedNameContext; +SparkSqlParser.QualifiedNameContext = QualifiedNameContext; -SqlBaseParser.prototype.qualifiedName = function() { +SparkSqlParser.prototype.qualifiedName = function() { var localctx = new QualifiedNameContext(this, this._ctx, this.state); - this.enterRule(localctx, 250, SqlBaseParser.RULE_qualifiedName); + this.enterRule(localctx, 250, SparkSqlParser.RULE_qualifiedName); try { this.enterOuterAlt(localctx, 1); this.state = 2930; @@ -27896,7 +27896,7 @@ SqlBaseParser.prototype.qualifiedName = function() { while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { if(_alt===1) { this.state = 2931; - this.match(SqlBaseParser.T__4); + this.match(SparkSqlParser.T__4); this.state = 2932; this.identifier(); } @@ -27929,7 +27929,7 @@ function ErrorCapturingIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_errorCapturingIdentifier; + this.ruleIndex = SparkSqlParser.RULE_errorCapturingIdentifier; return this; } @@ -27945,19 +27945,19 @@ ErrorCapturingIdentifierContext.prototype.errorCapturingIdentifierExtra = functi }; ErrorCapturingIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterErrorCapturingIdentifier(this); } }; ErrorCapturingIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitErrorCapturingIdentifier(this); } }; ErrorCapturingIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitErrorCapturingIdentifier(this); } else { return visitor.visitChildren(this); @@ -27967,12 +27967,12 @@ ErrorCapturingIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.ErrorCapturingIdentifierContext = ErrorCapturingIdentifierContext; +SparkSqlParser.ErrorCapturingIdentifierContext = ErrorCapturingIdentifierContext; -SqlBaseParser.prototype.errorCapturingIdentifier = function() { +SparkSqlParser.prototype.errorCapturingIdentifier = function() { var localctx = new ErrorCapturingIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 252, SqlBaseParser.RULE_errorCapturingIdentifier); + this.enterRule(localctx, 252, SparkSqlParser.RULE_errorCapturingIdentifier); try { this.enterOuterAlt(localctx, 1); this.state = 2938; @@ -28003,7 +28003,7 @@ function ErrorCapturingIdentifierExtraContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_errorCapturingIdentifierExtra; + this.ruleIndex = SparkSqlParser.RULE_errorCapturingIdentifierExtra; return this; } @@ -28026,16 +28026,16 @@ function ErrorIdentContext(parser, ctx) { ErrorIdentContext.prototype = Object.create(ErrorCapturingIdentifierExtraContext.prototype); ErrorIdentContext.prototype.constructor = ErrorIdentContext; -SqlBaseParser.ErrorIdentContext = ErrorIdentContext; +SparkSqlParser.ErrorIdentContext = ErrorIdentContext; ErrorIdentContext.prototype.MINUS = function(i) { if(i===undefined) { i = null; } if(i===null) { - return this.getTokens(SqlBaseParser.MINUS); + return this.getTokens(SparkSqlParser.MINUS); } else { - return this.getToken(SqlBaseParser.MINUS, i); + return this.getToken(SparkSqlParser.MINUS, i); } }; @@ -28051,19 +28051,19 @@ ErrorIdentContext.prototype.identifier = function(i) { } }; ErrorIdentContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterErrorIdent(this); } }; ErrorIdentContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitErrorIdent(this); } }; ErrorIdentContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitErrorIdent(this); } else { return visitor.visitChildren(this); @@ -28080,22 +28080,22 @@ function RealIdentContext(parser, ctx) { RealIdentContext.prototype = Object.create(ErrorCapturingIdentifierExtraContext.prototype); RealIdentContext.prototype.constructor = RealIdentContext; -SqlBaseParser.RealIdentContext = RealIdentContext; +SparkSqlParser.RealIdentContext = RealIdentContext; RealIdentContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterRealIdent(this); } }; RealIdentContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitRealIdent(this); } }; RealIdentContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitRealIdent(this); } else { return visitor.visitChildren(this); @@ -28104,12 +28104,12 @@ RealIdentContext.prototype.accept = function(visitor) { -SqlBaseParser.ErrorCapturingIdentifierExtraContext = ErrorCapturingIdentifierExtraContext; +SparkSqlParser.ErrorCapturingIdentifierExtraContext = ErrorCapturingIdentifierExtraContext; -SqlBaseParser.prototype.errorCapturingIdentifierExtra = function() { +SparkSqlParser.prototype.errorCapturingIdentifierExtra = function() { var localctx = new ErrorCapturingIdentifierExtraContext(this, this._ctx, this.state); - this.enterRule(localctx, 254, SqlBaseParser.RULE_errorCapturingIdentifierExtra); + this.enterRule(localctx, 254, SparkSqlParser.RULE_errorCapturingIdentifierExtra); try { this.state = 2948; this._errHandler.sync(this); @@ -28125,7 +28125,7 @@ SqlBaseParser.prototype.errorCapturingIdentifierExtra = function() { switch (_alt) { case 1: this.state = 2941; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); this.state = 2942; this.identifier(); break; @@ -28169,7 +28169,7 @@ function IdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_identifier; + this.ruleIndex = SparkSqlParser.RULE_identifier; return this; } @@ -28185,19 +28185,19 @@ IdentifierContext.prototype.strictNonReserved = function() { }; IdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIdentifier(this); } }; IdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIdentifier(this); } }; IdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIdentifier(this); } else { return visitor.visitChildren(this); @@ -28207,12 +28207,12 @@ IdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.IdentifierContext = IdentifierContext; +SparkSqlParser.IdentifierContext = IdentifierContext; -SqlBaseParser.prototype.identifier = function() { +SparkSqlParser.prototype.identifier = function() { var localctx = new IdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 256, SqlBaseParser.RULE_identifier); + this.enterRule(localctx, 256, SparkSqlParser.RULE_identifier); try { this.state = 2953; this._errHandler.sync(this); @@ -28259,7 +28259,7 @@ function StrictIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_strictIdentifier; + this.ruleIndex = SparkSqlParser.RULE_strictIdentifier; return this; } @@ -28282,25 +28282,25 @@ function QuotedIdentifierAlternativeContext(parser, ctx) { QuotedIdentifierAlternativeContext.prototype = Object.create(StrictIdentifierContext.prototype); QuotedIdentifierAlternativeContext.prototype.constructor = QuotedIdentifierAlternativeContext; -SqlBaseParser.QuotedIdentifierAlternativeContext = QuotedIdentifierAlternativeContext; +SparkSqlParser.QuotedIdentifierAlternativeContext = QuotedIdentifierAlternativeContext; QuotedIdentifierAlternativeContext.prototype.quotedIdentifier = function() { return this.getTypedRuleContext(QuotedIdentifierContext,0); }; QuotedIdentifierAlternativeContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQuotedIdentifierAlternative(this); } }; QuotedIdentifierAlternativeContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQuotedIdentifierAlternative(this); } }; QuotedIdentifierAlternativeContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQuotedIdentifierAlternative(this); } else { return visitor.visitChildren(this); @@ -28317,10 +28317,10 @@ function UnquotedIdentifierContext(parser, ctx) { UnquotedIdentifierContext.prototype = Object.create(StrictIdentifierContext.prototype); UnquotedIdentifierContext.prototype.constructor = UnquotedIdentifierContext; -SqlBaseParser.UnquotedIdentifierContext = UnquotedIdentifierContext; +SparkSqlParser.UnquotedIdentifierContext = UnquotedIdentifierContext; UnquotedIdentifierContext.prototype.IDENTIFIER = function() { - return this.getToken(SqlBaseParser.IDENTIFIER, 0); + return this.getToken(SparkSqlParser.IDENTIFIER, 0); }; UnquotedIdentifierContext.prototype.ansiNonReserved = function() { @@ -28331,19 +28331,19 @@ UnquotedIdentifierContext.prototype.nonReserved = function() { return this.getTypedRuleContext(NonReservedContext,0); }; UnquotedIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterUnquotedIdentifier(this); } }; UnquotedIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitUnquotedIdentifier(this); } }; UnquotedIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitUnquotedIdentifier(this); } else { return visitor.visitChildren(this); @@ -28352,12 +28352,12 @@ UnquotedIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.StrictIdentifierContext = StrictIdentifierContext; +SparkSqlParser.StrictIdentifierContext = StrictIdentifierContext; -SqlBaseParser.prototype.strictIdentifier = function() { +SparkSqlParser.prototype.strictIdentifier = function() { var localctx = new StrictIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 258, SqlBaseParser.RULE_strictIdentifier); + this.enterRule(localctx, 258, SparkSqlParser.RULE_strictIdentifier); try { this.state = 2961; this._errHandler.sync(this); @@ -28367,7 +28367,7 @@ SqlBaseParser.prototype.strictIdentifier = function() { localctx = new UnquotedIdentifierContext(this, localctx); this.enterOuterAlt(localctx, 1); this.state = 2955; - this.match(SqlBaseParser.IDENTIFIER); + this.match(SparkSqlParser.IDENTIFIER); break; case 2: @@ -28424,7 +28424,7 @@ function QuotedIdentifierContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_quotedIdentifier; + this.ruleIndex = SparkSqlParser.RULE_quotedIdentifier; return this; } @@ -28432,23 +28432,23 @@ QuotedIdentifierContext.prototype = Object.create(antlr4.ParserRuleContext.proto QuotedIdentifierContext.prototype.constructor = QuotedIdentifierContext; QuotedIdentifierContext.prototype.BACKQUOTED_IDENTIFIER = function() { - return this.getToken(SqlBaseParser.BACKQUOTED_IDENTIFIER, 0); + return this.getToken(SparkSqlParser.BACKQUOTED_IDENTIFIER, 0); }; QuotedIdentifierContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterQuotedIdentifier(this); } }; QuotedIdentifierContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitQuotedIdentifier(this); } }; QuotedIdentifierContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitQuotedIdentifier(this); } else { return visitor.visitChildren(this); @@ -28458,16 +28458,16 @@ QuotedIdentifierContext.prototype.accept = function(visitor) { -SqlBaseParser.QuotedIdentifierContext = QuotedIdentifierContext; +SparkSqlParser.QuotedIdentifierContext = QuotedIdentifierContext; -SqlBaseParser.prototype.quotedIdentifier = function() { +SparkSqlParser.prototype.quotedIdentifier = function() { var localctx = new QuotedIdentifierContext(this, this._ctx, this.state); - this.enterRule(localctx, 260, SqlBaseParser.RULE_quotedIdentifier); + this.enterRule(localctx, 260, SparkSqlParser.RULE_quotedIdentifier); try { this.enterOuterAlt(localctx, 1); this.state = 2963; - this.match(SqlBaseParser.BACKQUOTED_IDENTIFIER); + this.match(SparkSqlParser.BACKQUOTED_IDENTIFIER); } catch (re) { if(re instanceof antlr4.error.RecognitionException) { localctx.exception = re; @@ -28492,7 +28492,7 @@ function NumberContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_number; + this.ruleIndex = SparkSqlParser.RULE_number; return this; } @@ -28515,29 +28515,29 @@ function DecimalLiteralContext(parser, ctx) { DecimalLiteralContext.prototype = Object.create(NumberContext.prototype); DecimalLiteralContext.prototype.constructor = DecimalLiteralContext; -SqlBaseParser.DecimalLiteralContext = DecimalLiteralContext; +SparkSqlParser.DecimalLiteralContext = DecimalLiteralContext; DecimalLiteralContext.prototype.DECIMAL_VALUE = function() { - return this.getToken(SqlBaseParser.DECIMAL_VALUE, 0); + return this.getToken(SparkSqlParser.DECIMAL_VALUE, 0); }; DecimalLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; DecimalLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDecimalLiteral(this); } }; DecimalLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDecimalLiteral(this); } }; DecimalLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDecimalLiteral(this); } else { return visitor.visitChildren(this); @@ -28554,29 +28554,29 @@ function BigIntLiteralContext(parser, ctx) { BigIntLiteralContext.prototype = Object.create(NumberContext.prototype); BigIntLiteralContext.prototype.constructor = BigIntLiteralContext; -SqlBaseParser.BigIntLiteralContext = BigIntLiteralContext; +SparkSqlParser.BigIntLiteralContext = BigIntLiteralContext; BigIntLiteralContext.prototype.BIGINT_LITERAL = function() { - return this.getToken(SqlBaseParser.BIGINT_LITERAL, 0); + return this.getToken(SparkSqlParser.BIGINT_LITERAL, 0); }; BigIntLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; BigIntLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterBigIntLiteral(this); } }; BigIntLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitBigIntLiteral(this); } }; BigIntLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitBigIntLiteral(this); } else { return visitor.visitChildren(this); @@ -28593,29 +28593,29 @@ function TinyIntLiteralContext(parser, ctx) { TinyIntLiteralContext.prototype = Object.create(NumberContext.prototype); TinyIntLiteralContext.prototype.constructor = TinyIntLiteralContext; -SqlBaseParser.TinyIntLiteralContext = TinyIntLiteralContext; +SparkSqlParser.TinyIntLiteralContext = TinyIntLiteralContext; TinyIntLiteralContext.prototype.TINYINT_LITERAL = function() { - return this.getToken(SqlBaseParser.TINYINT_LITERAL, 0); + return this.getToken(SparkSqlParser.TINYINT_LITERAL, 0); }; TinyIntLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; TinyIntLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterTinyIntLiteral(this); } }; TinyIntLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitTinyIntLiteral(this); } }; TinyIntLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitTinyIntLiteral(this); } else { return visitor.visitChildren(this); @@ -28632,33 +28632,33 @@ function LegacyDecimalLiteralContext(parser, ctx) { LegacyDecimalLiteralContext.prototype = Object.create(NumberContext.prototype); LegacyDecimalLiteralContext.prototype.constructor = LegacyDecimalLiteralContext; -SqlBaseParser.LegacyDecimalLiteralContext = LegacyDecimalLiteralContext; +SparkSqlParser.LegacyDecimalLiteralContext = LegacyDecimalLiteralContext; LegacyDecimalLiteralContext.prototype.EXPONENT_VALUE = function() { - return this.getToken(SqlBaseParser.EXPONENT_VALUE, 0); + return this.getToken(SparkSqlParser.EXPONENT_VALUE, 0); }; LegacyDecimalLiteralContext.prototype.DECIMAL_VALUE = function() { - return this.getToken(SqlBaseParser.DECIMAL_VALUE, 0); + return this.getToken(SparkSqlParser.DECIMAL_VALUE, 0); }; LegacyDecimalLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; LegacyDecimalLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterLegacyDecimalLiteral(this); } }; LegacyDecimalLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitLegacyDecimalLiteral(this); } }; LegacyDecimalLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitLegacyDecimalLiteral(this); } else { return visitor.visitChildren(this); @@ -28675,29 +28675,29 @@ function BigDecimalLiteralContext(parser, ctx) { BigDecimalLiteralContext.prototype = Object.create(NumberContext.prototype); BigDecimalLiteralContext.prototype.constructor = BigDecimalLiteralContext; -SqlBaseParser.BigDecimalLiteralContext = BigDecimalLiteralContext; +SparkSqlParser.BigDecimalLiteralContext = BigDecimalLiteralContext; BigDecimalLiteralContext.prototype.BIGDECIMAL_LITERAL = function() { - return this.getToken(SqlBaseParser.BIGDECIMAL_LITERAL, 0); + return this.getToken(SparkSqlParser.BIGDECIMAL_LITERAL, 0); }; BigDecimalLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; BigDecimalLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterBigDecimalLiteral(this); } }; BigDecimalLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitBigDecimalLiteral(this); } }; BigDecimalLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitBigDecimalLiteral(this); } else { return visitor.visitChildren(this); @@ -28714,29 +28714,29 @@ function ExponentLiteralContext(parser, ctx) { ExponentLiteralContext.prototype = Object.create(NumberContext.prototype); ExponentLiteralContext.prototype.constructor = ExponentLiteralContext; -SqlBaseParser.ExponentLiteralContext = ExponentLiteralContext; +SparkSqlParser.ExponentLiteralContext = ExponentLiteralContext; ExponentLiteralContext.prototype.EXPONENT_VALUE = function() { - return this.getToken(SqlBaseParser.EXPONENT_VALUE, 0); + return this.getToken(SparkSqlParser.EXPONENT_VALUE, 0); }; ExponentLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; ExponentLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterExponentLiteral(this); } }; ExponentLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitExponentLiteral(this); } }; ExponentLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitExponentLiteral(this); } else { return visitor.visitChildren(this); @@ -28753,29 +28753,29 @@ function DoubleLiteralContext(parser, ctx) { DoubleLiteralContext.prototype = Object.create(NumberContext.prototype); DoubleLiteralContext.prototype.constructor = DoubleLiteralContext; -SqlBaseParser.DoubleLiteralContext = DoubleLiteralContext; +SparkSqlParser.DoubleLiteralContext = DoubleLiteralContext; DoubleLiteralContext.prototype.DOUBLE_LITERAL = function() { - return this.getToken(SqlBaseParser.DOUBLE_LITERAL, 0); + return this.getToken(SparkSqlParser.DOUBLE_LITERAL, 0); }; DoubleLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; DoubleLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterDoubleLiteral(this); } }; DoubleLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitDoubleLiteral(this); } }; DoubleLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitDoubleLiteral(this); } else { return visitor.visitChildren(this); @@ -28792,29 +28792,29 @@ function IntegerLiteralContext(parser, ctx) { IntegerLiteralContext.prototype = Object.create(NumberContext.prototype); IntegerLiteralContext.prototype.constructor = IntegerLiteralContext; -SqlBaseParser.IntegerLiteralContext = IntegerLiteralContext; +SparkSqlParser.IntegerLiteralContext = IntegerLiteralContext; IntegerLiteralContext.prototype.INTEGER_VALUE = function() { - return this.getToken(SqlBaseParser.INTEGER_VALUE, 0); + return this.getToken(SparkSqlParser.INTEGER_VALUE, 0); }; IntegerLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; IntegerLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterIntegerLiteral(this); } }; IntegerLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitIntegerLiteral(this); } }; IntegerLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitIntegerLiteral(this); } else { return visitor.visitChildren(this); @@ -28831,29 +28831,29 @@ function FloatLiteralContext(parser, ctx) { FloatLiteralContext.prototype = Object.create(NumberContext.prototype); FloatLiteralContext.prototype.constructor = FloatLiteralContext; -SqlBaseParser.FloatLiteralContext = FloatLiteralContext; +SparkSqlParser.FloatLiteralContext = FloatLiteralContext; FloatLiteralContext.prototype.FLOAT_LITERAL = function() { - return this.getToken(SqlBaseParser.FLOAT_LITERAL, 0); + return this.getToken(SparkSqlParser.FLOAT_LITERAL, 0); }; FloatLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; FloatLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterFloatLiteral(this); } }; FloatLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitFloatLiteral(this); } }; FloatLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitFloatLiteral(this); } else { return visitor.visitChildren(this); @@ -28870,29 +28870,29 @@ function SmallIntLiteralContext(parser, ctx) { SmallIntLiteralContext.prototype = Object.create(NumberContext.prototype); SmallIntLiteralContext.prototype.constructor = SmallIntLiteralContext; -SqlBaseParser.SmallIntLiteralContext = SmallIntLiteralContext; +SparkSqlParser.SmallIntLiteralContext = SmallIntLiteralContext; SmallIntLiteralContext.prototype.SMALLINT_LITERAL = function() { - return this.getToken(SqlBaseParser.SMALLINT_LITERAL, 0); + return this.getToken(SparkSqlParser.SMALLINT_LITERAL, 0); }; SmallIntLiteralContext.prototype.MINUS = function() { - return this.getToken(SqlBaseParser.MINUS, 0); + return this.getToken(SparkSqlParser.MINUS, 0); }; SmallIntLiteralContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterSmallIntLiteral(this); } }; SmallIntLiteralContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitSmallIntLiteral(this); } }; SmallIntLiteralContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitSmallIntLiteral(this); } else { return visitor.visitChildren(this); @@ -28901,12 +28901,12 @@ SmallIntLiteralContext.prototype.accept = function(visitor) { -SqlBaseParser.NumberContext = NumberContext; +SparkSqlParser.NumberContext = NumberContext; -SqlBaseParser.prototype.number = function() { +SparkSqlParser.prototype.number = function() { var localctx = new NumberContext(this, this._ctx, this.state); - this.enterRule(localctx, 262, SqlBaseParser.RULE_number); + this.enterRule(localctx, 262, SparkSqlParser.RULE_number); var _la = 0; // Token type try { this.state = 3008; @@ -28923,13 +28923,13 @@ SqlBaseParser.prototype.number = function() { this.state = 2967; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2966; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2969; - this.match(SqlBaseParser.EXPONENT_VALUE); + this.match(SparkSqlParser.EXPONENT_VALUE); break; case 2: @@ -28942,13 +28942,13 @@ SqlBaseParser.prototype.number = function() { this.state = 2972; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2971; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2974; - this.match(SqlBaseParser.DECIMAL_VALUE); + this.match(SparkSqlParser.DECIMAL_VALUE); break; case 3: @@ -28961,14 +28961,14 @@ SqlBaseParser.prototype.number = function() { this.state = 2977; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2976; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2979; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.EXPONENT_VALUE || _la===SqlBaseParser.DECIMAL_VALUE)) { + if(!(_la===SparkSqlParser.EXPONENT_VALUE || _la===SparkSqlParser.DECIMAL_VALUE)) { this._errHandler.recoverInline(this); } else { @@ -28983,13 +28983,13 @@ SqlBaseParser.prototype.number = function() { this.state = 2981; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2980; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2983; - this.match(SqlBaseParser.INTEGER_VALUE); + this.match(SparkSqlParser.INTEGER_VALUE); break; case 5: @@ -28998,13 +28998,13 @@ SqlBaseParser.prototype.number = function() { this.state = 2985; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2984; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2987; - this.match(SqlBaseParser.BIGINT_LITERAL); + this.match(SparkSqlParser.BIGINT_LITERAL); break; case 6: @@ -29013,13 +29013,13 @@ SqlBaseParser.prototype.number = function() { this.state = 2989; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2988; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2991; - this.match(SqlBaseParser.SMALLINT_LITERAL); + this.match(SparkSqlParser.SMALLINT_LITERAL); break; case 7: @@ -29028,13 +29028,13 @@ SqlBaseParser.prototype.number = function() { this.state = 2993; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2992; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2995; - this.match(SqlBaseParser.TINYINT_LITERAL); + this.match(SparkSqlParser.TINYINT_LITERAL); break; case 8: @@ -29043,13 +29043,13 @@ SqlBaseParser.prototype.number = function() { this.state = 2997; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 2996; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 2999; - this.match(SqlBaseParser.DOUBLE_LITERAL); + this.match(SparkSqlParser.DOUBLE_LITERAL); break; case 9: @@ -29058,13 +29058,13 @@ SqlBaseParser.prototype.number = function() { this.state = 3001; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 3000; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 3003; - this.match(SqlBaseParser.FLOAT_LITERAL); + this.match(SparkSqlParser.FLOAT_LITERAL); break; case 10: @@ -29073,13 +29073,13 @@ SqlBaseParser.prototype.number = function() { this.state = 3005; this._errHandler.sync(this); _la = this._input.LA(1); - if(_la===SqlBaseParser.MINUS) { + if(_la===SparkSqlParser.MINUS) { this.state = 3004; - this.match(SqlBaseParser.MINUS); + this.match(SparkSqlParser.MINUS); } this.state = 3007; - this.match(SqlBaseParser.BIGDECIMAL_LITERAL); + this.match(SparkSqlParser.BIGDECIMAL_LITERAL); break; } @@ -29107,7 +29107,7 @@ function AlterColumnActionContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_alterColumnAction; + this.ruleIndex = SparkSqlParser.RULE_alterColumnAction; this.setOrDrop = null; // Token return this; } @@ -29116,7 +29116,7 @@ AlterColumnActionContext.prototype = Object.create(antlr4.ParserRuleContext.prot AlterColumnActionContext.prototype.constructor = AlterColumnActionContext; AlterColumnActionContext.prototype.TYPE = function() { - return this.getToken(SqlBaseParser.TYPE, 0); + return this.getToken(SparkSqlParser.TYPE, 0); }; AlterColumnActionContext.prototype.dataType = function() { @@ -29132,35 +29132,35 @@ AlterColumnActionContext.prototype.colPosition = function() { }; AlterColumnActionContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; AlterColumnActionContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; AlterColumnActionContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; AlterColumnActionContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; AlterColumnActionContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAlterColumnAction(this); } }; AlterColumnActionContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAlterColumnAction(this); } }; AlterColumnActionContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAlterColumnAction(this); } else { return visitor.visitChildren(this); @@ -29170,42 +29170,42 @@ AlterColumnActionContext.prototype.accept = function(visitor) { -SqlBaseParser.AlterColumnActionContext = AlterColumnActionContext; +SparkSqlParser.AlterColumnActionContext = AlterColumnActionContext; -SqlBaseParser.prototype.alterColumnAction = function() { +SparkSqlParser.prototype.alterColumnAction = function() { var localctx = new AlterColumnActionContext(this, this._ctx, this.state); - this.enterRule(localctx, 264, SqlBaseParser.RULE_alterColumnAction); + this.enterRule(localctx, 264, SparkSqlParser.RULE_alterColumnAction); var _la = 0; // Token type try { this.state = 3017; this._errHandler.sync(this); switch(this._input.LA(1)) { - case SqlBaseParser.TYPE: + case SparkSqlParser.TYPE: this.enterOuterAlt(localctx, 1); this.state = 3010; - this.match(SqlBaseParser.TYPE); + this.match(SparkSqlParser.TYPE); this.state = 3011; this.dataType(); break; - case SqlBaseParser.COMMENT: + case SparkSqlParser.COMMENT: this.enterOuterAlt(localctx, 2); this.state = 3012; this.commentSpec(); break; - case SqlBaseParser.AFTER: - case SqlBaseParser.FIRST: + case SparkSqlParser.AFTER: + case SparkSqlParser.FIRST: this.enterOuterAlt(localctx, 3); this.state = 3013; this.colPosition(); break; - case SqlBaseParser.DROP: - case SqlBaseParser.SET: + case SparkSqlParser.DROP: + case SparkSqlParser.SET: this.enterOuterAlt(localctx, 4); this.state = 3014; localctx.setOrDrop = this._input.LT(1); _la = this._input.LA(1); - if(!(_la===SqlBaseParser.DROP || _la===SqlBaseParser.SET)) { + if(!(_la===SparkSqlParser.DROP || _la===SparkSqlParser.SET)) { localctx.setOrDrop = this._errHandler.recoverInline(this); } else { @@ -29213,9 +29213,9 @@ SqlBaseParser.prototype.alterColumnAction = function() { this.consume(); } this.state = 3015; - this.match(SqlBaseParser.NOT); + this.match(SparkSqlParser.NOT); this.state = 3016; - this.match(SqlBaseParser.NULL); + this.match(SparkSqlParser.NULL); break; default: throw new antlr4.error.NoViableAltException(this); @@ -29244,7 +29244,7 @@ function AnsiNonReservedContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_ansiNonReserved; + this.ruleIndex = SparkSqlParser.RULE_ansiNonReserved; return this; } @@ -29252,739 +29252,739 @@ AnsiNonReservedContext.prototype = Object.create(antlr4.ParserRuleContext.protot AnsiNonReservedContext.prototype.constructor = AnsiNonReservedContext; AnsiNonReservedContext.prototype.ADD = function() { - return this.getToken(SqlBaseParser.ADD, 0); + return this.getToken(SparkSqlParser.ADD, 0); }; AnsiNonReservedContext.prototype.AFTER = function() { - return this.getToken(SqlBaseParser.AFTER, 0); + return this.getToken(SparkSqlParser.AFTER, 0); }; AnsiNonReservedContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; AnsiNonReservedContext.prototype.ANALYZE = function() { - return this.getToken(SqlBaseParser.ANALYZE, 0); + return this.getToken(SparkSqlParser.ANALYZE, 0); }; AnsiNonReservedContext.prototype.ANTI = function() { - return this.getToken(SqlBaseParser.ANTI, 0); + return this.getToken(SparkSqlParser.ANTI, 0); }; AnsiNonReservedContext.prototype.ARCHIVE = function() { - return this.getToken(SqlBaseParser.ARCHIVE, 0); + return this.getToken(SparkSqlParser.ARCHIVE, 0); }; AnsiNonReservedContext.prototype.ARRAY = function() { - return this.getToken(SqlBaseParser.ARRAY, 0); + return this.getToken(SparkSqlParser.ARRAY, 0); }; AnsiNonReservedContext.prototype.ASC = function() { - return this.getToken(SqlBaseParser.ASC, 0); + return this.getToken(SparkSqlParser.ASC, 0); }; AnsiNonReservedContext.prototype.AT = function() { - return this.getToken(SqlBaseParser.AT, 0); + return this.getToken(SparkSqlParser.AT, 0); }; AnsiNonReservedContext.prototype.BETWEEN = function() { - return this.getToken(SqlBaseParser.BETWEEN, 0); + return this.getToken(SparkSqlParser.BETWEEN, 0); }; AnsiNonReservedContext.prototype.BUCKET = function() { - return this.getToken(SqlBaseParser.BUCKET, 0); + return this.getToken(SparkSqlParser.BUCKET, 0); }; AnsiNonReservedContext.prototype.BUCKETS = function() { - return this.getToken(SqlBaseParser.BUCKETS, 0); + return this.getToken(SparkSqlParser.BUCKETS, 0); }; AnsiNonReservedContext.prototype.BY = function() { - return this.getToken(SqlBaseParser.BY, 0); + return this.getToken(SparkSqlParser.BY, 0); }; AnsiNonReservedContext.prototype.CACHE = function() { - return this.getToken(SqlBaseParser.CACHE, 0); + return this.getToken(SparkSqlParser.CACHE, 0); }; AnsiNonReservedContext.prototype.CASCADE = function() { - return this.getToken(SqlBaseParser.CASCADE, 0); + return this.getToken(SparkSqlParser.CASCADE, 0); }; AnsiNonReservedContext.prototype.CHANGE = function() { - return this.getToken(SqlBaseParser.CHANGE, 0); + return this.getToken(SparkSqlParser.CHANGE, 0); }; AnsiNonReservedContext.prototype.CLEAR = function() { - return this.getToken(SqlBaseParser.CLEAR, 0); + return this.getToken(SparkSqlParser.CLEAR, 0); }; AnsiNonReservedContext.prototype.CLUSTER = function() { - return this.getToken(SqlBaseParser.CLUSTER, 0); + return this.getToken(SparkSqlParser.CLUSTER, 0); }; AnsiNonReservedContext.prototype.CLUSTERED = function() { - return this.getToken(SqlBaseParser.CLUSTERED, 0); + return this.getToken(SparkSqlParser.CLUSTERED, 0); }; AnsiNonReservedContext.prototype.CODEGEN = function() { - return this.getToken(SqlBaseParser.CODEGEN, 0); + return this.getToken(SparkSqlParser.CODEGEN, 0); }; AnsiNonReservedContext.prototype.COLLECTION = function() { - return this.getToken(SqlBaseParser.COLLECTION, 0); + return this.getToken(SparkSqlParser.COLLECTION, 0); }; AnsiNonReservedContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; AnsiNonReservedContext.prototype.COMMENT = function() { - return this.getToken(SqlBaseParser.COMMENT, 0); + return this.getToken(SparkSqlParser.COMMENT, 0); }; AnsiNonReservedContext.prototype.COMMIT = function() { - return this.getToken(SqlBaseParser.COMMIT, 0); + return this.getToken(SparkSqlParser.COMMIT, 0); }; AnsiNonReservedContext.prototype.COMPACT = function() { - return this.getToken(SqlBaseParser.COMPACT, 0); + return this.getToken(SparkSqlParser.COMPACT, 0); }; AnsiNonReservedContext.prototype.COMPACTIONS = function() { - return this.getToken(SqlBaseParser.COMPACTIONS, 0); + return this.getToken(SparkSqlParser.COMPACTIONS, 0); }; AnsiNonReservedContext.prototype.COMPUTE = function() { - return this.getToken(SqlBaseParser.COMPUTE, 0); + return this.getToken(SparkSqlParser.COMPUTE, 0); }; AnsiNonReservedContext.prototype.CONCATENATE = function() { - return this.getToken(SqlBaseParser.CONCATENATE, 0); + return this.getToken(SparkSqlParser.CONCATENATE, 0); }; AnsiNonReservedContext.prototype.COST = function() { - return this.getToken(SqlBaseParser.COST, 0); + return this.getToken(SparkSqlParser.COST, 0); }; AnsiNonReservedContext.prototype.CUBE = function() { - return this.getToken(SqlBaseParser.CUBE, 0); + return this.getToken(SparkSqlParser.CUBE, 0); }; AnsiNonReservedContext.prototype.CURRENT = function() { - return this.getToken(SqlBaseParser.CURRENT, 0); + return this.getToken(SparkSqlParser.CURRENT, 0); }; AnsiNonReservedContext.prototype.DATA = function() { - return this.getToken(SqlBaseParser.DATA, 0); + return this.getToken(SparkSqlParser.DATA, 0); }; AnsiNonReservedContext.prototype.DATABASE = function() { - return this.getToken(SqlBaseParser.DATABASE, 0); + return this.getToken(SparkSqlParser.DATABASE, 0); }; AnsiNonReservedContext.prototype.DATABASES = function() { - return this.getToken(SqlBaseParser.DATABASES, 0); + return this.getToken(SparkSqlParser.DATABASES, 0); }; AnsiNonReservedContext.prototype.DBPROPERTIES = function() { - return this.getToken(SqlBaseParser.DBPROPERTIES, 0); + return this.getToken(SparkSqlParser.DBPROPERTIES, 0); }; AnsiNonReservedContext.prototype.DEFINED = function() { - return this.getToken(SqlBaseParser.DEFINED, 0); + return this.getToken(SparkSqlParser.DEFINED, 0); }; AnsiNonReservedContext.prototype.DELETE = function() { - return this.getToken(SqlBaseParser.DELETE, 0); + return this.getToken(SparkSqlParser.DELETE, 0); }; AnsiNonReservedContext.prototype.DELIMITED = function() { - return this.getToken(SqlBaseParser.DELIMITED, 0); + return this.getToken(SparkSqlParser.DELIMITED, 0); }; AnsiNonReservedContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; AnsiNonReservedContext.prototype.DESCRIBE = function() { - return this.getToken(SqlBaseParser.DESCRIBE, 0); + return this.getToken(SparkSqlParser.DESCRIBE, 0); }; AnsiNonReservedContext.prototype.DFS = function() { - return this.getToken(SqlBaseParser.DFS, 0); + return this.getToken(SparkSqlParser.DFS, 0); }; AnsiNonReservedContext.prototype.DIRECTORIES = function() { - return this.getToken(SqlBaseParser.DIRECTORIES, 0); + return this.getToken(SparkSqlParser.DIRECTORIES, 0); }; AnsiNonReservedContext.prototype.DIRECTORY = function() { - return this.getToken(SqlBaseParser.DIRECTORY, 0); + return this.getToken(SparkSqlParser.DIRECTORY, 0); }; AnsiNonReservedContext.prototype.DISTRIBUTE = function() { - return this.getToken(SqlBaseParser.DISTRIBUTE, 0); + return this.getToken(SparkSqlParser.DISTRIBUTE, 0); }; AnsiNonReservedContext.prototype.DIV = function() { - return this.getToken(SqlBaseParser.DIV, 0); + return this.getToken(SparkSqlParser.DIV, 0); }; AnsiNonReservedContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; AnsiNonReservedContext.prototype.ESCAPED = function() { - return this.getToken(SqlBaseParser.ESCAPED, 0); + return this.getToken(SparkSqlParser.ESCAPED, 0); }; AnsiNonReservedContext.prototype.EXCHANGE = function() { - return this.getToken(SqlBaseParser.EXCHANGE, 0); + return this.getToken(SparkSqlParser.EXCHANGE, 0); }; AnsiNonReservedContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; AnsiNonReservedContext.prototype.EXPLAIN = function() { - return this.getToken(SqlBaseParser.EXPLAIN, 0); + return this.getToken(SparkSqlParser.EXPLAIN, 0); }; AnsiNonReservedContext.prototype.EXPORT = function() { - return this.getToken(SqlBaseParser.EXPORT, 0); + return this.getToken(SparkSqlParser.EXPORT, 0); }; AnsiNonReservedContext.prototype.EXTENDED = function() { - return this.getToken(SqlBaseParser.EXTENDED, 0); + return this.getToken(SparkSqlParser.EXTENDED, 0); }; AnsiNonReservedContext.prototype.EXTERNAL = function() { - return this.getToken(SqlBaseParser.EXTERNAL, 0); + return this.getToken(SparkSqlParser.EXTERNAL, 0); }; AnsiNonReservedContext.prototype.EXTRACT = function() { - return this.getToken(SqlBaseParser.EXTRACT, 0); + return this.getToken(SparkSqlParser.EXTRACT, 0); }; AnsiNonReservedContext.prototype.FIELDS = function() { - return this.getToken(SqlBaseParser.FIELDS, 0); + return this.getToken(SparkSqlParser.FIELDS, 0); }; AnsiNonReservedContext.prototype.FILEFORMAT = function() { - return this.getToken(SqlBaseParser.FILEFORMAT, 0); + return this.getToken(SparkSqlParser.FILEFORMAT, 0); }; AnsiNonReservedContext.prototype.FIRST = function() { - return this.getToken(SqlBaseParser.FIRST, 0); + return this.getToken(SparkSqlParser.FIRST, 0); }; AnsiNonReservedContext.prototype.FOLLOWING = function() { - return this.getToken(SqlBaseParser.FOLLOWING, 0); + return this.getToken(SparkSqlParser.FOLLOWING, 0); }; AnsiNonReservedContext.prototype.FORMAT = function() { - return this.getToken(SqlBaseParser.FORMAT, 0); + return this.getToken(SparkSqlParser.FORMAT, 0); }; AnsiNonReservedContext.prototype.FORMATTED = function() { - return this.getToken(SqlBaseParser.FORMATTED, 0); + return this.getToken(SparkSqlParser.FORMATTED, 0); }; AnsiNonReservedContext.prototype.FUNCTION = function() { - return this.getToken(SqlBaseParser.FUNCTION, 0); + return this.getToken(SparkSqlParser.FUNCTION, 0); }; AnsiNonReservedContext.prototype.FUNCTIONS = function() { - return this.getToken(SqlBaseParser.FUNCTIONS, 0); + return this.getToken(SparkSqlParser.FUNCTIONS, 0); }; AnsiNonReservedContext.prototype.GLOBAL = function() { - return this.getToken(SqlBaseParser.GLOBAL, 0); + return this.getToken(SparkSqlParser.GLOBAL, 0); }; AnsiNonReservedContext.prototype.GROUPING = function() { - return this.getToken(SqlBaseParser.GROUPING, 0); + return this.getToken(SparkSqlParser.GROUPING, 0); }; AnsiNonReservedContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; AnsiNonReservedContext.prototype.IGNORE = function() { - return this.getToken(SqlBaseParser.IGNORE, 0); + return this.getToken(SparkSqlParser.IGNORE, 0); }; AnsiNonReservedContext.prototype.IMPORT = function() { - return this.getToken(SqlBaseParser.IMPORT, 0); + return this.getToken(SparkSqlParser.IMPORT, 0); }; AnsiNonReservedContext.prototype.INDEX = function() { - return this.getToken(SqlBaseParser.INDEX, 0); + return this.getToken(SparkSqlParser.INDEX, 0); }; AnsiNonReservedContext.prototype.INDEXES = function() { - return this.getToken(SqlBaseParser.INDEXES, 0); + return this.getToken(SparkSqlParser.INDEXES, 0); }; AnsiNonReservedContext.prototype.INPATH = function() { - return this.getToken(SqlBaseParser.INPATH, 0); + return this.getToken(SparkSqlParser.INPATH, 0); }; AnsiNonReservedContext.prototype.INPUTFORMAT = function() { - return this.getToken(SqlBaseParser.INPUTFORMAT, 0); + return this.getToken(SparkSqlParser.INPUTFORMAT, 0); }; AnsiNonReservedContext.prototype.INSERT = function() { - return this.getToken(SqlBaseParser.INSERT, 0); + return this.getToken(SparkSqlParser.INSERT, 0); }; AnsiNonReservedContext.prototype.INTERVAL = function() { - return this.getToken(SqlBaseParser.INTERVAL, 0); + return this.getToken(SparkSqlParser.INTERVAL, 0); }; AnsiNonReservedContext.prototype.ITEMS = function() { - return this.getToken(SqlBaseParser.ITEMS, 0); + return this.getToken(SparkSqlParser.ITEMS, 0); }; AnsiNonReservedContext.prototype.KEYS = function() { - return this.getToken(SqlBaseParser.KEYS, 0); + return this.getToken(SparkSqlParser.KEYS, 0); }; AnsiNonReservedContext.prototype.LAST = function() { - return this.getToken(SqlBaseParser.LAST, 0); + return this.getToken(SparkSqlParser.LAST, 0); }; AnsiNonReservedContext.prototype.LATERAL = function() { - return this.getToken(SqlBaseParser.LATERAL, 0); + return this.getToken(SparkSqlParser.LATERAL, 0); }; AnsiNonReservedContext.prototype.LAZY = function() { - return this.getToken(SqlBaseParser.LAZY, 0); + return this.getToken(SparkSqlParser.LAZY, 0); }; AnsiNonReservedContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; AnsiNonReservedContext.prototype.LIMIT = function() { - return this.getToken(SqlBaseParser.LIMIT, 0); + return this.getToken(SparkSqlParser.LIMIT, 0); }; AnsiNonReservedContext.prototype.LINES = function() { - return this.getToken(SqlBaseParser.LINES, 0); + return this.getToken(SparkSqlParser.LINES, 0); }; AnsiNonReservedContext.prototype.LIST = function() { - return this.getToken(SqlBaseParser.LIST, 0); + return this.getToken(SparkSqlParser.LIST, 0); }; AnsiNonReservedContext.prototype.LOAD = function() { - return this.getToken(SqlBaseParser.LOAD, 0); + return this.getToken(SparkSqlParser.LOAD, 0); }; AnsiNonReservedContext.prototype.LOCAL = function() { - return this.getToken(SqlBaseParser.LOCAL, 0); + return this.getToken(SparkSqlParser.LOCAL, 0); }; AnsiNonReservedContext.prototype.LOCATION = function() { - return this.getToken(SqlBaseParser.LOCATION, 0); + return this.getToken(SparkSqlParser.LOCATION, 0); }; AnsiNonReservedContext.prototype.LOCK = function() { - return this.getToken(SqlBaseParser.LOCK, 0); + return this.getToken(SparkSqlParser.LOCK, 0); }; AnsiNonReservedContext.prototype.LOCKS = function() { - return this.getToken(SqlBaseParser.LOCKS, 0); + return this.getToken(SparkSqlParser.LOCKS, 0); }; AnsiNonReservedContext.prototype.LOGICAL = function() { - return this.getToken(SqlBaseParser.LOGICAL, 0); + return this.getToken(SparkSqlParser.LOGICAL, 0); }; AnsiNonReservedContext.prototype.MACRO = function() { - return this.getToken(SqlBaseParser.MACRO, 0); + return this.getToken(SparkSqlParser.MACRO, 0); }; AnsiNonReservedContext.prototype.MAP = function() { - return this.getToken(SqlBaseParser.MAP, 0); + return this.getToken(SparkSqlParser.MAP, 0); }; AnsiNonReservedContext.prototype.MATCHED = function() { - return this.getToken(SqlBaseParser.MATCHED, 0); + return this.getToken(SparkSqlParser.MATCHED, 0); }; AnsiNonReservedContext.prototype.MERGE = function() { - return this.getToken(SqlBaseParser.MERGE, 0); + return this.getToken(SparkSqlParser.MERGE, 0); }; AnsiNonReservedContext.prototype.MSCK = function() { - return this.getToken(SqlBaseParser.MSCK, 0); + return this.getToken(SparkSqlParser.MSCK, 0); }; AnsiNonReservedContext.prototype.NAMESPACE = function() { - return this.getToken(SqlBaseParser.NAMESPACE, 0); + return this.getToken(SparkSqlParser.NAMESPACE, 0); }; AnsiNonReservedContext.prototype.NAMESPACES = function() { - return this.getToken(SqlBaseParser.NAMESPACES, 0); + return this.getToken(SparkSqlParser.NAMESPACES, 0); }; AnsiNonReservedContext.prototype.NO = function() { - return this.getToken(SqlBaseParser.NO, 0); + return this.getToken(SparkSqlParser.NO, 0); }; AnsiNonReservedContext.prototype.NULLS = function() { - return this.getToken(SqlBaseParser.NULLS, 0); + return this.getToken(SparkSqlParser.NULLS, 0); }; AnsiNonReservedContext.prototype.OF = function() { - return this.getToken(SqlBaseParser.OF, 0); + return this.getToken(SparkSqlParser.OF, 0); }; AnsiNonReservedContext.prototype.OPTION = function() { - return this.getToken(SqlBaseParser.OPTION, 0); + return this.getToken(SparkSqlParser.OPTION, 0); }; AnsiNonReservedContext.prototype.OPTIONS = function() { - return this.getToken(SqlBaseParser.OPTIONS, 0); + return this.getToken(SparkSqlParser.OPTIONS, 0); }; AnsiNonReservedContext.prototype.OUT = function() { - return this.getToken(SqlBaseParser.OUT, 0); + return this.getToken(SparkSqlParser.OUT, 0); }; AnsiNonReservedContext.prototype.OUTPUTFORMAT = function() { - return this.getToken(SqlBaseParser.OUTPUTFORMAT, 0); + return this.getToken(SparkSqlParser.OUTPUTFORMAT, 0); }; AnsiNonReservedContext.prototype.OVER = function() { - return this.getToken(SqlBaseParser.OVER, 0); + return this.getToken(SparkSqlParser.OVER, 0); }; AnsiNonReservedContext.prototype.OVERLAY = function() { - return this.getToken(SqlBaseParser.OVERLAY, 0); + return this.getToken(SparkSqlParser.OVERLAY, 0); }; AnsiNonReservedContext.prototype.OVERWRITE = function() { - return this.getToken(SqlBaseParser.OVERWRITE, 0); + return this.getToken(SparkSqlParser.OVERWRITE, 0); }; AnsiNonReservedContext.prototype.PARTITION = function() { - return this.getToken(SqlBaseParser.PARTITION, 0); + return this.getToken(SparkSqlParser.PARTITION, 0); }; AnsiNonReservedContext.prototype.PARTITIONED = function() { - return this.getToken(SqlBaseParser.PARTITIONED, 0); + return this.getToken(SparkSqlParser.PARTITIONED, 0); }; AnsiNonReservedContext.prototype.PARTITIONS = function() { - return this.getToken(SqlBaseParser.PARTITIONS, 0); + return this.getToken(SparkSqlParser.PARTITIONS, 0); }; AnsiNonReservedContext.prototype.PERCENTLIT = function() { - return this.getToken(SqlBaseParser.PERCENTLIT, 0); + return this.getToken(SparkSqlParser.PERCENTLIT, 0); }; AnsiNonReservedContext.prototype.PIVOT = function() { - return this.getToken(SqlBaseParser.PIVOT, 0); + return this.getToken(SparkSqlParser.PIVOT, 0); }; AnsiNonReservedContext.prototype.PLACING = function() { - return this.getToken(SqlBaseParser.PLACING, 0); + return this.getToken(SparkSqlParser.PLACING, 0); }; AnsiNonReservedContext.prototype.POSITION = function() { - return this.getToken(SqlBaseParser.POSITION, 0); + return this.getToken(SparkSqlParser.POSITION, 0); }; AnsiNonReservedContext.prototype.PRECEDING = function() { - return this.getToken(SqlBaseParser.PRECEDING, 0); + return this.getToken(SparkSqlParser.PRECEDING, 0); }; AnsiNonReservedContext.prototype.PRINCIPALS = function() { - return this.getToken(SqlBaseParser.PRINCIPALS, 0); + return this.getToken(SparkSqlParser.PRINCIPALS, 0); }; AnsiNonReservedContext.prototype.PROPERTIES = function() { - return this.getToken(SqlBaseParser.PROPERTIES, 0); + return this.getToken(SparkSqlParser.PROPERTIES, 0); }; AnsiNonReservedContext.prototype.PURGE = function() { - return this.getToken(SqlBaseParser.PURGE, 0); + return this.getToken(SparkSqlParser.PURGE, 0); }; AnsiNonReservedContext.prototype.QUERY = function() { - return this.getToken(SqlBaseParser.QUERY, 0); + return this.getToken(SparkSqlParser.QUERY, 0); }; AnsiNonReservedContext.prototype.RANGE = function() { - return this.getToken(SqlBaseParser.RANGE, 0); + return this.getToken(SparkSqlParser.RANGE, 0); }; AnsiNonReservedContext.prototype.RECORDREADER = function() { - return this.getToken(SqlBaseParser.RECORDREADER, 0); + return this.getToken(SparkSqlParser.RECORDREADER, 0); }; AnsiNonReservedContext.prototype.RECORDWRITER = function() { - return this.getToken(SqlBaseParser.RECORDWRITER, 0); + return this.getToken(SparkSqlParser.RECORDWRITER, 0); }; AnsiNonReservedContext.prototype.RECOVER = function() { - return this.getToken(SqlBaseParser.RECOVER, 0); + return this.getToken(SparkSqlParser.RECOVER, 0); }; AnsiNonReservedContext.prototype.REDUCE = function() { - return this.getToken(SqlBaseParser.REDUCE, 0); + return this.getToken(SparkSqlParser.REDUCE, 0); }; AnsiNonReservedContext.prototype.REFRESH = function() { - return this.getToken(SqlBaseParser.REFRESH, 0); + return this.getToken(SparkSqlParser.REFRESH, 0); }; AnsiNonReservedContext.prototype.RENAME = function() { - return this.getToken(SqlBaseParser.RENAME, 0); + return this.getToken(SparkSqlParser.RENAME, 0); }; AnsiNonReservedContext.prototype.REPAIR = function() { - return this.getToken(SqlBaseParser.REPAIR, 0); + return this.getToken(SparkSqlParser.REPAIR, 0); }; AnsiNonReservedContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; AnsiNonReservedContext.prototype.RESET = function() { - return this.getToken(SqlBaseParser.RESET, 0); + return this.getToken(SparkSqlParser.RESET, 0); }; AnsiNonReservedContext.prototype.RESTRICT = function() { - return this.getToken(SqlBaseParser.RESTRICT, 0); + return this.getToken(SparkSqlParser.RESTRICT, 0); }; AnsiNonReservedContext.prototype.REVOKE = function() { - return this.getToken(SqlBaseParser.REVOKE, 0); + return this.getToken(SparkSqlParser.REVOKE, 0); }; AnsiNonReservedContext.prototype.RLIKE = function() { - return this.getToken(SqlBaseParser.RLIKE, 0); + return this.getToken(SparkSqlParser.RLIKE, 0); }; AnsiNonReservedContext.prototype.ROLE = function() { - return this.getToken(SqlBaseParser.ROLE, 0); + return this.getToken(SparkSqlParser.ROLE, 0); }; AnsiNonReservedContext.prototype.ROLES = function() { - return this.getToken(SqlBaseParser.ROLES, 0); + return this.getToken(SparkSqlParser.ROLES, 0); }; AnsiNonReservedContext.prototype.ROLLBACK = function() { - return this.getToken(SqlBaseParser.ROLLBACK, 0); + return this.getToken(SparkSqlParser.ROLLBACK, 0); }; AnsiNonReservedContext.prototype.ROLLUP = function() { - return this.getToken(SqlBaseParser.ROLLUP, 0); + return this.getToken(SparkSqlParser.ROLLUP, 0); }; AnsiNonReservedContext.prototype.ROW = function() { - return this.getToken(SqlBaseParser.ROW, 0); + return this.getToken(SparkSqlParser.ROW, 0); }; AnsiNonReservedContext.prototype.ROWS = function() { - return this.getToken(SqlBaseParser.ROWS, 0); + return this.getToken(SparkSqlParser.ROWS, 0); }; AnsiNonReservedContext.prototype.SCHEMA = function() { - return this.getToken(SqlBaseParser.SCHEMA, 0); + return this.getToken(SparkSqlParser.SCHEMA, 0); }; AnsiNonReservedContext.prototype.SEMI = function() { - return this.getToken(SqlBaseParser.SEMI, 0); + return this.getToken(SparkSqlParser.SEMI, 0); }; AnsiNonReservedContext.prototype.SEPARATED = function() { - return this.getToken(SqlBaseParser.SEPARATED, 0); + return this.getToken(SparkSqlParser.SEPARATED, 0); }; AnsiNonReservedContext.prototype.SERDE = function() { - return this.getToken(SqlBaseParser.SERDE, 0); + return this.getToken(SparkSqlParser.SERDE, 0); }; AnsiNonReservedContext.prototype.SERDEPROPERTIES = function() { - return this.getToken(SqlBaseParser.SERDEPROPERTIES, 0); + return this.getToken(SparkSqlParser.SERDEPROPERTIES, 0); }; AnsiNonReservedContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; AnsiNonReservedContext.prototype.SETMINUS = function() { - return this.getToken(SqlBaseParser.SETMINUS, 0); + return this.getToken(SparkSqlParser.SETMINUS, 0); }; AnsiNonReservedContext.prototype.SETS = function() { - return this.getToken(SqlBaseParser.SETS, 0); + return this.getToken(SparkSqlParser.SETS, 0); }; AnsiNonReservedContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; AnsiNonReservedContext.prototype.SKEWED = function() { - return this.getToken(SqlBaseParser.SKEWED, 0); + return this.getToken(SparkSqlParser.SKEWED, 0); }; AnsiNonReservedContext.prototype.SORT = function() { - return this.getToken(SqlBaseParser.SORT, 0); + return this.getToken(SparkSqlParser.SORT, 0); }; AnsiNonReservedContext.prototype.SORTED = function() { - return this.getToken(SqlBaseParser.SORTED, 0); + return this.getToken(SparkSqlParser.SORTED, 0); }; AnsiNonReservedContext.prototype.START = function() { - return this.getToken(SqlBaseParser.START, 0); + return this.getToken(SparkSqlParser.START, 0); }; AnsiNonReservedContext.prototype.STATISTICS = function() { - return this.getToken(SqlBaseParser.STATISTICS, 0); + return this.getToken(SparkSqlParser.STATISTICS, 0); }; AnsiNonReservedContext.prototype.STORED = function() { - return this.getToken(SqlBaseParser.STORED, 0); + return this.getToken(SparkSqlParser.STORED, 0); }; AnsiNonReservedContext.prototype.STRATIFY = function() { - return this.getToken(SqlBaseParser.STRATIFY, 0); + return this.getToken(SparkSqlParser.STRATIFY, 0); }; AnsiNonReservedContext.prototype.STRUCT = function() { - return this.getToken(SqlBaseParser.STRUCT, 0); + return this.getToken(SparkSqlParser.STRUCT, 0); }; AnsiNonReservedContext.prototype.SUBSTR = function() { - return this.getToken(SqlBaseParser.SUBSTR, 0); + return this.getToken(SparkSqlParser.SUBSTR, 0); }; AnsiNonReservedContext.prototype.SUBSTRING = function() { - return this.getToken(SqlBaseParser.SUBSTRING, 0); + return this.getToken(SparkSqlParser.SUBSTRING, 0); }; AnsiNonReservedContext.prototype.TABLES = function() { - return this.getToken(SqlBaseParser.TABLES, 0); + return this.getToken(SparkSqlParser.TABLES, 0); }; AnsiNonReservedContext.prototype.TABLESAMPLE = function() { - return this.getToken(SqlBaseParser.TABLESAMPLE, 0); + return this.getToken(SparkSqlParser.TABLESAMPLE, 0); }; AnsiNonReservedContext.prototype.TBLPROPERTIES = function() { - return this.getToken(SqlBaseParser.TBLPROPERTIES, 0); + return this.getToken(SparkSqlParser.TBLPROPERTIES, 0); }; AnsiNonReservedContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; AnsiNonReservedContext.prototype.TERMINATED = function() { - return this.getToken(SqlBaseParser.TERMINATED, 0); + return this.getToken(SparkSqlParser.TERMINATED, 0); }; AnsiNonReservedContext.prototype.TOUCH = function() { - return this.getToken(SqlBaseParser.TOUCH, 0); + return this.getToken(SparkSqlParser.TOUCH, 0); }; AnsiNonReservedContext.prototype.TRANSACTION = function() { - return this.getToken(SqlBaseParser.TRANSACTION, 0); + return this.getToken(SparkSqlParser.TRANSACTION, 0); }; AnsiNonReservedContext.prototype.TRANSACTIONS = function() { - return this.getToken(SqlBaseParser.TRANSACTIONS, 0); + return this.getToken(SparkSqlParser.TRANSACTIONS, 0); }; AnsiNonReservedContext.prototype.TRANSFORM = function() { - return this.getToken(SqlBaseParser.TRANSFORM, 0); + return this.getToken(SparkSqlParser.TRANSFORM, 0); }; AnsiNonReservedContext.prototype.TRIM = function() { - return this.getToken(SqlBaseParser.TRIM, 0); + return this.getToken(SparkSqlParser.TRIM, 0); }; AnsiNonReservedContext.prototype.TRUE = function() { - return this.getToken(SqlBaseParser.TRUE, 0); + return this.getToken(SparkSqlParser.TRUE, 0); }; AnsiNonReservedContext.prototype.TRUNCATE = function() { - return this.getToken(SqlBaseParser.TRUNCATE, 0); + return this.getToken(SparkSqlParser.TRUNCATE, 0); }; AnsiNonReservedContext.prototype.TYPE = function() { - return this.getToken(SqlBaseParser.TYPE, 0); + return this.getToken(SparkSqlParser.TYPE, 0); }; AnsiNonReservedContext.prototype.UNARCHIVE = function() { - return this.getToken(SqlBaseParser.UNARCHIVE, 0); + return this.getToken(SparkSqlParser.UNARCHIVE, 0); }; AnsiNonReservedContext.prototype.UNBOUNDED = function() { - return this.getToken(SqlBaseParser.UNBOUNDED, 0); + return this.getToken(SparkSqlParser.UNBOUNDED, 0); }; AnsiNonReservedContext.prototype.UNCACHE = function() { - return this.getToken(SqlBaseParser.UNCACHE, 0); + return this.getToken(SparkSqlParser.UNCACHE, 0); }; AnsiNonReservedContext.prototype.UNLOCK = function() { - return this.getToken(SqlBaseParser.UNLOCK, 0); + return this.getToken(SparkSqlParser.UNLOCK, 0); }; AnsiNonReservedContext.prototype.UNSET = function() { - return this.getToken(SqlBaseParser.UNSET, 0); + return this.getToken(SparkSqlParser.UNSET, 0); }; AnsiNonReservedContext.prototype.UPDATE = function() { - return this.getToken(SqlBaseParser.UPDATE, 0); + return this.getToken(SparkSqlParser.UPDATE, 0); }; AnsiNonReservedContext.prototype.USE = function() { - return this.getToken(SqlBaseParser.USE, 0); + return this.getToken(SparkSqlParser.USE, 0); }; AnsiNonReservedContext.prototype.VALUES = function() { - return this.getToken(SqlBaseParser.VALUES, 0); + return this.getToken(SparkSqlParser.VALUES, 0); }; AnsiNonReservedContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; AnsiNonReservedContext.prototype.VIEWS = function() { - return this.getToken(SqlBaseParser.VIEWS, 0); + return this.getToken(SparkSqlParser.VIEWS, 0); }; AnsiNonReservedContext.prototype.WINDOW = function() { - return this.getToken(SqlBaseParser.WINDOW, 0); + return this.getToken(SparkSqlParser.WINDOW, 0); }; AnsiNonReservedContext.prototype.ZONE = function() { - return this.getToken(SqlBaseParser.ZONE, 0); + return this.getToken(SparkSqlParser.ZONE, 0); }; AnsiNonReservedContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterAnsiNonReserved(this); } }; AnsiNonReservedContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitAnsiNonReserved(this); } }; AnsiNonReservedContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitAnsiNonReserved(this); } else { return visitor.visitChildren(this); @@ -29994,18 +29994,18 @@ AnsiNonReservedContext.prototype.accept = function(visitor) { -SqlBaseParser.AnsiNonReservedContext = AnsiNonReservedContext; +SparkSqlParser.AnsiNonReservedContext = AnsiNonReservedContext; -SqlBaseParser.prototype.ansiNonReserved = function() { +SparkSqlParser.prototype.ansiNonReserved = function() { var localctx = new AnsiNonReservedContext(this, this._ctx, this.state); - this.enterRule(localctx, 266, SqlBaseParser.RULE_ansiNonReserved); + this.enterRule(localctx, 266, SparkSqlParser.RULE_ansiNonReserved); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 3019; _la = this._input.LA(1); - if(!(((((_la - 12)) & ~0x1f) == 0 && ((1 << (_la - 12)) & ((1 << (SqlBaseParser.ADD - 12)) | (1 << (SqlBaseParser.AFTER - 12)) | (1 << (SqlBaseParser.ALTER - 12)) | (1 << (SqlBaseParser.ANALYZE - 12)) | (1 << (SqlBaseParser.ANTI - 12)) | (1 << (SqlBaseParser.ARCHIVE - 12)) | (1 << (SqlBaseParser.ARRAY - 12)) | (1 << (SqlBaseParser.ASC - 12)) | (1 << (SqlBaseParser.AT - 12)) | (1 << (SqlBaseParser.BETWEEN - 12)) | (1 << (SqlBaseParser.BUCKET - 12)) | (1 << (SqlBaseParser.BUCKETS - 12)) | (1 << (SqlBaseParser.BY - 12)) | (1 << (SqlBaseParser.CACHE - 12)) | (1 << (SqlBaseParser.CASCADE - 12)) | (1 << (SqlBaseParser.CHANGE - 12)) | (1 << (SqlBaseParser.CLEAR - 12)) | (1 << (SqlBaseParser.CLUSTER - 12)) | (1 << (SqlBaseParser.CLUSTERED - 12)) | (1 << (SqlBaseParser.CODEGEN - 12)) | (1 << (SqlBaseParser.COLLECTION - 12)))) !== 0) || ((((_la - 44)) & ~0x1f) == 0 && ((1 << (_la - 44)) & ((1 << (SqlBaseParser.COLUMNS - 44)) | (1 << (SqlBaseParser.COMMENT - 44)) | (1 << (SqlBaseParser.COMMIT - 44)) | (1 << (SqlBaseParser.COMPACT - 44)) | (1 << (SqlBaseParser.COMPACTIONS - 44)) | (1 << (SqlBaseParser.COMPUTE - 44)) | (1 << (SqlBaseParser.CONCATENATE - 44)) | (1 << (SqlBaseParser.COST - 44)) | (1 << (SqlBaseParser.CUBE - 44)) | (1 << (SqlBaseParser.CURRENT - 44)) | (1 << (SqlBaseParser.DATA - 44)) | (1 << (SqlBaseParser.DATABASE - 44)) | (1 << (SqlBaseParser.DATABASES - 44)) | (1 << (SqlBaseParser.DBPROPERTIES - 44)) | (1 << (SqlBaseParser.DEFINED - 44)) | (1 << (SqlBaseParser.DELETE - 44)) | (1 << (SqlBaseParser.DELIMITED - 44)) | (1 << (SqlBaseParser.DESC - 44)) | (1 << (SqlBaseParser.DESCRIBE - 44)) | (1 << (SqlBaseParser.DFS - 44)) | (1 << (SqlBaseParser.DIRECTORIES - 44)) | (1 << (SqlBaseParser.DIRECTORY - 44)) | (1 << (SqlBaseParser.DISTRIBUTE - 44)) | (1 << (SqlBaseParser.DIV - 44)))) !== 0) || ((((_la - 76)) & ~0x1f) == 0 && ((1 << (_la - 76)) & ((1 << (SqlBaseParser.DROP - 76)) | (1 << (SqlBaseParser.ESCAPED - 76)) | (1 << (SqlBaseParser.EXCHANGE - 76)) | (1 << (SqlBaseParser.EXISTS - 76)) | (1 << (SqlBaseParser.EXPLAIN - 76)) | (1 << (SqlBaseParser.EXPORT - 76)) | (1 << (SqlBaseParser.EXTENDED - 76)) | (1 << (SqlBaseParser.EXTERNAL - 76)) | (1 << (SqlBaseParser.EXTRACT - 76)) | (1 << (SqlBaseParser.FIELDS - 76)) | (1 << (SqlBaseParser.FILEFORMAT - 76)) | (1 << (SqlBaseParser.FIRST - 76)) | (1 << (SqlBaseParser.FOLLOWING - 76)) | (1 << (SqlBaseParser.FORMAT - 76)) | (1 << (SqlBaseParser.FORMATTED - 76)) | (1 << (SqlBaseParser.FUNCTION - 76)) | (1 << (SqlBaseParser.FUNCTIONS - 76)) | (1 << (SqlBaseParser.GLOBAL - 76)) | (1 << (SqlBaseParser.GROUPING - 76)))) !== 0) || ((((_la - 109)) & ~0x1f) == 0 && ((1 << (_la - 109)) & ((1 << (SqlBaseParser.IF - 109)) | (1 << (SqlBaseParser.IGNORE - 109)) | (1 << (SqlBaseParser.IMPORT - 109)) | (1 << (SqlBaseParser.INDEX - 109)) | (1 << (SqlBaseParser.INDEXES - 109)) | (1 << (SqlBaseParser.INPATH - 109)) | (1 << (SqlBaseParser.INPUTFORMAT - 109)) | (1 << (SqlBaseParser.INSERT - 109)) | (1 << (SqlBaseParser.INTERVAL - 109)) | (1 << (SqlBaseParser.ITEMS - 109)) | (1 << (SqlBaseParser.KEYS - 109)) | (1 << (SqlBaseParser.LAST - 109)) | (1 << (SqlBaseParser.LATERAL - 109)) | (1 << (SqlBaseParser.LAZY - 109)) | (1 << (SqlBaseParser.LIKE - 109)) | (1 << (SqlBaseParser.LIMIT - 109)) | (1 << (SqlBaseParser.LINES - 109)) | (1 << (SqlBaseParser.LIST - 109)) | (1 << (SqlBaseParser.LOAD - 109)) | (1 << (SqlBaseParser.LOCAL - 109)) | (1 << (SqlBaseParser.LOCATION - 109)) | (1 << (SqlBaseParser.LOCK - 109)) | (1 << (SqlBaseParser.LOCKS - 109)) | (1 << (SqlBaseParser.LOGICAL - 109)))) !== 0) || ((((_la - 141)) & ~0x1f) == 0 && ((1 << (_la - 141)) & ((1 << (SqlBaseParser.MACRO - 141)) | (1 << (SqlBaseParser.MAP - 141)) | (1 << (SqlBaseParser.MATCHED - 141)) | (1 << (SqlBaseParser.MERGE - 141)) | (1 << (SqlBaseParser.MSCK - 141)) | (1 << (SqlBaseParser.NAMESPACE - 141)) | (1 << (SqlBaseParser.NAMESPACES - 141)) | (1 << (SqlBaseParser.NO - 141)) | (1 << (SqlBaseParser.NULLS - 141)) | (1 << (SqlBaseParser.OF - 141)) | (1 << (SqlBaseParser.OPTION - 141)) | (1 << (SqlBaseParser.OPTIONS - 141)) | (1 << (SqlBaseParser.OUT - 141)) | (1 << (SqlBaseParser.OUTPUTFORMAT - 141)) | (1 << (SqlBaseParser.OVER - 141)) | (1 << (SqlBaseParser.OVERLAY - 141)) | (1 << (SqlBaseParser.OVERWRITE - 141)) | (1 << (SqlBaseParser.PARTITION - 141)) | (1 << (SqlBaseParser.PARTITIONED - 141)) | (1 << (SqlBaseParser.PARTITIONS - 141)) | (1 << (SqlBaseParser.PERCENTLIT - 141)) | (1 << (SqlBaseParser.PIVOT - 141)) | (1 << (SqlBaseParser.PLACING - 141)))) !== 0) || ((((_la - 173)) & ~0x1f) == 0 && ((1 << (_la - 173)) & ((1 << (SqlBaseParser.POSITION - 173)) | (1 << (SqlBaseParser.PRECEDING - 173)) | (1 << (SqlBaseParser.PRINCIPALS - 173)) | (1 << (SqlBaseParser.PROPERTIES - 173)) | (1 << (SqlBaseParser.PURGE - 173)) | (1 << (SqlBaseParser.QUERY - 173)) | (1 << (SqlBaseParser.RANGE - 173)) | (1 << (SqlBaseParser.RECORDREADER - 173)) | (1 << (SqlBaseParser.RECORDWRITER - 173)) | (1 << (SqlBaseParser.RECOVER - 173)) | (1 << (SqlBaseParser.REDUCE - 173)) | (1 << (SqlBaseParser.REFRESH - 173)) | (1 << (SqlBaseParser.RENAME - 173)) | (1 << (SqlBaseParser.REPAIR - 173)) | (1 << (SqlBaseParser.REPLACE - 173)) | (1 << (SqlBaseParser.RESET - 173)) | (1 << (SqlBaseParser.RESTRICT - 173)) | (1 << (SqlBaseParser.REVOKE - 173)) | (1 << (SqlBaseParser.RLIKE - 173)) | (1 << (SqlBaseParser.ROLE - 173)) | (1 << (SqlBaseParser.ROLES - 173)) | (1 << (SqlBaseParser.ROLLBACK - 173)) | (1 << (SqlBaseParser.ROLLUP - 173)) | (1 << (SqlBaseParser.ROW - 173)) | (1 << (SqlBaseParser.ROWS - 173)) | (1 << (SqlBaseParser.SCHEMA - 173)) | (1 << (SqlBaseParser.SEMI - 173)) | (1 << (SqlBaseParser.SEPARATED - 173)))) !== 0) || ((((_la - 205)) & ~0x1f) == 0 && ((1 << (_la - 205)) & ((1 << (SqlBaseParser.SERDE - 205)) | (1 << (SqlBaseParser.SERDEPROPERTIES - 205)) | (1 << (SqlBaseParser.SET - 205)) | (1 << (SqlBaseParser.SETMINUS - 205)) | (1 << (SqlBaseParser.SETS - 205)) | (1 << (SqlBaseParser.SHOW - 205)) | (1 << (SqlBaseParser.SKEWED - 205)) | (1 << (SqlBaseParser.SORT - 205)) | (1 << (SqlBaseParser.SORTED - 205)) | (1 << (SqlBaseParser.START - 205)) | (1 << (SqlBaseParser.STATISTICS - 205)) | (1 << (SqlBaseParser.STORED - 205)) | (1 << (SqlBaseParser.STRATIFY - 205)) | (1 << (SqlBaseParser.STRUCT - 205)) | (1 << (SqlBaseParser.SUBSTR - 205)) | (1 << (SqlBaseParser.SUBSTRING - 205)) | (1 << (SqlBaseParser.TABLES - 205)) | (1 << (SqlBaseParser.TABLESAMPLE - 205)) | (1 << (SqlBaseParser.TBLPROPERTIES - 205)) | (1 << (SqlBaseParser.TEMPORARY - 205)) | (1 << (SqlBaseParser.TERMINATED - 205)) | (1 << (SqlBaseParser.TOUCH - 205)) | (1 << (SqlBaseParser.TRANSACTION - 205)) | (1 << (SqlBaseParser.TRANSACTIONS - 205)) | (1 << (SqlBaseParser.TRANSFORM - 205)))) !== 0) || ((((_la - 237)) & ~0x1f) == 0 && ((1 << (_la - 237)) & ((1 << (SqlBaseParser.TRIM - 237)) | (1 << (SqlBaseParser.TRUE - 237)) | (1 << (SqlBaseParser.TRUNCATE - 237)) | (1 << (SqlBaseParser.TYPE - 237)) | (1 << (SqlBaseParser.UNARCHIVE - 237)) | (1 << (SqlBaseParser.UNBOUNDED - 237)) | (1 << (SqlBaseParser.UNCACHE - 237)) | (1 << (SqlBaseParser.UNLOCK - 237)) | (1 << (SqlBaseParser.UNSET - 237)) | (1 << (SqlBaseParser.UPDATE - 237)) | (1 << (SqlBaseParser.USE - 237)) | (1 << (SqlBaseParser.VALUES - 237)) | (1 << (SqlBaseParser.VIEW - 237)) | (1 << (SqlBaseParser.VIEWS - 237)) | (1 << (SqlBaseParser.WINDOW - 237)) | (1 << (SqlBaseParser.ZONE - 237)))) !== 0))) { + if(!(((((_la - 12)) & ~0x1f) == 0 && ((1 << (_la - 12)) & ((1 << (SparkSqlParser.ADD - 12)) | (1 << (SparkSqlParser.AFTER - 12)) | (1 << (SparkSqlParser.ALTER - 12)) | (1 << (SparkSqlParser.ANALYZE - 12)) | (1 << (SparkSqlParser.ANTI - 12)) | (1 << (SparkSqlParser.ARCHIVE - 12)) | (1 << (SparkSqlParser.ARRAY - 12)) | (1 << (SparkSqlParser.ASC - 12)) | (1 << (SparkSqlParser.AT - 12)) | (1 << (SparkSqlParser.BETWEEN - 12)) | (1 << (SparkSqlParser.BUCKET - 12)) | (1 << (SparkSqlParser.BUCKETS - 12)) | (1 << (SparkSqlParser.BY - 12)) | (1 << (SparkSqlParser.CACHE - 12)) | (1 << (SparkSqlParser.CASCADE - 12)) | (1 << (SparkSqlParser.CHANGE - 12)) | (1 << (SparkSqlParser.CLEAR - 12)) | (1 << (SparkSqlParser.CLUSTER - 12)) | (1 << (SparkSqlParser.CLUSTERED - 12)) | (1 << (SparkSqlParser.CODEGEN - 12)) | (1 << (SparkSqlParser.COLLECTION - 12)))) !== 0) || ((((_la - 44)) & ~0x1f) == 0 && ((1 << (_la - 44)) & ((1 << (SparkSqlParser.COLUMNS - 44)) | (1 << (SparkSqlParser.COMMENT - 44)) | (1 << (SparkSqlParser.COMMIT - 44)) | (1 << (SparkSqlParser.COMPACT - 44)) | (1 << (SparkSqlParser.COMPACTIONS - 44)) | (1 << (SparkSqlParser.COMPUTE - 44)) | (1 << (SparkSqlParser.CONCATENATE - 44)) | (1 << (SparkSqlParser.COST - 44)) | (1 << (SparkSqlParser.CUBE - 44)) | (1 << (SparkSqlParser.CURRENT - 44)) | (1 << (SparkSqlParser.DATA - 44)) | (1 << (SparkSqlParser.DATABASE - 44)) | (1 << (SparkSqlParser.DATABASES - 44)) | (1 << (SparkSqlParser.DBPROPERTIES - 44)) | (1 << (SparkSqlParser.DEFINED - 44)) | (1 << (SparkSqlParser.DELETE - 44)) | (1 << (SparkSqlParser.DELIMITED - 44)) | (1 << (SparkSqlParser.DESC - 44)) | (1 << (SparkSqlParser.DESCRIBE - 44)) | (1 << (SparkSqlParser.DFS - 44)) | (1 << (SparkSqlParser.DIRECTORIES - 44)) | (1 << (SparkSqlParser.DIRECTORY - 44)) | (1 << (SparkSqlParser.DISTRIBUTE - 44)) | (1 << (SparkSqlParser.DIV - 44)))) !== 0) || ((((_la - 76)) & ~0x1f) == 0 && ((1 << (_la - 76)) & ((1 << (SparkSqlParser.DROP - 76)) | (1 << (SparkSqlParser.ESCAPED - 76)) | (1 << (SparkSqlParser.EXCHANGE - 76)) | (1 << (SparkSqlParser.EXISTS - 76)) | (1 << (SparkSqlParser.EXPLAIN - 76)) | (1 << (SparkSqlParser.EXPORT - 76)) | (1 << (SparkSqlParser.EXTENDED - 76)) | (1 << (SparkSqlParser.EXTERNAL - 76)) | (1 << (SparkSqlParser.EXTRACT - 76)) | (1 << (SparkSqlParser.FIELDS - 76)) | (1 << (SparkSqlParser.FILEFORMAT - 76)) | (1 << (SparkSqlParser.FIRST - 76)) | (1 << (SparkSqlParser.FOLLOWING - 76)) | (1 << (SparkSqlParser.FORMAT - 76)) | (1 << (SparkSqlParser.FORMATTED - 76)) | (1 << (SparkSqlParser.FUNCTION - 76)) | (1 << (SparkSqlParser.FUNCTIONS - 76)) | (1 << (SparkSqlParser.GLOBAL - 76)) | (1 << (SparkSqlParser.GROUPING - 76)))) !== 0) || ((((_la - 109)) & ~0x1f) == 0 && ((1 << (_la - 109)) & ((1 << (SparkSqlParser.IF - 109)) | (1 << (SparkSqlParser.IGNORE - 109)) | (1 << (SparkSqlParser.IMPORT - 109)) | (1 << (SparkSqlParser.INDEX - 109)) | (1 << (SparkSqlParser.INDEXES - 109)) | (1 << (SparkSqlParser.INPATH - 109)) | (1 << (SparkSqlParser.INPUTFORMAT - 109)) | (1 << (SparkSqlParser.INSERT - 109)) | (1 << (SparkSqlParser.INTERVAL - 109)) | (1 << (SparkSqlParser.ITEMS - 109)) | (1 << (SparkSqlParser.KEYS - 109)) | (1 << (SparkSqlParser.LAST - 109)) | (1 << (SparkSqlParser.LATERAL - 109)) | (1 << (SparkSqlParser.LAZY - 109)) | (1 << (SparkSqlParser.LIKE - 109)) | (1 << (SparkSqlParser.LIMIT - 109)) | (1 << (SparkSqlParser.LINES - 109)) | (1 << (SparkSqlParser.LIST - 109)) | (1 << (SparkSqlParser.LOAD - 109)) | (1 << (SparkSqlParser.LOCAL - 109)) | (1 << (SparkSqlParser.LOCATION - 109)) | (1 << (SparkSqlParser.LOCK - 109)) | (1 << (SparkSqlParser.LOCKS - 109)) | (1 << (SparkSqlParser.LOGICAL - 109)))) !== 0) || ((((_la - 141)) & ~0x1f) == 0 && ((1 << (_la - 141)) & ((1 << (SparkSqlParser.MACRO - 141)) | (1 << (SparkSqlParser.MAP - 141)) | (1 << (SparkSqlParser.MATCHED - 141)) | (1 << (SparkSqlParser.MERGE - 141)) | (1 << (SparkSqlParser.MSCK - 141)) | (1 << (SparkSqlParser.NAMESPACE - 141)) | (1 << (SparkSqlParser.NAMESPACES - 141)) | (1 << (SparkSqlParser.NO - 141)) | (1 << (SparkSqlParser.NULLS - 141)) | (1 << (SparkSqlParser.OF - 141)) | (1 << (SparkSqlParser.OPTION - 141)) | (1 << (SparkSqlParser.OPTIONS - 141)) | (1 << (SparkSqlParser.OUT - 141)) | (1 << (SparkSqlParser.OUTPUTFORMAT - 141)) | (1 << (SparkSqlParser.OVER - 141)) | (1 << (SparkSqlParser.OVERLAY - 141)) | (1 << (SparkSqlParser.OVERWRITE - 141)) | (1 << (SparkSqlParser.PARTITION - 141)) | (1 << (SparkSqlParser.PARTITIONED - 141)) | (1 << (SparkSqlParser.PARTITIONS - 141)) | (1 << (SparkSqlParser.PERCENTLIT - 141)) | (1 << (SparkSqlParser.PIVOT - 141)) | (1 << (SparkSqlParser.PLACING - 141)))) !== 0) || ((((_la - 173)) & ~0x1f) == 0 && ((1 << (_la - 173)) & ((1 << (SparkSqlParser.POSITION - 173)) | (1 << (SparkSqlParser.PRECEDING - 173)) | (1 << (SparkSqlParser.PRINCIPALS - 173)) | (1 << (SparkSqlParser.PROPERTIES - 173)) | (1 << (SparkSqlParser.PURGE - 173)) | (1 << (SparkSqlParser.QUERY - 173)) | (1 << (SparkSqlParser.RANGE - 173)) | (1 << (SparkSqlParser.RECORDREADER - 173)) | (1 << (SparkSqlParser.RECORDWRITER - 173)) | (1 << (SparkSqlParser.RECOVER - 173)) | (1 << (SparkSqlParser.REDUCE - 173)) | (1 << (SparkSqlParser.REFRESH - 173)) | (1 << (SparkSqlParser.RENAME - 173)) | (1 << (SparkSqlParser.REPAIR - 173)) | (1 << (SparkSqlParser.REPLACE - 173)) | (1 << (SparkSqlParser.RESET - 173)) | (1 << (SparkSqlParser.RESTRICT - 173)) | (1 << (SparkSqlParser.REVOKE - 173)) | (1 << (SparkSqlParser.RLIKE - 173)) | (1 << (SparkSqlParser.ROLE - 173)) | (1 << (SparkSqlParser.ROLES - 173)) | (1 << (SparkSqlParser.ROLLBACK - 173)) | (1 << (SparkSqlParser.ROLLUP - 173)) | (1 << (SparkSqlParser.ROW - 173)) | (1 << (SparkSqlParser.ROWS - 173)) | (1 << (SparkSqlParser.SCHEMA - 173)) | (1 << (SparkSqlParser.SEMI - 173)) | (1 << (SparkSqlParser.SEPARATED - 173)))) !== 0) || ((((_la - 205)) & ~0x1f) == 0 && ((1 << (_la - 205)) & ((1 << (SparkSqlParser.SERDE - 205)) | (1 << (SparkSqlParser.SERDEPROPERTIES - 205)) | (1 << (SparkSqlParser.SET - 205)) | (1 << (SparkSqlParser.SETMINUS - 205)) | (1 << (SparkSqlParser.SETS - 205)) | (1 << (SparkSqlParser.SHOW - 205)) | (1 << (SparkSqlParser.SKEWED - 205)) | (1 << (SparkSqlParser.SORT - 205)) | (1 << (SparkSqlParser.SORTED - 205)) | (1 << (SparkSqlParser.START - 205)) | (1 << (SparkSqlParser.STATISTICS - 205)) | (1 << (SparkSqlParser.STORED - 205)) | (1 << (SparkSqlParser.STRATIFY - 205)) | (1 << (SparkSqlParser.STRUCT - 205)) | (1 << (SparkSqlParser.SUBSTR - 205)) | (1 << (SparkSqlParser.SUBSTRING - 205)) | (1 << (SparkSqlParser.TABLES - 205)) | (1 << (SparkSqlParser.TABLESAMPLE - 205)) | (1 << (SparkSqlParser.TBLPROPERTIES - 205)) | (1 << (SparkSqlParser.TEMPORARY - 205)) | (1 << (SparkSqlParser.TERMINATED - 205)) | (1 << (SparkSqlParser.TOUCH - 205)) | (1 << (SparkSqlParser.TRANSACTION - 205)) | (1 << (SparkSqlParser.TRANSACTIONS - 205)) | (1 << (SparkSqlParser.TRANSFORM - 205)))) !== 0) || ((((_la - 237)) & ~0x1f) == 0 && ((1 << (_la - 237)) & ((1 << (SparkSqlParser.TRIM - 237)) | (1 << (SparkSqlParser.TRUE - 237)) | (1 << (SparkSqlParser.TRUNCATE - 237)) | (1 << (SparkSqlParser.TYPE - 237)) | (1 << (SparkSqlParser.UNARCHIVE - 237)) | (1 << (SparkSqlParser.UNBOUNDED - 237)) | (1 << (SparkSqlParser.UNCACHE - 237)) | (1 << (SparkSqlParser.UNLOCK - 237)) | (1 << (SparkSqlParser.UNSET - 237)) | (1 << (SparkSqlParser.UPDATE - 237)) | (1 << (SparkSqlParser.USE - 237)) | (1 << (SparkSqlParser.VALUES - 237)) | (1 << (SparkSqlParser.VIEW - 237)) | (1 << (SparkSqlParser.VIEWS - 237)) | (1 << (SparkSqlParser.WINDOW - 237)) | (1 << (SparkSqlParser.ZONE - 237)))) !== 0))) { this._errHandler.recoverInline(this); } else { @@ -30036,7 +30036,7 @@ function StrictNonReservedContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_strictNonReserved; + this.ruleIndex = SparkSqlParser.RULE_strictNonReserved; return this; } @@ -30044,79 +30044,79 @@ StrictNonReservedContext.prototype = Object.create(antlr4.ParserRuleContext.prot StrictNonReservedContext.prototype.constructor = StrictNonReservedContext; StrictNonReservedContext.prototype.ANTI = function() { - return this.getToken(SqlBaseParser.ANTI, 0); + return this.getToken(SparkSqlParser.ANTI, 0); }; StrictNonReservedContext.prototype.CROSS = function() { - return this.getToken(SqlBaseParser.CROSS, 0); + return this.getToken(SparkSqlParser.CROSS, 0); }; StrictNonReservedContext.prototype.EXCEPT = function() { - return this.getToken(SqlBaseParser.EXCEPT, 0); + return this.getToken(SparkSqlParser.EXCEPT, 0); }; StrictNonReservedContext.prototype.FULL = function() { - return this.getToken(SqlBaseParser.FULL, 0); + return this.getToken(SparkSqlParser.FULL, 0); }; StrictNonReservedContext.prototype.INNER = function() { - return this.getToken(SqlBaseParser.INNER, 0); + return this.getToken(SparkSqlParser.INNER, 0); }; StrictNonReservedContext.prototype.INTERSECT = function() { - return this.getToken(SqlBaseParser.INTERSECT, 0); + return this.getToken(SparkSqlParser.INTERSECT, 0); }; StrictNonReservedContext.prototype.JOIN = function() { - return this.getToken(SqlBaseParser.JOIN, 0); + return this.getToken(SparkSqlParser.JOIN, 0); }; StrictNonReservedContext.prototype.LEFT = function() { - return this.getToken(SqlBaseParser.LEFT, 0); + return this.getToken(SparkSqlParser.LEFT, 0); }; StrictNonReservedContext.prototype.NATURAL = function() { - return this.getToken(SqlBaseParser.NATURAL, 0); + return this.getToken(SparkSqlParser.NATURAL, 0); }; StrictNonReservedContext.prototype.ON = function() { - return this.getToken(SqlBaseParser.ON, 0); + return this.getToken(SparkSqlParser.ON, 0); }; StrictNonReservedContext.prototype.RIGHT = function() { - return this.getToken(SqlBaseParser.RIGHT, 0); + return this.getToken(SparkSqlParser.RIGHT, 0); }; StrictNonReservedContext.prototype.SEMI = function() { - return this.getToken(SqlBaseParser.SEMI, 0); + return this.getToken(SparkSqlParser.SEMI, 0); }; StrictNonReservedContext.prototype.SETMINUS = function() { - return this.getToken(SqlBaseParser.SETMINUS, 0); + return this.getToken(SparkSqlParser.SETMINUS, 0); }; StrictNonReservedContext.prototype.UNION = function() { - return this.getToken(SqlBaseParser.UNION, 0); + return this.getToken(SparkSqlParser.UNION, 0); }; StrictNonReservedContext.prototype.USING = function() { - return this.getToken(SqlBaseParser.USING, 0); + return this.getToken(SparkSqlParser.USING, 0); }; StrictNonReservedContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterStrictNonReserved(this); } }; StrictNonReservedContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitStrictNonReserved(this); } }; StrictNonReservedContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitStrictNonReserved(this); } else { return visitor.visitChildren(this); @@ -30126,18 +30126,18 @@ StrictNonReservedContext.prototype.accept = function(visitor) { -SqlBaseParser.StrictNonReservedContext = StrictNonReservedContext; +SparkSqlParser.StrictNonReservedContext = StrictNonReservedContext; -SqlBaseParser.prototype.strictNonReserved = function() { +SparkSqlParser.prototype.strictNonReserved = function() { var localctx = new StrictNonReservedContext(this, this._ctx, this.state); - this.enterRule(localctx, 268, SqlBaseParser.RULE_strictNonReserved); + this.enterRule(localctx, 268, SparkSqlParser.RULE_strictNonReserved); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 3021; _la = this._input.LA(1); - if(!(_la===SqlBaseParser.ANTI || _la===SqlBaseParser.CROSS || _la===SqlBaseParser.EXCEPT || ((((_la - 101)) & ~0x1f) == 0 && ((1 << (_la - 101)) & ((1 << (SqlBaseParser.FULL - 101)) | (1 << (SqlBaseParser.INNER - 101)) | (1 << (SqlBaseParser.INTERSECT - 101)) | (1 << (SqlBaseParser.JOIN - 101)) | (1 << (SqlBaseParser.LEFT - 101)))) !== 0) || _la===SqlBaseParser.NATURAL || _la===SqlBaseParser.ON || ((((_la - 193)) & ~0x1f) == 0 && ((1 << (_la - 193)) & ((1 << (SqlBaseParser.RIGHT - 193)) | (1 << (SqlBaseParser.SEMI - 193)) | (1 << (SqlBaseParser.SETMINUS - 193)))) !== 0) || _la===SqlBaseParser.UNION || _la===SqlBaseParser.USING)) { + if(!(_la===SparkSqlParser.ANTI || _la===SparkSqlParser.CROSS || _la===SparkSqlParser.EXCEPT || ((((_la - 101)) & ~0x1f) == 0 && ((1 << (_la - 101)) & ((1 << (SparkSqlParser.FULL - 101)) | (1 << (SparkSqlParser.INNER - 101)) | (1 << (SparkSqlParser.INTERSECT - 101)) | (1 << (SparkSqlParser.JOIN - 101)) | (1 << (SparkSqlParser.LEFT - 101)))) !== 0) || _la===SparkSqlParser.NATURAL || _la===SparkSqlParser.ON || ((((_la - 193)) & ~0x1f) == 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.RIGHT - 193)) | (1 << (SparkSqlParser.SEMI - 193)) | (1 << (SparkSqlParser.SETMINUS - 193)))) !== 0) || _la===SparkSqlParser.UNION || _la===SparkSqlParser.USING)) { this._errHandler.recoverInline(this); } else { @@ -30168,7 +30168,7 @@ function NonReservedContext(parser, parent, invokingState) { } antlr4.ParserRuleContext.call(this, parent, invokingState); this.parser = parser; - this.ruleIndex = SqlBaseParser.RULE_nonReserved; + this.ruleIndex = SparkSqlParser.RULE_nonReserved; return this; } @@ -30176,955 +30176,955 @@ NonReservedContext.prototype = Object.create(antlr4.ParserRuleContext.prototype) NonReservedContext.prototype.constructor = NonReservedContext; NonReservedContext.prototype.ADD = function() { - return this.getToken(SqlBaseParser.ADD, 0); + return this.getToken(SparkSqlParser.ADD, 0); }; NonReservedContext.prototype.AFTER = function() { - return this.getToken(SqlBaseParser.AFTER, 0); + return this.getToken(SparkSqlParser.AFTER, 0); }; NonReservedContext.prototype.ALL = function() { - return this.getToken(SqlBaseParser.ALL, 0); + return this.getToken(SparkSqlParser.ALL, 0); }; NonReservedContext.prototype.ALTER = function() { - return this.getToken(SqlBaseParser.ALTER, 0); + return this.getToken(SparkSqlParser.ALTER, 0); }; NonReservedContext.prototype.ANALYZE = function() { - return this.getToken(SqlBaseParser.ANALYZE, 0); + return this.getToken(SparkSqlParser.ANALYZE, 0); }; NonReservedContext.prototype.AND = function() { - return this.getToken(SqlBaseParser.AND, 0); + return this.getToken(SparkSqlParser.AND, 0); }; NonReservedContext.prototype.ANY = function() { - return this.getToken(SqlBaseParser.ANY, 0); + return this.getToken(SparkSqlParser.ANY, 0); }; NonReservedContext.prototype.ARCHIVE = function() { - return this.getToken(SqlBaseParser.ARCHIVE, 0); + return this.getToken(SparkSqlParser.ARCHIVE, 0); }; NonReservedContext.prototype.ARRAY = function() { - return this.getToken(SqlBaseParser.ARRAY, 0); + return this.getToken(SparkSqlParser.ARRAY, 0); }; NonReservedContext.prototype.AS = function() { - return this.getToken(SqlBaseParser.AS, 0); + return this.getToken(SparkSqlParser.AS, 0); }; NonReservedContext.prototype.ASC = function() { - return this.getToken(SqlBaseParser.ASC, 0); + return this.getToken(SparkSqlParser.ASC, 0); }; NonReservedContext.prototype.AT = function() { - return this.getToken(SqlBaseParser.AT, 0); + return this.getToken(SparkSqlParser.AT, 0); }; NonReservedContext.prototype.AUTHORIZATION = function() { - return this.getToken(SqlBaseParser.AUTHORIZATION, 0); + return this.getToken(SparkSqlParser.AUTHORIZATION, 0); }; NonReservedContext.prototype.BETWEEN = function() { - return this.getToken(SqlBaseParser.BETWEEN, 0); + return this.getToken(SparkSqlParser.BETWEEN, 0); }; NonReservedContext.prototype.BOTH = function() { - return this.getToken(SqlBaseParser.BOTH, 0); + return this.getToken(SparkSqlParser.BOTH, 0); }; NonReservedContext.prototype.BUCKET = function() { - return this.getToken(SqlBaseParser.BUCKET, 0); + return this.getToken(SparkSqlParser.BUCKET, 0); }; NonReservedContext.prototype.BUCKETS = function() { - return this.getToken(SqlBaseParser.BUCKETS, 0); + return this.getToken(SparkSqlParser.BUCKETS, 0); }; NonReservedContext.prototype.BY = function() { - return this.getToken(SqlBaseParser.BY, 0); + return this.getToken(SparkSqlParser.BY, 0); }; NonReservedContext.prototype.CACHE = function() { - return this.getToken(SqlBaseParser.CACHE, 0); + return this.getToken(SparkSqlParser.CACHE, 0); }; NonReservedContext.prototype.CASCADE = function() { - return this.getToken(SqlBaseParser.CASCADE, 0); + return this.getToken(SparkSqlParser.CASCADE, 0); }; NonReservedContext.prototype.CASE = function() { - return this.getToken(SqlBaseParser.CASE, 0); + return this.getToken(SparkSqlParser.CASE, 0); }; NonReservedContext.prototype.CAST = function() { - return this.getToken(SqlBaseParser.CAST, 0); + return this.getToken(SparkSqlParser.CAST, 0); }; NonReservedContext.prototype.CHANGE = function() { - return this.getToken(SqlBaseParser.CHANGE, 0); + return this.getToken(SparkSqlParser.CHANGE, 0); }; NonReservedContext.prototype.CHECK = function() { - return this.getToken(SqlBaseParser.CHECK, 0); + return this.getToken(SparkSqlParser.CHECK, 0); }; NonReservedContext.prototype.CLEAR = function() { - return this.getToken(SqlBaseParser.CLEAR, 0); + return this.getToken(SparkSqlParser.CLEAR, 0); }; NonReservedContext.prototype.CLUSTER = function() { - return this.getToken(SqlBaseParser.CLUSTER, 0); + return this.getToken(SparkSqlParser.CLUSTER, 0); }; NonReservedContext.prototype.CLUSTERED = function() { - return this.getToken(SqlBaseParser.CLUSTERED, 0); + return this.getToken(SparkSqlParser.CLUSTERED, 0); }; NonReservedContext.prototype.CODEGEN = function() { - return this.getToken(SqlBaseParser.CODEGEN, 0); + return this.getToken(SparkSqlParser.CODEGEN, 0); }; NonReservedContext.prototype.COLLATE = function() { - return this.getToken(SqlBaseParser.COLLATE, 0); + return this.getToken(SparkSqlParser.COLLATE, 0); }; NonReservedContext.prototype.COLLECTION = function() { - return this.getToken(SqlBaseParser.COLLECTION, 0); + return this.getToken(SparkSqlParser.COLLECTION, 0); }; NonReservedContext.prototype.COLUMN = function() { - return this.getToken(SqlBaseParser.COLUMN, 0); + return this.getToken(SparkSqlParser.COLUMN, 0); }; NonReservedContext.prototype.COLUMNS = function() { - return this.getToken(SqlBaseParser.COLUMNS, 0); + return this.getToken(SparkSqlParser.COLUMNS, 0); }; NonReservedContext.prototype.COMMENT = function() { - return this.getToken(SqlBaseParser.COMMENT, 0); + return this.getToken(SparkSqlParser.COMMENT, 0); }; NonReservedContext.prototype.COMMIT = function() { - return this.getToken(SqlBaseParser.COMMIT, 0); + return this.getToken(SparkSqlParser.COMMIT, 0); }; NonReservedContext.prototype.COMPACT = function() { - return this.getToken(SqlBaseParser.COMPACT, 0); + return this.getToken(SparkSqlParser.COMPACT, 0); }; NonReservedContext.prototype.COMPACTIONS = function() { - return this.getToken(SqlBaseParser.COMPACTIONS, 0); + return this.getToken(SparkSqlParser.COMPACTIONS, 0); }; NonReservedContext.prototype.COMPUTE = function() { - return this.getToken(SqlBaseParser.COMPUTE, 0); + return this.getToken(SparkSqlParser.COMPUTE, 0); }; NonReservedContext.prototype.CONCATENATE = function() { - return this.getToken(SqlBaseParser.CONCATENATE, 0); + return this.getToken(SparkSqlParser.CONCATENATE, 0); }; NonReservedContext.prototype.CONSTRAINT = function() { - return this.getToken(SqlBaseParser.CONSTRAINT, 0); + return this.getToken(SparkSqlParser.CONSTRAINT, 0); }; NonReservedContext.prototype.COST = function() { - return this.getToken(SqlBaseParser.COST, 0); + return this.getToken(SparkSqlParser.COST, 0); }; NonReservedContext.prototype.CREATE = function() { - return this.getToken(SqlBaseParser.CREATE, 0); + return this.getToken(SparkSqlParser.CREATE, 0); }; NonReservedContext.prototype.CUBE = function() { - return this.getToken(SqlBaseParser.CUBE, 0); + return this.getToken(SparkSqlParser.CUBE, 0); }; NonReservedContext.prototype.CURRENT = function() { - return this.getToken(SqlBaseParser.CURRENT, 0); + return this.getToken(SparkSqlParser.CURRENT, 0); }; NonReservedContext.prototype.CURRENT_DATE = function() { - return this.getToken(SqlBaseParser.CURRENT_DATE, 0); + return this.getToken(SparkSqlParser.CURRENT_DATE, 0); }; NonReservedContext.prototype.CURRENT_TIME = function() { - return this.getToken(SqlBaseParser.CURRENT_TIME, 0); + return this.getToken(SparkSqlParser.CURRENT_TIME, 0); }; NonReservedContext.prototype.CURRENT_TIMESTAMP = function() { - return this.getToken(SqlBaseParser.CURRENT_TIMESTAMP, 0); + return this.getToken(SparkSqlParser.CURRENT_TIMESTAMP, 0); }; NonReservedContext.prototype.CURRENT_USER = function() { - return this.getToken(SqlBaseParser.CURRENT_USER, 0); + return this.getToken(SparkSqlParser.CURRENT_USER, 0); }; NonReservedContext.prototype.DATA = function() { - return this.getToken(SqlBaseParser.DATA, 0); + return this.getToken(SparkSqlParser.DATA, 0); }; NonReservedContext.prototype.DATABASE = function() { - return this.getToken(SqlBaseParser.DATABASE, 0); + return this.getToken(SparkSqlParser.DATABASE, 0); }; NonReservedContext.prototype.DATABASES = function() { - return this.getToken(SqlBaseParser.DATABASES, 0); + return this.getToken(SparkSqlParser.DATABASES, 0); }; NonReservedContext.prototype.DBPROPERTIES = function() { - return this.getToken(SqlBaseParser.DBPROPERTIES, 0); + return this.getToken(SparkSqlParser.DBPROPERTIES, 0); }; NonReservedContext.prototype.DEFINED = function() { - return this.getToken(SqlBaseParser.DEFINED, 0); + return this.getToken(SparkSqlParser.DEFINED, 0); }; NonReservedContext.prototype.DELETE = function() { - return this.getToken(SqlBaseParser.DELETE, 0); + return this.getToken(SparkSqlParser.DELETE, 0); }; NonReservedContext.prototype.DELIMITED = function() { - return this.getToken(SqlBaseParser.DELIMITED, 0); + return this.getToken(SparkSqlParser.DELIMITED, 0); }; NonReservedContext.prototype.DESC = function() { - return this.getToken(SqlBaseParser.DESC, 0); + return this.getToken(SparkSqlParser.DESC, 0); }; NonReservedContext.prototype.DESCRIBE = function() { - return this.getToken(SqlBaseParser.DESCRIBE, 0); + return this.getToken(SparkSqlParser.DESCRIBE, 0); }; NonReservedContext.prototype.DFS = function() { - return this.getToken(SqlBaseParser.DFS, 0); + return this.getToken(SparkSqlParser.DFS, 0); }; NonReservedContext.prototype.DIRECTORIES = function() { - return this.getToken(SqlBaseParser.DIRECTORIES, 0); + return this.getToken(SparkSqlParser.DIRECTORIES, 0); }; NonReservedContext.prototype.DIRECTORY = function() { - return this.getToken(SqlBaseParser.DIRECTORY, 0); + return this.getToken(SparkSqlParser.DIRECTORY, 0); }; NonReservedContext.prototype.DISTINCT = function() { - return this.getToken(SqlBaseParser.DISTINCT, 0); + return this.getToken(SparkSqlParser.DISTINCT, 0); }; NonReservedContext.prototype.DISTRIBUTE = function() { - return this.getToken(SqlBaseParser.DISTRIBUTE, 0); + return this.getToken(SparkSqlParser.DISTRIBUTE, 0); }; NonReservedContext.prototype.DIV = function() { - return this.getToken(SqlBaseParser.DIV, 0); + return this.getToken(SparkSqlParser.DIV, 0); }; NonReservedContext.prototype.DROP = function() { - return this.getToken(SqlBaseParser.DROP, 0); + return this.getToken(SparkSqlParser.DROP, 0); }; NonReservedContext.prototype.ELSE = function() { - return this.getToken(SqlBaseParser.ELSE, 0); + return this.getToken(SparkSqlParser.ELSE, 0); }; NonReservedContext.prototype.END = function() { - return this.getToken(SqlBaseParser.END, 0); + return this.getToken(SparkSqlParser.END, 0); }; NonReservedContext.prototype.ESCAPE = function() { - return this.getToken(SqlBaseParser.ESCAPE, 0); + return this.getToken(SparkSqlParser.ESCAPE, 0); }; NonReservedContext.prototype.ESCAPED = function() { - return this.getToken(SqlBaseParser.ESCAPED, 0); + return this.getToken(SparkSqlParser.ESCAPED, 0); }; NonReservedContext.prototype.EXCHANGE = function() { - return this.getToken(SqlBaseParser.EXCHANGE, 0); + return this.getToken(SparkSqlParser.EXCHANGE, 0); }; NonReservedContext.prototype.EXISTS = function() { - return this.getToken(SqlBaseParser.EXISTS, 0); + return this.getToken(SparkSqlParser.EXISTS, 0); }; NonReservedContext.prototype.EXPLAIN = function() { - return this.getToken(SqlBaseParser.EXPLAIN, 0); + return this.getToken(SparkSqlParser.EXPLAIN, 0); }; NonReservedContext.prototype.EXPORT = function() { - return this.getToken(SqlBaseParser.EXPORT, 0); + return this.getToken(SparkSqlParser.EXPORT, 0); }; NonReservedContext.prototype.EXTENDED = function() { - return this.getToken(SqlBaseParser.EXTENDED, 0); + return this.getToken(SparkSqlParser.EXTENDED, 0); }; NonReservedContext.prototype.EXTERNAL = function() { - return this.getToken(SqlBaseParser.EXTERNAL, 0); + return this.getToken(SparkSqlParser.EXTERNAL, 0); }; NonReservedContext.prototype.EXTRACT = function() { - return this.getToken(SqlBaseParser.EXTRACT, 0); + return this.getToken(SparkSqlParser.EXTRACT, 0); }; NonReservedContext.prototype.FALSE = function() { - return this.getToken(SqlBaseParser.FALSE, 0); + return this.getToken(SparkSqlParser.FALSE, 0); }; NonReservedContext.prototype.FETCH = function() { - return this.getToken(SqlBaseParser.FETCH, 0); + return this.getToken(SparkSqlParser.FETCH, 0); }; NonReservedContext.prototype.FILTER = function() { - return this.getToken(SqlBaseParser.FILTER, 0); + return this.getToken(SparkSqlParser.FILTER, 0); }; NonReservedContext.prototype.FIELDS = function() { - return this.getToken(SqlBaseParser.FIELDS, 0); + return this.getToken(SparkSqlParser.FIELDS, 0); }; NonReservedContext.prototype.FILEFORMAT = function() { - return this.getToken(SqlBaseParser.FILEFORMAT, 0); + return this.getToken(SparkSqlParser.FILEFORMAT, 0); }; NonReservedContext.prototype.FIRST = function() { - return this.getToken(SqlBaseParser.FIRST, 0); + return this.getToken(SparkSqlParser.FIRST, 0); }; NonReservedContext.prototype.FOLLOWING = function() { - return this.getToken(SqlBaseParser.FOLLOWING, 0); + return this.getToken(SparkSqlParser.FOLLOWING, 0); }; NonReservedContext.prototype.FOR = function() { - return this.getToken(SqlBaseParser.FOR, 0); + return this.getToken(SparkSqlParser.FOR, 0); }; NonReservedContext.prototype.FOREIGN = function() { - return this.getToken(SqlBaseParser.FOREIGN, 0); + return this.getToken(SparkSqlParser.FOREIGN, 0); }; NonReservedContext.prototype.FORMAT = function() { - return this.getToken(SqlBaseParser.FORMAT, 0); + return this.getToken(SparkSqlParser.FORMAT, 0); }; NonReservedContext.prototype.FORMATTED = function() { - return this.getToken(SqlBaseParser.FORMATTED, 0); + return this.getToken(SparkSqlParser.FORMATTED, 0); }; NonReservedContext.prototype.FROM = function() { - return this.getToken(SqlBaseParser.FROM, 0); + return this.getToken(SparkSqlParser.FROM, 0); }; NonReservedContext.prototype.FUNCTION = function() { - return this.getToken(SqlBaseParser.FUNCTION, 0); + return this.getToken(SparkSqlParser.FUNCTION, 0); }; NonReservedContext.prototype.FUNCTIONS = function() { - return this.getToken(SqlBaseParser.FUNCTIONS, 0); + return this.getToken(SparkSqlParser.FUNCTIONS, 0); }; NonReservedContext.prototype.GLOBAL = function() { - return this.getToken(SqlBaseParser.GLOBAL, 0); + return this.getToken(SparkSqlParser.GLOBAL, 0); }; NonReservedContext.prototype.GRANT = function() { - return this.getToken(SqlBaseParser.GRANT, 0); + return this.getToken(SparkSqlParser.GRANT, 0); }; NonReservedContext.prototype.GROUP = function() { - return this.getToken(SqlBaseParser.GROUP, 0); + return this.getToken(SparkSqlParser.GROUP, 0); }; NonReservedContext.prototype.GROUPING = function() { - return this.getToken(SqlBaseParser.GROUPING, 0); + return this.getToken(SparkSqlParser.GROUPING, 0); }; NonReservedContext.prototype.HAVING = function() { - return this.getToken(SqlBaseParser.HAVING, 0); + return this.getToken(SparkSqlParser.HAVING, 0); }; NonReservedContext.prototype.IF = function() { - return this.getToken(SqlBaseParser.IF, 0); + return this.getToken(SparkSqlParser.IF, 0); }; NonReservedContext.prototype.IGNORE = function() { - return this.getToken(SqlBaseParser.IGNORE, 0); + return this.getToken(SparkSqlParser.IGNORE, 0); }; NonReservedContext.prototype.IMPORT = function() { - return this.getToken(SqlBaseParser.IMPORT, 0); + return this.getToken(SparkSqlParser.IMPORT, 0); }; NonReservedContext.prototype.IN = function() { - return this.getToken(SqlBaseParser.IN, 0); + return this.getToken(SparkSqlParser.IN, 0); }; NonReservedContext.prototype.INDEX = function() { - return this.getToken(SqlBaseParser.INDEX, 0); + return this.getToken(SparkSqlParser.INDEX, 0); }; NonReservedContext.prototype.INDEXES = function() { - return this.getToken(SqlBaseParser.INDEXES, 0); + return this.getToken(SparkSqlParser.INDEXES, 0); }; NonReservedContext.prototype.INPATH = function() { - return this.getToken(SqlBaseParser.INPATH, 0); + return this.getToken(SparkSqlParser.INPATH, 0); }; NonReservedContext.prototype.INPUTFORMAT = function() { - return this.getToken(SqlBaseParser.INPUTFORMAT, 0); + return this.getToken(SparkSqlParser.INPUTFORMAT, 0); }; NonReservedContext.prototype.INSERT = function() { - return this.getToken(SqlBaseParser.INSERT, 0); + return this.getToken(SparkSqlParser.INSERT, 0); }; NonReservedContext.prototype.INTERVAL = function() { - return this.getToken(SqlBaseParser.INTERVAL, 0); + return this.getToken(SparkSqlParser.INTERVAL, 0); }; NonReservedContext.prototype.INTO = function() { - return this.getToken(SqlBaseParser.INTO, 0); + return this.getToken(SparkSqlParser.INTO, 0); }; NonReservedContext.prototype.IS = function() { - return this.getToken(SqlBaseParser.IS, 0); + return this.getToken(SparkSqlParser.IS, 0); }; NonReservedContext.prototype.ITEMS = function() { - return this.getToken(SqlBaseParser.ITEMS, 0); + return this.getToken(SparkSqlParser.ITEMS, 0); }; NonReservedContext.prototype.KEYS = function() { - return this.getToken(SqlBaseParser.KEYS, 0); + return this.getToken(SparkSqlParser.KEYS, 0); }; NonReservedContext.prototype.LAST = function() { - return this.getToken(SqlBaseParser.LAST, 0); + return this.getToken(SparkSqlParser.LAST, 0); }; NonReservedContext.prototype.LATERAL = function() { - return this.getToken(SqlBaseParser.LATERAL, 0); + return this.getToken(SparkSqlParser.LATERAL, 0); }; NonReservedContext.prototype.LAZY = function() { - return this.getToken(SqlBaseParser.LAZY, 0); + return this.getToken(SparkSqlParser.LAZY, 0); }; NonReservedContext.prototype.LEADING = function() { - return this.getToken(SqlBaseParser.LEADING, 0); + return this.getToken(SparkSqlParser.LEADING, 0); }; NonReservedContext.prototype.LIKE = function() { - return this.getToken(SqlBaseParser.LIKE, 0); + return this.getToken(SparkSqlParser.LIKE, 0); }; NonReservedContext.prototype.LIMIT = function() { - return this.getToken(SqlBaseParser.LIMIT, 0); + return this.getToken(SparkSqlParser.LIMIT, 0); }; NonReservedContext.prototype.LINES = function() { - return this.getToken(SqlBaseParser.LINES, 0); + return this.getToken(SparkSqlParser.LINES, 0); }; NonReservedContext.prototype.LIST = function() { - return this.getToken(SqlBaseParser.LIST, 0); + return this.getToken(SparkSqlParser.LIST, 0); }; NonReservedContext.prototype.LOAD = function() { - return this.getToken(SqlBaseParser.LOAD, 0); + return this.getToken(SparkSqlParser.LOAD, 0); }; NonReservedContext.prototype.LOCAL = function() { - return this.getToken(SqlBaseParser.LOCAL, 0); + return this.getToken(SparkSqlParser.LOCAL, 0); }; NonReservedContext.prototype.LOCATION = function() { - return this.getToken(SqlBaseParser.LOCATION, 0); + return this.getToken(SparkSqlParser.LOCATION, 0); }; NonReservedContext.prototype.LOCK = function() { - return this.getToken(SqlBaseParser.LOCK, 0); + return this.getToken(SparkSqlParser.LOCK, 0); }; NonReservedContext.prototype.LOCKS = function() { - return this.getToken(SqlBaseParser.LOCKS, 0); + return this.getToken(SparkSqlParser.LOCKS, 0); }; NonReservedContext.prototype.LOGICAL = function() { - return this.getToken(SqlBaseParser.LOGICAL, 0); + return this.getToken(SparkSqlParser.LOGICAL, 0); }; NonReservedContext.prototype.MACRO = function() { - return this.getToken(SqlBaseParser.MACRO, 0); + return this.getToken(SparkSqlParser.MACRO, 0); }; NonReservedContext.prototype.MAP = function() { - return this.getToken(SqlBaseParser.MAP, 0); + return this.getToken(SparkSqlParser.MAP, 0); }; NonReservedContext.prototype.MATCHED = function() { - return this.getToken(SqlBaseParser.MATCHED, 0); + return this.getToken(SparkSqlParser.MATCHED, 0); }; NonReservedContext.prototype.MERGE = function() { - return this.getToken(SqlBaseParser.MERGE, 0); + return this.getToken(SparkSqlParser.MERGE, 0); }; NonReservedContext.prototype.MSCK = function() { - return this.getToken(SqlBaseParser.MSCK, 0); + return this.getToken(SparkSqlParser.MSCK, 0); }; NonReservedContext.prototype.NAMESPACE = function() { - return this.getToken(SqlBaseParser.NAMESPACE, 0); + return this.getToken(SparkSqlParser.NAMESPACE, 0); }; NonReservedContext.prototype.NAMESPACES = function() { - return this.getToken(SqlBaseParser.NAMESPACES, 0); + return this.getToken(SparkSqlParser.NAMESPACES, 0); }; NonReservedContext.prototype.NO = function() { - return this.getToken(SqlBaseParser.NO, 0); + return this.getToken(SparkSqlParser.NO, 0); }; NonReservedContext.prototype.NOT = function() { - return this.getToken(SqlBaseParser.NOT, 0); + return this.getToken(SparkSqlParser.NOT, 0); }; NonReservedContext.prototype.NULL = function() { - return this.getToken(SqlBaseParser.NULL, 0); + return this.getToken(SparkSqlParser.NULL, 0); }; NonReservedContext.prototype.NULLS = function() { - return this.getToken(SqlBaseParser.NULLS, 0); + return this.getToken(SparkSqlParser.NULLS, 0); }; NonReservedContext.prototype.OF = function() { - return this.getToken(SqlBaseParser.OF, 0); + return this.getToken(SparkSqlParser.OF, 0); }; NonReservedContext.prototype.ONLY = function() { - return this.getToken(SqlBaseParser.ONLY, 0); + return this.getToken(SparkSqlParser.ONLY, 0); }; NonReservedContext.prototype.OPTION = function() { - return this.getToken(SqlBaseParser.OPTION, 0); + return this.getToken(SparkSqlParser.OPTION, 0); }; NonReservedContext.prototype.OPTIONS = function() { - return this.getToken(SqlBaseParser.OPTIONS, 0); + return this.getToken(SparkSqlParser.OPTIONS, 0); }; NonReservedContext.prototype.OR = function() { - return this.getToken(SqlBaseParser.OR, 0); + return this.getToken(SparkSqlParser.OR, 0); }; NonReservedContext.prototype.ORDER = function() { - return this.getToken(SqlBaseParser.ORDER, 0); + return this.getToken(SparkSqlParser.ORDER, 0); }; NonReservedContext.prototype.OUT = function() { - return this.getToken(SqlBaseParser.OUT, 0); + return this.getToken(SparkSqlParser.OUT, 0); }; NonReservedContext.prototype.OUTER = function() { - return this.getToken(SqlBaseParser.OUTER, 0); + return this.getToken(SparkSqlParser.OUTER, 0); }; NonReservedContext.prototype.OUTPUTFORMAT = function() { - return this.getToken(SqlBaseParser.OUTPUTFORMAT, 0); + return this.getToken(SparkSqlParser.OUTPUTFORMAT, 0); }; NonReservedContext.prototype.OVER = function() { - return this.getToken(SqlBaseParser.OVER, 0); + return this.getToken(SparkSqlParser.OVER, 0); }; NonReservedContext.prototype.OVERLAPS = function() { - return this.getToken(SqlBaseParser.OVERLAPS, 0); + return this.getToken(SparkSqlParser.OVERLAPS, 0); }; NonReservedContext.prototype.OVERLAY = function() { - return this.getToken(SqlBaseParser.OVERLAY, 0); + return this.getToken(SparkSqlParser.OVERLAY, 0); }; NonReservedContext.prototype.OVERWRITE = function() { - return this.getToken(SqlBaseParser.OVERWRITE, 0); + return this.getToken(SparkSqlParser.OVERWRITE, 0); }; NonReservedContext.prototype.PARTITION = function() { - return this.getToken(SqlBaseParser.PARTITION, 0); + return this.getToken(SparkSqlParser.PARTITION, 0); }; NonReservedContext.prototype.PARTITIONED = function() { - return this.getToken(SqlBaseParser.PARTITIONED, 0); + return this.getToken(SparkSqlParser.PARTITIONED, 0); }; NonReservedContext.prototype.PARTITIONS = function() { - return this.getToken(SqlBaseParser.PARTITIONS, 0); + return this.getToken(SparkSqlParser.PARTITIONS, 0); }; NonReservedContext.prototype.PERCENTLIT = function() { - return this.getToken(SqlBaseParser.PERCENTLIT, 0); + return this.getToken(SparkSqlParser.PERCENTLIT, 0); }; NonReservedContext.prototype.PIVOT = function() { - return this.getToken(SqlBaseParser.PIVOT, 0); + return this.getToken(SparkSqlParser.PIVOT, 0); }; NonReservedContext.prototype.PLACING = function() { - return this.getToken(SqlBaseParser.PLACING, 0); + return this.getToken(SparkSqlParser.PLACING, 0); }; NonReservedContext.prototype.POSITION = function() { - return this.getToken(SqlBaseParser.POSITION, 0); + return this.getToken(SparkSqlParser.POSITION, 0); }; NonReservedContext.prototype.PRECEDING = function() { - return this.getToken(SqlBaseParser.PRECEDING, 0); + return this.getToken(SparkSqlParser.PRECEDING, 0); }; NonReservedContext.prototype.PRIMARY = function() { - return this.getToken(SqlBaseParser.PRIMARY, 0); + return this.getToken(SparkSqlParser.PRIMARY, 0); }; NonReservedContext.prototype.PRINCIPALS = function() { - return this.getToken(SqlBaseParser.PRINCIPALS, 0); + return this.getToken(SparkSqlParser.PRINCIPALS, 0); }; NonReservedContext.prototype.PROPERTIES = function() { - return this.getToken(SqlBaseParser.PROPERTIES, 0); + return this.getToken(SparkSqlParser.PROPERTIES, 0); }; NonReservedContext.prototype.PURGE = function() { - return this.getToken(SqlBaseParser.PURGE, 0); + return this.getToken(SparkSqlParser.PURGE, 0); }; NonReservedContext.prototype.QUERY = function() { - return this.getToken(SqlBaseParser.QUERY, 0); + return this.getToken(SparkSqlParser.QUERY, 0); }; NonReservedContext.prototype.RANGE = function() { - return this.getToken(SqlBaseParser.RANGE, 0); + return this.getToken(SparkSqlParser.RANGE, 0); }; NonReservedContext.prototype.RECORDREADER = function() { - return this.getToken(SqlBaseParser.RECORDREADER, 0); + return this.getToken(SparkSqlParser.RECORDREADER, 0); }; NonReservedContext.prototype.RECORDWRITER = function() { - return this.getToken(SqlBaseParser.RECORDWRITER, 0); + return this.getToken(SparkSqlParser.RECORDWRITER, 0); }; NonReservedContext.prototype.RECOVER = function() { - return this.getToken(SqlBaseParser.RECOVER, 0); + return this.getToken(SparkSqlParser.RECOVER, 0); }; NonReservedContext.prototype.REDUCE = function() { - return this.getToken(SqlBaseParser.REDUCE, 0); + return this.getToken(SparkSqlParser.REDUCE, 0); }; NonReservedContext.prototype.REFERENCES = function() { - return this.getToken(SqlBaseParser.REFERENCES, 0); + return this.getToken(SparkSqlParser.REFERENCES, 0); }; NonReservedContext.prototype.REFRESH = function() { - return this.getToken(SqlBaseParser.REFRESH, 0); + return this.getToken(SparkSqlParser.REFRESH, 0); }; NonReservedContext.prototype.RENAME = function() { - return this.getToken(SqlBaseParser.RENAME, 0); + return this.getToken(SparkSqlParser.RENAME, 0); }; NonReservedContext.prototype.REPAIR = function() { - return this.getToken(SqlBaseParser.REPAIR, 0); + return this.getToken(SparkSqlParser.REPAIR, 0); }; NonReservedContext.prototype.REPLACE = function() { - return this.getToken(SqlBaseParser.REPLACE, 0); + return this.getToken(SparkSqlParser.REPLACE, 0); }; NonReservedContext.prototype.RESET = function() { - return this.getToken(SqlBaseParser.RESET, 0); + return this.getToken(SparkSqlParser.RESET, 0); }; NonReservedContext.prototype.RESTRICT = function() { - return this.getToken(SqlBaseParser.RESTRICT, 0); + return this.getToken(SparkSqlParser.RESTRICT, 0); }; NonReservedContext.prototype.REVOKE = function() { - return this.getToken(SqlBaseParser.REVOKE, 0); + return this.getToken(SparkSqlParser.REVOKE, 0); }; NonReservedContext.prototype.RLIKE = function() { - return this.getToken(SqlBaseParser.RLIKE, 0); + return this.getToken(SparkSqlParser.RLIKE, 0); }; NonReservedContext.prototype.ROLE = function() { - return this.getToken(SqlBaseParser.ROLE, 0); + return this.getToken(SparkSqlParser.ROLE, 0); }; NonReservedContext.prototype.ROLES = function() { - return this.getToken(SqlBaseParser.ROLES, 0); + return this.getToken(SparkSqlParser.ROLES, 0); }; NonReservedContext.prototype.ROLLBACK = function() { - return this.getToken(SqlBaseParser.ROLLBACK, 0); + return this.getToken(SparkSqlParser.ROLLBACK, 0); }; NonReservedContext.prototype.ROLLUP = function() { - return this.getToken(SqlBaseParser.ROLLUP, 0); + return this.getToken(SparkSqlParser.ROLLUP, 0); }; NonReservedContext.prototype.ROW = function() { - return this.getToken(SqlBaseParser.ROW, 0); + return this.getToken(SparkSqlParser.ROW, 0); }; NonReservedContext.prototype.ROWS = function() { - return this.getToken(SqlBaseParser.ROWS, 0); + return this.getToken(SparkSqlParser.ROWS, 0); }; NonReservedContext.prototype.SCHEMA = function() { - return this.getToken(SqlBaseParser.SCHEMA, 0); + return this.getToken(SparkSqlParser.SCHEMA, 0); }; NonReservedContext.prototype.SELECT = function() { - return this.getToken(SqlBaseParser.SELECT, 0); + return this.getToken(SparkSqlParser.SELECT, 0); }; NonReservedContext.prototype.SEPARATED = function() { - return this.getToken(SqlBaseParser.SEPARATED, 0); + return this.getToken(SparkSqlParser.SEPARATED, 0); }; NonReservedContext.prototype.SERDE = function() { - return this.getToken(SqlBaseParser.SERDE, 0); + return this.getToken(SparkSqlParser.SERDE, 0); }; NonReservedContext.prototype.SERDEPROPERTIES = function() { - return this.getToken(SqlBaseParser.SERDEPROPERTIES, 0); + return this.getToken(SparkSqlParser.SERDEPROPERTIES, 0); }; NonReservedContext.prototype.SESSION_USER = function() { - return this.getToken(SqlBaseParser.SESSION_USER, 0); + return this.getToken(SparkSqlParser.SESSION_USER, 0); }; NonReservedContext.prototype.SET = function() { - return this.getToken(SqlBaseParser.SET, 0); + return this.getToken(SparkSqlParser.SET, 0); }; NonReservedContext.prototype.SETS = function() { - return this.getToken(SqlBaseParser.SETS, 0); + return this.getToken(SparkSqlParser.SETS, 0); }; NonReservedContext.prototype.SHOW = function() { - return this.getToken(SqlBaseParser.SHOW, 0); + return this.getToken(SparkSqlParser.SHOW, 0); }; NonReservedContext.prototype.SKEWED = function() { - return this.getToken(SqlBaseParser.SKEWED, 0); + return this.getToken(SparkSqlParser.SKEWED, 0); }; NonReservedContext.prototype.SOME = function() { - return this.getToken(SqlBaseParser.SOME, 0); + return this.getToken(SparkSqlParser.SOME, 0); }; NonReservedContext.prototype.SORT = function() { - return this.getToken(SqlBaseParser.SORT, 0); + return this.getToken(SparkSqlParser.SORT, 0); }; NonReservedContext.prototype.SORTED = function() { - return this.getToken(SqlBaseParser.SORTED, 0); + return this.getToken(SparkSqlParser.SORTED, 0); }; NonReservedContext.prototype.START = function() { - return this.getToken(SqlBaseParser.START, 0); + return this.getToken(SparkSqlParser.START, 0); }; NonReservedContext.prototype.STATISTICS = function() { - return this.getToken(SqlBaseParser.STATISTICS, 0); + return this.getToken(SparkSqlParser.STATISTICS, 0); }; NonReservedContext.prototype.STORED = function() { - return this.getToken(SqlBaseParser.STORED, 0); + return this.getToken(SparkSqlParser.STORED, 0); }; NonReservedContext.prototype.STRATIFY = function() { - return this.getToken(SqlBaseParser.STRATIFY, 0); + return this.getToken(SparkSqlParser.STRATIFY, 0); }; NonReservedContext.prototype.STRUCT = function() { - return this.getToken(SqlBaseParser.STRUCT, 0); + return this.getToken(SparkSqlParser.STRUCT, 0); }; NonReservedContext.prototype.SUBSTR = function() { - return this.getToken(SqlBaseParser.SUBSTR, 0); + return this.getToken(SparkSqlParser.SUBSTR, 0); }; NonReservedContext.prototype.SUBSTRING = function() { - return this.getToken(SqlBaseParser.SUBSTRING, 0); + return this.getToken(SparkSqlParser.SUBSTRING, 0); }; NonReservedContext.prototype.TABLE = function() { - return this.getToken(SqlBaseParser.TABLE, 0); + return this.getToken(SparkSqlParser.TABLE, 0); }; NonReservedContext.prototype.TABLES = function() { - return this.getToken(SqlBaseParser.TABLES, 0); + return this.getToken(SparkSqlParser.TABLES, 0); }; NonReservedContext.prototype.TABLESAMPLE = function() { - return this.getToken(SqlBaseParser.TABLESAMPLE, 0); + return this.getToken(SparkSqlParser.TABLESAMPLE, 0); }; NonReservedContext.prototype.TBLPROPERTIES = function() { - return this.getToken(SqlBaseParser.TBLPROPERTIES, 0); + return this.getToken(SparkSqlParser.TBLPROPERTIES, 0); }; NonReservedContext.prototype.TEMPORARY = function() { - return this.getToken(SqlBaseParser.TEMPORARY, 0); + return this.getToken(SparkSqlParser.TEMPORARY, 0); }; NonReservedContext.prototype.TERMINATED = function() { - return this.getToken(SqlBaseParser.TERMINATED, 0); + return this.getToken(SparkSqlParser.TERMINATED, 0); }; NonReservedContext.prototype.THEN = function() { - return this.getToken(SqlBaseParser.THEN, 0); + return this.getToken(SparkSqlParser.THEN, 0); }; NonReservedContext.prototype.TIME = function() { - return this.getToken(SqlBaseParser.TIME, 0); + return this.getToken(SparkSqlParser.TIME, 0); }; NonReservedContext.prototype.TO = function() { - return this.getToken(SqlBaseParser.TO, 0); + return this.getToken(SparkSqlParser.TO, 0); }; NonReservedContext.prototype.TOUCH = function() { - return this.getToken(SqlBaseParser.TOUCH, 0); + return this.getToken(SparkSqlParser.TOUCH, 0); }; NonReservedContext.prototype.TRAILING = function() { - return this.getToken(SqlBaseParser.TRAILING, 0); + return this.getToken(SparkSqlParser.TRAILING, 0); }; NonReservedContext.prototype.TRANSACTION = function() { - return this.getToken(SqlBaseParser.TRANSACTION, 0); + return this.getToken(SparkSqlParser.TRANSACTION, 0); }; NonReservedContext.prototype.TRANSACTIONS = function() { - return this.getToken(SqlBaseParser.TRANSACTIONS, 0); + return this.getToken(SparkSqlParser.TRANSACTIONS, 0); }; NonReservedContext.prototype.TRANSFORM = function() { - return this.getToken(SqlBaseParser.TRANSFORM, 0); + return this.getToken(SparkSqlParser.TRANSFORM, 0); }; NonReservedContext.prototype.TRIM = function() { - return this.getToken(SqlBaseParser.TRIM, 0); + return this.getToken(SparkSqlParser.TRIM, 0); }; NonReservedContext.prototype.TRUE = function() { - return this.getToken(SqlBaseParser.TRUE, 0); + return this.getToken(SparkSqlParser.TRUE, 0); }; NonReservedContext.prototype.TRUNCATE = function() { - return this.getToken(SqlBaseParser.TRUNCATE, 0); + return this.getToken(SparkSqlParser.TRUNCATE, 0); }; NonReservedContext.prototype.TYPE = function() { - return this.getToken(SqlBaseParser.TYPE, 0); + return this.getToken(SparkSqlParser.TYPE, 0); }; NonReservedContext.prototype.UNARCHIVE = function() { - return this.getToken(SqlBaseParser.UNARCHIVE, 0); + return this.getToken(SparkSqlParser.UNARCHIVE, 0); }; NonReservedContext.prototype.UNBOUNDED = function() { - return this.getToken(SqlBaseParser.UNBOUNDED, 0); + return this.getToken(SparkSqlParser.UNBOUNDED, 0); }; NonReservedContext.prototype.UNCACHE = function() { - return this.getToken(SqlBaseParser.UNCACHE, 0); + return this.getToken(SparkSqlParser.UNCACHE, 0); }; NonReservedContext.prototype.UNIQUE = function() { - return this.getToken(SqlBaseParser.UNIQUE, 0); + return this.getToken(SparkSqlParser.UNIQUE, 0); }; NonReservedContext.prototype.UNKNOWN = function() { - return this.getToken(SqlBaseParser.UNKNOWN, 0); + return this.getToken(SparkSqlParser.UNKNOWN, 0); }; NonReservedContext.prototype.UNLOCK = function() { - return this.getToken(SqlBaseParser.UNLOCK, 0); + return this.getToken(SparkSqlParser.UNLOCK, 0); }; NonReservedContext.prototype.UNSET = function() { - return this.getToken(SqlBaseParser.UNSET, 0); + return this.getToken(SparkSqlParser.UNSET, 0); }; NonReservedContext.prototype.UPDATE = function() { - return this.getToken(SqlBaseParser.UPDATE, 0); + return this.getToken(SparkSqlParser.UPDATE, 0); }; NonReservedContext.prototype.USE = function() { - return this.getToken(SqlBaseParser.USE, 0); + return this.getToken(SparkSqlParser.USE, 0); }; NonReservedContext.prototype.USER = function() { - return this.getToken(SqlBaseParser.USER, 0); + return this.getToken(SparkSqlParser.USER, 0); }; NonReservedContext.prototype.VALUES = function() { - return this.getToken(SqlBaseParser.VALUES, 0); + return this.getToken(SparkSqlParser.VALUES, 0); }; NonReservedContext.prototype.VIEW = function() { - return this.getToken(SqlBaseParser.VIEW, 0); + return this.getToken(SparkSqlParser.VIEW, 0); }; NonReservedContext.prototype.VIEWS = function() { - return this.getToken(SqlBaseParser.VIEWS, 0); + return this.getToken(SparkSqlParser.VIEWS, 0); }; NonReservedContext.prototype.WHEN = function() { - return this.getToken(SqlBaseParser.WHEN, 0); + return this.getToken(SparkSqlParser.WHEN, 0); }; NonReservedContext.prototype.WHERE = function() { - return this.getToken(SqlBaseParser.WHERE, 0); + return this.getToken(SparkSqlParser.WHERE, 0); }; NonReservedContext.prototype.WINDOW = function() { - return this.getToken(SqlBaseParser.WINDOW, 0); + return this.getToken(SparkSqlParser.WINDOW, 0); }; NonReservedContext.prototype.WITH = function() { - return this.getToken(SqlBaseParser.WITH, 0); + return this.getToken(SparkSqlParser.WITH, 0); }; NonReservedContext.prototype.ZONE = function() { - return this.getToken(SqlBaseParser.ZONE, 0); + return this.getToken(SparkSqlParser.ZONE, 0); }; NonReservedContext.prototype.enterRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.enterNonReserved(this); } }; NonReservedContext.prototype.exitRule = function(listener) { - if(listener instanceof SqlBaseListener ) { + if(listener instanceof SparkSqlListener ) { listener.exitNonReserved(this); } }; NonReservedContext.prototype.accept = function(visitor) { - if ( visitor instanceof SqlBaseVisitor ) { + if ( visitor instanceof SparkSqlVisitor ) { return visitor.visitNonReserved(this); } else { return visitor.visitChildren(this); @@ -31134,18 +31134,18 @@ NonReservedContext.prototype.accept = function(visitor) { -SqlBaseParser.NonReservedContext = NonReservedContext; +SparkSqlParser.NonReservedContext = NonReservedContext; -SqlBaseParser.prototype.nonReserved = function() { +SparkSqlParser.prototype.nonReserved = function() { var localctx = new NonReservedContext(this, this._ctx, this.state); - this.enterRule(localctx, 270, SqlBaseParser.RULE_nonReserved); + this.enterRule(localctx, 270, SparkSqlParser.RULE_nonReserved); var _la = 0; // Token type try { this.enterOuterAlt(localctx, 1); this.state = 3023; _la = this._input.LA(1); - if(!(((((_la - 12)) & ~0x1f) == 0 && ((1 << (_la - 12)) & ((1 << (SqlBaseParser.ADD - 12)) | (1 << (SqlBaseParser.AFTER - 12)) | (1 << (SqlBaseParser.ALL - 12)) | (1 << (SqlBaseParser.ALTER - 12)) | (1 << (SqlBaseParser.ANALYZE - 12)) | (1 << (SqlBaseParser.AND - 12)) | (1 << (SqlBaseParser.ANY - 12)) | (1 << (SqlBaseParser.ARCHIVE - 12)) | (1 << (SqlBaseParser.ARRAY - 12)) | (1 << (SqlBaseParser.AS - 12)) | (1 << (SqlBaseParser.ASC - 12)) | (1 << (SqlBaseParser.AT - 12)) | (1 << (SqlBaseParser.AUTHORIZATION - 12)) | (1 << (SqlBaseParser.BETWEEN - 12)) | (1 << (SqlBaseParser.BOTH - 12)) | (1 << (SqlBaseParser.BUCKET - 12)) | (1 << (SqlBaseParser.BUCKETS - 12)) | (1 << (SqlBaseParser.BY - 12)) | (1 << (SqlBaseParser.CACHE - 12)) | (1 << (SqlBaseParser.CASCADE - 12)) | (1 << (SqlBaseParser.CASE - 12)) | (1 << (SqlBaseParser.CAST - 12)) | (1 << (SqlBaseParser.CHANGE - 12)) | (1 << (SqlBaseParser.CHECK - 12)) | (1 << (SqlBaseParser.CLEAR - 12)) | (1 << (SqlBaseParser.CLUSTER - 12)) | (1 << (SqlBaseParser.CLUSTERED - 12)) | (1 << (SqlBaseParser.CODEGEN - 12)) | (1 << (SqlBaseParser.COLLATE - 12)) | (1 << (SqlBaseParser.COLLECTION - 12)) | (1 << (SqlBaseParser.COLUMN - 12)))) !== 0) || ((((_la - 44)) & ~0x1f) == 0 && ((1 << (_la - 44)) & ((1 << (SqlBaseParser.COLUMNS - 44)) | (1 << (SqlBaseParser.COMMENT - 44)) | (1 << (SqlBaseParser.COMMIT - 44)) | (1 << (SqlBaseParser.COMPACT - 44)) | (1 << (SqlBaseParser.COMPACTIONS - 44)) | (1 << (SqlBaseParser.COMPUTE - 44)) | (1 << (SqlBaseParser.CONCATENATE - 44)) | (1 << (SqlBaseParser.CONSTRAINT - 44)) | (1 << (SqlBaseParser.COST - 44)) | (1 << (SqlBaseParser.CREATE - 44)) | (1 << (SqlBaseParser.CUBE - 44)) | (1 << (SqlBaseParser.CURRENT - 44)) | (1 << (SqlBaseParser.CURRENT_DATE - 44)) | (1 << (SqlBaseParser.CURRENT_TIME - 44)) | (1 << (SqlBaseParser.CURRENT_TIMESTAMP - 44)) | (1 << (SqlBaseParser.CURRENT_USER - 44)) | (1 << (SqlBaseParser.DATA - 44)) | (1 << (SqlBaseParser.DATABASE - 44)) | (1 << (SqlBaseParser.DATABASES - 44)) | (1 << (SqlBaseParser.DBPROPERTIES - 44)) | (1 << (SqlBaseParser.DEFINED - 44)) | (1 << (SqlBaseParser.DELETE - 44)) | (1 << (SqlBaseParser.DELIMITED - 44)) | (1 << (SqlBaseParser.DESC - 44)) | (1 << (SqlBaseParser.DESCRIBE - 44)) | (1 << (SqlBaseParser.DFS - 44)) | (1 << (SqlBaseParser.DIRECTORIES - 44)) | (1 << (SqlBaseParser.DIRECTORY - 44)) | (1 << (SqlBaseParser.DISTINCT - 44)) | (1 << (SqlBaseParser.DISTRIBUTE - 44)) | (1 << (SqlBaseParser.DIV - 44)))) !== 0) || ((((_la - 76)) & ~0x1f) == 0 && ((1 << (_la - 76)) & ((1 << (SqlBaseParser.DROP - 76)) | (1 << (SqlBaseParser.ELSE - 76)) | (1 << (SqlBaseParser.END - 76)) | (1 << (SqlBaseParser.ESCAPE - 76)) | (1 << (SqlBaseParser.ESCAPED - 76)) | (1 << (SqlBaseParser.EXCHANGE - 76)) | (1 << (SqlBaseParser.EXISTS - 76)) | (1 << (SqlBaseParser.EXPLAIN - 76)) | (1 << (SqlBaseParser.EXPORT - 76)) | (1 << (SqlBaseParser.EXTENDED - 76)) | (1 << (SqlBaseParser.EXTERNAL - 76)) | (1 << (SqlBaseParser.EXTRACT - 76)) | (1 << (SqlBaseParser.FALSE - 76)) | (1 << (SqlBaseParser.FETCH - 76)) | (1 << (SqlBaseParser.FIELDS - 76)) | (1 << (SqlBaseParser.FILTER - 76)) | (1 << (SqlBaseParser.FILEFORMAT - 76)) | (1 << (SqlBaseParser.FIRST - 76)) | (1 << (SqlBaseParser.FOLLOWING - 76)) | (1 << (SqlBaseParser.FOR - 76)) | (1 << (SqlBaseParser.FOREIGN - 76)) | (1 << (SqlBaseParser.FORMAT - 76)) | (1 << (SqlBaseParser.FORMATTED - 76)) | (1 << (SqlBaseParser.FROM - 76)) | (1 << (SqlBaseParser.FUNCTION - 76)) | (1 << (SqlBaseParser.FUNCTIONS - 76)) | (1 << (SqlBaseParser.GLOBAL - 76)) | (1 << (SqlBaseParser.GRANT - 76)) | (1 << (SqlBaseParser.GROUP - 76)) | (1 << (SqlBaseParser.GROUPING - 76)))) !== 0) || ((((_la - 108)) & ~0x1f) == 0 && ((1 << (_la - 108)) & ((1 << (SqlBaseParser.HAVING - 108)) | (1 << (SqlBaseParser.IF - 108)) | (1 << (SqlBaseParser.IGNORE - 108)) | (1 << (SqlBaseParser.IMPORT - 108)) | (1 << (SqlBaseParser.IN - 108)) | (1 << (SqlBaseParser.INDEX - 108)) | (1 << (SqlBaseParser.INDEXES - 108)) | (1 << (SqlBaseParser.INPATH - 108)) | (1 << (SqlBaseParser.INPUTFORMAT - 108)) | (1 << (SqlBaseParser.INSERT - 108)) | (1 << (SqlBaseParser.INTERVAL - 108)) | (1 << (SqlBaseParser.INTO - 108)) | (1 << (SqlBaseParser.IS - 108)) | (1 << (SqlBaseParser.ITEMS - 108)) | (1 << (SqlBaseParser.KEYS - 108)) | (1 << (SqlBaseParser.LAST - 108)) | (1 << (SqlBaseParser.LATERAL - 108)) | (1 << (SqlBaseParser.LAZY - 108)) | (1 << (SqlBaseParser.LEADING - 108)) | (1 << (SqlBaseParser.LIKE - 108)) | (1 << (SqlBaseParser.LIMIT - 108)) | (1 << (SqlBaseParser.LINES - 108)) | (1 << (SqlBaseParser.LIST - 108)) | (1 << (SqlBaseParser.LOAD - 108)) | (1 << (SqlBaseParser.LOCAL - 108)) | (1 << (SqlBaseParser.LOCATION - 108)) | (1 << (SqlBaseParser.LOCK - 108)) | (1 << (SqlBaseParser.LOCKS - 108)))) !== 0) || ((((_la - 140)) & ~0x1f) == 0 && ((1 << (_la - 140)) & ((1 << (SqlBaseParser.LOGICAL - 140)) | (1 << (SqlBaseParser.MACRO - 140)) | (1 << (SqlBaseParser.MAP - 140)) | (1 << (SqlBaseParser.MATCHED - 140)) | (1 << (SqlBaseParser.MERGE - 140)) | (1 << (SqlBaseParser.MSCK - 140)) | (1 << (SqlBaseParser.NAMESPACE - 140)) | (1 << (SqlBaseParser.NAMESPACES - 140)) | (1 << (SqlBaseParser.NO - 140)) | (1 << (SqlBaseParser.NOT - 140)) | (1 << (SqlBaseParser.NULL - 140)) | (1 << (SqlBaseParser.NULLS - 140)) | (1 << (SqlBaseParser.OF - 140)) | (1 << (SqlBaseParser.ONLY - 140)) | (1 << (SqlBaseParser.OPTION - 140)) | (1 << (SqlBaseParser.OPTIONS - 140)) | (1 << (SqlBaseParser.OR - 140)) | (1 << (SqlBaseParser.ORDER - 140)) | (1 << (SqlBaseParser.OUT - 140)) | (1 << (SqlBaseParser.OUTER - 140)) | (1 << (SqlBaseParser.OUTPUTFORMAT - 140)) | (1 << (SqlBaseParser.OVER - 140)) | (1 << (SqlBaseParser.OVERLAPS - 140)) | (1 << (SqlBaseParser.OVERLAY - 140)) | (1 << (SqlBaseParser.OVERWRITE - 140)) | (1 << (SqlBaseParser.PARTITION - 140)) | (1 << (SqlBaseParser.PARTITIONED - 140)) | (1 << (SqlBaseParser.PARTITIONS - 140)) | (1 << (SqlBaseParser.PERCENTLIT - 140)) | (1 << (SqlBaseParser.PIVOT - 140)))) !== 0) || ((((_la - 172)) & ~0x1f) == 0 && ((1 << (_la - 172)) & ((1 << (SqlBaseParser.PLACING - 172)) | (1 << (SqlBaseParser.POSITION - 172)) | (1 << (SqlBaseParser.PRECEDING - 172)) | (1 << (SqlBaseParser.PRIMARY - 172)) | (1 << (SqlBaseParser.PRINCIPALS - 172)) | (1 << (SqlBaseParser.PROPERTIES - 172)) | (1 << (SqlBaseParser.PURGE - 172)) | (1 << (SqlBaseParser.QUERY - 172)) | (1 << (SqlBaseParser.RANGE - 172)) | (1 << (SqlBaseParser.RECORDREADER - 172)) | (1 << (SqlBaseParser.RECORDWRITER - 172)) | (1 << (SqlBaseParser.RECOVER - 172)) | (1 << (SqlBaseParser.REDUCE - 172)) | (1 << (SqlBaseParser.REFERENCES - 172)) | (1 << (SqlBaseParser.REFRESH - 172)) | (1 << (SqlBaseParser.RENAME - 172)) | (1 << (SqlBaseParser.REPAIR - 172)) | (1 << (SqlBaseParser.REPLACE - 172)) | (1 << (SqlBaseParser.RESET - 172)) | (1 << (SqlBaseParser.RESTRICT - 172)) | (1 << (SqlBaseParser.REVOKE - 172)) | (1 << (SqlBaseParser.RLIKE - 172)) | (1 << (SqlBaseParser.ROLE - 172)) | (1 << (SqlBaseParser.ROLES - 172)) | (1 << (SqlBaseParser.ROLLBACK - 172)) | (1 << (SqlBaseParser.ROLLUP - 172)) | (1 << (SqlBaseParser.ROW - 172)) | (1 << (SqlBaseParser.ROWS - 172)) | (1 << (SqlBaseParser.SCHEMA - 172)) | (1 << (SqlBaseParser.SELECT - 172)))) !== 0) || ((((_la - 204)) & ~0x1f) == 0 && ((1 << (_la - 204)) & ((1 << (SqlBaseParser.SEPARATED - 204)) | (1 << (SqlBaseParser.SERDE - 204)) | (1 << (SqlBaseParser.SERDEPROPERTIES - 204)) | (1 << (SqlBaseParser.SESSION_USER - 204)) | (1 << (SqlBaseParser.SET - 204)) | (1 << (SqlBaseParser.SETS - 204)) | (1 << (SqlBaseParser.SHOW - 204)) | (1 << (SqlBaseParser.SKEWED - 204)) | (1 << (SqlBaseParser.SOME - 204)) | (1 << (SqlBaseParser.SORT - 204)) | (1 << (SqlBaseParser.SORTED - 204)) | (1 << (SqlBaseParser.START - 204)) | (1 << (SqlBaseParser.STATISTICS - 204)) | (1 << (SqlBaseParser.STORED - 204)) | (1 << (SqlBaseParser.STRATIFY - 204)) | (1 << (SqlBaseParser.STRUCT - 204)) | (1 << (SqlBaseParser.SUBSTR - 204)) | (1 << (SqlBaseParser.SUBSTRING - 204)) | (1 << (SqlBaseParser.TABLE - 204)) | (1 << (SqlBaseParser.TABLES - 204)) | (1 << (SqlBaseParser.TABLESAMPLE - 204)) | (1 << (SqlBaseParser.TBLPROPERTIES - 204)) | (1 << (SqlBaseParser.TEMPORARY - 204)) | (1 << (SqlBaseParser.TERMINATED - 204)) | (1 << (SqlBaseParser.THEN - 204)) | (1 << (SqlBaseParser.TIME - 204)) | (1 << (SqlBaseParser.TO - 204)) | (1 << (SqlBaseParser.TOUCH - 204)) | (1 << (SqlBaseParser.TRAILING - 204)) | (1 << (SqlBaseParser.TRANSACTION - 204)) | (1 << (SqlBaseParser.TRANSACTIONS - 204)))) !== 0) || ((((_la - 236)) & ~0x1f) == 0 && ((1 << (_la - 236)) & ((1 << (SqlBaseParser.TRANSFORM - 236)) | (1 << (SqlBaseParser.TRIM - 236)) | (1 << (SqlBaseParser.TRUE - 236)) | (1 << (SqlBaseParser.TRUNCATE - 236)) | (1 << (SqlBaseParser.TYPE - 236)) | (1 << (SqlBaseParser.UNARCHIVE - 236)) | (1 << (SqlBaseParser.UNBOUNDED - 236)) | (1 << (SqlBaseParser.UNCACHE - 236)) | (1 << (SqlBaseParser.UNIQUE - 236)) | (1 << (SqlBaseParser.UNKNOWN - 236)) | (1 << (SqlBaseParser.UNLOCK - 236)) | (1 << (SqlBaseParser.UNSET - 236)) | (1 << (SqlBaseParser.UPDATE - 236)) | (1 << (SqlBaseParser.USE - 236)) | (1 << (SqlBaseParser.USER - 236)) | (1 << (SqlBaseParser.VALUES - 236)) | (1 << (SqlBaseParser.VIEW - 236)) | (1 << (SqlBaseParser.VIEWS - 236)) | (1 << (SqlBaseParser.WHEN - 236)) | (1 << (SqlBaseParser.WHERE - 236)) | (1 << (SqlBaseParser.WINDOW - 236)) | (1 << (SqlBaseParser.WITH - 236)) | (1 << (SqlBaseParser.ZONE - 236)))) !== 0))) { + if(!(((((_la - 12)) & ~0x1f) == 0 && ((1 << (_la - 12)) & ((1 << (SparkSqlParser.ADD - 12)) | (1 << (SparkSqlParser.AFTER - 12)) | (1 << (SparkSqlParser.ALL - 12)) | (1 << (SparkSqlParser.ALTER - 12)) | (1 << (SparkSqlParser.ANALYZE - 12)) | (1 << (SparkSqlParser.AND - 12)) | (1 << (SparkSqlParser.ANY - 12)) | (1 << (SparkSqlParser.ARCHIVE - 12)) | (1 << (SparkSqlParser.ARRAY - 12)) | (1 << (SparkSqlParser.AS - 12)) | (1 << (SparkSqlParser.ASC - 12)) | (1 << (SparkSqlParser.AT - 12)) | (1 << (SparkSqlParser.AUTHORIZATION - 12)) | (1 << (SparkSqlParser.BETWEEN - 12)) | (1 << (SparkSqlParser.BOTH - 12)) | (1 << (SparkSqlParser.BUCKET - 12)) | (1 << (SparkSqlParser.BUCKETS - 12)) | (1 << (SparkSqlParser.BY - 12)) | (1 << (SparkSqlParser.CACHE - 12)) | (1 << (SparkSqlParser.CASCADE - 12)) | (1 << (SparkSqlParser.CASE - 12)) | (1 << (SparkSqlParser.CAST - 12)) | (1 << (SparkSqlParser.CHANGE - 12)) | (1 << (SparkSqlParser.CHECK - 12)) | (1 << (SparkSqlParser.CLEAR - 12)) | (1 << (SparkSqlParser.CLUSTER - 12)) | (1 << (SparkSqlParser.CLUSTERED - 12)) | (1 << (SparkSqlParser.CODEGEN - 12)) | (1 << (SparkSqlParser.COLLATE - 12)) | (1 << (SparkSqlParser.COLLECTION - 12)) | (1 << (SparkSqlParser.COLUMN - 12)))) !== 0) || ((((_la - 44)) & ~0x1f) == 0 && ((1 << (_la - 44)) & ((1 << (SparkSqlParser.COLUMNS - 44)) | (1 << (SparkSqlParser.COMMENT - 44)) | (1 << (SparkSqlParser.COMMIT - 44)) | (1 << (SparkSqlParser.COMPACT - 44)) | (1 << (SparkSqlParser.COMPACTIONS - 44)) | (1 << (SparkSqlParser.COMPUTE - 44)) | (1 << (SparkSqlParser.CONCATENATE - 44)) | (1 << (SparkSqlParser.CONSTRAINT - 44)) | (1 << (SparkSqlParser.COST - 44)) | (1 << (SparkSqlParser.CREATE - 44)) | (1 << (SparkSqlParser.CUBE - 44)) | (1 << (SparkSqlParser.CURRENT - 44)) | (1 << (SparkSqlParser.CURRENT_DATE - 44)) | (1 << (SparkSqlParser.CURRENT_TIME - 44)) | (1 << (SparkSqlParser.CURRENT_TIMESTAMP - 44)) | (1 << (SparkSqlParser.CURRENT_USER - 44)) | (1 << (SparkSqlParser.DATA - 44)) | (1 << (SparkSqlParser.DATABASE - 44)) | (1 << (SparkSqlParser.DATABASES - 44)) | (1 << (SparkSqlParser.DBPROPERTIES - 44)) | (1 << (SparkSqlParser.DEFINED - 44)) | (1 << (SparkSqlParser.DELETE - 44)) | (1 << (SparkSqlParser.DELIMITED - 44)) | (1 << (SparkSqlParser.DESC - 44)) | (1 << (SparkSqlParser.DESCRIBE - 44)) | (1 << (SparkSqlParser.DFS - 44)) | (1 << (SparkSqlParser.DIRECTORIES - 44)) | (1 << (SparkSqlParser.DIRECTORY - 44)) | (1 << (SparkSqlParser.DISTINCT - 44)) | (1 << (SparkSqlParser.DISTRIBUTE - 44)) | (1 << (SparkSqlParser.DIV - 44)))) !== 0) || ((((_la - 76)) & ~0x1f) == 0 && ((1 << (_la - 76)) & ((1 << (SparkSqlParser.DROP - 76)) | (1 << (SparkSqlParser.ELSE - 76)) | (1 << (SparkSqlParser.END - 76)) | (1 << (SparkSqlParser.ESCAPE - 76)) | (1 << (SparkSqlParser.ESCAPED - 76)) | (1 << (SparkSqlParser.EXCHANGE - 76)) | (1 << (SparkSqlParser.EXISTS - 76)) | (1 << (SparkSqlParser.EXPLAIN - 76)) | (1 << (SparkSqlParser.EXPORT - 76)) | (1 << (SparkSqlParser.EXTENDED - 76)) | (1 << (SparkSqlParser.EXTERNAL - 76)) | (1 << (SparkSqlParser.EXTRACT - 76)) | (1 << (SparkSqlParser.FALSE - 76)) | (1 << (SparkSqlParser.FETCH - 76)) | (1 << (SparkSqlParser.FIELDS - 76)) | (1 << (SparkSqlParser.FILTER - 76)) | (1 << (SparkSqlParser.FILEFORMAT - 76)) | (1 << (SparkSqlParser.FIRST - 76)) | (1 << (SparkSqlParser.FOLLOWING - 76)) | (1 << (SparkSqlParser.FOR - 76)) | (1 << (SparkSqlParser.FOREIGN - 76)) | (1 << (SparkSqlParser.FORMAT - 76)) | (1 << (SparkSqlParser.FORMATTED - 76)) | (1 << (SparkSqlParser.FROM - 76)) | (1 << (SparkSqlParser.FUNCTION - 76)) | (1 << (SparkSqlParser.FUNCTIONS - 76)) | (1 << (SparkSqlParser.GLOBAL - 76)) | (1 << (SparkSqlParser.GRANT - 76)) | (1 << (SparkSqlParser.GROUP - 76)) | (1 << (SparkSqlParser.GROUPING - 76)))) !== 0) || ((((_la - 108)) & ~0x1f) == 0 && ((1 << (_la - 108)) & ((1 << (SparkSqlParser.HAVING - 108)) | (1 << (SparkSqlParser.IF - 108)) | (1 << (SparkSqlParser.IGNORE - 108)) | (1 << (SparkSqlParser.IMPORT - 108)) | (1 << (SparkSqlParser.IN - 108)) | (1 << (SparkSqlParser.INDEX - 108)) | (1 << (SparkSqlParser.INDEXES - 108)) | (1 << (SparkSqlParser.INPATH - 108)) | (1 << (SparkSqlParser.INPUTFORMAT - 108)) | (1 << (SparkSqlParser.INSERT - 108)) | (1 << (SparkSqlParser.INTERVAL - 108)) | (1 << (SparkSqlParser.INTO - 108)) | (1 << (SparkSqlParser.IS - 108)) | (1 << (SparkSqlParser.ITEMS - 108)) | (1 << (SparkSqlParser.KEYS - 108)) | (1 << (SparkSqlParser.LAST - 108)) | (1 << (SparkSqlParser.LATERAL - 108)) | (1 << (SparkSqlParser.LAZY - 108)) | (1 << (SparkSqlParser.LEADING - 108)) | (1 << (SparkSqlParser.LIKE - 108)) | (1 << (SparkSqlParser.LIMIT - 108)) | (1 << (SparkSqlParser.LINES - 108)) | (1 << (SparkSqlParser.LIST - 108)) | (1 << (SparkSqlParser.LOAD - 108)) | (1 << (SparkSqlParser.LOCAL - 108)) | (1 << (SparkSqlParser.LOCATION - 108)) | (1 << (SparkSqlParser.LOCK - 108)) | (1 << (SparkSqlParser.LOCKS - 108)))) !== 0) || ((((_la - 140)) & ~0x1f) == 0 && ((1 << (_la - 140)) & ((1 << (SparkSqlParser.LOGICAL - 140)) | (1 << (SparkSqlParser.MACRO - 140)) | (1 << (SparkSqlParser.MAP - 140)) | (1 << (SparkSqlParser.MATCHED - 140)) | (1 << (SparkSqlParser.MERGE - 140)) | (1 << (SparkSqlParser.MSCK - 140)) | (1 << (SparkSqlParser.NAMESPACE - 140)) | (1 << (SparkSqlParser.NAMESPACES - 140)) | (1 << (SparkSqlParser.NO - 140)) | (1 << (SparkSqlParser.NOT - 140)) | (1 << (SparkSqlParser.NULL - 140)) | (1 << (SparkSqlParser.NULLS - 140)) | (1 << (SparkSqlParser.OF - 140)) | (1 << (SparkSqlParser.ONLY - 140)) | (1 << (SparkSqlParser.OPTION - 140)) | (1 << (SparkSqlParser.OPTIONS - 140)) | (1 << (SparkSqlParser.OR - 140)) | (1 << (SparkSqlParser.ORDER - 140)) | (1 << (SparkSqlParser.OUT - 140)) | (1 << (SparkSqlParser.OUTER - 140)) | (1 << (SparkSqlParser.OUTPUTFORMAT - 140)) | (1 << (SparkSqlParser.OVER - 140)) | (1 << (SparkSqlParser.OVERLAPS - 140)) | (1 << (SparkSqlParser.OVERLAY - 140)) | (1 << (SparkSqlParser.OVERWRITE - 140)) | (1 << (SparkSqlParser.PARTITION - 140)) | (1 << (SparkSqlParser.PARTITIONED - 140)) | (1 << (SparkSqlParser.PARTITIONS - 140)) | (1 << (SparkSqlParser.PERCENTLIT - 140)) | (1 << (SparkSqlParser.PIVOT - 140)))) !== 0) || ((((_la - 172)) & ~0x1f) == 0 && ((1 << (_la - 172)) & ((1 << (SparkSqlParser.PLACING - 172)) | (1 << (SparkSqlParser.POSITION - 172)) | (1 << (SparkSqlParser.PRECEDING - 172)) | (1 << (SparkSqlParser.PRIMARY - 172)) | (1 << (SparkSqlParser.PRINCIPALS - 172)) | (1 << (SparkSqlParser.PROPERTIES - 172)) | (1 << (SparkSqlParser.PURGE - 172)) | (1 << (SparkSqlParser.QUERY - 172)) | (1 << (SparkSqlParser.RANGE - 172)) | (1 << (SparkSqlParser.RECORDREADER - 172)) | (1 << (SparkSqlParser.RECORDWRITER - 172)) | (1 << (SparkSqlParser.RECOVER - 172)) | (1 << (SparkSqlParser.REDUCE - 172)) | (1 << (SparkSqlParser.REFERENCES - 172)) | (1 << (SparkSqlParser.REFRESH - 172)) | (1 << (SparkSqlParser.RENAME - 172)) | (1 << (SparkSqlParser.REPAIR - 172)) | (1 << (SparkSqlParser.REPLACE - 172)) | (1 << (SparkSqlParser.RESET - 172)) | (1 << (SparkSqlParser.RESTRICT - 172)) | (1 << (SparkSqlParser.REVOKE - 172)) | (1 << (SparkSqlParser.RLIKE - 172)) | (1 << (SparkSqlParser.ROLE - 172)) | (1 << (SparkSqlParser.ROLES - 172)) | (1 << (SparkSqlParser.ROLLBACK - 172)) | (1 << (SparkSqlParser.ROLLUP - 172)) | (1 << (SparkSqlParser.ROW - 172)) | (1 << (SparkSqlParser.ROWS - 172)) | (1 << (SparkSqlParser.SCHEMA - 172)) | (1 << (SparkSqlParser.SELECT - 172)))) !== 0) || ((((_la - 204)) & ~0x1f) == 0 && ((1 << (_la - 204)) & ((1 << (SparkSqlParser.SEPARATED - 204)) | (1 << (SparkSqlParser.SERDE - 204)) | (1 << (SparkSqlParser.SERDEPROPERTIES - 204)) | (1 << (SparkSqlParser.SESSION_USER - 204)) | (1 << (SparkSqlParser.SET - 204)) | (1 << (SparkSqlParser.SETS - 204)) | (1 << (SparkSqlParser.SHOW - 204)) | (1 << (SparkSqlParser.SKEWED - 204)) | (1 << (SparkSqlParser.SOME - 204)) | (1 << (SparkSqlParser.SORT - 204)) | (1 << (SparkSqlParser.SORTED - 204)) | (1 << (SparkSqlParser.START - 204)) | (1 << (SparkSqlParser.STATISTICS - 204)) | (1 << (SparkSqlParser.STORED - 204)) | (1 << (SparkSqlParser.STRATIFY - 204)) | (1 << (SparkSqlParser.STRUCT - 204)) | (1 << (SparkSqlParser.SUBSTR - 204)) | (1 << (SparkSqlParser.SUBSTRING - 204)) | (1 << (SparkSqlParser.TABLE - 204)) | (1 << (SparkSqlParser.TABLES - 204)) | (1 << (SparkSqlParser.TABLESAMPLE - 204)) | (1 << (SparkSqlParser.TBLPROPERTIES - 204)) | (1 << (SparkSqlParser.TEMPORARY - 204)) | (1 << (SparkSqlParser.TERMINATED - 204)) | (1 << (SparkSqlParser.THEN - 204)) | (1 << (SparkSqlParser.TIME - 204)) | (1 << (SparkSqlParser.TO - 204)) | (1 << (SparkSqlParser.TOUCH - 204)) | (1 << (SparkSqlParser.TRAILING - 204)) | (1 << (SparkSqlParser.TRANSACTION - 204)) | (1 << (SparkSqlParser.TRANSACTIONS - 204)))) !== 0) || ((((_la - 236)) & ~0x1f) == 0 && ((1 << (_la - 236)) & ((1 << (SparkSqlParser.TRANSFORM - 236)) | (1 << (SparkSqlParser.TRIM - 236)) | (1 << (SparkSqlParser.TRUE - 236)) | (1 << (SparkSqlParser.TRUNCATE - 236)) | (1 << (SparkSqlParser.TYPE - 236)) | (1 << (SparkSqlParser.UNARCHIVE - 236)) | (1 << (SparkSqlParser.UNBOUNDED - 236)) | (1 << (SparkSqlParser.UNCACHE - 236)) | (1 << (SparkSqlParser.UNIQUE - 236)) | (1 << (SparkSqlParser.UNKNOWN - 236)) | (1 << (SparkSqlParser.UNLOCK - 236)) | (1 << (SparkSqlParser.UNSET - 236)) | (1 << (SparkSqlParser.UPDATE - 236)) | (1 << (SparkSqlParser.USE - 236)) | (1 << (SparkSqlParser.USER - 236)) | (1 << (SparkSqlParser.VALUES - 236)) | (1 << (SparkSqlParser.VIEW - 236)) | (1 << (SparkSqlParser.VIEWS - 236)) | (1 << (SparkSqlParser.WHEN - 236)) | (1 << (SparkSqlParser.WHERE - 236)) | (1 << (SparkSqlParser.WINDOW - 236)) | (1 << (SparkSqlParser.WITH - 236)) | (1 << (SparkSqlParser.ZONE - 236)))) !== 0))) { this._errHandler.recoverInline(this); } else { @@ -31167,7 +31167,7 @@ SqlBaseParser.prototype.nonReserved = function() { }; -SqlBaseParser.prototype.sempred = function(localctx, ruleIndex, predIndex) { +SparkSqlParser.prototype.sempred = function(localctx, ruleIndex, predIndex) { switch(ruleIndex) { case 41: return this.queryTerm_sempred(localctx, predIndex); @@ -31188,7 +31188,7 @@ SqlBaseParser.prototype.sempred = function(localctx, ruleIndex, predIndex) { } }; -SqlBaseParser.prototype.queryTerm_sempred = function(localctx, predIndex) { +SparkSqlParser.prototype.queryTerm_sempred = function(localctx, predIndex) { switch(predIndex) { case 0: return this.precpred(this._ctx, 3); @@ -31207,7 +31207,7 @@ SqlBaseParser.prototype.queryTerm_sempred = function(localctx, predIndex) { } }; -SqlBaseParser.prototype.booleanExpression_sempred = function(localctx, predIndex) { +SparkSqlParser.prototype.booleanExpression_sempred = function(localctx, predIndex) { switch(predIndex) { case 6: return this.precpred(this._ctx, 2); @@ -31218,7 +31218,7 @@ SqlBaseParser.prototype.booleanExpression_sempred = function(localctx, predIndex } }; -SqlBaseParser.prototype.valueExpression_sempred = function(localctx, predIndex) { +SparkSqlParser.prototype.valueExpression_sempred = function(localctx, predIndex) { switch(predIndex) { case 8: return this.precpred(this._ctx, 6); @@ -31237,7 +31237,7 @@ SqlBaseParser.prototype.valueExpression_sempred = function(localctx, predIndex) } }; -SqlBaseParser.prototype.primaryExpression_sempred = function(localctx, predIndex) { +SparkSqlParser.prototype.primaryExpression_sempred = function(localctx, predIndex) { switch(predIndex) { case 14: return this.precpred(this._ctx, 8); @@ -31248,7 +31248,7 @@ SqlBaseParser.prototype.primaryExpression_sempred = function(localctx, predIndex } }; -SqlBaseParser.prototype.identifier_sempred = function(localctx, predIndex) { +SparkSqlParser.prototype.identifier_sempred = function(localctx, predIndex) { switch(predIndex) { case 16: return !SQL_standard_keyword_behavior; @@ -31257,7 +31257,7 @@ SqlBaseParser.prototype.identifier_sempred = function(localctx, predIndex) { } }; -SqlBaseParser.prototype.strictIdentifier_sempred = function(localctx, predIndex) { +SparkSqlParser.prototype.strictIdentifier_sempred = function(localctx, predIndex) { switch(predIndex) { case 17: return SQL_standard_keyword_behavior; @@ -31268,7 +31268,7 @@ SqlBaseParser.prototype.strictIdentifier_sempred = function(localctx, predIndex) } }; -SqlBaseParser.prototype.number_sempred = function(localctx, predIndex) { +SparkSqlParser.prototype.number_sempred = function(localctx, predIndex) { switch(predIndex) { case 19: return !legacy_exponent_literal_as_decimal_enabled; @@ -31282,4 +31282,4 @@ SqlBaseParser.prototype.number_sempred = function(localctx, predIndex) { }; -exports.SqlBaseParser = SqlBaseParser; +exports.SparkSqlParser = SparkSqlParser; diff --git a/src/lib/spark/SparkSqlVisitor.js b/src/lib/spark/SparkSqlVisitor.js new file mode 100644 index 0000000..54d1189 --- /dev/null +++ b/src/lib/spark/SparkSqlVisitor.js @@ -0,0 +1,1636 @@ +// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SparkSql.g4 by ANTLR 4.8 +// jshint ignore: start +var antlr4 = require('antlr4/index'); + +// This class defines a complete generic visitor for a parse tree produced by SparkSqlParser. + +function SparkSqlVisitor() { + antlr4.tree.ParseTreeVisitor.call(this); + return this; +} + +SparkSqlVisitor.prototype = Object.create(antlr4.tree.ParseTreeVisitor.prototype); +SparkSqlVisitor.prototype.constructor = SparkSqlVisitor; + +// Visit a parse tree produced by SparkSqlParser#program. +SparkSqlVisitor.prototype.visitProgram = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#singleStatement. +SparkSqlVisitor.prototype.visitSingleStatement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#singleExpression. +SparkSqlVisitor.prototype.visitSingleExpression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#singleTableIdentifier. +SparkSqlVisitor.prototype.visitSingleTableIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#singleMultipartIdentifier. +SparkSqlVisitor.prototype.visitSingleMultipartIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#singleDataType. +SparkSqlVisitor.prototype.visitSingleDataType = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#singleTableSchema. +SparkSqlVisitor.prototype.visitSingleTableSchema = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#statementDefault. +SparkSqlVisitor.prototype.visitStatementDefault = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dmlStatement. +SparkSqlVisitor.prototype.visitDmlStatement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#use. +SparkSqlVisitor.prototype.visitUse = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createNamespace. +SparkSqlVisitor.prototype.visitCreateNamespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setNamespaceProperties. +SparkSqlVisitor.prototype.visitSetNamespaceProperties = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setNamespaceLocation. +SparkSqlVisitor.prototype.visitSetNamespaceLocation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dropNamespace. +SparkSqlVisitor.prototype.visitDropNamespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showNamespaces. +SparkSqlVisitor.prototype.visitShowNamespaces = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createTable. +SparkSqlVisitor.prototype.visitCreateTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createHiveTable. +SparkSqlVisitor.prototype.visitCreateHiveTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createTableLike. +SparkSqlVisitor.prototype.visitCreateTableLike = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#replaceTable. +SparkSqlVisitor.prototype.visitReplaceTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#analyze. +SparkSqlVisitor.prototype.visitAnalyze = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#addTableColumns. +SparkSqlVisitor.prototype.visitAddTableColumns = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#renameTableColumn. +SparkSqlVisitor.prototype.visitRenameTableColumn = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dropTableColumns. +SparkSqlVisitor.prototype.visitDropTableColumns = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#renameTable. +SparkSqlVisitor.prototype.visitRenameTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setTableProperties. +SparkSqlVisitor.prototype.visitSetTableProperties = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#unsetTableProperties. +SparkSqlVisitor.prototype.visitUnsetTableProperties = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#alterTableAlterColumn. +SparkSqlVisitor.prototype.visitAlterTableAlterColumn = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#hiveChangeColumn. +SparkSqlVisitor.prototype.visitHiveChangeColumn = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#hiveReplaceColumns. +SparkSqlVisitor.prototype.visitHiveReplaceColumns = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setTableSerDe. +SparkSqlVisitor.prototype.visitSetTableSerDe = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#addTablePartition. +SparkSqlVisitor.prototype.visitAddTablePartition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#renameTablePartition. +SparkSqlVisitor.prototype.visitRenameTablePartition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dropTablePartitions. +SparkSqlVisitor.prototype.visitDropTablePartitions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setTableLocation. +SparkSqlVisitor.prototype.visitSetTableLocation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#recoverPartitions. +SparkSqlVisitor.prototype.visitRecoverPartitions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dropTable. +SparkSqlVisitor.prototype.visitDropTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dropView. +SparkSqlVisitor.prototype.visitDropView = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createView. +SparkSqlVisitor.prototype.visitCreateView = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createTempViewUsing. +SparkSqlVisitor.prototype.visitCreateTempViewUsing = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#alterViewQuery. +SparkSqlVisitor.prototype.visitAlterViewQuery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createFunction. +SparkSqlVisitor.prototype.visitCreateFunction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dropFunction. +SparkSqlVisitor.prototype.visitDropFunction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#explain. +SparkSqlVisitor.prototype.visitExplain = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showTables. +SparkSqlVisitor.prototype.visitShowTables = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showTable. +SparkSqlVisitor.prototype.visitShowTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showTblProperties. +SparkSqlVisitor.prototype.visitShowTblProperties = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showColumns. +SparkSqlVisitor.prototype.visitShowColumns = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showViews. +SparkSqlVisitor.prototype.visitShowViews = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showPartitions. +SparkSqlVisitor.prototype.visitShowPartitions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showFunctions. +SparkSqlVisitor.prototype.visitShowFunctions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showCreateTable. +SparkSqlVisitor.prototype.visitShowCreateTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#showCurrentNamespace. +SparkSqlVisitor.prototype.visitShowCurrentNamespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#describeFunction. +SparkSqlVisitor.prototype.visitDescribeFunction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#describeNamespace. +SparkSqlVisitor.prototype.visitDescribeNamespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#describeRelation. +SparkSqlVisitor.prototype.visitDescribeRelation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#describeQuery. +SparkSqlVisitor.prototype.visitDescribeQuery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#commentNamespace. +SparkSqlVisitor.prototype.visitCommentNamespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#commentTable. +SparkSqlVisitor.prototype.visitCommentTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#refreshTable. +SparkSqlVisitor.prototype.visitRefreshTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#refreshFunction. +SparkSqlVisitor.prototype.visitRefreshFunction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#refreshResource. +SparkSqlVisitor.prototype.visitRefreshResource = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#cacheTable. +SparkSqlVisitor.prototype.visitCacheTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#uncacheTable. +SparkSqlVisitor.prototype.visitUncacheTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#clearCache. +SparkSqlVisitor.prototype.visitClearCache = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#loadData. +SparkSqlVisitor.prototype.visitLoadData = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#truncateTable. +SparkSqlVisitor.prototype.visitTruncateTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#repairTable. +SparkSqlVisitor.prototype.visitRepairTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#manageResource. +SparkSqlVisitor.prototype.visitManageResource = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#failNativeCommand. +SparkSqlVisitor.prototype.visitFailNativeCommand = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setTimeZone. +SparkSqlVisitor.prototype.visitSetTimeZone = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setQuotedConfiguration. +SparkSqlVisitor.prototype.visitSetQuotedConfiguration = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setConfiguration. +SparkSqlVisitor.prototype.visitSetConfiguration = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#resetQuotedConfiguration. +SparkSqlVisitor.prototype.visitResetQuotedConfiguration = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#resetConfiguration. +SparkSqlVisitor.prototype.visitResetConfiguration = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#configKey. +SparkSqlVisitor.prototype.visitConfigKey = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#unsupportedHiveNativeCommands. +SparkSqlVisitor.prototype.visitUnsupportedHiveNativeCommands = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createTableHeader. +SparkSqlVisitor.prototype.visitCreateTableHeader = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#replaceTableHeader. +SparkSqlVisitor.prototype.visitReplaceTableHeader = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#bucketSpec. +SparkSqlVisitor.prototype.visitBucketSpec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#skewSpec. +SparkSqlVisitor.prototype.visitSkewSpec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#locationSpec. +SparkSqlVisitor.prototype.visitLocationSpec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#commentSpec. +SparkSqlVisitor.prototype.visitCommentSpec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#query. +SparkSqlVisitor.prototype.visitQuery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#insertOverwriteTable. +SparkSqlVisitor.prototype.visitInsertOverwriteTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#insertIntoTable. +SparkSqlVisitor.prototype.visitInsertIntoTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#insertOverwriteHiveDir. +SparkSqlVisitor.prototype.visitInsertOverwriteHiveDir = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#insertOverwriteDir. +SparkSqlVisitor.prototype.visitInsertOverwriteDir = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#partitionSpecLocation. +SparkSqlVisitor.prototype.visitPartitionSpecLocation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#partitionSpec. +SparkSqlVisitor.prototype.visitPartitionSpec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#partitionVal. +SparkSqlVisitor.prototype.visitPartitionVal = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#namespace. +SparkSqlVisitor.prototype.visitNamespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#describeFuncName. +SparkSqlVisitor.prototype.visitDescribeFuncName = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#describeColName. +SparkSqlVisitor.prototype.visitDescribeColName = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#ctes. +SparkSqlVisitor.prototype.visitCtes = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#namedQuery. +SparkSqlVisitor.prototype.visitNamedQuery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tableProvider. +SparkSqlVisitor.prototype.visitTableProvider = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createTableClauses. +SparkSqlVisitor.prototype.visitCreateTableClauses = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tablePropertyList. +SparkSqlVisitor.prototype.visitTablePropertyList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tableProperty. +SparkSqlVisitor.prototype.visitTableProperty = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tablePropertyKey. +SparkSqlVisitor.prototype.visitTablePropertyKey = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tablePropertyValue. +SparkSqlVisitor.prototype.visitTablePropertyValue = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#constantList. +SparkSqlVisitor.prototype.visitConstantList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#nestedConstantList. +SparkSqlVisitor.prototype.visitNestedConstantList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#createFileFormat. +SparkSqlVisitor.prototype.visitCreateFileFormat = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tableFileFormat. +SparkSqlVisitor.prototype.visitTableFileFormat = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#genericFileFormat. +SparkSqlVisitor.prototype.visitGenericFileFormat = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#storageHandler. +SparkSqlVisitor.prototype.visitStorageHandler = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#resource. +SparkSqlVisitor.prototype.visitResource = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#singleInsertQuery. +SparkSqlVisitor.prototype.visitSingleInsertQuery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#multiInsertQuery. +SparkSqlVisitor.prototype.visitMultiInsertQuery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#deleteFromTable. +SparkSqlVisitor.prototype.visitDeleteFromTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#updateTable. +SparkSqlVisitor.prototype.visitUpdateTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#mergeIntoTable. +SparkSqlVisitor.prototype.visitMergeIntoTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#queryOrganization. +SparkSqlVisitor.prototype.visitQueryOrganization = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#multiInsertQueryBody. +SparkSqlVisitor.prototype.visitMultiInsertQueryBody = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#queryTermDefault. +SparkSqlVisitor.prototype.visitQueryTermDefault = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setOperation. +SparkSqlVisitor.prototype.visitSetOperation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#queryPrimaryDefault. +SparkSqlVisitor.prototype.visitQueryPrimaryDefault = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#fromStmt. +SparkSqlVisitor.prototype.visitFromStmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#table. +SparkSqlVisitor.prototype.visitTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#inlineTableDefault1. +SparkSqlVisitor.prototype.visitInlineTableDefault1 = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#subquery. +SparkSqlVisitor.prototype.visitSubquery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#sortItem. +SparkSqlVisitor.prototype.visitSortItem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#fromStatement. +SparkSqlVisitor.prototype.visitFromStatement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#fromStatementBody. +SparkSqlVisitor.prototype.visitFromStatementBody = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#transformQuerySpecification. +SparkSqlVisitor.prototype.visitTransformQuerySpecification = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#regularQuerySpecification. +SparkSqlVisitor.prototype.visitRegularQuerySpecification = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#transformClause. +SparkSqlVisitor.prototype.visitTransformClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#selectClause. +SparkSqlVisitor.prototype.visitSelectClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setClause. +SparkSqlVisitor.prototype.visitSetClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#matchedClause. +SparkSqlVisitor.prototype.visitMatchedClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#notMatchedClause. +SparkSqlVisitor.prototype.visitNotMatchedClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#matchedAction. +SparkSqlVisitor.prototype.visitMatchedAction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#notMatchedAction. +SparkSqlVisitor.prototype.visitNotMatchedAction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#assignmentList. +SparkSqlVisitor.prototype.visitAssignmentList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#assignment. +SparkSqlVisitor.prototype.visitAssignment = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#whereClause. +SparkSqlVisitor.prototype.visitWhereClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#havingClause. +SparkSqlVisitor.prototype.visitHavingClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#hint. +SparkSqlVisitor.prototype.visitHint = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#hintStatement. +SparkSqlVisitor.prototype.visitHintStatement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#fromClause. +SparkSqlVisitor.prototype.visitFromClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#aggregationClause. +SparkSqlVisitor.prototype.visitAggregationClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#groupingSet. +SparkSqlVisitor.prototype.visitGroupingSet = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#pivotClause. +SparkSqlVisitor.prototype.visitPivotClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#pivotColumn. +SparkSqlVisitor.prototype.visitPivotColumn = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#pivotValue. +SparkSqlVisitor.prototype.visitPivotValue = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#lateralView. +SparkSqlVisitor.prototype.visitLateralView = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#setQuantifier. +SparkSqlVisitor.prototype.visitSetQuantifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#relation. +SparkSqlVisitor.prototype.visitRelation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#joinRelation. +SparkSqlVisitor.prototype.visitJoinRelation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#joinType. +SparkSqlVisitor.prototype.visitJoinType = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#joinCriteria. +SparkSqlVisitor.prototype.visitJoinCriteria = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#sample. +SparkSqlVisitor.prototype.visitSample = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#sampleByPercentile. +SparkSqlVisitor.prototype.visitSampleByPercentile = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#sampleByRows. +SparkSqlVisitor.prototype.visitSampleByRows = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#sampleByBucket. +SparkSqlVisitor.prototype.visitSampleByBucket = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#sampleByBytes. +SparkSqlVisitor.prototype.visitSampleByBytes = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#identifierList. +SparkSqlVisitor.prototype.visitIdentifierList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#identifierSeq. +SparkSqlVisitor.prototype.visitIdentifierSeq = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#orderedIdentifierList. +SparkSqlVisitor.prototype.visitOrderedIdentifierList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#orderedIdentifier. +SparkSqlVisitor.prototype.visitOrderedIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#identifierCommentList. +SparkSqlVisitor.prototype.visitIdentifierCommentList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#identifierComment. +SparkSqlVisitor.prototype.visitIdentifierComment = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tableName. +SparkSqlVisitor.prototype.visitTableName = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#aliasedQuery. +SparkSqlVisitor.prototype.visitAliasedQuery = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#aliasedRelation. +SparkSqlVisitor.prototype.visitAliasedRelation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#inlineTableDefault2. +SparkSqlVisitor.prototype.visitInlineTableDefault2 = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tableValuedFunction. +SparkSqlVisitor.prototype.visitTableValuedFunction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#inlineTable. +SparkSqlVisitor.prototype.visitInlineTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#functionTable. +SparkSqlVisitor.prototype.visitFunctionTable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tableAlias. +SparkSqlVisitor.prototype.visitTableAlias = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#rowFormatSerde. +SparkSqlVisitor.prototype.visitRowFormatSerde = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#rowFormatDelimited. +SparkSqlVisitor.prototype.visitRowFormatDelimited = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#multipartIdentifierList. +SparkSqlVisitor.prototype.visitMultipartIdentifierList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#multipartIdentifier. +SparkSqlVisitor.prototype.visitMultipartIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tableIdentifier. +SparkSqlVisitor.prototype.visitTableIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#namedExpression. +SparkSqlVisitor.prototype.visitNamedExpression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#namedExpressionSeq. +SparkSqlVisitor.prototype.visitNamedExpressionSeq = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#transformList. +SparkSqlVisitor.prototype.visitTransformList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#identityTransform. +SparkSqlVisitor.prototype.visitIdentityTransform = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#applyTransform. +SparkSqlVisitor.prototype.visitApplyTransform = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#transformArgument. +SparkSqlVisitor.prototype.visitTransformArgument = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#expression. +SparkSqlVisitor.prototype.visitExpression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#logicalNot. +SparkSqlVisitor.prototype.visitLogicalNot = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#predicated. +SparkSqlVisitor.prototype.visitPredicated = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#exists. +SparkSqlVisitor.prototype.visitExists = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#logicalBinary. +SparkSqlVisitor.prototype.visitLogicalBinary = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#predicate. +SparkSqlVisitor.prototype.visitPredicate = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#valueExpressionDefault. +SparkSqlVisitor.prototype.visitValueExpressionDefault = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#comparison. +SparkSqlVisitor.prototype.visitComparison = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#arithmeticBinary. +SparkSqlVisitor.prototype.visitArithmeticBinary = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#arithmeticUnary. +SparkSqlVisitor.prototype.visitArithmeticUnary = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#struct. +SparkSqlVisitor.prototype.visitStruct = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#dereference. +SparkSqlVisitor.prototype.visitDereference = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#simpleCase. +SparkSqlVisitor.prototype.visitSimpleCase = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#columnReference. +SparkSqlVisitor.prototype.visitColumnReference = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#rowConstructor. +SparkSqlVisitor.prototype.visitRowConstructor = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#last. +SparkSqlVisitor.prototype.visitLast = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#star. +SparkSqlVisitor.prototype.visitStar = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#overlay. +SparkSqlVisitor.prototype.visitOverlay = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#subscript. +SparkSqlVisitor.prototype.visitSubscript = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#subqueryExpression. +SparkSqlVisitor.prototype.visitSubqueryExpression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#substring. +SparkSqlVisitor.prototype.visitSubstring = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#currentDatetime. +SparkSqlVisitor.prototype.visitCurrentDatetime = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#cast. +SparkSqlVisitor.prototype.visitCast = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#constantDefault. +SparkSqlVisitor.prototype.visitConstantDefault = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#lambda. +SparkSqlVisitor.prototype.visitLambda = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#parenthesizedExpression. +SparkSqlVisitor.prototype.visitParenthesizedExpression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#extract. +SparkSqlVisitor.prototype.visitExtract = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#trim. +SparkSqlVisitor.prototype.visitTrim = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#functionCall. +SparkSqlVisitor.prototype.visitFunctionCall = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#searchedCase. +SparkSqlVisitor.prototype.visitSearchedCase = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#position. +SparkSqlVisitor.prototype.visitPosition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#first. +SparkSqlVisitor.prototype.visitFirst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#nullLiteral. +SparkSqlVisitor.prototype.visitNullLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#intervalLiteral. +SparkSqlVisitor.prototype.visitIntervalLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#typeConstructor. +SparkSqlVisitor.prototype.visitTypeConstructor = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#numericLiteral. +SparkSqlVisitor.prototype.visitNumericLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#booleanLiteral. +SparkSqlVisitor.prototype.visitBooleanLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#stringLiteral. +SparkSqlVisitor.prototype.visitStringLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#comparisonOperator. +SparkSqlVisitor.prototype.visitComparisonOperator = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#arithmeticOperator. +SparkSqlVisitor.prototype.visitArithmeticOperator = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#predicateOperator. +SparkSqlVisitor.prototype.visitPredicateOperator = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#booleanValue. +SparkSqlVisitor.prototype.visitBooleanValue = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#interval. +SparkSqlVisitor.prototype.visitInterval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#errorCapturingMultiUnitsInterval. +SparkSqlVisitor.prototype.visitErrorCapturingMultiUnitsInterval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#multiUnitsInterval. +SparkSqlVisitor.prototype.visitMultiUnitsInterval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#errorCapturingUnitToUnitInterval. +SparkSqlVisitor.prototype.visitErrorCapturingUnitToUnitInterval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#unitToUnitInterval. +SparkSqlVisitor.prototype.visitUnitToUnitInterval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#intervalValue. +SparkSqlVisitor.prototype.visitIntervalValue = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#colPosition. +SparkSqlVisitor.prototype.visitColPosition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#complexDataType. +SparkSqlVisitor.prototype.visitComplexDataType = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#primitiveDataType. +SparkSqlVisitor.prototype.visitPrimitiveDataType = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#qualifiedColTypeWithPositionList. +SparkSqlVisitor.prototype.visitQualifiedColTypeWithPositionList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#qualifiedColTypeWithPosition. +SparkSqlVisitor.prototype.visitQualifiedColTypeWithPosition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#colTypeList. +SparkSqlVisitor.prototype.visitColTypeList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#colType. +SparkSqlVisitor.prototype.visitColType = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#complexColTypeList. +SparkSqlVisitor.prototype.visitComplexColTypeList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#complexColType. +SparkSqlVisitor.prototype.visitComplexColType = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#whenClause. +SparkSqlVisitor.prototype.visitWhenClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#windowClause. +SparkSqlVisitor.prototype.visitWindowClause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#namedWindow. +SparkSqlVisitor.prototype.visitNamedWindow = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#windowRef. +SparkSqlVisitor.prototype.visitWindowRef = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#windowDef. +SparkSqlVisitor.prototype.visitWindowDef = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#windowFrame. +SparkSqlVisitor.prototype.visitWindowFrame = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#frameBound. +SparkSqlVisitor.prototype.visitFrameBound = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#qualifiedNameList. +SparkSqlVisitor.prototype.visitQualifiedNameList = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#functionName. +SparkSqlVisitor.prototype.visitFunctionName = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#qualifiedName. +SparkSqlVisitor.prototype.visitQualifiedName = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#errorCapturingIdentifier. +SparkSqlVisitor.prototype.visitErrorCapturingIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#errorIdent. +SparkSqlVisitor.prototype.visitErrorIdent = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#realIdent. +SparkSqlVisitor.prototype.visitRealIdent = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#identifier. +SparkSqlVisitor.prototype.visitIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#unquotedIdentifier. +SparkSqlVisitor.prototype.visitUnquotedIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#quotedIdentifierAlternative. +SparkSqlVisitor.prototype.visitQuotedIdentifierAlternative = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#quotedIdentifier. +SparkSqlVisitor.prototype.visitQuotedIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#exponentLiteral. +SparkSqlVisitor.prototype.visitExponentLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#decimalLiteral. +SparkSqlVisitor.prototype.visitDecimalLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#legacyDecimalLiteral. +SparkSqlVisitor.prototype.visitLegacyDecimalLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#integerLiteral. +SparkSqlVisitor.prototype.visitIntegerLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#bigIntLiteral. +SparkSqlVisitor.prototype.visitBigIntLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#smallIntLiteral. +SparkSqlVisitor.prototype.visitSmallIntLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#tinyIntLiteral. +SparkSqlVisitor.prototype.visitTinyIntLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#doubleLiteral. +SparkSqlVisitor.prototype.visitDoubleLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#floatLiteral. +SparkSqlVisitor.prototype.visitFloatLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#bigDecimalLiteral. +SparkSqlVisitor.prototype.visitBigDecimalLiteral = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#alterColumnAction. +SparkSqlVisitor.prototype.visitAlterColumnAction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#ansiNonReserved. +SparkSqlVisitor.prototype.visitAnsiNonReserved = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#strictNonReserved. +SparkSqlVisitor.prototype.visitStrictNonReserved = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by SparkSqlParser#nonReserved. +SparkSqlVisitor.prototype.visitNonReserved = function(ctx) { + return this.visitChildren(ctx); +}; + + + +exports.SparkSqlVisitor = SparkSqlVisitor; \ No newline at end of file diff --git a/src/lib/spark/SqlBaseListener.js b/src/lib/spark/SqlBaseListener.js deleted file mode 100644 index 1cc870b..0000000 --- a/src/lib/spark/SqlBaseListener.js +++ /dev/null @@ -1,2445 +0,0 @@ -// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SqlBase.g4 by ANTLR 4.8 -// jshint ignore: start -var antlr4 = require('antlr4/index'); - -// This class defines a complete listener for a parse tree produced by SqlBaseParser. -function SqlBaseListener() { - antlr4.tree.ParseTreeListener.call(this); - return this; -} - -SqlBaseListener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype); -SqlBaseListener.prototype.constructor = SqlBaseListener; - -// Enter a parse tree produced by SqlBaseParser#program. -SqlBaseListener.prototype.enterProgram = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#program. -SqlBaseListener.prototype.exitProgram = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#singleStatement. -SqlBaseListener.prototype.enterSingleStatement = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#singleStatement. -SqlBaseListener.prototype.exitSingleStatement = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#singleExpression. -SqlBaseListener.prototype.enterSingleExpression = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#singleExpression. -SqlBaseListener.prototype.exitSingleExpression = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#singleTableIdentifier. -SqlBaseListener.prototype.enterSingleTableIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#singleTableIdentifier. -SqlBaseListener.prototype.exitSingleTableIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#singleMultipartIdentifier. -SqlBaseListener.prototype.enterSingleMultipartIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#singleMultipartIdentifier. -SqlBaseListener.prototype.exitSingleMultipartIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#singleDataType. -SqlBaseListener.prototype.enterSingleDataType = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#singleDataType. -SqlBaseListener.prototype.exitSingleDataType = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#singleTableSchema. -SqlBaseListener.prototype.enterSingleTableSchema = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#singleTableSchema. -SqlBaseListener.prototype.exitSingleTableSchema = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#statementDefault. -SqlBaseListener.prototype.enterStatementDefault = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#statementDefault. -SqlBaseListener.prototype.exitStatementDefault = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dmlStatement. -SqlBaseListener.prototype.enterDmlStatement = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dmlStatement. -SqlBaseListener.prototype.exitDmlStatement = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#use. -SqlBaseListener.prototype.enterUse = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#use. -SqlBaseListener.prototype.exitUse = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createNamespace. -SqlBaseListener.prototype.enterCreateNamespace = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createNamespace. -SqlBaseListener.prototype.exitCreateNamespace = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setNamespaceProperties. -SqlBaseListener.prototype.enterSetNamespaceProperties = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setNamespaceProperties. -SqlBaseListener.prototype.exitSetNamespaceProperties = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setNamespaceLocation. -SqlBaseListener.prototype.enterSetNamespaceLocation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setNamespaceLocation. -SqlBaseListener.prototype.exitSetNamespaceLocation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dropNamespace. -SqlBaseListener.prototype.enterDropNamespace = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dropNamespace. -SqlBaseListener.prototype.exitDropNamespace = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showNamespaces. -SqlBaseListener.prototype.enterShowNamespaces = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showNamespaces. -SqlBaseListener.prototype.exitShowNamespaces = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createTable. -SqlBaseListener.prototype.enterCreateTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createTable. -SqlBaseListener.prototype.exitCreateTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createHiveTable. -SqlBaseListener.prototype.enterCreateHiveTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createHiveTable. -SqlBaseListener.prototype.exitCreateHiveTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createTableLike. -SqlBaseListener.prototype.enterCreateTableLike = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createTableLike. -SqlBaseListener.prototype.exitCreateTableLike = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#replaceTable. -SqlBaseListener.prototype.enterReplaceTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#replaceTable. -SqlBaseListener.prototype.exitReplaceTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#analyze. -SqlBaseListener.prototype.enterAnalyze = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#analyze. -SqlBaseListener.prototype.exitAnalyze = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#addTableColumns. -SqlBaseListener.prototype.enterAddTableColumns = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#addTableColumns. -SqlBaseListener.prototype.exitAddTableColumns = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#renameTableColumn. -SqlBaseListener.prototype.enterRenameTableColumn = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#renameTableColumn. -SqlBaseListener.prototype.exitRenameTableColumn = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dropTableColumns. -SqlBaseListener.prototype.enterDropTableColumns = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dropTableColumns. -SqlBaseListener.prototype.exitDropTableColumns = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#renameTable. -SqlBaseListener.prototype.enterRenameTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#renameTable. -SqlBaseListener.prototype.exitRenameTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setTableProperties. -SqlBaseListener.prototype.enterSetTableProperties = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setTableProperties. -SqlBaseListener.prototype.exitSetTableProperties = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#unsetTableProperties. -SqlBaseListener.prototype.enterUnsetTableProperties = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#unsetTableProperties. -SqlBaseListener.prototype.exitUnsetTableProperties = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#alterTableAlterColumn. -SqlBaseListener.prototype.enterAlterTableAlterColumn = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#alterTableAlterColumn. -SqlBaseListener.prototype.exitAlterTableAlterColumn = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#hiveChangeColumn. -SqlBaseListener.prototype.enterHiveChangeColumn = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#hiveChangeColumn. -SqlBaseListener.prototype.exitHiveChangeColumn = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#hiveReplaceColumns. -SqlBaseListener.prototype.enterHiveReplaceColumns = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#hiveReplaceColumns. -SqlBaseListener.prototype.exitHiveReplaceColumns = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setTableSerDe. -SqlBaseListener.prototype.enterSetTableSerDe = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setTableSerDe. -SqlBaseListener.prototype.exitSetTableSerDe = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#addTablePartition. -SqlBaseListener.prototype.enterAddTablePartition = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#addTablePartition. -SqlBaseListener.prototype.exitAddTablePartition = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#renameTablePartition. -SqlBaseListener.prototype.enterRenameTablePartition = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#renameTablePartition. -SqlBaseListener.prototype.exitRenameTablePartition = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dropTablePartitions. -SqlBaseListener.prototype.enterDropTablePartitions = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dropTablePartitions. -SqlBaseListener.prototype.exitDropTablePartitions = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setTableLocation. -SqlBaseListener.prototype.enterSetTableLocation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setTableLocation. -SqlBaseListener.prototype.exitSetTableLocation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#recoverPartitions. -SqlBaseListener.prototype.enterRecoverPartitions = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#recoverPartitions. -SqlBaseListener.prototype.exitRecoverPartitions = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dropTable. -SqlBaseListener.prototype.enterDropTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dropTable. -SqlBaseListener.prototype.exitDropTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dropView. -SqlBaseListener.prototype.enterDropView = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dropView. -SqlBaseListener.prototype.exitDropView = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createView. -SqlBaseListener.prototype.enterCreateView = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createView. -SqlBaseListener.prototype.exitCreateView = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createTempViewUsing. -SqlBaseListener.prototype.enterCreateTempViewUsing = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createTempViewUsing. -SqlBaseListener.prototype.exitCreateTempViewUsing = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#alterViewQuery. -SqlBaseListener.prototype.enterAlterViewQuery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#alterViewQuery. -SqlBaseListener.prototype.exitAlterViewQuery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createFunction. -SqlBaseListener.prototype.enterCreateFunction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createFunction. -SqlBaseListener.prototype.exitCreateFunction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dropFunction. -SqlBaseListener.prototype.enterDropFunction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dropFunction. -SqlBaseListener.prototype.exitDropFunction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#explain. -SqlBaseListener.prototype.enterExplain = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#explain. -SqlBaseListener.prototype.exitExplain = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showTables. -SqlBaseListener.prototype.enterShowTables = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showTables. -SqlBaseListener.prototype.exitShowTables = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showTable. -SqlBaseListener.prototype.enterShowTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showTable. -SqlBaseListener.prototype.exitShowTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showTblProperties. -SqlBaseListener.prototype.enterShowTblProperties = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showTblProperties. -SqlBaseListener.prototype.exitShowTblProperties = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showColumns. -SqlBaseListener.prototype.enterShowColumns = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showColumns. -SqlBaseListener.prototype.exitShowColumns = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showViews. -SqlBaseListener.prototype.enterShowViews = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showViews. -SqlBaseListener.prototype.exitShowViews = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showPartitions. -SqlBaseListener.prototype.enterShowPartitions = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showPartitions. -SqlBaseListener.prototype.exitShowPartitions = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showFunctions. -SqlBaseListener.prototype.enterShowFunctions = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showFunctions. -SqlBaseListener.prototype.exitShowFunctions = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showCreateTable. -SqlBaseListener.prototype.enterShowCreateTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showCreateTable. -SqlBaseListener.prototype.exitShowCreateTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#showCurrentNamespace. -SqlBaseListener.prototype.enterShowCurrentNamespace = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#showCurrentNamespace. -SqlBaseListener.prototype.exitShowCurrentNamespace = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#describeFunction. -SqlBaseListener.prototype.enterDescribeFunction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#describeFunction. -SqlBaseListener.prototype.exitDescribeFunction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#describeNamespace. -SqlBaseListener.prototype.enterDescribeNamespace = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#describeNamespace. -SqlBaseListener.prototype.exitDescribeNamespace = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#describeRelation. -SqlBaseListener.prototype.enterDescribeRelation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#describeRelation. -SqlBaseListener.prototype.exitDescribeRelation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#describeQuery. -SqlBaseListener.prototype.enterDescribeQuery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#describeQuery. -SqlBaseListener.prototype.exitDescribeQuery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#commentNamespace. -SqlBaseListener.prototype.enterCommentNamespace = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#commentNamespace. -SqlBaseListener.prototype.exitCommentNamespace = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#commentTable. -SqlBaseListener.prototype.enterCommentTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#commentTable. -SqlBaseListener.prototype.exitCommentTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#refreshTable. -SqlBaseListener.prototype.enterRefreshTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#refreshTable. -SqlBaseListener.prototype.exitRefreshTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#refreshFunction. -SqlBaseListener.prototype.enterRefreshFunction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#refreshFunction. -SqlBaseListener.prototype.exitRefreshFunction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#refreshResource. -SqlBaseListener.prototype.enterRefreshResource = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#refreshResource. -SqlBaseListener.prototype.exitRefreshResource = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#cacheTable. -SqlBaseListener.prototype.enterCacheTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#cacheTable. -SqlBaseListener.prototype.exitCacheTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#uncacheTable. -SqlBaseListener.prototype.enterUncacheTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#uncacheTable. -SqlBaseListener.prototype.exitUncacheTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#clearCache. -SqlBaseListener.prototype.enterClearCache = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#clearCache. -SqlBaseListener.prototype.exitClearCache = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#loadData. -SqlBaseListener.prototype.enterLoadData = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#loadData. -SqlBaseListener.prototype.exitLoadData = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#truncateTable. -SqlBaseListener.prototype.enterTruncateTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#truncateTable. -SqlBaseListener.prototype.exitTruncateTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#repairTable. -SqlBaseListener.prototype.enterRepairTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#repairTable. -SqlBaseListener.prototype.exitRepairTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#manageResource. -SqlBaseListener.prototype.enterManageResource = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#manageResource. -SqlBaseListener.prototype.exitManageResource = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#failNativeCommand. -SqlBaseListener.prototype.enterFailNativeCommand = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#failNativeCommand. -SqlBaseListener.prototype.exitFailNativeCommand = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setTimeZone. -SqlBaseListener.prototype.enterSetTimeZone = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setTimeZone. -SqlBaseListener.prototype.exitSetTimeZone = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setQuotedConfiguration. -SqlBaseListener.prototype.enterSetQuotedConfiguration = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setQuotedConfiguration. -SqlBaseListener.prototype.exitSetQuotedConfiguration = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setConfiguration. -SqlBaseListener.prototype.enterSetConfiguration = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setConfiguration. -SqlBaseListener.prototype.exitSetConfiguration = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#resetQuotedConfiguration. -SqlBaseListener.prototype.enterResetQuotedConfiguration = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#resetQuotedConfiguration. -SqlBaseListener.prototype.exitResetQuotedConfiguration = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#resetConfiguration. -SqlBaseListener.prototype.enterResetConfiguration = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#resetConfiguration. -SqlBaseListener.prototype.exitResetConfiguration = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#configKey. -SqlBaseListener.prototype.enterConfigKey = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#configKey. -SqlBaseListener.prototype.exitConfigKey = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#unsupportedHiveNativeCommands. -SqlBaseListener.prototype.enterUnsupportedHiveNativeCommands = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#unsupportedHiveNativeCommands. -SqlBaseListener.prototype.exitUnsupportedHiveNativeCommands = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createTableHeader. -SqlBaseListener.prototype.enterCreateTableHeader = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createTableHeader. -SqlBaseListener.prototype.exitCreateTableHeader = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#replaceTableHeader. -SqlBaseListener.prototype.enterReplaceTableHeader = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#replaceTableHeader. -SqlBaseListener.prototype.exitReplaceTableHeader = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#bucketSpec. -SqlBaseListener.prototype.enterBucketSpec = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#bucketSpec. -SqlBaseListener.prototype.exitBucketSpec = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#skewSpec. -SqlBaseListener.prototype.enterSkewSpec = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#skewSpec. -SqlBaseListener.prototype.exitSkewSpec = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#locationSpec. -SqlBaseListener.prototype.enterLocationSpec = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#locationSpec. -SqlBaseListener.prototype.exitLocationSpec = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#commentSpec. -SqlBaseListener.prototype.enterCommentSpec = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#commentSpec. -SqlBaseListener.prototype.exitCommentSpec = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#query. -SqlBaseListener.prototype.enterQuery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#query. -SqlBaseListener.prototype.exitQuery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#insertOverwriteTable. -SqlBaseListener.prototype.enterInsertOverwriteTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#insertOverwriteTable. -SqlBaseListener.prototype.exitInsertOverwriteTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#insertIntoTable. -SqlBaseListener.prototype.enterInsertIntoTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#insertIntoTable. -SqlBaseListener.prototype.exitInsertIntoTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#insertOverwriteHiveDir. -SqlBaseListener.prototype.enterInsertOverwriteHiveDir = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#insertOverwriteHiveDir. -SqlBaseListener.prototype.exitInsertOverwriteHiveDir = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#insertOverwriteDir. -SqlBaseListener.prototype.enterInsertOverwriteDir = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#insertOverwriteDir. -SqlBaseListener.prototype.exitInsertOverwriteDir = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#partitionSpecLocation. -SqlBaseListener.prototype.enterPartitionSpecLocation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#partitionSpecLocation. -SqlBaseListener.prototype.exitPartitionSpecLocation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#partitionSpec. -SqlBaseListener.prototype.enterPartitionSpec = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#partitionSpec. -SqlBaseListener.prototype.exitPartitionSpec = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#partitionVal. -SqlBaseListener.prototype.enterPartitionVal = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#partitionVal. -SqlBaseListener.prototype.exitPartitionVal = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#namespace. -SqlBaseListener.prototype.enterNamespace = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#namespace. -SqlBaseListener.prototype.exitNamespace = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#describeFuncName. -SqlBaseListener.prototype.enterDescribeFuncName = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#describeFuncName. -SqlBaseListener.prototype.exitDescribeFuncName = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#describeColName. -SqlBaseListener.prototype.enterDescribeColName = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#describeColName. -SqlBaseListener.prototype.exitDescribeColName = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#ctes. -SqlBaseListener.prototype.enterCtes = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#ctes. -SqlBaseListener.prototype.exitCtes = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#namedQuery. -SqlBaseListener.prototype.enterNamedQuery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#namedQuery. -SqlBaseListener.prototype.exitNamedQuery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tableProvider. -SqlBaseListener.prototype.enterTableProvider = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tableProvider. -SqlBaseListener.prototype.exitTableProvider = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createTableClauses. -SqlBaseListener.prototype.enterCreateTableClauses = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createTableClauses. -SqlBaseListener.prototype.exitCreateTableClauses = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tablePropertyList. -SqlBaseListener.prototype.enterTablePropertyList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tablePropertyList. -SqlBaseListener.prototype.exitTablePropertyList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tableProperty. -SqlBaseListener.prototype.enterTableProperty = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tableProperty. -SqlBaseListener.prototype.exitTableProperty = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tablePropertyKey. -SqlBaseListener.prototype.enterTablePropertyKey = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tablePropertyKey. -SqlBaseListener.prototype.exitTablePropertyKey = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tablePropertyValue. -SqlBaseListener.prototype.enterTablePropertyValue = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tablePropertyValue. -SqlBaseListener.prototype.exitTablePropertyValue = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#constantList. -SqlBaseListener.prototype.enterConstantList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#constantList. -SqlBaseListener.prototype.exitConstantList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#nestedConstantList. -SqlBaseListener.prototype.enterNestedConstantList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#nestedConstantList. -SqlBaseListener.prototype.exitNestedConstantList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#createFileFormat. -SqlBaseListener.prototype.enterCreateFileFormat = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#createFileFormat. -SqlBaseListener.prototype.exitCreateFileFormat = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tableFileFormat. -SqlBaseListener.prototype.enterTableFileFormat = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tableFileFormat. -SqlBaseListener.prototype.exitTableFileFormat = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#genericFileFormat. -SqlBaseListener.prototype.enterGenericFileFormat = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#genericFileFormat. -SqlBaseListener.prototype.exitGenericFileFormat = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#storageHandler. -SqlBaseListener.prototype.enterStorageHandler = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#storageHandler. -SqlBaseListener.prototype.exitStorageHandler = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#resource. -SqlBaseListener.prototype.enterResource = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#resource. -SqlBaseListener.prototype.exitResource = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#singleInsertQuery. -SqlBaseListener.prototype.enterSingleInsertQuery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#singleInsertQuery. -SqlBaseListener.prototype.exitSingleInsertQuery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#multiInsertQuery. -SqlBaseListener.prototype.enterMultiInsertQuery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#multiInsertQuery. -SqlBaseListener.prototype.exitMultiInsertQuery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#deleteFromTable. -SqlBaseListener.prototype.enterDeleteFromTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#deleteFromTable. -SqlBaseListener.prototype.exitDeleteFromTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#updateTable. -SqlBaseListener.prototype.enterUpdateTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#updateTable. -SqlBaseListener.prototype.exitUpdateTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#mergeIntoTable. -SqlBaseListener.prototype.enterMergeIntoTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#mergeIntoTable. -SqlBaseListener.prototype.exitMergeIntoTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#queryOrganization. -SqlBaseListener.prototype.enterQueryOrganization = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#queryOrganization. -SqlBaseListener.prototype.exitQueryOrganization = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#multiInsertQueryBody. -SqlBaseListener.prototype.enterMultiInsertQueryBody = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#multiInsertQueryBody. -SqlBaseListener.prototype.exitMultiInsertQueryBody = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#queryTermDefault. -SqlBaseListener.prototype.enterQueryTermDefault = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#queryTermDefault. -SqlBaseListener.prototype.exitQueryTermDefault = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setOperation. -SqlBaseListener.prototype.enterSetOperation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setOperation. -SqlBaseListener.prototype.exitSetOperation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#queryPrimaryDefault. -SqlBaseListener.prototype.enterQueryPrimaryDefault = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#queryPrimaryDefault. -SqlBaseListener.prototype.exitQueryPrimaryDefault = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#fromStmt. -SqlBaseListener.prototype.enterFromStmt = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#fromStmt. -SqlBaseListener.prototype.exitFromStmt = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#table. -SqlBaseListener.prototype.enterTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#table. -SqlBaseListener.prototype.exitTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#inlineTableDefault1. -SqlBaseListener.prototype.enterInlineTableDefault1 = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#inlineTableDefault1. -SqlBaseListener.prototype.exitInlineTableDefault1 = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#subquery. -SqlBaseListener.prototype.enterSubquery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#subquery. -SqlBaseListener.prototype.exitSubquery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#sortItem. -SqlBaseListener.prototype.enterSortItem = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#sortItem. -SqlBaseListener.prototype.exitSortItem = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#fromStatement. -SqlBaseListener.prototype.enterFromStatement = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#fromStatement. -SqlBaseListener.prototype.exitFromStatement = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#fromStatementBody. -SqlBaseListener.prototype.enterFromStatementBody = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#fromStatementBody. -SqlBaseListener.prototype.exitFromStatementBody = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#transformQuerySpecification. -SqlBaseListener.prototype.enterTransformQuerySpecification = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#transformQuerySpecification. -SqlBaseListener.prototype.exitTransformQuerySpecification = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#regularQuerySpecification. -SqlBaseListener.prototype.enterRegularQuerySpecification = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#regularQuerySpecification. -SqlBaseListener.prototype.exitRegularQuerySpecification = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#transformClause. -SqlBaseListener.prototype.enterTransformClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#transformClause. -SqlBaseListener.prototype.exitTransformClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#selectClause. -SqlBaseListener.prototype.enterSelectClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#selectClause. -SqlBaseListener.prototype.exitSelectClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setClause. -SqlBaseListener.prototype.enterSetClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setClause. -SqlBaseListener.prototype.exitSetClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#matchedClause. -SqlBaseListener.prototype.enterMatchedClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#matchedClause. -SqlBaseListener.prototype.exitMatchedClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#notMatchedClause. -SqlBaseListener.prototype.enterNotMatchedClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#notMatchedClause. -SqlBaseListener.prototype.exitNotMatchedClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#matchedAction. -SqlBaseListener.prototype.enterMatchedAction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#matchedAction. -SqlBaseListener.prototype.exitMatchedAction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#notMatchedAction. -SqlBaseListener.prototype.enterNotMatchedAction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#notMatchedAction. -SqlBaseListener.prototype.exitNotMatchedAction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#assignmentList. -SqlBaseListener.prototype.enterAssignmentList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#assignmentList. -SqlBaseListener.prototype.exitAssignmentList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#assignment. -SqlBaseListener.prototype.enterAssignment = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#assignment. -SqlBaseListener.prototype.exitAssignment = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#whereClause. -SqlBaseListener.prototype.enterWhereClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#whereClause. -SqlBaseListener.prototype.exitWhereClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#havingClause. -SqlBaseListener.prototype.enterHavingClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#havingClause. -SqlBaseListener.prototype.exitHavingClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#hint. -SqlBaseListener.prototype.enterHint = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#hint. -SqlBaseListener.prototype.exitHint = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#hintStatement. -SqlBaseListener.prototype.enterHintStatement = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#hintStatement. -SqlBaseListener.prototype.exitHintStatement = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#fromClause. -SqlBaseListener.prototype.enterFromClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#fromClause. -SqlBaseListener.prototype.exitFromClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#aggregationClause. -SqlBaseListener.prototype.enterAggregationClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#aggregationClause. -SqlBaseListener.prototype.exitAggregationClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#groupingSet. -SqlBaseListener.prototype.enterGroupingSet = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#groupingSet. -SqlBaseListener.prototype.exitGroupingSet = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#pivotClause. -SqlBaseListener.prototype.enterPivotClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#pivotClause. -SqlBaseListener.prototype.exitPivotClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#pivotColumn. -SqlBaseListener.prototype.enterPivotColumn = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#pivotColumn. -SqlBaseListener.prototype.exitPivotColumn = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#pivotValue. -SqlBaseListener.prototype.enterPivotValue = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#pivotValue. -SqlBaseListener.prototype.exitPivotValue = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#lateralView. -SqlBaseListener.prototype.enterLateralView = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#lateralView. -SqlBaseListener.prototype.exitLateralView = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#setQuantifier. -SqlBaseListener.prototype.enterSetQuantifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#setQuantifier. -SqlBaseListener.prototype.exitSetQuantifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#relation. -SqlBaseListener.prototype.enterRelation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#relation. -SqlBaseListener.prototype.exitRelation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#joinRelation. -SqlBaseListener.prototype.enterJoinRelation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#joinRelation. -SqlBaseListener.prototype.exitJoinRelation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#joinType. -SqlBaseListener.prototype.enterJoinType = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#joinType. -SqlBaseListener.prototype.exitJoinType = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#joinCriteria. -SqlBaseListener.prototype.enterJoinCriteria = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#joinCriteria. -SqlBaseListener.prototype.exitJoinCriteria = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#sample. -SqlBaseListener.prototype.enterSample = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#sample. -SqlBaseListener.prototype.exitSample = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#sampleByPercentile. -SqlBaseListener.prototype.enterSampleByPercentile = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#sampleByPercentile. -SqlBaseListener.prototype.exitSampleByPercentile = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#sampleByRows. -SqlBaseListener.prototype.enterSampleByRows = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#sampleByRows. -SqlBaseListener.prototype.exitSampleByRows = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#sampleByBucket. -SqlBaseListener.prototype.enterSampleByBucket = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#sampleByBucket. -SqlBaseListener.prototype.exitSampleByBucket = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#sampleByBytes. -SqlBaseListener.prototype.enterSampleByBytes = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#sampleByBytes. -SqlBaseListener.prototype.exitSampleByBytes = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#identifierList. -SqlBaseListener.prototype.enterIdentifierList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#identifierList. -SqlBaseListener.prototype.exitIdentifierList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#identifierSeq. -SqlBaseListener.prototype.enterIdentifierSeq = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#identifierSeq. -SqlBaseListener.prototype.exitIdentifierSeq = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#orderedIdentifierList. -SqlBaseListener.prototype.enterOrderedIdentifierList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#orderedIdentifierList. -SqlBaseListener.prototype.exitOrderedIdentifierList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#orderedIdentifier. -SqlBaseListener.prototype.enterOrderedIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#orderedIdentifier. -SqlBaseListener.prototype.exitOrderedIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#identifierCommentList. -SqlBaseListener.prototype.enterIdentifierCommentList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#identifierCommentList. -SqlBaseListener.prototype.exitIdentifierCommentList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#identifierComment. -SqlBaseListener.prototype.enterIdentifierComment = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#identifierComment. -SqlBaseListener.prototype.exitIdentifierComment = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tableName. -SqlBaseListener.prototype.enterTableName = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tableName. -SqlBaseListener.prototype.exitTableName = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#aliasedQuery. -SqlBaseListener.prototype.enterAliasedQuery = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#aliasedQuery. -SqlBaseListener.prototype.exitAliasedQuery = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#aliasedRelation. -SqlBaseListener.prototype.enterAliasedRelation = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#aliasedRelation. -SqlBaseListener.prototype.exitAliasedRelation = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#inlineTableDefault2. -SqlBaseListener.prototype.enterInlineTableDefault2 = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#inlineTableDefault2. -SqlBaseListener.prototype.exitInlineTableDefault2 = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tableValuedFunction. -SqlBaseListener.prototype.enterTableValuedFunction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tableValuedFunction. -SqlBaseListener.prototype.exitTableValuedFunction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#inlineTable. -SqlBaseListener.prototype.enterInlineTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#inlineTable. -SqlBaseListener.prototype.exitInlineTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#functionTable. -SqlBaseListener.prototype.enterFunctionTable = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#functionTable. -SqlBaseListener.prototype.exitFunctionTable = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tableAlias. -SqlBaseListener.prototype.enterTableAlias = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tableAlias. -SqlBaseListener.prototype.exitTableAlias = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#rowFormatSerde. -SqlBaseListener.prototype.enterRowFormatSerde = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#rowFormatSerde. -SqlBaseListener.prototype.exitRowFormatSerde = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#rowFormatDelimited. -SqlBaseListener.prototype.enterRowFormatDelimited = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#rowFormatDelimited. -SqlBaseListener.prototype.exitRowFormatDelimited = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#multipartIdentifierList. -SqlBaseListener.prototype.enterMultipartIdentifierList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#multipartIdentifierList. -SqlBaseListener.prototype.exitMultipartIdentifierList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#multipartIdentifier. -SqlBaseListener.prototype.enterMultipartIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#multipartIdentifier. -SqlBaseListener.prototype.exitMultipartIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tableIdentifier. -SqlBaseListener.prototype.enterTableIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tableIdentifier. -SqlBaseListener.prototype.exitTableIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#namedExpression. -SqlBaseListener.prototype.enterNamedExpression = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#namedExpression. -SqlBaseListener.prototype.exitNamedExpression = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#namedExpressionSeq. -SqlBaseListener.prototype.enterNamedExpressionSeq = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#namedExpressionSeq. -SqlBaseListener.prototype.exitNamedExpressionSeq = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#transformList. -SqlBaseListener.prototype.enterTransformList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#transformList. -SqlBaseListener.prototype.exitTransformList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#identityTransform. -SqlBaseListener.prototype.enterIdentityTransform = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#identityTransform. -SqlBaseListener.prototype.exitIdentityTransform = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#applyTransform. -SqlBaseListener.prototype.enterApplyTransform = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#applyTransform. -SqlBaseListener.prototype.exitApplyTransform = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#transformArgument. -SqlBaseListener.prototype.enterTransformArgument = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#transformArgument. -SqlBaseListener.prototype.exitTransformArgument = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#expression. -SqlBaseListener.prototype.enterExpression = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#expression. -SqlBaseListener.prototype.exitExpression = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#logicalNot. -SqlBaseListener.prototype.enterLogicalNot = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#logicalNot. -SqlBaseListener.prototype.exitLogicalNot = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#predicated. -SqlBaseListener.prototype.enterPredicated = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#predicated. -SqlBaseListener.prototype.exitPredicated = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#exists. -SqlBaseListener.prototype.enterExists = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#exists. -SqlBaseListener.prototype.exitExists = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#logicalBinary. -SqlBaseListener.prototype.enterLogicalBinary = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#logicalBinary. -SqlBaseListener.prototype.exitLogicalBinary = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#predicate. -SqlBaseListener.prototype.enterPredicate = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#predicate. -SqlBaseListener.prototype.exitPredicate = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#valueExpressionDefault. -SqlBaseListener.prototype.enterValueExpressionDefault = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#valueExpressionDefault. -SqlBaseListener.prototype.exitValueExpressionDefault = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#comparison. -SqlBaseListener.prototype.enterComparison = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#comparison. -SqlBaseListener.prototype.exitComparison = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#arithmeticBinary. -SqlBaseListener.prototype.enterArithmeticBinary = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#arithmeticBinary. -SqlBaseListener.prototype.exitArithmeticBinary = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#arithmeticUnary. -SqlBaseListener.prototype.enterArithmeticUnary = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#arithmeticUnary. -SqlBaseListener.prototype.exitArithmeticUnary = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#struct. -SqlBaseListener.prototype.enterStruct = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#struct. -SqlBaseListener.prototype.exitStruct = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#dereference. -SqlBaseListener.prototype.enterDereference = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#dereference. -SqlBaseListener.prototype.exitDereference = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#simpleCase. -SqlBaseListener.prototype.enterSimpleCase = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#simpleCase. -SqlBaseListener.prototype.exitSimpleCase = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#columnReference. -SqlBaseListener.prototype.enterColumnReference = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#columnReference. -SqlBaseListener.prototype.exitColumnReference = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#rowConstructor. -SqlBaseListener.prototype.enterRowConstructor = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#rowConstructor. -SqlBaseListener.prototype.exitRowConstructor = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#last. -SqlBaseListener.prototype.enterLast = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#last. -SqlBaseListener.prototype.exitLast = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#star. -SqlBaseListener.prototype.enterStar = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#star. -SqlBaseListener.prototype.exitStar = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#overlay. -SqlBaseListener.prototype.enterOverlay = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#overlay. -SqlBaseListener.prototype.exitOverlay = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#subscript. -SqlBaseListener.prototype.enterSubscript = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#subscript. -SqlBaseListener.prototype.exitSubscript = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#subqueryExpression. -SqlBaseListener.prototype.enterSubqueryExpression = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#subqueryExpression. -SqlBaseListener.prototype.exitSubqueryExpression = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#substring. -SqlBaseListener.prototype.enterSubstring = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#substring. -SqlBaseListener.prototype.exitSubstring = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#currentDatetime. -SqlBaseListener.prototype.enterCurrentDatetime = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#currentDatetime. -SqlBaseListener.prototype.exitCurrentDatetime = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#cast. -SqlBaseListener.prototype.enterCast = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#cast. -SqlBaseListener.prototype.exitCast = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#constantDefault. -SqlBaseListener.prototype.enterConstantDefault = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#constantDefault. -SqlBaseListener.prototype.exitConstantDefault = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#lambda. -SqlBaseListener.prototype.enterLambda = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#lambda. -SqlBaseListener.prototype.exitLambda = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#parenthesizedExpression. -SqlBaseListener.prototype.enterParenthesizedExpression = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#parenthesizedExpression. -SqlBaseListener.prototype.exitParenthesizedExpression = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#extract. -SqlBaseListener.prototype.enterExtract = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#extract. -SqlBaseListener.prototype.exitExtract = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#trim. -SqlBaseListener.prototype.enterTrim = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#trim. -SqlBaseListener.prototype.exitTrim = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#functionCall. -SqlBaseListener.prototype.enterFunctionCall = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#functionCall. -SqlBaseListener.prototype.exitFunctionCall = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#searchedCase. -SqlBaseListener.prototype.enterSearchedCase = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#searchedCase. -SqlBaseListener.prototype.exitSearchedCase = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#position. -SqlBaseListener.prototype.enterPosition = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#position. -SqlBaseListener.prototype.exitPosition = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#first. -SqlBaseListener.prototype.enterFirst = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#first. -SqlBaseListener.prototype.exitFirst = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#nullLiteral. -SqlBaseListener.prototype.enterNullLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#nullLiteral. -SqlBaseListener.prototype.exitNullLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#intervalLiteral. -SqlBaseListener.prototype.enterIntervalLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#intervalLiteral. -SqlBaseListener.prototype.exitIntervalLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#typeConstructor. -SqlBaseListener.prototype.enterTypeConstructor = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#typeConstructor. -SqlBaseListener.prototype.exitTypeConstructor = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#numericLiteral. -SqlBaseListener.prototype.enterNumericLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#numericLiteral. -SqlBaseListener.prototype.exitNumericLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#booleanLiteral. -SqlBaseListener.prototype.enterBooleanLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#booleanLiteral. -SqlBaseListener.prototype.exitBooleanLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#stringLiteral. -SqlBaseListener.prototype.enterStringLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#stringLiteral. -SqlBaseListener.prototype.exitStringLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#comparisonOperator. -SqlBaseListener.prototype.enterComparisonOperator = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#comparisonOperator. -SqlBaseListener.prototype.exitComparisonOperator = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#arithmeticOperator. -SqlBaseListener.prototype.enterArithmeticOperator = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#arithmeticOperator. -SqlBaseListener.prototype.exitArithmeticOperator = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#predicateOperator. -SqlBaseListener.prototype.enterPredicateOperator = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#predicateOperator. -SqlBaseListener.prototype.exitPredicateOperator = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#booleanValue. -SqlBaseListener.prototype.enterBooleanValue = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#booleanValue. -SqlBaseListener.prototype.exitBooleanValue = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#interval. -SqlBaseListener.prototype.enterInterval = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#interval. -SqlBaseListener.prototype.exitInterval = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#errorCapturingMultiUnitsInterval. -SqlBaseListener.prototype.enterErrorCapturingMultiUnitsInterval = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#errorCapturingMultiUnitsInterval. -SqlBaseListener.prototype.exitErrorCapturingMultiUnitsInterval = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#multiUnitsInterval. -SqlBaseListener.prototype.enterMultiUnitsInterval = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#multiUnitsInterval. -SqlBaseListener.prototype.exitMultiUnitsInterval = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#errorCapturingUnitToUnitInterval. -SqlBaseListener.prototype.enterErrorCapturingUnitToUnitInterval = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#errorCapturingUnitToUnitInterval. -SqlBaseListener.prototype.exitErrorCapturingUnitToUnitInterval = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#unitToUnitInterval. -SqlBaseListener.prototype.enterUnitToUnitInterval = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#unitToUnitInterval. -SqlBaseListener.prototype.exitUnitToUnitInterval = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#intervalValue. -SqlBaseListener.prototype.enterIntervalValue = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#intervalValue. -SqlBaseListener.prototype.exitIntervalValue = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#colPosition. -SqlBaseListener.prototype.enterColPosition = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#colPosition. -SqlBaseListener.prototype.exitColPosition = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#complexDataType. -SqlBaseListener.prototype.enterComplexDataType = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#complexDataType. -SqlBaseListener.prototype.exitComplexDataType = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#primitiveDataType. -SqlBaseListener.prototype.enterPrimitiveDataType = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#primitiveDataType. -SqlBaseListener.prototype.exitPrimitiveDataType = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#qualifiedColTypeWithPositionList. -SqlBaseListener.prototype.enterQualifiedColTypeWithPositionList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#qualifiedColTypeWithPositionList. -SqlBaseListener.prototype.exitQualifiedColTypeWithPositionList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#qualifiedColTypeWithPosition. -SqlBaseListener.prototype.enterQualifiedColTypeWithPosition = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#qualifiedColTypeWithPosition. -SqlBaseListener.prototype.exitQualifiedColTypeWithPosition = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#colTypeList. -SqlBaseListener.prototype.enterColTypeList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#colTypeList. -SqlBaseListener.prototype.exitColTypeList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#colType. -SqlBaseListener.prototype.enterColType = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#colType. -SqlBaseListener.prototype.exitColType = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#complexColTypeList. -SqlBaseListener.prototype.enterComplexColTypeList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#complexColTypeList. -SqlBaseListener.prototype.exitComplexColTypeList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#complexColType. -SqlBaseListener.prototype.enterComplexColType = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#complexColType. -SqlBaseListener.prototype.exitComplexColType = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#whenClause. -SqlBaseListener.prototype.enterWhenClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#whenClause. -SqlBaseListener.prototype.exitWhenClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#windowClause. -SqlBaseListener.prototype.enterWindowClause = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#windowClause. -SqlBaseListener.prototype.exitWindowClause = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#namedWindow. -SqlBaseListener.prototype.enterNamedWindow = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#namedWindow. -SqlBaseListener.prototype.exitNamedWindow = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#windowRef. -SqlBaseListener.prototype.enterWindowRef = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#windowRef. -SqlBaseListener.prototype.exitWindowRef = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#windowDef. -SqlBaseListener.prototype.enterWindowDef = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#windowDef. -SqlBaseListener.prototype.exitWindowDef = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#windowFrame. -SqlBaseListener.prototype.enterWindowFrame = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#windowFrame. -SqlBaseListener.prototype.exitWindowFrame = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#frameBound. -SqlBaseListener.prototype.enterFrameBound = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#frameBound. -SqlBaseListener.prototype.exitFrameBound = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#qualifiedNameList. -SqlBaseListener.prototype.enterQualifiedNameList = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#qualifiedNameList. -SqlBaseListener.prototype.exitQualifiedNameList = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#functionName. -SqlBaseListener.prototype.enterFunctionName = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#functionName. -SqlBaseListener.prototype.exitFunctionName = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#qualifiedName. -SqlBaseListener.prototype.enterQualifiedName = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#qualifiedName. -SqlBaseListener.prototype.exitQualifiedName = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#errorCapturingIdentifier. -SqlBaseListener.prototype.enterErrorCapturingIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#errorCapturingIdentifier. -SqlBaseListener.prototype.exitErrorCapturingIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#errorIdent. -SqlBaseListener.prototype.enterErrorIdent = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#errorIdent. -SqlBaseListener.prototype.exitErrorIdent = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#realIdent. -SqlBaseListener.prototype.enterRealIdent = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#realIdent. -SqlBaseListener.prototype.exitRealIdent = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#identifier. -SqlBaseListener.prototype.enterIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#identifier. -SqlBaseListener.prototype.exitIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#unquotedIdentifier. -SqlBaseListener.prototype.enterUnquotedIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#unquotedIdentifier. -SqlBaseListener.prototype.exitUnquotedIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#quotedIdentifierAlternative. -SqlBaseListener.prototype.enterQuotedIdentifierAlternative = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#quotedIdentifierAlternative. -SqlBaseListener.prototype.exitQuotedIdentifierAlternative = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#quotedIdentifier. -SqlBaseListener.prototype.enterQuotedIdentifier = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#quotedIdentifier. -SqlBaseListener.prototype.exitQuotedIdentifier = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#exponentLiteral. -SqlBaseListener.prototype.enterExponentLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#exponentLiteral. -SqlBaseListener.prototype.exitExponentLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#decimalLiteral. -SqlBaseListener.prototype.enterDecimalLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#decimalLiteral. -SqlBaseListener.prototype.exitDecimalLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#legacyDecimalLiteral. -SqlBaseListener.prototype.enterLegacyDecimalLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#legacyDecimalLiteral. -SqlBaseListener.prototype.exitLegacyDecimalLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#integerLiteral. -SqlBaseListener.prototype.enterIntegerLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#integerLiteral. -SqlBaseListener.prototype.exitIntegerLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#bigIntLiteral. -SqlBaseListener.prototype.enterBigIntLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#bigIntLiteral. -SqlBaseListener.prototype.exitBigIntLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#smallIntLiteral. -SqlBaseListener.prototype.enterSmallIntLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#smallIntLiteral. -SqlBaseListener.prototype.exitSmallIntLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#tinyIntLiteral. -SqlBaseListener.prototype.enterTinyIntLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#tinyIntLiteral. -SqlBaseListener.prototype.exitTinyIntLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#doubleLiteral. -SqlBaseListener.prototype.enterDoubleLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#doubleLiteral. -SqlBaseListener.prototype.exitDoubleLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#floatLiteral. -SqlBaseListener.prototype.enterFloatLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#floatLiteral. -SqlBaseListener.prototype.exitFloatLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#bigDecimalLiteral. -SqlBaseListener.prototype.enterBigDecimalLiteral = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#bigDecimalLiteral. -SqlBaseListener.prototype.exitBigDecimalLiteral = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#alterColumnAction. -SqlBaseListener.prototype.enterAlterColumnAction = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#alterColumnAction. -SqlBaseListener.prototype.exitAlterColumnAction = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#ansiNonReserved. -SqlBaseListener.prototype.enterAnsiNonReserved = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#ansiNonReserved. -SqlBaseListener.prototype.exitAnsiNonReserved = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#strictNonReserved. -SqlBaseListener.prototype.enterStrictNonReserved = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#strictNonReserved. -SqlBaseListener.prototype.exitStrictNonReserved = function(ctx) { -}; - - -// Enter a parse tree produced by SqlBaseParser#nonReserved. -SqlBaseListener.prototype.enterNonReserved = function(ctx) { -}; - -// Exit a parse tree produced by SqlBaseParser#nonReserved. -SqlBaseListener.prototype.exitNonReserved = function(ctx) { -}; - - - -exports.SqlBaseListener = SqlBaseListener; \ No newline at end of file diff --git a/src/lib/spark/SqlBaseVisitor.js b/src/lib/spark/SqlBaseVisitor.js deleted file mode 100644 index dabbadd..0000000 --- a/src/lib/spark/SqlBaseVisitor.js +++ /dev/null @@ -1,1636 +0,0 @@ -// Generated from /Users/jinjiongxi/workspace/dt-sql-parser/src/grammar/spark/SqlBase.g4 by ANTLR 4.8 -// jshint ignore: start -var antlr4 = require('antlr4/index'); - -// This class defines a complete generic visitor for a parse tree produced by SqlBaseParser. - -function SqlBaseVisitor() { - antlr4.tree.ParseTreeVisitor.call(this); - return this; -} - -SqlBaseVisitor.prototype = Object.create(antlr4.tree.ParseTreeVisitor.prototype); -SqlBaseVisitor.prototype.constructor = SqlBaseVisitor; - -// Visit a parse tree produced by SqlBaseParser#program. -SqlBaseVisitor.prototype.visitProgram = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#singleStatement. -SqlBaseVisitor.prototype.visitSingleStatement = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#singleExpression. -SqlBaseVisitor.prototype.visitSingleExpression = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#singleTableIdentifier. -SqlBaseVisitor.prototype.visitSingleTableIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#singleMultipartIdentifier. -SqlBaseVisitor.prototype.visitSingleMultipartIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#singleDataType. -SqlBaseVisitor.prototype.visitSingleDataType = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#singleTableSchema. -SqlBaseVisitor.prototype.visitSingleTableSchema = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#statementDefault. -SqlBaseVisitor.prototype.visitStatementDefault = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dmlStatement. -SqlBaseVisitor.prototype.visitDmlStatement = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#use. -SqlBaseVisitor.prototype.visitUse = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createNamespace. -SqlBaseVisitor.prototype.visitCreateNamespace = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setNamespaceProperties. -SqlBaseVisitor.prototype.visitSetNamespaceProperties = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setNamespaceLocation. -SqlBaseVisitor.prototype.visitSetNamespaceLocation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dropNamespace. -SqlBaseVisitor.prototype.visitDropNamespace = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showNamespaces. -SqlBaseVisitor.prototype.visitShowNamespaces = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createTable. -SqlBaseVisitor.prototype.visitCreateTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createHiveTable. -SqlBaseVisitor.prototype.visitCreateHiveTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createTableLike. -SqlBaseVisitor.prototype.visitCreateTableLike = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#replaceTable. -SqlBaseVisitor.prototype.visitReplaceTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#analyze. -SqlBaseVisitor.prototype.visitAnalyze = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#addTableColumns. -SqlBaseVisitor.prototype.visitAddTableColumns = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#renameTableColumn. -SqlBaseVisitor.prototype.visitRenameTableColumn = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dropTableColumns. -SqlBaseVisitor.prototype.visitDropTableColumns = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#renameTable. -SqlBaseVisitor.prototype.visitRenameTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setTableProperties. -SqlBaseVisitor.prototype.visitSetTableProperties = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#unsetTableProperties. -SqlBaseVisitor.prototype.visitUnsetTableProperties = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#alterTableAlterColumn. -SqlBaseVisitor.prototype.visitAlterTableAlterColumn = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#hiveChangeColumn. -SqlBaseVisitor.prototype.visitHiveChangeColumn = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#hiveReplaceColumns. -SqlBaseVisitor.prototype.visitHiveReplaceColumns = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setTableSerDe. -SqlBaseVisitor.prototype.visitSetTableSerDe = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#addTablePartition. -SqlBaseVisitor.prototype.visitAddTablePartition = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#renameTablePartition. -SqlBaseVisitor.prototype.visitRenameTablePartition = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dropTablePartitions. -SqlBaseVisitor.prototype.visitDropTablePartitions = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setTableLocation. -SqlBaseVisitor.prototype.visitSetTableLocation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#recoverPartitions. -SqlBaseVisitor.prototype.visitRecoverPartitions = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dropTable. -SqlBaseVisitor.prototype.visitDropTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dropView. -SqlBaseVisitor.prototype.visitDropView = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createView. -SqlBaseVisitor.prototype.visitCreateView = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createTempViewUsing. -SqlBaseVisitor.prototype.visitCreateTempViewUsing = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#alterViewQuery. -SqlBaseVisitor.prototype.visitAlterViewQuery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createFunction. -SqlBaseVisitor.prototype.visitCreateFunction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dropFunction. -SqlBaseVisitor.prototype.visitDropFunction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#explain. -SqlBaseVisitor.prototype.visitExplain = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showTables. -SqlBaseVisitor.prototype.visitShowTables = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showTable. -SqlBaseVisitor.prototype.visitShowTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showTblProperties. -SqlBaseVisitor.prototype.visitShowTblProperties = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showColumns. -SqlBaseVisitor.prototype.visitShowColumns = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showViews. -SqlBaseVisitor.prototype.visitShowViews = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showPartitions. -SqlBaseVisitor.prototype.visitShowPartitions = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showFunctions. -SqlBaseVisitor.prototype.visitShowFunctions = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showCreateTable. -SqlBaseVisitor.prototype.visitShowCreateTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#showCurrentNamespace. -SqlBaseVisitor.prototype.visitShowCurrentNamespace = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#describeFunction. -SqlBaseVisitor.prototype.visitDescribeFunction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#describeNamespace. -SqlBaseVisitor.prototype.visitDescribeNamespace = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#describeRelation. -SqlBaseVisitor.prototype.visitDescribeRelation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#describeQuery. -SqlBaseVisitor.prototype.visitDescribeQuery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#commentNamespace. -SqlBaseVisitor.prototype.visitCommentNamespace = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#commentTable. -SqlBaseVisitor.prototype.visitCommentTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#refreshTable. -SqlBaseVisitor.prototype.visitRefreshTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#refreshFunction. -SqlBaseVisitor.prototype.visitRefreshFunction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#refreshResource. -SqlBaseVisitor.prototype.visitRefreshResource = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#cacheTable. -SqlBaseVisitor.prototype.visitCacheTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#uncacheTable. -SqlBaseVisitor.prototype.visitUncacheTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#clearCache. -SqlBaseVisitor.prototype.visitClearCache = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#loadData. -SqlBaseVisitor.prototype.visitLoadData = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#truncateTable. -SqlBaseVisitor.prototype.visitTruncateTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#repairTable. -SqlBaseVisitor.prototype.visitRepairTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#manageResource. -SqlBaseVisitor.prototype.visitManageResource = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#failNativeCommand. -SqlBaseVisitor.prototype.visitFailNativeCommand = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setTimeZone. -SqlBaseVisitor.prototype.visitSetTimeZone = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setQuotedConfiguration. -SqlBaseVisitor.prototype.visitSetQuotedConfiguration = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setConfiguration. -SqlBaseVisitor.prototype.visitSetConfiguration = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#resetQuotedConfiguration. -SqlBaseVisitor.prototype.visitResetQuotedConfiguration = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#resetConfiguration. -SqlBaseVisitor.prototype.visitResetConfiguration = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#configKey. -SqlBaseVisitor.prototype.visitConfigKey = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#unsupportedHiveNativeCommands. -SqlBaseVisitor.prototype.visitUnsupportedHiveNativeCommands = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createTableHeader. -SqlBaseVisitor.prototype.visitCreateTableHeader = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#replaceTableHeader. -SqlBaseVisitor.prototype.visitReplaceTableHeader = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#bucketSpec. -SqlBaseVisitor.prototype.visitBucketSpec = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#skewSpec. -SqlBaseVisitor.prototype.visitSkewSpec = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#locationSpec. -SqlBaseVisitor.prototype.visitLocationSpec = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#commentSpec. -SqlBaseVisitor.prototype.visitCommentSpec = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#query. -SqlBaseVisitor.prototype.visitQuery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#insertOverwriteTable. -SqlBaseVisitor.prototype.visitInsertOverwriteTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#insertIntoTable. -SqlBaseVisitor.prototype.visitInsertIntoTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#insertOverwriteHiveDir. -SqlBaseVisitor.prototype.visitInsertOverwriteHiveDir = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#insertOverwriteDir. -SqlBaseVisitor.prototype.visitInsertOverwriteDir = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#partitionSpecLocation. -SqlBaseVisitor.prototype.visitPartitionSpecLocation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#partitionSpec. -SqlBaseVisitor.prototype.visitPartitionSpec = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#partitionVal. -SqlBaseVisitor.prototype.visitPartitionVal = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#namespace. -SqlBaseVisitor.prototype.visitNamespace = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#describeFuncName. -SqlBaseVisitor.prototype.visitDescribeFuncName = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#describeColName. -SqlBaseVisitor.prototype.visitDescribeColName = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#ctes. -SqlBaseVisitor.prototype.visitCtes = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#namedQuery. -SqlBaseVisitor.prototype.visitNamedQuery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tableProvider. -SqlBaseVisitor.prototype.visitTableProvider = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createTableClauses. -SqlBaseVisitor.prototype.visitCreateTableClauses = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tablePropertyList. -SqlBaseVisitor.prototype.visitTablePropertyList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tableProperty. -SqlBaseVisitor.prototype.visitTableProperty = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tablePropertyKey. -SqlBaseVisitor.prototype.visitTablePropertyKey = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tablePropertyValue. -SqlBaseVisitor.prototype.visitTablePropertyValue = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#constantList. -SqlBaseVisitor.prototype.visitConstantList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#nestedConstantList. -SqlBaseVisitor.prototype.visitNestedConstantList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#createFileFormat. -SqlBaseVisitor.prototype.visitCreateFileFormat = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tableFileFormat. -SqlBaseVisitor.prototype.visitTableFileFormat = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#genericFileFormat. -SqlBaseVisitor.prototype.visitGenericFileFormat = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#storageHandler. -SqlBaseVisitor.prototype.visitStorageHandler = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#resource. -SqlBaseVisitor.prototype.visitResource = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#singleInsertQuery. -SqlBaseVisitor.prototype.visitSingleInsertQuery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#multiInsertQuery. -SqlBaseVisitor.prototype.visitMultiInsertQuery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#deleteFromTable. -SqlBaseVisitor.prototype.visitDeleteFromTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#updateTable. -SqlBaseVisitor.prototype.visitUpdateTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#mergeIntoTable. -SqlBaseVisitor.prototype.visitMergeIntoTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#queryOrganization. -SqlBaseVisitor.prototype.visitQueryOrganization = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#multiInsertQueryBody. -SqlBaseVisitor.prototype.visitMultiInsertQueryBody = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#queryTermDefault. -SqlBaseVisitor.prototype.visitQueryTermDefault = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setOperation. -SqlBaseVisitor.prototype.visitSetOperation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#queryPrimaryDefault. -SqlBaseVisitor.prototype.visitQueryPrimaryDefault = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#fromStmt. -SqlBaseVisitor.prototype.visitFromStmt = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#table. -SqlBaseVisitor.prototype.visitTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#inlineTableDefault1. -SqlBaseVisitor.prototype.visitInlineTableDefault1 = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#subquery. -SqlBaseVisitor.prototype.visitSubquery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#sortItem. -SqlBaseVisitor.prototype.visitSortItem = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#fromStatement. -SqlBaseVisitor.prototype.visitFromStatement = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#fromStatementBody. -SqlBaseVisitor.prototype.visitFromStatementBody = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#transformQuerySpecification. -SqlBaseVisitor.prototype.visitTransformQuerySpecification = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#regularQuerySpecification. -SqlBaseVisitor.prototype.visitRegularQuerySpecification = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#transformClause. -SqlBaseVisitor.prototype.visitTransformClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#selectClause. -SqlBaseVisitor.prototype.visitSelectClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setClause. -SqlBaseVisitor.prototype.visitSetClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#matchedClause. -SqlBaseVisitor.prototype.visitMatchedClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#notMatchedClause. -SqlBaseVisitor.prototype.visitNotMatchedClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#matchedAction. -SqlBaseVisitor.prototype.visitMatchedAction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#notMatchedAction. -SqlBaseVisitor.prototype.visitNotMatchedAction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#assignmentList. -SqlBaseVisitor.prototype.visitAssignmentList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#assignment. -SqlBaseVisitor.prototype.visitAssignment = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#whereClause. -SqlBaseVisitor.prototype.visitWhereClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#havingClause. -SqlBaseVisitor.prototype.visitHavingClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#hint. -SqlBaseVisitor.prototype.visitHint = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#hintStatement. -SqlBaseVisitor.prototype.visitHintStatement = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#fromClause. -SqlBaseVisitor.prototype.visitFromClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#aggregationClause. -SqlBaseVisitor.prototype.visitAggregationClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#groupingSet. -SqlBaseVisitor.prototype.visitGroupingSet = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#pivotClause. -SqlBaseVisitor.prototype.visitPivotClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#pivotColumn. -SqlBaseVisitor.prototype.visitPivotColumn = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#pivotValue. -SqlBaseVisitor.prototype.visitPivotValue = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#lateralView. -SqlBaseVisitor.prototype.visitLateralView = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#setQuantifier. -SqlBaseVisitor.prototype.visitSetQuantifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#relation. -SqlBaseVisitor.prototype.visitRelation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#joinRelation. -SqlBaseVisitor.prototype.visitJoinRelation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#joinType. -SqlBaseVisitor.prototype.visitJoinType = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#joinCriteria. -SqlBaseVisitor.prototype.visitJoinCriteria = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#sample. -SqlBaseVisitor.prototype.visitSample = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#sampleByPercentile. -SqlBaseVisitor.prototype.visitSampleByPercentile = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#sampleByRows. -SqlBaseVisitor.prototype.visitSampleByRows = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#sampleByBucket. -SqlBaseVisitor.prototype.visitSampleByBucket = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#sampleByBytes. -SqlBaseVisitor.prototype.visitSampleByBytes = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#identifierList. -SqlBaseVisitor.prototype.visitIdentifierList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#identifierSeq. -SqlBaseVisitor.prototype.visitIdentifierSeq = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#orderedIdentifierList. -SqlBaseVisitor.prototype.visitOrderedIdentifierList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#orderedIdentifier. -SqlBaseVisitor.prototype.visitOrderedIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#identifierCommentList. -SqlBaseVisitor.prototype.visitIdentifierCommentList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#identifierComment. -SqlBaseVisitor.prototype.visitIdentifierComment = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tableName. -SqlBaseVisitor.prototype.visitTableName = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#aliasedQuery. -SqlBaseVisitor.prototype.visitAliasedQuery = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#aliasedRelation. -SqlBaseVisitor.prototype.visitAliasedRelation = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#inlineTableDefault2. -SqlBaseVisitor.prototype.visitInlineTableDefault2 = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tableValuedFunction. -SqlBaseVisitor.prototype.visitTableValuedFunction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#inlineTable. -SqlBaseVisitor.prototype.visitInlineTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#functionTable. -SqlBaseVisitor.prototype.visitFunctionTable = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tableAlias. -SqlBaseVisitor.prototype.visitTableAlias = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#rowFormatSerde. -SqlBaseVisitor.prototype.visitRowFormatSerde = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#rowFormatDelimited. -SqlBaseVisitor.prototype.visitRowFormatDelimited = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#multipartIdentifierList. -SqlBaseVisitor.prototype.visitMultipartIdentifierList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#multipartIdentifier. -SqlBaseVisitor.prototype.visitMultipartIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tableIdentifier. -SqlBaseVisitor.prototype.visitTableIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#namedExpression. -SqlBaseVisitor.prototype.visitNamedExpression = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#namedExpressionSeq. -SqlBaseVisitor.prototype.visitNamedExpressionSeq = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#transformList. -SqlBaseVisitor.prototype.visitTransformList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#identityTransform. -SqlBaseVisitor.prototype.visitIdentityTransform = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#applyTransform. -SqlBaseVisitor.prototype.visitApplyTransform = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#transformArgument. -SqlBaseVisitor.prototype.visitTransformArgument = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#expression. -SqlBaseVisitor.prototype.visitExpression = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#logicalNot. -SqlBaseVisitor.prototype.visitLogicalNot = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#predicated. -SqlBaseVisitor.prototype.visitPredicated = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#exists. -SqlBaseVisitor.prototype.visitExists = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#logicalBinary. -SqlBaseVisitor.prototype.visitLogicalBinary = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#predicate. -SqlBaseVisitor.prototype.visitPredicate = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#valueExpressionDefault. -SqlBaseVisitor.prototype.visitValueExpressionDefault = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#comparison. -SqlBaseVisitor.prototype.visitComparison = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#arithmeticBinary. -SqlBaseVisitor.prototype.visitArithmeticBinary = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#arithmeticUnary. -SqlBaseVisitor.prototype.visitArithmeticUnary = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#struct. -SqlBaseVisitor.prototype.visitStruct = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#dereference. -SqlBaseVisitor.prototype.visitDereference = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#simpleCase. -SqlBaseVisitor.prototype.visitSimpleCase = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#columnReference. -SqlBaseVisitor.prototype.visitColumnReference = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#rowConstructor. -SqlBaseVisitor.prototype.visitRowConstructor = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#last. -SqlBaseVisitor.prototype.visitLast = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#star. -SqlBaseVisitor.prototype.visitStar = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#overlay. -SqlBaseVisitor.prototype.visitOverlay = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#subscript. -SqlBaseVisitor.prototype.visitSubscript = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#subqueryExpression. -SqlBaseVisitor.prototype.visitSubqueryExpression = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#substring. -SqlBaseVisitor.prototype.visitSubstring = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#currentDatetime. -SqlBaseVisitor.prototype.visitCurrentDatetime = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#cast. -SqlBaseVisitor.prototype.visitCast = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#constantDefault. -SqlBaseVisitor.prototype.visitConstantDefault = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#lambda. -SqlBaseVisitor.prototype.visitLambda = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#parenthesizedExpression. -SqlBaseVisitor.prototype.visitParenthesizedExpression = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#extract. -SqlBaseVisitor.prototype.visitExtract = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#trim. -SqlBaseVisitor.prototype.visitTrim = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#functionCall. -SqlBaseVisitor.prototype.visitFunctionCall = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#searchedCase. -SqlBaseVisitor.prototype.visitSearchedCase = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#position. -SqlBaseVisitor.prototype.visitPosition = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#first. -SqlBaseVisitor.prototype.visitFirst = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#nullLiteral. -SqlBaseVisitor.prototype.visitNullLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#intervalLiteral. -SqlBaseVisitor.prototype.visitIntervalLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#typeConstructor. -SqlBaseVisitor.prototype.visitTypeConstructor = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#numericLiteral. -SqlBaseVisitor.prototype.visitNumericLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#booleanLiteral. -SqlBaseVisitor.prototype.visitBooleanLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#stringLiteral. -SqlBaseVisitor.prototype.visitStringLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#comparisonOperator. -SqlBaseVisitor.prototype.visitComparisonOperator = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#arithmeticOperator. -SqlBaseVisitor.prototype.visitArithmeticOperator = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#predicateOperator. -SqlBaseVisitor.prototype.visitPredicateOperator = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#booleanValue. -SqlBaseVisitor.prototype.visitBooleanValue = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#interval. -SqlBaseVisitor.prototype.visitInterval = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#errorCapturingMultiUnitsInterval. -SqlBaseVisitor.prototype.visitErrorCapturingMultiUnitsInterval = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#multiUnitsInterval. -SqlBaseVisitor.prototype.visitMultiUnitsInterval = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#errorCapturingUnitToUnitInterval. -SqlBaseVisitor.prototype.visitErrorCapturingUnitToUnitInterval = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#unitToUnitInterval. -SqlBaseVisitor.prototype.visitUnitToUnitInterval = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#intervalValue. -SqlBaseVisitor.prototype.visitIntervalValue = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#colPosition. -SqlBaseVisitor.prototype.visitColPosition = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#complexDataType. -SqlBaseVisitor.prototype.visitComplexDataType = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#primitiveDataType. -SqlBaseVisitor.prototype.visitPrimitiveDataType = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#qualifiedColTypeWithPositionList. -SqlBaseVisitor.prototype.visitQualifiedColTypeWithPositionList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#qualifiedColTypeWithPosition. -SqlBaseVisitor.prototype.visitQualifiedColTypeWithPosition = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#colTypeList. -SqlBaseVisitor.prototype.visitColTypeList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#colType. -SqlBaseVisitor.prototype.visitColType = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#complexColTypeList. -SqlBaseVisitor.prototype.visitComplexColTypeList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#complexColType. -SqlBaseVisitor.prototype.visitComplexColType = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#whenClause. -SqlBaseVisitor.prototype.visitWhenClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#windowClause. -SqlBaseVisitor.prototype.visitWindowClause = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#namedWindow. -SqlBaseVisitor.prototype.visitNamedWindow = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#windowRef. -SqlBaseVisitor.prototype.visitWindowRef = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#windowDef. -SqlBaseVisitor.prototype.visitWindowDef = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#windowFrame. -SqlBaseVisitor.prototype.visitWindowFrame = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#frameBound. -SqlBaseVisitor.prototype.visitFrameBound = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#qualifiedNameList. -SqlBaseVisitor.prototype.visitQualifiedNameList = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#functionName. -SqlBaseVisitor.prototype.visitFunctionName = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#qualifiedName. -SqlBaseVisitor.prototype.visitQualifiedName = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#errorCapturingIdentifier. -SqlBaseVisitor.prototype.visitErrorCapturingIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#errorIdent. -SqlBaseVisitor.prototype.visitErrorIdent = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#realIdent. -SqlBaseVisitor.prototype.visitRealIdent = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#identifier. -SqlBaseVisitor.prototype.visitIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#unquotedIdentifier. -SqlBaseVisitor.prototype.visitUnquotedIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#quotedIdentifierAlternative. -SqlBaseVisitor.prototype.visitQuotedIdentifierAlternative = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#quotedIdentifier. -SqlBaseVisitor.prototype.visitQuotedIdentifier = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#exponentLiteral. -SqlBaseVisitor.prototype.visitExponentLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#decimalLiteral. -SqlBaseVisitor.prototype.visitDecimalLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#legacyDecimalLiteral. -SqlBaseVisitor.prototype.visitLegacyDecimalLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#integerLiteral. -SqlBaseVisitor.prototype.visitIntegerLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#bigIntLiteral. -SqlBaseVisitor.prototype.visitBigIntLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#smallIntLiteral. -SqlBaseVisitor.prototype.visitSmallIntLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#tinyIntLiteral. -SqlBaseVisitor.prototype.visitTinyIntLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#doubleLiteral. -SqlBaseVisitor.prototype.visitDoubleLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#floatLiteral. -SqlBaseVisitor.prototype.visitFloatLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#bigDecimalLiteral. -SqlBaseVisitor.prototype.visitBigDecimalLiteral = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#alterColumnAction. -SqlBaseVisitor.prototype.visitAlterColumnAction = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#ansiNonReserved. -SqlBaseVisitor.prototype.visitAnsiNonReserved = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#strictNonReserved. -SqlBaseVisitor.prototype.visitStrictNonReserved = function(ctx) { - return this.visitChildren(ctx); -}; - - -// Visit a parse tree produced by SqlBaseParser#nonReserved. -SqlBaseVisitor.prototype.visitNonReserved = function(ctx) { - return this.visitChildren(ctx); -}; - - - -exports.SqlBaseVisitor = SqlBaseVisitor; \ No newline at end of file diff --git a/src/parser/spark.ts b/src/parser/spark.ts index 48a6e34..a4076db 100644 --- a/src/parser/spark.ts +++ b/src/parser/spark.ts @@ -1,19 +1,19 @@ import { InputStream, CommonTokenStream, Lexer } from 'antlr4'; -import { SqlBaseLexer } from '../lib/spark/SqlBaseLexer'; -import { SqlBaseParser } from '../lib/spark/SqlBaseParser'; -export * from '../lib/spark/SqlBaseVisitor'; -export * from '../lib/spark/SqlBaseListener'; +import { SparkSqlLexer } from '../lib/spark/SparkSqlLexer'; +import { SparkSqlParser } from '../lib/spark/SparkSqlParser'; +export * from '../lib/spark/SparkSqlVisitor'; +export * from '../lib/spark/SparkSqlListener'; import BasicParser from './common/BasicParser'; export default class SparkSQL extends BasicParser { public createLexer(input: string): Lexer { const chars = new InputStream(input.toUpperCase()); // Some Lexer only support uppercase token, So you need transform - const lexer = new SqlBaseLexer(chars) as Lexer; + const lexer = new SparkSqlLexer(chars) as Lexer; return lexer; } public createParserFromLexer(lexer: Lexer) { const tokenStream = new CommonTokenStream(lexer); - return new SqlBaseParser(tokenStream); + return new SparkSqlParser(tokenStream); } } diff --git a/test/parser/spark/listener.test.ts b/test/parser/spark/listener.test.ts index 6c82f6a..8b9a1cf 100644 --- a/test/parser/spark/listener.test.ts +++ b/test/parser/spark/listener.test.ts @@ -1,4 +1,4 @@ -import SQLParser, { SqlBaseListener } from '../../../src/parser/spark'; +import SQLParser, { SparkSqlListener } from '../../../src/parser/spark'; describe('Spark SQL Listener Tests', () => { const expectTableName = 'user1'; @@ -9,7 +9,7 @@ describe('Spark SQL Listener Tests', () => { test('Listener enterTableName', () => { let result = ''; - class MyListener extends SqlBaseListener { + class MyListener extends SparkSqlListener { enterTableName(ctx): void { result = ctx.getText().toLowerCase(); } diff --git a/test/parser/spark/syntax.test.ts b/test/parser/spark/syntax.test.ts index 3d0b21f..1541b59 100644 --- a/test/parser/spark/syntax.test.ts +++ b/test/parser/spark/syntax.test.ts @@ -1,7 +1,6 @@ /* eslint-disable max-len */ import SQLParser from '../../../src/parser/spark'; -// const log = console.log.bind(console); const error = console.log.bind(console, '***** error\n'); const validateTest = (sqls) => { diff --git a/test/parser/spark/visitor.test.ts b/test/parser/spark/visitor.test.ts index 6cf20a4..4c625b9 100644 --- a/test/parser/spark/visitor.test.ts +++ b/test/parser/spark/visitor.test.ts @@ -1,4 +1,4 @@ -import SQLParser, { SqlBaseVisitor } from '../../../src/parser/spark'; +import SQLParser, { SparkSqlVisitor } from '../../../src/parser/spark'; describe('Spark SQL Visitor Tests', () => { const expectTableName = 'user1'; @@ -13,7 +13,7 @@ describe('Spark SQL Visitor Tests', () => { test('Visitor visitTableName', () => { let result = ''; - class MyVisitor extends SqlBaseVisitor { + class MyVisitor extends SparkSqlVisitor { visitTableName(ctx): void { result = ctx.getText().toLowerCase(); super.visitTableName(ctx);