0d9d3d65f3
* test: accurate description * refactor: optimize the use of tableName and viewName for --------- Co-authored-by: liuyi <liuyi@dtstack.com>
29258 lines
1023 KiB
TypeScript
29258 lines
1023 KiB
TypeScript
// Generated from /Users/liuyi/Desktop/Projects/dtstack/dt-sql-parser/src/grammar/spark/SparkSqlParser.g4 by ANTLR 4.9.0-SNAPSHOT
|
|
|
|
|
|
import { ATN } from "antlr4ts/atn/ATN";
|
|
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
|
|
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
|
|
import { NotNull } from "antlr4ts/Decorators";
|
|
import { NoViableAltException } from "antlr4ts/NoViableAltException";
|
|
import { Override } from "antlr4ts/Decorators";
|
|
import { Parser } from "antlr4ts/Parser";
|
|
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
|
|
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
|
|
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
|
|
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
|
|
import { RecognitionException } from "antlr4ts/RecognitionException";
|
|
import { RuleContext } from "antlr4ts/RuleContext";
|
|
//import { RuleVersion } from "antlr4ts/RuleVersion";
|
|
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
|
|
import { Token } from "antlr4ts/Token";
|
|
import { TokenStream } from "antlr4ts/TokenStream";
|
|
import { Vocabulary } from "antlr4ts/Vocabulary";
|
|
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";
|
|
|
|
import * as Utils from "antlr4ts/misc/Utils";
|
|
|
|
import { SparkSqlParserListener } from "./SparkSqlParserListener";
|
|
import { SparkSqlParserVisitor } from "./SparkSqlParserVisitor";
|
|
|
|
|
|
export class SparkSqlParser extends Parser {
|
|
public static readonly SEMICOLON = 1;
|
|
public static readonly LEFT_PAREN = 2;
|
|
public static readonly RIGHT_PAREN = 3;
|
|
public static readonly COMMA = 4;
|
|
public static readonly DOT = 5;
|
|
public static readonly LEFT_BRACKET = 6;
|
|
public static readonly RIGHT_BRACKET = 7;
|
|
public static readonly KW_ADD = 8;
|
|
public static readonly KW_AFTER = 9;
|
|
public static readonly KW_ALL = 10;
|
|
public static readonly KW_ALTER = 11;
|
|
public static readonly KW_ALWAYS = 12;
|
|
public static readonly KW_ANALYZE = 13;
|
|
public static readonly KW_AND = 14;
|
|
public static readonly KW_ANTI = 15;
|
|
public static readonly KW_ANY = 16;
|
|
public static readonly KW_ANY_VALUE = 17;
|
|
public static readonly KW_ARCHIVE = 18;
|
|
public static readonly KW_ARRAY = 19;
|
|
public static readonly KW_AS = 20;
|
|
public static readonly KW_ASC = 21;
|
|
public static readonly KW_AT = 22;
|
|
public static readonly KW_AUTHORIZATION = 23;
|
|
public static readonly KW_BETWEEN = 24;
|
|
public static readonly KW_BIGINT = 25;
|
|
public static readonly KW_BINARY = 26;
|
|
public static readonly KW_BOOLEAN = 27;
|
|
public static readonly KW_BOTH = 28;
|
|
public static readonly KW_BUCKET = 29;
|
|
public static readonly KW_BUCKETS = 30;
|
|
public static readonly KW_BY = 31;
|
|
public static readonly KW_BYTE = 32;
|
|
public static readonly KW_CACHE = 33;
|
|
public static readonly KW_CASCADE = 34;
|
|
public static readonly KW_CASE = 35;
|
|
public static readonly KW_CAST = 36;
|
|
public static readonly KW_CATALOG = 37;
|
|
public static readonly KW_CATALOGS = 38;
|
|
public static readonly KW_CHANGE = 39;
|
|
public static readonly KW_CHAR = 40;
|
|
public static readonly KW_CHARACTER = 41;
|
|
public static readonly KW_CHECK = 42;
|
|
public static readonly KW_CLEAR = 43;
|
|
public static readonly KW_CLUSTER = 44;
|
|
public static readonly KW_CLUSTERED = 45;
|
|
public static readonly KW_CODEGEN = 46;
|
|
public static readonly KW_COLLATE = 47;
|
|
public static readonly KW_COLLECTION = 48;
|
|
public static readonly KW_COLUMN = 49;
|
|
public static readonly KW_COLUMNS = 50;
|
|
public static readonly KW_COMMENT = 51;
|
|
public static readonly KW_COMMIT = 52;
|
|
public static readonly KW_COMPACT = 53;
|
|
public static readonly KW_COMPACTIONS = 54;
|
|
public static readonly KW_COMPUTE = 55;
|
|
public static readonly KW_CONCATENATE = 56;
|
|
public static readonly KW_CONSTRAINT = 57;
|
|
public static readonly KW_COST = 58;
|
|
public static readonly KW_CREATE = 59;
|
|
public static readonly KW_CROSS = 60;
|
|
public static readonly KW_CUBE = 61;
|
|
public static readonly KW_CURRENT = 62;
|
|
public static readonly KW_CURRENT_DATE = 63;
|
|
public static readonly KW_CURRENT_TIME = 64;
|
|
public static readonly KW_CURRENT_TIMESTAMP = 65;
|
|
public static readonly KW_CURRENT_USER = 66;
|
|
public static readonly KW_DAY = 67;
|
|
public static readonly KW_DAYS = 68;
|
|
public static readonly KW_DAYOFYEAR = 69;
|
|
public static readonly KW_DATA = 70;
|
|
public static readonly KW_DATE = 71;
|
|
public static readonly KW_DATABASE = 72;
|
|
public static readonly KW_DATABASES = 73;
|
|
public static readonly KW_DATEADD = 74;
|
|
public static readonly KW_DATE_ADD = 75;
|
|
public static readonly KW_DATEDIFF = 76;
|
|
public static readonly KW_DATE_DIFF = 77;
|
|
public static readonly KW_DBPROPERTIES = 78;
|
|
public static readonly KW_DEC = 79;
|
|
public static readonly KW_DECIMAL = 80;
|
|
public static readonly KW_DECLARE = 81;
|
|
public static readonly KW_DEFAULT = 82;
|
|
public static readonly KW_DEFINED = 83;
|
|
public static readonly KW_DELETE = 84;
|
|
public static readonly KW_DELIMITED = 85;
|
|
public static readonly KW_DESC = 86;
|
|
public static readonly KW_DESCRIBE = 87;
|
|
public static readonly KW_DFS = 88;
|
|
public static readonly KW_DIRECTORIES = 89;
|
|
public static readonly KW_DIRECTORY = 90;
|
|
public static readonly KW_DISTINCT = 91;
|
|
public static readonly KW_DISTRIBUTE = 92;
|
|
public static readonly KW_DIV = 93;
|
|
public static readonly KW_DOUBLE = 94;
|
|
public static readonly KW_DROP = 95;
|
|
public static readonly KW_ELSE = 96;
|
|
public static readonly KW_END = 97;
|
|
public static readonly KW_ESCAPE = 98;
|
|
public static readonly KW_ESCAPED = 99;
|
|
public static readonly KW_EXCEPT = 100;
|
|
public static readonly KW_EXCHANGE = 101;
|
|
public static readonly KW_EXCLUDE = 102;
|
|
public static readonly KW_EXISTS = 103;
|
|
public static readonly KW_EXPLAIN = 104;
|
|
public static readonly KW_EXPORT = 105;
|
|
public static readonly KW_EXTENDED = 106;
|
|
public static readonly KW_EXTERNAL = 107;
|
|
public static readonly KW_EXTRACT = 108;
|
|
public static readonly KW_FALSE = 109;
|
|
public static readonly KW_FETCH = 110;
|
|
public static readonly KW_FIELDS = 111;
|
|
public static readonly KW_FILTER = 112;
|
|
public static readonly KW_FILEFORMAT = 113;
|
|
public static readonly KW_FIRST = 114;
|
|
public static readonly KW_FLOAT = 115;
|
|
public static readonly KW_FOLLOWING = 116;
|
|
public static readonly KW_FOR = 117;
|
|
public static readonly KW_FOREIGN = 118;
|
|
public static readonly KW_FORMAT = 119;
|
|
public static readonly KW_FORMATTED = 120;
|
|
public static readonly KW_FROM = 121;
|
|
public static readonly KW_FULL = 122;
|
|
public static readonly KW_FUNCTION = 123;
|
|
public static readonly KW_FUNCTIONS = 124;
|
|
public static readonly KW_GENERATED = 125;
|
|
public static readonly KW_GLOBAL = 126;
|
|
public static readonly KW_GRANT = 127;
|
|
public static readonly KW_GROUP = 128;
|
|
public static readonly KW_GROUPING = 129;
|
|
public static readonly KW_HAVING = 130;
|
|
public static readonly KW_BINARY_HEX = 131;
|
|
public static readonly KW_HOUR = 132;
|
|
public static readonly KW_HOURS = 133;
|
|
public static readonly KW_IDENTIFIER_KW = 134;
|
|
public static readonly KW_IF = 135;
|
|
public static readonly KW_IGNORE = 136;
|
|
public static readonly KW_IMPORT = 137;
|
|
public static readonly KW_IN = 138;
|
|
public static readonly KW_INCLUDE = 139;
|
|
public static readonly KW_INDEX = 140;
|
|
public static readonly KW_INDEXES = 141;
|
|
public static readonly KW_INNER = 142;
|
|
public static readonly KW_INPATH = 143;
|
|
public static readonly KW_INPUTFORMAT = 144;
|
|
public static readonly KW_INSERT = 145;
|
|
public static readonly KW_INTERSECT = 146;
|
|
public static readonly KW_INTERVAL = 147;
|
|
public static readonly KW_INT = 148;
|
|
public static readonly KW_INTEGER = 149;
|
|
public static readonly KW_INTO = 150;
|
|
public static readonly KW_IS = 151;
|
|
public static readonly KW_ITEMS = 152;
|
|
public static readonly KW_JOIN = 153;
|
|
public static readonly KW_KEYS = 154;
|
|
public static readonly KW_LAST = 155;
|
|
public static readonly KW_LATERAL = 156;
|
|
public static readonly KW_LAZY = 157;
|
|
public static readonly KW_LEADING = 158;
|
|
public static readonly KW_LEFT = 159;
|
|
public static readonly KW_LIKE = 160;
|
|
public static readonly KW_ILIKE = 161;
|
|
public static readonly KW_LIMIT = 162;
|
|
public static readonly KW_LINES = 163;
|
|
public static readonly KW_LIST = 164;
|
|
public static readonly KW_LOAD = 165;
|
|
public static readonly KW_LOCAL = 166;
|
|
public static readonly KW_LOCATION = 167;
|
|
public static readonly KW_LOCK = 168;
|
|
public static readonly KW_LOCKS = 169;
|
|
public static readonly KW_LOGICAL = 170;
|
|
public static readonly KW_LONG = 171;
|
|
public static readonly KW_MACRO = 172;
|
|
public static readonly KW_MAP = 173;
|
|
public static readonly KW_MATCHED = 174;
|
|
public static readonly KW_MERGE = 175;
|
|
public static readonly KW_MICROSECOND = 176;
|
|
public static readonly KW_MICROSECONDS = 177;
|
|
public static readonly KW_MILLISECOND = 178;
|
|
public static readonly KW_MILLISECONDS = 179;
|
|
public static readonly KW_MINUTE = 180;
|
|
public static readonly KW_MINUTES = 181;
|
|
public static readonly KW_MONTH = 182;
|
|
public static readonly KW_MONTHS = 183;
|
|
public static readonly KW_MSCK = 184;
|
|
public static readonly KW_NAME = 185;
|
|
public static readonly KW_NAMESPACE = 186;
|
|
public static readonly KW_NAMESPACES = 187;
|
|
public static readonly KW_NANOSECOND = 188;
|
|
public static readonly KW_NANOSECONDS = 189;
|
|
public static readonly KW_NATURAL = 190;
|
|
public static readonly KW_NO = 191;
|
|
public static readonly KW_NOT = 192;
|
|
public static readonly KW_NULL = 193;
|
|
public static readonly KW_NULLS = 194;
|
|
public static readonly KW_NUMERIC = 195;
|
|
public static readonly KW_OF = 196;
|
|
public static readonly KW_OFFSET = 197;
|
|
public static readonly KW_ON = 198;
|
|
public static readonly KW_ONLY = 199;
|
|
public static readonly KW_OPTION = 200;
|
|
public static readonly KW_OPTIONS = 201;
|
|
public static readonly KW_OR = 202;
|
|
public static readonly KW_ORDER = 203;
|
|
public static readonly KW_OUT = 204;
|
|
public static readonly KW_OUTER = 205;
|
|
public static readonly KW_OUTPUTFORMAT = 206;
|
|
public static readonly KW_OVER = 207;
|
|
public static readonly KW_OVERLAPS = 208;
|
|
public static readonly KW_OVERLAY = 209;
|
|
public static readonly KW_OVERWRITE = 210;
|
|
public static readonly KW_PARTITION = 211;
|
|
public static readonly KW_PARTITIONED = 212;
|
|
public static readonly KW_PARTITIONS = 213;
|
|
public static readonly KW_PERCENTILE_CONT = 214;
|
|
public static readonly KW_PERCENTILE_DISC = 215;
|
|
public static readonly KW_PERCENTLIT = 216;
|
|
public static readonly KW_PIVOT = 217;
|
|
public static readonly KW_PLACING = 218;
|
|
public static readonly KW_POSITION = 219;
|
|
public static readonly KW_PRECEDING = 220;
|
|
public static readonly KW_PRIMARY = 221;
|
|
public static readonly KW_PRINCIPALS = 222;
|
|
public static readonly KW_PROPERTIES = 223;
|
|
public static readonly KW_PURGE = 224;
|
|
public static readonly KW_QUARTER = 225;
|
|
public static readonly KW_QUERY = 226;
|
|
public static readonly KW_RANGE = 227;
|
|
public static readonly KW_REAL = 228;
|
|
public static readonly KW_RECORDREADER = 229;
|
|
public static readonly KW_RECORDWRITER = 230;
|
|
public static readonly KW_RECOVER = 231;
|
|
public static readonly KW_REDUCE = 232;
|
|
public static readonly KW_REFERENCES = 233;
|
|
public static readonly KW_REFRESH = 234;
|
|
public static readonly KW_RENAME = 235;
|
|
public static readonly KW_REPAIR = 236;
|
|
public static readonly KW_REPEATABLE = 237;
|
|
public static readonly KW_REPLACE = 238;
|
|
public static readonly KW_RESET = 239;
|
|
public static readonly KW_RESPECT = 240;
|
|
public static readonly KW_RESTRICT = 241;
|
|
public static readonly KW_REVOKE = 242;
|
|
public static readonly KW_RIGHT = 243;
|
|
public static readonly KW_RLIKE = 244;
|
|
public static readonly KW_REGEXP = 245;
|
|
public static readonly KW_ROLE = 246;
|
|
public static readonly KW_ROLES = 247;
|
|
public static readonly KW_ROLLBACK = 248;
|
|
public static readonly KW_ROLLUP = 249;
|
|
public static readonly KW_ROW = 250;
|
|
public static readonly KW_ROWS = 251;
|
|
public static readonly KW_SECOND = 252;
|
|
public static readonly KW_SECONDS = 253;
|
|
public static readonly KW_SCHEMA = 254;
|
|
public static readonly KW_SCHEMAS = 255;
|
|
public static readonly KW_SELECT = 256;
|
|
public static readonly KW_SEMI = 257;
|
|
public static readonly KW_SEPARATED = 258;
|
|
public static readonly KW_SERDE = 259;
|
|
public static readonly KW_SERDEPROPERTIES = 260;
|
|
public static readonly KW_SESSION_USER = 261;
|
|
public static readonly KW_SET = 262;
|
|
public static readonly KW_SETMINUS = 263;
|
|
public static readonly KW_SETS = 264;
|
|
public static readonly KW_SHORT = 265;
|
|
public static readonly KW_SHOW = 266;
|
|
public static readonly KW_SINGLE = 267;
|
|
public static readonly KW_SKEWED = 268;
|
|
public static readonly KW_SMALLINT = 269;
|
|
public static readonly KW_SOME = 270;
|
|
public static readonly KW_SORT = 271;
|
|
public static readonly KW_SORTED = 272;
|
|
public static readonly KW_SOURCE = 273;
|
|
public static readonly KW_START = 274;
|
|
public static readonly KW_STATISTICS = 275;
|
|
public static readonly KW_STORED = 276;
|
|
public static readonly KW_STRATIFY = 277;
|
|
public static readonly KW_STRING = 278;
|
|
public static readonly KW_STRUCT = 279;
|
|
public static readonly KW_SUBSTR = 280;
|
|
public static readonly KW_SUBSTRING = 281;
|
|
public static readonly KW_SYNC = 282;
|
|
public static readonly KW_SYSTEM = 283;
|
|
public static readonly KW_SYSTEM_TIME = 284;
|
|
public static readonly KW_SYSTEM_VERSION = 285;
|
|
public static readonly KW_TABLE = 286;
|
|
public static readonly KW_TABLES = 287;
|
|
public static readonly KW_TABLESAMPLE = 288;
|
|
public static readonly KW_TARGET = 289;
|
|
public static readonly KW_TBLPROPERTIES = 290;
|
|
public static readonly KW_TEMPORARY = 291;
|
|
public static readonly KW_TERMINATED = 292;
|
|
public static readonly KW_THEN = 293;
|
|
public static readonly KW_TIME = 294;
|
|
public static readonly KW_TIMEDIFF = 295;
|
|
public static readonly KW_TIMESTAMP = 296;
|
|
public static readonly KW_TIMESTAMP_LTZ = 297;
|
|
public static readonly KW_TIMESTAMP_NTZ = 298;
|
|
public static readonly KW_TIMESTAMPADD = 299;
|
|
public static readonly KW_TIMESTAMPDIFF = 300;
|
|
public static readonly KW_TINYINT = 301;
|
|
public static readonly KW_TO = 302;
|
|
public static readonly KW_TOUCH = 303;
|
|
public static readonly KW_TRAILING = 304;
|
|
public static readonly KW_TRANSACTION = 305;
|
|
public static readonly KW_TRANSACTIONS = 306;
|
|
public static readonly KW_TRANSFORM = 307;
|
|
public static readonly KW_TRIM = 308;
|
|
public static readonly KW_TRUE = 309;
|
|
public static readonly KW_TRUNCATE = 310;
|
|
public static readonly KW_TRY_CAST = 311;
|
|
public static readonly KW_TYPE = 312;
|
|
public static readonly KW_UNARCHIVE = 313;
|
|
public static readonly KW_UNBOUNDED = 314;
|
|
public static readonly KW_UNCACHE = 315;
|
|
public static readonly KW_UNION = 316;
|
|
public static readonly KW_UNIQUE = 317;
|
|
public static readonly KW_UNKNOWN = 318;
|
|
public static readonly KW_UNLOCK = 319;
|
|
public static readonly KW_UNPIVOT = 320;
|
|
public static readonly KW_UNSET = 321;
|
|
public static readonly KW_UPDATE = 322;
|
|
public static readonly KW_USE = 323;
|
|
public static readonly KW_USER = 324;
|
|
public static readonly KW_USING = 325;
|
|
public static readonly KW_VALUES = 326;
|
|
public static readonly KW_VARCHAR = 327;
|
|
public static readonly KW_VAR = 328;
|
|
public static readonly KW_VARIABLE = 329;
|
|
public static readonly KW_VERSION = 330;
|
|
public static readonly KW_VIEW = 331;
|
|
public static readonly KW_VIEWS = 332;
|
|
public static readonly KW_VOID = 333;
|
|
public static readonly KW_WEEK = 334;
|
|
public static readonly KW_WEEKS = 335;
|
|
public static readonly KW_WHEN = 336;
|
|
public static readonly KW_WHERE = 337;
|
|
public static readonly KW_WINDOW = 338;
|
|
public static readonly KW_WITH = 339;
|
|
public static readonly KW_WITHIN = 340;
|
|
public static readonly KW_YEAR = 341;
|
|
public static readonly KW_YEARS = 342;
|
|
public static readonly KW_ZONE = 343;
|
|
public static readonly EQ = 344;
|
|
public static readonly NSEQ = 345;
|
|
public static readonly NEQ = 346;
|
|
public static readonly NEQJ = 347;
|
|
public static readonly LT = 348;
|
|
public static readonly LTE = 349;
|
|
public static readonly GT = 350;
|
|
public static readonly GTE = 351;
|
|
public static readonly NOT = 352;
|
|
public static readonly PLUS = 353;
|
|
public static readonly MINUS = 354;
|
|
public static readonly ASTERISK = 355;
|
|
public static readonly SLASH = 356;
|
|
public static readonly PERCENT = 357;
|
|
public static readonly TILDE = 358;
|
|
public static readonly AMPERSAND = 359;
|
|
public static readonly PIPE = 360;
|
|
public static readonly CONCAT_PIPE = 361;
|
|
public static readonly HAT = 362;
|
|
public static readonly COLON = 363;
|
|
public static readonly ARROW = 364;
|
|
public static readonly FAT_ARROW = 365;
|
|
public static readonly HENT_START = 366;
|
|
public static readonly HENT_END = 367;
|
|
public static readonly QUESTION = 368;
|
|
public static readonly STRING_LITERAL = 369;
|
|
public static readonly DOUBLEQUOTED_STRING = 370;
|
|
public static readonly BIGINT_LITERAL = 371;
|
|
public static readonly SMALLINT_LITERAL = 372;
|
|
public static readonly TINYINT_LITERAL = 373;
|
|
public static readonly INTEGER_VALUE = 374;
|
|
public static readonly EXPONENT_VALUE = 375;
|
|
public static readonly DECIMAL_VALUE = 376;
|
|
public static readonly FLOAT_LITERAL = 377;
|
|
public static readonly DOUBLE_LITERAL = 378;
|
|
public static readonly BIGDECIMAL_LITERAL = 379;
|
|
public static readonly IDENTIFIER = 380;
|
|
public static readonly BACKQUOTED_IDENTIFIER = 381;
|
|
public static readonly SIMPLE_COMMENT = 382;
|
|
public static readonly BRACKETED_COMMENT = 383;
|
|
public static readonly WS = 384;
|
|
public static readonly UNRECOGNIZED = 385;
|
|
public static readonly RULE_program = 0;
|
|
public static readonly RULE_singleStatement = 1;
|
|
public static readonly RULE_statement = 2;
|
|
public static readonly RULE_timezone = 3;
|
|
public static readonly RULE_configKey = 4;
|
|
public static readonly RULE_configValue = 5;
|
|
public static readonly RULE_unsupportedHiveNativeCommands = 6;
|
|
public static readonly RULE_createTableHeader = 7;
|
|
public static readonly RULE_replaceTableHeader = 8;
|
|
public static readonly RULE_bucketSpec = 9;
|
|
public static readonly RULE_skewSpec = 10;
|
|
public static readonly RULE_locationSpec = 11;
|
|
public static readonly RULE_commentSpec = 12;
|
|
public static readonly RULE_query = 13;
|
|
public static readonly RULE_insertInto = 14;
|
|
public static readonly RULE_partitionSpecLocation = 15;
|
|
public static readonly RULE_partitionSpec = 16;
|
|
public static readonly RULE_partitionVal = 17;
|
|
public static readonly RULE_dbSchema = 18;
|
|
public static readonly RULE_dbSchemas = 19;
|
|
public static readonly RULE_describeFuncName = 20;
|
|
public static readonly RULE_describeColName = 21;
|
|
public static readonly RULE_ctes = 22;
|
|
public static readonly RULE_namedQuery = 23;
|
|
public static readonly RULE_tableProvider = 24;
|
|
public static readonly RULE_createTableClauses = 25;
|
|
public static readonly RULE_propertyList = 26;
|
|
public static readonly RULE_property = 27;
|
|
public static readonly RULE_propertyKey = 28;
|
|
public static readonly RULE_propertyValue = 29;
|
|
public static readonly RULE_expressionPropertyList = 30;
|
|
public static readonly RULE_expressionProperty = 31;
|
|
public static readonly RULE_constantList = 32;
|
|
public static readonly RULE_nestedConstantList = 33;
|
|
public static readonly RULE_createFileFormat = 34;
|
|
public static readonly RULE_fileFormat = 35;
|
|
public static readonly RULE_storageHandler = 36;
|
|
public static readonly RULE_resource = 37;
|
|
public static readonly RULE_dmlStatementNoWith = 38;
|
|
public static readonly RULE_dbSchemaName = 39;
|
|
public static readonly RULE_dbSchemaNameCreate = 40;
|
|
public static readonly RULE_tableNameCreate = 41;
|
|
public static readonly RULE_tableName = 42;
|
|
public static readonly RULE_viewNameCreate = 43;
|
|
public static readonly RULE_viewName = 44;
|
|
public static readonly RULE_identifierReference = 45;
|
|
public static readonly RULE_queryOrganization = 46;
|
|
public static readonly RULE_multiInsertQueryBody = 47;
|
|
public static readonly RULE_queryTerm = 48;
|
|
public static readonly RULE_queryPrimary = 49;
|
|
public static readonly RULE_sortItem = 50;
|
|
public static readonly RULE_fromStatement = 51;
|
|
public static readonly RULE_fromStatementBody = 52;
|
|
public static readonly RULE_querySpecification = 53;
|
|
public static readonly RULE_transformClause = 54;
|
|
public static readonly RULE_selectClause = 55;
|
|
public static readonly RULE_setClause = 56;
|
|
public static readonly RULE_matchedClause = 57;
|
|
public static readonly RULE_notMatchedClause = 58;
|
|
public static readonly RULE_notMatchedBySourceClause = 59;
|
|
public static readonly RULE_matchedAction = 60;
|
|
public static readonly RULE_notMatchedAction = 61;
|
|
public static readonly RULE_notMatchedBySourceAction = 62;
|
|
public static readonly RULE_assignmentList = 63;
|
|
public static readonly RULE_assignment = 64;
|
|
public static readonly RULE_whereClause = 65;
|
|
public static readonly RULE_havingClause = 66;
|
|
public static readonly RULE_hint = 67;
|
|
public static readonly RULE_hintStatement = 68;
|
|
public static readonly RULE_fromClause = 69;
|
|
public static readonly RULE_functionKind = 70;
|
|
public static readonly RULE_temporalClause = 71;
|
|
public static readonly RULE_aggregationClause = 72;
|
|
public static readonly RULE_groupByClause = 73;
|
|
public static readonly RULE_groupingAnalytics = 74;
|
|
public static readonly RULE_groupingElement = 75;
|
|
public static readonly RULE_groupingSet = 76;
|
|
public static readonly RULE_pivotClause = 77;
|
|
public static readonly RULE_pivotColumn = 78;
|
|
public static readonly RULE_pivotValue = 79;
|
|
public static readonly RULE_unpivotClause = 80;
|
|
public static readonly RULE_unpivotNullClause = 81;
|
|
public static readonly RULE_unpivotOperator = 82;
|
|
public static readonly RULE_unpivotSingleValueColumnClause = 83;
|
|
public static readonly RULE_unpivotMultiValueColumnClause = 84;
|
|
public static readonly RULE_unpivotColumnSet = 85;
|
|
public static readonly RULE_unpivotValueColumn = 86;
|
|
public static readonly RULE_unpivotNameColumn = 87;
|
|
public static readonly RULE_unpivotColumnAndAlias = 88;
|
|
public static readonly RULE_unpivotColumn = 89;
|
|
public static readonly RULE_unpivotAlias = 90;
|
|
public static readonly RULE_ifNotExists = 91;
|
|
public static readonly RULE_ifExists = 92;
|
|
public static readonly RULE_lateralView = 93;
|
|
public static readonly RULE_setQuantifier = 94;
|
|
public static readonly RULE_relation = 95;
|
|
public static readonly RULE_relationExtension = 96;
|
|
public static readonly RULE_joinRelation = 97;
|
|
public static readonly RULE_joinType = 98;
|
|
public static readonly RULE_joinCriteria = 99;
|
|
public static readonly RULE_sample = 100;
|
|
public static readonly RULE_sampleMethod = 101;
|
|
public static readonly RULE_identifierList = 102;
|
|
public static readonly RULE_identifierSeq = 103;
|
|
public static readonly RULE_orderedIdentifierList = 104;
|
|
public static readonly RULE_orderedIdentifier = 105;
|
|
public static readonly RULE_identifierCommentList = 106;
|
|
public static readonly RULE_identifierComment = 107;
|
|
public static readonly RULE_relationPrimary = 108;
|
|
public static readonly RULE_inlineTable = 109;
|
|
public static readonly RULE_functionTableSubqueryArgument = 110;
|
|
public static readonly RULE_tableArgumentPartitioning = 111;
|
|
public static readonly RULE_functionTableNamedArgumentExpression = 112;
|
|
public static readonly RULE_functionTableReferenceArgument = 113;
|
|
public static readonly RULE_functionTableArgument = 114;
|
|
public static readonly RULE_functionTable = 115;
|
|
public static readonly RULE_tableAlias = 116;
|
|
public static readonly RULE_rowFormat = 117;
|
|
public static readonly RULE_multipartIdentifierList = 118;
|
|
public static readonly RULE_multipartIdentifier = 119;
|
|
public static readonly RULE_multipartIdentifierPropertyList = 120;
|
|
public static readonly RULE_multipartIdentifierProperty = 121;
|
|
public static readonly RULE_tableIdentifier = 122;
|
|
public static readonly RULE_viewIdentifier = 123;
|
|
public static readonly RULE_namedExpression = 124;
|
|
public static readonly RULE_namedExpressionSeq = 125;
|
|
public static readonly RULE_partitionFieldList = 126;
|
|
public static readonly RULE_partitionField = 127;
|
|
public static readonly RULE_transform = 128;
|
|
public static readonly RULE_transformArgument = 129;
|
|
public static readonly RULE_expression = 130;
|
|
public static readonly RULE_namedArgumentExpression = 131;
|
|
public static readonly RULE_functionArgument = 132;
|
|
public static readonly RULE_expressionSeq = 133;
|
|
public static readonly RULE_booleanExpression = 134;
|
|
public static readonly RULE_predicate = 135;
|
|
public static readonly RULE_valueExpression = 136;
|
|
public static readonly RULE_datetimeUnit = 137;
|
|
public static readonly RULE_primaryExpression = 138;
|
|
public static readonly RULE_literalType = 139;
|
|
public static readonly RULE_constant = 140;
|
|
public static readonly RULE_comparisonOperator = 141;
|
|
public static readonly RULE_arithmeticOperator = 142;
|
|
public static readonly RULE_predicateOperator = 143;
|
|
public static readonly RULE_booleanValue = 144;
|
|
public static readonly RULE_interval = 145;
|
|
public static readonly RULE_errorCapturingMultiUnitsInterval = 146;
|
|
public static readonly RULE_multiUnitsInterval = 147;
|
|
public static readonly RULE_errorCapturingUnitToUnitInterval = 148;
|
|
public static readonly RULE_unitToUnitInterval = 149;
|
|
public static readonly RULE_intervalValue = 150;
|
|
public static readonly RULE_unitInMultiUnits = 151;
|
|
public static readonly RULE_unitInUnitToUnit = 152;
|
|
public static readonly RULE_colPosition = 153;
|
|
public static readonly RULE_type = 154;
|
|
public static readonly RULE_dataType = 155;
|
|
public static readonly RULE_qualifiedColTypeWithPositionList = 156;
|
|
public static readonly RULE_qualifiedColTypeWithPosition = 157;
|
|
public static readonly RULE_colDefinitionDescriptorWithPosition = 158;
|
|
public static readonly RULE_defaultExpression = 159;
|
|
public static readonly RULE_variableDefaultExpression = 160;
|
|
public static readonly RULE_colTypeList = 161;
|
|
public static readonly RULE_colType = 162;
|
|
public static readonly RULE_createOrReplaceTableColTypeList = 163;
|
|
public static readonly RULE_createOrReplaceTableColType = 164;
|
|
public static readonly RULE_colDefinitionOption = 165;
|
|
public static readonly RULE_generationExpression = 166;
|
|
public static readonly RULE_complexColTypeList = 167;
|
|
public static readonly RULE_complexColType = 168;
|
|
public static readonly RULE_whenClause = 169;
|
|
public static readonly RULE_windowClause = 170;
|
|
public static readonly RULE_namedWindow = 171;
|
|
public static readonly RULE_windowSpec = 172;
|
|
public static readonly RULE_windowFrame = 173;
|
|
public static readonly RULE_frameBound = 174;
|
|
public static readonly RULE_qualifiedNameList = 175;
|
|
public static readonly RULE_functionName = 176;
|
|
public static readonly RULE_functionNameCreate = 177;
|
|
public static readonly RULE_qualifiedName = 178;
|
|
public static readonly RULE_errorCapturingIdentifier = 179;
|
|
public static readonly RULE_errorCapturingIdentifierExtra = 180;
|
|
public static readonly RULE_identifier = 181;
|
|
public static readonly RULE_strictIdentifier = 182;
|
|
public static readonly RULE_quotedIdentifier = 183;
|
|
public static readonly RULE_backQuotedIdentifier = 184;
|
|
public static readonly RULE_number = 185;
|
|
public static readonly RULE_alterColumnAction = 186;
|
|
public static readonly RULE_stringLit = 187;
|
|
public static readonly RULE_comment = 188;
|
|
public static readonly RULE_version = 189;
|
|
public static readonly RULE_ansiNonReserved = 190;
|
|
public static readonly RULE_strictNonReserved = 191;
|
|
public static readonly RULE_nonReserved = 192;
|
|
// tslint:disable:no-trailing-whitespace
|
|
public static readonly ruleNames: string[] = [
|
|
"program", "singleStatement", "statement", "timezone", "configKey", "configValue",
|
|
"unsupportedHiveNativeCommands", "createTableHeader", "replaceTableHeader",
|
|
"bucketSpec", "skewSpec", "locationSpec", "commentSpec", "query", "insertInto",
|
|
"partitionSpecLocation", "partitionSpec", "partitionVal", "dbSchema",
|
|
"dbSchemas", "describeFuncName", "describeColName", "ctes", "namedQuery",
|
|
"tableProvider", "createTableClauses", "propertyList", "property", "propertyKey",
|
|
"propertyValue", "expressionPropertyList", "expressionProperty", "constantList",
|
|
"nestedConstantList", "createFileFormat", "fileFormat", "storageHandler",
|
|
"resource", "dmlStatementNoWith", "dbSchemaName", "dbSchemaNameCreate",
|
|
"tableNameCreate", "tableName", "viewNameCreate", "viewName", "identifierReference",
|
|
"queryOrganization", "multiInsertQueryBody", "queryTerm", "queryPrimary",
|
|
"sortItem", "fromStatement", "fromStatementBody", "querySpecification",
|
|
"transformClause", "selectClause", "setClause", "matchedClause", "notMatchedClause",
|
|
"notMatchedBySourceClause", "matchedAction", "notMatchedAction", "notMatchedBySourceAction",
|
|
"assignmentList", "assignment", "whereClause", "havingClause", "hint",
|
|
"hintStatement", "fromClause", "functionKind", "temporalClause", "aggregationClause",
|
|
"groupByClause", "groupingAnalytics", "groupingElement", "groupingSet",
|
|
"pivotClause", "pivotColumn", "pivotValue", "unpivotClause", "unpivotNullClause",
|
|
"unpivotOperator", "unpivotSingleValueColumnClause", "unpivotMultiValueColumnClause",
|
|
"unpivotColumnSet", "unpivotValueColumn", "unpivotNameColumn", "unpivotColumnAndAlias",
|
|
"unpivotColumn", "unpivotAlias", "ifNotExists", "ifExists", "lateralView",
|
|
"setQuantifier", "relation", "relationExtension", "joinRelation", "joinType",
|
|
"joinCriteria", "sample", "sampleMethod", "identifierList", "identifierSeq",
|
|
"orderedIdentifierList", "orderedIdentifier", "identifierCommentList",
|
|
"identifierComment", "relationPrimary", "inlineTable", "functionTableSubqueryArgument",
|
|
"tableArgumentPartitioning", "functionTableNamedArgumentExpression", "functionTableReferenceArgument",
|
|
"functionTableArgument", "functionTable", "tableAlias", "rowFormat", "multipartIdentifierList",
|
|
"multipartIdentifier", "multipartIdentifierPropertyList", "multipartIdentifierProperty",
|
|
"tableIdentifier", "viewIdentifier", "namedExpression", "namedExpressionSeq",
|
|
"partitionFieldList", "partitionField", "transform", "transformArgument",
|
|
"expression", "namedArgumentExpression", "functionArgument", "expressionSeq",
|
|
"booleanExpression", "predicate", "valueExpression", "datetimeUnit", "primaryExpression",
|
|
"literalType", "constant", "comparisonOperator", "arithmeticOperator",
|
|
"predicateOperator", "booleanValue", "interval", "errorCapturingMultiUnitsInterval",
|
|
"multiUnitsInterval", "errorCapturingUnitToUnitInterval", "unitToUnitInterval",
|
|
"intervalValue", "unitInMultiUnits", "unitInUnitToUnit", "colPosition",
|
|
"type", "dataType", "qualifiedColTypeWithPositionList", "qualifiedColTypeWithPosition",
|
|
"colDefinitionDescriptorWithPosition", "defaultExpression", "variableDefaultExpression",
|
|
"colTypeList", "colType", "createOrReplaceTableColTypeList", "createOrReplaceTableColType",
|
|
"colDefinitionOption", "generationExpression", "complexColTypeList", "complexColType",
|
|
"whenClause", "windowClause", "namedWindow", "windowSpec", "windowFrame",
|
|
"frameBound", "qualifiedNameList", "functionName", "functionNameCreate",
|
|
"qualifiedName", "errorCapturingIdentifier", "errorCapturingIdentifierExtra",
|
|
"identifier", "strictIdentifier", "quotedIdentifier", "backQuotedIdentifier",
|
|
"number", "alterColumnAction", "stringLit", "comment", "version", "ansiNonReserved",
|
|
"strictNonReserved", "nonReserved",
|
|
];
|
|
|
|
private static readonly _LITERAL_NAMES: Array<string | undefined> = [
|
|
undefined, "';'", "'('", "')'", "','", "'.'", "'['", "']'", "'ADD'", "'AFTER'",
|
|
"'ALL'", "'ALTER'", "'ALWAYS'", "'ANALYZE'", "'AND'", "'ANTI'", "'ANY'",
|
|
"'ANY_VALUE'", "'ARCHIVE'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORIZATION'",
|
|
"'BETWEEN'", "'BIGINT'", "'BINARY'", "'BOOLEAN'", "'BOTH'", "'BUCKET'",
|
|
"'BUCKETS'", "'BY'", "'BYTE'", "'CACHE'", "'CASCADE'", "'CASE'", "'CAST'",
|
|
"'CATALOG'", "'CATALOGS'", "'CHANGE'", "'CHAR'", "'CHARACTER'", "'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'", "'DAY'", "'DAYS'", "'DAYOFYEAR'", "'DATA'", "'DATE'",
|
|
"'DATABASE'", "'DATABASES'", "'DATEADD'", "'DATE_ADD'", "'DATEDIFF'",
|
|
"'DATE_DIFF'", "'DBPROPERTIES'", "'DEC'", "'DECIMAL'", "'DECLARE'", "'DEFAULT'",
|
|
"'DEFINED'", "'DELETE'", "'DELIMITED'", "'DESC'", "'DESCRIBE'", "'DFS'",
|
|
"'DIRECTORIES'", "'DIRECTORY'", "'DISTINCT'", "'DISTRIBUTE'", "'DIV'",
|
|
"'DOUBLE'", "'DROP'", "'ELSE'", "'END'", "'ESCAPE'", "'ESCAPED'", "'EXCEPT'",
|
|
"'EXCHANGE'", "'EXCLUDE'", "'EXISTS'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'",
|
|
"'EXTERNAL'", "'EXTRACT'", "'FALSE'", "'FETCH'", "'FIELDS'", "'FILTER'",
|
|
"'FILEFORMAT'", "'FIRST'", "'FLOAT'", "'FOLLOWING'", "'FOR'", "'FOREIGN'",
|
|
"'FORMAT'", "'FORMATTED'", "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'",
|
|
"'GENERATED'", "'GLOBAL'", "'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'",
|
|
"'X'", "'HOUR'", "'HOURS'", "'IDENTIFIER'", "'IF'", "'IGNORE'", "'IMPORT'",
|
|
"'IN'", "'INCLUDE'", "'INDEX'", "'INDEXES'", "'INNER'", "'INPATH'", "'INPUTFORMAT'",
|
|
"'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INT'", "'INTEGER'", "'INTO'",
|
|
"'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", "'LAST'", "'LATERAL'", "'LAZY'",
|
|
"'LEADING'", "'LEFT'", "'LIKE'", "'ILIKE'", "'LIMIT'", "'LINES'", "'LIST'",
|
|
"'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", "'LOCKS'", "'LOGICAL'", "'LONG'",
|
|
"'MACRO'", "'MAP'", "'MATCHED'", "'MERGE'", "'MICROSECOND'", "'MICROSECONDS'",
|
|
"'MILLISECOND'", "'MILLISECONDS'", "'MINUTE'", "'MINUTES'", "'MONTH'",
|
|
"'MONTHS'", "'MSCK'", "'NAME'", "'NAMESPACE'", "'NAMESPACES'", "'NANOSECOND'",
|
|
"'NANOSECONDS'", "'NATURAL'", "'NO'", "'NOT'", "'NULL'", "'NULLS'", "'NUMERIC'",
|
|
"'OF'", "'OFFSET'", "'ON'", "'ONLY'", "'OPTION'", "'OPTIONS'", "'OR'",
|
|
"'ORDER'", "'OUT'", "'OUTER'", "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'",
|
|
"'OVERLAY'", "'OVERWRITE'", "'PARTITION'", "'PARTITIONED'", "'PARTITIONS'",
|
|
"'PERCENTILE_CONT'", "'PERCENTILE_DISC'", "'PERCENT'", "'PIVOT'", "'PLACING'",
|
|
"'POSITION'", "'PRECEDING'", "'PRIMARY'", "'PRINCIPALS'", "'PROPERTIES'",
|
|
"'PURGE'", "'QUARTER'", "'QUERY'", "'RANGE'", "'REAL'", "'RECORDREADER'",
|
|
"'RECORDWRITER'", "'RECOVER'", "'REDUCE'", "'REFERENCES'", "'REFRESH'",
|
|
"'RENAME'", "'REPAIR'", "'REPEATABLE'", "'REPLACE'", "'RESET'", "'RESPECT'",
|
|
"'RESTRICT'", "'REVOKE'", "'RIGHT'", "'RLIKE'", "'REGEXP'", "'ROLE'",
|
|
"'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", "'SECOND'", "'SECONDS'",
|
|
"'SCHEMA'", "'SCHEMAS'", "'SELECT'", "'SEMI'", "'SEPARATED'", "'SERDE'",
|
|
"'SERDEPROPERTIES'", "'SESSION_USER'", "'SET'", "'MINUS'", "'SETS'", "'SHORT'",
|
|
"'SHOW'", "'SINGLE'", "'SKEWED'", "'SMALLINT'", "'SOME'", "'SORT'", "'SORTED'",
|
|
"'SOURCE'", "'START'", "'STATISTICS'", "'STORED'", "'STRATIFY'", "'STRING'",
|
|
"'STRUCT'", "'SUBSTR'", "'SUBSTRING'", "'SYNC'", "'SYSTEM'", "'SYSTEM_TIME'",
|
|
"'SYSTEM_VERSION'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TARGET'",
|
|
"'TBLPROPERTIES'", "'TEMPORARY'", "'TERMINATED'", "'THEN'", "'TIME'",
|
|
"'TIMEDIFF'", "'TIMESTAMP'", "'TIMESTAMP_LTZ'", "'TIMESTAMP_NTZ'", "'TIMESTAMPADD'",
|
|
"'TIMESTAMPDIFF'", "'TINYINT'", "'TO'", "'TOUCH'", "'TRAILING'", "'TRANSACTION'",
|
|
"'TRANSACTIONS'", "'TRANSFORM'", "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TRY_CAST'",
|
|
"'TYPE'", "'UNARCHIVE'", "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'",
|
|
"'UNKNOWN'", "'UNLOCK'", "'UNPIVOT'", "'UNSET'", "'UPDATE'", "'USE'",
|
|
"'USER'", "'USING'", "'VALUES'", "'VARCHAR'", "'VAR'", "'VARIABLE'", "'VERSION'",
|
|
"'VIEW'", "'VIEWS'", "'VOID'", "'WEEK'", "'WEEKS'", "'WHEN'", "'WHERE'",
|
|
"'WINDOW'", "'WITH'", "'WITHIN'", "'YEAR'", "'YEARS'", "'ZONE'", undefined,
|
|
"'<=>'", "'<>'", "'!='", "'<'", undefined, "'>'", undefined, "'!'", "'+'",
|
|
"'-'", "'*'", "'/'", "'%'", "'~'", "'&'", "'|'", "'||'", "'^'", "':'",
|
|
"'->'", "'=>'", "'/*+'", "'*/'", "'?'",
|
|
];
|
|
private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
|
|
undefined, "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", "LEFT_BRACKET",
|
|
"RIGHT_BRACKET", "KW_ADD", "KW_AFTER", "KW_ALL", "KW_ALTER", "KW_ALWAYS",
|
|
"KW_ANALYZE", "KW_AND", "KW_ANTI", "KW_ANY", "KW_ANY_VALUE", "KW_ARCHIVE",
|
|
"KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", "KW_AUTHORIZATION", "KW_BETWEEN",
|
|
"KW_BIGINT", "KW_BINARY", "KW_BOOLEAN", "KW_BOTH", "KW_BUCKET", "KW_BUCKETS",
|
|
"KW_BY", "KW_BYTE", "KW_CACHE", "KW_CASCADE", "KW_CASE", "KW_CAST", "KW_CATALOG",
|
|
"KW_CATALOGS", "KW_CHANGE", "KW_CHAR", "KW_CHARACTER", "KW_CHECK", "KW_CLEAR",
|
|
"KW_CLUSTER", "KW_CLUSTERED", "KW_CODEGEN", "KW_COLLATE", "KW_COLLECTION",
|
|
"KW_COLUMN", "KW_COLUMNS", "KW_COMMENT", "KW_COMMIT", "KW_COMPACT", "KW_COMPACTIONS",
|
|
"KW_COMPUTE", "KW_CONCATENATE", "KW_CONSTRAINT", "KW_COST", "KW_CREATE",
|
|
"KW_CROSS", "KW_CUBE", "KW_CURRENT", "KW_CURRENT_DATE", "KW_CURRENT_TIME",
|
|
"KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", "KW_DAY", "KW_DAYS", "KW_DAYOFYEAR",
|
|
"KW_DATA", "KW_DATE", "KW_DATABASE", "KW_DATABASES", "KW_DATEADD", "KW_DATE_ADD",
|
|
"KW_DATEDIFF", "KW_DATE_DIFF", "KW_DBPROPERTIES", "KW_DEC", "KW_DECIMAL",
|
|
"KW_DECLARE", "KW_DEFAULT", "KW_DEFINED", "KW_DELETE", "KW_DELIMITED",
|
|
"KW_DESC", "KW_DESCRIBE", "KW_DFS", "KW_DIRECTORIES", "KW_DIRECTORY",
|
|
"KW_DISTINCT", "KW_DISTRIBUTE", "KW_DIV", "KW_DOUBLE", "KW_DROP", "KW_ELSE",
|
|
"KW_END", "KW_ESCAPE", "KW_ESCAPED", "KW_EXCEPT", "KW_EXCHANGE", "KW_EXCLUDE",
|
|
"KW_EXISTS", "KW_EXPLAIN", "KW_EXPORT", "KW_EXTENDED", "KW_EXTERNAL",
|
|
"KW_EXTRACT", "KW_FALSE", "KW_FETCH", "KW_FIELDS", "KW_FILTER", "KW_FILEFORMAT",
|
|
"KW_FIRST", "KW_FLOAT", "KW_FOLLOWING", "KW_FOR", "KW_FOREIGN", "KW_FORMAT",
|
|
"KW_FORMATTED", "KW_FROM", "KW_FULL", "KW_FUNCTION", "KW_FUNCTIONS", "KW_GENERATED",
|
|
"KW_GLOBAL", "KW_GRANT", "KW_GROUP", "KW_GROUPING", "KW_HAVING", "KW_BINARY_HEX",
|
|
"KW_HOUR", "KW_HOURS", "KW_IDENTIFIER_KW", "KW_IF", "KW_IGNORE", "KW_IMPORT",
|
|
"KW_IN", "KW_INCLUDE", "KW_INDEX", "KW_INDEXES", "KW_INNER", "KW_INPATH",
|
|
"KW_INPUTFORMAT", "KW_INSERT", "KW_INTERSECT", "KW_INTERVAL", "KW_INT",
|
|
"KW_INTEGER", "KW_INTO", "KW_IS", "KW_ITEMS", "KW_JOIN", "KW_KEYS", "KW_LAST",
|
|
"KW_LATERAL", "KW_LAZY", "KW_LEADING", "KW_LEFT", "KW_LIKE", "KW_ILIKE",
|
|
"KW_LIMIT", "KW_LINES", "KW_LIST", "KW_LOAD", "KW_LOCAL", "KW_LOCATION",
|
|
"KW_LOCK", "KW_LOCKS", "KW_LOGICAL", "KW_LONG", "KW_MACRO", "KW_MAP",
|
|
"KW_MATCHED", "KW_MERGE", "KW_MICROSECOND", "KW_MICROSECONDS", "KW_MILLISECOND",
|
|
"KW_MILLISECONDS", "KW_MINUTE", "KW_MINUTES", "KW_MONTH", "KW_MONTHS",
|
|
"KW_MSCK", "KW_NAME", "KW_NAMESPACE", "KW_NAMESPACES", "KW_NANOSECOND",
|
|
"KW_NANOSECONDS", "KW_NATURAL", "KW_NO", "KW_NOT", "KW_NULL", "KW_NULLS",
|
|
"KW_NUMERIC", "KW_OF", "KW_OFFSET", "KW_ON", "KW_ONLY", "KW_OPTION", "KW_OPTIONS",
|
|
"KW_OR", "KW_ORDER", "KW_OUT", "KW_OUTER", "KW_OUTPUTFORMAT", "KW_OVER",
|
|
"KW_OVERLAPS", "KW_OVERLAY", "KW_OVERWRITE", "KW_PARTITION", "KW_PARTITIONED",
|
|
"KW_PARTITIONS", "KW_PERCENTILE_CONT", "KW_PERCENTILE_DISC", "KW_PERCENTLIT",
|
|
"KW_PIVOT", "KW_PLACING", "KW_POSITION", "KW_PRECEDING", "KW_PRIMARY",
|
|
"KW_PRINCIPALS", "KW_PROPERTIES", "KW_PURGE", "KW_QUARTER", "KW_QUERY",
|
|
"KW_RANGE", "KW_REAL", "KW_RECORDREADER", "KW_RECORDWRITER", "KW_RECOVER",
|
|
"KW_REDUCE", "KW_REFERENCES", "KW_REFRESH", "KW_RENAME", "KW_REPAIR",
|
|
"KW_REPEATABLE", "KW_REPLACE", "KW_RESET", "KW_RESPECT", "KW_RESTRICT",
|
|
"KW_REVOKE", "KW_RIGHT", "KW_RLIKE", "KW_REGEXP", "KW_ROLE", "KW_ROLES",
|
|
"KW_ROLLBACK", "KW_ROLLUP", "KW_ROW", "KW_ROWS", "KW_SECOND", "KW_SECONDS",
|
|
"KW_SCHEMA", "KW_SCHEMAS", "KW_SELECT", "KW_SEMI", "KW_SEPARATED", "KW_SERDE",
|
|
"KW_SERDEPROPERTIES", "KW_SESSION_USER", "KW_SET", "KW_SETMINUS", "KW_SETS",
|
|
"KW_SHORT", "KW_SHOW", "KW_SINGLE", "KW_SKEWED", "KW_SMALLINT", "KW_SOME",
|
|
"KW_SORT", "KW_SORTED", "KW_SOURCE", "KW_START", "KW_STATISTICS", "KW_STORED",
|
|
"KW_STRATIFY", "KW_STRING", "KW_STRUCT", "KW_SUBSTR", "KW_SUBSTRING",
|
|
"KW_SYNC", "KW_SYSTEM", "KW_SYSTEM_TIME", "KW_SYSTEM_VERSION", "KW_TABLE",
|
|
"KW_TABLES", "KW_TABLESAMPLE", "KW_TARGET", "KW_TBLPROPERTIES", "KW_TEMPORARY",
|
|
"KW_TERMINATED", "KW_THEN", "KW_TIME", "KW_TIMEDIFF", "KW_TIMESTAMP",
|
|
"KW_TIMESTAMP_LTZ", "KW_TIMESTAMP_NTZ", "KW_TIMESTAMPADD", "KW_TIMESTAMPDIFF",
|
|
"KW_TINYINT", "KW_TO", "KW_TOUCH", "KW_TRAILING", "KW_TRANSACTION", "KW_TRANSACTIONS",
|
|
"KW_TRANSFORM", "KW_TRIM", "KW_TRUE", "KW_TRUNCATE", "KW_TRY_CAST", "KW_TYPE",
|
|
"KW_UNARCHIVE", "KW_UNBOUNDED", "KW_UNCACHE", "KW_UNION", "KW_UNIQUE",
|
|
"KW_UNKNOWN", "KW_UNLOCK", "KW_UNPIVOT", "KW_UNSET", "KW_UPDATE", "KW_USE",
|
|
"KW_USER", "KW_USING", "KW_VALUES", "KW_VARCHAR", "KW_VAR", "KW_VARIABLE",
|
|
"KW_VERSION", "KW_VIEW", "KW_VIEWS", "KW_VOID", "KW_WEEK", "KW_WEEKS",
|
|
"KW_WHEN", "KW_WHERE", "KW_WINDOW", "KW_WITH", "KW_WITHIN", "KW_YEAR",
|
|
"KW_YEARS", "KW_ZONE", "EQ", "NSEQ", "NEQ", "NEQJ", "LT", "LTE", "GT",
|
|
"GTE", "NOT", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "TILDE",
|
|
"AMPERSAND", "PIPE", "CONCAT_PIPE", "HAT", "COLON", "ARROW", "FAT_ARROW",
|
|
"HENT_START", "HENT_END", "QUESTION", "STRING_LITERAL", "DOUBLEQUOTED_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",
|
|
];
|
|
public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(SparkSqlParser._LITERAL_NAMES, SparkSqlParser._SYMBOLIC_NAMES, []);
|
|
|
|
// @Override
|
|
// @NotNull
|
|
public get vocabulary(): Vocabulary {
|
|
return SparkSqlParser.VOCABULARY;
|
|
}
|
|
// tslint:enable:no-trailing-whitespace
|
|
|
|
// @Override
|
|
public get grammarFileName(): string { return "SparkSqlParser.g4"; }
|
|
|
|
// @Override
|
|
public get ruleNames(): string[] { return SparkSqlParser.ruleNames; }
|
|
|
|
// @Override
|
|
public get serializedATN(): string { return SparkSqlParser._serializedATN; }
|
|
|
|
protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
|
|
return new FailedPredicateException(this, predicate, message);
|
|
}
|
|
|
|
|
|
/**
|
|
* When false, KW_INTERSECT is given the greater precedence over the other set
|
|
* operations (KW_UNION, KW_EXCEPT and MINUS) as per the SQL standard.
|
|
*/
|
|
public legacy_setops_precedence_enabled = false;
|
|
|
|
/**
|
|
* When false, a literal with an exponent would be converted into
|
|
* double type rather than decimal type.
|
|
*/
|
|
public legacy_exponent_literal_as_decimal_enabled = false;
|
|
|
|
/**
|
|
* When true, the behavior of keywords follows ANSI SQL standard.
|
|
*/
|
|
public SQL_standard_keyword_behavior = false;
|
|
|
|
/**
|
|
* When true, double quoted literals are identifiers rather than STRINGs.
|
|
*/
|
|
public double_quoted_identifiers = false;
|
|
|
|
constructor(input: TokenStream) {
|
|
super(input);
|
|
this._interp = new ParserATNSimulator(SparkSqlParser._ATN, this);
|
|
}
|
|
// @RuleVersion(0)
|
|
public program(): ProgramContext {
|
|
let _localctx: ProgramContext = new ProgramContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 0, SparkSqlParser.RULE_program);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 389;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ANALYZE))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (SparkSqlParser.KW_CACHE - 33)) | (1 << (SparkSqlParser.KW_CLEAR - 33)) | (1 << (SparkSqlParser.KW_COMMENT - 33)) | (1 << (SparkSqlParser.KW_COMMIT - 33)) | (1 << (SparkSqlParser.KW_CREATE - 33)))) !== 0) || ((((_la - 81)) & ~0x1F) === 0 && ((1 << (_la - 81)) & ((1 << (SparkSqlParser.KW_DECLARE - 81)) | (1 << (SparkSqlParser.KW_DELETE - 81)) | (1 << (SparkSqlParser.KW_DESC - 81)) | (1 << (SparkSqlParser.KW_DESCRIBE - 81)) | (1 << (SparkSqlParser.KW_DFS - 81)) | (1 << (SparkSqlParser.KW_DROP - 81)) | (1 << (SparkSqlParser.KW_EXPLAIN - 81)) | (1 << (SparkSqlParser.KW_EXPORT - 81)))) !== 0) || ((((_la - 121)) & ~0x1F) === 0 && ((1 << (_la - 121)) & ((1 << (SparkSqlParser.KW_FROM - 121)) | (1 << (SparkSqlParser.KW_GRANT - 121)) | (1 << (SparkSqlParser.KW_IMPORT - 121)) | (1 << (SparkSqlParser.KW_INSERT - 121)))) !== 0) || ((((_la - 164)) & ~0x1F) === 0 && ((1 << (_la - 164)) & ((1 << (SparkSqlParser.KW_LIST - 164)) | (1 << (SparkSqlParser.KW_LOAD - 164)) | (1 << (SparkSqlParser.KW_LOCK - 164)) | (1 << (SparkSqlParser.KW_MAP - 164)) | (1 << (SparkSqlParser.KW_MERGE - 164)) | (1 << (SparkSqlParser.KW_MSCK - 164)))) !== 0) || ((((_la - 232)) & ~0x1F) === 0 && ((1 << (_la - 232)) & ((1 << (SparkSqlParser.KW_REDUCE - 232)) | (1 << (SparkSqlParser.KW_REFRESH - 232)) | (1 << (SparkSqlParser.KW_REPAIR - 232)) | (1 << (SparkSqlParser.KW_REPLACE - 232)) | (1 << (SparkSqlParser.KW_RESET - 232)) | (1 << (SparkSqlParser.KW_REVOKE - 232)) | (1 << (SparkSqlParser.KW_ROLLBACK - 232)) | (1 << (SparkSqlParser.KW_SELECT - 232)) | (1 << (SparkSqlParser.KW_SET - 232)))) !== 0) || ((((_la - 266)) & ~0x1F) === 0 && ((1 << (_la - 266)) & ((1 << (SparkSqlParser.KW_SHOW - 266)) | (1 << (SparkSqlParser.KW_START - 266)) | (1 << (SparkSqlParser.KW_TABLE - 266)))) !== 0) || ((((_la - 310)) & ~0x1F) === 0 && ((1 << (_la - 310)) & ((1 << (SparkSqlParser.KW_TRUNCATE - 310)) | (1 << (SparkSqlParser.KW_UNCACHE - 310)) | (1 << (SparkSqlParser.KW_UNLOCK - 310)) | (1 << (SparkSqlParser.KW_UPDATE - 310)) | (1 << (SparkSqlParser.KW_USE - 310)) | (1 << (SparkSqlParser.KW_VALUES - 310)) | (1 << (SparkSqlParser.KW_WITH - 310)))) !== 0)) {
|
|
{
|
|
{
|
|
this.state = 386;
|
|
this.singleStatement();
|
|
}
|
|
}
|
|
this.state = 391;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 392;
|
|
this.match(SparkSqlParser.EOF);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public singleStatement(): SingleStatementContext {
|
|
let _localctx: SingleStatementContext = new SingleStatementContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 2, SparkSqlParser.RULE_singleStatement);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 394;
|
|
this.statement();
|
|
this.state = 396;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.SEMICOLON) {
|
|
{
|
|
this.state = 395;
|
|
this.match(SparkSqlParser.SEMICOLON);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public statement(): StatementContext {
|
|
let _localctx: StatementContext = new StatementContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 4, SparkSqlParser.RULE_statement);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.state = 1237;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 133, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 398;
|
|
this.query();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 400;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_WITH) {
|
|
{
|
|
this.state = 399;
|
|
this.ctes();
|
|
}
|
|
}
|
|
|
|
this.state = 402;
|
|
this.dmlStatementNoWith();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 403;
|
|
this.match(SparkSqlParser.KW_USE);
|
|
this.state = 404;
|
|
this.dbSchemaName();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 405;
|
|
this.match(SparkSqlParser.KW_USE);
|
|
this.state = 406;
|
|
this.dbSchema();
|
|
this.state = 407;
|
|
this.dbSchemaName();
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 409;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 410;
|
|
this.match(SparkSqlParser.KW_CATALOG);
|
|
this.state = 413;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 3, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 411;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 412;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 415;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 416;
|
|
this.dbSchema();
|
|
this.state = 418;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 4, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 417;
|
|
this.ifNotExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 420;
|
|
this.dbSchemaNameCreate();
|
|
this.state = 428;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
this.state = 426;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_COMMENT:
|
|
{
|
|
this.state = 421;
|
|
this.commentSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_LOCATION:
|
|
{
|
|
this.state = 422;
|
|
this.locationSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_WITH:
|
|
{
|
|
{
|
|
this.state = 423;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 424;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DBPROPERTIES || _la === SparkSqlParser.KW_PROPERTIES)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 425;
|
|
this.propertyList();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
}
|
|
this.state = 430;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 431;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 432;
|
|
this.dbSchema();
|
|
this.state = 433;
|
|
this.dbSchemaName();
|
|
this.state = 434;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 435;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DBPROPERTIES || _la === SparkSqlParser.KW_PROPERTIES)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 436;
|
|
this.propertyList();
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
this.enterOuterAlt(_localctx, 8);
|
|
{
|
|
this.state = 438;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 439;
|
|
this.dbSchema();
|
|
this.state = 440;
|
|
this.dbSchemaName();
|
|
this.state = 441;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 442;
|
|
this.locationSpec();
|
|
}
|
|
break;
|
|
|
|
case 9:
|
|
this.enterOuterAlt(_localctx, 9);
|
|
{
|
|
this.state = 444;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 445;
|
|
this.dbSchema();
|
|
this.state = 447;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 7, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 446;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 449;
|
|
this.dbSchemaName();
|
|
this.state = 451;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_CASCADE || _la === SparkSqlParser.KW_RESTRICT) {
|
|
{
|
|
this.state = 450;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_CASCADE || _la === SparkSqlParser.KW_RESTRICT)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 10:
|
|
this.enterOuterAlt(_localctx, 10);
|
|
{
|
|
this.state = 453;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 454;
|
|
this.dbSchemas();
|
|
this.state = 457;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 455;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 456;
|
|
this.multipartIdentifier();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 463;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 11, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 460;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 10, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 459;
|
|
this.match(SparkSqlParser.KW_LIKE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 462;
|
|
_localctx._pattern = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 11:
|
|
this.enterOuterAlt(_localctx, 11);
|
|
{
|
|
this.state = 465;
|
|
this.createTableHeader();
|
|
this.state = 470;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 12, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 466;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 467;
|
|
this.createOrReplaceTableColTypeList();
|
|
this.state = 468;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 473;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_USING) {
|
|
{
|
|
this.state = 472;
|
|
this.tableProvider();
|
|
}
|
|
}
|
|
|
|
this.state = 475;
|
|
this.createTableClauses();
|
|
this.state = 480;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 15, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 477;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AS) {
|
|
{
|
|
this.state = 476;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
}
|
|
|
|
this.state = 479;
|
|
this.query();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 12:
|
|
this.enterOuterAlt(_localctx, 12);
|
|
{
|
|
this.state = 482;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 483;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 485;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 484;
|
|
this.ifNotExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 487;
|
|
_localctx._target = this.tableNameCreate();
|
|
this.state = 488;
|
|
this.match(SparkSqlParser.KW_LIKE);
|
|
this.state = 489;
|
|
_localctx._source = this.tableName();
|
|
this.state = 498;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.KW_LOCATION || _la === SparkSqlParser.KW_ROW || _la === SparkSqlParser.KW_STORED || _la === SparkSqlParser.KW_TBLPROPERTIES || _la === SparkSqlParser.KW_USING) {
|
|
{
|
|
this.state = 496;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_USING:
|
|
{
|
|
this.state = 490;
|
|
this.tableProvider();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_ROW:
|
|
{
|
|
this.state = 491;
|
|
this.rowFormat();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_STORED:
|
|
{
|
|
this.state = 492;
|
|
this.createFileFormat();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_LOCATION:
|
|
{
|
|
this.state = 493;
|
|
this.locationSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_TBLPROPERTIES:
|
|
{
|
|
{
|
|
this.state = 494;
|
|
this.match(SparkSqlParser.KW_TBLPROPERTIES);
|
|
this.state = 495;
|
|
_localctx._tableProps = this.propertyList();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
this.state = 500;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 13:
|
|
this.enterOuterAlt(_localctx, 13);
|
|
{
|
|
this.state = 501;
|
|
this.replaceTableHeader();
|
|
this.state = 506;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 19, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 502;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 503;
|
|
this.createOrReplaceTableColTypeList();
|
|
this.state = 504;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 509;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_USING) {
|
|
{
|
|
this.state = 508;
|
|
this.tableProvider();
|
|
}
|
|
}
|
|
|
|
this.state = 511;
|
|
this.createTableClauses();
|
|
this.state = 516;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 22, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 513;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AS) {
|
|
{
|
|
this.state = 512;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
}
|
|
|
|
this.state = 515;
|
|
this.query();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 14:
|
|
this.enterOuterAlt(_localctx, 14);
|
|
{
|
|
this.state = 518;
|
|
this.match(SparkSqlParser.KW_ANALYZE);
|
|
this.state = 519;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 520;
|
|
this.tableName();
|
|
this.state = 522;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 521;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 524;
|
|
this.match(SparkSqlParser.KW_COMPUTE);
|
|
this.state = 525;
|
|
this.match(SparkSqlParser.KW_STATISTICS);
|
|
this.state = 533;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 24, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 526;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 527;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
this.state = 528;
|
|
this.match(SparkSqlParser.KW_COLUMNS);
|
|
this.state = 529;
|
|
this.identifierSeq();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
this.state = 530;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
this.state = 531;
|
|
this.match(SparkSqlParser.KW_ALL);
|
|
this.state = 532;
|
|
this.match(SparkSqlParser.KW_COLUMNS);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 15:
|
|
this.enterOuterAlt(_localctx, 15);
|
|
{
|
|
this.state = 535;
|
|
this.match(SparkSqlParser.KW_ANALYZE);
|
|
this.state = 536;
|
|
this.match(SparkSqlParser.KW_TABLES);
|
|
this.state = 539;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN) {
|
|
{
|
|
this.state = 537;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 538;
|
|
this.dbSchemaName();
|
|
}
|
|
}
|
|
|
|
this.state = 541;
|
|
this.match(SparkSqlParser.KW_COMPUTE);
|
|
this.state = 542;
|
|
this.match(SparkSqlParser.KW_STATISTICS);
|
|
this.state = 544;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 26, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 543;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
this.enterOuterAlt(_localctx, 16);
|
|
{
|
|
this.state = 546;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 547;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 548;
|
|
this.tableName();
|
|
this.state = 549;
|
|
this.match(SparkSqlParser.KW_ADD);
|
|
this.state = 550;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 551;
|
|
this.qualifiedColTypeWithPositionList();
|
|
}
|
|
break;
|
|
|
|
case 17:
|
|
this.enterOuterAlt(_localctx, 17);
|
|
{
|
|
this.state = 553;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 554;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 555;
|
|
this.tableName();
|
|
this.state = 556;
|
|
this.match(SparkSqlParser.KW_ADD);
|
|
this.state = 557;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 558;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 559;
|
|
this.qualifiedColTypeWithPositionList();
|
|
this.state = 560;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 18:
|
|
this.enterOuterAlt(_localctx, 18);
|
|
{
|
|
this.state = 562;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 563;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 564;
|
|
_localctx._table = this.tableName();
|
|
this.state = 565;
|
|
this.match(SparkSqlParser.KW_RENAME);
|
|
this.state = 566;
|
|
this.match(SparkSqlParser.KW_COLUMN);
|
|
this.state = 567;
|
|
this.multipartIdentifier();
|
|
this.state = 568;
|
|
this.match(SparkSqlParser.KW_TO);
|
|
this.state = 569;
|
|
this.errorCapturingIdentifier();
|
|
}
|
|
break;
|
|
|
|
case 19:
|
|
this.enterOuterAlt(_localctx, 19);
|
|
{
|
|
this.state = 571;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 572;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 573;
|
|
this.tableName();
|
|
this.state = 574;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 575;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 577;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IF) {
|
|
{
|
|
this.state = 576;
|
|
this.ifExists();
|
|
}
|
|
}
|
|
|
|
this.state = 579;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 580;
|
|
this.multipartIdentifierList();
|
|
this.state = 581;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 20:
|
|
this.enterOuterAlt(_localctx, 20);
|
|
{
|
|
this.state = 583;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 584;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 585;
|
|
this.tableName();
|
|
this.state = 586;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 587;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 589;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 28, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 588;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 591;
|
|
this.multipartIdentifierList();
|
|
}
|
|
break;
|
|
|
|
case 21:
|
|
this.enterOuterAlt(_localctx, 21);
|
|
{
|
|
this.state = 593;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 598;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_TABLE:
|
|
{
|
|
this.state = 594;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 595;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_VIEW:
|
|
{
|
|
this.state = 596;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 597;
|
|
this.viewName();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 600;
|
|
this.match(SparkSqlParser.KW_RENAME);
|
|
this.state = 601;
|
|
this.match(SparkSqlParser.KW_TO);
|
|
this.state = 602;
|
|
this.multipartIdentifier();
|
|
}
|
|
break;
|
|
|
|
case 22:
|
|
this.enterOuterAlt(_localctx, 22);
|
|
{
|
|
this.state = 604;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 609;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_TABLE:
|
|
{
|
|
this.state = 605;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 606;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_VIEW:
|
|
{
|
|
this.state = 607;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 608;
|
|
this.viewName();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 611;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 612;
|
|
this.match(SparkSqlParser.KW_TBLPROPERTIES);
|
|
this.state = 613;
|
|
this.propertyList();
|
|
}
|
|
break;
|
|
|
|
case 23:
|
|
this.enterOuterAlt(_localctx, 23);
|
|
{
|
|
this.state = 615;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 620;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_TABLE:
|
|
{
|
|
this.state = 616;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 617;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_VIEW:
|
|
{
|
|
this.state = 618;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 619;
|
|
this.viewName();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 622;
|
|
this.match(SparkSqlParser.KW_UNSET);
|
|
this.state = 623;
|
|
this.match(SparkSqlParser.KW_TBLPROPERTIES);
|
|
this.state = 625;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IF) {
|
|
{
|
|
this.state = 624;
|
|
this.ifExists();
|
|
}
|
|
}
|
|
|
|
this.state = 627;
|
|
this.propertyList();
|
|
}
|
|
break;
|
|
|
|
case 24:
|
|
this.enterOuterAlt(_localctx, 24);
|
|
{
|
|
this.state = 629;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 630;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 631;
|
|
_localctx._table = this.tableName();
|
|
this.state = 632;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ALTER || _la === SparkSqlParser.KW_CHANGE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 634;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 33, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 633;
|
|
this.match(SparkSqlParser.KW_COLUMN);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 636;
|
|
_localctx._column = this.multipartIdentifier();
|
|
this.state = 638;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 34, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 637;
|
|
this.alterColumnAction();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 25:
|
|
this.enterOuterAlt(_localctx, 25);
|
|
{
|
|
this.state = 640;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 641;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 642;
|
|
_localctx._table = this.tableName();
|
|
this.state = 644;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 643;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 646;
|
|
this.match(SparkSqlParser.KW_CHANGE);
|
|
this.state = 648;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 36, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 647;
|
|
this.match(SparkSqlParser.KW_COLUMN);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 650;
|
|
_localctx._colName = this.multipartIdentifier();
|
|
this.state = 651;
|
|
this.colType();
|
|
this.state = 653;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AFTER || _la === SparkSqlParser.KW_FIRST) {
|
|
{
|
|
this.state = 652;
|
|
this.colPosition();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 26:
|
|
this.enterOuterAlt(_localctx, 26);
|
|
{
|
|
this.state = 655;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 656;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 657;
|
|
_localctx._table = this.tableName();
|
|
this.state = 659;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 658;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 661;
|
|
this.match(SparkSqlParser.KW_REPLACE);
|
|
this.state = 662;
|
|
this.match(SparkSqlParser.KW_COLUMNS);
|
|
this.state = 663;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 664;
|
|
this.qualifiedColTypeWithPositionList();
|
|
this.state = 665;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 27:
|
|
this.enterOuterAlt(_localctx, 27);
|
|
{
|
|
this.state = 667;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 668;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 669;
|
|
this.tableName();
|
|
this.state = 671;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 670;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 673;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 674;
|
|
this.match(SparkSqlParser.KW_SERDE);
|
|
this.state = 675;
|
|
this.stringLit();
|
|
this.state = 679;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 40, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 676;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 677;
|
|
this.match(SparkSqlParser.KW_SERDEPROPERTIES);
|
|
this.state = 678;
|
|
this.propertyList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 28:
|
|
this.enterOuterAlt(_localctx, 28);
|
|
{
|
|
this.state = 681;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 682;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 683;
|
|
this.tableName();
|
|
this.state = 685;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 684;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 687;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 688;
|
|
this.match(SparkSqlParser.KW_SERDEPROPERTIES);
|
|
this.state = 689;
|
|
this.propertyList();
|
|
}
|
|
break;
|
|
|
|
case 29:
|
|
this.enterOuterAlt(_localctx, 29);
|
|
{
|
|
this.state = 691;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 696;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_TABLE:
|
|
{
|
|
this.state = 692;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 693;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_VIEW:
|
|
{
|
|
this.state = 694;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 695;
|
|
this.viewName();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 698;
|
|
this.match(SparkSqlParser.KW_ADD);
|
|
this.state = 700;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IF) {
|
|
{
|
|
this.state = 699;
|
|
this.ifNotExists();
|
|
}
|
|
}
|
|
|
|
this.state = 703;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
this.state = 702;
|
|
this.partitionSpecLocation();
|
|
}
|
|
}
|
|
this.state = 705;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
} while (_la === SparkSqlParser.KW_PARTITION);
|
|
}
|
|
break;
|
|
|
|
case 30:
|
|
this.enterOuterAlt(_localctx, 30);
|
|
{
|
|
this.state = 707;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 708;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 709;
|
|
this.tableName();
|
|
this.state = 710;
|
|
this.partitionSpec();
|
|
this.state = 711;
|
|
this.match(SparkSqlParser.KW_RENAME);
|
|
this.state = 712;
|
|
this.match(SparkSqlParser.KW_TO);
|
|
this.state = 713;
|
|
this.partitionSpec();
|
|
}
|
|
break;
|
|
|
|
case 31:
|
|
this.enterOuterAlt(_localctx, 31);
|
|
{
|
|
this.state = 715;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 720;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_TABLE:
|
|
{
|
|
this.state = 716;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 717;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_VIEW:
|
|
{
|
|
this.state = 718;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 719;
|
|
this.viewName();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 722;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 724;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IF) {
|
|
{
|
|
this.state = 723;
|
|
this.ifExists();
|
|
}
|
|
}
|
|
|
|
this.state = 726;
|
|
this.partitionSpec();
|
|
this.state = 731;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 727;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 728;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
this.state = 733;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 735;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PURGE) {
|
|
{
|
|
this.state = 734;
|
|
this.match(SparkSqlParser.KW_PURGE);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
this.enterOuterAlt(_localctx, 32);
|
|
{
|
|
this.state = 737;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 738;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 739;
|
|
this.tableName();
|
|
this.state = 741;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 740;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 743;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 744;
|
|
this.locationSpec();
|
|
}
|
|
break;
|
|
|
|
case 33:
|
|
this.enterOuterAlt(_localctx, 33);
|
|
{
|
|
this.state = 746;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 747;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 748;
|
|
this.tableName();
|
|
this.state = 749;
|
|
this.match(SparkSqlParser.KW_RECOVER);
|
|
this.state = 750;
|
|
this.match(SparkSqlParser.KW_PARTITIONS);
|
|
}
|
|
break;
|
|
|
|
case 34:
|
|
this.enterOuterAlt(_localctx, 34);
|
|
{
|
|
this.state = 752;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 753;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 755;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 50, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 754;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 757;
|
|
this.tableName();
|
|
this.state = 759;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PURGE) {
|
|
{
|
|
this.state = 758;
|
|
this.match(SparkSqlParser.KW_PURGE);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 35:
|
|
this.enterOuterAlt(_localctx, 35);
|
|
{
|
|
this.state = 761;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 762;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 764;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 52, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 763;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 766;
|
|
this.viewName();
|
|
}
|
|
break;
|
|
|
|
case 36:
|
|
this.enterOuterAlt(_localctx, 36);
|
|
{
|
|
this.state = 767;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 770;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OR) {
|
|
{
|
|
this.state = 768;
|
|
this.match(SparkSqlParser.KW_OR);
|
|
this.state = 769;
|
|
this.match(SparkSqlParser.KW_REPLACE);
|
|
}
|
|
}
|
|
|
|
this.state = 776;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_GLOBAL || _la === SparkSqlParser.KW_TEMPORARY) {
|
|
{
|
|
this.state = 773;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_GLOBAL) {
|
|
{
|
|
this.state = 772;
|
|
this.match(SparkSqlParser.KW_GLOBAL);
|
|
}
|
|
}
|
|
|
|
this.state = 775;
|
|
this.match(SparkSqlParser.KW_TEMPORARY);
|
|
}
|
|
}
|
|
|
|
this.state = 778;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 780;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 56, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 779;
|
|
this.ifNotExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 782;
|
|
this.viewNameCreate();
|
|
this.state = 784;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.LEFT_PAREN) {
|
|
{
|
|
this.state = 783;
|
|
this.identifierCommentList();
|
|
}
|
|
}
|
|
|
|
this.state = 794;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.KW_COMMENT || _la === SparkSqlParser.KW_PARTITIONED || _la === SparkSqlParser.KW_TBLPROPERTIES) {
|
|
{
|
|
this.state = 792;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_COMMENT:
|
|
{
|
|
this.state = 786;
|
|
this.commentSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_PARTITIONED:
|
|
{
|
|
{
|
|
this.state = 787;
|
|
this.match(SparkSqlParser.KW_PARTITIONED);
|
|
this.state = 788;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 789;
|
|
this.identifierList();
|
|
}
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_TBLPROPERTIES:
|
|
{
|
|
{
|
|
this.state = 790;
|
|
this.match(SparkSqlParser.KW_TBLPROPERTIES);
|
|
this.state = 791;
|
|
this.propertyList();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
this.state = 796;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 797;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 798;
|
|
this.query();
|
|
}
|
|
break;
|
|
|
|
case 37:
|
|
this.enterOuterAlt(_localctx, 37);
|
|
{
|
|
this.state = 800;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 803;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OR) {
|
|
{
|
|
this.state = 801;
|
|
this.match(SparkSqlParser.KW_OR);
|
|
this.state = 802;
|
|
this.match(SparkSqlParser.KW_REPLACE);
|
|
}
|
|
}
|
|
|
|
this.state = 806;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_GLOBAL) {
|
|
{
|
|
this.state = 805;
|
|
this.match(SparkSqlParser.KW_GLOBAL);
|
|
}
|
|
}
|
|
|
|
this.state = 808;
|
|
this.match(SparkSqlParser.KW_TEMPORARY);
|
|
this.state = 809;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 810;
|
|
this.viewNameCreate();
|
|
this.state = 815;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.LEFT_PAREN) {
|
|
{
|
|
this.state = 811;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 812;
|
|
this.colTypeList();
|
|
this.state = 813;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
|
|
this.state = 817;
|
|
this.tableProvider();
|
|
this.state = 820;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OPTIONS) {
|
|
{
|
|
this.state = 818;
|
|
this.match(SparkSqlParser.KW_OPTIONS);
|
|
this.state = 819;
|
|
this.propertyList();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 38:
|
|
this.enterOuterAlt(_localctx, 38);
|
|
{
|
|
this.state = 822;
|
|
this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 823;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 824;
|
|
this.viewName();
|
|
this.state = 826;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AS) {
|
|
{
|
|
this.state = 825;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
}
|
|
|
|
this.state = 828;
|
|
this.query();
|
|
}
|
|
break;
|
|
|
|
case 39:
|
|
this.enterOuterAlt(_localctx, 39);
|
|
{
|
|
this.state = 830;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 833;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OR) {
|
|
{
|
|
this.state = 831;
|
|
this.match(SparkSqlParser.KW_OR);
|
|
this.state = 832;
|
|
this.match(SparkSqlParser.KW_REPLACE);
|
|
}
|
|
}
|
|
|
|
this.state = 836;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_TEMPORARY) {
|
|
{
|
|
this.state = 835;
|
|
this.match(SparkSqlParser.KW_TEMPORARY);
|
|
}
|
|
}
|
|
|
|
this.state = 838;
|
|
this.match(SparkSqlParser.KW_FUNCTION);
|
|
this.state = 840;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 67, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 839;
|
|
this.ifNotExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 842;
|
|
this.functionNameCreate();
|
|
this.state = 843;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 844;
|
|
_localctx._className = this.stringLit();
|
|
this.state = 854;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_USING) {
|
|
{
|
|
this.state = 845;
|
|
this.match(SparkSqlParser.KW_USING);
|
|
this.state = 846;
|
|
this.resource();
|
|
this.state = 851;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 847;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 848;
|
|
this.resource();
|
|
}
|
|
}
|
|
this.state = 853;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 40:
|
|
this.enterOuterAlt(_localctx, 40);
|
|
{
|
|
this.state = 856;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 858;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_TEMPORARY) {
|
|
{
|
|
this.state = 857;
|
|
this.match(SparkSqlParser.KW_TEMPORARY);
|
|
}
|
|
}
|
|
|
|
this.state = 860;
|
|
this.match(SparkSqlParser.KW_FUNCTION);
|
|
this.state = 862;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 71, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 861;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 864;
|
|
this.functionName();
|
|
}
|
|
break;
|
|
|
|
case 41:
|
|
this.enterOuterAlt(_localctx, 41);
|
|
{
|
|
this.state = 865;
|
|
this.match(SparkSqlParser.KW_DECLARE);
|
|
this.state = 868;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 72, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 866;
|
|
this.match(SparkSqlParser.KW_OR);
|
|
this.state = 867;
|
|
this.match(SparkSqlParser.KW_REPLACE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 871;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 73, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 870;
|
|
this.match(SparkSqlParser.KW_VARIABLE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 873;
|
|
this.functionName();
|
|
this.state = 875;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 74, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 874;
|
|
this.dataType();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 878;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.EQ) {
|
|
{
|
|
this.state = 877;
|
|
this.variableDefaultExpression();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 42:
|
|
this.enterOuterAlt(_localctx, 42);
|
|
{
|
|
this.state = 880;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 881;
|
|
this.match(SparkSqlParser.KW_TEMPORARY);
|
|
this.state = 882;
|
|
this.match(SparkSqlParser.KW_VARIABLE);
|
|
this.state = 884;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 76, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 883;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 889;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 77, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 886;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 887;
|
|
this.viewName();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
this.state = 888;
|
|
this.functionName();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 43:
|
|
this.enterOuterAlt(_localctx, 43);
|
|
{
|
|
this.state = 891;
|
|
this.match(SparkSqlParser.KW_EXPLAIN);
|
|
this.state = 893;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_CODEGEN || _la === SparkSqlParser.KW_COST || _la === SparkSqlParser.KW_EXTENDED || _la === SparkSqlParser.KW_FORMATTED || _la === SparkSqlParser.KW_LOGICAL) {
|
|
{
|
|
this.state = 892;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_CODEGEN || _la === SparkSqlParser.KW_COST || _la === SparkSqlParser.KW_EXTENDED || _la === SparkSqlParser.KW_FORMATTED || _la === SparkSqlParser.KW_LOGICAL)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 895;
|
|
this.statement();
|
|
}
|
|
break;
|
|
|
|
case 44:
|
|
this.enterOuterAlt(_localctx, 44);
|
|
{
|
|
this.state = 896;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 897;
|
|
this.match(SparkSqlParser.KW_TABLES);
|
|
this.state = 900;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 79, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 898;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 899;
|
|
this.dbSchemaName();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 906;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 81, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 903;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 80, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 902;
|
|
this.match(SparkSqlParser.KW_LIKE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 905;
|
|
_localctx._pattern = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 45:
|
|
this.enterOuterAlt(_localctx, 45);
|
|
{
|
|
this.state = 908;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 909;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 910;
|
|
this.match(SparkSqlParser.KW_EXTENDED);
|
|
this.state = 913;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN) {
|
|
{
|
|
this.state = 911;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 912;
|
|
_localctx._ns = this.dbSchemaName();
|
|
}
|
|
}
|
|
|
|
this.state = 915;
|
|
this.match(SparkSqlParser.KW_LIKE);
|
|
this.state = 916;
|
|
_localctx._pattern = this.stringLit();
|
|
this.state = 918;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 917;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 46:
|
|
this.enterOuterAlt(_localctx, 46);
|
|
{
|
|
this.state = 920;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 921;
|
|
this.match(SparkSqlParser.KW_TBLPROPERTIES);
|
|
this.state = 922;
|
|
_localctx._table = this.tableName();
|
|
this.state = 927;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 84, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 923;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 924;
|
|
_localctx._key = this.propertyKey();
|
|
this.state = 925;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 47:
|
|
this.enterOuterAlt(_localctx, 47);
|
|
{
|
|
this.state = 929;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 930;
|
|
this.match(SparkSqlParser.KW_COLUMNS);
|
|
this.state = 931;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 932;
|
|
_localctx._table = this.tableName();
|
|
this.state = 935;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 85, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 933;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 934;
|
|
this.multipartIdentifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 48:
|
|
this.enterOuterAlt(_localctx, 48);
|
|
{
|
|
this.state = 937;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 938;
|
|
this.match(SparkSqlParser.KW_VIEWS);
|
|
this.state = 941;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 86, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 939;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 940;
|
|
this.dbSchemaName();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 947;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 88, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 944;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 87, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 943;
|
|
this.match(SparkSqlParser.KW_LIKE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 946;
|
|
_localctx._pattern = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 49:
|
|
this.enterOuterAlt(_localctx, 49);
|
|
{
|
|
this.state = 949;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 950;
|
|
this.match(SparkSqlParser.KW_PARTITIONS);
|
|
this.state = 951;
|
|
this.tableName();
|
|
this.state = 953;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 952;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 50:
|
|
this.enterOuterAlt(_localctx, 50);
|
|
{
|
|
this.state = 955;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 957;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_SYSTEM || _la === SparkSqlParser.KW_USER) {
|
|
{
|
|
this.state = 956;
|
|
this.functionKind();
|
|
}
|
|
}
|
|
|
|
this.state = 959;
|
|
this.match(SparkSqlParser.KW_FUNCTIONS);
|
|
this.state = 962;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 91, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 960;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 961;
|
|
_localctx._ns = this.dbSchemaName();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 971;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 94, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 965;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 92, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 964;
|
|
this.match(SparkSqlParser.KW_LIKE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 969;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 93, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 967;
|
|
_localctx._legacy = this.multipartIdentifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 968;
|
|
_localctx._pattern = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 51:
|
|
this.enterOuterAlt(_localctx, 51);
|
|
{
|
|
this.state = 973;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 974;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 975;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 976;
|
|
this.tableName();
|
|
this.state = 979;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AS) {
|
|
{
|
|
this.state = 977;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 978;
|
|
this.match(SparkSqlParser.KW_SERDE);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 52:
|
|
this.enterOuterAlt(_localctx, 52);
|
|
{
|
|
this.state = 981;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 982;
|
|
this.match(SparkSqlParser.KW_CURRENT);
|
|
this.state = 983;
|
|
this.dbSchema();
|
|
}
|
|
break;
|
|
|
|
case 53:
|
|
this.enterOuterAlt(_localctx, 53);
|
|
{
|
|
this.state = 984;
|
|
this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 985;
|
|
this.match(SparkSqlParser.KW_CATALOGS);
|
|
this.state = 990;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 97, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 987;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 96, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 986;
|
|
this.match(SparkSqlParser.KW_LIKE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 989;
|
|
_localctx._pattern = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 54:
|
|
this.enterOuterAlt(_localctx, 54);
|
|
{
|
|
this.state = 992;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 993;
|
|
this.match(SparkSqlParser.KW_FUNCTION);
|
|
this.state = 995;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 98, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 994;
|
|
this.match(SparkSqlParser.KW_EXTENDED);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 997;
|
|
this.describeFuncName();
|
|
}
|
|
break;
|
|
|
|
case 55:
|
|
this.enterOuterAlt(_localctx, 55);
|
|
{
|
|
this.state = 998;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 999;
|
|
this.match(SparkSqlParser.KW_DATABASE);
|
|
this.state = 1001;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 99, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1000;
|
|
this.match(SparkSqlParser.KW_EXTENDED);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1003;
|
|
this.dbSchemaName();
|
|
}
|
|
break;
|
|
|
|
case 56:
|
|
this.enterOuterAlt(_localctx, 56);
|
|
{
|
|
this.state = 1004;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1006;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 100, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1005;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1009;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 101, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1008;
|
|
_localctx._option = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_EXTENDED || _la === SparkSqlParser.KW_FORMATTED)) {
|
|
_localctx._option = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1011;
|
|
this.tableName();
|
|
this.state = 1013;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 102, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1012;
|
|
this.partitionSpec();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1016;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 103, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1015;
|
|
this.describeColName();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 57:
|
|
this.enterOuterAlt(_localctx, 57);
|
|
{
|
|
this.state = 1018;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1020;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_QUERY) {
|
|
{
|
|
this.state = 1019;
|
|
this.match(SparkSqlParser.KW_QUERY);
|
|
}
|
|
}
|
|
|
|
this.state = 1022;
|
|
this.query();
|
|
}
|
|
break;
|
|
|
|
case 58:
|
|
this.enterOuterAlt(_localctx, 58);
|
|
{
|
|
this.state = 1023;
|
|
this.match(SparkSqlParser.KW_COMMENT);
|
|
this.state = 1024;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 1025;
|
|
this.dbSchema();
|
|
this.state = 1026;
|
|
this.dbSchemaName();
|
|
this.state = 1027;
|
|
this.match(SparkSqlParser.KW_IS);
|
|
this.state = 1028;
|
|
this.comment();
|
|
}
|
|
break;
|
|
|
|
case 59:
|
|
this.enterOuterAlt(_localctx, 59);
|
|
{
|
|
this.state = 1030;
|
|
this.match(SparkSqlParser.KW_COMMENT);
|
|
this.state = 1031;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 1032;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1033;
|
|
this.tableName();
|
|
this.state = 1034;
|
|
this.match(SparkSqlParser.KW_IS);
|
|
this.state = 1035;
|
|
this.comment();
|
|
}
|
|
break;
|
|
|
|
case 60:
|
|
this.enterOuterAlt(_localctx, 60);
|
|
{
|
|
this.state = 1037;
|
|
this.match(SparkSqlParser.KW_REFRESH);
|
|
this.state = 1038;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1039;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
|
|
case 61:
|
|
this.enterOuterAlt(_localctx, 61);
|
|
{
|
|
this.state = 1040;
|
|
this.match(SparkSqlParser.KW_REFRESH);
|
|
this.state = 1041;
|
|
this.match(SparkSqlParser.KW_FUNCTION);
|
|
this.state = 1042;
|
|
this.functionName();
|
|
}
|
|
break;
|
|
|
|
case 62:
|
|
this.enterOuterAlt(_localctx, 62);
|
|
{
|
|
this.state = 1043;
|
|
this.match(SparkSqlParser.KW_REFRESH);
|
|
this.state = 1051;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 106, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1044;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 1048;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 105, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1045;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1050;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 105, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 63:
|
|
this.enterOuterAlt(_localctx, 63);
|
|
{
|
|
this.state = 1053;
|
|
this.match(SparkSqlParser.KW_CACHE);
|
|
this.state = 1055;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_LAZY) {
|
|
{
|
|
this.state = 1054;
|
|
this.match(SparkSqlParser.KW_LAZY);
|
|
}
|
|
}
|
|
|
|
this.state = 1057;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1058;
|
|
this.tableName();
|
|
this.state = 1061;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OPTIONS) {
|
|
{
|
|
this.state = 1059;
|
|
this.match(SparkSqlParser.KW_OPTIONS);
|
|
this.state = 1060;
|
|
_localctx._options = this.propertyList();
|
|
}
|
|
}
|
|
|
|
this.state = 1067;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 110, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1064;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AS) {
|
|
{
|
|
this.state = 1063;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
}
|
|
|
|
this.state = 1066;
|
|
this.query();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 64:
|
|
this.enterOuterAlt(_localctx, 64);
|
|
{
|
|
this.state = 1069;
|
|
this.match(SparkSqlParser.KW_UNCACHE);
|
|
this.state = 1070;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1072;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 111, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1071;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1074;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
|
|
case 65:
|
|
this.enterOuterAlt(_localctx, 65);
|
|
{
|
|
this.state = 1075;
|
|
this.match(SparkSqlParser.KW_CLEAR);
|
|
this.state = 1076;
|
|
this.match(SparkSqlParser.KW_CACHE);
|
|
}
|
|
break;
|
|
|
|
case 66:
|
|
this.enterOuterAlt(_localctx, 66);
|
|
{
|
|
this.state = 1077;
|
|
this.match(SparkSqlParser.KW_LOAD);
|
|
this.state = 1078;
|
|
this.match(SparkSqlParser.KW_DATA);
|
|
this.state = 1080;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_LOCAL) {
|
|
{
|
|
this.state = 1079;
|
|
this.match(SparkSqlParser.KW_LOCAL);
|
|
}
|
|
}
|
|
|
|
this.state = 1082;
|
|
this.match(SparkSqlParser.KW_INPATH);
|
|
this.state = 1083;
|
|
_localctx._path = this.stringLit();
|
|
this.state = 1085;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OVERWRITE) {
|
|
{
|
|
this.state = 1084;
|
|
this.match(SparkSqlParser.KW_OVERWRITE);
|
|
}
|
|
}
|
|
|
|
this.state = 1087;
|
|
this.match(SparkSqlParser.KW_INTO);
|
|
this.state = 1088;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1089;
|
|
this.tableName();
|
|
this.state = 1091;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1090;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 67:
|
|
this.enterOuterAlt(_localctx, 67);
|
|
{
|
|
this.state = 1093;
|
|
this.match(SparkSqlParser.KW_TRUNCATE);
|
|
this.state = 1094;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1095;
|
|
this.tableName();
|
|
this.state = 1097;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1096;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 68:
|
|
this.enterOuterAlt(_localctx, 68);
|
|
{
|
|
this.state = 1100;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_MSCK) {
|
|
{
|
|
this.state = 1099;
|
|
this.match(SparkSqlParser.KW_MSCK);
|
|
}
|
|
}
|
|
|
|
this.state = 1102;
|
|
this.match(SparkSqlParser.KW_REPAIR);
|
|
this.state = 1103;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1104;
|
|
this.tableName();
|
|
this.state = 1107;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 117, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1105;
|
|
_localctx._option = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ADD || _la === SparkSqlParser.KW_DROP || _la === SparkSqlParser.KW_SYNC)) {
|
|
_localctx._option = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1106;
|
|
this.match(SparkSqlParser.KW_PARTITIONS);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 69:
|
|
this.enterOuterAlt(_localctx, 69);
|
|
{
|
|
this.state = 1109;
|
|
_localctx._op = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ADD || _la === SparkSqlParser.KW_LIST)) {
|
|
_localctx._op = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1110;
|
|
this.identifier();
|
|
this.state = 1114;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 118, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1111;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1116;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 118, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 70:
|
|
this.enterOuterAlt(_localctx, 70);
|
|
{
|
|
this.state = 1117;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1118;
|
|
this.match(SparkSqlParser.KW_ROLE);
|
|
this.state = 1122;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 119, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1119;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1124;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 119, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 71:
|
|
this.enterOuterAlt(_localctx, 71);
|
|
{
|
|
this.state = 1125;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1126;
|
|
this.match(SparkSqlParser.KW_TIME);
|
|
this.state = 1127;
|
|
this.match(SparkSqlParser.KW_ZONE);
|
|
this.state = 1128;
|
|
this.interval();
|
|
}
|
|
break;
|
|
|
|
case 72:
|
|
this.enterOuterAlt(_localctx, 72);
|
|
{
|
|
this.state = 1129;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1130;
|
|
this.match(SparkSqlParser.KW_TIME);
|
|
this.state = 1131;
|
|
this.match(SparkSqlParser.KW_ZONE);
|
|
this.state = 1132;
|
|
this.timezone();
|
|
}
|
|
break;
|
|
|
|
case 73:
|
|
this.enterOuterAlt(_localctx, 73);
|
|
{
|
|
this.state = 1133;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1134;
|
|
this.match(SparkSqlParser.KW_TIME);
|
|
this.state = 1135;
|
|
this.match(SparkSqlParser.KW_ZONE);
|
|
this.state = 1139;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 120, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1136;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1141;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 120, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 74:
|
|
this.enterOuterAlt(_localctx, 74);
|
|
{
|
|
this.state = 1142;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1143;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_VAR || _la === SparkSqlParser.KW_VARIABLE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1144;
|
|
this.assignmentList();
|
|
}
|
|
break;
|
|
|
|
case 75:
|
|
this.enterOuterAlt(_localctx, 75);
|
|
{
|
|
this.state = 1145;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1146;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_VAR || _la === SparkSqlParser.KW_VARIABLE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1147;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1148;
|
|
this.multipartIdentifierList();
|
|
this.state = 1149;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 1150;
|
|
this.match(SparkSqlParser.EQ);
|
|
this.state = 1151;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1152;
|
|
this.query();
|
|
this.state = 1153;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 76:
|
|
this.enterOuterAlt(_localctx, 76);
|
|
{
|
|
this.state = 1155;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1156;
|
|
this.configKey();
|
|
this.state = 1157;
|
|
this.match(SparkSqlParser.EQ);
|
|
this.state = 1158;
|
|
this.configValue();
|
|
}
|
|
break;
|
|
|
|
case 77:
|
|
this.enterOuterAlt(_localctx, 77);
|
|
{
|
|
this.state = 1160;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1161;
|
|
this.configKey();
|
|
this.state = 1169;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.EQ) {
|
|
{
|
|
this.state = 1162;
|
|
this.match(SparkSqlParser.EQ);
|
|
this.state = 1166;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 121, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1163;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1168;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 121, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 78:
|
|
this.enterOuterAlt(_localctx, 78);
|
|
{
|
|
this.state = 1171;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1175;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 123, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1172;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1177;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 123, this._ctx);
|
|
}
|
|
this.state = 1178;
|
|
this.match(SparkSqlParser.EQ);
|
|
this.state = 1179;
|
|
this.configValue();
|
|
}
|
|
break;
|
|
|
|
case 79:
|
|
this.enterOuterAlt(_localctx, 79);
|
|
{
|
|
this.state = 1180;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1184;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 124, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1181;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1186;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 124, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 80:
|
|
this.enterOuterAlt(_localctx, 80);
|
|
{
|
|
this.state = 1187;
|
|
this.match(SparkSqlParser.KW_RESET);
|
|
this.state = 1188;
|
|
this.configKey();
|
|
}
|
|
break;
|
|
|
|
case 81:
|
|
this.enterOuterAlt(_localctx, 81);
|
|
{
|
|
this.state = 1189;
|
|
this.match(SparkSqlParser.KW_RESET);
|
|
this.state = 1193;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 125, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1190;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1195;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 125, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 82:
|
|
this.enterOuterAlt(_localctx, 82);
|
|
{
|
|
this.state = 1196;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 1197;
|
|
this.match(SparkSqlParser.KW_INDEX);
|
|
this.state = 1199;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 126, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1198;
|
|
this.ifNotExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1201;
|
|
this.identifier();
|
|
this.state = 1202;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 1204;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 127, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1203;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1206;
|
|
this.tableName();
|
|
this.state = 1209;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_USING) {
|
|
{
|
|
this.state = 1207;
|
|
this.match(SparkSqlParser.KW_USING);
|
|
this.state = 1208;
|
|
_localctx._indexType = this.identifier();
|
|
}
|
|
}
|
|
|
|
this.state = 1211;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1212;
|
|
this.multipartIdentifierPropertyList();
|
|
this.state = 1213;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 1216;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OPTIONS) {
|
|
{
|
|
this.state = 1214;
|
|
this.match(SparkSqlParser.KW_OPTIONS);
|
|
this.state = 1215;
|
|
_localctx._options = this.propertyList();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 83:
|
|
this.enterOuterAlt(_localctx, 83);
|
|
{
|
|
this.state = 1218;
|
|
this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 1219;
|
|
this.match(SparkSqlParser.KW_INDEX);
|
|
this.state = 1221;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 130, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1220;
|
|
this.ifExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1223;
|
|
this.identifier();
|
|
this.state = 1224;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 1226;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 131, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1225;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1228;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
|
|
case 84:
|
|
this.enterOuterAlt(_localctx, 84);
|
|
{
|
|
this.state = 1230;
|
|
this.unsupportedHiveNativeCommands();
|
|
this.state = 1234;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 132, this._ctx);
|
|
while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1 + 1) {
|
|
{
|
|
{
|
|
this.state = 1231;
|
|
this.matchWildcard();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1236;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 132, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public timezone(): TimezoneContext {
|
|
let _localctx: TimezoneContext = new TimezoneContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 6, SparkSqlParser.RULE_timezone);
|
|
try {
|
|
this.state = 1241;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 134, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1239;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1240;
|
|
this.match(SparkSqlParser.KW_LOCAL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public configKey(): ConfigKeyContext {
|
|
let _localctx: ConfigKeyContext = new ConfigKeyContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 8, SparkSqlParser.RULE_configKey);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1243;
|
|
this.quotedIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public configValue(): ConfigValueContext {
|
|
let _localctx: ConfigValueContext = new ConfigValueContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 10, SparkSqlParser.RULE_configValue);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1245;
|
|
this.backQuotedIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext {
|
|
let _localctx: UnsupportedHiveNativeCommandsContext = new UnsupportedHiveNativeCommandsContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 12, SparkSqlParser.RULE_unsupportedHiveNativeCommands);
|
|
let _la: number;
|
|
try {
|
|
this.state = 1415;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 142, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1247;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 1248;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1249;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 1250;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 1251;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_GRANT);
|
|
this.state = 1253;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 135, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1252;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 1255;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_REVOKE);
|
|
this.state = 1257;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 136, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1256;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 1259;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1260;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_GRANT);
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 1261;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1262;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
|
|
this.state = 1264;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 137, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1263;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_GRANT);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 1266;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1267;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_PRINCIPALS);
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
this.enterOuterAlt(_localctx, 8);
|
|
{
|
|
this.state = 1268;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1269;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_ROLES);
|
|
}
|
|
break;
|
|
|
|
case 9:
|
|
this.enterOuterAlt(_localctx, 9);
|
|
{
|
|
this.state = 1270;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1271;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_CURRENT);
|
|
this.state = 1272;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_ROLES);
|
|
}
|
|
break;
|
|
|
|
case 10:
|
|
this.enterOuterAlt(_localctx, 10);
|
|
{
|
|
this.state = 1273;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_EXPORT);
|
|
this.state = 1274;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
|
|
case 11:
|
|
this.enterOuterAlt(_localctx, 11);
|
|
{
|
|
this.state = 1275;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_IMPORT);
|
|
this.state = 1276;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
|
|
case 12:
|
|
this.enterOuterAlt(_localctx, 12);
|
|
{
|
|
this.state = 1277;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1278;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_COMPACTIONS);
|
|
}
|
|
break;
|
|
|
|
case 13:
|
|
this.enterOuterAlt(_localctx, 13);
|
|
{
|
|
this.state = 1279;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1280;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 1281;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
|
|
case 14:
|
|
this.enterOuterAlt(_localctx, 14);
|
|
{
|
|
this.state = 1282;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1283;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TRANSACTIONS);
|
|
}
|
|
break;
|
|
|
|
case 15:
|
|
this.enterOuterAlt(_localctx, 15);
|
|
{
|
|
this.state = 1284;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1285;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_INDEXES);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
this.enterOuterAlt(_localctx, 16);
|
|
{
|
|
this.state = 1286;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
|
|
this.state = 1287;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_LOCKS);
|
|
}
|
|
break;
|
|
|
|
case 17:
|
|
this.enterOuterAlt(_localctx, 17);
|
|
{
|
|
this.state = 1288;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 1289;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_INDEX);
|
|
}
|
|
break;
|
|
|
|
case 18:
|
|
this.enterOuterAlt(_localctx, 18);
|
|
{
|
|
this.state = 1290;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 1291;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_INDEX);
|
|
}
|
|
break;
|
|
|
|
case 19:
|
|
this.enterOuterAlt(_localctx, 19);
|
|
{
|
|
this.state = 1292;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1293;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_INDEX);
|
|
}
|
|
break;
|
|
|
|
case 20:
|
|
this.enterOuterAlt(_localctx, 20);
|
|
{
|
|
this.state = 1294;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_LOCK);
|
|
this.state = 1295;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
|
|
case 21:
|
|
this.enterOuterAlt(_localctx, 21);
|
|
{
|
|
this.state = 1296;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_LOCK);
|
|
this.state = 1297;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_DATABASE);
|
|
}
|
|
break;
|
|
|
|
case 22:
|
|
this.enterOuterAlt(_localctx, 22);
|
|
{
|
|
this.state = 1298;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_UNLOCK);
|
|
this.state = 1299;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
|
|
case 23:
|
|
this.enterOuterAlt(_localctx, 23);
|
|
{
|
|
this.state = 1300;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_UNLOCK);
|
|
this.state = 1301;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_DATABASE);
|
|
}
|
|
break;
|
|
|
|
case 24:
|
|
this.enterOuterAlt(_localctx, 24);
|
|
{
|
|
this.state = 1302;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 1303;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TEMPORARY);
|
|
this.state = 1304;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_MACRO);
|
|
}
|
|
break;
|
|
|
|
case 25:
|
|
this.enterOuterAlt(_localctx, 25);
|
|
{
|
|
this.state = 1305;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 1306;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TEMPORARY);
|
|
this.state = 1307;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_MACRO);
|
|
}
|
|
break;
|
|
|
|
case 26:
|
|
this.enterOuterAlt(_localctx, 26);
|
|
{
|
|
this.state = 1308;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1309;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1310;
|
|
this.tableName();
|
|
this.state = 1311;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 1312;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_CLUSTERED);
|
|
}
|
|
break;
|
|
|
|
case 27:
|
|
this.enterOuterAlt(_localctx, 27);
|
|
{
|
|
this.state = 1314;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1315;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1316;
|
|
this.tableName();
|
|
this.state = 1317;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_CLUSTERED);
|
|
this.state = 1318;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_BY);
|
|
}
|
|
break;
|
|
|
|
case 28:
|
|
this.enterOuterAlt(_localctx, 28);
|
|
{
|
|
this.state = 1320;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1321;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1322;
|
|
this.tableName();
|
|
this.state = 1323;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 1324;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_SORTED);
|
|
}
|
|
break;
|
|
|
|
case 29:
|
|
this.enterOuterAlt(_localctx, 29);
|
|
{
|
|
this.state = 1326;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1327;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1328;
|
|
this.tableName();
|
|
this.state = 1329;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_SKEWED);
|
|
this.state = 1330;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_BY);
|
|
}
|
|
break;
|
|
|
|
case 30:
|
|
this.enterOuterAlt(_localctx, 30);
|
|
{
|
|
this.state = 1332;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1333;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1334;
|
|
this.tableName();
|
|
this.state = 1335;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 1336;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_SKEWED);
|
|
}
|
|
break;
|
|
|
|
case 31:
|
|
this.enterOuterAlt(_localctx, 31);
|
|
{
|
|
this.state = 1338;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1339;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1340;
|
|
this.tableName();
|
|
this.state = 1341;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 1342;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_STORED);
|
|
this.state = 1343;
|
|
_localctx._kw5 = this.match(SparkSqlParser.KW_AS);
|
|
this.state = 1344;
|
|
_localctx._kw6 = this.match(SparkSqlParser.KW_DIRECTORIES);
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
this.enterOuterAlt(_localctx, 32);
|
|
{
|
|
this.state = 1346;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1347;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1348;
|
|
this.tableName();
|
|
this.state = 1349;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1350;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_SKEWED);
|
|
this.state = 1351;
|
|
_localctx._kw5 = this.match(SparkSqlParser.KW_LOCATION);
|
|
}
|
|
break;
|
|
|
|
case 33:
|
|
this.enterOuterAlt(_localctx, 33);
|
|
{
|
|
this.state = 1353;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1354;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1355;
|
|
this.tableName();
|
|
this.state = 1356;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_EXCHANGE);
|
|
this.state = 1357;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
|
|
}
|
|
break;
|
|
|
|
case 34:
|
|
this.enterOuterAlt(_localctx, 34);
|
|
{
|
|
this.state = 1359;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1360;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1361;
|
|
this.tableName();
|
|
this.state = 1362;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_ARCHIVE);
|
|
this.state = 1363;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
|
|
}
|
|
break;
|
|
|
|
case 35:
|
|
this.enterOuterAlt(_localctx, 35);
|
|
{
|
|
this.state = 1365;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1366;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1367;
|
|
this.tableName();
|
|
this.state = 1368;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_UNARCHIVE);
|
|
this.state = 1369;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
|
|
}
|
|
break;
|
|
|
|
case 36:
|
|
this.enterOuterAlt(_localctx, 36);
|
|
{
|
|
this.state = 1371;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1372;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1373;
|
|
this.tableName();
|
|
this.state = 1374;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_TOUCH);
|
|
}
|
|
break;
|
|
|
|
case 37:
|
|
this.enterOuterAlt(_localctx, 37);
|
|
{
|
|
this.state = 1376;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1377;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1378;
|
|
this.tableName();
|
|
this.state = 1380;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1379;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 1382;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_COMPACT);
|
|
}
|
|
break;
|
|
|
|
case 38:
|
|
this.enterOuterAlt(_localctx, 38);
|
|
{
|
|
this.state = 1384;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1385;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1386;
|
|
this.tableName();
|
|
this.state = 1388;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1387;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 1390;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_CONCATENATE);
|
|
}
|
|
break;
|
|
|
|
case 39:
|
|
this.enterOuterAlt(_localctx, 39);
|
|
{
|
|
this.state = 1392;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1393;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1394;
|
|
this.tableName();
|
|
this.state = 1396;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1395;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 1398;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_SET);
|
|
this.state = 1399;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_FILEFORMAT);
|
|
}
|
|
break;
|
|
|
|
case 40:
|
|
this.enterOuterAlt(_localctx, 40);
|
|
{
|
|
this.state = 1401;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
|
|
this.state = 1402;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1403;
|
|
this.tableName();
|
|
this.state = 1405;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1404;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 1407;
|
|
_localctx._kw3 = this.match(SparkSqlParser.KW_REPLACE);
|
|
this.state = 1408;
|
|
_localctx._kw4 = this.match(SparkSqlParser.KW_COLUMNS);
|
|
}
|
|
break;
|
|
|
|
case 41:
|
|
this.enterOuterAlt(_localctx, 41);
|
|
{
|
|
this.state = 1410;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_START);
|
|
this.state = 1411;
|
|
_localctx._kw2 = this.match(SparkSqlParser.KW_TRANSACTION);
|
|
}
|
|
break;
|
|
|
|
case 42:
|
|
this.enterOuterAlt(_localctx, 42);
|
|
{
|
|
this.state = 1412;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_COMMIT);
|
|
}
|
|
break;
|
|
|
|
case 43:
|
|
this.enterOuterAlt(_localctx, 43);
|
|
{
|
|
this.state = 1413;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_ROLLBACK);
|
|
}
|
|
break;
|
|
|
|
case 44:
|
|
this.enterOuterAlt(_localctx, 44);
|
|
{
|
|
this.state = 1414;
|
|
_localctx._kw1 = this.match(SparkSqlParser.KW_DFS);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public createTableHeader(): CreateTableHeaderContext {
|
|
let _localctx: CreateTableHeaderContext = new CreateTableHeaderContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 14, SparkSqlParser.RULE_createTableHeader);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1417;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 1419;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_TEMPORARY) {
|
|
{
|
|
this.state = 1418;
|
|
this.match(SparkSqlParser.KW_TEMPORARY);
|
|
}
|
|
}
|
|
|
|
this.state = 1422;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_EXTERNAL) {
|
|
{
|
|
this.state = 1421;
|
|
this.match(SparkSqlParser.KW_EXTERNAL);
|
|
}
|
|
}
|
|
|
|
this.state = 1424;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1426;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 145, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1425;
|
|
this.ifNotExists();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1428;
|
|
this.tableNameCreate();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public replaceTableHeader(): ReplaceTableHeaderContext {
|
|
let _localctx: ReplaceTableHeaderContext = new ReplaceTableHeaderContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 16, SparkSqlParser.RULE_replaceTableHeader);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1432;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_CREATE) {
|
|
{
|
|
this.state = 1430;
|
|
this.match(SparkSqlParser.KW_CREATE);
|
|
this.state = 1431;
|
|
this.match(SparkSqlParser.KW_OR);
|
|
}
|
|
}
|
|
|
|
this.state = 1434;
|
|
this.match(SparkSqlParser.KW_REPLACE);
|
|
this.state = 1435;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1436;
|
|
this.tableNameCreate();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public bucketSpec(): BucketSpecContext {
|
|
let _localctx: BucketSpecContext = new BucketSpecContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 18, SparkSqlParser.RULE_bucketSpec);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1438;
|
|
this.match(SparkSqlParser.KW_CLUSTERED);
|
|
this.state = 1439;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1440;
|
|
this.identifierList();
|
|
this.state = 1444;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_SORTED) {
|
|
{
|
|
this.state = 1441;
|
|
this.match(SparkSqlParser.KW_SORTED);
|
|
this.state = 1442;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1443;
|
|
this.orderedIdentifierList();
|
|
}
|
|
}
|
|
|
|
this.state = 1446;
|
|
this.match(SparkSqlParser.KW_INTO);
|
|
this.state = 1447;
|
|
this.match(SparkSqlParser.INTEGER_VALUE);
|
|
this.state = 1448;
|
|
this.match(SparkSqlParser.KW_BUCKETS);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public skewSpec(): SkewSpecContext {
|
|
let _localctx: SkewSpecContext = new SkewSpecContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 20, SparkSqlParser.RULE_skewSpec);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1450;
|
|
this.match(SparkSqlParser.KW_SKEWED);
|
|
this.state = 1451;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1452;
|
|
this.identifierList();
|
|
this.state = 1453;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 1456;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 148, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1454;
|
|
this.constantList();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 1455;
|
|
this.nestedConstantList();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1461;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 149, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1458;
|
|
this.match(SparkSqlParser.KW_STORED);
|
|
this.state = 1459;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 1460;
|
|
this.match(SparkSqlParser.KW_DIRECTORIES);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public locationSpec(): LocationSpecContext {
|
|
let _localctx: LocationSpecContext = new LocationSpecContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 22, SparkSqlParser.RULE_locationSpec);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1463;
|
|
this.match(SparkSqlParser.KW_LOCATION);
|
|
this.state = 1464;
|
|
this.stringLit();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public commentSpec(): CommentSpecContext {
|
|
let _localctx: CommentSpecContext = new CommentSpecContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 24, SparkSqlParser.RULE_commentSpec);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1466;
|
|
this.match(SparkSqlParser.KW_COMMENT);
|
|
this.state = 1467;
|
|
this.stringLit();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public query(): QueryContext {
|
|
let _localctx: QueryContext = new QueryContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 26, SparkSqlParser.RULE_query);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1470;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_WITH) {
|
|
{
|
|
this.state = 1469;
|
|
this.ctes();
|
|
}
|
|
}
|
|
|
|
this.state = 1472;
|
|
this.queryTerm(0);
|
|
this.state = 1473;
|
|
this.queryOrganization();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public insertInto(): InsertIntoContext {
|
|
let _localctx: InsertIntoContext = new InsertIntoContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 28, SparkSqlParser.RULE_insertInto);
|
|
let _la: number;
|
|
try {
|
|
this.state = 1545;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 166, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1475;
|
|
this.match(SparkSqlParser.KW_INSERT);
|
|
this.state = 1476;
|
|
this.match(SparkSqlParser.KW_OVERWRITE);
|
|
this.state = 1478;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 151, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1477;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1480;
|
|
this.tableName();
|
|
this.state = 1485;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1481;
|
|
this.partitionSpec();
|
|
this.state = 1483;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IF) {
|
|
{
|
|
this.state = 1482;
|
|
this.ifNotExists();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
this.state = 1490;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 154, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 1487;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1488;
|
|
this.match(SparkSqlParser.KW_NAME);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 1489;
|
|
this.identifierList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1492;
|
|
this.match(SparkSqlParser.KW_INSERT);
|
|
this.state = 1493;
|
|
this.match(SparkSqlParser.KW_INTO);
|
|
this.state = 1495;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 155, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1494;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1497;
|
|
this.tableName();
|
|
this.state = 1499;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 1498;
|
|
this.partitionSpec();
|
|
}
|
|
}
|
|
|
|
this.state = 1502;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IF) {
|
|
{
|
|
this.state = 1501;
|
|
this.ifNotExists();
|
|
}
|
|
}
|
|
|
|
this.state = 1507;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 158, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 1504;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1505;
|
|
this.match(SparkSqlParser.KW_NAME);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 1506;
|
|
this.identifierList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 1509;
|
|
this.match(SparkSqlParser.KW_INSERT);
|
|
this.state = 1510;
|
|
this.match(SparkSqlParser.KW_INTO);
|
|
this.state = 1512;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 159, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1511;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1514;
|
|
this.tableName();
|
|
this.state = 1515;
|
|
this.match(SparkSqlParser.KW_REPLACE);
|
|
this.state = 1516;
|
|
this.whereClause();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 1518;
|
|
this.match(SparkSqlParser.KW_INSERT);
|
|
this.state = 1519;
|
|
this.match(SparkSqlParser.KW_OVERWRITE);
|
|
this.state = 1521;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_LOCAL) {
|
|
{
|
|
this.state = 1520;
|
|
this.match(SparkSqlParser.KW_LOCAL);
|
|
}
|
|
}
|
|
|
|
this.state = 1523;
|
|
this.match(SparkSqlParser.KW_DIRECTORY);
|
|
this.state = 1524;
|
|
_localctx._path = this.stringLit();
|
|
this.state = 1526;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ROW) {
|
|
{
|
|
this.state = 1525;
|
|
this.rowFormat();
|
|
}
|
|
}
|
|
|
|
this.state = 1529;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_STORED) {
|
|
{
|
|
this.state = 1528;
|
|
this.createFileFormat();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 1531;
|
|
this.match(SparkSqlParser.KW_INSERT);
|
|
this.state = 1532;
|
|
this.match(SparkSqlParser.KW_OVERWRITE);
|
|
this.state = 1534;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_LOCAL) {
|
|
{
|
|
this.state = 1533;
|
|
this.match(SparkSqlParser.KW_LOCAL);
|
|
}
|
|
}
|
|
|
|
this.state = 1536;
|
|
this.match(SparkSqlParser.KW_DIRECTORY);
|
|
this.state = 1538;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 164, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1537;
|
|
_localctx._path = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1540;
|
|
this.tableProvider();
|
|
this.state = 1543;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OPTIONS) {
|
|
{
|
|
this.state = 1541;
|
|
this.match(SparkSqlParser.KW_OPTIONS);
|
|
this.state = 1542;
|
|
_localctx._options = this.propertyList();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public partitionSpecLocation(): PartitionSpecLocationContext {
|
|
let _localctx: PartitionSpecLocationContext = new PartitionSpecLocationContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 30, SparkSqlParser.RULE_partitionSpecLocation);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1547;
|
|
this.partitionSpec();
|
|
this.state = 1549;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_LOCATION) {
|
|
{
|
|
this.state = 1548;
|
|
this.locationSpec();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public partitionSpec(): PartitionSpecContext {
|
|
let _localctx: PartitionSpecContext = new PartitionSpecContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 32, SparkSqlParser.RULE_partitionSpec);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1551;
|
|
this.match(SparkSqlParser.KW_PARTITION);
|
|
this.state = 1552;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1553;
|
|
this.partitionVal();
|
|
this.state = 1558;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 1554;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1555;
|
|
this.partitionVal();
|
|
}
|
|
}
|
|
this.state = 1560;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 1561;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public partitionVal(): PartitionValContext {
|
|
let _localctx: PartitionValContext = new PartitionValContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 34, SparkSqlParser.RULE_partitionVal);
|
|
let _la: number;
|
|
try {
|
|
this.state = 1572;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 170, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1563;
|
|
this.identifier();
|
|
this.state = 1566;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.EQ) {
|
|
{
|
|
this.state = 1564;
|
|
this.match(SparkSqlParser.EQ);
|
|
this.state = 1565;
|
|
this.constant();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1568;
|
|
this.identifier();
|
|
this.state = 1569;
|
|
this.match(SparkSqlParser.EQ);
|
|
this.state = 1570;
|
|
this.match(SparkSqlParser.KW_DEFAULT);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public dbSchema(): DbSchemaContext {
|
|
let _localctx: DbSchemaContext = new DbSchemaContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 36, SparkSqlParser.RULE_dbSchema);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1574;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DATABASE || _la === SparkSqlParser.KW_NAMESPACE || _la === SparkSqlParser.KW_SCHEMA)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public dbSchemas(): DbSchemasContext {
|
|
let _localctx: DbSchemasContext = new DbSchemasContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 38, SparkSqlParser.RULE_dbSchemas);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1576;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DATABASES || _la === SparkSqlParser.KW_NAMESPACES || _la === SparkSqlParser.KW_SCHEMAS)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public describeFuncName(): DescribeFuncNameContext {
|
|
let _localctx: DescribeFuncNameContext = new DescribeFuncNameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 40, SparkSqlParser.RULE_describeFuncName);
|
|
try {
|
|
this.state = 1583;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 171, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1578;
|
|
this.identifierReference();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1579;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 1580;
|
|
this.comparisonOperator();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 1581;
|
|
this.arithmeticOperator();
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 1582;
|
|
this.predicateOperator();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public describeColName(): DescribeColNameContext {
|
|
let _localctx: DescribeColNameContext = new DescribeColNameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 42, SparkSqlParser.RULE_describeColName);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1585;
|
|
_localctx._identifier = this.identifier();
|
|
_localctx._nameParts.push(_localctx._identifier);
|
|
this.state = 1590;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.DOT) {
|
|
{
|
|
{
|
|
this.state = 1586;
|
|
this.match(SparkSqlParser.DOT);
|
|
this.state = 1587;
|
|
_localctx._identifier = this.identifier();
|
|
_localctx._nameParts.push(_localctx._identifier);
|
|
}
|
|
}
|
|
this.state = 1592;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public ctes(): CtesContext {
|
|
let _localctx: CtesContext = new CtesContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 44, SparkSqlParser.RULE_ctes);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1593;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 1594;
|
|
this.namedQuery();
|
|
this.state = 1599;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 1595;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1596;
|
|
this.namedQuery();
|
|
}
|
|
}
|
|
this.state = 1601;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public namedQuery(): NamedQueryContext {
|
|
let _localctx: NamedQueryContext = new NamedQueryContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 46, SparkSqlParser.RULE_namedQuery);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1602;
|
|
_localctx._name = this.errorCapturingIdentifier();
|
|
this.state = 1604;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 174, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1603;
|
|
_localctx._columnAliases = this.identifierList();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1607;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AS) {
|
|
{
|
|
this.state = 1606;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
}
|
|
|
|
this.state = 1609;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1610;
|
|
this.query();
|
|
this.state = 1611;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public tableProvider(): TableProviderContext {
|
|
let _localctx: TableProviderContext = new TableProviderContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 48, SparkSqlParser.RULE_tableProvider);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1613;
|
|
this.match(SparkSqlParser.KW_USING);
|
|
this.state = 1614;
|
|
this.multipartIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public createTableClauses(): CreateTableClausesContext {
|
|
let _localctx: CreateTableClausesContext = new CreateTableClausesContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 50, SparkSqlParser.RULE_createTableClauses);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1631;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 177, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
this.state = 1629;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_OPTIONS:
|
|
{
|
|
{
|
|
this.state = 1616;
|
|
this.match(SparkSqlParser.KW_OPTIONS);
|
|
this.state = 1617;
|
|
_localctx._options = this.expressionPropertyList();
|
|
}
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_PARTITIONED:
|
|
{
|
|
{
|
|
this.state = 1618;
|
|
this.match(SparkSqlParser.KW_PARTITIONED);
|
|
this.state = 1619;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1620;
|
|
_localctx._partitioning = this.partitionFieldList();
|
|
}
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_SKEWED:
|
|
{
|
|
this.state = 1621;
|
|
this.skewSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_CLUSTERED:
|
|
{
|
|
this.state = 1622;
|
|
this.bucketSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_ROW:
|
|
{
|
|
this.state = 1623;
|
|
this.rowFormat();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_STORED:
|
|
{
|
|
this.state = 1624;
|
|
this.createFileFormat();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_LOCATION:
|
|
{
|
|
this.state = 1625;
|
|
this.locationSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_COMMENT:
|
|
{
|
|
this.state = 1626;
|
|
this.commentSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_TBLPROPERTIES:
|
|
{
|
|
{
|
|
this.state = 1627;
|
|
this.match(SparkSqlParser.KW_TBLPROPERTIES);
|
|
this.state = 1628;
|
|
_localctx._tableProps = this.propertyList();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
}
|
|
this.state = 1633;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 177, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public propertyList(): PropertyListContext {
|
|
let _localctx: PropertyListContext = new PropertyListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 52, SparkSqlParser.RULE_propertyList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1634;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1635;
|
|
this.property();
|
|
this.state = 1640;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 1636;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1637;
|
|
this.property();
|
|
}
|
|
}
|
|
this.state = 1642;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 1643;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public property(): PropertyContext {
|
|
let _localctx: PropertyContext = new PropertyContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 54, SparkSqlParser.RULE_property);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1645;
|
|
_localctx._key = this.propertyKey();
|
|
this.state = 1650;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 180, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1647;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 179, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1646;
|
|
this.match(SparkSqlParser.EQ);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1649;
|
|
_localctx._value = this.propertyValue();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public propertyKey(): PropertyKeyContext {
|
|
let _localctx: PropertyKeyContext = new PropertyKeyContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 56, SparkSqlParser.RULE_propertyKey);
|
|
try {
|
|
let _alt: number;
|
|
this.state = 1661;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 182, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1652;
|
|
this.identifier();
|
|
this.state = 1657;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 181, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1653;
|
|
this.match(SparkSqlParser.DOT);
|
|
this.state = 1654;
|
|
this.identifier();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1659;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 181, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1660;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public propertyValue(): PropertyValueContext {
|
|
let _localctx: PropertyValueContext = new PropertyValueContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 58, SparkSqlParser.RULE_propertyValue);
|
|
try {
|
|
this.state = 1667;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 183, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1663;
|
|
this.match(SparkSqlParser.INTEGER_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1664;
|
|
this.match(SparkSqlParser.DECIMAL_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 1665;
|
|
this.booleanValue();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 1666;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public expressionPropertyList(): ExpressionPropertyListContext {
|
|
let _localctx: ExpressionPropertyListContext = new ExpressionPropertyListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 60, SparkSqlParser.RULE_expressionPropertyList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1669;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1670;
|
|
this.expressionProperty();
|
|
this.state = 1675;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 1671;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1672;
|
|
this.expressionProperty();
|
|
}
|
|
}
|
|
this.state = 1677;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 1678;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public expressionProperty(): ExpressionPropertyContext {
|
|
let _localctx: ExpressionPropertyContext = new ExpressionPropertyContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 62, SparkSqlParser.RULE_expressionProperty);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1680;
|
|
_localctx._key = this.propertyKey();
|
|
this.state = 1685;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 186, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1682;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 185, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1681;
|
|
this.match(SparkSqlParser.EQ);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1684;
|
|
_localctx._value = this.expression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public constantList(): ConstantListContext {
|
|
let _localctx: ConstantListContext = new ConstantListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 64, SparkSqlParser.RULE_constantList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1687;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1688;
|
|
this.constant();
|
|
this.state = 1693;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 1689;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1690;
|
|
this.constant();
|
|
}
|
|
}
|
|
this.state = 1695;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 1696;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public nestedConstantList(): NestedConstantListContext {
|
|
let _localctx: NestedConstantListContext = new NestedConstantListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 66, SparkSqlParser.RULE_nestedConstantList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1698;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1699;
|
|
this.constantList();
|
|
this.state = 1704;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 1700;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1701;
|
|
this.constantList();
|
|
}
|
|
}
|
|
this.state = 1706;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 1707;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public createFileFormat(): CreateFileFormatContext {
|
|
let _localctx: CreateFileFormatContext = new CreateFileFormatContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 68, SparkSqlParser.RULE_createFileFormat);
|
|
try {
|
|
this.state = 1715;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 189, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1709;
|
|
this.match(SparkSqlParser.KW_STORED);
|
|
this.state = 1710;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 1711;
|
|
this.fileFormat();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1712;
|
|
this.match(SparkSqlParser.KW_STORED);
|
|
this.state = 1713;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1714;
|
|
this.storageHandler();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public fileFormat(): FileFormatContext {
|
|
let _localctx: FileFormatContext = new FileFormatContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 70, SparkSqlParser.RULE_fileFormat);
|
|
try {
|
|
this.state = 1723;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 190, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1717;
|
|
this.match(SparkSqlParser.KW_INPUTFORMAT);
|
|
this.state = 1718;
|
|
_localctx._inFmt = this.stringLit();
|
|
this.state = 1719;
|
|
this.match(SparkSqlParser.KW_OUTPUTFORMAT);
|
|
this.state = 1720;
|
|
_localctx._outFmt = this.stringLit();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1722;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public storageHandler(): StorageHandlerContext {
|
|
let _localctx: StorageHandlerContext = new StorageHandlerContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 72, SparkSqlParser.RULE_storageHandler);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1725;
|
|
this.stringLit();
|
|
this.state = 1729;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 191, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1726;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 1727;
|
|
this.match(SparkSqlParser.KW_SERDEPROPERTIES);
|
|
this.state = 1728;
|
|
this.propertyList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public resource(): ResourceContext {
|
|
let _localctx: ResourceContext = new ResourceContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 74, SparkSqlParser.RULE_resource);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1731;
|
|
this.identifier();
|
|
this.state = 1732;
|
|
this.stringLit();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public dmlStatementNoWith(): DmlStatementNoWithContext {
|
|
let _localctx: DmlStatementNoWithContext = new DmlStatementNoWithContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 76, SparkSqlParser.RULE_dmlStatementNoWith);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.state = 1790;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_INSERT:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1734;
|
|
this.insertInto();
|
|
this.state = 1735;
|
|
this.query();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_FROM:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1737;
|
|
this.fromClause();
|
|
this.state = 1739;
|
|
this._errHandler.sync(this);
|
|
_alt = 1;
|
|
do {
|
|
switch (_alt) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 1738;
|
|
this.multiInsertQueryBody();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 1741;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 192, this._ctx);
|
|
} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_DELETE:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 1743;
|
|
this.match(SparkSqlParser.KW_DELETE);
|
|
this.state = 1744;
|
|
this.match(SparkSqlParser.KW_FROM);
|
|
this.state = 1745;
|
|
this.tableName();
|
|
this.state = 1746;
|
|
this.tableAlias();
|
|
this.state = 1748;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_WHERE) {
|
|
{
|
|
this.state = 1747;
|
|
this.whereClause();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_UPDATE:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 1750;
|
|
this.match(SparkSqlParser.KW_UPDATE);
|
|
this.state = 1751;
|
|
this.tableName();
|
|
this.state = 1752;
|
|
this.tableAlias();
|
|
this.state = 1753;
|
|
this.setClause();
|
|
this.state = 1755;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_WHERE) {
|
|
{
|
|
this.state = 1754;
|
|
this.whereClause();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_MERGE:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 1757;
|
|
this.match(SparkSqlParser.KW_MERGE);
|
|
this.state = 1758;
|
|
this.match(SparkSqlParser.KW_INTO);
|
|
this.state = 1759;
|
|
_localctx._target = this.tableName();
|
|
this.state = 1760;
|
|
_localctx._targetAlias = this.tableAlias();
|
|
this.state = 1761;
|
|
this.match(SparkSqlParser.KW_USING);
|
|
this.state = 1767;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 195, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1762;
|
|
_localctx._source = this.identifierReference();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 1763;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1764;
|
|
_localctx._sourceQuery = this.query();
|
|
this.state = 1765;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1769;
|
|
_localctx._sourceAlias = this.tableAlias();
|
|
this.state = 1770;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 1771;
|
|
_localctx._mergeCondition = this.booleanExpression(0);
|
|
this.state = 1775;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 196, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1772;
|
|
this.matchedClause();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1777;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 196, this._ctx);
|
|
}
|
|
this.state = 1781;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 197, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1778;
|
|
this.notMatchedClause();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1783;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 197, this._ctx);
|
|
}
|
|
this.state = 1787;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.KW_WHEN) {
|
|
{
|
|
{
|
|
this.state = 1784;
|
|
this.notMatchedBySourceClause();
|
|
}
|
|
}
|
|
this.state = 1789;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public dbSchemaName(): DbSchemaNameContext {
|
|
let _localctx: DbSchemaNameContext = new DbSchemaNameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 78, SparkSqlParser.RULE_dbSchemaName);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1792;
|
|
this.identifierReference();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public dbSchemaNameCreate(): DbSchemaNameCreateContext {
|
|
let _localctx: DbSchemaNameCreateContext = new DbSchemaNameCreateContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 80, SparkSqlParser.RULE_dbSchemaNameCreate);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1794;
|
|
this.identifierReference();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public tableNameCreate(): TableNameCreateContext {
|
|
let _localctx: TableNameCreateContext = new TableNameCreateContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 82, SparkSqlParser.RULE_tableNameCreate);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1796;
|
|
this.tableIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public tableName(): TableNameContext {
|
|
let _localctx: TableNameContext = new TableNameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 84, SparkSqlParser.RULE_tableName);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1798;
|
|
this.tableIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public viewNameCreate(): ViewNameCreateContext {
|
|
let _localctx: ViewNameCreateContext = new ViewNameCreateContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 86, SparkSqlParser.RULE_viewNameCreate);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1800;
|
|
this.viewIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public viewName(): ViewNameContext {
|
|
let _localctx: ViewNameContext = new ViewNameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 88, SparkSqlParser.RULE_viewName);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1802;
|
|
this.viewIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public identifierReference(): IdentifierReferenceContext {
|
|
let _localctx: IdentifierReferenceContext = new IdentifierReferenceContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 90, SparkSqlParser.RULE_identifierReference);
|
|
try {
|
|
this.state = 1810;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 200, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1804;
|
|
this.match(SparkSqlParser.KW_IDENTIFIER_KW);
|
|
this.state = 1805;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1806;
|
|
this.expression();
|
|
this.state = 1807;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1809;
|
|
this.multipartIdentifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public queryOrganization(): QueryOrganizationContext {
|
|
let _localctx: QueryOrganizationContext = new QueryOrganizationContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 92, SparkSqlParser.RULE_queryOrganization);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1822;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 202, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1812;
|
|
this.match(SparkSqlParser.KW_ORDER);
|
|
this.state = 1813;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1814;
|
|
_localctx._sortItem = this.sortItem();
|
|
_localctx._order.push(_localctx._sortItem);
|
|
this.state = 1819;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 201, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1815;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1816;
|
|
_localctx._sortItem = this.sortItem();
|
|
_localctx._order.push(_localctx._sortItem);
|
|
}
|
|
}
|
|
}
|
|
this.state = 1821;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 201, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1834;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 204, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1824;
|
|
this.match(SparkSqlParser.KW_CLUSTER);
|
|
this.state = 1825;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1826;
|
|
_localctx._expression = this.expression();
|
|
_localctx._clusterBy.push(_localctx._expression);
|
|
this.state = 1831;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 203, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1827;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1828;
|
|
_localctx._expression = this.expression();
|
|
_localctx._clusterBy.push(_localctx._expression);
|
|
}
|
|
}
|
|
}
|
|
this.state = 1833;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 203, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1846;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 206, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1836;
|
|
this.match(SparkSqlParser.KW_DISTRIBUTE);
|
|
this.state = 1837;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1838;
|
|
_localctx._expression = this.expression();
|
|
_localctx._distributeBy.push(_localctx._expression);
|
|
this.state = 1843;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 205, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1839;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1840;
|
|
_localctx._expression = this.expression();
|
|
_localctx._distributeBy.push(_localctx._expression);
|
|
}
|
|
}
|
|
}
|
|
this.state = 1845;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 205, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1858;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 208, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1848;
|
|
this.match(SparkSqlParser.KW_SORT);
|
|
this.state = 1849;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 1850;
|
|
_localctx._sortItem = this.sortItem();
|
|
_localctx._sort.push(_localctx._sortItem);
|
|
this.state = 1855;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 207, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1851;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 1852;
|
|
_localctx._sortItem = this.sortItem();
|
|
_localctx._sort.push(_localctx._sortItem);
|
|
}
|
|
}
|
|
}
|
|
this.state = 1857;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 207, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1861;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 209, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1860;
|
|
this.windowClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1868;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 211, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1863;
|
|
this.match(SparkSqlParser.KW_LIMIT);
|
|
this.state = 1866;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 210, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1864;
|
|
this.match(SparkSqlParser.KW_ALL);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 1865;
|
|
_localctx._limit = this.expression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1872;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 212, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1870;
|
|
this.match(SparkSqlParser.KW_OFFSET);
|
|
this.state = 1871;
|
|
_localctx._offset = this.expression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public multiInsertQueryBody(): MultiInsertQueryBodyContext {
|
|
let _localctx: MultiInsertQueryBodyContext = new MultiInsertQueryBodyContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 94, SparkSqlParser.RULE_multiInsertQueryBody);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1874;
|
|
this.insertInto();
|
|
this.state = 1875;
|
|
this.fromStatementBody();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public queryTerm(): QueryTermContext;
|
|
public queryTerm(_p: number): QueryTermContext;
|
|
// @RuleVersion(0)
|
|
public queryTerm(_p?: number): QueryTermContext {
|
|
if (_p === undefined) {
|
|
_p = 0;
|
|
}
|
|
|
|
let _parentctx: ParserRuleContext = this._ctx;
|
|
let _parentState: number = this.state;
|
|
let _localctx: QueryTermContext = new QueryTermContext(this._ctx, _parentState);
|
|
let _prevctx: QueryTermContext = _localctx;
|
|
let _startState: number = 96;
|
|
this.enterRecursionRule(_localctx, 96, SparkSqlParser.RULE_queryTerm, _p);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
this.state = 1878;
|
|
this.queryPrimary();
|
|
}
|
|
this._ctx._stop = this._input.tryLT(-1);
|
|
this.state = 1903;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 217, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
if (this._parseListeners != null) {
|
|
this.triggerExitRuleEvent();
|
|
}
|
|
_prevctx = _localctx;
|
|
{
|
|
this.state = 1901;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 216, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new QueryTermContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_queryTerm);
|
|
this.state = 1880;
|
|
if (!(this.precpred(this._ctx, 3))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
|
|
}
|
|
this.state = 1881;
|
|
if (!(this.legacy_setops_precedence_enabled)) {
|
|
throw this.createFailedPredicateException("this.legacy_setops_precedence_enabled");
|
|
}
|
|
this.state = 1882;
|
|
_localctx._operator = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_INTERSECT || _la === SparkSqlParser.KW_SETMINUS || _la === SparkSqlParser.KW_UNION)) {
|
|
_localctx._operator = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1884;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
|
|
{
|
|
this.state = 1883;
|
|
this.setQuantifier();
|
|
}
|
|
}
|
|
|
|
this.state = 1886;
|
|
_localctx._right = this.queryTerm(4);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
_localctx = new QueryTermContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_queryTerm);
|
|
this.state = 1887;
|
|
if (!(this.precpred(this._ctx, 2))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
|
|
}
|
|
this.state = 1888;
|
|
if (!(!this.legacy_setops_precedence_enabled)) {
|
|
throw this.createFailedPredicateException("!this.legacy_setops_precedence_enabled");
|
|
}
|
|
this.state = 1889;
|
|
_localctx._operator = this.match(SparkSqlParser.KW_INTERSECT);
|
|
this.state = 1891;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
|
|
{
|
|
this.state = 1890;
|
|
this.setQuantifier();
|
|
}
|
|
}
|
|
|
|
this.state = 1893;
|
|
_localctx._right = this.queryTerm(3);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
_localctx = new QueryTermContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_queryTerm);
|
|
this.state = 1894;
|
|
if (!(this.precpred(this._ctx, 1))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
|
|
}
|
|
this.state = 1895;
|
|
if (!(!this.legacy_setops_precedence_enabled)) {
|
|
throw this.createFailedPredicateException("!this.legacy_setops_precedence_enabled");
|
|
}
|
|
this.state = 1896;
|
|
_localctx._operator = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_SETMINUS || _la === SparkSqlParser.KW_UNION)) {
|
|
_localctx._operator = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 1898;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
|
|
{
|
|
this.state = 1897;
|
|
this.setQuantifier();
|
|
}
|
|
}
|
|
|
|
this.state = 1900;
|
|
_localctx._right = this.queryTerm(2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.state = 1905;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 217, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public queryPrimary(): QueryPrimaryContext {
|
|
let _localctx: QueryPrimaryContext = new QueryPrimaryContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 98, SparkSqlParser.RULE_queryPrimary);
|
|
try {
|
|
this.state = 1915;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_MAP:
|
|
case SparkSqlParser.KW_REDUCE:
|
|
case SparkSqlParser.KW_SELECT:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1906;
|
|
this.querySpecification();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_FROM:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1907;
|
|
this.fromStatement();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_TABLE:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 1908;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 1909;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_VALUES:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 1910;
|
|
this.inlineTable();
|
|
}
|
|
break;
|
|
case SparkSqlParser.LEFT_PAREN:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 1911;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 1912;
|
|
this.query();
|
|
this.state = 1913;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public sortItem(): SortItemContext {
|
|
let _localctx: SortItemContext = new SortItemContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 100, SparkSqlParser.RULE_sortItem);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1917;
|
|
this.expression();
|
|
this.state = 1919;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 219, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1918;
|
|
_localctx._ordering = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ASC || _la === SparkSqlParser.KW_DESC)) {
|
|
_localctx._ordering = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1923;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 220, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1921;
|
|
this.match(SparkSqlParser.KW_NULLS);
|
|
this.state = 1922;
|
|
_localctx._nullOrder = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FIRST || _la === SparkSqlParser.KW_LAST)) {
|
|
_localctx._nullOrder = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public fromStatement(): FromStatementContext {
|
|
let _localctx: FromStatementContext = new FromStatementContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 102, SparkSqlParser.RULE_fromStatement);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1925;
|
|
this.fromClause();
|
|
this.state = 1927;
|
|
this._errHandler.sync(this);
|
|
_alt = 1;
|
|
do {
|
|
switch (_alt) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 1926;
|
|
this.fromStatementBody();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 1929;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 221, this._ctx);
|
|
} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public fromStatementBody(): FromStatementBodyContext {
|
|
let _localctx: FromStatementBodyContext = new FromStatementBodyContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 104, SparkSqlParser.RULE_fromStatementBody);
|
|
try {
|
|
let _alt: number;
|
|
this.state = 1958;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 228, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1931;
|
|
this.transformClause();
|
|
this.state = 1933;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 222, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1932;
|
|
this.whereClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1935;
|
|
this.queryOrganization();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1937;
|
|
this.selectClause();
|
|
this.state = 1941;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 223, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1938;
|
|
this.lateralView();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1943;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 223, this._ctx);
|
|
}
|
|
this.state = 1945;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 224, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1944;
|
|
this.whereClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1948;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 225, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1947;
|
|
this.aggregationClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1951;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 226, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1950;
|
|
this.havingClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1954;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 227, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1953;
|
|
this.windowClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1956;
|
|
this.queryOrganization();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public querySpecification(): QuerySpecificationContext {
|
|
let _localctx: QuerySpecificationContext = new QuerySpecificationContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 106, SparkSqlParser.RULE_querySpecification);
|
|
try {
|
|
let _alt: number;
|
|
this.state = 2004;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 241, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 1960;
|
|
this.transformClause();
|
|
this.state = 1962;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 229, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1961;
|
|
this.fromClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1967;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 230, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1964;
|
|
this.lateralView();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1969;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 230, this._ctx);
|
|
}
|
|
this.state = 1971;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 231, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1970;
|
|
this.whereClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1974;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 232, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1973;
|
|
this.aggregationClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1977;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 233, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1976;
|
|
this.havingClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1980;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 234, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1979;
|
|
this.windowClause();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 1982;
|
|
this.selectClause();
|
|
this.state = 1984;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 235, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1983;
|
|
this.fromClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1989;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 236, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 1986;
|
|
this.lateralView();
|
|
}
|
|
}
|
|
}
|
|
this.state = 1991;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 236, this._ctx);
|
|
}
|
|
this.state = 1993;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 237, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1992;
|
|
this.whereClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1996;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 238, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1995;
|
|
this.aggregationClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 1999;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 239, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 1998;
|
|
this.havingClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2002;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 240, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2001;
|
|
this.windowClause();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public transformClause(): TransformClauseContext {
|
|
let _localctx: TransformClauseContext = new TransformClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 108, SparkSqlParser.RULE_transformClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2025;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_SELECT:
|
|
{
|
|
this.state = 2006;
|
|
this.match(SparkSqlParser.KW_SELECT);
|
|
this.state = 2007;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_TRANSFORM);
|
|
this.state = 2008;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2010;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 242, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2009;
|
|
this.setQuantifier();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2012;
|
|
this.expressionSeq();
|
|
this.state = 2013;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_MAP:
|
|
{
|
|
this.state = 2015;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_MAP);
|
|
this.state = 2017;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 243, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2016;
|
|
this.setQuantifier();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2019;
|
|
this.expressionSeq();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_REDUCE:
|
|
{
|
|
this.state = 2020;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_REDUCE);
|
|
this.state = 2022;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 244, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2021;
|
|
this.setQuantifier();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2024;
|
|
this.expressionSeq();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 2028;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ROW) {
|
|
{
|
|
this.state = 2027;
|
|
_localctx._inRowFormat = this.rowFormat();
|
|
}
|
|
}
|
|
|
|
this.state = 2032;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_RECORDWRITER) {
|
|
{
|
|
this.state = 2030;
|
|
this.match(SparkSqlParser.KW_RECORDWRITER);
|
|
this.state = 2031;
|
|
_localctx._recordWriter = this.stringLit();
|
|
}
|
|
}
|
|
|
|
this.state = 2034;
|
|
this.match(SparkSqlParser.KW_USING);
|
|
this.state = 2035;
|
|
_localctx._script = this.stringLit();
|
|
this.state = 2048;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 250, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2036;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 2046;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 249, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2037;
|
|
this.identifierSeq();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2038;
|
|
this.colTypeList();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
{
|
|
this.state = 2039;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2042;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 248, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2040;
|
|
this.identifierSeq();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2041;
|
|
this.colTypeList();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2044;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2051;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 251, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2050;
|
|
_localctx._outRowFormat = this.rowFormat();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2055;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 252, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2053;
|
|
this.match(SparkSqlParser.KW_RECORDREADER);
|
|
this.state = 2054;
|
|
_localctx._recordReader = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public selectClause(): SelectClauseContext {
|
|
let _localctx: SelectClauseContext = new SelectClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 110, SparkSqlParser.RULE_selectClause);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2057;
|
|
this.match(SparkSqlParser.KW_SELECT);
|
|
this.state = 2061;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 253, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2058;
|
|
_localctx._hint = this.hint();
|
|
_localctx._hints.push(_localctx._hint);
|
|
}
|
|
}
|
|
}
|
|
this.state = 2063;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 253, this._ctx);
|
|
}
|
|
this.state = 2065;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 254, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2064;
|
|
this.setQuantifier();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2067;
|
|
this.namedExpressionSeq();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public setClause(): SetClauseContext {
|
|
let _localctx: SetClauseContext = new SetClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 112, SparkSqlParser.RULE_setClause);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2069;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 2070;
|
|
this.assignmentList();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public matchedClause(): MatchedClauseContext {
|
|
let _localctx: MatchedClauseContext = new MatchedClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 114, SparkSqlParser.RULE_matchedClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2072;
|
|
this.match(SparkSqlParser.KW_WHEN);
|
|
this.state = 2073;
|
|
this.match(SparkSqlParser.KW_MATCHED);
|
|
this.state = 2076;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AND) {
|
|
{
|
|
this.state = 2074;
|
|
this.match(SparkSqlParser.KW_AND);
|
|
this.state = 2075;
|
|
_localctx._matchedCond = this.booleanExpression(0);
|
|
}
|
|
}
|
|
|
|
this.state = 2078;
|
|
this.match(SparkSqlParser.KW_THEN);
|
|
this.state = 2079;
|
|
this.matchedAction();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public notMatchedClause(): NotMatchedClauseContext {
|
|
let _localctx: NotMatchedClauseContext = new NotMatchedClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 116, SparkSqlParser.RULE_notMatchedClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2081;
|
|
this.match(SparkSqlParser.KW_WHEN);
|
|
this.state = 2082;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 2083;
|
|
this.match(SparkSqlParser.KW_MATCHED);
|
|
this.state = 2086;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_BY) {
|
|
{
|
|
this.state = 2084;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2085;
|
|
this.match(SparkSqlParser.KW_TARGET);
|
|
}
|
|
}
|
|
|
|
this.state = 2090;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AND) {
|
|
{
|
|
this.state = 2088;
|
|
this.match(SparkSqlParser.KW_AND);
|
|
this.state = 2089;
|
|
_localctx._notMatchedCond = this.booleanExpression(0);
|
|
}
|
|
}
|
|
|
|
this.state = 2092;
|
|
this.match(SparkSqlParser.KW_THEN);
|
|
this.state = 2093;
|
|
this.notMatchedAction();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public notMatchedBySourceClause(): NotMatchedBySourceClauseContext {
|
|
let _localctx: NotMatchedBySourceClauseContext = new NotMatchedBySourceClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 118, SparkSqlParser.RULE_notMatchedBySourceClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2095;
|
|
this.match(SparkSqlParser.KW_WHEN);
|
|
this.state = 2096;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 2097;
|
|
this.match(SparkSqlParser.KW_MATCHED);
|
|
this.state = 2098;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2099;
|
|
this.match(SparkSqlParser.KW_SOURCE);
|
|
this.state = 2102;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_AND) {
|
|
{
|
|
this.state = 2100;
|
|
this.match(SparkSqlParser.KW_AND);
|
|
this.state = 2101;
|
|
_localctx._notMatchedBySourceCond = this.booleanExpression(0);
|
|
}
|
|
}
|
|
|
|
this.state = 2104;
|
|
this.match(SparkSqlParser.KW_THEN);
|
|
this.state = 2105;
|
|
this.notMatchedBySourceAction();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public matchedAction(): MatchedActionContext {
|
|
let _localctx: MatchedActionContext = new MatchedActionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 120, SparkSqlParser.RULE_matchedAction);
|
|
try {
|
|
this.state = 2114;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 259, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2107;
|
|
this.match(SparkSqlParser.KW_DELETE);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2108;
|
|
this.match(SparkSqlParser.KW_UPDATE);
|
|
this.state = 2109;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 2110;
|
|
this.match(SparkSqlParser.ASTERISK);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 2111;
|
|
this.match(SparkSqlParser.KW_UPDATE);
|
|
this.state = 2112;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 2113;
|
|
this.assignmentList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public notMatchedAction(): NotMatchedActionContext {
|
|
let _localctx: NotMatchedActionContext = new NotMatchedActionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 122, SparkSqlParser.RULE_notMatchedAction);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2134;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 261, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2116;
|
|
this.match(SparkSqlParser.KW_INSERT);
|
|
this.state = 2117;
|
|
this.match(SparkSqlParser.ASTERISK);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2118;
|
|
this.match(SparkSqlParser.KW_INSERT);
|
|
this.state = 2119;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2120;
|
|
this.multipartIdentifierList();
|
|
this.state = 2121;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2122;
|
|
this.match(SparkSqlParser.KW_VALUES);
|
|
this.state = 2123;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2124;
|
|
this.expression();
|
|
this.state = 2129;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2125;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2126;
|
|
this.expression();
|
|
}
|
|
}
|
|
this.state = 2131;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2132;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public notMatchedBySourceAction(): NotMatchedBySourceActionContext {
|
|
let _localctx: NotMatchedBySourceActionContext = new NotMatchedBySourceActionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 124, SparkSqlParser.RULE_notMatchedBySourceAction);
|
|
try {
|
|
this.state = 2140;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_DELETE:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2136;
|
|
this.match(SparkSqlParser.KW_DELETE);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_UPDATE:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2137;
|
|
this.match(SparkSqlParser.KW_UPDATE);
|
|
this.state = 2138;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 2139;
|
|
this.assignmentList();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public assignmentList(): AssignmentListContext {
|
|
let _localctx: AssignmentListContext = new AssignmentListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 126, SparkSqlParser.RULE_assignmentList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2142;
|
|
this.assignment();
|
|
this.state = 2147;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2143;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2144;
|
|
this.assignment();
|
|
}
|
|
}
|
|
this.state = 2149;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public assignment(): AssignmentContext {
|
|
let _localctx: AssignmentContext = new AssignmentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 128, SparkSqlParser.RULE_assignment);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2150;
|
|
_localctx._key = this.multipartIdentifier();
|
|
this.state = 2151;
|
|
this.match(SparkSqlParser.EQ);
|
|
this.state = 2152;
|
|
_localctx._value = this.expression();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public whereClause(): WhereClauseContext {
|
|
let _localctx: WhereClauseContext = new WhereClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 130, SparkSqlParser.RULE_whereClause);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2154;
|
|
this.match(SparkSqlParser.KW_WHERE);
|
|
this.state = 2155;
|
|
this.booleanExpression(0);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public havingClause(): HavingClauseContext {
|
|
let _localctx: HavingClauseContext = new HavingClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 132, SparkSqlParser.RULE_havingClause);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2157;
|
|
this.match(SparkSqlParser.KW_HAVING);
|
|
this.state = 2158;
|
|
this.booleanExpression(0);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public hint(): HintContext {
|
|
let _localctx: HintContext = new HintContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 134, SparkSqlParser.RULE_hint);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2160;
|
|
this.match(SparkSqlParser.HENT_START);
|
|
this.state = 2161;
|
|
_localctx._hintStatement = this.hintStatement();
|
|
_localctx._hintStatements.push(_localctx._hintStatement);
|
|
this.state = 2168;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 265, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2163;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 264, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2162;
|
|
this.match(SparkSqlParser.COMMA);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2165;
|
|
_localctx._hintStatement = this.hintStatement();
|
|
_localctx._hintStatements.push(_localctx._hintStatement);
|
|
}
|
|
}
|
|
}
|
|
this.state = 2170;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 265, this._ctx);
|
|
}
|
|
this.state = 2171;
|
|
this.match(SparkSqlParser.HENT_END);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public hintStatement(): HintStatementContext {
|
|
let _localctx: HintStatementContext = new HintStatementContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 136, SparkSqlParser.RULE_hintStatement);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2186;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 267, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2173;
|
|
_localctx._hintName = this.identifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2174;
|
|
_localctx._hintName = this.identifier();
|
|
this.state = 2175;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2176;
|
|
_localctx._primaryExpression = this.primaryExpression(0);
|
|
_localctx._parameters.push(_localctx._primaryExpression);
|
|
this.state = 2181;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2177;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2178;
|
|
_localctx._primaryExpression = this.primaryExpression(0);
|
|
_localctx._parameters.push(_localctx._primaryExpression);
|
|
}
|
|
}
|
|
this.state = 2183;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2184;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public fromClause(): FromClauseContext {
|
|
let _localctx: FromClauseContext = new FromClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 138, SparkSqlParser.RULE_fromClause);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2188;
|
|
this.match(SparkSqlParser.KW_FROM);
|
|
this.state = 2189;
|
|
this.relation();
|
|
this.state = 2194;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 268, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2190;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2191;
|
|
this.relation();
|
|
}
|
|
}
|
|
}
|
|
this.state = 2196;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 268, this._ctx);
|
|
}
|
|
this.state = 2200;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 269, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2197;
|
|
this.lateralView();
|
|
}
|
|
}
|
|
}
|
|
this.state = 2202;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 269, this._ctx);
|
|
}
|
|
this.state = 2204;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 270, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2203;
|
|
this.pivotClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2207;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 271, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2206;
|
|
this.unpivotClause();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionKind(): FunctionKindContext {
|
|
let _localctx: FunctionKindContext = new FunctionKindContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 140, SparkSqlParser.RULE_functionKind);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2209;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_SYSTEM || _la === SparkSqlParser.KW_USER)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public temporalClause(): TemporalClauseContext {
|
|
let _localctx: TemporalClauseContext = new TemporalClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 142, SparkSqlParser.RULE_temporalClause);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2225;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 274, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2212;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_FOR) {
|
|
{
|
|
this.state = 2211;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
}
|
|
}
|
|
|
|
this.state = 2214;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_SYSTEM_VERSION || _la === SparkSqlParser.KW_VERSION)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2215;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 2216;
|
|
this.match(SparkSqlParser.KW_OF);
|
|
this.state = 2217;
|
|
this.version();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2219;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_FOR) {
|
|
{
|
|
this.state = 2218;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
}
|
|
}
|
|
|
|
this.state = 2221;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_SYSTEM_TIME || _la === SparkSqlParser.KW_TIMESTAMP)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2222;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 2223;
|
|
this.match(SparkSqlParser.KW_OF);
|
|
this.state = 2224;
|
|
_localctx._timestamp = this.valueExpression(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public aggregationClause(): AggregationClauseContext {
|
|
let _localctx: AggregationClauseContext = new AggregationClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 144, SparkSqlParser.RULE_aggregationClause);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.state = 2266;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 279, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2227;
|
|
this.match(SparkSqlParser.KW_GROUP);
|
|
this.state = 2228;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2229;
|
|
_localctx._groupByClause = this.groupByClause();
|
|
_localctx._groupingExpressionsWithGroupingAnalytics.push(_localctx._groupByClause);
|
|
this.state = 2234;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 275, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2230;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2231;
|
|
_localctx._groupByClause = this.groupByClause();
|
|
_localctx._groupingExpressionsWithGroupingAnalytics.push(_localctx._groupByClause);
|
|
}
|
|
}
|
|
}
|
|
this.state = 2236;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 275, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2237;
|
|
this.match(SparkSqlParser.KW_GROUP);
|
|
this.state = 2238;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2239;
|
|
_localctx._expression = this.expression();
|
|
_localctx._groupingExpressions.push(_localctx._expression);
|
|
this.state = 2244;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 276, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2240;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2241;
|
|
_localctx._expression = this.expression();
|
|
_localctx._groupingExpressions.push(_localctx._expression);
|
|
}
|
|
}
|
|
}
|
|
this.state = 2246;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 276, this._ctx);
|
|
}
|
|
this.state = 2264;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 278, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2247;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 2248;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_ROLLUP);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2249;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 2250;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_CUBE);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
this.state = 2251;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_GROUPING);
|
|
this.state = 2252;
|
|
this.match(SparkSqlParser.KW_SETS);
|
|
this.state = 2253;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2254;
|
|
this.groupingSet();
|
|
this.state = 2259;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2255;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2256;
|
|
this.groupingSet();
|
|
}
|
|
}
|
|
this.state = 2261;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2262;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public groupByClause(): GroupByClauseContext {
|
|
let _localctx: GroupByClauseContext = new GroupByClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 146, SparkSqlParser.RULE_groupByClause);
|
|
try {
|
|
this.state = 2270;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 280, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2268;
|
|
this.groupingAnalytics();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2269;
|
|
this.expression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public groupingAnalytics(): GroupingAnalyticsContext {
|
|
let _localctx: GroupingAnalyticsContext = new GroupingAnalyticsContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 148, SparkSqlParser.RULE_groupingAnalytics);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2297;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_CUBE:
|
|
case SparkSqlParser.KW_ROLLUP:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2272;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_CUBE || _la === SparkSqlParser.KW_ROLLUP)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2273;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2274;
|
|
this.groupingSet();
|
|
this.state = 2279;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2275;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2276;
|
|
this.groupingSet();
|
|
}
|
|
}
|
|
this.state = 2281;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2282;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_GROUPING:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2284;
|
|
this.match(SparkSqlParser.KW_GROUPING);
|
|
this.state = 2285;
|
|
this.match(SparkSqlParser.KW_SETS);
|
|
this.state = 2286;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2287;
|
|
this.groupingElement();
|
|
this.state = 2292;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2288;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2289;
|
|
this.groupingElement();
|
|
}
|
|
}
|
|
this.state = 2294;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2295;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public groupingElement(): GroupingElementContext {
|
|
let _localctx: GroupingElementContext = new GroupingElementContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 150, SparkSqlParser.RULE_groupingElement);
|
|
try {
|
|
this.state = 2301;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 284, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2299;
|
|
this.groupingAnalytics();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2300;
|
|
this.groupingSet();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public groupingSet(): GroupingSetContext {
|
|
let _localctx: GroupingSetContext = new GroupingSetContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 152, SparkSqlParser.RULE_groupingSet);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2316;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 287, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2303;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2312;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 286, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2304;
|
|
this.expression();
|
|
this.state = 2309;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2305;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2306;
|
|
this.expression();
|
|
}
|
|
}
|
|
this.state = 2311;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2314;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2315;
|
|
this.expression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public pivotClause(): PivotClauseContext {
|
|
let _localctx: PivotClauseContext = new PivotClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 154, SparkSqlParser.RULE_pivotClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2318;
|
|
this.match(SparkSqlParser.KW_PIVOT);
|
|
this.state = 2319;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2320;
|
|
_localctx._aggregates = this.namedExpressionSeq();
|
|
this.state = 2321;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
this.state = 2322;
|
|
this.pivotColumn();
|
|
this.state = 2323;
|
|
this.match(SparkSqlParser.KW_IN);
|
|
this.state = 2324;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2325;
|
|
_localctx._pivotValue = this.pivotValue();
|
|
_localctx._pivotValues.push(_localctx._pivotValue);
|
|
this.state = 2330;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2326;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2327;
|
|
_localctx._pivotValue = this.pivotValue();
|
|
_localctx._pivotValues.push(_localctx._pivotValue);
|
|
}
|
|
}
|
|
this.state = 2332;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2333;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2334;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public pivotColumn(): PivotColumnContext {
|
|
let _localctx: PivotColumnContext = new PivotColumnContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 156, SparkSqlParser.RULE_pivotColumn);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2348;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 290, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2336;
|
|
_localctx._identifier = this.identifier();
|
|
_localctx._identifiers.push(_localctx._identifier);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2337;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2338;
|
|
_localctx._identifier = this.identifier();
|
|
_localctx._identifiers.push(_localctx._identifier);
|
|
this.state = 2343;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2339;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2340;
|
|
_localctx._identifier = this.identifier();
|
|
_localctx._identifiers.push(_localctx._identifier);
|
|
}
|
|
}
|
|
this.state = 2345;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2346;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public pivotValue(): PivotValueContext {
|
|
let _localctx: PivotValueContext = new PivotValueContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 158, SparkSqlParser.RULE_pivotValue);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2350;
|
|
this.expression();
|
|
this.state = 2355;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 292, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2352;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 291, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2351;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2354;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotClause(): UnpivotClauseContext {
|
|
let _localctx: UnpivotClauseContext = new UnpivotClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 160, SparkSqlParser.RULE_unpivotClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2357;
|
|
this.match(SparkSqlParser.KW_UNPIVOT);
|
|
this.state = 2359;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_EXCLUDE || _la === SparkSqlParser.KW_INCLUDE) {
|
|
{
|
|
this.state = 2358;
|
|
_localctx._nullOperator = this.unpivotNullClause();
|
|
}
|
|
}
|
|
|
|
this.state = 2361;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2362;
|
|
_localctx._operator = this.unpivotOperator();
|
|
this.state = 2363;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2368;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 295, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2365;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 294, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2364;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2367;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotNullClause(): UnpivotNullClauseContext {
|
|
let _localctx: UnpivotNullClauseContext = new UnpivotNullClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 162, SparkSqlParser.RULE_unpivotNullClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2370;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_EXCLUDE || _la === SparkSqlParser.KW_INCLUDE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2371;
|
|
this.match(SparkSqlParser.KW_NULLS);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotOperator(): UnpivotOperatorContext {
|
|
let _localctx: UnpivotOperatorContext = new UnpivotOperatorContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 164, SparkSqlParser.RULE_unpivotOperator);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2375;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 296, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2373;
|
|
this.unpivotSingleValueColumnClause();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2374;
|
|
this.unpivotMultiValueColumnClause();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext {
|
|
let _localctx: UnpivotSingleValueColumnClauseContext = new UnpivotSingleValueColumnClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 166, SparkSqlParser.RULE_unpivotSingleValueColumnClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2377;
|
|
this.unpivotValueColumn();
|
|
this.state = 2378;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
this.state = 2379;
|
|
this.unpivotNameColumn();
|
|
this.state = 2380;
|
|
this.match(SparkSqlParser.KW_IN);
|
|
this.state = 2381;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2382;
|
|
_localctx._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
|
|
_localctx._unpivotColumns.push(_localctx._unpivotColumnAndAlias);
|
|
this.state = 2387;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2383;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2384;
|
|
_localctx._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
|
|
_localctx._unpivotColumns.push(_localctx._unpivotColumnAndAlias);
|
|
}
|
|
}
|
|
this.state = 2389;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2390;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotMultiValueColumnClause(): UnpivotMultiValueColumnClauseContext {
|
|
let _localctx: UnpivotMultiValueColumnClauseContext = new UnpivotMultiValueColumnClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 168, SparkSqlParser.RULE_unpivotMultiValueColumnClause);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2392;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2393;
|
|
_localctx._unpivotValueColumn = this.unpivotValueColumn();
|
|
_localctx._unpivotValueColumns.push(_localctx._unpivotValueColumn);
|
|
this.state = 2398;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2394;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2395;
|
|
_localctx._unpivotValueColumn = this.unpivotValueColumn();
|
|
_localctx._unpivotValueColumns.push(_localctx._unpivotValueColumn);
|
|
}
|
|
}
|
|
this.state = 2400;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2401;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2402;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
this.state = 2403;
|
|
this.unpivotNameColumn();
|
|
this.state = 2404;
|
|
this.match(SparkSqlParser.KW_IN);
|
|
this.state = 2405;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2406;
|
|
_localctx._unpivotColumnSet = this.unpivotColumnSet();
|
|
_localctx._unpivotColumnSets.push(_localctx._unpivotColumnSet);
|
|
this.state = 2411;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2407;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2408;
|
|
_localctx._unpivotColumnSet = this.unpivotColumnSet();
|
|
_localctx._unpivotColumnSets.push(_localctx._unpivotColumnSet);
|
|
}
|
|
}
|
|
this.state = 2413;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2414;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotColumnSet(): UnpivotColumnSetContext {
|
|
let _localctx: UnpivotColumnSetContext = new UnpivotColumnSetContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 170, SparkSqlParser.RULE_unpivotColumnSet);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2416;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2417;
|
|
_localctx._unpivotColumn = this.unpivotColumn();
|
|
_localctx._unpivotColumns.push(_localctx._unpivotColumn);
|
|
this.state = 2422;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2418;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2419;
|
|
_localctx._unpivotColumn = this.unpivotColumn();
|
|
_localctx._unpivotColumns.push(_localctx._unpivotColumn);
|
|
}
|
|
}
|
|
this.state = 2424;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2425;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2427;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 301, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2426;
|
|
this.unpivotAlias();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotValueColumn(): UnpivotValueColumnContext {
|
|
let _localctx: UnpivotValueColumnContext = new UnpivotValueColumnContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 172, SparkSqlParser.RULE_unpivotValueColumn);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2429;
|
|
this.identifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotNameColumn(): UnpivotNameColumnContext {
|
|
let _localctx: UnpivotNameColumnContext = new UnpivotNameColumnContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 174, SparkSqlParser.RULE_unpivotNameColumn);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2431;
|
|
this.identifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext {
|
|
let _localctx: UnpivotColumnAndAliasContext = new UnpivotColumnAndAliasContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 176, SparkSqlParser.RULE_unpivotColumnAndAlias);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2433;
|
|
this.unpivotColumn();
|
|
this.state = 2435;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 302, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2434;
|
|
this.unpivotAlias();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotColumn(): UnpivotColumnContext {
|
|
let _localctx: UnpivotColumnContext = new UnpivotColumnContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 178, SparkSqlParser.RULE_unpivotColumn);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2437;
|
|
this.multipartIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unpivotAlias(): UnpivotAliasContext {
|
|
let _localctx: UnpivotAliasContext = new UnpivotAliasContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 180, SparkSqlParser.RULE_unpivotAlias);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2440;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 303, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2439;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2442;
|
|
this.identifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public ifNotExists(): IfNotExistsContext {
|
|
let _localctx: IfNotExistsContext = new IfNotExistsContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 182, SparkSqlParser.RULE_ifNotExists);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2444;
|
|
this.match(SparkSqlParser.KW_IF);
|
|
this.state = 2445;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 2446;
|
|
this.match(SparkSqlParser.KW_EXISTS);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public ifExists(): IfExistsContext {
|
|
let _localctx: IfExistsContext = new IfExistsContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 184, SparkSqlParser.RULE_ifExists);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2448;
|
|
this.match(SparkSqlParser.KW_IF);
|
|
this.state = 2449;
|
|
this.match(SparkSqlParser.KW_EXISTS);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public lateralView(): LateralViewContext {
|
|
let _localctx: LateralViewContext = new LateralViewContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 186, SparkSqlParser.RULE_lateralView);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2451;
|
|
this.match(SparkSqlParser.KW_LATERAL);
|
|
this.state = 2452;
|
|
this.match(SparkSqlParser.KW_VIEW);
|
|
this.state = 2454;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 304, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2453;
|
|
this.match(SparkSqlParser.KW_OUTER);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2456;
|
|
this.viewName();
|
|
this.state = 2457;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2466;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 306, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2458;
|
|
this.expression();
|
|
this.state = 2463;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2459;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2460;
|
|
this.expression();
|
|
}
|
|
}
|
|
this.state = 2465;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2468;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2469;
|
|
this.tableAlias();
|
|
this.state = 2481;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 309, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2471;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 307, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2470;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2473;
|
|
_localctx._identifier = this.identifier();
|
|
_localctx._colName.push(_localctx._identifier);
|
|
this.state = 2478;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 308, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2474;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2475;
|
|
_localctx._identifier = this.identifier();
|
|
_localctx._colName.push(_localctx._identifier);
|
|
}
|
|
}
|
|
}
|
|
this.state = 2480;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 308, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public setQuantifier(): SetQuantifierContext {
|
|
let _localctx: SetQuantifierContext = new SetQuantifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 188, SparkSqlParser.RULE_setQuantifier);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2483;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public relation(): RelationContext {
|
|
let _localctx: RelationContext = new RelationContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 190, SparkSqlParser.RULE_relation);
|
|
try {
|
|
let _alt: number;
|
|
this.state = 2496;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 312, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2486;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 310, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2485;
|
|
this.match(SparkSqlParser.KW_LATERAL);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2488;
|
|
this.relationPrimary();
|
|
this.state = 2492;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 311, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2489;
|
|
this.relationExtension();
|
|
}
|
|
}
|
|
}
|
|
this.state = 2494;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 311, this._ctx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2495;
|
|
this.tableName();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public relationExtension(): RelationExtensionContext {
|
|
let _localctx: RelationExtensionContext = new RelationExtensionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 192, SparkSqlParser.RULE_relationExtension);
|
|
try {
|
|
this.state = 2501;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_ANTI:
|
|
case SparkSqlParser.KW_CROSS:
|
|
case SparkSqlParser.KW_FULL:
|
|
case SparkSqlParser.KW_INNER:
|
|
case SparkSqlParser.KW_JOIN:
|
|
case SparkSqlParser.KW_LEFT:
|
|
case SparkSqlParser.KW_NATURAL:
|
|
case SparkSqlParser.KW_RIGHT:
|
|
case SparkSqlParser.KW_SEMI:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2498;
|
|
this.joinRelation();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_PIVOT:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2499;
|
|
this.pivotClause();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_UNPIVOT:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 2500;
|
|
this.unpivotClause();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public joinRelation(): JoinRelationContext {
|
|
let _localctx: JoinRelationContext = new JoinRelationContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 194, SparkSqlParser.RULE_joinRelation);
|
|
try {
|
|
this.state = 2520;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_ANTI:
|
|
case SparkSqlParser.KW_CROSS:
|
|
case SparkSqlParser.KW_FULL:
|
|
case SparkSqlParser.KW_INNER:
|
|
case SparkSqlParser.KW_JOIN:
|
|
case SparkSqlParser.KW_LEFT:
|
|
case SparkSqlParser.KW_RIGHT:
|
|
case SparkSqlParser.KW_SEMI:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
this.state = 2503;
|
|
this.joinType();
|
|
}
|
|
this.state = 2504;
|
|
this.match(SparkSqlParser.KW_JOIN);
|
|
this.state = 2506;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 314, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2505;
|
|
this.match(SparkSqlParser.KW_LATERAL);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2508;
|
|
_localctx._right = this.relationPrimary();
|
|
this.state = 2510;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 315, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2509;
|
|
this.joinCriteria();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_NATURAL:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2512;
|
|
this.match(SparkSqlParser.KW_NATURAL);
|
|
this.state = 2513;
|
|
this.joinType();
|
|
this.state = 2514;
|
|
this.match(SparkSqlParser.KW_JOIN);
|
|
this.state = 2516;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 316, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2515;
|
|
this.match(SparkSqlParser.KW_LATERAL);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2518;
|
|
_localctx._right = this.relationPrimary();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public joinType(): JoinTypeContext {
|
|
let _localctx: JoinTypeContext = new JoinTypeContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 196, SparkSqlParser.RULE_joinType);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2546;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 324, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2523;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_INNER) {
|
|
{
|
|
this.state = 2522;
|
|
this.match(SparkSqlParser.KW_INNER);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2525;
|
|
this.match(SparkSqlParser.KW_CROSS);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 2526;
|
|
this.match(SparkSqlParser.KW_LEFT);
|
|
this.state = 2528;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OUTER) {
|
|
{
|
|
this.state = 2527;
|
|
this.match(SparkSqlParser.KW_OUTER);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 2531;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_LEFT) {
|
|
{
|
|
this.state = 2530;
|
|
this.match(SparkSqlParser.KW_LEFT);
|
|
}
|
|
}
|
|
|
|
this.state = 2533;
|
|
this.match(SparkSqlParser.KW_SEMI);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 2534;
|
|
this.match(SparkSqlParser.KW_RIGHT);
|
|
this.state = 2536;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OUTER) {
|
|
{
|
|
this.state = 2535;
|
|
this.match(SparkSqlParser.KW_OUTER);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 2538;
|
|
this.match(SparkSqlParser.KW_FULL);
|
|
this.state = 2540;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OUTER) {
|
|
{
|
|
this.state = 2539;
|
|
this.match(SparkSqlParser.KW_OUTER);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 2543;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_LEFT) {
|
|
{
|
|
this.state = 2542;
|
|
this.match(SparkSqlParser.KW_LEFT);
|
|
}
|
|
}
|
|
|
|
this.state = 2545;
|
|
this.match(SparkSqlParser.KW_ANTI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public joinCriteria(): JoinCriteriaContext {
|
|
let _localctx: JoinCriteriaContext = new JoinCriteriaContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 198, SparkSqlParser.RULE_joinCriteria);
|
|
try {
|
|
this.state = 2552;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_ON:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2548;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 2549;
|
|
this.booleanExpression(0);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_USING:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2550;
|
|
this.match(SparkSqlParser.KW_USING);
|
|
this.state = 2551;
|
|
this.identifierList();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public sample(): SampleContext {
|
|
let _localctx: SampleContext = new SampleContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 200, SparkSqlParser.RULE_sample);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2554;
|
|
this.match(SparkSqlParser.KW_TABLESAMPLE);
|
|
this.state = 2555;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2557;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 326, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2556;
|
|
this.sampleMethod();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2559;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2564;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 327, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2560;
|
|
this.match(SparkSqlParser.KW_REPEATABLE);
|
|
this.state = 2561;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2562;
|
|
_localctx._seed = this.match(SparkSqlParser.INTEGER_VALUE);
|
|
this.state = 2563;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public sampleMethod(): SampleMethodContext {
|
|
let _localctx: SampleMethodContext = new SampleMethodContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 202, SparkSqlParser.RULE_sampleMethod);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2590;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 331, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2567;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 2566;
|
|
_localctx._negativeSign = this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 2569;
|
|
_localctx._percentage = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.INTEGER_VALUE || _la === SparkSqlParser.DECIMAL_VALUE)) {
|
|
_localctx._percentage = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2570;
|
|
this.match(SparkSqlParser.KW_PERCENTLIT);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2571;
|
|
this.expression();
|
|
this.state = 2572;
|
|
this.match(SparkSqlParser.KW_ROWS);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 2574;
|
|
_localctx._sampleType = this.match(SparkSqlParser.KW_BUCKET);
|
|
this.state = 2575;
|
|
_localctx._numerator = this.match(SparkSqlParser.INTEGER_VALUE);
|
|
this.state = 2576;
|
|
this.match(SparkSqlParser.KW_OUT);
|
|
this.state = 2577;
|
|
this.match(SparkSqlParser.KW_OF);
|
|
this.state = 2578;
|
|
_localctx._denominator = this.match(SparkSqlParser.INTEGER_VALUE);
|
|
this.state = 2587;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ON) {
|
|
{
|
|
this.state = 2579;
|
|
this.match(SparkSqlParser.KW_ON);
|
|
this.state = 2585;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 329, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2580;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2581;
|
|
this.qualifiedName();
|
|
this.state = 2582;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2583;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 2589;
|
|
_localctx._bytes = this.expression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public identifierList(): IdentifierListContext {
|
|
let _localctx: IdentifierListContext = new IdentifierListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 204, SparkSqlParser.RULE_identifierList);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2592;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2593;
|
|
this.identifierSeq();
|
|
this.state = 2594;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public identifierSeq(): IdentifierSeqContext {
|
|
let _localctx: IdentifierSeqContext = new IdentifierSeqContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 206, SparkSqlParser.RULE_identifierSeq);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2596;
|
|
_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
|
|
_localctx._ident.push(_localctx._errorCapturingIdentifier);
|
|
this.state = 2601;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 332, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2597;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2598;
|
|
_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
|
|
_localctx._ident.push(_localctx._errorCapturingIdentifier);
|
|
}
|
|
}
|
|
}
|
|
this.state = 2603;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 332, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public orderedIdentifierList(): OrderedIdentifierListContext {
|
|
let _localctx: OrderedIdentifierListContext = new OrderedIdentifierListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 208, SparkSqlParser.RULE_orderedIdentifierList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2604;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2605;
|
|
this.orderedIdentifier();
|
|
this.state = 2610;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2606;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2607;
|
|
this.orderedIdentifier();
|
|
}
|
|
}
|
|
this.state = 2612;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2613;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public orderedIdentifier(): OrderedIdentifierContext {
|
|
let _localctx: OrderedIdentifierContext = new OrderedIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 210, SparkSqlParser.RULE_orderedIdentifier);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2615;
|
|
_localctx._ident = this.errorCapturingIdentifier();
|
|
this.state = 2617;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ASC || _la === SparkSqlParser.KW_DESC) {
|
|
{
|
|
this.state = 2616;
|
|
_localctx._ordering = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ASC || _la === SparkSqlParser.KW_DESC)) {
|
|
_localctx._ordering = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public identifierCommentList(): IdentifierCommentListContext {
|
|
let _localctx: IdentifierCommentListContext = new IdentifierCommentListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 212, SparkSqlParser.RULE_identifierCommentList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2619;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2620;
|
|
this.identifierComment();
|
|
this.state = 2625;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2621;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2622;
|
|
this.identifierComment();
|
|
}
|
|
}
|
|
this.state = 2627;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2628;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public identifierComment(): IdentifierCommentContext {
|
|
let _localctx: IdentifierCommentContext = new IdentifierCommentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 214, SparkSqlParser.RULE_identifierComment);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2630;
|
|
this.identifier();
|
|
this.state = 2632;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_COMMENT) {
|
|
{
|
|
this.state = 2631;
|
|
this.commentSpec();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public relationPrimary(): RelationPrimaryContext {
|
|
let _localctx: RelationPrimaryContext = new RelationPrimaryContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 216, SparkSqlParser.RULE_relationPrimary);
|
|
try {
|
|
this.state = 2661;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 341, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2634;
|
|
this.identifierReference();
|
|
this.state = 2636;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 337, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2635;
|
|
this.temporalClause();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2639;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 338, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2638;
|
|
this.sample();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2641;
|
|
this.tableAlias();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2643;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2644;
|
|
this.query();
|
|
this.state = 2645;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2647;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 339, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2646;
|
|
this.sample();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2649;
|
|
this.tableAlias();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 2651;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2652;
|
|
this.relation();
|
|
this.state = 2653;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2655;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 340, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2654;
|
|
this.sample();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2657;
|
|
this.tableAlias();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 2659;
|
|
this.inlineTable();
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 2660;
|
|
this.functionTable();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public inlineTable(): InlineTableContext {
|
|
let _localctx: InlineTableContext = new InlineTableContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 218, SparkSqlParser.RULE_inlineTable);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2663;
|
|
this.match(SparkSqlParser.KW_VALUES);
|
|
this.state = 2664;
|
|
this.expression();
|
|
this.state = 2669;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 342, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2665;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2666;
|
|
this.expression();
|
|
}
|
|
}
|
|
}
|
|
this.state = 2671;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 342, this._ctx);
|
|
}
|
|
this.state = 2672;
|
|
this.tableAlias();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext {
|
|
let _localctx: FunctionTableSubqueryArgumentContext = new FunctionTableSubqueryArgumentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 220, SparkSqlParser.RULE_functionTableSubqueryArgument);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2693;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 346, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2674;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 2675;
|
|
this.tableName();
|
|
this.state = 2677;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
|
|
{
|
|
this.state = 2676;
|
|
this.tableArgumentPartitioning();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2679;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 2680;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2681;
|
|
this.tableName();
|
|
this.state = 2682;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2684;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
|
|
{
|
|
this.state = 2683;
|
|
this.tableArgumentPartitioning();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 2686;
|
|
this.match(SparkSqlParser.KW_TABLE);
|
|
this.state = 2687;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2688;
|
|
this.query();
|
|
this.state = 2689;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2691;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
|
|
{
|
|
this.state = 2690;
|
|
this.tableArgumentPartitioning();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public tableArgumentPartitioning(): TableArgumentPartitioningContext {
|
|
let _localctx: TableArgumentPartitioningContext = new TableArgumentPartitioningContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 222, SparkSqlParser.RULE_tableArgumentPartitioning);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2714;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_WITH:
|
|
{
|
|
{
|
|
this.state = 2695;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 2696;
|
|
this.match(SparkSqlParser.KW_SINGLE);
|
|
this.state = 2697;
|
|
this.match(SparkSqlParser.KW_PARTITION);
|
|
}
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_DISTRIBUTE:
|
|
case SparkSqlParser.KW_PARTITION:
|
|
{
|
|
{
|
|
this.state = 2698;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2699;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2712;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 348, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
{
|
|
{
|
|
this.state = 2700;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2701;
|
|
_localctx._expression = this.expression();
|
|
_localctx._partition.push(_localctx._expression);
|
|
this.state = 2706;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2702;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2703;
|
|
_localctx._expression = this.expression();
|
|
_localctx._partition.push(_localctx._expression);
|
|
}
|
|
}
|
|
this.state = 2708;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2709;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2711;
|
|
_localctx._expression = this.expression();
|
|
_localctx._partition.push(_localctx._expression);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 2732;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT) {
|
|
{
|
|
this.state = 2716;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2717;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
{
|
|
this.state = 2730;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 351, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 2718;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2719;
|
|
this.sortItem();
|
|
this.state = 2724;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2720;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2721;
|
|
this.sortItem();
|
|
}
|
|
}
|
|
this.state = 2726;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2727;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2729;
|
|
this.sortItem();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionTableNamedArgumentExpression(): FunctionTableNamedArgumentExpressionContext {
|
|
let _localctx: FunctionTableNamedArgumentExpressionContext = new FunctionTableNamedArgumentExpressionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 224, SparkSqlParser.RULE_functionTableNamedArgumentExpression);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2734;
|
|
_localctx._key = this.identifier();
|
|
this.state = 2735;
|
|
this.match(SparkSqlParser.FAT_ARROW);
|
|
this.state = 2736;
|
|
_localctx._table = this.functionTableSubqueryArgument();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionTableReferenceArgument(): FunctionTableReferenceArgumentContext {
|
|
let _localctx: FunctionTableReferenceArgumentContext = new FunctionTableReferenceArgumentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 226, SparkSqlParser.RULE_functionTableReferenceArgument);
|
|
try {
|
|
this.state = 2740;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 353, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2738;
|
|
this.functionTableSubqueryArgument();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2739;
|
|
this.functionTableNamedArgumentExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionTableArgument(): FunctionTableArgumentContext {
|
|
let _localctx: FunctionTableArgumentContext = new FunctionTableArgumentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 228, SparkSqlParser.RULE_functionTableArgument);
|
|
try {
|
|
this.state = 2744;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 354, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2742;
|
|
this.functionTableReferenceArgument();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2743;
|
|
this.functionArgument();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionTable(): FunctionTableContext {
|
|
let _localctx: FunctionTableContext = new FunctionTableContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 230, SparkSqlParser.RULE_functionTable);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2746;
|
|
this.functionName();
|
|
this.state = 2747;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2756;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 356, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2748;
|
|
this.functionTableArgument();
|
|
this.state = 2753;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2749;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2750;
|
|
this.functionTableArgument();
|
|
}
|
|
}
|
|
this.state = 2755;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2758;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 2759;
|
|
this.tableAlias();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public tableAlias(): TableAliasContext {
|
|
let _localctx: TableAliasContext = new TableAliasContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 232, SparkSqlParser.RULE_tableAlias);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2768;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 359, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2762;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 357, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2761;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2764;
|
|
this.strictIdentifier();
|
|
this.state = 2766;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 358, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2765;
|
|
this.identifierList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public rowFormat(): RowFormatContext {
|
|
let _localctx: RowFormatContext = new RowFormatContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 234, SparkSqlParser.RULE_rowFormat);
|
|
try {
|
|
this.state = 2819;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 367, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2770;
|
|
this.match(SparkSqlParser.KW_ROW);
|
|
this.state = 2771;
|
|
this.match(SparkSqlParser.KW_FORMAT);
|
|
this.state = 2772;
|
|
this.match(SparkSqlParser.KW_SERDE);
|
|
this.state = 2773;
|
|
_localctx._name = this.stringLit();
|
|
this.state = 2777;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 360, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2774;
|
|
this.match(SparkSqlParser.KW_WITH);
|
|
this.state = 2775;
|
|
this.match(SparkSqlParser.KW_SERDEPROPERTIES);
|
|
this.state = 2776;
|
|
_localctx._props = this.propertyList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2779;
|
|
this.match(SparkSqlParser.KW_ROW);
|
|
this.state = 2780;
|
|
this.match(SparkSqlParser.KW_FORMAT);
|
|
this.state = 2781;
|
|
this.match(SparkSqlParser.KW_DELIMITED);
|
|
this.state = 2791;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 362, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2782;
|
|
this.match(SparkSqlParser.KW_FIELDS);
|
|
this.state = 2783;
|
|
this.match(SparkSqlParser.KW_TERMINATED);
|
|
this.state = 2784;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2785;
|
|
_localctx._fieldsTerminatedBy = this.stringLit();
|
|
this.state = 2789;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 361, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2786;
|
|
this.match(SparkSqlParser.KW_ESCAPED);
|
|
this.state = 2787;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2788;
|
|
_localctx._escapedBy = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2798;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 363, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2793;
|
|
this.match(SparkSqlParser.KW_COLLECTION);
|
|
this.state = 2794;
|
|
this.match(SparkSqlParser.KW_ITEMS);
|
|
this.state = 2795;
|
|
this.match(SparkSqlParser.KW_TERMINATED);
|
|
this.state = 2796;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2797;
|
|
_localctx._collectionItemsTerminatedBy = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2805;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 364, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2800;
|
|
this.match(SparkSqlParser.KW_MAP);
|
|
this.state = 2801;
|
|
this.match(SparkSqlParser.KW_KEYS);
|
|
this.state = 2802;
|
|
this.match(SparkSqlParser.KW_TERMINATED);
|
|
this.state = 2803;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2804;
|
|
_localctx._keysTerminatedBy = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2811;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 365, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2807;
|
|
this.match(SparkSqlParser.KW_LINES);
|
|
this.state = 2808;
|
|
this.match(SparkSqlParser.KW_TERMINATED);
|
|
this.state = 2809;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 2810;
|
|
_localctx._linesSeparatedBy = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2817;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 366, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2813;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
this.state = 2814;
|
|
this.match(SparkSqlParser.KW_DEFINED);
|
|
this.state = 2815;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 2816;
|
|
_localctx._nullDefinedAs = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public multipartIdentifierList(): MultipartIdentifierListContext {
|
|
let _localctx: MultipartIdentifierListContext = new MultipartIdentifierListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 236, SparkSqlParser.RULE_multipartIdentifierList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2821;
|
|
this.multipartIdentifier();
|
|
this.state = 2826;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2822;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2823;
|
|
this.multipartIdentifier();
|
|
}
|
|
}
|
|
this.state = 2828;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public multipartIdentifier(): MultipartIdentifierContext {
|
|
let _localctx: MultipartIdentifierContext = new MultipartIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 238, SparkSqlParser.RULE_multipartIdentifier);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2829;
|
|
_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
|
|
_localctx._parts.push(_localctx._errorCapturingIdentifier);
|
|
this.state = 2834;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 369, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2830;
|
|
this.match(SparkSqlParser.DOT);
|
|
this.state = 2831;
|
|
_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
|
|
_localctx._parts.push(_localctx._errorCapturingIdentifier);
|
|
}
|
|
}
|
|
}
|
|
this.state = 2836;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 369, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext {
|
|
let _localctx: MultipartIdentifierPropertyListContext = new MultipartIdentifierPropertyListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 240, SparkSqlParser.RULE_multipartIdentifierPropertyList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2837;
|
|
this.multipartIdentifierProperty();
|
|
this.state = 2842;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2838;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2839;
|
|
this.multipartIdentifierProperty();
|
|
}
|
|
}
|
|
this.state = 2844;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public multipartIdentifierProperty(): MultipartIdentifierPropertyContext {
|
|
let _localctx: MultipartIdentifierPropertyContext = new MultipartIdentifierPropertyContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 242, SparkSqlParser.RULE_multipartIdentifierProperty);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2845;
|
|
this.multipartIdentifier();
|
|
this.state = 2848;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_OPTIONS) {
|
|
{
|
|
this.state = 2846;
|
|
this.match(SparkSqlParser.KW_OPTIONS);
|
|
this.state = 2847;
|
|
_localctx._options = this.propertyList();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public tableIdentifier(): TableIdentifierContext {
|
|
let _localctx: TableIdentifierContext = new TableIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 244, SparkSqlParser.RULE_tableIdentifier);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2853;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 372, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2850;
|
|
_localctx._db = this.errorCapturingIdentifier();
|
|
this.state = 2851;
|
|
this.match(SparkSqlParser.DOT);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2855;
|
|
_localctx._table = this.errorCapturingIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public viewIdentifier(): ViewIdentifierContext {
|
|
let _localctx: ViewIdentifierContext = new ViewIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 246, SparkSqlParser.RULE_viewIdentifier);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2860;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 373, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2857;
|
|
_localctx._db = this.errorCapturingIdentifier();
|
|
this.state = 2858;
|
|
this.match(SparkSqlParser.DOT);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2862;
|
|
_localctx._view = this.errorCapturingIdentifier();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public namedExpression(): NamedExpressionContext {
|
|
let _localctx: NamedExpressionContext = new NamedExpressionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 248, SparkSqlParser.RULE_namedExpression);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2864;
|
|
this.expression();
|
|
this.state = 2872;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 376, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2866;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 374, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2865;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 2870;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 375, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2868;
|
|
_localctx._name = this.errorCapturingIdentifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2869;
|
|
this.identifierList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public namedExpressionSeq(): NamedExpressionSeqContext {
|
|
let _localctx: NamedExpressionSeqContext = new NamedExpressionSeqContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 250, SparkSqlParser.RULE_namedExpressionSeq);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2874;
|
|
this.namedExpression();
|
|
this.state = 2879;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 377, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 2875;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2876;
|
|
this.namedExpression();
|
|
}
|
|
}
|
|
}
|
|
this.state = 2881;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 377, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public partitionFieldList(): PartitionFieldListContext {
|
|
let _localctx: PartitionFieldListContext = new PartitionFieldListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 252, SparkSqlParser.RULE_partitionFieldList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2882;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2883;
|
|
_localctx._partitionField = this.partitionField();
|
|
_localctx._fields.push(_localctx._partitionField);
|
|
this.state = 2888;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2884;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2885;
|
|
_localctx._partitionField = this.partitionField();
|
|
_localctx._fields.push(_localctx._partitionField);
|
|
}
|
|
}
|
|
this.state = 2890;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2891;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public partitionField(): PartitionFieldContext {
|
|
let _localctx: PartitionFieldContext = new PartitionFieldContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 254, SparkSqlParser.RULE_partitionField);
|
|
try {
|
|
this.state = 2895;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 379, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2893;
|
|
this.transform();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2894;
|
|
this.colType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public transform(): TransformContext {
|
|
let _localctx: TransformContext = new TransformContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 256, SparkSqlParser.RULE_transform);
|
|
let _la: number;
|
|
try {
|
|
this.state = 2910;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 381, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2897;
|
|
this.qualifiedName();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2898;
|
|
_localctx._transformName = this.identifier();
|
|
this.state = 2899;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2900;
|
|
this.transformArgument();
|
|
this.state = 2905;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2901;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2902;
|
|
this.transformArgument();
|
|
}
|
|
}
|
|
this.state = 2907;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2908;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public transformArgument(): TransformArgumentContext {
|
|
let _localctx: TransformArgumentContext = new TransformArgumentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 258, SparkSqlParser.RULE_transformArgument);
|
|
try {
|
|
this.state = 2914;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 382, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2912;
|
|
this.qualifiedName();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2913;
|
|
this.constant();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public expression(): ExpressionContext {
|
|
let _localctx: ExpressionContext = new ExpressionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 260, SparkSqlParser.RULE_expression);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2916;
|
|
this.booleanExpression(0);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public namedArgumentExpression(): NamedArgumentExpressionContext {
|
|
let _localctx: NamedArgumentExpressionContext = new NamedArgumentExpressionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 262, SparkSqlParser.RULE_namedArgumentExpression);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2918;
|
|
_localctx._key = this.identifier();
|
|
this.state = 2919;
|
|
this.match(SparkSqlParser.FAT_ARROW);
|
|
this.state = 2920;
|
|
_localctx._value = this.expression();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionArgument(): FunctionArgumentContext {
|
|
let _localctx: FunctionArgumentContext = new FunctionArgumentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 264, SparkSqlParser.RULE_functionArgument);
|
|
try {
|
|
this.state = 2924;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 383, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2922;
|
|
this.expression();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2923;
|
|
this.namedArgumentExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public expressionSeq(): ExpressionSeqContext {
|
|
let _localctx: ExpressionSeqContext = new ExpressionSeqContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 266, SparkSqlParser.RULE_expressionSeq);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2926;
|
|
this.expression();
|
|
this.state = 2931;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2927;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2928;
|
|
this.expression();
|
|
}
|
|
}
|
|
this.state = 2933;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public booleanExpression(): BooleanExpressionContext;
|
|
public booleanExpression(_p: number): BooleanExpressionContext;
|
|
// @RuleVersion(0)
|
|
public booleanExpression(_p?: number): BooleanExpressionContext {
|
|
if (_p === undefined) {
|
|
_p = 0;
|
|
}
|
|
|
|
let _parentctx: ParserRuleContext = this._ctx;
|
|
let _parentState: number = this.state;
|
|
let _localctx: BooleanExpressionContext = new BooleanExpressionContext(this._ctx, _parentState);
|
|
let _prevctx: BooleanExpressionContext = _localctx;
|
|
let _startState: number = 268;
|
|
this.enterRecursionRule(_localctx, 268, SparkSqlParser.RULE_booleanExpression, _p);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2946;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 386, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2935;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_NOT || _la === SparkSqlParser.NOT)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2936;
|
|
this.booleanExpression(5);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 2937;
|
|
this.match(SparkSqlParser.KW_EXISTS);
|
|
this.state = 2938;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2939;
|
|
this.query();
|
|
this.state = 2940;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
this.state = 2942;
|
|
this.valueExpression(0);
|
|
this.state = 2944;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 385, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 2943;
|
|
this.predicate();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this._ctx._stop = this._input.tryLT(-1);
|
|
this.state = 2956;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 388, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
if (this._parseListeners != null) {
|
|
this.triggerExitRuleEvent();
|
|
}
|
|
_prevctx = _localctx;
|
|
{
|
|
this.state = 2954;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 387, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new BooleanExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_booleanExpression);
|
|
this.state = 2948;
|
|
if (!(this.precpred(this._ctx, 2))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
|
|
}
|
|
this.state = 2949;
|
|
_localctx._operator = this.match(SparkSqlParser.KW_AND);
|
|
this.state = 2950;
|
|
_localctx._right = this.booleanExpression(3);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
_localctx = new BooleanExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_booleanExpression);
|
|
this.state = 2951;
|
|
if (!(this.precpred(this._ctx, 1))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
|
|
}
|
|
this.state = 2952;
|
|
_localctx._operator = this.match(SparkSqlParser.KW_OR);
|
|
this.state = 2953;
|
|
_localctx._right = this.booleanExpression(2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.state = 2958;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 388, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public predicate(): PredicateContext {
|
|
let _localctx: PredicateContext = new PredicateContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 270, SparkSqlParser.RULE_predicate);
|
|
let _la: number;
|
|
try {
|
|
this.state = 3041;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 402, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 2960;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 2959;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 2962;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_BETWEEN);
|
|
this.state = 2963;
|
|
_localctx._lower = this.valueExpression(0);
|
|
this.state = 2964;
|
|
this.match(SparkSqlParser.KW_AND);
|
|
this.state = 2965;
|
|
_localctx._upper = this.valueExpression(0);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 2968;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 2967;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 2970;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_IN);
|
|
this.state = 2971;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2972;
|
|
this.expression();
|
|
this.state = 2977;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 2973;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 2974;
|
|
this.expression();
|
|
}
|
|
}
|
|
this.state = 2979;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 2980;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 2983;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 2982;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 2985;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_IN);
|
|
this.state = 2986;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 2987;
|
|
this.query();
|
|
this.state = 2988;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 2991;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 2990;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 2993;
|
|
_localctx._kind = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_RLIKE || _la === SparkSqlParser.KW_REGEXP)) {
|
|
_localctx._kind = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2994;
|
|
_localctx._pattern = this.valueExpression(0);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 2996;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 2995;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 2998;
|
|
_localctx._kind = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.KW_ILIKE)) {
|
|
_localctx._kind = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 2999;
|
|
_localctx._quantifier = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_ANY || _la === SparkSqlParser.KW_SOME)) {
|
|
_localctx._quantifier = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3013;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 396, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3000;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3001;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3002;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3003;
|
|
this.expression();
|
|
this.state = 3008;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3004;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3005;
|
|
this.expression();
|
|
}
|
|
}
|
|
this.state = 3010;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 3011;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 3016;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 3015;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 3018;
|
|
_localctx._kind = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.KW_ILIKE)) {
|
|
_localctx._kind = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3019;
|
|
_localctx._pattern = this.valueExpression(0);
|
|
this.state = 3022;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 398, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3020;
|
|
this.match(SparkSqlParser.KW_ESCAPE);
|
|
this.state = 3021;
|
|
_localctx._escapeChar = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 3024;
|
|
this.match(SparkSqlParser.KW_IS);
|
|
this.state = 3026;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 3025;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 3028;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
this.enterOuterAlt(_localctx, 8);
|
|
{
|
|
this.state = 3029;
|
|
this.match(SparkSqlParser.KW_IS);
|
|
this.state = 3031;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 3030;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 3033;
|
|
_localctx._kind = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FALSE || _la === SparkSqlParser.KW_TRUE || _la === SparkSqlParser.KW_UNKNOWN)) {
|
|
_localctx._kind = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 9:
|
|
this.enterOuterAlt(_localctx, 9);
|
|
{
|
|
this.state = 3034;
|
|
this.match(SparkSqlParser.KW_IS);
|
|
this.state = 3036;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 3035;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
}
|
|
}
|
|
|
|
this.state = 3038;
|
|
_localctx._kind = this.match(SparkSqlParser.KW_DISTINCT);
|
|
this.state = 3039;
|
|
this.match(SparkSqlParser.KW_FROM);
|
|
this.state = 3040;
|
|
_localctx._right = this.valueExpression(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public valueExpression(): ValueExpressionContext;
|
|
public valueExpression(_p: number): ValueExpressionContext;
|
|
// @RuleVersion(0)
|
|
public valueExpression(_p?: number): ValueExpressionContext {
|
|
if (_p === undefined) {
|
|
_p = 0;
|
|
}
|
|
|
|
let _parentctx: ParserRuleContext = this._ctx;
|
|
let _parentState: number = this.state;
|
|
let _localctx: ValueExpressionContext = new ValueExpressionContext(this._ctx, _parentState);
|
|
let _prevctx: ValueExpressionContext = _localctx;
|
|
let _startState: number = 272;
|
|
this.enterRecursionRule(_localctx, 272, SparkSqlParser.RULE_valueExpression, _p);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3047;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 403, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3044;
|
|
this.primaryExpression(0);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3045;
|
|
_localctx._operator = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.TILDE - 353)))) !== 0))) {
|
|
_localctx._operator = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3046;
|
|
this.valueExpression(7);
|
|
}
|
|
break;
|
|
}
|
|
this._ctx._stop = this._input.tryLT(-1);
|
|
this.state = 3070;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 405, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
if (this._parseListeners != null) {
|
|
this.triggerExitRuleEvent();
|
|
}
|
|
_prevctx = _localctx;
|
|
{
|
|
this.state = 3068;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 404, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new ValueExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
|
|
this.state = 3049;
|
|
if (!(this.precpred(this._ctx, 6))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 6)");
|
|
}
|
|
this.state = 3050;
|
|
_localctx._operator = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DIV || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & ((1 << (SparkSqlParser.ASTERISK - 355)) | (1 << (SparkSqlParser.SLASH - 355)) | (1 << (SparkSqlParser.PERCENT - 355)))) !== 0))) {
|
|
_localctx._operator = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3051;
|
|
_localctx._right = this.valueExpression(7);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
_localctx = new ValueExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
|
|
this.state = 3052;
|
|
if (!(this.precpred(this._ctx, 5))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
|
|
}
|
|
this.state = 3053;
|
|
_localctx._operator = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.CONCAT_PIPE - 353)))) !== 0))) {
|
|
_localctx._operator = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3054;
|
|
_localctx._right = this.valueExpression(6);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
_localctx = new ValueExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
|
|
this.state = 3055;
|
|
if (!(this.precpred(this._ctx, 4))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
|
|
}
|
|
this.state = 3056;
|
|
_localctx._operator = this.match(SparkSqlParser.AMPERSAND);
|
|
this.state = 3057;
|
|
_localctx._right = this.valueExpression(5);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
{
|
|
_localctx = new ValueExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
|
|
this.state = 3058;
|
|
if (!(this.precpred(this._ctx, 3))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
|
|
}
|
|
this.state = 3059;
|
|
_localctx._operator = this.match(SparkSqlParser.HAT);
|
|
this.state = 3060;
|
|
_localctx._right = this.valueExpression(4);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
{
|
|
_localctx = new ValueExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
|
|
this.state = 3061;
|
|
if (!(this.precpred(this._ctx, 2))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
|
|
}
|
|
this.state = 3062;
|
|
_localctx._operator = this.match(SparkSqlParser.PIPE);
|
|
this.state = 3063;
|
|
_localctx._right = this.valueExpression(3);
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
{
|
|
_localctx = new ValueExpressionContext(_parentctx, _parentState);
|
|
_localctx._left = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
|
|
this.state = 3064;
|
|
if (!(this.precpred(this._ctx, 1))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
|
|
}
|
|
this.state = 3065;
|
|
this.comparisonOperator();
|
|
this.state = 3066;
|
|
_localctx._right = this.valueExpression(2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.state = 3072;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 405, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public datetimeUnit(): DatetimeUnitContext {
|
|
let _localctx: DatetimeUnitContext = new DatetimeUnitContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 274, SparkSqlParser.RULE_datetimeUnit);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3073;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_DAYOFYEAR || _la === SparkSqlParser.KW_HOUR || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (SparkSqlParser.KW_MICROSECOND - 176)) | (1 << (SparkSqlParser.KW_MILLISECOND - 176)) | (1 << (SparkSqlParser.KW_MINUTE - 176)) | (1 << (SparkSqlParser.KW_MONTH - 176)))) !== 0) || _la === SparkSqlParser.KW_QUARTER || _la === SparkSqlParser.KW_SECOND || _la === SparkSqlParser.KW_WEEK || _la === SparkSqlParser.KW_YEAR)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public primaryExpression(): PrimaryExpressionContext;
|
|
public primaryExpression(_p: number): PrimaryExpressionContext;
|
|
// @RuleVersion(0)
|
|
public primaryExpression(_p?: number): PrimaryExpressionContext {
|
|
if (_p === undefined) {
|
|
_p = 0;
|
|
}
|
|
|
|
let _parentctx: ParserRuleContext = this._ctx;
|
|
let _parentState: number = this.state;
|
|
let _localctx: PrimaryExpressionContext = new PrimaryExpressionContext(this._ctx, _parentState);
|
|
let _prevctx: PrimaryExpressionContext = _localctx;
|
|
let _startState: number = 276;
|
|
this.enterRecursionRule(_localctx, 276, SparkSqlParser.RULE_primaryExpression, _p);
|
|
let _la: number;
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3324;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 431, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3076;
|
|
_localctx._name = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(((((_la - 63)) & ~0x1F) === 0 && ((1 << (_la - 63)) & ((1 << (SparkSqlParser.KW_CURRENT_DATE - 63)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 63)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 63)))) !== 0) || _la === SparkSqlParser.KW_SESSION_USER || _la === SparkSqlParser.KW_USER)) {
|
|
_localctx._name = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3077;
|
|
_localctx._name = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DATEADD || _la === SparkSqlParser.KW_DATE_ADD || _la === SparkSqlParser.KW_TIMESTAMPADD)) {
|
|
_localctx._name = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3078;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3081;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 406, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3079;
|
|
_localctx._unit = this.datetimeUnit();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3080;
|
|
_localctx._invalidUnit = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3083;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3084;
|
|
_localctx._unitsAmount = this.valueExpression(0);
|
|
this.state = 3085;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3086;
|
|
_localctx._timestamp = this.valueExpression(0);
|
|
this.state = 3087;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
this.state = 3089;
|
|
_localctx._name = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DATEDIFF || _la === SparkSqlParser.KW_DATE_DIFF || _la === SparkSqlParser.KW_TIMEDIFF || _la === SparkSqlParser.KW_TIMESTAMPDIFF)) {
|
|
_localctx._name = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3090;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3093;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 407, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3091;
|
|
_localctx._unit = this.datetimeUnit();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3092;
|
|
_localctx._invalidUnit = this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3095;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3096;
|
|
_localctx._startTimestamp = this.valueExpression(0);
|
|
this.state = 3097;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3098;
|
|
_localctx._endTimestamp = this.valueExpression(0);
|
|
this.state = 3099;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
{
|
|
this.state = 3101;
|
|
this.match(SparkSqlParser.KW_CASE);
|
|
this.state = 3103;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
this.state = 3102;
|
|
this.whenClause();
|
|
}
|
|
}
|
|
this.state = 3105;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
} while (_la === SparkSqlParser.KW_WHEN);
|
|
this.state = 3109;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ELSE) {
|
|
{
|
|
this.state = 3107;
|
|
this.match(SparkSqlParser.KW_ELSE);
|
|
this.state = 3108;
|
|
_localctx._elseExpression = this.expression();
|
|
}
|
|
}
|
|
|
|
this.state = 3111;
|
|
this.match(SparkSqlParser.KW_END);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
{
|
|
this.state = 3113;
|
|
this.match(SparkSqlParser.KW_CASE);
|
|
this.state = 3114;
|
|
this.expression();
|
|
this.state = 3116;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
this.state = 3115;
|
|
this.whenClause();
|
|
}
|
|
}
|
|
this.state = 3118;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
} while (_la === SparkSqlParser.KW_WHEN);
|
|
this.state = 3122;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ELSE) {
|
|
{
|
|
this.state = 3120;
|
|
this.match(SparkSqlParser.KW_ELSE);
|
|
this.state = 3121;
|
|
_localctx._elseExpression = this.expression();
|
|
}
|
|
}
|
|
|
|
this.state = 3124;
|
|
this.match(SparkSqlParser.KW_END);
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
{
|
|
this.state = 3126;
|
|
_localctx._name = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_CAST || _la === SparkSqlParser.KW_TRY_CAST)) {
|
|
_localctx._name = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3127;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3128;
|
|
this.expression();
|
|
this.state = 3129;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 3130;
|
|
this.dataType();
|
|
this.state = 3131;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
{
|
|
this.state = 3133;
|
|
this.match(SparkSqlParser.KW_STRUCT);
|
|
this.state = 3134;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3143;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 413, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3135;
|
|
this.namedExpression();
|
|
this.state = 3140;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3136;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3137;
|
|
this.namedExpression();
|
|
}
|
|
}
|
|
this.state = 3142;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3145;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
{
|
|
this.state = 3146;
|
|
this.match(SparkSqlParser.KW_FIRST);
|
|
this.state = 3147;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3148;
|
|
this.expression();
|
|
this.state = 3151;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IGNORE) {
|
|
{
|
|
this.state = 3149;
|
|
this.match(SparkSqlParser.KW_IGNORE);
|
|
this.state = 3150;
|
|
this.match(SparkSqlParser.KW_NULLS);
|
|
}
|
|
}
|
|
|
|
this.state = 3153;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 9:
|
|
{
|
|
this.state = 3155;
|
|
this.match(SparkSqlParser.KW_ANY_VALUE);
|
|
this.state = 3156;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3157;
|
|
this.expression();
|
|
this.state = 3160;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IGNORE) {
|
|
{
|
|
this.state = 3158;
|
|
this.match(SparkSqlParser.KW_IGNORE);
|
|
this.state = 3159;
|
|
this.match(SparkSqlParser.KW_NULLS);
|
|
}
|
|
}
|
|
|
|
this.state = 3162;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 10:
|
|
{
|
|
this.state = 3164;
|
|
this.match(SparkSqlParser.KW_LAST);
|
|
this.state = 3165;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3166;
|
|
this.expression();
|
|
this.state = 3169;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_IGNORE) {
|
|
{
|
|
this.state = 3167;
|
|
this.match(SparkSqlParser.KW_IGNORE);
|
|
this.state = 3168;
|
|
this.match(SparkSqlParser.KW_NULLS);
|
|
}
|
|
}
|
|
|
|
this.state = 3171;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 11:
|
|
{
|
|
this.state = 3173;
|
|
this.match(SparkSqlParser.KW_POSITION);
|
|
this.state = 3174;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3175;
|
|
_localctx._substr = this.valueExpression(0);
|
|
this.state = 3176;
|
|
this.match(SparkSqlParser.KW_IN);
|
|
this.state = 3177;
|
|
_localctx._str = this.valueExpression(0);
|
|
this.state = 3178;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 12:
|
|
{
|
|
this.state = 3180;
|
|
this.constant();
|
|
}
|
|
break;
|
|
|
|
case 13:
|
|
{
|
|
this.state = 3181;
|
|
this.match(SparkSqlParser.ASTERISK);
|
|
}
|
|
break;
|
|
|
|
case 14:
|
|
{
|
|
this.state = 3182;
|
|
this.qualifiedName();
|
|
this.state = 3183;
|
|
this.match(SparkSqlParser.DOT);
|
|
this.state = 3184;
|
|
this.match(SparkSqlParser.ASTERISK);
|
|
}
|
|
break;
|
|
|
|
case 15:
|
|
{
|
|
this.state = 3186;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3187;
|
|
this.namedExpression();
|
|
this.state = 3190;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
this.state = 3188;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3189;
|
|
this.namedExpression();
|
|
}
|
|
}
|
|
this.state = 3192;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
} while (_la === SparkSqlParser.COMMA);
|
|
this.state = 3194;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
{
|
|
this.state = 3196;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3197;
|
|
this.query();
|
|
this.state = 3198;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 17:
|
|
{
|
|
this.state = 3200;
|
|
this.match(SparkSqlParser.KW_IDENTIFIER_KW);
|
|
this.state = 3201;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3202;
|
|
this.expression();
|
|
this.state = 3203;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 18:
|
|
{
|
|
this.state = 3205;
|
|
this.functionName();
|
|
this.state = 3206;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3218;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 420, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3208;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 418, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3207;
|
|
this.setQuantifier();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3210;
|
|
this.functionArgument();
|
|
this.state = 3215;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3211;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3212;
|
|
this.functionArgument();
|
|
}
|
|
}
|
|
this.state = 3217;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3220;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 3227;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 421, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3221;
|
|
this.match(SparkSqlParser.KW_FILTER);
|
|
this.state = 3222;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3223;
|
|
this.match(SparkSqlParser.KW_WHERE);
|
|
this.state = 3224;
|
|
_localctx._where = this.booleanExpression(0);
|
|
this.state = 3225;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3231;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 422, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3229;
|
|
_localctx._nullsOption = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_IGNORE || _la === SparkSqlParser.KW_RESPECT)) {
|
|
_localctx._nullsOption = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3230;
|
|
this.match(SparkSqlParser.KW_NULLS);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3235;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 423, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3233;
|
|
this.match(SparkSqlParser.KW_OVER);
|
|
this.state = 3234;
|
|
this.windowSpec();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 19:
|
|
{
|
|
this.state = 3237;
|
|
this.identifier();
|
|
this.state = 3238;
|
|
this.match(SparkSqlParser.ARROW);
|
|
this.state = 3239;
|
|
this.expression();
|
|
}
|
|
break;
|
|
|
|
case 20:
|
|
{
|
|
this.state = 3241;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3242;
|
|
this.identifier();
|
|
this.state = 3245;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
this.state = 3243;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3244;
|
|
this.identifier();
|
|
}
|
|
}
|
|
this.state = 3247;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
} while (_la === SparkSqlParser.COMMA);
|
|
this.state = 3249;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 3250;
|
|
this.match(SparkSqlParser.ARROW);
|
|
this.state = 3251;
|
|
this.expression();
|
|
}
|
|
break;
|
|
|
|
case 21:
|
|
{
|
|
this.state = 3253;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
|
|
case 22:
|
|
{
|
|
this.state = 3254;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3255;
|
|
this.expression();
|
|
this.state = 3256;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 23:
|
|
{
|
|
this.state = 3258;
|
|
this.match(SparkSqlParser.KW_EXTRACT);
|
|
this.state = 3259;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3260;
|
|
_localctx._field = this.identifier();
|
|
this.state = 3261;
|
|
this.match(SparkSqlParser.KW_FROM);
|
|
this.state = 3262;
|
|
_localctx._source = this.valueExpression(0);
|
|
this.state = 3263;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 24:
|
|
{
|
|
this.state = 3265;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_SUBSTR || _la === SparkSqlParser.KW_SUBSTRING)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3266;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3267;
|
|
_localctx._str = this.valueExpression(0);
|
|
this.state = 3268;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.COMMA || _la === SparkSqlParser.KW_FROM)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3269;
|
|
_localctx._pos = this.valueExpression(0);
|
|
this.state = 3272;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.COMMA || _la === SparkSqlParser.KW_FOR) {
|
|
{
|
|
this.state = 3270;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.COMMA || _la === SparkSqlParser.KW_FOR)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3271;
|
|
_localctx._len = this.valueExpression(0);
|
|
}
|
|
}
|
|
|
|
this.state = 3274;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 25:
|
|
{
|
|
this.state = 3276;
|
|
this.match(SparkSqlParser.KW_TRIM);
|
|
this.state = 3277;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3279;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 426, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3278;
|
|
_localctx._trimOption = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_BOTH || _la === SparkSqlParser.KW_LEADING || _la === SparkSqlParser.KW_TRAILING)) {
|
|
_localctx._trimOption = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3282;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 427, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3281;
|
|
_localctx._trimStr = this.valueExpression(0);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3284;
|
|
this.match(SparkSqlParser.KW_FROM);
|
|
this.state = 3285;
|
|
_localctx._srcStr = this.valueExpression(0);
|
|
this.state = 3286;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 26:
|
|
{
|
|
this.state = 3288;
|
|
this.match(SparkSqlParser.KW_OVERLAY);
|
|
this.state = 3289;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3290;
|
|
_localctx._input = this.valueExpression(0);
|
|
this.state = 3291;
|
|
this.match(SparkSqlParser.KW_PLACING);
|
|
this.state = 3292;
|
|
_localctx._replace = this.valueExpression(0);
|
|
this.state = 3293;
|
|
this.match(SparkSqlParser.KW_FROM);
|
|
this.state = 3294;
|
|
_localctx._position = this.valueExpression(0);
|
|
this.state = 3297;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_FOR) {
|
|
{
|
|
this.state = 3295;
|
|
this.match(SparkSqlParser.KW_FOR);
|
|
this.state = 3296;
|
|
_localctx._length = this.valueExpression(0);
|
|
}
|
|
}
|
|
|
|
this.state = 3299;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 27:
|
|
{
|
|
this.state = 3301;
|
|
_localctx._name = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_PERCENTILE_CONT || _la === SparkSqlParser.KW_PERCENTILE_DISC)) {
|
|
_localctx._name = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3302;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3303;
|
|
_localctx._percentage = this.valueExpression(0);
|
|
this.state = 3304;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 3305;
|
|
this.match(SparkSqlParser.KW_WITHIN);
|
|
this.state = 3306;
|
|
this.match(SparkSqlParser.KW_GROUP);
|
|
this.state = 3307;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3308;
|
|
this.match(SparkSqlParser.KW_ORDER);
|
|
this.state = 3309;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 3310;
|
|
this.sortItem();
|
|
this.state = 3311;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
this.state = 3318;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 429, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3312;
|
|
this.match(SparkSqlParser.KW_FILTER);
|
|
this.state = 3313;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3314;
|
|
this.match(SparkSqlParser.KW_WHERE);
|
|
this.state = 3315;
|
|
_localctx._where = this.booleanExpression(0);
|
|
this.state = 3316;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3322;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 430, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3320;
|
|
this.match(SparkSqlParser.KW_OVER);
|
|
this.state = 3321;
|
|
this.windowSpec();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this._ctx._stop = this._input.tryLT(-1);
|
|
this.state = 3336;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 433, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
if (this._parseListeners != null) {
|
|
this.triggerExitRuleEvent();
|
|
}
|
|
_prevctx = _localctx;
|
|
{
|
|
this.state = 3334;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 432, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new PrimaryExpressionContext(_parentctx, _parentState);
|
|
_localctx._value = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_primaryExpression);
|
|
this.state = 3326;
|
|
if (!(this.precpred(this._ctx, 9))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 9)");
|
|
}
|
|
this.state = 3327;
|
|
this.match(SparkSqlParser.LEFT_BRACKET);
|
|
this.state = 3328;
|
|
_localctx._index = this.valueExpression(0);
|
|
this.state = 3329;
|
|
this.match(SparkSqlParser.RIGHT_BRACKET);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
_localctx = new PrimaryExpressionContext(_parentctx, _parentState);
|
|
_localctx._base = _prevctx;
|
|
this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_primaryExpression);
|
|
this.state = 3331;
|
|
if (!(this.precpred(this._ctx, 7))) {
|
|
throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
|
|
}
|
|
this.state = 3332;
|
|
this.match(SparkSqlParser.DOT);
|
|
this.state = 3333;
|
|
_localctx._fieldName = this.identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.state = 3338;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 433, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public literalType(): LiteralTypeContext {
|
|
let _localctx: LiteralTypeContext = new LiteralTypeContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 278, SparkSqlParser.RULE_literalType);
|
|
try {
|
|
this.state = 3346;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 434, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3339;
|
|
this.match(SparkSqlParser.KW_DATE);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3340;
|
|
this.match(SparkSqlParser.KW_TIMESTAMP);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3341;
|
|
this.match(SparkSqlParser.KW_TIMESTAMP_LTZ);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3342;
|
|
this.match(SparkSqlParser.KW_TIMESTAMP_NTZ);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 3343;
|
|
this.match(SparkSqlParser.KW_INTERVAL);
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 3344;
|
|
this.match(SparkSqlParser.KW_BINARY_HEX);
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 3345;
|
|
_localctx._unsupportedType = this.identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public constant(): ConstantContext {
|
|
let _localctx: ConstantContext = new ConstantContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 280, SparkSqlParser.RULE_constant);
|
|
try {
|
|
let _alt: number;
|
|
this.state = 3363;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 436, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3348;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3349;
|
|
this.match(SparkSqlParser.QUESTION);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3350;
|
|
this.match(SparkSqlParser.COLON);
|
|
this.state = 3351;
|
|
this.identifier();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3352;
|
|
this.interval();
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 3353;
|
|
this.literalType();
|
|
this.state = 3354;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 3356;
|
|
this.number();
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 3357;
|
|
this.booleanValue();
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
this.enterOuterAlt(_localctx, 8);
|
|
{
|
|
this.state = 3359;
|
|
this._errHandler.sync(this);
|
|
_alt = 1;
|
|
do {
|
|
switch (_alt) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 3358;
|
|
this.stringLit();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 3361;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 435, this._ctx);
|
|
} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public comparisonOperator(): ComparisonOperatorContext {
|
|
let _localctx: ComparisonOperatorContext = new ComparisonOperatorContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 282, SparkSqlParser.RULE_comparisonOperator);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3365;
|
|
_la = this._input.LA(1);
|
|
if (!(((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (SparkSqlParser.EQ - 344)) | (1 << (SparkSqlParser.NSEQ - 344)) | (1 << (SparkSqlParser.NEQ - 344)) | (1 << (SparkSqlParser.NEQJ - 344)) | (1 << (SparkSqlParser.LT - 344)) | (1 << (SparkSqlParser.LTE - 344)) | (1 << (SparkSqlParser.GT - 344)) | (1 << (SparkSqlParser.GTE - 344)))) !== 0))) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public arithmeticOperator(): ArithmeticOperatorContext {
|
|
let _localctx: ArithmeticOperatorContext = new ArithmeticOperatorContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 284, SparkSqlParser.RULE_arithmeticOperator);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3367;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DIV || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.SLASH - 353)) | (1 << (SparkSqlParser.PERCENT - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.AMPERSAND - 353)) | (1 << (SparkSqlParser.PIPE - 353)) | (1 << (SparkSqlParser.CONCAT_PIPE - 353)) | (1 << (SparkSqlParser.HAT - 353)))) !== 0))) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public predicateOperator(): PredicateOperatorContext {
|
|
let _localctx: PredicateOperatorContext = new PredicateOperatorContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 286, SparkSqlParser.RULE_predicateOperator);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3369;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_AND || _la === SparkSqlParser.KW_IN || _la === SparkSqlParser.KW_NOT || _la === SparkSqlParser.KW_OR)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public booleanValue(): BooleanValueContext {
|
|
let _localctx: BooleanValueContext = new BooleanValueContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 288, SparkSqlParser.RULE_booleanValue);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3371;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FALSE || _la === SparkSqlParser.KW_TRUE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public interval(): IntervalContext {
|
|
let _localctx: IntervalContext = new IntervalContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 290, SparkSqlParser.RULE_interval);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3373;
|
|
this.match(SparkSqlParser.KW_INTERVAL);
|
|
this.state = 3376;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 437, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3374;
|
|
this.errorCapturingMultiUnitsInterval();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3375;
|
|
this.errorCapturingUnitToUnitInterval();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext {
|
|
let _localctx: ErrorCapturingMultiUnitsIntervalContext = new ErrorCapturingMultiUnitsIntervalContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 292, SparkSqlParser.RULE_errorCapturingMultiUnitsInterval);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3378;
|
|
_localctx._body = this.multiUnitsInterval();
|
|
this.state = 3380;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 438, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3379;
|
|
this.unitToUnitInterval();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public multiUnitsInterval(): MultiUnitsIntervalContext {
|
|
let _localctx: MultiUnitsIntervalContext = new MultiUnitsIntervalContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 294, SparkSqlParser.RULE_multiUnitsInterval);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3385;
|
|
this._errHandler.sync(this);
|
|
_alt = 1;
|
|
do {
|
|
switch (_alt) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 3382;
|
|
this.intervalValue();
|
|
this.state = 3383;
|
|
_localctx._unitInMultiUnits = this.unitInMultiUnits();
|
|
_localctx._unit.push(_localctx._unitInMultiUnits);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 3387;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 439, this._ctx);
|
|
} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext {
|
|
let _localctx: ErrorCapturingUnitToUnitIntervalContext = new ErrorCapturingUnitToUnitIntervalContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 296, SparkSqlParser.RULE_errorCapturingUnitToUnitInterval);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3389;
|
|
_localctx._body = this.unitToUnitInterval();
|
|
this.state = 3392;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 440, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3390;
|
|
_localctx._error1 = this.multiUnitsInterval();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3391;
|
|
_localctx._error2 = this.unitToUnitInterval();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unitToUnitInterval(): UnitToUnitIntervalContext {
|
|
let _localctx: UnitToUnitIntervalContext = new UnitToUnitIntervalContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 298, SparkSqlParser.RULE_unitToUnitInterval);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3394;
|
|
_localctx._value = this.intervalValue();
|
|
this.state = 3395;
|
|
this.unitInUnitToUnit();
|
|
this.state = 3396;
|
|
this.match(SparkSqlParser.KW_TO);
|
|
this.state = 3397;
|
|
this.unitInUnitToUnit();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public intervalValue(): IntervalValueContext {
|
|
let _localctx: IntervalValueContext = new IntervalValueContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 300, SparkSqlParser.RULE_intervalValue);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3400;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 441, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3399;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.PLUS || _la === SparkSqlParser.MINUS)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3405;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 442, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3402;
|
|
this.match(SparkSqlParser.INTEGER_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
this.state = 3403;
|
|
this.match(SparkSqlParser.DECIMAL_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
this.state = 3404;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unitInMultiUnits(): UnitInMultiUnitsContext {
|
|
let _localctx: UnitInMultiUnitsContext = new UnitInMultiUnitsContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 302, SparkSqlParser.RULE_unitInMultiUnits);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3407;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_DAYS || _la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_HOURS || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (SparkSqlParser.KW_MICROSECOND - 176)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 176)) | (1 << (SparkSqlParser.KW_MILLISECOND - 176)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 176)) | (1 << (SparkSqlParser.KW_MINUTE - 176)) | (1 << (SparkSqlParser.KW_MINUTES - 176)) | (1 << (SparkSqlParser.KW_MONTH - 176)) | (1 << (SparkSqlParser.KW_MONTHS - 176)) | (1 << (SparkSqlParser.KW_NANOSECOND - 176)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 176)))) !== 0) || _la === SparkSqlParser.KW_SECOND || _la === SparkSqlParser.KW_SECONDS || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (SparkSqlParser.KW_WEEK - 334)) | (1 << (SparkSqlParser.KW_WEEKS - 334)) | (1 << (SparkSqlParser.KW_YEAR - 334)) | (1 << (SparkSqlParser.KW_YEARS - 334)))) !== 0))) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public unitInUnitToUnit(): UnitInUnitToUnitContext {
|
|
let _localctx: UnitInUnitToUnitContext = new UnitInUnitToUnitContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 304, SparkSqlParser.RULE_unitInUnitToUnit);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3409;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_MINUTE || _la === SparkSqlParser.KW_MONTH || _la === SparkSqlParser.KW_SECOND || _la === SparkSqlParser.KW_YEAR)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public colPosition(): ColPositionContext {
|
|
let _localctx: ColPositionContext = new ColPositionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 306, SparkSqlParser.RULE_colPosition);
|
|
try {
|
|
this.state = 3414;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_FIRST:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3411;
|
|
_localctx._position = this.match(SparkSqlParser.KW_FIRST);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_AFTER:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3412;
|
|
_localctx._position = this.match(SparkSqlParser.KW_AFTER);
|
|
this.state = 3413;
|
|
_localctx._afterCol = this.errorCapturingIdentifier();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public type(): TypeContext {
|
|
let _localctx: TypeContext = new TypeContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 308, SparkSqlParser.RULE_type);
|
|
try {
|
|
this.state = 3446;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 444, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3416;
|
|
this.match(SparkSqlParser.KW_BOOLEAN);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3417;
|
|
this.match(SparkSqlParser.KW_TINYINT);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3418;
|
|
this.match(SparkSqlParser.KW_BYTE);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3419;
|
|
this.match(SparkSqlParser.KW_SMALLINT);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 3420;
|
|
this.match(SparkSqlParser.KW_SHORT);
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 3421;
|
|
this.match(SparkSqlParser.KW_INT);
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 3422;
|
|
this.match(SparkSqlParser.KW_INTEGER);
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
this.enterOuterAlt(_localctx, 8);
|
|
{
|
|
this.state = 3423;
|
|
this.match(SparkSqlParser.KW_BIGINT);
|
|
}
|
|
break;
|
|
|
|
case 9:
|
|
this.enterOuterAlt(_localctx, 9);
|
|
{
|
|
this.state = 3424;
|
|
this.match(SparkSqlParser.KW_LONG);
|
|
}
|
|
break;
|
|
|
|
case 10:
|
|
this.enterOuterAlt(_localctx, 10);
|
|
{
|
|
this.state = 3425;
|
|
this.match(SparkSqlParser.KW_FLOAT);
|
|
}
|
|
break;
|
|
|
|
case 11:
|
|
this.enterOuterAlt(_localctx, 11);
|
|
{
|
|
this.state = 3426;
|
|
this.match(SparkSqlParser.KW_REAL);
|
|
}
|
|
break;
|
|
|
|
case 12:
|
|
this.enterOuterAlt(_localctx, 12);
|
|
{
|
|
this.state = 3427;
|
|
this.match(SparkSqlParser.KW_DOUBLE);
|
|
}
|
|
break;
|
|
|
|
case 13:
|
|
this.enterOuterAlt(_localctx, 13);
|
|
{
|
|
this.state = 3428;
|
|
this.match(SparkSqlParser.KW_DATE);
|
|
}
|
|
break;
|
|
|
|
case 14:
|
|
this.enterOuterAlt(_localctx, 14);
|
|
{
|
|
this.state = 3429;
|
|
this.match(SparkSqlParser.KW_TIMESTAMP);
|
|
}
|
|
break;
|
|
|
|
case 15:
|
|
this.enterOuterAlt(_localctx, 15);
|
|
{
|
|
this.state = 3430;
|
|
this.match(SparkSqlParser.KW_TIMESTAMP_NTZ);
|
|
}
|
|
break;
|
|
|
|
case 16:
|
|
this.enterOuterAlt(_localctx, 16);
|
|
{
|
|
this.state = 3431;
|
|
this.match(SparkSqlParser.KW_TIMESTAMP_LTZ);
|
|
}
|
|
break;
|
|
|
|
case 17:
|
|
this.enterOuterAlt(_localctx, 17);
|
|
{
|
|
this.state = 3432;
|
|
this.match(SparkSqlParser.KW_STRING);
|
|
}
|
|
break;
|
|
|
|
case 18:
|
|
this.enterOuterAlt(_localctx, 18);
|
|
{
|
|
this.state = 3433;
|
|
this.match(SparkSqlParser.KW_CHARACTER);
|
|
}
|
|
break;
|
|
|
|
case 19:
|
|
this.enterOuterAlt(_localctx, 19);
|
|
{
|
|
this.state = 3434;
|
|
this.match(SparkSqlParser.KW_CHAR);
|
|
}
|
|
break;
|
|
|
|
case 20:
|
|
this.enterOuterAlt(_localctx, 20);
|
|
{
|
|
this.state = 3435;
|
|
this.match(SparkSqlParser.KW_VARCHAR);
|
|
}
|
|
break;
|
|
|
|
case 21:
|
|
this.enterOuterAlt(_localctx, 21);
|
|
{
|
|
this.state = 3436;
|
|
this.match(SparkSqlParser.KW_BINARY);
|
|
}
|
|
break;
|
|
|
|
case 22:
|
|
this.enterOuterAlt(_localctx, 22);
|
|
{
|
|
this.state = 3437;
|
|
this.match(SparkSqlParser.KW_DECIMAL);
|
|
}
|
|
break;
|
|
|
|
case 23:
|
|
this.enterOuterAlt(_localctx, 23);
|
|
{
|
|
this.state = 3438;
|
|
this.match(SparkSqlParser.KW_DEC);
|
|
}
|
|
break;
|
|
|
|
case 24:
|
|
this.enterOuterAlt(_localctx, 24);
|
|
{
|
|
this.state = 3439;
|
|
this.match(SparkSqlParser.KW_NUMERIC);
|
|
}
|
|
break;
|
|
|
|
case 25:
|
|
this.enterOuterAlt(_localctx, 25);
|
|
{
|
|
this.state = 3440;
|
|
this.match(SparkSqlParser.KW_VOID);
|
|
}
|
|
break;
|
|
|
|
case 26:
|
|
this.enterOuterAlt(_localctx, 26);
|
|
{
|
|
this.state = 3441;
|
|
this.match(SparkSqlParser.KW_INTERVAL);
|
|
}
|
|
break;
|
|
|
|
case 27:
|
|
this.enterOuterAlt(_localctx, 27);
|
|
{
|
|
this.state = 3442;
|
|
this.match(SparkSqlParser.KW_ARRAY);
|
|
}
|
|
break;
|
|
|
|
case 28:
|
|
this.enterOuterAlt(_localctx, 28);
|
|
{
|
|
this.state = 3443;
|
|
this.match(SparkSqlParser.KW_STRUCT);
|
|
}
|
|
break;
|
|
|
|
case 29:
|
|
this.enterOuterAlt(_localctx, 29);
|
|
{
|
|
this.state = 3444;
|
|
this.match(SparkSqlParser.KW_MAP);
|
|
}
|
|
break;
|
|
|
|
case 30:
|
|
this.enterOuterAlt(_localctx, 30);
|
|
{
|
|
this.state = 3445;
|
|
_localctx._unsupportedType = this.identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public dataType(): DataTypeContext {
|
|
let _localctx: DataTypeContext = new DataTypeContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 310, SparkSqlParser.RULE_dataType);
|
|
let _la: number;
|
|
try {
|
|
this.state = 3494;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 451, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3448;
|
|
_localctx._complex = this.match(SparkSqlParser.KW_ARRAY);
|
|
this.state = 3449;
|
|
this.match(SparkSqlParser.LT);
|
|
this.state = 3450;
|
|
this.dataType();
|
|
this.state = 3451;
|
|
this.match(SparkSqlParser.GT);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3453;
|
|
_localctx._complex = this.match(SparkSqlParser.KW_MAP);
|
|
this.state = 3454;
|
|
this.match(SparkSqlParser.LT);
|
|
this.state = 3455;
|
|
this.dataType();
|
|
this.state = 3456;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3457;
|
|
this.dataType();
|
|
this.state = 3458;
|
|
this.match(SparkSqlParser.GT);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3460;
|
|
_localctx._complex = this.match(SparkSqlParser.KW_STRUCT);
|
|
this.state = 3467;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.LT:
|
|
{
|
|
this.state = 3461;
|
|
this.match(SparkSqlParser.LT);
|
|
this.state = 3463;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 445, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3462;
|
|
this.complexColTypeList();
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3465;
|
|
this.match(SparkSqlParser.GT);
|
|
}
|
|
break;
|
|
case SparkSqlParser.NEQ:
|
|
{
|
|
this.state = 3466;
|
|
this.match(SparkSqlParser.NEQ);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3469;
|
|
this.match(SparkSqlParser.KW_INTERVAL);
|
|
this.state = 3470;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_MONTH || _la === SparkSqlParser.KW_YEAR)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3473;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 447, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3471;
|
|
this.match(SparkSqlParser.KW_TO);
|
|
this.state = 3472;
|
|
this.match(SparkSqlParser.KW_MONTH);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 3475;
|
|
this.match(SparkSqlParser.KW_INTERVAL);
|
|
this.state = 3476;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_MINUTE || _la === SparkSqlParser.KW_SECOND)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3479;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 448, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3477;
|
|
this.match(SparkSqlParser.KW_TO);
|
|
this.state = 3478;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_MINUTE || _la === SparkSqlParser.KW_SECOND)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 3481;
|
|
this.type();
|
|
this.state = 3492;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 450, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3482;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3483;
|
|
this.match(SparkSqlParser.INTEGER_VALUE);
|
|
this.state = 3488;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3484;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3485;
|
|
this.match(SparkSqlParser.INTEGER_VALUE);
|
|
}
|
|
}
|
|
this.state = 3490;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
this.state = 3491;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public qualifiedColTypeWithPositionList(): QualifiedColTypeWithPositionListContext {
|
|
let _localctx: QualifiedColTypeWithPositionListContext = new QualifiedColTypeWithPositionListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 312, SparkSqlParser.RULE_qualifiedColTypeWithPositionList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3496;
|
|
this.qualifiedColTypeWithPosition();
|
|
this.state = 3501;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3497;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3498;
|
|
this.qualifiedColTypeWithPosition();
|
|
}
|
|
}
|
|
this.state = 3503;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public qualifiedColTypeWithPosition(): QualifiedColTypeWithPositionContext {
|
|
let _localctx: QualifiedColTypeWithPositionContext = new QualifiedColTypeWithPositionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 314, SparkSqlParser.RULE_qualifiedColTypeWithPosition);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3504;
|
|
_localctx._name = this.multipartIdentifier();
|
|
this.state = 3505;
|
|
this.dataType();
|
|
this.state = 3509;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 453, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 3506;
|
|
this.colDefinitionDescriptorWithPosition();
|
|
}
|
|
}
|
|
}
|
|
this.state = 3511;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 453, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext {
|
|
let _localctx: ColDefinitionDescriptorWithPositionContext = new ColDefinitionDescriptorWithPositionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 316, SparkSqlParser.RULE_colDefinitionDescriptorWithPosition);
|
|
try {
|
|
this.state = 3517;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_NOT:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3512;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 3513;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_DEFAULT:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3514;
|
|
this.defaultExpression();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_COMMENT:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3515;
|
|
this.commentSpec();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_AFTER:
|
|
case SparkSqlParser.KW_FIRST:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3516;
|
|
this.colPosition();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public defaultExpression(): DefaultExpressionContext {
|
|
let _localctx: DefaultExpressionContext = new DefaultExpressionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 318, SparkSqlParser.RULE_defaultExpression);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3519;
|
|
this.match(SparkSqlParser.KW_DEFAULT);
|
|
this.state = 3520;
|
|
this.expression();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public variableDefaultExpression(): VariableDefaultExpressionContext {
|
|
let _localctx: VariableDefaultExpressionContext = new VariableDefaultExpressionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 320, SparkSqlParser.RULE_variableDefaultExpression);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3522;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.EQ)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3523;
|
|
this.expression();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public colTypeList(): ColTypeListContext {
|
|
let _localctx: ColTypeListContext = new ColTypeListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 322, SparkSqlParser.RULE_colTypeList);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3525;
|
|
this.colType();
|
|
this.state = 3530;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 455, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 3526;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3527;
|
|
this.colType();
|
|
}
|
|
}
|
|
}
|
|
this.state = 3532;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 455, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public colType(): ColTypeContext {
|
|
let _localctx: ColTypeContext = new ColTypeContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 324, SparkSqlParser.RULE_colType);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3533;
|
|
_localctx._colName = this.errorCapturingIdentifier();
|
|
this.state = 3534;
|
|
this.dataType();
|
|
this.state = 3537;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 456, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3535;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 3536;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3540;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 457, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3539;
|
|
this.commentSpec();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext {
|
|
let _localctx: CreateOrReplaceTableColTypeListContext = new CreateOrReplaceTableColTypeListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 326, SparkSqlParser.RULE_createOrReplaceTableColTypeList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3542;
|
|
this.createOrReplaceTableColType();
|
|
this.state = 3547;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3543;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3544;
|
|
this.createOrReplaceTableColType();
|
|
}
|
|
}
|
|
this.state = 3549;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext {
|
|
let _localctx: CreateOrReplaceTableColTypeContext = new CreateOrReplaceTableColTypeContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 328, SparkSqlParser.RULE_createOrReplaceTableColType);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3550;
|
|
_localctx._colName = this.errorCapturingIdentifier();
|
|
this.state = 3551;
|
|
this.dataType();
|
|
this.state = 3555;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.KW_COMMENT || _la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.KW_GENERATED || _la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
{
|
|
this.state = 3552;
|
|
this.colDefinitionOption();
|
|
}
|
|
}
|
|
this.state = 3557;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public colDefinitionOption(): ColDefinitionOptionContext {
|
|
let _localctx: ColDefinitionOptionContext = new ColDefinitionOptionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 330, SparkSqlParser.RULE_colDefinitionOption);
|
|
try {
|
|
this.state = 3563;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_NOT:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3558;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 3559;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_DEFAULT:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3560;
|
|
this.defaultExpression();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_GENERATED:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3561;
|
|
this.generationExpression();
|
|
}
|
|
break;
|
|
case SparkSqlParser.KW_COMMENT:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3562;
|
|
this.commentSpec();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public generationExpression(): GenerationExpressionContext {
|
|
let _localctx: GenerationExpressionContext = new GenerationExpressionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 332, SparkSqlParser.RULE_generationExpression);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3565;
|
|
this.match(SparkSqlParser.KW_GENERATED);
|
|
this.state = 3566;
|
|
this.match(SparkSqlParser.KW_ALWAYS);
|
|
this.state = 3567;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 3568;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3569;
|
|
this.expression();
|
|
this.state = 3570;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public complexColTypeList(): ComplexColTypeListContext {
|
|
let _localctx: ComplexColTypeListContext = new ComplexColTypeListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 334, SparkSqlParser.RULE_complexColTypeList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3572;
|
|
this.complexColType();
|
|
this.state = 3577;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3573;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3574;
|
|
this.complexColType();
|
|
}
|
|
}
|
|
this.state = 3579;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public complexColType(): ComplexColTypeContext {
|
|
let _localctx: ComplexColTypeContext = new ComplexColTypeContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 336, SparkSqlParser.RULE_complexColType);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3580;
|
|
this.identifier();
|
|
this.state = 3582;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 462, this._ctx) ) {
|
|
case 1:
|
|
{
|
|
this.state = 3581;
|
|
this.match(SparkSqlParser.COLON);
|
|
}
|
|
break;
|
|
}
|
|
this.state = 3584;
|
|
this.dataType();
|
|
this.state = 3587;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_NOT) {
|
|
{
|
|
this.state = 3585;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 3586;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
}
|
|
|
|
this.state = 3590;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_COMMENT) {
|
|
{
|
|
this.state = 3589;
|
|
this.commentSpec();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public whenClause(): WhenClauseContext {
|
|
let _localctx: WhenClauseContext = new WhenClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 338, SparkSqlParser.RULE_whenClause);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3592;
|
|
this.match(SparkSqlParser.KW_WHEN);
|
|
this.state = 3593;
|
|
_localctx._condition = this.expression();
|
|
this.state = 3594;
|
|
this.match(SparkSqlParser.KW_THEN);
|
|
this.state = 3595;
|
|
_localctx._result = this.expression();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public windowClause(): WindowClauseContext {
|
|
let _localctx: WindowClauseContext = new WindowClauseContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 340, SparkSqlParser.RULE_windowClause);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3597;
|
|
this.match(SparkSqlParser.KW_WINDOW);
|
|
this.state = 3598;
|
|
this.namedWindow();
|
|
this.state = 3603;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 465, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 3599;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3600;
|
|
this.namedWindow();
|
|
}
|
|
}
|
|
}
|
|
this.state = 3605;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 465, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public namedWindow(): NamedWindowContext {
|
|
let _localctx: NamedWindowContext = new NamedWindowContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 342, SparkSqlParser.RULE_namedWindow);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3606;
|
|
_localctx._name = this.errorCapturingIdentifier();
|
|
this.state = 3607;
|
|
this.match(SparkSqlParser.KW_AS);
|
|
this.state = 3608;
|
|
this.windowSpec();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public windowSpec(): WindowSpecContext {
|
|
let _localctx: WindowSpecContext = new WindowSpecContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 344, SparkSqlParser.RULE_windowSpec);
|
|
let _la: number;
|
|
try {
|
|
this.state = 3656;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 473, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3610;
|
|
_localctx._name = this.errorCapturingIdentifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3611;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3612;
|
|
_localctx._name = this.errorCapturingIdentifier();
|
|
this.state = 3613;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3615;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3650;
|
|
this._errHandler.sync(this);
|
|
switch (this._input.LA(1)) {
|
|
case SparkSqlParser.KW_CLUSTER:
|
|
{
|
|
this.state = 3616;
|
|
this.match(SparkSqlParser.KW_CLUSTER);
|
|
this.state = 3617;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 3618;
|
|
_localctx._expression = this.expression();
|
|
_localctx._partition.push(_localctx._expression);
|
|
this.state = 3623;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3619;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3620;
|
|
_localctx._expression = this.expression();
|
|
_localctx._partition.push(_localctx._expression);
|
|
}
|
|
}
|
|
this.state = 3625;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
case SparkSqlParser.RIGHT_PAREN:
|
|
case SparkSqlParser.KW_DISTRIBUTE:
|
|
case SparkSqlParser.KW_ORDER:
|
|
case SparkSqlParser.KW_PARTITION:
|
|
case SparkSqlParser.KW_RANGE:
|
|
case SparkSqlParser.KW_ROWS:
|
|
case SparkSqlParser.KW_SORT:
|
|
{
|
|
this.state = 3636;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION) {
|
|
{
|
|
this.state = 3626;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3627;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 3628;
|
|
_localctx._expression = this.expression();
|
|
_localctx._partition.push(_localctx._expression);
|
|
this.state = 3633;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3629;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3630;
|
|
_localctx._expression = this.expression();
|
|
_localctx._partition.push(_localctx._expression);
|
|
}
|
|
}
|
|
this.state = 3635;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.state = 3648;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT) {
|
|
{
|
|
this.state = 3638;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3639;
|
|
this.match(SparkSqlParser.KW_BY);
|
|
this.state = 3640;
|
|
this.sortItem();
|
|
this.state = 3645;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3641;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3642;
|
|
this.sortItem();
|
|
}
|
|
}
|
|
this.state = 3647;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 3653;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.KW_RANGE || _la === SparkSqlParser.KW_ROWS) {
|
|
{
|
|
this.state = 3652;
|
|
this.windowFrame();
|
|
}
|
|
}
|
|
|
|
this.state = 3655;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public windowFrame(): WindowFrameContext {
|
|
let _localctx: WindowFrameContext = new WindowFrameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 346, SparkSqlParser.RULE_windowFrame);
|
|
try {
|
|
this.state = 3674;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 474, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3658;
|
|
_localctx._frameType = this.match(SparkSqlParser.KW_RANGE);
|
|
this.state = 3659;
|
|
_localctx._start_ = this.frameBound();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3660;
|
|
_localctx._frameType = this.match(SparkSqlParser.KW_ROWS);
|
|
this.state = 3661;
|
|
_localctx._start_ = this.frameBound();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3662;
|
|
_localctx._frameType = this.match(SparkSqlParser.KW_RANGE);
|
|
this.state = 3663;
|
|
this.match(SparkSqlParser.KW_BETWEEN);
|
|
this.state = 3664;
|
|
_localctx._start_ = this.frameBound();
|
|
this.state = 3665;
|
|
this.match(SparkSqlParser.KW_AND);
|
|
this.state = 3666;
|
|
_localctx._end = this.frameBound();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3668;
|
|
_localctx._frameType = this.match(SparkSqlParser.KW_ROWS);
|
|
this.state = 3669;
|
|
this.match(SparkSqlParser.KW_BETWEEN);
|
|
this.state = 3670;
|
|
_localctx._start_ = this.frameBound();
|
|
this.state = 3671;
|
|
this.match(SparkSqlParser.KW_AND);
|
|
this.state = 3672;
|
|
_localctx._end = this.frameBound();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public frameBound(): FrameBoundContext {
|
|
let _localctx: FrameBoundContext = new FrameBoundContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 348, SparkSqlParser.RULE_frameBound);
|
|
let _la: number;
|
|
try {
|
|
this.state = 3683;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 475, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3676;
|
|
this.match(SparkSqlParser.KW_UNBOUNDED);
|
|
this.state = 3677;
|
|
_localctx._boundType = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FOLLOWING || _la === SparkSqlParser.KW_PRECEDING)) {
|
|
_localctx._boundType = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3678;
|
|
_localctx._boundType = this.match(SparkSqlParser.KW_CURRENT);
|
|
this.state = 3679;
|
|
this.match(SparkSqlParser.KW_ROW);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3680;
|
|
this.expression();
|
|
this.state = 3681;
|
|
_localctx._boundType = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_FOLLOWING || _la === SparkSqlParser.KW_PRECEDING)) {
|
|
_localctx._boundType = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public qualifiedNameList(): QualifiedNameListContext {
|
|
let _localctx: QualifiedNameListContext = new QualifiedNameListContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 350, SparkSqlParser.RULE_qualifiedNameList);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3685;
|
|
this.qualifiedName();
|
|
this.state = 3690;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
while (_la === SparkSqlParser.COMMA) {
|
|
{
|
|
{
|
|
this.state = 3686;
|
|
this.match(SparkSqlParser.COMMA);
|
|
this.state = 3687;
|
|
this.qualifiedName();
|
|
}
|
|
}
|
|
this.state = 3692;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionName(): FunctionNameContext {
|
|
let _localctx: FunctionNameContext = new FunctionNameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 352, SparkSqlParser.RULE_functionName);
|
|
try {
|
|
this.state = 3702;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 477, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3693;
|
|
this.match(SparkSqlParser.KW_IDENTIFIER_KW);
|
|
this.state = 3694;
|
|
this.match(SparkSqlParser.LEFT_PAREN);
|
|
this.state = 3695;
|
|
this.expression();
|
|
this.state = 3696;
|
|
this.match(SparkSqlParser.RIGHT_PAREN);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3698;
|
|
this.qualifiedName();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3699;
|
|
this.match(SparkSqlParser.KW_FILTER);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3700;
|
|
this.match(SparkSqlParser.KW_LEFT);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 3701;
|
|
this.match(SparkSqlParser.KW_RIGHT);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public functionNameCreate(): FunctionNameCreateContext {
|
|
let _localctx: FunctionNameCreateContext = new FunctionNameCreateContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 354, SparkSqlParser.RULE_functionNameCreate);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3704;
|
|
this.qualifiedName();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public qualifiedName(): QualifiedNameContext {
|
|
let _localctx: QualifiedNameContext = new QualifiedNameContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 356, SparkSqlParser.RULE_qualifiedName);
|
|
try {
|
|
let _alt: number;
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3706;
|
|
this.identifier();
|
|
this.state = 3711;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 478, this._ctx);
|
|
while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
|
|
if (_alt === 1) {
|
|
{
|
|
{
|
|
this.state = 3707;
|
|
this.match(SparkSqlParser.DOT);
|
|
this.state = 3708;
|
|
this.identifier();
|
|
}
|
|
}
|
|
}
|
|
this.state = 3713;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 478, this._ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
|
|
let _localctx: ErrorCapturingIdentifierContext = new ErrorCapturingIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 358, SparkSqlParser.RULE_errorCapturingIdentifier);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3714;
|
|
this.identifier();
|
|
this.state = 3715;
|
|
this.errorCapturingIdentifierExtra();
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext {
|
|
let _localctx: ErrorCapturingIdentifierExtraContext = new ErrorCapturingIdentifierExtraContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 360, SparkSqlParser.RULE_errorCapturingIdentifierExtra);
|
|
try {
|
|
let _alt: number;
|
|
this.state = 3724;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 480, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3719;
|
|
this._errHandler.sync(this);
|
|
_alt = 1;
|
|
do {
|
|
switch (_alt) {
|
|
case 1:
|
|
{
|
|
{
|
|
this.state = 3717;
|
|
this.match(SparkSqlParser.MINUS);
|
|
this.state = 3718;
|
|
this.identifier();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
this.state = 3721;
|
|
this._errHandler.sync(this);
|
|
_alt = this.interpreter.adaptivePredict(this._input, 479, this._ctx);
|
|
} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
// tslint:disable-next-line:no-empty
|
|
{
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public identifier(): IdentifierContext {
|
|
let _localctx: IdentifierContext = new IdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 362, SparkSqlParser.RULE_identifier);
|
|
try {
|
|
this.state = 3729;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 481, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3726;
|
|
this.strictIdentifier();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3727;
|
|
if (!(!this.SQL_standard_keyword_behavior)) {
|
|
throw this.createFailedPredicateException("!this.SQL_standard_keyword_behavior");
|
|
}
|
|
this.state = 3728;
|
|
this.strictNonReserved();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public strictIdentifier(): StrictIdentifierContext {
|
|
let _localctx: StrictIdentifierContext = new StrictIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 364, SparkSqlParser.RULE_strictIdentifier);
|
|
try {
|
|
this.state = 3737;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 482, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3731;
|
|
this.match(SparkSqlParser.IDENTIFIER);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3732;
|
|
this.quotedIdentifier();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3733;
|
|
if (!(this.SQL_standard_keyword_behavior)) {
|
|
throw this.createFailedPredicateException("this.SQL_standard_keyword_behavior");
|
|
}
|
|
this.state = 3734;
|
|
this.ansiNonReserved();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3735;
|
|
if (!(!this.SQL_standard_keyword_behavior)) {
|
|
throw this.createFailedPredicateException("!this.SQL_standard_keyword_behavior");
|
|
}
|
|
this.state = 3736;
|
|
this.nonReserved();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public quotedIdentifier(): QuotedIdentifierContext {
|
|
let _localctx: QuotedIdentifierContext = new QuotedIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 366, SparkSqlParser.RULE_quotedIdentifier);
|
|
try {
|
|
this.state = 3742;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 483, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3739;
|
|
this.match(SparkSqlParser.BACKQUOTED_IDENTIFIER);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3740;
|
|
if (!(this.double_quoted_identifiers)) {
|
|
throw this.createFailedPredicateException("this.double_quoted_identifiers");
|
|
}
|
|
this.state = 3741;
|
|
this.match(SparkSqlParser.DOUBLEQUOTED_STRING);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public backQuotedIdentifier(): BackQuotedIdentifierContext {
|
|
let _localctx: BackQuotedIdentifierContext = new BackQuotedIdentifierContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 368, SparkSqlParser.RULE_backQuotedIdentifier);
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3744;
|
|
this.match(SparkSqlParser.BACKQUOTED_IDENTIFIER);
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public number(): NumberContext {
|
|
let _localctx: NumberContext = new NumberContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 370, SparkSqlParser.RULE_number);
|
|
let _la: number;
|
|
try {
|
|
this.state = 3789;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 494, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3746;
|
|
if (!(!this.legacy_exponent_literal_as_decimal_enabled)) {
|
|
throw this.createFailedPredicateException("!this.legacy_exponent_literal_as_decimal_enabled");
|
|
}
|
|
this.state = 3748;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3747;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3750;
|
|
this.match(SparkSqlParser.EXPONENT_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3751;
|
|
if (!(!this.legacy_exponent_literal_as_decimal_enabled)) {
|
|
throw this.createFailedPredicateException("!this.legacy_exponent_literal_as_decimal_enabled");
|
|
}
|
|
this.state = 3753;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3752;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3755;
|
|
this.match(SparkSqlParser.DECIMAL_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3756;
|
|
if (!(this.legacy_exponent_literal_as_decimal_enabled)) {
|
|
throw this.createFailedPredicateException("this.legacy_exponent_literal_as_decimal_enabled");
|
|
}
|
|
this.state = 3758;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3757;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3760;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.EXPONENT_VALUE || _la === SparkSqlParser.DECIMAL_VALUE)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3762;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3761;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3764;
|
|
this.match(SparkSqlParser.INTEGER_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 3766;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3765;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3768;
|
|
this.match(SparkSqlParser.BIGINT_LITERAL);
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 3770;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3769;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3772;
|
|
this.match(SparkSqlParser.SMALLINT_LITERAL);
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
this.enterOuterAlt(_localctx, 7);
|
|
{
|
|
this.state = 3774;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3773;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3776;
|
|
this.match(SparkSqlParser.TINYINT_LITERAL);
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
this.enterOuterAlt(_localctx, 8);
|
|
{
|
|
this.state = 3778;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3777;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3780;
|
|
this.match(SparkSqlParser.DOUBLE_LITERAL);
|
|
}
|
|
break;
|
|
|
|
case 9:
|
|
this.enterOuterAlt(_localctx, 9);
|
|
{
|
|
this.state = 3782;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3781;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3784;
|
|
this.match(SparkSqlParser.FLOAT_LITERAL);
|
|
}
|
|
break;
|
|
|
|
case 10:
|
|
this.enterOuterAlt(_localctx, 10);
|
|
{
|
|
this.state = 3786;
|
|
this._errHandler.sync(this);
|
|
_la = this._input.LA(1);
|
|
if (_la === SparkSqlParser.MINUS) {
|
|
{
|
|
this.state = 3785;
|
|
this.match(SparkSqlParser.MINUS);
|
|
}
|
|
}
|
|
|
|
this.state = 3788;
|
|
this.match(SparkSqlParser.BIGDECIMAL_LITERAL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public alterColumnAction(): AlterColumnActionContext {
|
|
let _localctx: AlterColumnActionContext = new AlterColumnActionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 372, SparkSqlParser.RULE_alterColumnAction);
|
|
let _la: number;
|
|
try {
|
|
this.state = 3802;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 495, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3791;
|
|
this.match(SparkSqlParser.KW_TYPE);
|
|
this.state = 3792;
|
|
this.dataType();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3793;
|
|
this.commentSpec();
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
this.enterOuterAlt(_localctx, 3);
|
|
{
|
|
this.state = 3794;
|
|
this.colPosition();
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
this.enterOuterAlt(_localctx, 4);
|
|
{
|
|
this.state = 3795;
|
|
_localctx._setOrDrop = this._input.LT(1);
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_DROP || _la === SparkSqlParser.KW_SET)) {
|
|
_localctx._setOrDrop = this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
this.state = 3796;
|
|
this.match(SparkSqlParser.KW_NOT);
|
|
this.state = 3797;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
this.enterOuterAlt(_localctx, 5);
|
|
{
|
|
this.state = 3798;
|
|
this.match(SparkSqlParser.KW_SET);
|
|
this.state = 3799;
|
|
this.defaultExpression();
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
this.enterOuterAlt(_localctx, 6);
|
|
{
|
|
this.state = 3800;
|
|
_localctx._dropDefault = this.match(SparkSqlParser.KW_DROP);
|
|
this.state = 3801;
|
|
this.match(SparkSqlParser.KW_DEFAULT);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public stringLit(): StringLitContext {
|
|
let _localctx: StringLitContext = new StringLitContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 374, SparkSqlParser.RULE_stringLit);
|
|
try {
|
|
this.state = 3807;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 496, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3804;
|
|
this.match(SparkSqlParser.STRING_LITERAL);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3805;
|
|
if (!(!this.double_quoted_identifiers)) {
|
|
throw this.createFailedPredicateException("!this.double_quoted_identifiers");
|
|
}
|
|
this.state = 3806;
|
|
this.match(SparkSqlParser.DOUBLEQUOTED_STRING);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public comment(): CommentContext {
|
|
let _localctx: CommentContext = new CommentContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 376, SparkSqlParser.RULE_comment);
|
|
try {
|
|
this.state = 3811;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 497, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3809;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3810;
|
|
this.match(SparkSqlParser.KW_NULL);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public version(): VersionContext {
|
|
let _localctx: VersionContext = new VersionContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 378, SparkSqlParser.RULE_version);
|
|
try {
|
|
this.state = 3815;
|
|
this._errHandler.sync(this);
|
|
switch ( this.interpreter.adaptivePredict(this._input, 498, this._ctx) ) {
|
|
case 1:
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3813;
|
|
this.match(SparkSqlParser.INTEGER_VALUE);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
this.enterOuterAlt(_localctx, 2);
|
|
{
|
|
this.state = 3814;
|
|
this.stringLit();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public ansiNonReserved(): AnsiNonReservedContext {
|
|
let _localctx: AnsiNonReservedContext = new AnsiNonReservedContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 380, SparkSqlParser.RULE_ansiNonReserved);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3817;
|
|
_la = this._input.LA(1);
|
|
if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)))) !== 0) || ((((_la - 67)) & ~0x1F) === 0 && ((1 << (_la - 67)) & ((1 << (SparkSqlParser.KW_DAY - 67)) | (1 << (SparkSqlParser.KW_DAYS - 67)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 67)) | (1 << (SparkSqlParser.KW_DATA - 67)) | (1 << (SparkSqlParser.KW_DATE - 67)) | (1 << (SparkSqlParser.KW_DATABASE - 67)) | (1 << (SparkSqlParser.KW_DATABASES - 67)) | (1 << (SparkSqlParser.KW_DATEADD - 67)) | (1 << (SparkSqlParser.KW_DATE_ADD - 67)) | (1 << (SparkSqlParser.KW_DATEDIFF - 67)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 67)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 67)) | (1 << (SparkSqlParser.KW_DEC - 67)) | (1 << (SparkSqlParser.KW_DECIMAL - 67)) | (1 << (SparkSqlParser.KW_DECLARE - 67)) | (1 << (SparkSqlParser.KW_DEFAULT - 67)) | (1 << (SparkSqlParser.KW_DEFINED - 67)) | (1 << (SparkSqlParser.KW_DELETE - 67)) | (1 << (SparkSqlParser.KW_DELIMITED - 67)) | (1 << (SparkSqlParser.KW_DESC - 67)) | (1 << (SparkSqlParser.KW_DESCRIBE - 67)) | (1 << (SparkSqlParser.KW_DFS - 67)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 67)) | (1 << (SparkSqlParser.KW_DIRECTORY - 67)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 67)) | (1 << (SparkSqlParser.KW_DIV - 67)) | (1 << (SparkSqlParser.KW_DOUBLE - 67)) | (1 << (SparkSqlParser.KW_DROP - 67)))) !== 0) || ((((_la - 99)) & ~0x1F) === 0 && ((1 << (_la - 99)) & ((1 << (SparkSqlParser.KW_ESCAPED - 99)) | (1 << (SparkSqlParser.KW_EXCHANGE - 99)) | (1 << (SparkSqlParser.KW_EXCLUDE - 99)) | (1 << (SparkSqlParser.KW_EXISTS - 99)) | (1 << (SparkSqlParser.KW_EXPLAIN - 99)) | (1 << (SparkSqlParser.KW_EXPORT - 99)) | (1 << (SparkSqlParser.KW_EXTENDED - 99)) | (1 << (SparkSqlParser.KW_EXTERNAL - 99)) | (1 << (SparkSqlParser.KW_EXTRACT - 99)) | (1 << (SparkSqlParser.KW_FIELDS - 99)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 99)) | (1 << (SparkSqlParser.KW_FIRST - 99)) | (1 << (SparkSqlParser.KW_FLOAT - 99)) | (1 << (SparkSqlParser.KW_FOLLOWING - 99)) | (1 << (SparkSqlParser.KW_FORMAT - 99)) | (1 << (SparkSqlParser.KW_FORMATTED - 99)) | (1 << (SparkSqlParser.KW_FUNCTION - 99)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 99)) | (1 << (SparkSqlParser.KW_GENERATED - 99)) | (1 << (SparkSqlParser.KW_GLOBAL - 99)) | (1 << (SparkSqlParser.KW_GROUPING - 99)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (SparkSqlParser.KW_BINARY_HEX - 131)) | (1 << (SparkSqlParser.KW_HOUR - 131)) | (1 << (SparkSqlParser.KW_HOURS - 131)) | (1 << (SparkSqlParser.KW_IDENTIFIER_KW - 131)) | (1 << (SparkSqlParser.KW_IF - 131)) | (1 << (SparkSqlParser.KW_IGNORE - 131)) | (1 << (SparkSqlParser.KW_IMPORT - 131)) | (1 << (SparkSqlParser.KW_INCLUDE - 131)) | (1 << (SparkSqlParser.KW_INDEX - 131)) | (1 << (SparkSqlParser.KW_INDEXES - 131)) | (1 << (SparkSqlParser.KW_INPATH - 131)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 131)) | (1 << (SparkSqlParser.KW_INSERT - 131)) | (1 << (SparkSqlParser.KW_INTERVAL - 131)) | (1 << (SparkSqlParser.KW_INT - 131)) | (1 << (SparkSqlParser.KW_INTEGER - 131)) | (1 << (SparkSqlParser.KW_ITEMS - 131)) | (1 << (SparkSqlParser.KW_KEYS - 131)) | (1 << (SparkSqlParser.KW_LAST - 131)) | (1 << (SparkSqlParser.KW_LAZY - 131)) | (1 << (SparkSqlParser.KW_LIKE - 131)) | (1 << (SparkSqlParser.KW_ILIKE - 131)) | (1 << (SparkSqlParser.KW_LIMIT - 131)))) !== 0) || ((((_la - 163)) & ~0x1F) === 0 && ((1 << (_la - 163)) & ((1 << (SparkSqlParser.KW_LINES - 163)) | (1 << (SparkSqlParser.KW_LIST - 163)) | (1 << (SparkSqlParser.KW_LOAD - 163)) | (1 << (SparkSqlParser.KW_LOCAL - 163)) | (1 << (SparkSqlParser.KW_LOCATION - 163)) | (1 << (SparkSqlParser.KW_LOCK - 163)) | (1 << (SparkSqlParser.KW_LOCKS - 163)) | (1 << (SparkSqlParser.KW_LOGICAL - 163)) | (1 << (SparkSqlParser.KW_LONG - 163)) | (1 << (SparkSqlParser.KW_MACRO - 163)) | (1 << (SparkSqlParser.KW_MAP - 163)) | (1 << (SparkSqlParser.KW_MATCHED - 163)) | (1 << (SparkSqlParser.KW_MERGE - 163)) | (1 << (SparkSqlParser.KW_MICROSECOND - 163)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 163)) | (1 << (SparkSqlParser.KW_MILLISECOND - 163)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 163)) | (1 << (SparkSqlParser.KW_MINUTE - 163)) | (1 << (SparkSqlParser.KW_MINUTES - 163)) | (1 << (SparkSqlParser.KW_MONTH - 163)) | (1 << (SparkSqlParser.KW_MONTHS - 163)) | (1 << (SparkSqlParser.KW_MSCK - 163)) | (1 << (SparkSqlParser.KW_NAME - 163)) | (1 << (SparkSqlParser.KW_NAMESPACE - 163)) | (1 << (SparkSqlParser.KW_NAMESPACES - 163)) | (1 << (SparkSqlParser.KW_NANOSECOND - 163)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 163)) | (1 << (SparkSqlParser.KW_NO - 163)) | (1 << (SparkSqlParser.KW_NULLS - 163)))) !== 0) || ((((_la - 195)) & ~0x1F) === 0 && ((1 << (_la - 195)) & ((1 << (SparkSqlParser.KW_NUMERIC - 195)) | (1 << (SparkSqlParser.KW_OF - 195)) | (1 << (SparkSqlParser.KW_OPTION - 195)) | (1 << (SparkSqlParser.KW_OPTIONS - 195)) | (1 << (SparkSqlParser.KW_OUT - 195)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 195)) | (1 << (SparkSqlParser.KW_OVER - 195)) | (1 << (SparkSqlParser.KW_OVERLAY - 195)) | (1 << (SparkSqlParser.KW_OVERWRITE - 195)) | (1 << (SparkSqlParser.KW_PARTITION - 195)) | (1 << (SparkSqlParser.KW_PARTITIONED - 195)) | (1 << (SparkSqlParser.KW_PARTITIONS - 195)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 195)) | (1 << (SparkSqlParser.KW_PIVOT - 195)) | (1 << (SparkSqlParser.KW_PLACING - 195)) | (1 << (SparkSqlParser.KW_POSITION - 195)) | (1 << (SparkSqlParser.KW_PRECEDING - 195)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 195)) | (1 << (SparkSqlParser.KW_PROPERTIES - 195)) | (1 << (SparkSqlParser.KW_PURGE - 195)) | (1 << (SparkSqlParser.KW_QUARTER - 195)) | (1 << (SparkSqlParser.KW_QUERY - 195)))) !== 0) || ((((_la - 227)) & ~0x1F) === 0 && ((1 << (_la - 227)) & ((1 << (SparkSqlParser.KW_RANGE - 227)) | (1 << (SparkSqlParser.KW_REAL - 227)) | (1 << (SparkSqlParser.KW_RECORDREADER - 227)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 227)) | (1 << (SparkSqlParser.KW_RECOVER - 227)) | (1 << (SparkSqlParser.KW_REDUCE - 227)) | (1 << (SparkSqlParser.KW_REFRESH - 227)) | (1 << (SparkSqlParser.KW_RENAME - 227)) | (1 << (SparkSqlParser.KW_REPAIR - 227)) | (1 << (SparkSqlParser.KW_REPEATABLE - 227)) | (1 << (SparkSqlParser.KW_REPLACE - 227)) | (1 << (SparkSqlParser.KW_RESET - 227)) | (1 << (SparkSqlParser.KW_RESPECT - 227)) | (1 << (SparkSqlParser.KW_RESTRICT - 227)) | (1 << (SparkSqlParser.KW_REVOKE - 227)) | (1 << (SparkSqlParser.KW_RLIKE - 227)) | (1 << (SparkSqlParser.KW_REGEXP - 227)) | (1 << (SparkSqlParser.KW_ROLE - 227)) | (1 << (SparkSqlParser.KW_ROLES - 227)) | (1 << (SparkSqlParser.KW_ROLLBACK - 227)) | (1 << (SparkSqlParser.KW_ROLLUP - 227)) | (1 << (SparkSqlParser.KW_ROW - 227)) | (1 << (SparkSqlParser.KW_ROWS - 227)) | (1 << (SparkSqlParser.KW_SECOND - 227)) | (1 << (SparkSqlParser.KW_SECONDS - 227)) | (1 << (SparkSqlParser.KW_SCHEMA - 227)) | (1 << (SparkSqlParser.KW_SCHEMAS - 227)) | (1 << (SparkSqlParser.KW_SEMI - 227)) | (1 << (SparkSqlParser.KW_SEPARATED - 227)))) !== 0) || ((((_la - 259)) & ~0x1F) === 0 && ((1 << (_la - 259)) & ((1 << (SparkSqlParser.KW_SERDE - 259)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 259)) | (1 << (SparkSqlParser.KW_SET - 259)) | (1 << (SparkSqlParser.KW_SETMINUS - 259)) | (1 << (SparkSqlParser.KW_SETS - 259)) | (1 << (SparkSqlParser.KW_SHORT - 259)) | (1 << (SparkSqlParser.KW_SHOW - 259)) | (1 << (SparkSqlParser.KW_SINGLE - 259)) | (1 << (SparkSqlParser.KW_SKEWED - 259)) | (1 << (SparkSqlParser.KW_SMALLINT - 259)) | (1 << (SparkSqlParser.KW_SORT - 259)) | (1 << (SparkSqlParser.KW_SORTED - 259)) | (1 << (SparkSqlParser.KW_SOURCE - 259)) | (1 << (SparkSqlParser.KW_START - 259)) | (1 << (SparkSqlParser.KW_STATISTICS - 259)) | (1 << (SparkSqlParser.KW_STORED - 259)) | (1 << (SparkSqlParser.KW_STRATIFY - 259)) | (1 << (SparkSqlParser.KW_STRING - 259)) | (1 << (SparkSqlParser.KW_STRUCT - 259)) | (1 << (SparkSqlParser.KW_SUBSTR - 259)) | (1 << (SparkSqlParser.KW_SUBSTRING - 259)) | (1 << (SparkSqlParser.KW_SYNC - 259)) | (1 << (SparkSqlParser.KW_SYSTEM - 259)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 259)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 259)) | (1 << (SparkSqlParser.KW_TABLES - 259)) | (1 << (SparkSqlParser.KW_TABLESAMPLE - 259)) | (1 << (SparkSqlParser.KW_TARGET - 259)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 259)))) !== 0) || ((((_la - 291)) & ~0x1F) === 0 && ((1 << (_la - 291)) & ((1 << (SparkSqlParser.KW_TEMPORARY - 291)) | (1 << (SparkSqlParser.KW_TERMINATED - 291)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 291)) | (1 << (SparkSqlParser.KW_TINYINT - 291)) | (1 << (SparkSqlParser.KW_TOUCH - 291)) | (1 << (SparkSqlParser.KW_TRANSACTION - 291)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 291)) | (1 << (SparkSqlParser.KW_TRANSFORM - 291)) | (1 << (SparkSqlParser.KW_TRIM - 291)) | (1 << (SparkSqlParser.KW_TRUE - 291)) | (1 << (SparkSqlParser.KW_TRUNCATE - 291)) | (1 << (SparkSqlParser.KW_TRY_CAST - 291)) | (1 << (SparkSqlParser.KW_TYPE - 291)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 291)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 291)) | (1 << (SparkSqlParser.KW_UNCACHE - 291)) | (1 << (SparkSqlParser.KW_UNLOCK - 291)) | (1 << (SparkSqlParser.KW_UNPIVOT - 291)) | (1 << (SparkSqlParser.KW_UNSET - 291)) | (1 << (SparkSqlParser.KW_UPDATE - 291)))) !== 0) || ((((_la - 323)) & ~0x1F) === 0 && ((1 << (_la - 323)) & ((1 << (SparkSqlParser.KW_USE - 323)) | (1 << (SparkSqlParser.KW_VALUES - 323)) | (1 << (SparkSqlParser.KW_VARCHAR - 323)) | (1 << (SparkSqlParser.KW_VAR - 323)) | (1 << (SparkSqlParser.KW_VARIABLE - 323)) | (1 << (SparkSqlParser.KW_VERSION - 323)) | (1 << (SparkSqlParser.KW_VIEW - 323)) | (1 << (SparkSqlParser.KW_VIEWS - 323)) | (1 << (SparkSqlParser.KW_VOID - 323)) | (1 << (SparkSqlParser.KW_WEEK - 323)) | (1 << (SparkSqlParser.KW_WEEKS - 323)) | (1 << (SparkSqlParser.KW_WINDOW - 323)) | (1 << (SparkSqlParser.KW_YEAR - 323)) | (1 << (SparkSqlParser.KW_YEARS - 323)) | (1 << (SparkSqlParser.KW_ZONE - 323)))) !== 0))) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public strictNonReserved(): StrictNonReservedContext {
|
|
let _localctx: StrictNonReservedContext = new StrictNonReservedContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 382, SparkSqlParser.RULE_strictNonReserved);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3819;
|
|
_la = this._input.LA(1);
|
|
if (!(_la === SparkSqlParser.KW_ANTI || _la === SparkSqlParser.KW_CROSS || _la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_FULL || ((((_la - 142)) & ~0x1F) === 0 && ((1 << (_la - 142)) & ((1 << (SparkSqlParser.KW_INNER - 142)) | (1 << (SparkSqlParser.KW_INTERSECT - 142)) | (1 << (SparkSqlParser.KW_JOIN - 142)) | (1 << (SparkSqlParser.KW_LATERAL - 142)) | (1 << (SparkSqlParser.KW_LEFT - 142)))) !== 0) || _la === SparkSqlParser.KW_NATURAL || _la === SparkSqlParser.KW_ON || ((((_la - 243)) & ~0x1F) === 0 && ((1 << (_la - 243)) & ((1 << (SparkSqlParser.KW_RIGHT - 243)) | (1 << (SparkSqlParser.KW_SEMI - 243)) | (1 << (SparkSqlParser.KW_SETMINUS - 243)))) !== 0) || _la === SparkSqlParser.KW_UNION || _la === SparkSqlParser.KW_USING)) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
// @RuleVersion(0)
|
|
public nonReserved(): NonReservedContext {
|
|
let _localctx: NonReservedContext = new NonReservedContext(this._ctx, this.state);
|
|
this.enterRule(_localctx, 384, SparkSqlParser.RULE_nonReserved);
|
|
let _la: number;
|
|
try {
|
|
this.enterOuterAlt(_localctx, 1);
|
|
{
|
|
this.state = 3821;
|
|
_la = this._input.LA(1);
|
|
if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER_KW - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & ((1 << (SparkSqlParser.KW_NOT - 192)) | (1 << (SparkSqlParser.KW_NULL - 192)) | (1 << (SparkSqlParser.KW_NULLS - 192)) | (1 << (SparkSqlParser.KW_NUMERIC - 192)) | (1 << (SparkSqlParser.KW_OF - 192)) | (1 << (SparkSqlParser.KW_OFFSET - 192)) | (1 << (SparkSqlParser.KW_ONLY - 192)) | (1 << (SparkSqlParser.KW_OPTION - 192)) | (1 << (SparkSqlParser.KW_OPTIONS - 192)) | (1 << (SparkSqlParser.KW_OR - 192)) | (1 << (SparkSqlParser.KW_ORDER - 192)) | (1 << (SparkSqlParser.KW_OUT - 192)) | (1 << (SparkSqlParser.KW_OUTER - 192)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 192)) | (1 << (SparkSqlParser.KW_OVER - 192)) | (1 << (SparkSqlParser.KW_OVERLAPS - 192)) | (1 << (SparkSqlParser.KW_OVERLAY - 192)) | (1 << (SparkSqlParser.KW_OVERWRITE - 192)) | (1 << (SparkSqlParser.KW_PARTITION - 192)) | (1 << (SparkSqlParser.KW_PARTITIONED - 192)) | (1 << (SparkSqlParser.KW_PARTITIONS - 192)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 192)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 192)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 192)) | (1 << (SparkSqlParser.KW_PIVOT - 192)) | (1 << (SparkSqlParser.KW_PLACING - 192)) | (1 << (SparkSqlParser.KW_POSITION - 192)) | (1 << (SparkSqlParser.KW_PRECEDING - 192)) | (1 << (SparkSqlParser.KW_PRIMARY - 192)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 192)) | (1 << (SparkSqlParser.KW_PROPERTIES - 192)))) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & ((1 << (SparkSqlParser.KW_PURGE - 224)) | (1 << (SparkSqlParser.KW_QUARTER - 224)) | (1 << (SparkSqlParser.KW_QUERY - 224)) | (1 << (SparkSqlParser.KW_RANGE - 224)) | (1 << (SparkSqlParser.KW_REAL - 224)) | (1 << (SparkSqlParser.KW_RECORDREADER - 224)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 224)) | (1 << (SparkSqlParser.KW_RECOVER - 224)) | (1 << (SparkSqlParser.KW_REDUCE - 224)) | (1 << (SparkSqlParser.KW_REFERENCES - 224)) | (1 << (SparkSqlParser.KW_REFRESH - 224)) | (1 << (SparkSqlParser.KW_RENAME - 224)) | (1 << (SparkSqlParser.KW_REPAIR - 224)) | (1 << (SparkSqlParser.KW_REPEATABLE - 224)) | (1 << (SparkSqlParser.KW_REPLACE - 224)) | (1 << (SparkSqlParser.KW_RESET - 224)) | (1 << (SparkSqlParser.KW_RESPECT - 224)) | (1 << (SparkSqlParser.KW_RESTRICT - 224)) | (1 << (SparkSqlParser.KW_REVOKE - 224)) | (1 << (SparkSqlParser.KW_RLIKE - 224)) | (1 << (SparkSqlParser.KW_REGEXP - 224)) | (1 << (SparkSqlParser.KW_ROLE - 224)) | (1 << (SparkSqlParser.KW_ROLES - 224)) | (1 << (SparkSqlParser.KW_ROLLBACK - 224)) | (1 << (SparkSqlParser.KW_ROLLUP - 224)) | (1 << (SparkSqlParser.KW_ROW - 224)) | (1 << (SparkSqlParser.KW_ROWS - 224)) | (1 << (SparkSqlParser.KW_SECOND - 224)) | (1 << (SparkSqlParser.KW_SECONDS - 224)) | (1 << (SparkSqlParser.KW_SCHEMA - 224)) | (1 << (SparkSqlParser.KW_SCHEMAS - 224)))) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & ((1 << (SparkSqlParser.KW_SELECT - 256)) | (1 << (SparkSqlParser.KW_SEPARATED - 256)) | (1 << (SparkSqlParser.KW_SERDE - 256)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 256)) | (1 << (SparkSqlParser.KW_SESSION_USER - 256)) | (1 << (SparkSqlParser.KW_SET - 256)) | (1 << (SparkSqlParser.KW_SETS - 256)) | (1 << (SparkSqlParser.KW_SHORT - 256)) | (1 << (SparkSqlParser.KW_SHOW - 256)) | (1 << (SparkSqlParser.KW_SINGLE - 256)) | (1 << (SparkSqlParser.KW_SKEWED - 256)) | (1 << (SparkSqlParser.KW_SMALLINT - 256)) | (1 << (SparkSqlParser.KW_SOME - 256)) | (1 << (SparkSqlParser.KW_SORT - 256)) | (1 << (SparkSqlParser.KW_SORTED - 256)) | (1 << (SparkSqlParser.KW_SOURCE - 256)) | (1 << (SparkSqlParser.KW_START - 256)) | (1 << (SparkSqlParser.KW_STATISTICS - 256)) | (1 << (SparkSqlParser.KW_STORED - 256)) | (1 << (SparkSqlParser.KW_STRATIFY - 256)) | (1 << (SparkSqlParser.KW_STRING - 256)) | (1 << (SparkSqlParser.KW_STRUCT - 256)) | (1 << (SparkSqlParser.KW_SUBSTR - 256)) | (1 << (SparkSqlParser.KW_SUBSTRING - 256)) | (1 << (SparkSqlParser.KW_SYNC - 256)) | (1 << (SparkSqlParser.KW_SYSTEM - 256)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 256)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 256)) | (1 << (SparkSqlParser.KW_TABLE - 256)) | (1 << (SparkSqlParser.KW_TABLES - 256)))) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 288)) | (1 << (SparkSqlParser.KW_TARGET - 288)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 288)) | (1 << (SparkSqlParser.KW_TEMPORARY - 288)) | (1 << (SparkSqlParser.KW_TERMINATED - 288)) | (1 << (SparkSqlParser.KW_THEN - 288)) | (1 << (SparkSqlParser.KW_TIME - 288)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 288)) | (1 << (SparkSqlParser.KW_TINYINT - 288)) | (1 << (SparkSqlParser.KW_TO - 288)) | (1 << (SparkSqlParser.KW_TOUCH - 288)) | (1 << (SparkSqlParser.KW_TRAILING - 288)) | (1 << (SparkSqlParser.KW_TRANSACTION - 288)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 288)) | (1 << (SparkSqlParser.KW_TRANSFORM - 288)) | (1 << (SparkSqlParser.KW_TRIM - 288)) | (1 << (SparkSqlParser.KW_TRUE - 288)) | (1 << (SparkSqlParser.KW_TRUNCATE - 288)) | (1 << (SparkSqlParser.KW_TRY_CAST - 288)) | (1 << (SparkSqlParser.KW_TYPE - 288)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 288)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 288)) | (1 << (SparkSqlParser.KW_UNCACHE - 288)) | (1 << (SparkSqlParser.KW_UNIQUE - 288)) | (1 << (SparkSqlParser.KW_UNKNOWN - 288)) | (1 << (SparkSqlParser.KW_UNLOCK - 288)))) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 320)) | (1 << (SparkSqlParser.KW_UNSET - 320)) | (1 << (SparkSqlParser.KW_UPDATE - 320)) | (1 << (SparkSqlParser.KW_USE - 320)) | (1 << (SparkSqlParser.KW_USER - 320)) | (1 << (SparkSqlParser.KW_VALUES - 320)) | (1 << (SparkSqlParser.KW_VARCHAR - 320)) | (1 << (SparkSqlParser.KW_VAR - 320)) | (1 << (SparkSqlParser.KW_VARIABLE - 320)) | (1 << (SparkSqlParser.KW_VERSION - 320)) | (1 << (SparkSqlParser.KW_VIEW - 320)) | (1 << (SparkSqlParser.KW_VIEWS - 320)) | (1 << (SparkSqlParser.KW_VOID - 320)) | (1 << (SparkSqlParser.KW_WEEK - 320)) | (1 << (SparkSqlParser.KW_WEEKS - 320)) | (1 << (SparkSqlParser.KW_WHEN - 320)) | (1 << (SparkSqlParser.KW_WHERE - 320)) | (1 << (SparkSqlParser.KW_WINDOW - 320)) | (1 << (SparkSqlParser.KW_WITH - 320)) | (1 << (SparkSqlParser.KW_WITHIN - 320)) | (1 << (SparkSqlParser.KW_YEAR - 320)) | (1 << (SparkSqlParser.KW_YEARS - 320)) | (1 << (SparkSqlParser.KW_ZONE - 320)))) !== 0))) {
|
|
this._errHandler.recoverInline(this);
|
|
} else {
|
|
if (this._input.LA(1) === Token.EOF) {
|
|
this.matchedEOF = true;
|
|
}
|
|
|
|
this._errHandler.reportMatch(this);
|
|
this.consume();
|
|
}
|
|
}
|
|
}
|
|
catch (re) {
|
|
if (re instanceof RecognitionException) {
|
|
_localctx.exception = re;
|
|
this._errHandler.reportError(this, re);
|
|
this._errHandler.recover(this, re);
|
|
} else {
|
|
throw re;
|
|
}
|
|
}
|
|
finally {
|
|
this.exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean {
|
|
switch (ruleIndex) {
|
|
case 48:
|
|
return this.queryTerm_sempred(_localctx as QueryTermContext, predIndex);
|
|
|
|
case 134:
|
|
return this.booleanExpression_sempred(_localctx as BooleanExpressionContext, predIndex);
|
|
|
|
case 136:
|
|
return this.valueExpression_sempred(_localctx as ValueExpressionContext, predIndex);
|
|
|
|
case 138:
|
|
return this.primaryExpression_sempred(_localctx as PrimaryExpressionContext, predIndex);
|
|
|
|
case 181:
|
|
return this.identifier_sempred(_localctx as IdentifierContext, predIndex);
|
|
|
|
case 182:
|
|
return this.strictIdentifier_sempred(_localctx as StrictIdentifierContext, predIndex);
|
|
|
|
case 183:
|
|
return this.quotedIdentifier_sempred(_localctx as QuotedIdentifierContext, predIndex);
|
|
|
|
case 185:
|
|
return this.number_sempred(_localctx as NumberContext, predIndex);
|
|
|
|
case 187:
|
|
return this.stringLit_sempred(_localctx as StringLitContext, predIndex);
|
|
}
|
|
return true;
|
|
}
|
|
private queryTerm_sempred(_localctx: QueryTermContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 0:
|
|
return this.precpred(this._ctx, 3);
|
|
|
|
case 1:
|
|
return this.legacy_setops_precedence_enabled;
|
|
|
|
case 2:
|
|
return this.precpred(this._ctx, 2);
|
|
|
|
case 3:
|
|
return !this.legacy_setops_precedence_enabled;
|
|
|
|
case 4:
|
|
return this.precpred(this._ctx, 1);
|
|
|
|
case 5:
|
|
return !this.legacy_setops_precedence_enabled;
|
|
}
|
|
return true;
|
|
}
|
|
private booleanExpression_sempred(_localctx: BooleanExpressionContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 6:
|
|
return this.precpred(this._ctx, 2);
|
|
|
|
case 7:
|
|
return this.precpred(this._ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private valueExpression_sempred(_localctx: ValueExpressionContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 8:
|
|
return this.precpred(this._ctx, 6);
|
|
|
|
case 9:
|
|
return this.precpred(this._ctx, 5);
|
|
|
|
case 10:
|
|
return this.precpred(this._ctx, 4);
|
|
|
|
case 11:
|
|
return this.precpred(this._ctx, 3);
|
|
|
|
case 12:
|
|
return this.precpred(this._ctx, 2);
|
|
|
|
case 13:
|
|
return this.precpred(this._ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private primaryExpression_sempred(_localctx: PrimaryExpressionContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 14:
|
|
return this.precpred(this._ctx, 9);
|
|
|
|
case 15:
|
|
return this.precpred(this._ctx, 7);
|
|
}
|
|
return true;
|
|
}
|
|
private identifier_sempred(_localctx: IdentifierContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 16:
|
|
return !this.SQL_standard_keyword_behavior;
|
|
}
|
|
return true;
|
|
}
|
|
private strictIdentifier_sempred(_localctx: StrictIdentifierContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 17:
|
|
return this.SQL_standard_keyword_behavior;
|
|
|
|
case 18:
|
|
return !this.SQL_standard_keyword_behavior;
|
|
}
|
|
return true;
|
|
}
|
|
private quotedIdentifier_sempred(_localctx: QuotedIdentifierContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 19:
|
|
return this.double_quoted_identifiers;
|
|
}
|
|
return true;
|
|
}
|
|
private number_sempred(_localctx: NumberContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 20:
|
|
return !this.legacy_exponent_literal_as_decimal_enabled;
|
|
|
|
case 21:
|
|
return !this.legacy_exponent_literal_as_decimal_enabled;
|
|
|
|
case 22:
|
|
return this.legacy_exponent_literal_as_decimal_enabled;
|
|
}
|
|
return true;
|
|
}
|
|
private stringLit_sempred(_localctx: StringLitContext, predIndex: number): boolean {
|
|
switch (predIndex) {
|
|
case 23:
|
|
return !this.double_quoted_identifiers;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static readonly _serializedATNSegments: number = 8;
|
|
private static readonly _serializedATNSegment0: string =
|
|
"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\u0183\u0EF2\x04" +
|
|
"\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" +
|
|
"\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r" +
|
|
"\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" +
|
|
"\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17" +
|
|
"\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C" +
|
|
"\x04\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04" +
|
|
"#\t#\x04$\t$\x04%\t%\x04&\t&\x04\'\t\'\x04(\t(\x04)\t)\x04*\t*\x04+\t" +
|
|
"+\x04,\t,\x04-\t-\x04.\t.\x04/\t/\x040\t0\x041\t1\x042\t2\x043\t3\x04" +
|
|
"4\t4\x045\t5\x046\t6\x047\t7\x048\t8\x049\t9\x04:\t:\x04;\t;\x04<\t<\x04" +
|
|
"=\t=\x04>\t>\x04?\t?\x04@\t@\x04A\tA\x04B\tB\x04C\tC\x04D\tD\x04E\tE\x04" +
|
|
"F\tF\x04G\tG\x04H\tH\x04I\tI\x04J\tJ\x04K\tK\x04L\tL\x04M\tM\x04N\tN\x04" +
|
|
"O\tO\x04P\tP\x04Q\tQ\x04R\tR\x04S\tS\x04T\tT\x04U\tU\x04V\tV\x04W\tW\x04" +
|
|
"X\tX\x04Y\tY\x04Z\tZ\x04[\t[\x04\\\t\\\x04]\t]\x04^\t^\x04_\t_\x04`\t" +
|
|
"`\x04a\ta\x04b\tb\x04c\tc\x04d\td\x04e\te\x04f\tf\x04g\tg\x04h\th\x04" +
|
|
"i\ti\x04j\tj\x04k\tk\x04l\tl\x04m\tm\x04n\tn\x04o\to\x04p\tp\x04q\tq\x04" +
|
|
"r\tr\x04s\ts\x04t\tt\x04u\tu\x04v\tv\x04w\tw\x04x\tx\x04y\ty\x04z\tz\x04" +
|
|
"{\t{\x04|\t|\x04}\t}\x04~\t~\x04\x7F\t\x7F\x04\x80\t\x80\x04\x81\t\x81" +
|
|
"\x04\x82\t\x82\x04\x83\t\x83\x04\x84\t\x84\x04\x85\t\x85\x04\x86\t\x86" +
|
|
"\x04\x87\t\x87\x04\x88\t\x88\x04\x89\t\x89\x04\x8A\t\x8A\x04\x8B\t\x8B" +
|
|
"\x04\x8C\t\x8C\x04\x8D\t\x8D\x04\x8E\t\x8E\x04\x8F\t\x8F\x04\x90\t\x90" +
|
|
"\x04\x91\t\x91\x04\x92\t\x92\x04\x93\t\x93\x04\x94\t\x94\x04\x95\t\x95" +
|
|
"\x04\x96\t\x96\x04\x97\t\x97\x04\x98\t\x98\x04\x99\t\x99\x04\x9A\t\x9A" +
|
|
"\x04\x9B\t\x9B\x04\x9C\t\x9C\x04\x9D\t\x9D\x04\x9E\t\x9E\x04\x9F\t\x9F" +
|
|
"\x04\xA0\t\xA0\x04\xA1\t\xA1\x04\xA2\t\xA2\x04\xA3\t\xA3\x04\xA4\t\xA4" +
|
|
"\x04\xA5\t\xA5\x04\xA6\t\xA6\x04\xA7\t\xA7\x04\xA8\t\xA8\x04\xA9\t\xA9" +
|
|
"\x04\xAA\t\xAA\x04\xAB\t\xAB\x04\xAC\t\xAC\x04\xAD\t\xAD\x04\xAE\t\xAE" +
|
|
"\x04\xAF\t\xAF\x04\xB0\t\xB0\x04\xB1\t\xB1\x04\xB2\t\xB2\x04\xB3\t\xB3" +
|
|
"\x04\xB4\t\xB4\x04\xB5\t\xB5\x04\xB6\t\xB6\x04\xB7\t\xB7\x04\xB8\t\xB8" +
|
|
"\x04\xB9\t\xB9\x04\xBA\t\xBA\x04\xBB\t\xBB\x04\xBC\t\xBC\x04\xBD\t\xBD" +
|
|
"\x04\xBE\t\xBE\x04\xBF\t\xBF\x04\xC0\t\xC0\x04\xC1\t\xC1\x04\xC2\t\xC2" +
|
|
"\x03\x02\x07\x02\u0186\n\x02\f\x02\x0E\x02\u0189\v\x02\x03\x02\x03\x02" +
|
|
"\x03\x03\x03\x03\x05\x03\u018F\n\x03\x03\x04\x03\x04\x05\x04\u0193\n\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x05\x04\u01A0\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u01A5" +
|
|
"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u01AD\n" +
|
|
"\x04\f\x04\x0E\x04\u01B0\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x05\x04\u01C2\n\x04\x03\x04\x03\x04\x05\x04\u01C6\n\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u01CC\n\x04\x03\x04\x05\x04\u01CF" +
|
|
"\n\x04\x03\x04\x05\x04\u01D2\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x05\x04\u01D9\n\x04\x03\x04\x05\x04\u01DC\n\x04\x03\x04\x03\x04\x05" +
|
|
"\x04\u01E0\n\x04\x03\x04\x05\x04\u01E3\n\x04\x03\x04\x03\x04\x03\x04\x05" +
|
|
"\x04\u01E8\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x07\x04\u01F3\n\x04\f\x04\x0E\x04\u01F6\v\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u01FD\n\x04\x03\x04\x05\x04\u0200" +
|
|
"\n\x04\x03\x04\x03\x04\x05\x04\u0204\n\x04\x03\x04\x05\x04\u0207\n\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u020D\n\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0218\n\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u021E\n\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x05\x04\u0223\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0244" +
|
|
"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x05\x04\u0250\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x05\x04\u0259\n\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0264\n\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u026F" +
|
|
"\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0274\n\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u027D\n\x04\x03\x04\x03\x04" +
|
|
"\x05\x04\u0281\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0287\n\x04" +
|
|
"\x03\x04\x03\x04\x05\x04\u028B\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0290" +
|
|
"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0296\n\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05" +
|
|
"\x04\u02A2\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
|
|
"\u02AA\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u02B0\n\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
|
|
"\u02BB\n\x04\x03\x04\x03\x04\x05\x04\u02BF\n\x04\x03\x04\x06\x04\u02C2" +
|
|
"\n\x04\r\x04\x0E\x04\u02C3\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u02D3" +
|
|
"\n\x04\x03\x04\x03\x04\x05\x04\u02D7\n\x04\x03\x04\x03\x04\x03\x04\x07" +
|
|
"\x04\u02DC\n\x04\f\x04\x0E\x04\u02DF\v\x04\x03\x04\x05\x04\u02E2\n\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u02E8\n\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x05\x04\u02F6\n\x04\x03\x04\x03\x04\x05\x04\u02FA\n\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x05\x04\u02FF\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
|
|
"\u0305\n\x04\x03\x04\x05\x04\u0308\n\x04\x03\x04\x05\x04\u030B\n\x04\x03" +
|
|
"\x04\x03\x04\x05\x04\u030F\n\x04\x03\x04\x03\x04\x05\x04\u0313\n\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u031B\n\x04\f\x04" +
|
|
"\x0E\x04\u031E\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05" +
|
|
"\x04\u0326\n\x04\x03\x04\x05\x04\u0329\n\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0332\n\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x05\x04\u0337\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u033D\n\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0344\n\x04\x03\x04\x05" +
|
|
"\x04\u0347\n\x04\x03\x04\x03\x04\x05\x04\u034B\n\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0354\n\x04\f\x04\x0E\x04" +
|
|
"\u0357\v\x04\x05\x04\u0359\n\x04\x03\x04\x03\x04\x05\x04\u035D\n\x04\x03" +
|
|
"\x04\x03\x04\x05\x04\u0361\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
|
|
"\u0367\n\x04\x03\x04\x05\x04\u036A\n\x04\x03\x04\x03\x04\x05\x04\u036E" +
|
|
"\n\x04\x03\x04\x05\x04\u0371\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05" +
|
|
"\x04\u0377\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u037C\n\x04\x03\x04\x03" +
|
|
"\x04\x05\x04\u0380\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
|
|
"\u0387\n\x04\x03\x04\x05\x04\u038A\n\x04\x03\x04\x05\x04\u038D\n\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0394\n\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x05\x04\u0399\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x05\x04\u03A2\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x05\x04\u03AA\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03B0" +
|
|
"\n\x04\x03\x04\x05\x04\u03B3\n\x04\x03\x04\x05\x04\u03B6\n\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x05\x04\u03BC\n\x04\x03\x04\x03\x04\x05\x04\u03C0" +
|
|
"\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03C5\n\x04\x03\x04\x05\x04\u03C8" +
|
|
"\n\x04\x03\x04\x03\x04\x05\x04\u03CC\n\x04\x05\x04\u03CE\n\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03D6\n\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03DE\n\x04\x03\x04\x05\x04" +
|
|
"\u03E1\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03E6\n\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x05\x04\u03EC\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03F1" +
|
|
"\n\x04\x03\x04\x05\x04\u03F4\n\x04\x03\x04\x03\x04\x05\x04\u03F8\n\x04" +
|
|
"\x03\x04\x05\x04\u03FB\n\x04\x03\x04\x03\x04\x05\x04\u03FF\n\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0419\n\x04\f\x04\x0E" +
|
|
"\x04\u041C\v\x04\x05\x04\u041E\n\x04\x03\x04\x03\x04\x05\x04\u0422\n\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0428\n\x04\x03\x04\x05\x04\u042B" +
|
|
"\n\x04\x03\x04\x05\x04\u042E\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0433" +
|
|
"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u043B\n" +
|
|
"\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0440\n\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x05\x04\u0446\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u044C" +
|
|
"\n\x04\x03\x04\x05\x04\u044F\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x05\x04\u0456\n\x04\x03\x04\x03\x04\x03\x04\x07\x04\u045B\n\x04\f" +
|
|
"\x04\x0E\x04\u045E\v\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0463\n\x04\f" +
|
|
"\x04\x0E\x04\u0466\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0474\n\x04\f" +
|
|
"\x04\x0E\x04\u0477\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u048F" +
|
|
"\n\x04\f\x04\x0E\x04\u0492\v\x04\x05\x04\u0494\n\x04\x03\x04\x03\x04\x07" +
|
|
"\x04\u0498\n\x04\f\x04\x0E\x04\u049B\v\x04\x03\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x07\x04\u04A1\n\x04\f\x04\x0E\x04\u04A4\v\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x07\x04\u04AA\n\x04\f\x04\x0E\x04\u04AD\v\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x05\x04\u04B2\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u04B7" +
|
|
"\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u04BC\n\x04\x03\x04\x03\x04\x03" +
|
|
"\x04\x03\x04\x03\x04\x05\x04\u04C3\n\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
|
|
"\u04C8\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u04CD\n\x04\x03\x04\x03\x04" +
|
|
"\x03\x04\x03\x04\x07\x04\u04D3\n\x04\f\x04\x0E\x04\u04D6\v\x04\x05\x04" +
|
|
"\u04D8\n\x04\x03\x05\x03\x05\x05\x05\u04DC\n\x05\x03\x06\x03\x06\x03\x07" +
|
|
"\x03\x07\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u04E8\n\b\x03\b\x03" +
|
|
"\b\x05\b\u04EC\n\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u04F3\n\b\x03\b" +
|
|
"\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u0567\n\b\x03\b\x03\b\x03\b\x03" +
|
|
"\b\x03\b\x03\b\x05\b\u056F\n\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05" +
|
|
"\b\u0577\n\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u0580\n\b" +
|
|
"\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u058A\n\b\x03\t" +
|
|
"\x03\t\x05\t\u058E\n\t\x03\t\x05\t\u0591\n\t\x03\t\x03\t\x05\t\u0595\n" +
|
|
"\t\x03\t\x03\t\x03\n\x03\n\x05\n\u059B\n\n\x03\n\x03\n\x03\n\x03\n\x03" +
|
|
"\v\x03\v\x03\v\x03\v\x03\v\x03\v\x05\v\u05A7\n\v\x03\v\x03\v\x03\v\x03" +
|
|
"\v\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x05\f\u05B3\n\f\x03\f\x03\f\x03" +
|
|
"\f\x05\f\u05B8\n\f\x03\r\x03\r\x03\r\x03\x0E\x03\x0E\x03\x0E\x03\x0F\x05" +
|
|
"\x0F\u05C1\n\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x10\x05\x10" +
|
|
"\u05C9\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05CE\n\x10\x05\x10\u05D0" +
|
|
"\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05D5\n\x10\x03\x10\x03\x10\x03" +
|
|
"\x10\x05\x10\u05DA\n\x10\x03\x10\x03\x10\x05\x10\u05DE\n\x10\x03\x10\x05" +
|
|
"\x10\u05E1\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05E6\n\x10\x03\x10\x03" +
|
|
"\x10\x03\x10\x05\x10\u05EB\n\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10" +
|
|
"\x03\x10\x03\x10\x05\x10\u05F4\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05F9" +
|
|
"\n\x10\x03\x10\x05\x10\u05FC\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u0601" +
|
|
"\n\x10\x03\x10\x03\x10\x05\x10\u0605\n\x10\x03\x10\x03\x10\x03\x10\x05" +
|
|
"\x10\u060A\n\x10\x05\x10\u060C\n\x10\x03\x11\x03\x11\x05\x11\u0610\n\x11" +
|
|
"\x03\x12\x03\x12\x03\x12\x03\x12\x03\x12\x07\x12\u0617\n\x12\f\x12\x0E" +
|
|
"\x12\u061A\v\x12\x03\x12\x03\x12\x03\x13\x03\x13\x03\x13\x05\x13\u0621" +
|
|
"\n\x13\x03\x13\x03\x13\x03\x13\x03\x13\x05\x13\u0627\n\x13\x03\x14\x03" +
|
|
"\x14\x03\x15\x03\x15\x03\x16\x03\x16\x03\x16\x03\x16\x03\x16\x05\x16\u0632" +
|
|
"\n\x16\x03\x17\x03\x17\x03\x17\x07\x17\u0637\n\x17\f\x17\x0E\x17\u063A" +
|
|
"\v\x17\x03\x18\x03\x18\x03\x18\x03\x18\x07\x18\u0640\n\x18\f\x18\x0E\x18" +
|
|
"\u0643\v\x18\x03\x19\x03\x19\x05\x19\u0647\n\x19\x03\x19\x05\x19\u064A" +
|
|
"\n\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1B" +
|
|
"\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B" +
|
|
"\x03\x1B\x03\x1B\x03\x1B\x07\x1B\u0660\n\x1B\f\x1B\x0E\x1B\u0663\v\x1B" +
|
|
"\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x07\x1C\u0669\n\x1C\f\x1C\x0E\x1C\u066C" +
|
|
"\v\x1C\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x05\x1D\u0672\n\x1D\x03\x1D\x05" +
|
|
"\x1D\u0675\n\x1D\x03\x1E\x03\x1E\x03\x1E\x07\x1E\u067A\n\x1E\f\x1E\x0E" +
|
|
"\x1E\u067D\v\x1E\x03\x1E\x05\x1E\u0680\n\x1E\x03\x1F\x03\x1F\x03\x1F\x03" +
|
|
"\x1F\x05\x1F\u0686\n\x1F\x03 \x03 \x03 \x03 \x07 \u068C\n \f \x0E \u068F" +
|
|
"\v \x03 \x03 \x03!\x03!\x05!\u0695\n!\x03!\x05!\u0698\n!\x03\"\x03\"\x03" +
|
|
"\"\x03\"\x07\"\u069E\n\"\f\"\x0E\"\u06A1\v\"\x03\"\x03\"\x03#\x03#\x03" +
|
|
"#\x03#\x07#\u06A9\n#\f#\x0E#\u06AC\v#\x03#\x03#\x03$\x03$\x03$\x03$\x03" +
|
|
"$\x03$\x05$\u06B6\n$\x03%\x03%\x03%\x03%\x03%\x03%\x05%\u06BE\n%\x03&" +
|
|
"\x03&\x03&\x03&\x05&\u06C4\n&\x03\'\x03\'\x03\'\x03(\x03(\x03(\x03(\x03" +
|
|
"(\x06(\u06CE\n(\r(\x0E(\u06CF\x03(\x03(\x03(\x03(\x03(\x05(\u06D7\n(\x03" +
|
|
"(\x03(\x03(\x03(\x03(\x05(\u06DE\n(\x03(\x03(\x03(\x03(\x03(\x03(\x03" +
|
|
"(\x03(\x03(\x03(\x05(\u06EA\n(\x03(\x03(\x03(\x03(\x07(\u06F0\n(\f(\x0E" +
|
|
"(\u06F3\v(\x03(\x07(\u06F6\n(\f(\x0E(\u06F9\v(\x03(\x07(\u06FC\n(\f(\x0E" +
|
|
"(\u06FF\v(\x05(\u0701\n(\x03)\x03)\x03*\x03*\x03+\x03+\x03,\x03,\x03-" +
|
|
"\x03-\x03.\x03.\x03/\x03/\x03/\x03/\x03/\x03/\x05/\u0715\n/\x030\x030" +
|
|
"\x030\x030\x030\x070\u071C\n0\f0\x0E0\u071F\v0\x050\u0721\n0\x030\x03" +
|
|
"0\x030\x030\x030\x070\u0728\n0\f0\x0E0\u072B\v0\x050\u072D\n0\x030\x03" +
|
|
"0\x030\x030\x030\x070\u0734\n0\f0\x0E0\u0737\v0\x050\u0739\n0\x030\x03" +
|
|
"0\x030\x030\x030\x070\u0740\n0\f0\x0E0\u0743\v0\x050\u0745\n0\x030\x05" +
|
|
"0\u0748\n0\x030\x030\x030\x050\u074D\n0\x050\u074F\n0\x030\x030\x050\u0753" +
|
|
"\n0\x031\x031\x031\x032\x032\x032\x032\x032\x032\x032\x052\u075F\n2\x03" +
|
|
"2\x032\x032\x032\x032\x052\u0766\n2\x032\x032\x032\x032\x032\x052\u076D" +
|
|
"\n2\x032\x072\u0770\n2\f2\x0E2\u0773\v2\x033\x033\x033\x033\x033\x033" +
|
|
"\x033\x033\x033\x053\u077E\n3\x034\x034\x054\u0782\n4\x034\x034\x054\u0786" +
|
|
"\n4\x035\x035\x065\u078A\n5\r5\x0E5\u078B\x036\x036\x056\u0790\n6\x03" +
|
|
"6\x036\x036\x036\x076\u0796\n6\f6\x0E6\u0799\v6\x036\x056\u079C\n6\x03" +
|
|
"6\x056\u079F\n6\x036\x056\u07A2\n6\x036\x056\u07A5\n6\x036\x036\x056\u07A9" +
|
|
"\n6\x037\x037\x057\u07AD\n7\x037\x077\u07B0\n7\f7\x0E7\u07B3\v7\x037\x05" +
|
|
"7\u07B6\n7\x037\x057\u07B9\n7\x037\x057\u07BC\n7\x037\x057\u07BF\n7\x03" +
|
|
"7\x037\x057\u07C3\n7\x037\x077\u07C6\n7\f7\x0E7\u07C9\v7\x037\x057\u07CC" +
|
|
"\n7\x037\x057\u07CF\n7\x037\x057\u07D2\n7\x037\x057\u07D5\n7\x057\u07D7" +
|
|
"\n7\x038\x038\x038\x038\x058\u07DD\n8\x038\x038\x038\x038\x038\x058\u07E4" +
|
|
"\n8\x038\x038\x038\x058\u07E9\n8\x038\x058\u07EC\n8\x038\x058\u07EF\n" +
|
|
"8\x038\x038\x058\u07F3\n8\x038\x038\x038\x038\x038\x038\x038\x038\x05" +
|
|
"8\u07FD\n8\x038\x038\x058\u0801\n8\x058\u0803\n8\x038\x058\u0806\n8\x03" +
|
|
"8\x038\x058\u080A\n8\x039\x039\x079\u080E\n9\f9\x0E9\u0811\v9\x039\x05" +
|
|
"9\u0814\n9\x039\x039\x03:\x03:\x03:\x03;\x03;\x03;\x03;\x05;\u081F\n;" +
|
|
"\x03;\x03;\x03;\x03<\x03<\x03<\x03<\x03<\x05<\u0829\n<\x03<\x03<\x05<" +
|
|
"\u082D\n<\x03<\x03<\x03<\x03=\x03=\x03=\x03=\x03=\x03=\x03=\x05=\u0839" +
|
|
"\n=\x03=\x03=\x03=\x03>\x03>\x03>\x03>\x03>\x03>\x03>\x05>\u0845\n>\x03" +
|
|
"?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x03?\x07?\u0852\n?\f?\x0E" +
|
|
"?\u0855\v?\x03?\x03?\x05?\u0859\n?\x03@\x03@\x03@\x03@\x05@\u085F\n@\x03" +
|
|
"A\x03A\x03A\x07A\u0864\nA\fA\x0EA\u0867\vA\x03B\x03B\x03B\x03B\x03C\x03" +
|
|
"C\x03C\x03D\x03D\x03D\x03E\x03E\x03E\x05E\u0876\nE\x03E\x07E\u0879\nE" +
|
|
"\fE\x0EE\u087C\vE\x03E\x03E\x03F\x03F\x03F\x03F\x03F\x03F\x07F\u0886\n" +
|
|
"F\fF\x0EF\u0889\vF\x03F\x03F\x05F\u088D\nF\x03G\x03G\x03G\x03G\x07G\u0893" +
|
|
"\nG\fG\x0EG\u0896\vG\x03G\x07G\u0899\nG\fG\x0EG\u089C\vG\x03G\x05G\u089F" +
|
|
"\nG\x03G\x05G\u08A2\nG\x03H\x03H\x03I\x05I\u08A7\nI\x03I\x03I\x03I\x03" +
|
|
"I\x03I\x05I\u08AE\nI\x03I\x03I\x03I\x03I\x05I\u08B4\nI\x03J\x03J\x03J" +
|
|
"\x03J\x03J\x07J\u08BB\nJ\fJ\x0EJ\u08BE\vJ\x03J\x03J\x03J\x03J\x03J\x07" +
|
|
"J\u08C5\nJ\fJ\x0EJ\u08C8\vJ\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03" +
|
|
"J\x03J\x07J\u08D4\nJ\fJ\x0EJ\u08D7\vJ\x03J\x03J\x05J\u08DB\nJ\x05J\u08DD" +
|
|
"\nJ\x03K\x03K\x05K\u08E1\nK\x03L\x03L\x03L\x03L\x03L\x07L\u08E8\nL\fL" +
|
|
"\x0EL\u08EB\vL\x03L\x03L\x03L\x03L\x03L\x03L\x03L\x03L\x07L\u08F5\nL\f" +
|
|
"L\x0EL\u08F8\vL\x03L\x03L\x05L\u08FC\nL\x03M\x03M\x05M\u0900\nM\x03N\x03" +
|
|
"N\x03N\x03N\x07N\u0906\nN\fN\x0EN\u0909\vN\x05N\u090B\nN\x03N\x03N\x05" +
|
|
"N\u090F\nN\x03O\x03O\x03O\x03O\x03O\x03O\x03O\x03O\x03O";
|
|
private static readonly _serializedATNSegment1: string =
|
|
"\x03O\x07O\u091B\nO\fO\x0EO\u091E\vO\x03O\x03O\x03O\x03P\x03P\x03P\x03" +
|
|
"P\x03P\x07P\u0928\nP\fP\x0EP\u092B\vP\x03P\x03P\x05P\u092F\nP\x03Q\x03" +
|
|
"Q\x05Q\u0933\nQ\x03Q\x05Q\u0936\nQ\x03R\x03R\x05R\u093A\nR\x03R\x03R\x03" +
|
|
"R\x03R\x05R\u0940\nR\x03R\x05R\u0943\nR\x03S\x03S\x03S\x03T\x03T\x05T" +
|
|
"\u094A\nT\x03U\x03U\x03U\x03U\x03U\x03U\x03U\x03U\x07U\u0954\nU\fU\x0E" +
|
|
"U\u0957\vU\x03U\x03U\x03V\x03V\x03V\x03V\x07V\u095F\nV\fV\x0EV\u0962\v" +
|
|
"V\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x03V\x07V\u096C\nV\fV\x0EV\u096F" +
|
|
"\vV\x03V\x03V\x03W\x03W\x03W\x03W\x07W\u0977\nW\fW\x0EW\u097A\vW\x03W" +
|
|
"\x03W\x05W\u097E\nW\x03X\x03X\x03Y\x03Y\x03Z\x03Z\x05Z\u0986\nZ\x03[\x03" +
|
|
"[\x03\\\x05\\\u098B\n\\\x03\\\x03\\\x03]\x03]\x03]\x03]\x03^\x03^\x03" +
|
|
"^\x03_\x03_\x03_\x05_\u0999\n_\x03_\x03_\x03_\x03_\x03_\x07_\u09A0\n_" +
|
|
"\f_\x0E_\u09A3\v_\x05_\u09A5\n_\x03_\x03_\x03_\x05_\u09AA\n_\x03_\x03" +
|
|
"_\x03_\x07_\u09AF\n_\f_\x0E_\u09B2\v_\x05_\u09B4\n_\x03`\x03`\x03a\x05" +
|
|
"a\u09B9\na\x03a\x03a\x07a\u09BD\na\fa\x0Ea\u09C0\va\x03a\x05a\u09C3\n" +
|
|
"a\x03b\x03b\x03b\x05b\u09C8\nb\x03c\x03c\x03c\x05c\u09CD\nc\x03c\x03c" +
|
|
"\x05c\u09D1\nc\x03c\x03c\x03c\x03c\x05c\u09D7\nc\x03c\x03c\x05c\u09DB" +
|
|
"\nc\x03d\x05d\u09DE\nd\x03d\x03d\x03d\x05d\u09E3\nd\x03d\x05d\u09E6\n" +
|
|
"d\x03d\x03d\x03d\x05d\u09EB\nd\x03d\x03d\x05d\u09EF\nd\x03d\x05d\u09F2" +
|
|
"\nd\x03d\x05d\u09F5\nd\x03e\x03e\x03e\x03e\x05e\u09FB\ne\x03f\x03f\x03" +
|
|
"f\x05f\u0A00\nf\x03f\x03f\x03f\x03f\x03f\x05f\u0A07\nf\x03g\x05g\u0A0A" +
|
|
"\ng\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03" +
|
|
"g\x03g\x03g\x05g\u0A1C\ng\x05g\u0A1E\ng\x03g\x05g\u0A21\ng\x03h\x03h\x03" +
|
|
"h\x03h\x03i\x03i\x03i\x07i\u0A2A\ni\fi\x0Ei\u0A2D\vi\x03j\x03j\x03j\x03" +
|
|
"j\x07j\u0A33\nj\fj\x0Ej\u0A36\vj\x03j\x03j\x03k\x03k\x05k\u0A3C\nk\x03" +
|
|
"l\x03l\x03l\x03l\x07l\u0A42\nl\fl\x0El\u0A45\vl\x03l\x03l\x03m\x03m\x05" +
|
|
"m\u0A4B\nm\x03n\x03n\x05n\u0A4F\nn\x03n\x05n\u0A52\nn\x03n\x03n\x03n\x03" +
|
|
"n\x03n\x03n\x05n\u0A5A\nn\x03n\x03n\x03n\x03n\x03n\x03n\x05n\u0A62\nn" +
|
|
"\x03n\x03n\x03n\x03n\x05n\u0A68\nn\x03o\x03o\x03o\x03o\x07o\u0A6E\no\f" +
|
|
"o\x0Eo\u0A71\vo\x03o\x03o\x03p\x03p\x03p\x05p\u0A78\np\x03p\x03p\x03p" +
|
|
"\x03p\x03p\x05p\u0A7F\np\x03p\x03p\x03p\x03p\x03p\x05p\u0A86\np\x05p\u0A88" +
|
|
"\np\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x07q\u0A93\nq\fq\x0E" +
|
|
"q\u0A96\vq\x03q\x03q\x03q\x05q\u0A9B\nq\x05q\u0A9D\nq\x03q\x03q\x03q\x03" +
|
|
"q\x03q\x03q\x07q\u0AA5\nq\fq\x0Eq\u0AA8\vq\x03q\x03q\x03q\x05q\u0AAD\n" +
|
|
"q\x05q\u0AAF\nq\x03r\x03r\x03r\x03r\x03s\x03s\x05s\u0AB7\ns\x03t\x03t" +
|
|
"\x05t\u0ABB\nt\x03u\x03u\x03u\x03u\x03u\x07u\u0AC2\nu\fu\x0Eu\u0AC5\v" +
|
|
"u\x05u\u0AC7\nu\x03u\x03u\x03u\x03v\x05v\u0ACD\nv\x03v\x03v\x05v\u0AD1" +
|
|
"\nv\x05v\u0AD3\nv\x03w\x03w\x03w\x03w\x03w\x03w\x03w\x05w\u0ADC\nw\x03" +
|
|
"w\x03w\x03w\x03w\x03w\x03w\x03w\x03w\x03w\x03w\x05w\u0AE8\nw\x05w\u0AEA" +
|
|
"\nw\x03w\x03w\x03w\x03w\x03w\x05w\u0AF1\nw\x03w\x03w\x03w\x03w\x03w\x05" +
|
|
"w\u0AF8\nw\x03w\x03w\x03w\x03w\x05w\u0AFE\nw\x03w\x03w\x03w\x03w\x05w" +
|
|
"\u0B04\nw\x05w\u0B06\nw\x03x\x03x\x03x\x07x\u0B0B\nx\fx\x0Ex\u0B0E\vx" +
|
|
"\x03y\x03y\x03y\x07y\u0B13\ny\fy\x0Ey\u0B16\vy\x03z\x03z\x03z\x07z\u0B1B" +
|
|
"\nz\fz\x0Ez\u0B1E\vz\x03{\x03{\x03{\x05{\u0B23\n{\x03|\x03|\x03|\x05|" +
|
|
"\u0B28\n|\x03|\x03|\x03}\x03}\x03}\x05}\u0B2F\n}\x03}\x03}\x03~\x03~\x05" +
|
|
"~\u0B35\n~\x03~\x03~\x05~\u0B39\n~\x05~\u0B3B\n~\x03\x7F\x03\x7F\x03\x7F" +
|
|
"\x07\x7F\u0B40\n\x7F\f\x7F\x0E\x7F\u0B43\v\x7F\x03\x80\x03\x80\x03\x80" +
|
|
"\x03\x80\x07\x80\u0B49\n\x80\f\x80\x0E\x80\u0B4C\v\x80\x03\x80\x03\x80" +
|
|
"\x03\x81\x03\x81\x05\x81\u0B52\n\x81\x03\x82\x03\x82\x03\x82\x03\x82\x03" +
|
|
"\x82\x03\x82\x07\x82\u0B5A\n\x82\f\x82\x0E\x82\u0B5D\v\x82\x03\x82\x03" +
|
|
"\x82\x05\x82\u0B61\n\x82\x03\x83\x03\x83\x05\x83\u0B65\n\x83\x03\x84\x03" +
|
|
"\x84\x03\x85\x03\x85\x03\x85\x03\x85\x03\x86\x03\x86\x05\x86\u0B6F\n\x86" +
|
|
"\x03\x87\x03\x87\x03\x87\x07\x87\u0B74\n\x87\f\x87\x0E\x87\u0B77\v\x87" +
|
|
"\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88" +
|
|
"\x03\x88\x05\x88\u0B83\n\x88\x05\x88\u0B85\n\x88\x03\x88\x03\x88\x03\x88" +
|
|
"\x03\x88\x03\x88\x03\x88\x07\x88\u0B8D\n\x88\f\x88\x0E\x88\u0B90\v\x88" +
|
|
"\x03\x89\x05\x89\u0B93\n\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03" +
|
|
"\x89\x05\x89\u0B9B\n\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x07\x89" +
|
|
"\u0BA2\n\x89\f\x89\x0E\x89\u0BA5\v\x89\x03\x89\x03\x89\x03\x89\x05\x89" +
|
|
"\u0BAA\n\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x05\x89\u0BB2" +
|
|
"\n\x89\x03\x89\x03\x89\x03\x89\x05\x89\u0BB7\n\x89\x03\x89\x03\x89\x03" +
|
|
"\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x07\x89\u0BC1\n\x89\f\x89" +
|
|
"\x0E\x89\u0BC4\v\x89\x03\x89\x03\x89\x05\x89\u0BC8\n\x89\x03\x89\x05\x89" +
|
|
"\u0BCB\n\x89\x03\x89\x03\x89\x03\x89\x03\x89\x05\x89\u0BD1\n\x89\x03\x89" +
|
|
"\x03\x89\x05\x89\u0BD5\n\x89\x03\x89\x03\x89\x03\x89\x05\x89\u0BDA\n\x89" +
|
|
"\x03\x89\x03\x89\x03\x89\x05\x89\u0BDF\n\x89\x03\x89\x03\x89\x03\x89\x05" +
|
|
"\x89\u0BE4\n\x89\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x05\x8A\u0BEA\n\x8A\x03" +
|
|
"\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03" +
|
|
"\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03" +
|
|
"\x8A\x07\x8A\u0BFF\n\x8A\f\x8A\x0E\x8A\u0C02\v\x8A\x03\x8B\x03\x8B\x03" +
|
|
"\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0C0C\n\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x05\x8C\u0C18\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x03\x8C\x06\x8C\u0C22\n\x8C\r\x8C\x0E\x8C\u0C23\x03\x8C\x03\x8C\x05" +
|
|
"\x8C\u0C28\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x06\x8C\u0C2F" +
|
|
"\n\x8C\r\x8C\x0E\x8C\u0C30\x03\x8C\x03\x8C\x05\x8C\u0C35\n\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x07\x8C\u0C45\n\x8C\f\x8C\x0E\x8C\u0C48" +
|
|
"\v\x8C\x05\x8C\u0C4A\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x05\x8C\u0C52\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x05\x8C\u0C5B\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x03\x8C\x05\x8C\u0C64\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x06\x8C\u0C79\n\x8C\r\x8C\x0E" +
|
|
"\x8C\u0C7A\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0C8B\n\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x07\x8C\u0C90\n\x8C\f\x8C\x0E\x8C\u0C93\v\x8C" +
|
|
"\x05\x8C\u0C95\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x05\x8C\u0C9E\n\x8C\x03\x8C\x03\x8C\x05\x8C\u0CA2\n\x8C\x03\x8C\x03" +
|
|
"\x8C\x05\x8C\u0CA6\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x06\x8C\u0CB0\n\x8C\r\x8C\x0E\x8C\u0CB1\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0CCB\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x03\x8C\x05\x8C\u0CD2\n\x8C\x03\x8C\x05\x8C\u0CD5\n\x8C\x03\x8C\x03" +
|
|
"\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x03\x8C\x03\x8C\x05\x8C\u0CE4\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
|
|
"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0CF9\n\x8C\x03" +
|
|
"\x8C\x03\x8C\x05\x8C\u0CFD\n\x8C\x05\x8C\u0CFF\n\x8C\x03\x8C\x03\x8C\x03" +
|
|
"\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x07\x8C\u0D09\n\x8C\f\x8C" +
|
|
"\x0E\x8C\u0D0C\v\x8C\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03" +
|
|
"\x8D\x05\x8D\u0D15\n\x8D\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8E" +
|
|
"\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x06\x8E\u0D22\n\x8E\r\x8E\x0E" +
|
|
"\x8E\u0D23\x05\x8E\u0D26\n\x8E\x03\x8F\x03\x8F\x03\x90\x03\x90\x03\x91" +
|
|
"\x03\x91\x03\x92\x03\x92\x03\x93\x03\x93\x03\x93\x05\x93\u0D33\n\x93\x03" +
|
|
"\x94\x03\x94\x05\x94\u0D37\n\x94\x03\x95\x03\x95\x03\x95\x06\x95\u0D3C" +
|
|
"\n\x95\r\x95\x0E\x95\u0D3D\x03\x96\x03\x96\x03\x96\x05\x96\u0D43\n\x96" +
|
|
"\x03\x97\x03\x97\x03\x97\x03\x97\x03\x97\x03\x98\x05\x98\u0D4B\n\x98\x03" +
|
|
"\x98\x03\x98\x03\x98\x05\x98\u0D50\n\x98\x03\x99\x03\x99\x03\x9A\x03\x9A" +
|
|
"\x03\x9B\x03\x9B\x03\x9B\x05\x9B\u0D59\n\x9B\x03\x9C\x03\x9C\x03\x9C\x03" +
|
|
"\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03" +
|
|
"\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03" +
|
|
"\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x05" +
|
|
"\x9C\u0D79\n\x9C\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" +
|
|
"\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x05\x9D" +
|
|
"\u0D8A\n\x9D\x03\x9D\x03\x9D\x05\x9D\u0D8E\n\x9D\x03\x9D\x03\x9D\x03\x9D" +
|
|
"\x03\x9D\x05\x9D\u0D94\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x05\x9D\u0D9A" +
|
|
"\n\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x07\x9D\u0DA1\n\x9D\f\x9D" +
|
|
"\x0E\x9D\u0DA4\v\x9D\x03\x9D\x05\x9D\u0DA7\n\x9D\x05\x9D\u0DA9\n\x9D\x03" +
|
|
"\x9E\x03\x9E\x03\x9E\x07\x9E\u0DAE\n\x9E\f\x9E\x0E\x9E\u0DB1\v\x9E\x03" +
|
|
"\x9F\x03\x9F\x03\x9F\x07\x9F\u0DB6\n\x9F\f\x9F\x0E\x9F\u0DB9\v\x9F\x03" +
|
|
"\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x05\xA0\u0DC0\n\xA0\x03\xA1\x03\xA1" +
|
|
"\x03\xA1\x03\xA2\x03\xA2\x03\xA2\x03\xA3\x03\xA3\x03\xA3\x07\xA3\u0DCB" +
|
|
"\n\xA3\f\xA3\x0E\xA3\u0DCE\v\xA3\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x05\xA4" +
|
|
"\u0DD4\n\xA4\x03\xA4\x05\xA4\u0DD7\n\xA4\x03\xA5\x03\xA5\x03\xA5\x07\xA5" +
|
|
"\u0DDC\n\xA5\f\xA5\x0E\xA5\u0DDF\v\xA5\x03\xA6\x03\xA6\x03\xA6\x07\xA6" +
|
|
"\u0DE4\n\xA6\f\xA6\x0E\xA6\u0DE7\v\xA6\x03\xA7\x03\xA7\x03\xA7\x03\xA7" +
|
|
"\x03\xA7\x05\xA7\u0DEE\n\xA7\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03" +
|
|
"\xA8\x03\xA8\x03\xA9\x03\xA9\x03\xA9\x07\xA9\u0DFA\n\xA9\f\xA9\x0E\xA9" +
|
|
"\u0DFD\v\xA9\x03\xAA\x03\xAA\x05\xAA\u0E01\n\xAA\x03\xAA\x03\xAA\x03\xAA" +
|
|
"\x05\xAA\u0E06\n\xAA\x03\xAA\x05\xAA\u0E09\n\xAA\x03\xAB\x03\xAB\x03\xAB" +
|
|
"\x03\xAB\x03\xAB\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x07\xAC\u0E14\n\xAC\f" +
|
|
"\xAC\x0E\xAC\u0E17\v\xAC\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAE\x03\xAE" +
|
|
"\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE" +
|
|
"\x07\xAE\u0E28\n\xAE\f\xAE\x0E\xAE\u0E2B\v\xAE\x03\xAE\x03\xAE\x03\xAE" +
|
|
"\x03\xAE\x03\xAE\x07\xAE\u0E32\n\xAE\f\xAE\x0E\xAE\u0E35\v\xAE\x05\xAE" +
|
|
"\u0E37\n\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x07\xAE\u0E3E\n\xAE" +
|
|
"\f\xAE\x0E\xAE\u0E41\v\xAE\x05\xAE\u0E43\n\xAE\x05\xAE\u0E45\n\xAE\x03" +
|
|
"\xAE\x05\xAE\u0E48\n\xAE\x03\xAE\x05\xAE\u0E4B\n\xAE\x03\xAF\x03\xAF\x03" +
|
|
"\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03" +
|
|
"\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x05\xAF\u0E5D\n\xAF\x03\xB0\x03\xB0" +
|
|
"\x03\xB0\x03\xB0\x03\xB0\x03\xB0\x03\xB0\x05\xB0\u0E66\n\xB0\x03\xB1\x03" +
|
|
"\xB1\x03\xB1\x07\xB1\u0E6B\n\xB1\f\xB1\x0E\xB1\u0E6E\v\xB1\x03\xB2\x03" +
|
|
"\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x05\xB2\u0E79" +
|
|
"\n\xB2\x03\xB3\x03\xB3\x03\xB4\x03\xB4\x03\xB4\x07\xB4\u0E80\n\xB4\f\xB4" +
|
|
"\x0E\xB4\u0E83\v\xB4\x03\xB5\x03\xB5\x03\xB5\x03\xB6\x03\xB6\x06\xB6\u0E8A" +
|
|
"\n\xB6\r\xB6\x0E\xB6\u0E8B\x03\xB6\x05\xB6\u0E8F\n\xB6\x03\xB7\x03\xB7" +
|
|
"\x03\xB7\x05\xB7\u0E94\n\xB7\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03" +
|
|
"\xB8\x05\xB8\u0E9C\n\xB8\x03\xB9\x03\xB9\x03\xB9\x05\xB9\u0EA1\n\xB9\x03" +
|
|
"\xBA\x03\xBA\x03\xBB\x03\xBB\x05\xBB\u0EA7\n\xBB\x03\xBB\x03\xBB\x03\xBB" +
|
|
"\x05\xBB\u0EAC\n\xBB\x03\xBB\x03\xBB\x03\xBB\x05\xBB\u0EB1\n\xBB\x03\xBB" +
|
|
"\x03\xBB\x05\xBB\u0EB5\n\xBB\x03\xBB\x03\xBB\x05\xBB\u0EB9\n\xBB\x03\xBB" +
|
|
"\x03\xBB\x05\xBB\u0EBD\n\xBB\x03\xBB\x03\xBB\x05\xBB\u0EC1\n\xBB\x03\xBB" +
|
|
"\x03\xBB\x05\xBB\u0EC5\n\xBB\x03\xBB\x03\xBB\x05\xBB\u0EC9\n\xBB\x03\xBB" +
|
|
"\x03\xBB\x05\xBB\u0ECD\n\xBB\x03\xBB\x05\xBB\u0ED0\n\xBB\x03\xBC\x03\xBC" +
|
|
"\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC" +
|
|
"\x05\xBC\u0EDD\n\xBC\x03\xBD\x03\xBD\x03\xBD\x05\xBD\u0EE2\n\xBD\x03\xBE" +
|
|
"\x03\xBE\x05\xBE\u0EE6\n\xBE\x03\xBF\x03\xBF\x05\xBF\u0EEA\n\xBF\x03\xC0" +
|
|
"\x03\xC0\x03\xC1\x03\xC1\x03\xC2\x03\xC2\x03\xC2\v\u041A\u045C\u0464\u0475" +
|
|
"\u0490\u0499\u04A2\u04AB\u04D4\x02\x06b\u010E\u0112\u0116\xC3\x02\x02" +
|
|
"\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16" +
|
|
"\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02 \x02\"\x02$\x02&\x02(\x02*\x02,\x02" +
|
|
".\x020\x022\x024\x026\x028\x02:\x02<\x02>\x02@\x02B\x02D\x02F\x02H\x02" +
|
|
"J\x02L\x02N\x02P\x02R\x02T\x02V\x02X\x02Z\x02\\\x02^\x02`\x02b\x02d\x02" +
|
|
"f\x02h\x02j\x02l\x02n\x02p\x02r\x02t\x02v\x02x\x02z\x02|\x02~\x02\x80" +
|
|
"\x02\x82\x02\x84\x02\x86\x02\x88\x02\x8A\x02\x8C\x02\x8E\x02\x90\x02\x92" +
|
|
"\x02\x94\x02\x96\x02\x98\x02\x9A\x02\x9C\x02\x9E\x02\xA0\x02\xA2\x02\xA4" +
|
|
"\x02\xA6\x02\xA8\x02\xAA\x02\xAC\x02\xAE\x02\xB0\x02\xB2\x02\xB4\x02\xB6" +
|
|
"\x02\xB8\x02\xBA\x02\xBC\x02\xBE\x02\xC0\x02\xC2\x02\xC4\x02\xC6\x02\xC8" +
|
|
"\x02\xCA\x02\xCC\x02\xCE\x02\xD0\x02\xD2\x02\xD4\x02\xD6\x02\xD8\x02\xDA" +
|
|
"\x02\xDC\x02\xDE\x02\xE0\x02\xE2\x02\xE4\x02\xE6\x02\xE8\x02\xEA\x02\xEC" +
|
|
"\x02\xEE\x02\xF0\x02\xF2\x02\xF4\x02\xF6\x02\xF8\x02\xFA\x02\xFC\x02\xFE" +
|
|
"\x02\u0100\x02\u0102\x02\u0104\x02\u0106\x02\u0108\x02\u010A\x02\u010C" +
|
|
"\x02\u010E\x02\u0110\x02\u0112\x02\u0114\x02\u0116\x02\u0118\x02\u011A" +
|
|
"\x02\u011C\x02\u011E\x02\u0120\x02\u0122\x02\u0124\x02\u0126\x02\u0128" +
|
|
"\x02\u012A\x02\u012C\x02\u012E\x02\u0130\x02\u0132\x02\u0134\x02\u0136" +
|
|
"\x02\u0138\x02\u013A\x02\u013C\x02\u013E\x02\u0140\x02\u0142\x02\u0144" +
|
|
"\x02\u0146\x02\u0148\x02\u014A\x02\u014C\x02\u014E\x02\u0150\x02\u0152" +
|
|
"\x02\u0154\x02\u0156\x02\u0158\x02\u015A\x02\u015C\x02\u015E\x02\u0160" +
|
|
"\x02\u0162\x02\u0164\x02\u0166\x02\u0168\x02\u016A\x02\u016C\x02\u016E" +
|
|
"\x02\u0170\x02\u0172\x02\u0174\x02\u0176\x02\u0178\x02\u017A\x02\u017C" +
|
|
"\x02\u017E\x02\u0180\x02\u0182\x02\x02@\x04\x02PP\xE1\xE1\x04\x02$$\xF3" +
|
|
"\xF3\x04\x02{{\x8C\x8C\x03\x0234\x04\x02\r\r))\x07\x0200<<llzz\xAC\xAC" +
|
|
"\x03\x02XY\x04\x02llzz\x05\x02\n\naa\u011C\u011C\x04\x02\n\n\xA6\xA6\x03" +
|
|
"\x02\u014A\u014B\x05\x02JJ\xBC\xBC\u0100\u0100\x05\x02KK\xBD\xBD\u0101" +
|
|
"\u0101\x06\x02ff\x94\x94\u0109\u0109\u013E\u013E\x05\x02ff\u0109\u0109" +
|
|
"\u013E\u013E\x04\x02\x17\x17XX\x04\x02tt\x9D\x9D\x05\x02\f\f\u011D\u011D" +
|
|
"\u0146\u0146\x04\x02\u011F\u011F\u014C\u014C\x04\x02\u011E\u011E\u012A" +
|
|
"\u012A\x04\x02??\xFB\xFB\x04\x02hh\x8D\x8D\x04\x02\f\f]]\x04\x02\u0178" +
|
|
"\u0178\u017A\u017A\x04\x02^^\xD5\xD5\x04\x02\xCD\xCD\u0111\u0111\x04\x02" +
|
|
"\xC2\xC2\u0162\u0162\x03\x02\xF6\xF7\x03\x02\xA2\xA3\x05\x02\f\f\x12\x12" +
|
|
"\u0110\u0110\x05\x02oo\u0137\u0137\u0140\u0140\x04\x02\u0163\u0164\u0168" +
|
|
"\u0168\x04\x02__\u0165\u0167\x04\x02\u0163\u0164\u016B\u016B\r\x02EEG" +
|
|
"G\x86\x86\xB2\xB2\xB4\xB4\xB6\xB6\xB8\xB8\xE3\xE3\xFE\xFE\u0150\u0150" +
|
|
"\u0157\u0157\x06\x02AACD\u0107\u0107\u0146\u0146\x04\x02LM\u012D\u012D" +
|
|
"\x05\x02NO\u0129\u0129\u012E\u012E\x04\x02&&\u0139\u0139\x04\x02\x8A\x8A" +
|
|
"\xF2\xF2\x03\x02\u011A\u011B\x04\x02\x06\x06{{\x04\x02\x06\x06ww\x05\x02" +
|
|
"\x1E\x1E\xA0\xA0\u0132\u0132\x03\x02\xD8\xD9\x03\x02\u015A\u0161\x04\x02" +
|
|
"__\u0163\u016C\x06\x02\x10\x10\x8C\x8C\xC2\xC2\xCC\xCC\x04\x02oo\u0137" +
|
|
"\u0137\x03\x02\u0163\u0164\t\x02EF\x86\x87\xB2\xB9\xBE\xBF\xFE\xFF\u0150" +
|
|
"\u0151\u0157\u0158\b\x02EE\x86\x86\xB6\xB6\xB8\xB8\xFE\xFE\u0157\u0157" +
|
|
"\x04\x02\xB8\xB8\u0157\u0157\x06\x02EE\x86\x86\xB6\xB6\xFE\xFE\x05\x02" +
|
|
"\x86\x86\xB6\xB6\xFE\xFE\x04\x02TT\u015A\u015A\x04\x02vv\xDE\xDE\x03\x02" +
|
|
"\u0179\u017A\x04\x02aa\u0108\u01085\x02\n\v\r\x0F\x11\x11\x13\x15\x17" +
|
|
"\x18\x1A\x1D\x1F$\'+-0224:<<?@E\\^aeegnqqsvyz}\x80\x83\x83\x85\x8B\x8D" +
|
|
"\x8F\x91\x93\x95\x97\x9A\x9A\x9C\x9D\x9F\x9F\xA2\xBF\xC1\xC1\xC4\xC6\xCA" +
|
|
"\xCB\xCE\xCE\xD0\xD1\xD3\xD7\xDA\xDE\xE0\xEA\xEC\xF4\xF6\u0101\u0103\u0106" +
|
|
"\u0108\u010F\u0111\u011F\u0121\u0126\u0129\u012F\u0131\u0131\u0133\u013D" +
|
|
"\u0141\u0145\u0148\u0151\u0154\u0154\u0157\u0159\x12\x02\x11\x11>>ff|" +
|
|
"|\x90\x90\x94\x94\x9B\x9B\x9E\x9E\xA1\xA1\xC0\xC0\xC8\xC8\xF5\xF5\u0103" +
|
|
"\u0103\u0109\u0109\u013E\u013E\u0147\u0147\x13\x02\n\x10\x12=?eg{}\x8F" +
|
|
"\x91\x93\x95\x9A\x9C\x9D\x9F\xA0\xA2\xBF\xC1\xC7\xC9\xF4\xF6\u0102\u0104" +
|
|
"\u0108\u010A\u013D\u013F\u0146\u0148\u0159\x02\u113B\x02\u0187\x03\x02" +
|
|
"\x02\x02\x04\u018C\x03\x02\x02\x02\x06\u04D7\x03\x02\x02\x02\b\u04DB\x03" +
|
|
"\x02\x02\x02\n\u04DD\x03\x02\x02\x02\f\u04DF\x03\x02\x02\x02\x0E\u0589" +
|
|
"\x03\x02\x02\x02\x10\u058B\x03\x02\x02\x02\x12\u059A\x03\x02\x02\x02\x14" +
|
|
"\u05A0\x03\x02\x02\x02\x16\u05AC\x03\x02\x02\x02\x18\u05B9\x03\x02\x02" +
|
|
"\x02\x1A\u05BC\x03\x02\x02\x02\x1C\u05C0\x03\x02\x02\x02\x1E\u060B\x03" +
|
|
"\x02\x02\x02 \u060D\x03\x02\x02\x02\"\u0611\x03\x02\x02\x02$\u0626\x03" +
|
|
"\x02\x02\x02&\u0628\x03\x02\x02\x02(\u062A\x03\x02\x02\x02*\u0631\x03" +
|
|
"\x02\x02\x02,\u0633\x03\x02\x02\x02.\u063B\x03\x02\x02\x020\u0644\x03" +
|
|
"\x02\x02\x022\u064F\x03\x02\x02\x024\u0661\x03\x02\x02\x026\u0664\x03" +
|
|
"\x02\x02\x028\u066F\x03\x02\x02\x02:\u067F\x03\x02\x02\x02<\u0685\x03" +
|
|
"\x02\x02\x02>\u0687\x03\x02\x02\x02@\u0692\x03\x02\x02\x02B\u0699\x03" +
|
|
"\x02\x02\x02D\u06A4\x03\x02\x02\x02F\u06B5\x03\x02\x02\x02H\u06BD\x03" +
|
|
"\x02\x02\x02J\u06BF\x03\x02\x02\x02L\u06C5\x03\x02\x02\x02N\u0700\x03" +
|
|
"\x02\x02\x02P\u0702\x03\x02\x02\x02R\u0704\x03\x02\x02\x02T\u0706\x03" +
|
|
"\x02\x02\x02V\u0708\x03\x02\x02\x02X\u070A\x03\x02\x02\x02Z\u070C\x03" +
|
|
"\x02\x02\x02\\\u0714\x03\x02\x02\x02^\u0720\x03\x02\x02\x02`\u0754\x03" +
|
|
"\x02\x02\x02b\u0757\x03\x02\x02\x02d\u077D\x03\x02\x02\x02f\u077F\x03" +
|
|
"\x02\x02\x02h\u0787\x03\x02\x02\x02j\u07A8\x03\x02\x02\x02l\u07D6\x03" +
|
|
"\x02\x02\x02n\u07EB\x03\x02\x02\x02p\u080B\x03\x02\x02\x02r\u0817\x03" +
|
|
"\x02\x02\x02t\u081A\x03\x02\x02\x02v\u0823\x03\x02\x02\x02x\u0831\x03" +
|
|
"\x02\x02\x02z\u0844\x03\x02\x02\x02|\u0858\x03\x02\x02\x02~\u085E\x03" +
|
|
"\x02\x02\x02\x80\u0860\x03\x02\x02\x02\x82\u0868\x03\x02\x02\x02\x84\u086C" +
|
|
"\x03\x02\x02\x02\x86\u086F\x03\x02\x02\x02\x88\u0872\x03\x02\x02\x02\x8A" +
|
|
"\u088C\x03\x02\x02\x02\x8C\u088E\x03\x02\x02\x02\x8E\u08A3\x03\x02\x02" +
|
|
"\x02\x90\u08B3\x03\x02\x02\x02\x92\u08DC\x03\x02\x02\x02\x94\u08E0\x03" +
|
|
"\x02\x02\x02\x96\u08FB\x03\x02\x02\x02\x98\u08FF\x03\x02\x02\x02\x9A\u090E" +
|
|
"\x03\x02\x02\x02\x9C\u0910\x03\x02\x02\x02\x9E\u092E\x03\x02\x02\x02\xA0" +
|
|
"\u0930\x03\x02\x02\x02\xA2\u0937\x03\x02\x02\x02\xA4\u0944\x03\x02\x02" +
|
|
"\x02\xA6\u0949\x03\x02\x02\x02\xA8\u094B\x03\x02\x02\x02\xAA\u095A\x03" +
|
|
"\x02\x02\x02\xAC\u0972\x03\x02\x02\x02\xAE\u097F\x03\x02\x02\x02\xB0\u0981" +
|
|
"\x03\x02\x02\x02\xB2\u0983\x03\x02\x02\x02\xB4\u0987\x03\x02\x02\x02\xB6" +
|
|
"\u098A\x03\x02\x02\x02\xB8\u098E\x03\x02\x02\x02\xBA\u0992\x03\x02\x02" +
|
|
"\x02\xBC\u0995\x03\x02\x02\x02\xBE\u09B5\x03\x02\x02\x02\xC0\u09C2\x03" +
|
|
"\x02\x02\x02\xC2\u09C7\x03\x02\x02\x02\xC4\u09DA\x03\x02\x02\x02\xC6\u09F4" +
|
|
"\x03\x02\x02\x02\xC8\u09FA\x03\x02\x02\x02\xCA\u09FC\x03\x02\x02\x02\xCC" +
|
|
"\u0A20\x03\x02\x02\x02\xCE\u0A22\x03\x02\x02\x02\xD0\u0A26\x03\x02\x02" +
|
|
"\x02\xD2\u0A2E\x03\x02\x02\x02\xD4\u0A39\x03\x02\x02\x02\xD6\u0A3D\x03" +
|
|
"\x02\x02\x02\xD8\u0A48\x03\x02\x02\x02\xDA\u0A67\x03\x02\x02\x02\xDC\u0A69" +
|
|
"\x03\x02\x02\x02\xDE\u0A87\x03\x02\x02\x02\xE0\u0A9C\x03\x02\x02\x02\xE2" +
|
|
"\u0AB0\x03\x02\x02\x02\xE4\u0AB6\x03\x02\x02\x02\xE6\u0ABA\x03\x02\x02" +
|
|
"\x02\xE8\u0ABC\x03\x02\x02\x02\xEA\u0AD2\x03\x02\x02\x02\xEC\u0B05\x03" +
|
|
"\x02\x02\x02\xEE\u0B07\x03\x02\x02\x02\xF0\u0B0F\x03\x02\x02\x02\xF2\u0B17" +
|
|
"\x03\x02\x02\x02\xF4\u0B1F\x03\x02\x02\x02\xF6\u0B27\x03\x02\x02\x02\xF8" +
|
|
"\u0B2E\x03\x02\x02\x02\xFA\u0B32\x03\x02\x02\x02\xFC\u0B3C\x03\x02\x02";
|
|
private static readonly _serializedATNSegment2: string =
|
|
"\x02\xFE\u0B44\x03\x02\x02\x02\u0100\u0B51\x03\x02\x02\x02\u0102\u0B60" +
|
|
"\x03\x02\x02\x02\u0104\u0B64\x03\x02\x02\x02\u0106\u0B66\x03\x02\x02\x02" +
|
|
"\u0108\u0B68\x03\x02\x02\x02\u010A\u0B6E\x03\x02\x02\x02\u010C\u0B70\x03" +
|
|
"\x02\x02\x02\u010E\u0B84\x03\x02\x02\x02\u0110\u0BE3\x03\x02\x02\x02\u0112" +
|
|
"\u0BE9\x03\x02\x02\x02\u0114\u0C03\x03\x02\x02\x02\u0116\u0CFE\x03\x02" +
|
|
"\x02\x02\u0118\u0D14\x03\x02\x02\x02\u011A\u0D25\x03\x02\x02\x02\u011C" +
|
|
"\u0D27\x03\x02\x02\x02\u011E\u0D29\x03\x02\x02\x02\u0120\u0D2B\x03\x02" +
|
|
"\x02\x02\u0122\u0D2D\x03\x02\x02\x02\u0124\u0D2F\x03\x02\x02\x02\u0126" +
|
|
"\u0D34\x03\x02\x02\x02\u0128\u0D3B\x03\x02\x02\x02\u012A\u0D3F\x03\x02" +
|
|
"\x02\x02\u012C\u0D44\x03\x02\x02\x02\u012E\u0D4A\x03\x02\x02\x02\u0130" +
|
|
"\u0D51\x03\x02\x02\x02\u0132\u0D53\x03\x02\x02\x02\u0134\u0D58\x03\x02" +
|
|
"\x02\x02\u0136\u0D78\x03\x02\x02\x02\u0138\u0DA8\x03\x02\x02\x02\u013A" +
|
|
"\u0DAA\x03\x02\x02\x02\u013C\u0DB2\x03\x02\x02\x02\u013E\u0DBF\x03\x02" +
|
|
"\x02\x02\u0140\u0DC1\x03\x02\x02\x02\u0142\u0DC4\x03\x02\x02\x02\u0144" +
|
|
"\u0DC7\x03\x02\x02\x02\u0146\u0DCF\x03\x02\x02\x02\u0148\u0DD8\x03\x02" +
|
|
"\x02\x02\u014A\u0DE0\x03\x02\x02\x02\u014C\u0DED\x03\x02\x02\x02\u014E" +
|
|
"\u0DEF\x03\x02\x02\x02\u0150\u0DF6\x03\x02\x02\x02\u0152\u0DFE\x03\x02" +
|
|
"\x02\x02\u0154\u0E0A\x03\x02\x02\x02\u0156\u0E0F\x03\x02\x02\x02\u0158" +
|
|
"\u0E18\x03\x02\x02\x02\u015A\u0E4A\x03\x02\x02\x02\u015C\u0E5C\x03\x02" +
|
|
"\x02\x02\u015E\u0E65\x03\x02\x02\x02\u0160\u0E67\x03\x02\x02\x02\u0162" +
|
|
"\u0E78\x03\x02\x02\x02\u0164\u0E7A\x03\x02\x02\x02\u0166\u0E7C\x03\x02" +
|
|
"\x02\x02\u0168\u0E84\x03\x02\x02\x02\u016A\u0E8E\x03\x02\x02\x02\u016C" +
|
|
"\u0E93\x03\x02\x02\x02\u016E\u0E9B\x03\x02\x02\x02\u0170\u0EA0\x03\x02" +
|
|
"\x02\x02\u0172\u0EA2\x03\x02\x02\x02\u0174\u0ECF\x03\x02\x02\x02\u0176" +
|
|
"\u0EDC\x03\x02\x02\x02\u0178\u0EE1\x03\x02\x02\x02\u017A\u0EE5\x03\x02" +
|
|
"\x02\x02\u017C\u0EE9\x03\x02\x02\x02\u017E\u0EEB\x03\x02\x02\x02\u0180" +
|
|
"\u0EED\x03\x02\x02\x02\u0182\u0EEF\x03\x02\x02\x02\u0184\u0186\x05\x04" +
|
|
"\x03\x02\u0185\u0184\x03\x02\x02\x02\u0186\u0189\x03\x02\x02\x02\u0187" +
|
|
"\u0185\x03\x02\x02\x02\u0187\u0188\x03\x02\x02\x02\u0188\u018A\x03\x02" +
|
|
"\x02\x02\u0189\u0187\x03\x02\x02\x02\u018A\u018B\x07\x02\x02\x03\u018B" +
|
|
"\x03\x03\x02\x02\x02\u018C\u018E\x05\x06\x04\x02\u018D\u018F\x07\x03\x02" +
|
|
"\x02\u018E\u018D\x03\x02\x02\x02\u018E\u018F\x03\x02\x02\x02\u018F\x05" +
|
|
"\x03\x02\x02\x02\u0190\u04D8\x05\x1C\x0F\x02\u0191\u0193\x05.\x18\x02" +
|
|
"\u0192\u0191\x03\x02\x02\x02\u0192\u0193\x03\x02\x02\x02\u0193\u0194\x03" +
|
|
"\x02\x02\x02\u0194\u04D8\x05N(\x02\u0195\u0196\x07\u0145\x02\x02\u0196" +
|
|
"\u04D8\x05P)\x02\u0197\u0198\x07\u0145\x02\x02\u0198\u0199\x05&\x14\x02" +
|
|
"\u0199\u019A\x05P)\x02\u019A\u04D8\x03\x02\x02\x02\u019B\u019C\x07\u0108" +
|
|
"\x02\x02\u019C\u019F\x07\'\x02\x02\u019D\u01A0\x05\u016C\xB7\x02\u019E" +
|
|
"\u01A0\x05\u0178\xBD\x02\u019F\u019D\x03\x02\x02\x02\u019F\u019E\x03\x02" +
|
|
"\x02\x02\u01A0\u04D8\x03\x02\x02\x02\u01A1\u01A2\x07=\x02\x02\u01A2\u01A4" +
|
|
"\x05&\x14\x02\u01A3\u01A5\x05\xB8]\x02\u01A4\u01A3\x03\x02\x02\x02\u01A4" +
|
|
"\u01A5\x03\x02\x02\x02\u01A5\u01A6\x03\x02\x02\x02\u01A6\u01AE\x05R*\x02" +
|
|
"\u01A7\u01AD\x05\x1A\x0E\x02\u01A8\u01AD\x05\x18\r\x02\u01A9\u01AA\x07" +
|
|
"\u0155\x02\x02\u01AA\u01AB\t\x02\x02\x02\u01AB\u01AD\x056\x1C\x02\u01AC" +
|
|
"\u01A7\x03\x02\x02\x02\u01AC\u01A8\x03\x02\x02\x02\u01AC\u01A9\x03\x02" +
|
|
"\x02\x02\u01AD\u01B0\x03\x02\x02\x02\u01AE\u01AC\x03\x02\x02\x02\u01AE" +
|
|
"\u01AF\x03\x02\x02\x02\u01AF\u04D8\x03\x02\x02\x02\u01B0\u01AE\x03\x02" +
|
|
"\x02\x02\u01B1\u01B2\x07\r\x02\x02\u01B2\u01B3\x05&\x14\x02\u01B3\u01B4" +
|
|
"\x05P)\x02\u01B4\u01B5\x07\u0108\x02\x02\u01B5\u01B6\t\x02\x02\x02\u01B6" +
|
|
"\u01B7\x056\x1C\x02\u01B7\u04D8\x03\x02\x02\x02\u01B8\u01B9\x07\r\x02" +
|
|
"\x02\u01B9\u01BA\x05&\x14\x02\u01BA\u01BB\x05P)\x02\u01BB\u01BC\x07\u0108" +
|
|
"\x02\x02\u01BC\u01BD\x05\x18\r\x02\u01BD\u04D8\x03\x02\x02\x02\u01BE\u01BF" +
|
|
"\x07a\x02\x02\u01BF\u01C1\x05&\x14\x02\u01C0\u01C2\x05\xBA^\x02\u01C1" +
|
|
"\u01C0\x03\x02\x02\x02\u01C1\u01C2\x03\x02\x02\x02\u01C2\u01C3\x03\x02" +
|
|
"\x02\x02\u01C3\u01C5\x05P)\x02\u01C4\u01C6\t\x03\x02\x02\u01C5\u01C4\x03" +
|
|
"\x02\x02\x02\u01C5\u01C6\x03\x02\x02\x02\u01C6\u04D8\x03\x02\x02\x02\u01C7" +
|
|
"\u01C8\x07\u010C\x02\x02\u01C8\u01CB\x05(\x15\x02\u01C9\u01CA\t\x04\x02" +
|
|
"\x02\u01CA\u01CC\x05\xF0y\x02\u01CB\u01C9\x03\x02\x02\x02\u01CB\u01CC" +
|
|
"\x03\x02\x02\x02\u01CC\u01D1\x03\x02\x02\x02\u01CD\u01CF\x07\xA2\x02\x02" +
|
|
"\u01CE\u01CD\x03\x02\x02\x02\u01CE\u01CF\x03\x02\x02\x02\u01CF\u01D0\x03" +
|
|
"\x02\x02\x02\u01D0\u01D2\x05\u0178\xBD\x02\u01D1\u01CE\x03\x02\x02\x02" +
|
|
"\u01D1\u01D2\x03\x02\x02\x02\u01D2\u04D8\x03\x02\x02\x02\u01D3\u01D8\x05" +
|
|
"\x10\t\x02\u01D4\u01D5\x07\x04\x02\x02\u01D5\u01D6\x05\u0148\xA5\x02\u01D6" +
|
|
"\u01D7\x07\x05\x02\x02\u01D7\u01D9\x03\x02\x02\x02\u01D8\u01D4\x03\x02" +
|
|
"\x02\x02\u01D8\u01D9\x03\x02\x02\x02\u01D9\u01DB\x03\x02\x02\x02\u01DA" +
|
|
"\u01DC\x052\x1A\x02\u01DB\u01DA\x03\x02\x02\x02\u01DB\u01DC\x03\x02\x02" +
|
|
"\x02\u01DC\u01DD\x03\x02\x02\x02\u01DD\u01E2\x054\x1B\x02\u01DE\u01E0" +
|
|
"\x07\x16\x02\x02\u01DF\u01DE\x03\x02\x02\x02\u01DF\u01E0\x03\x02\x02\x02" +
|
|
"\u01E0\u01E1\x03\x02\x02\x02\u01E1\u01E3\x05\x1C\x0F\x02\u01E2\u01DF\x03" +
|
|
"\x02\x02\x02\u01E2\u01E3\x03\x02\x02\x02\u01E3\u04D8\x03\x02\x02\x02\u01E4" +
|
|
"\u01E5\x07=\x02\x02\u01E5\u01E7\x07\u0120\x02\x02\u01E6\u01E8\x05\xB8" +
|
|
"]\x02\u01E7\u01E6\x03\x02\x02\x02\u01E7\u01E8\x03\x02\x02\x02\u01E8\u01E9" +
|
|
"\x03\x02\x02\x02\u01E9\u01EA\x05T+\x02\u01EA\u01EB\x07\xA2\x02\x02\u01EB" +
|
|
"\u01F4\x05V,\x02\u01EC\u01F3\x052\x1A\x02\u01ED\u01F3\x05\xECw\x02\u01EE" +
|
|
"\u01F3\x05F$\x02\u01EF\u01F3\x05\x18\r\x02\u01F0\u01F1\x07\u0124\x02\x02" +
|
|
"\u01F1\u01F3\x056\x1C\x02\u01F2\u01EC\x03\x02\x02\x02\u01F2\u01ED\x03" +
|
|
"\x02\x02\x02\u01F2\u01EE\x03\x02\x02\x02\u01F2\u01EF\x03\x02\x02\x02\u01F2" +
|
|
"\u01F0\x03\x02\x02\x02\u01F3\u01F6\x03\x02\x02\x02\u01F4\u01F2\x03\x02" +
|
|
"\x02\x02\u01F4\u01F5\x03\x02\x02\x02\u01F5\u04D8\x03\x02\x02\x02\u01F6" +
|
|
"\u01F4\x03\x02\x02\x02\u01F7\u01FC\x05\x12\n\x02\u01F8\u01F9\x07\x04\x02" +
|
|
"\x02\u01F9\u01FA\x05\u0148\xA5\x02\u01FA\u01FB\x07\x05\x02\x02\u01FB\u01FD" +
|
|
"\x03\x02\x02\x02\u01FC\u01F8\x03\x02\x02\x02\u01FC\u01FD\x03\x02\x02\x02" +
|
|
"\u01FD\u01FF\x03\x02\x02\x02\u01FE\u0200\x052\x1A\x02\u01FF\u01FE\x03" +
|
|
"\x02\x02\x02\u01FF\u0200\x03\x02\x02\x02\u0200\u0201\x03\x02\x02\x02\u0201" +
|
|
"\u0206\x054\x1B\x02\u0202\u0204\x07\x16\x02\x02\u0203\u0202\x03\x02\x02" +
|
|
"\x02\u0203\u0204\x03\x02\x02\x02\u0204\u0205\x03\x02\x02\x02\u0205\u0207" +
|
|
"\x05\x1C\x0F\x02\u0206\u0203\x03\x02\x02\x02\u0206\u0207\x03\x02\x02\x02" +
|
|
"\u0207\u04D8\x03\x02\x02\x02\u0208\u0209\x07\x0F\x02\x02\u0209\u020A\x07" +
|
|
"\u0120\x02\x02\u020A\u020C\x05V,\x02\u020B\u020D\x05\"\x12\x02\u020C\u020B" +
|
|
"\x03\x02\x02\x02\u020C\u020D\x03\x02\x02\x02\u020D\u020E\x03\x02\x02\x02" +
|
|
"\u020E\u020F\x079\x02\x02\u020F\u0217\x07\u0115\x02\x02\u0210\u0218\x05" +
|
|
"\u016C\xB7\x02\u0211\u0212\x07w\x02\x02\u0212\u0213\x074\x02\x02\u0213" +
|
|
"\u0218\x05\xD0i\x02\u0214\u0215\x07w\x02\x02\u0215\u0216\x07\f\x02\x02" +
|
|
"\u0216\u0218\x074\x02\x02\u0217\u0210\x03\x02\x02\x02\u0217\u0211\x03" +
|
|
"\x02\x02\x02\u0217\u0214\x03\x02\x02\x02\u0217\u0218\x03\x02\x02\x02\u0218" +
|
|
"\u04D8\x03\x02\x02\x02\u0219\u021A\x07\x0F\x02\x02\u021A\u021D\x07\u0121" +
|
|
"\x02\x02\u021B\u021C\t\x04\x02\x02\u021C\u021E\x05P)\x02\u021D\u021B\x03" +
|
|
"\x02\x02\x02\u021D\u021E\x03\x02\x02\x02\u021E\u021F\x03\x02\x02\x02\u021F" +
|
|
"\u0220\x079\x02\x02\u0220\u0222\x07\u0115\x02\x02\u0221\u0223\x05\u016C" +
|
|
"\xB7\x02\u0222\u0221\x03\x02\x02\x02\u0222\u0223\x03\x02\x02\x02\u0223" +
|
|
"\u04D8\x03\x02\x02\x02\u0224\u0225\x07\r\x02\x02\u0225\u0226\x07\u0120" +
|
|
"\x02\x02\u0226\u0227\x05V,\x02\u0227\u0228\x07\n\x02\x02\u0228\u0229\t" +
|
|
"\x05\x02\x02\u0229\u022A\x05\u013A\x9E\x02\u022A\u04D8\x03\x02\x02\x02" +
|
|
"\u022B\u022C\x07\r\x02\x02\u022C\u022D\x07\u0120\x02\x02\u022D\u022E\x05" +
|
|
"V,\x02\u022E\u022F\x07\n\x02\x02\u022F\u0230\t\x05\x02\x02\u0230\u0231" +
|
|
"\x07\x04\x02\x02\u0231\u0232\x05\u013A\x9E\x02\u0232\u0233\x07\x05\x02" +
|
|
"\x02\u0233\u04D8\x03\x02\x02\x02\u0234\u0235\x07\r\x02\x02\u0235\u0236" +
|
|
"\x07\u0120\x02\x02\u0236\u0237\x05V,\x02\u0237\u0238\x07\xED\x02\x02\u0238" +
|
|
"\u0239\x073\x02\x02\u0239\u023A\x05\xF0y\x02\u023A\u023B\x07\u0130\x02" +
|
|
"\x02\u023B\u023C\x05\u0168\xB5\x02\u023C\u04D8\x03\x02\x02\x02\u023D\u023E" +
|
|
"\x07\r\x02\x02\u023E\u023F\x07\u0120\x02\x02\u023F\u0240\x05V,\x02\u0240" +
|
|
"\u0241\x07a\x02\x02\u0241\u0243\t\x05\x02\x02\u0242\u0244\x05\xBA^\x02" +
|
|
"\u0243\u0242\x03\x02\x02\x02\u0243\u0244\x03\x02\x02\x02\u0244\u0245\x03" +
|
|
"\x02\x02\x02\u0245\u0246\x07\x04\x02\x02\u0246\u0247\x05\xEEx\x02\u0247" +
|
|
"\u0248\x07\x05\x02\x02\u0248\u04D8\x03\x02\x02\x02\u0249\u024A\x07\r\x02" +
|
|
"\x02\u024A\u024B\x07\u0120\x02\x02\u024B\u024C\x05V,\x02\u024C\u024D\x07" +
|
|
"a\x02\x02\u024D\u024F\t\x05\x02\x02\u024E\u0250\x05\xBA^\x02\u024F\u024E" +
|
|
"\x03\x02\x02\x02\u024F\u0250\x03\x02\x02\x02\u0250\u0251\x03\x02\x02\x02" +
|
|
"\u0251\u0252\x05\xEEx\x02\u0252\u04D8\x03\x02\x02\x02\u0253\u0258\x07" +
|
|
"\r\x02\x02\u0254\u0255\x07\u0120\x02\x02\u0255\u0259\x05V,\x02\u0256\u0257" +
|
|
"\x07\u014D\x02\x02\u0257\u0259\x05Z.\x02\u0258\u0254\x03\x02\x02\x02\u0258" +
|
|
"\u0256\x03\x02\x02\x02\u0259\u025A\x03\x02\x02\x02\u025A\u025B\x07\xED" +
|
|
"\x02\x02\u025B\u025C\x07\u0130\x02\x02\u025C\u025D\x05\xF0y\x02\u025D" +
|
|
"\u04D8\x03\x02\x02\x02\u025E\u0263\x07\r\x02\x02\u025F\u0260\x07\u0120" +
|
|
"\x02\x02\u0260\u0264\x05V,\x02\u0261\u0262\x07\u014D\x02\x02\u0262\u0264" +
|
|
"\x05Z.\x02\u0263\u025F\x03\x02\x02\x02\u0263\u0261\x03\x02\x02\x02\u0264" +
|
|
"\u0265\x03\x02\x02\x02\u0265\u0266\x07\u0108\x02\x02\u0266\u0267\x07\u0124" +
|
|
"\x02\x02\u0267\u0268\x056\x1C\x02\u0268\u04D8\x03\x02\x02\x02\u0269\u026E" +
|
|
"\x07\r\x02\x02\u026A\u026B\x07\u0120\x02\x02\u026B\u026F\x05V,\x02\u026C" +
|
|
"\u026D\x07\u014D\x02\x02\u026D\u026F\x05Z.\x02\u026E\u026A\x03\x02\x02" +
|
|
"\x02\u026E\u026C\x03\x02\x02\x02\u026F\u0270\x03\x02\x02\x02\u0270\u0271" +
|
|
"\x07\u0143\x02\x02\u0271\u0273\x07\u0124\x02\x02\u0272\u0274\x05\xBA^" +
|
|
"\x02\u0273\u0272\x03\x02\x02\x02\u0273\u0274\x03\x02\x02\x02\u0274\u0275" +
|
|
"\x03\x02\x02\x02\u0275\u0276\x056\x1C\x02\u0276\u04D8\x03\x02\x02\x02" +
|
|
"\u0277\u0278\x07\r\x02\x02\u0278\u0279\x07\u0120\x02\x02\u0279\u027A\x05" +
|
|
"V,\x02\u027A\u027C\t\x06\x02\x02\u027B\u027D\x073\x02\x02\u027C\u027B" +
|
|
"\x03\x02\x02\x02\u027C\u027D\x03\x02\x02\x02\u027D\u027E\x03\x02\x02\x02" +
|
|
"\u027E\u0280\x05\xF0y\x02\u027F\u0281\x05\u0176\xBC\x02\u0280\u027F\x03" +
|
|
"\x02\x02\x02\u0280\u0281\x03\x02\x02\x02\u0281\u04D8\x03\x02\x02\x02\u0282" +
|
|
"\u0283\x07\r\x02\x02\u0283\u0284\x07\u0120\x02\x02\u0284\u0286\x05V,\x02" +
|
|
"\u0285\u0287\x05\"\x12\x02\u0286\u0285\x03\x02\x02\x02\u0286\u0287\x03" +
|
|
"\x02\x02\x02\u0287\u0288\x03\x02\x02\x02\u0288\u028A\x07)\x02\x02\u0289" +
|
|
"\u028B\x073\x02\x02\u028A\u0289\x03\x02\x02\x02\u028A\u028B\x03\x02\x02" +
|
|
"\x02\u028B\u028C\x03\x02\x02\x02\u028C\u028D\x05\xF0y\x02\u028D\u028F" +
|
|
"\x05\u0146\xA4\x02\u028E\u0290\x05\u0134\x9B\x02\u028F\u028E\x03\x02\x02" +
|
|
"\x02\u028F\u0290\x03\x02\x02\x02\u0290\u04D8\x03\x02\x02\x02\u0291\u0292" +
|
|
"\x07\r\x02\x02\u0292\u0293\x07\u0120\x02\x02\u0293\u0295\x05V,\x02\u0294" +
|
|
"\u0296\x05\"\x12\x02\u0295\u0294\x03\x02\x02\x02\u0295\u0296\x03\x02\x02" +
|
|
"\x02\u0296\u0297\x03\x02\x02\x02\u0297\u0298\x07\xF0\x02\x02\u0298\u0299" +
|
|
"\x074\x02\x02\u0299\u029A\x07\x04\x02\x02\u029A\u029B\x05\u013A\x9E\x02" +
|
|
"\u029B\u029C\x07\x05\x02\x02\u029C\u04D8\x03\x02\x02\x02\u029D\u029E\x07" +
|
|
"\r\x02\x02\u029E\u029F\x07\u0120\x02\x02\u029F\u02A1\x05V,\x02\u02A0\u02A2" +
|
|
"\x05\"\x12\x02\u02A1\u02A0\x03\x02\x02\x02\u02A1\u02A2\x03\x02\x02\x02" +
|
|
"\u02A2\u02A3\x03\x02\x02\x02\u02A3\u02A4\x07\u0108\x02\x02\u02A4\u02A5" +
|
|
"\x07\u0105\x02\x02\u02A5\u02A9\x05\u0178\xBD\x02\u02A6\u02A7\x07\u0155" +
|
|
"\x02\x02\u02A7\u02A8\x07\u0106\x02\x02\u02A8\u02AA\x056\x1C\x02\u02A9" +
|
|
"\u02A6\x03\x02\x02\x02\u02A9\u02AA\x03\x02\x02\x02\u02AA\u04D8\x03\x02" +
|
|
"\x02\x02\u02AB\u02AC\x07\r\x02\x02\u02AC\u02AD\x07\u0120\x02\x02\u02AD" +
|
|
"\u02AF\x05V,\x02\u02AE\u02B0\x05\"\x12\x02\u02AF\u02AE\x03\x02\x02\x02" +
|
|
"\u02AF\u02B0\x03\x02\x02\x02\u02B0\u02B1\x03\x02\x02\x02\u02B1\u02B2\x07" +
|
|
"\u0108\x02\x02\u02B2\u02B3\x07\u0106\x02\x02\u02B3\u02B4\x056\x1C\x02" +
|
|
"\u02B4\u04D8\x03\x02\x02\x02\u02B5\u02BA\x07\r\x02\x02\u02B6\u02B7\x07" +
|
|
"\u0120\x02\x02\u02B7\u02BB\x05V,\x02\u02B8\u02B9\x07\u014D\x02\x02\u02B9" +
|
|
"\u02BB\x05Z.\x02\u02BA\u02B6\x03\x02\x02\x02\u02BA\u02B8\x03\x02\x02\x02" +
|
|
"\u02BB\u02BC\x03\x02\x02\x02\u02BC\u02BE\x07\n\x02\x02\u02BD\u02BF\x05" +
|
|
"\xB8]\x02\u02BE\u02BD\x03\x02\x02\x02\u02BE\u02BF\x03\x02\x02\x02\u02BF" +
|
|
"\u02C1\x03\x02\x02\x02\u02C0\u02C2\x05 \x11\x02\u02C1\u02C0\x03\x02\x02" +
|
|
"\x02\u02C2\u02C3\x03\x02\x02\x02\u02C3\u02C1\x03\x02\x02\x02\u02C3\u02C4" +
|
|
"\x03\x02\x02\x02\u02C4\u04D8\x03\x02\x02\x02\u02C5\u02C6\x07\r\x02\x02" +
|
|
"\u02C6\u02C7\x07\u0120\x02\x02\u02C7\u02C8\x05V,\x02\u02C8\u02C9\x05\"" +
|
|
"\x12\x02\u02C9\u02CA\x07\xED\x02\x02\u02CA\u02CB\x07\u0130\x02\x02\u02CB" +
|
|
"\u02CC\x05\"\x12\x02\u02CC\u04D8\x03\x02\x02\x02\u02CD\u02D2\x07\r\x02" +
|
|
"\x02\u02CE\u02CF\x07\u0120\x02\x02\u02CF\u02D3\x05V,\x02\u02D0\u02D1\x07" +
|
|
"\u014D\x02\x02\u02D1\u02D3\x05Z.\x02\u02D2\u02CE\x03\x02\x02\x02\u02D2" +
|
|
"\u02D0\x03\x02\x02\x02\u02D3\u02D4\x03\x02\x02\x02\u02D4\u02D6\x07a\x02" +
|
|
"\x02\u02D5\u02D7\x05\xBA^\x02\u02D6\u02D5\x03\x02\x02\x02\u02D6\u02D7" +
|
|
"\x03\x02\x02\x02\u02D7\u02D8\x03\x02\x02\x02\u02D8\u02DD\x05\"\x12\x02" +
|
|
"\u02D9\u02DA\x07\x06\x02\x02\u02DA\u02DC\x05\"\x12\x02\u02DB\u02D9\x03" +
|
|
"\x02\x02\x02\u02DC\u02DF\x03\x02\x02\x02\u02DD\u02DB\x03\x02\x02\x02\u02DD" +
|
|
"\u02DE\x03\x02\x02\x02\u02DE\u02E1\x03\x02\x02\x02\u02DF\u02DD\x03\x02" +
|
|
"\x02\x02\u02E0\u02E2\x07\xE2\x02\x02\u02E1\u02E0\x03\x02\x02\x02\u02E1" +
|
|
"\u02E2\x03\x02\x02\x02\u02E2\u04D8\x03\x02\x02\x02\u02E3\u02E4\x07\r\x02" +
|
|
"\x02\u02E4\u02E5\x07\u0120\x02\x02\u02E5\u02E7\x05V,\x02\u02E6\u02E8\x05" +
|
|
"\"\x12\x02\u02E7\u02E6\x03\x02\x02\x02\u02E7\u02E8\x03\x02\x02\x02\u02E8" +
|
|
"\u02E9\x03\x02\x02\x02\u02E9\u02EA\x07\u0108\x02\x02\u02EA\u02EB\x05\x18" +
|
|
"\r\x02\u02EB\u04D8\x03\x02\x02\x02\u02EC\u02ED\x07\r\x02\x02\u02ED\u02EE" +
|
|
"\x07\u0120\x02\x02\u02EE\u02EF\x05V,\x02\u02EF\u02F0\x07\xE9\x02\x02\u02F0" +
|
|
"\u02F1\x07\xD7\x02\x02\u02F1\u04D8\x03\x02\x02\x02\u02F2\u02F3\x07a\x02" +
|
|
"\x02\u02F3\u02F5\x07\u0120\x02\x02\u02F4\u02F6\x05\xBA^\x02\u02F5\u02F4" +
|
|
"\x03\x02\x02\x02\u02F5\u02F6\x03\x02\x02\x02\u02F6\u02F7\x03\x02\x02\x02" +
|
|
"\u02F7\u02F9\x05V,\x02\u02F8\u02FA\x07\xE2\x02\x02\u02F9\u02F8\x03\x02" +
|
|
"\x02\x02\u02F9\u02FA\x03\x02\x02\x02\u02FA\u04D8\x03\x02\x02\x02\u02FB" +
|
|
"\u02FC\x07a\x02\x02\u02FC\u02FE\x07\u014D\x02\x02\u02FD\u02FF\x05\xBA" +
|
|
"^\x02\u02FE\u02FD\x03\x02\x02\x02\u02FE\u02FF\x03\x02\x02\x02\u02FF\u0300" +
|
|
"\x03\x02\x02\x02\u0300\u04D8\x05Z.\x02\u0301\u0304\x07=\x02\x02\u0302" +
|
|
"\u0303\x07\xCC\x02\x02\u0303\u0305\x07\xF0\x02\x02\u0304\u0302\x03\x02" +
|
|
"\x02\x02\u0304\u0305\x03\x02\x02\x02\u0305\u030A\x03\x02\x02\x02\u0306" +
|
|
"\u0308\x07\x80\x02\x02\u0307\u0306\x03\x02\x02\x02\u0307\u0308\x03\x02" +
|
|
"\x02\x02\u0308\u0309\x03\x02\x02\x02\u0309\u030B\x07\u0125\x02\x02\u030A" +
|
|
"\u0307\x03\x02\x02\x02\u030A\u030B\x03\x02\x02\x02\u030B\u030C\x03\x02" +
|
|
"\x02\x02\u030C\u030E\x07\u014D\x02\x02\u030D\u030F\x05\xB8]\x02\u030E" +
|
|
"\u030D\x03\x02\x02\x02\u030E\u030F\x03\x02\x02\x02\u030F\u0310\x03\x02" +
|
|
"\x02\x02\u0310\u0312\x05X-\x02\u0311\u0313\x05\xD6l\x02\u0312\u0311\x03" +
|
|
"\x02\x02\x02\u0312\u0313\x03\x02\x02\x02\u0313\u031C\x03\x02\x02\x02\u0314" +
|
|
"\u031B\x05\x1A\x0E\x02\u0315\u0316\x07\xD6\x02\x02\u0316\u0317\x07\xC8" +
|
|
"\x02\x02\u0317\u031B\x05\xCEh\x02\u0318\u0319\x07\u0124\x02\x02\u0319" +
|
|
"\u031B\x056\x1C\x02\u031A\u0314\x03\x02\x02\x02\u031A\u0315\x03\x02\x02" +
|
|
"\x02\u031A\u0318\x03\x02\x02\x02\u031B\u031E\x03\x02\x02\x02\u031C\u031A" +
|
|
"\x03\x02\x02\x02\u031C\u031D\x03\x02\x02\x02\u031D\u031F\x03\x02\x02\x02" +
|
|
"\u031E\u031C\x03\x02\x02\x02\u031F\u0320\x07\x16\x02\x02\u0320\u0321\x05" +
|
|
"\x1C\x0F\x02\u0321\u04D8\x03\x02\x02\x02\u0322\u0325\x07=\x02\x02\u0323" +
|
|
"\u0324\x07\xCC\x02\x02\u0324\u0326\x07\xF0\x02\x02\u0325\u0323\x03\x02" +
|
|
"\x02\x02\u0325\u0326\x03\x02\x02\x02\u0326\u0328\x03\x02\x02\x02\u0327" +
|
|
"\u0329\x07\x80\x02\x02\u0328\u0327\x03\x02\x02\x02\u0328\u0329\x03\x02" +
|
|
"\x02\x02\u0329\u032A\x03\x02\x02\x02\u032A\u032B\x07\u0125\x02\x02\u032B" +
|
|
"\u032C\x07\u014D\x02\x02\u032C\u0331\x05X-\x02\u032D\u032E\x07\x04\x02" +
|
|
"\x02\u032E\u032F\x05\u0144\xA3\x02\u032F\u0330\x07\x05\x02\x02\u0330\u0332" +
|
|
"\x03\x02\x02\x02\u0331\u032D\x03\x02\x02\x02\u0331\u0332\x03\x02\x02\x02" +
|
|
"\u0332\u0333\x03\x02\x02\x02\u0333\u0336\x052\x1A\x02\u0334\u0335\x07" +
|
|
"\xCB\x02\x02\u0335\u0337\x056\x1C\x02\u0336\u0334\x03\x02\x02\x02\u0336" +
|
|
"\u0337\x03\x02\x02\x02\u0337\u04D8\x03\x02\x02\x02\u0338\u0339\x07\r\x02" +
|
|
"\x02\u0339\u033A\x07\u014D\x02\x02\u033A\u033C\x05Z.\x02\u033B\u033D\x07" +
|
|
"\x16\x02\x02\u033C\u033B\x03\x02\x02\x02\u033C\u033D\x03\x02\x02\x02\u033D" +
|
|
"\u033E\x03\x02\x02\x02\u033E\u033F\x05\x1C\x0F\x02\u033F\u04D8\x03\x02" +
|
|
"\x02\x02\u0340\u0343\x07=\x02\x02\u0341\u0342\x07\xCC\x02\x02\u0342\u0344" +
|
|
"\x07\xF0\x02\x02\u0343\u0341\x03\x02\x02\x02\u0343\u0344\x03\x02\x02\x02" +
|
|
"\u0344\u0346\x03\x02\x02\x02\u0345\u0347\x07\u0125\x02\x02\u0346\u0345" +
|
|
"\x03\x02\x02\x02\u0346\u0347\x03\x02\x02\x02\u0347\u0348\x03\x02\x02\x02" +
|
|
"\u0348\u034A\x07}\x02\x02\u0349\u034B\x05\xB8]\x02\u034A\u0349\x03\x02" +
|
|
"\x02\x02\u034A\u034B\x03\x02\x02\x02\u034B\u034C\x03\x02\x02\x02\u034C" +
|
|
"\u034D\x05\u0164\xB3\x02\u034D\u034E\x07\x16\x02\x02\u034E\u0358\x05\u0178" +
|
|
"\xBD\x02\u034F\u0350\x07\u0147\x02\x02\u0350\u0355\x05L\'\x02\u0351\u0352" +
|
|
"\x07\x06\x02\x02\u0352\u0354\x05L\'\x02\u0353\u0351\x03\x02\x02\x02\u0354" +
|
|
"\u0357\x03\x02\x02\x02\u0355\u0353\x03\x02\x02\x02\u0355\u0356\x03\x02" +
|
|
"\x02\x02\u0356\u0359\x03\x02\x02\x02\u0357\u0355\x03\x02\x02\x02\u0358" +
|
|
"\u034F\x03\x02\x02\x02\u0358\u0359\x03\x02\x02\x02\u0359\u04D8\x03\x02" +
|
|
"\x02\x02\u035A\u035C\x07a\x02\x02\u035B\u035D\x07\u0125\x02\x02\u035C" +
|
|
"\u035B\x03\x02\x02\x02\u035C\u035D\x03\x02\x02\x02\u035D\u035E\x03\x02" +
|
|
"\x02\x02\u035E\u0360\x07}\x02\x02\u035F\u0361\x05\xBA^\x02\u0360\u035F" +
|
|
"\x03\x02\x02\x02\u0360\u0361\x03\x02\x02\x02\u0361\u0362\x03\x02\x02\x02" +
|
|
"\u0362\u04D8\x05\u0162\xB2\x02\u0363\u0366\x07S\x02\x02\u0364\u0365\x07" +
|
|
"\xCC\x02\x02\u0365\u0367\x07\xF0\x02\x02\u0366\u0364\x03\x02\x02\x02\u0366" +
|
|
"\u0367\x03\x02\x02\x02\u0367\u0369\x03\x02\x02\x02\u0368\u036A\x07\u014B" +
|
|
"\x02\x02\u0369\u0368\x03\x02\x02\x02\u0369\u036A\x03\x02\x02\x02\u036A" +
|
|
"\u036B\x03\x02\x02\x02\u036B\u036D\x05\u0162\xB2\x02\u036C\u036E\x05\u0138" +
|
|
"\x9D\x02\u036D\u036C\x03\x02\x02\x02\u036D\u036E\x03\x02\x02\x02\u036E" +
|
|
"\u0370\x03\x02\x02\x02\u036F\u0371\x05\u0142\xA2\x02\u0370\u036F\x03\x02" +
|
|
"\x02\x02\u0370\u0371\x03\x02\x02\x02\u0371\u04D8\x03\x02\x02\x02\u0372" +
|
|
"\u0373\x07a\x02\x02\u0373\u0374\x07\u0125\x02\x02\u0374\u0376\x07\u014B" +
|
|
"\x02\x02\u0375\u0377\x05\xBA^\x02\u0376\u0375\x03\x02\x02\x02\u0376\u0377" +
|
|
"\x03\x02\x02\x02\u0377\u037B\x03\x02\x02\x02\u0378\u037C\x05V,\x02\u0379" +
|
|
"\u037C\x05Z.\x02\u037A\u037C\x05\u0162\xB2\x02\u037B\u0378\x03\x02\x02" +
|
|
"\x02\u037B\u0379\x03\x02\x02\x02\u037B\u037A\x03\x02\x02\x02\u037C\u04D8" +
|
|
"\x03\x02\x02\x02\u037D\u037F\x07j\x02\x02\u037E\u0380\t\x07\x02\x02\u037F" +
|
|
"\u037E\x03\x02\x02\x02\u037F\u0380\x03\x02\x02\x02\u0380\u0381\x03\x02" +
|
|
"\x02\x02\u0381\u04D8\x05\x06\x04\x02\u0382\u0383\x07\u010C\x02\x02\u0383" +
|
|
"\u0386\x07\u0121\x02\x02\u0384\u0385\t\x04\x02\x02\u0385\u0387\x05P)\x02" +
|
|
"\u0386\u0384\x03\x02\x02\x02\u0386\u0387\x03\x02\x02\x02\u0387\u038C\x03" +
|
|
"\x02\x02\x02\u0388\u038A\x07\xA2\x02\x02\u0389\u0388\x03\x02\x02\x02\u0389" +
|
|
"\u038A\x03\x02\x02\x02\u038A\u038B\x03\x02\x02\x02\u038B\u038D\x05\u0178" +
|
|
"\xBD\x02\u038C\u0389\x03\x02\x02\x02\u038C\u038D\x03\x02\x02\x02\u038D" +
|
|
"\u04D8\x03\x02\x02\x02\u038E\u038F\x07\u010C\x02\x02\u038F\u0390\x07\u0120" +
|
|
"\x02\x02\u0390\u0393\x07l\x02\x02\u0391\u0392\t\x04\x02\x02\u0392\u0394" +
|
|
"\x05P)\x02\u0393\u0391\x03\x02\x02\x02\u0393\u0394\x03\x02\x02\x02\u0394" +
|
|
"\u0395\x03\x02\x02\x02\u0395\u0396\x07\xA2\x02\x02\u0396\u0398\x05\u0178" +
|
|
"\xBD\x02\u0397\u0399\x05\"\x12\x02\u0398\u0397\x03\x02\x02\x02\u0398\u0399" +
|
|
"\x03\x02\x02\x02\u0399\u04D8\x03\x02\x02\x02\u039A\u039B\x07\u010C\x02" +
|
|
"\x02\u039B\u039C\x07\u0124\x02\x02\u039C\u03A1\x05V,\x02\u039D\u039E\x07" +
|
|
"\x04\x02\x02\u039E\u039F\x05:\x1E\x02\u039F\u03A0\x07\x05\x02\x02\u03A0" +
|
|
"\u03A2\x03\x02\x02\x02\u03A1\u039D\x03\x02\x02\x02\u03A1\u03A2\x03\x02" +
|
|
"\x02\x02\u03A2\u04D8\x03\x02\x02\x02\u03A3\u03A4\x07\u010C\x02\x02\u03A4" +
|
|
"\u03A5\x074\x02\x02\u03A5\u03A6\t\x04\x02\x02\u03A6\u03A9\x05V,\x02\u03A7" +
|
|
"\u03A8\t\x04\x02\x02\u03A8\u03AA\x05\xF0y\x02\u03A9\u03A7\x03\x02\x02" +
|
|
"\x02\u03A9\u03AA\x03\x02\x02\x02\u03AA\u04D8\x03\x02\x02\x02\u03AB\u03AC" +
|
|
"\x07\u010C\x02\x02\u03AC\u03AF\x07\u014E\x02\x02\u03AD\u03AE\t\x04\x02" +
|
|
"\x02\u03AE\u03B0\x05P)\x02\u03AF\u03AD\x03\x02\x02\x02\u03AF\u03B0\x03" +
|
|
"\x02\x02\x02\u03B0\u03B5\x03\x02\x02\x02\u03B1\u03B3\x07\xA2\x02\x02\u03B2" +
|
|
"\u03B1\x03\x02\x02\x02\u03B2\u03B3\x03\x02\x02\x02\u03B3\u03B4\x03\x02" +
|
|
"\x02\x02\u03B4\u03B6\x05\u0178\xBD\x02\u03B5\u03B2\x03\x02\x02\x02\u03B5" +
|
|
"\u03B6\x03\x02\x02\x02\u03B6\u04D8\x03\x02\x02\x02\u03B7\u03B8\x07\u010C" +
|
|
"\x02\x02\u03B8\u03B9\x07\xD7\x02\x02\u03B9\u03BB\x05V,\x02\u03BA\u03BC" +
|
|
"\x05\"\x12\x02\u03BB\u03BA\x03\x02\x02\x02\u03BB\u03BC\x03\x02\x02\x02" +
|
|
"\u03BC\u04D8\x03\x02\x02\x02\u03BD\u03BF\x07\u010C\x02\x02\u03BE\u03C0" +
|
|
"\x05\x8EH\x02\u03BF\u03BE\x03\x02\x02\x02\u03BF\u03C0\x03\x02\x02\x02" +
|
|
"\u03C0\u03C1\x03\x02\x02\x02\u03C1\u03C4\x07~\x02\x02\u03C2\u03C3\t\x04" +
|
|
"\x02\x02\u03C3\u03C5\x05P)\x02\u03C4\u03C2\x03\x02\x02\x02\u03C4\u03C5" +
|
|
"\x03\x02\x02\x02\u03C5\u03CD\x03\x02\x02\x02\u03C6\u03C8\x07\xA2\x02\x02" +
|
|
"\u03C7\u03C6\x03\x02\x02\x02\u03C7\u03C8\x03\x02\x02\x02\u03C8\u03CB\x03" +
|
|
"\x02\x02\x02\u03C9\u03CC\x05\xF0y\x02\u03CA\u03CC\x05\u0178\xBD\x02\u03CB" +
|
|
"\u03C9\x03\x02\x02\x02\u03CB\u03CA\x03\x02\x02\x02\u03CC\u03CE\x03\x02" +
|
|
"\x02\x02\u03CD\u03C7\x03\x02\x02\x02\u03CD\u03CE\x03\x02\x02\x02\u03CE" +
|
|
"\u04D8\x03\x02\x02\x02\u03CF\u03D0\x07\u010C\x02\x02\u03D0\u03D1\x07=" +
|
|
"\x02\x02\u03D1\u03D2\x07\u0120\x02\x02\u03D2\u03D5\x05V,\x02\u03D3\u03D4" +
|
|
"\x07\x16\x02\x02\u03D4\u03D6\x07\u0105\x02\x02\u03D5\u03D3\x03\x02\x02" +
|
|
"\x02\u03D5\u03D6\x03\x02\x02\x02\u03D6\u04D8\x03\x02\x02\x02\u03D7\u03D8" +
|
|
"\x07\u010C\x02\x02\u03D8\u03D9\x07@\x02\x02\u03D9\u04D8\x05&\x14\x02\u03DA" +
|
|
"\u03DB\x07\u010C\x02\x02\u03DB\u03E0\x07(\x02\x02\u03DC\u03DE\x07\xA2" +
|
|
"\x02\x02\u03DD\u03DC\x03\x02\x02\x02\u03DD\u03DE\x03\x02\x02\x02\u03DE" +
|
|
"\u03DF\x03\x02\x02\x02\u03DF\u03E1\x05\u0178\xBD\x02\u03E0\u03DD\x03\x02" +
|
|
"\x02\x02\u03E0\u03E1\x03\x02\x02\x02\u03E1\u04D8\x03\x02\x02\x02\u03E2" +
|
|
"\u03E3\t\b\x02\x02\u03E3\u03E5\x07}\x02\x02\u03E4\u03E6\x07l\x02\x02\u03E5" +
|
|
"\u03E4\x03\x02\x02\x02\u03E5\u03E6\x03\x02\x02\x02\u03E6\u03E7\x03\x02" +
|
|
"\x02\x02\u03E7\u04D8\x05*\x16\x02\u03E8\u03E9\t\b\x02\x02\u03E9\u03EB" +
|
|
"\x07J\x02\x02\u03EA\u03EC\x07l\x02\x02\u03EB\u03EA\x03\x02\x02\x02\u03EB" +
|
|
"\u03EC\x03\x02\x02\x02\u03EC\u03ED\x03\x02\x02\x02\u03ED\u04D8\x05P)\x02" +
|
|
"\u03EE\u03F0\t\b\x02\x02\u03EF\u03F1\x07\u0120\x02\x02\u03F0\u03EF\x03" +
|
|
"\x02\x02\x02\u03F0\u03F1\x03\x02\x02\x02\u03F1\u03F3\x03\x02\x02\x02\u03F2" +
|
|
"\u03F4\t\t\x02\x02\u03F3\u03F2\x03\x02\x02\x02\u03F3\u03F4\x03\x02\x02" +
|
|
"\x02\u03F4\u03F5\x03\x02\x02\x02\u03F5\u03F7\x05V,\x02\u03F6\u03F8\x05" +
|
|
"\"\x12\x02\u03F7\u03F6\x03\x02\x02\x02\u03F7\u03F8\x03\x02\x02\x02\u03F8" +
|
|
"\u03FA\x03\x02\x02\x02\u03F9\u03FB\x05,\x17\x02\u03FA\u03F9\x03\x02\x02" +
|
|
"\x02\u03FA\u03FB\x03\x02\x02\x02\u03FB\u04D8\x03\x02\x02\x02\u03FC\u03FE" +
|
|
"\t\b\x02\x02\u03FD\u03FF\x07\xE4\x02\x02\u03FE\u03FD\x03\x02\x02\x02\u03FE" +
|
|
"\u03FF\x03\x02\x02\x02\u03FF\u0400\x03\x02\x02\x02\u0400\u04D8\x05\x1C" +
|
|
"\x0F\x02\u0401\u0402\x075\x02\x02\u0402\u0403\x07\xC8\x02\x02\u0403\u0404" +
|
|
"\x05&\x14\x02\u0404\u0405\x05P)\x02\u0405\u0406\x07\x99\x02\x02\u0406" +
|
|
"\u0407\x05\u017A\xBE\x02\u0407\u04D8\x03\x02\x02\x02\u0408\u0409\x075" +
|
|
"\x02\x02\u0409\u040A\x07\xC8\x02\x02\u040A\u040B\x07\u0120\x02\x02\u040B" +
|
|
"\u040C\x05V,\x02\u040C\u040D\x07\x99\x02\x02\u040D\u040E\x05\u017A\xBE" +
|
|
"\x02\u040E\u04D8\x03\x02\x02\x02\u040F\u0410\x07\xEC\x02\x02\u0410\u0411" +
|
|
"\x07\u0120\x02\x02\u0411";
|
|
private static readonly _serializedATNSegment3: string =
|
|
"\u04D8\x05V,\x02\u0412\u0413\x07\xEC\x02\x02\u0413\u0414\x07}\x02\x02" +
|
|
"\u0414\u04D8\x05\u0162\xB2\x02\u0415\u041D\x07\xEC\x02\x02\u0416\u041E" +
|
|
"\x05\u0178\xBD\x02\u0417\u0419\v\x02\x02\x02\u0418\u0417\x03\x02\x02\x02" +
|
|
"\u0419\u041C\x03\x02\x02\x02\u041A\u041B\x03\x02\x02\x02\u041A\u0418\x03" +
|
|
"\x02\x02\x02\u041B\u041E\x03\x02\x02\x02\u041C\u041A\x03\x02\x02\x02\u041D" +
|
|
"\u0416\x03\x02\x02\x02\u041D\u041A\x03\x02\x02\x02\u041E\u04D8\x03\x02" +
|
|
"\x02\x02\u041F\u0421\x07#\x02\x02\u0420\u0422\x07\x9F\x02\x02\u0421\u0420" +
|
|
"\x03\x02\x02\x02\u0421\u0422\x03\x02\x02\x02\u0422\u0423\x03\x02\x02\x02" +
|
|
"\u0423\u0424\x07\u0120\x02\x02\u0424\u0427\x05V,\x02\u0425\u0426\x07\xCB" +
|
|
"\x02\x02\u0426\u0428\x056\x1C\x02\u0427\u0425\x03\x02\x02\x02\u0427\u0428" +
|
|
"\x03\x02\x02\x02\u0428\u042D\x03\x02\x02\x02\u0429\u042B\x07\x16\x02\x02" +
|
|
"\u042A\u0429\x03\x02\x02\x02\u042A\u042B\x03\x02\x02\x02\u042B\u042C\x03" +
|
|
"\x02\x02\x02\u042C\u042E\x05\x1C\x0F\x02\u042D\u042A\x03\x02\x02\x02\u042D" +
|
|
"\u042E\x03\x02\x02\x02\u042E\u04D8\x03\x02\x02\x02\u042F\u0430\x07\u013D" +
|
|
"\x02\x02\u0430\u0432\x07\u0120\x02\x02\u0431\u0433\x05\xBA^\x02\u0432" +
|
|
"\u0431\x03\x02\x02\x02\u0432\u0433\x03\x02\x02\x02\u0433\u0434\x03\x02" +
|
|
"\x02\x02\u0434\u04D8\x05V,\x02\u0435\u0436\x07-\x02\x02\u0436\u04D8\x07" +
|
|
"#\x02\x02\u0437\u0438\x07\xA7\x02\x02\u0438\u043A\x07H\x02\x02\u0439\u043B" +
|
|
"\x07\xA8\x02\x02\u043A\u0439\x03\x02\x02\x02\u043A\u043B\x03\x02\x02\x02" +
|
|
"\u043B\u043C\x03\x02\x02\x02\u043C\u043D\x07\x91\x02\x02\u043D\u043F\x05" +
|
|
"\u0178\xBD\x02\u043E\u0440\x07\xD4\x02\x02\u043F\u043E\x03\x02\x02\x02" +
|
|
"\u043F\u0440\x03\x02\x02\x02\u0440\u0441\x03\x02\x02\x02\u0441\u0442\x07" +
|
|
"\x98\x02\x02\u0442\u0443\x07\u0120\x02\x02\u0443\u0445\x05V,\x02\u0444" +
|
|
"\u0446\x05\"\x12\x02\u0445\u0444\x03\x02\x02\x02\u0445\u0446\x03\x02\x02" +
|
|
"\x02\u0446\u04D8\x03\x02\x02\x02\u0447\u0448\x07\u0138\x02\x02\u0448\u0449" +
|
|
"\x07\u0120\x02\x02\u0449\u044B\x05V,\x02\u044A\u044C\x05\"\x12\x02\u044B" +
|
|
"\u044A\x03\x02\x02\x02\u044B\u044C\x03\x02\x02\x02\u044C\u04D8\x03\x02" +
|
|
"\x02\x02\u044D\u044F\x07\xBA\x02\x02\u044E\u044D\x03\x02\x02\x02\u044E" +
|
|
"\u044F\x03\x02\x02\x02\u044F\u0450\x03\x02\x02\x02\u0450\u0451\x07\xEE" +
|
|
"\x02\x02\u0451\u0452\x07\u0120\x02\x02\u0452\u0455\x05V,\x02\u0453\u0454" +
|
|
"\t\n\x02\x02\u0454\u0456\x07\xD7\x02\x02\u0455\u0453\x03\x02\x02\x02\u0455" +
|
|
"\u0456\x03\x02\x02\x02\u0456\u04D8\x03\x02\x02\x02\u0457\u0458\t\v\x02" +
|
|
"\x02\u0458\u045C\x05\u016C\xB7\x02\u0459\u045B\v\x02\x02\x02\u045A\u0459" +
|
|
"\x03\x02\x02\x02\u045B\u045E\x03\x02\x02\x02\u045C\u045D\x03\x02\x02\x02" +
|
|
"\u045C\u045A\x03\x02\x02\x02\u045D\u04D8\x03\x02\x02\x02\u045E\u045C\x03" +
|
|
"\x02\x02\x02\u045F\u0460\x07\u0108\x02\x02\u0460\u0464\x07\xF8\x02\x02" +
|
|
"\u0461\u0463\v\x02\x02\x02\u0462\u0461\x03\x02\x02\x02\u0463\u0466\x03" +
|
|
"\x02\x02\x02\u0464\u0465\x03\x02\x02\x02\u0464\u0462\x03\x02\x02\x02\u0465" +
|
|
"\u04D8\x03\x02\x02\x02\u0466\u0464\x03\x02\x02\x02\u0467\u0468\x07\u0108" +
|
|
"\x02\x02\u0468\u0469\x07\u0128\x02\x02\u0469\u046A\x07\u0159\x02\x02\u046A" +
|
|
"\u04D8\x05\u0124\x93\x02\u046B\u046C\x07\u0108\x02\x02\u046C\u046D\x07" +
|
|
"\u0128\x02\x02\u046D\u046E\x07\u0159\x02\x02\u046E\u04D8\x05\b\x05\x02" +
|
|
"\u046F\u0470\x07\u0108\x02\x02\u0470\u0471\x07\u0128\x02\x02\u0471\u0475" +
|
|
"\x07\u0159\x02\x02\u0472\u0474\v\x02\x02\x02\u0473\u0472\x03\x02\x02\x02" +
|
|
"\u0474\u0477\x03\x02\x02\x02\u0475\u0476\x03\x02\x02\x02\u0475\u0473\x03" +
|
|
"\x02\x02\x02\u0476\u04D8\x03\x02\x02\x02\u0477\u0475\x03\x02\x02\x02\u0478" +
|
|
"\u0479\x07\u0108\x02\x02\u0479\u047A\t\f\x02\x02\u047A\u04D8\x05\x80A" +
|
|
"\x02\u047B\u047C\x07\u0108\x02\x02\u047C\u047D\t\f\x02\x02\u047D\u047E" +
|
|
"\x07\x04\x02\x02\u047E\u047F\x05\xEEx\x02\u047F\u0480\x07\x05\x02\x02" +
|
|
"\u0480\u0481\x07\u015A\x02\x02\u0481\u0482\x07\x04\x02\x02\u0482\u0483" +
|
|
"\x05\x1C\x0F\x02\u0483\u0484\x07\x05\x02\x02\u0484\u04D8\x03\x02\x02\x02" +
|
|
"\u0485\u0486\x07\u0108\x02\x02\u0486\u0487\x05\n\x06\x02\u0487\u0488\x07" +
|
|
"\u015A\x02\x02\u0488\u0489\x05\f\x07\x02\u0489\u04D8\x03\x02\x02\x02\u048A" +
|
|
"\u048B\x07\u0108\x02\x02\u048B\u0493\x05\n\x06\x02\u048C\u0490\x07\u015A" +
|
|
"\x02\x02\u048D\u048F\v\x02\x02\x02\u048E\u048D\x03\x02\x02\x02\u048F\u0492" +
|
|
"\x03\x02\x02\x02\u0490\u0491\x03\x02\x02\x02\u0490\u048E\x03\x02\x02\x02" +
|
|
"\u0491\u0494\x03\x02\x02\x02\u0492\u0490\x03\x02\x02\x02\u0493\u048C\x03" +
|
|
"\x02\x02\x02\u0493\u0494\x03\x02\x02\x02\u0494\u04D8\x03\x02\x02\x02\u0495" +
|
|
"\u0499\x07\u0108\x02\x02\u0496\u0498\v\x02\x02\x02\u0497\u0496\x03\x02" +
|
|
"\x02\x02\u0498\u049B\x03\x02\x02\x02\u0499\u049A\x03\x02\x02\x02\u0499" +
|
|
"\u0497\x03\x02\x02\x02\u049A\u049C\x03\x02\x02\x02\u049B\u0499\x03\x02" +
|
|
"\x02\x02\u049C\u049D\x07\u015A\x02\x02\u049D\u04D8\x05\f\x07\x02\u049E" +
|
|
"\u04A2\x07\u0108\x02\x02\u049F\u04A1\v\x02\x02\x02\u04A0\u049F\x03\x02" +
|
|
"\x02\x02\u04A1\u04A4\x03\x02\x02\x02\u04A2\u04A3\x03\x02\x02\x02\u04A2" +
|
|
"\u04A0\x03\x02\x02\x02\u04A3\u04D8\x03\x02\x02\x02\u04A4\u04A2\x03\x02" +
|
|
"\x02\x02\u04A5\u04A6\x07\xF1\x02\x02\u04A6\u04D8\x05\n\x06\x02\u04A7\u04AB" +
|
|
"\x07\xF1\x02\x02\u04A8\u04AA\v\x02\x02\x02\u04A9\u04A8\x03\x02\x02\x02" +
|
|
"\u04AA\u04AD\x03\x02\x02\x02\u04AB\u04AC\x03\x02\x02\x02\u04AB\u04A9\x03" +
|
|
"\x02\x02\x02\u04AC\u04D8\x03\x02\x02\x02\u04AD\u04AB\x03\x02\x02\x02\u04AE" +
|
|
"\u04AF\x07=\x02\x02\u04AF\u04B1\x07\x8E\x02\x02\u04B0\u04B2\x05\xB8]\x02" +
|
|
"\u04B1\u04B0\x03\x02\x02\x02\u04B1\u04B2\x03\x02\x02\x02\u04B2\u04B3\x03" +
|
|
"\x02\x02\x02\u04B3\u04B4\x05\u016C\xB7\x02\u04B4\u04B6\x07\xC8\x02\x02" +
|
|
"\u04B5\u04B7\x07\u0120\x02\x02\u04B6\u04B5\x03\x02\x02\x02\u04B6\u04B7" +
|
|
"\x03\x02\x02\x02\u04B7\u04B8\x03\x02\x02\x02\u04B8\u04BB\x05V,\x02\u04B9" +
|
|
"\u04BA\x07\u0147\x02\x02\u04BA\u04BC\x05\u016C\xB7\x02\u04BB\u04B9\x03" +
|
|
"\x02\x02\x02\u04BB\u04BC\x03\x02\x02\x02\u04BC\u04BD\x03\x02\x02\x02\u04BD" +
|
|
"\u04BE\x07\x04\x02\x02\u04BE\u04BF\x05\xF2z\x02\u04BF\u04C2\x07\x05\x02" +
|
|
"\x02\u04C0\u04C1\x07\xCB\x02\x02\u04C1\u04C3\x056\x1C\x02\u04C2\u04C0" +
|
|
"\x03\x02\x02\x02\u04C2\u04C3\x03\x02\x02\x02\u04C3\u04D8\x03\x02\x02\x02" +
|
|
"\u04C4\u04C5\x07a\x02\x02\u04C5\u04C7\x07\x8E\x02\x02\u04C6\u04C8\x05" +
|
|
"\xBA^\x02\u04C7\u04C6\x03\x02\x02\x02\u04C7\u04C8\x03\x02\x02\x02\u04C8" +
|
|
"\u04C9\x03\x02\x02\x02\u04C9\u04CA\x05\u016C\xB7\x02\u04CA\u04CC\x07\xC8" +
|
|
"\x02\x02\u04CB\u04CD\x07\u0120\x02\x02\u04CC\u04CB\x03\x02\x02\x02\u04CC" +
|
|
"\u04CD\x03\x02\x02\x02\u04CD\u04CE\x03\x02\x02\x02\u04CE\u04CF\x05V,\x02" +
|
|
"\u04CF\u04D8\x03\x02\x02\x02\u04D0\u04D4\x05\x0E\b\x02\u04D1\u04D3\v\x02" +
|
|
"\x02\x02\u04D2\u04D1\x03\x02\x02\x02\u04D3\u04D6\x03\x02\x02\x02\u04D4" +
|
|
"\u04D5\x03\x02\x02\x02\u04D4\u04D2\x03\x02\x02\x02\u04D5\u04D8\x03\x02" +
|
|
"\x02\x02\u04D6\u04D4\x03\x02\x02\x02\u04D7\u0190\x03\x02\x02\x02\u04D7" +
|
|
"\u0192\x03\x02\x02\x02\u04D7\u0195\x03\x02\x02\x02\u04D7\u0197\x03\x02" +
|
|
"\x02\x02\u04D7\u019B\x03\x02\x02\x02\u04D7\u01A1\x03\x02\x02\x02\u04D7" +
|
|
"\u01B1\x03\x02\x02\x02\u04D7\u01B8\x03\x02\x02\x02\u04D7\u01BE\x03\x02" +
|
|
"\x02\x02\u04D7\u01C7\x03\x02\x02\x02\u04D7\u01D3\x03\x02\x02\x02\u04D7" +
|
|
"\u01E4\x03\x02\x02\x02\u04D7\u01F7\x03\x02\x02\x02\u04D7\u0208\x03\x02" +
|
|
"\x02\x02\u04D7\u0219\x03\x02\x02\x02\u04D7\u0224\x03\x02\x02\x02\u04D7" +
|
|
"\u022B\x03\x02\x02\x02\u04D7\u0234\x03\x02\x02\x02\u04D7\u023D\x03\x02" +
|
|
"\x02\x02\u04D7\u0249\x03\x02\x02\x02\u04D7\u0253\x03\x02\x02\x02\u04D7" +
|
|
"\u025E\x03\x02\x02\x02\u04D7\u0269\x03\x02\x02\x02\u04D7\u0277\x03\x02" +
|
|
"\x02\x02\u04D7\u0282\x03\x02\x02\x02\u04D7\u0291\x03\x02\x02\x02\u04D7" +
|
|
"\u029D\x03\x02\x02\x02\u04D7\u02AB\x03\x02\x02\x02\u04D7\u02B5\x03\x02" +
|
|
"\x02\x02\u04D7\u02C5\x03\x02\x02\x02\u04D7\u02CD\x03\x02\x02\x02\u04D7" +
|
|
"\u02E3\x03\x02\x02\x02\u04D7\u02EC\x03\x02\x02\x02\u04D7\u02F2\x03\x02" +
|
|
"\x02\x02\u04D7\u02FB\x03\x02\x02\x02\u04D7\u0301\x03\x02\x02\x02\u04D7" +
|
|
"\u0322\x03\x02\x02\x02\u04D7\u0338\x03\x02\x02\x02\u04D7\u0340\x03\x02" +
|
|
"\x02\x02\u04D7\u035A\x03\x02\x02\x02\u04D7\u0363\x03\x02\x02\x02\u04D7" +
|
|
"\u0372\x03\x02\x02\x02\u04D7\u037D\x03\x02\x02\x02\u04D7\u0382\x03\x02" +
|
|
"\x02\x02\u04D7\u038E\x03\x02\x02\x02\u04D7\u039A\x03\x02\x02\x02\u04D7" +
|
|
"\u03A3\x03\x02\x02\x02\u04D7\u03AB\x03\x02\x02\x02\u04D7\u03B7\x03\x02" +
|
|
"\x02\x02\u04D7\u03BD\x03\x02\x02\x02\u04D7\u03CF\x03\x02\x02\x02\u04D7" +
|
|
"\u03D7\x03\x02\x02\x02\u04D7\u03DA\x03\x02\x02\x02\u04D7\u03E2\x03\x02" +
|
|
"\x02\x02\u04D7\u03E8\x03\x02\x02\x02\u04D7\u03EE\x03\x02\x02\x02\u04D7" +
|
|
"\u03FC\x03\x02\x02\x02\u04D7\u0401\x03\x02\x02\x02\u04D7\u0408\x03\x02" +
|
|
"\x02\x02\u04D7\u040F\x03\x02\x02\x02\u04D7\u0412\x03\x02\x02\x02\u04D7" +
|
|
"\u0415\x03\x02\x02\x02\u04D7\u041F\x03\x02\x02\x02\u04D7\u042F\x03\x02" +
|
|
"\x02\x02\u04D7\u0435\x03\x02\x02\x02\u04D7\u0437\x03\x02\x02\x02\u04D7" +
|
|
"\u0447\x03\x02\x02\x02\u04D7\u044E\x03\x02\x02\x02\u04D7\u0457\x03\x02" +
|
|
"\x02\x02\u04D7\u045F\x03\x02\x02\x02\u04D7\u0467\x03\x02\x02\x02\u04D7" +
|
|
"\u046B\x03\x02\x02\x02\u04D7\u046F\x03\x02\x02\x02\u04D7\u0478\x03\x02" +
|
|
"\x02\x02\u04D7\u047B\x03\x02\x02\x02\u04D7\u0485\x03\x02\x02\x02\u04D7" +
|
|
"\u048A\x03\x02\x02\x02\u04D7\u0495\x03\x02\x02\x02\u04D7\u049E\x03\x02" +
|
|
"\x02\x02\u04D7\u04A5\x03\x02\x02\x02\u04D7\u04A7\x03\x02\x02\x02\u04D7" +
|
|
"\u04AE\x03\x02\x02\x02\u04D7\u04C4\x03\x02\x02\x02\u04D7\u04D0\x03\x02" +
|
|
"\x02\x02\u04D8\x07\x03\x02\x02\x02\u04D9\u04DC\x05\u0178\xBD\x02\u04DA" +
|
|
"\u04DC\x07\xA8\x02\x02\u04DB\u04D9\x03\x02\x02\x02\u04DB\u04DA\x03\x02" +
|
|
"\x02\x02\u04DC\t\x03\x02\x02\x02\u04DD\u04DE\x05\u0170\xB9\x02\u04DE\v" +
|
|
"\x03\x02\x02\x02\u04DF\u04E0\x05\u0172\xBA\x02\u04E0\r\x03\x02\x02\x02" +
|
|
"\u04E1\u04E2\x07=\x02\x02\u04E2\u058A\x07\xF8\x02\x02\u04E3\u04E4\x07" +
|
|
"a\x02\x02\u04E4\u058A\x07\xF8\x02\x02\u04E5\u04E7\x07\x81\x02\x02\u04E6" +
|
|
"\u04E8\x07\xF8\x02\x02\u04E7\u04E6\x03\x02\x02\x02\u04E7\u04E8\x03\x02" +
|
|
"\x02\x02\u04E8\u058A\x03\x02\x02\x02\u04E9\u04EB\x07\xF4\x02\x02\u04EA" +
|
|
"\u04EC\x07\xF8\x02\x02\u04EB\u04EA\x03\x02\x02\x02\u04EB\u04EC\x03\x02" +
|
|
"\x02\x02\u04EC\u058A\x03\x02\x02\x02\u04ED\u04EE\x07\u010C\x02\x02\u04EE" +
|
|
"\u058A\x07\x81\x02\x02\u04EF\u04F0\x07\u010C\x02\x02\u04F0\u04F2\x07\xF8" +
|
|
"\x02\x02\u04F1\u04F3\x07\x81\x02\x02\u04F2\u04F1\x03\x02\x02\x02\u04F2" +
|
|
"\u04F3\x03\x02\x02\x02\u04F3\u058A\x03\x02\x02\x02\u04F4\u04F5\x07\u010C" +
|
|
"\x02\x02\u04F5\u058A\x07\xE0\x02\x02\u04F6\u04F7\x07\u010C\x02\x02\u04F7" +
|
|
"\u058A\x07\xF9\x02\x02\u04F8\u04F9\x07\u010C\x02\x02\u04F9\u04FA\x07@" +
|
|
"\x02\x02\u04FA\u058A\x07\xF9\x02\x02\u04FB\u04FC\x07k\x02\x02\u04FC\u058A" +
|
|
"\x07\u0120\x02\x02\u04FD\u04FE\x07\x8B\x02\x02\u04FE\u058A\x07\u0120\x02" +
|
|
"\x02\u04FF\u0500\x07\u010C\x02\x02\u0500\u058A\x078\x02\x02\u0501\u0502" +
|
|
"\x07\u010C\x02\x02\u0502\u0503\x07=\x02\x02\u0503\u058A\x07\u0120\x02" +
|
|
"\x02\u0504\u0505\x07\u010C\x02\x02\u0505\u058A\x07\u0134\x02\x02\u0506" +
|
|
"\u0507\x07\u010C\x02\x02\u0507\u058A\x07\x8F\x02\x02\u0508\u0509\x07\u010C" +
|
|
"\x02\x02\u0509\u058A\x07\xAB\x02\x02\u050A\u050B\x07=\x02\x02\u050B\u058A" +
|
|
"\x07\x8E\x02\x02\u050C\u050D\x07a\x02\x02\u050D\u058A\x07\x8E\x02\x02" +
|
|
"\u050E\u050F\x07\r\x02\x02\u050F\u058A\x07\x8E\x02\x02\u0510\u0511\x07" +
|
|
"\xAA\x02\x02\u0511\u058A\x07\u0120\x02\x02\u0512\u0513\x07\xAA\x02\x02" +
|
|
"\u0513\u058A\x07J\x02\x02\u0514\u0515\x07\u0141\x02\x02\u0515\u058A\x07" +
|
|
"\u0120\x02\x02\u0516\u0517\x07\u0141\x02\x02\u0517\u058A\x07J\x02\x02" +
|
|
"\u0518\u0519\x07=\x02\x02\u0519\u051A\x07\u0125\x02\x02\u051A\u058A\x07" +
|
|
"\xAE\x02\x02\u051B\u051C\x07a\x02\x02\u051C\u051D\x07\u0125\x02\x02\u051D" +
|
|
"\u058A\x07\xAE\x02\x02\u051E\u051F\x07\r\x02\x02\u051F\u0520\x07\u0120" +
|
|
"\x02\x02\u0520\u0521\x05V,\x02\u0521\u0522\x07\xC2\x02\x02\u0522\u0523" +
|
|
"\x07/\x02\x02\u0523\u058A\x03\x02\x02\x02\u0524\u0525\x07\r\x02\x02\u0525" +
|
|
"\u0526\x07\u0120\x02\x02\u0526\u0527\x05V,\x02\u0527\u0528\x07/\x02\x02" +
|
|
"\u0528\u0529\x07!\x02\x02\u0529\u058A\x03\x02\x02\x02\u052A\u052B\x07" +
|
|
"\r\x02\x02\u052B\u052C\x07\u0120\x02\x02\u052C\u052D\x05V,\x02\u052D\u052E" +
|
|
"\x07\xC2\x02\x02\u052E\u052F\x07\u0112\x02\x02\u052F\u058A\x03\x02\x02" +
|
|
"\x02\u0530\u0531\x07\r\x02\x02\u0531\u0532\x07\u0120\x02\x02\u0532\u0533" +
|
|
"\x05V,\x02\u0533\u0534\x07\u010E\x02\x02\u0534\u0535\x07!\x02\x02\u0535" +
|
|
"\u058A\x03\x02\x02\x02\u0536\u0537\x07\r\x02\x02\u0537\u0538\x07\u0120" +
|
|
"\x02\x02\u0538\u0539\x05V,\x02\u0539\u053A\x07\xC2\x02\x02\u053A\u053B" +
|
|
"\x07\u010E\x02\x02\u053B\u058A\x03\x02\x02\x02\u053C\u053D\x07\r\x02\x02" +
|
|
"\u053D\u053E\x07\u0120\x02\x02\u053E\u053F\x05V,\x02\u053F\u0540\x07\xC2" +
|
|
"\x02\x02\u0540\u0541\x07\u0116\x02\x02\u0541\u0542\x07\x16\x02\x02\u0542" +
|
|
"\u0543\x07[\x02\x02\u0543\u058A\x03\x02\x02\x02\u0544\u0545\x07\r\x02" +
|
|
"\x02\u0545\u0546\x07\u0120\x02\x02\u0546\u0547\x05V,\x02\u0547\u0548\x07" +
|
|
"\u0108\x02\x02\u0548\u0549\x07\u010E\x02\x02\u0549\u054A\x07\xA9\x02\x02" +
|
|
"\u054A\u058A\x03\x02\x02\x02\u054B\u054C\x07\r\x02\x02\u054C\u054D\x07" +
|
|
"\u0120\x02\x02\u054D\u054E\x05V,\x02\u054E\u054F\x07g\x02\x02\u054F\u0550" +
|
|
"\x07\xD5\x02\x02\u0550\u058A\x03\x02\x02\x02\u0551\u0552\x07\r\x02\x02" +
|
|
"\u0552\u0553\x07\u0120\x02\x02\u0553\u0554\x05V,\x02\u0554\u0555\x07\x14" +
|
|
"\x02\x02\u0555\u0556\x07\xD5\x02\x02\u0556\u058A\x03\x02\x02\x02\u0557" +
|
|
"\u0558\x07\r\x02\x02\u0558\u0559\x07\u0120\x02\x02\u0559\u055A\x05V,\x02" +
|
|
"\u055A\u055B\x07\u013B\x02\x02\u055B\u055C\x07\xD5\x02\x02\u055C\u058A" +
|
|
"\x03\x02\x02\x02\u055D\u055E\x07\r\x02\x02\u055E\u055F\x07\u0120\x02\x02" +
|
|
"\u055F\u0560\x05V,\x02\u0560\u0561\x07\u0131\x02\x02\u0561\u058A\x03\x02" +
|
|
"\x02\x02\u0562\u0563\x07\r\x02\x02\u0563\u0564\x07\u0120\x02\x02\u0564" +
|
|
"\u0566\x05V,\x02\u0565\u0567\x05\"\x12\x02\u0566\u0565\x03\x02\x02\x02" +
|
|
"\u0566\u0567\x03\x02\x02\x02\u0567\u0568\x03\x02\x02\x02\u0568\u0569\x07" +
|
|
"7\x02\x02\u0569\u058A\x03\x02\x02\x02\u056A\u056B\x07\r\x02\x02\u056B" +
|
|
"\u056C\x07\u0120\x02\x02\u056C\u056E\x05V,\x02\u056D\u056F\x05\"\x12\x02" +
|
|
"\u056E\u056D\x03\x02\x02\x02\u056E\u056F\x03\x02\x02\x02\u056F\u0570\x03" +
|
|
"\x02\x02\x02\u0570\u0571\x07:\x02\x02\u0571\u058A\x03\x02\x02\x02\u0572" +
|
|
"\u0573\x07\r\x02\x02\u0573\u0574\x07\u0120\x02\x02\u0574\u0576\x05V,\x02" +
|
|
"\u0575\u0577\x05\"\x12\x02\u0576\u0575\x03\x02\x02\x02\u0576\u0577\x03" +
|
|
"\x02\x02\x02\u0577\u0578\x03\x02\x02\x02\u0578\u0579\x07\u0108\x02\x02" +
|
|
"\u0579\u057A\x07s\x02\x02\u057A\u058A\x03\x02\x02\x02\u057B\u057C\x07" +
|
|
"\r\x02\x02\u057C\u057D\x07\u0120\x02\x02\u057D\u057F\x05V,\x02\u057E\u0580" +
|
|
"\x05\"\x12\x02\u057F\u057E\x03\x02\x02\x02\u057F\u0580\x03\x02\x02\x02" +
|
|
"\u0580\u0581\x03\x02\x02\x02\u0581\u0582\x07\xF0\x02\x02\u0582\u0583\x07" +
|
|
"4\x02\x02\u0583\u058A\x03\x02\x02\x02\u0584\u0585\x07\u0114\x02\x02\u0585" +
|
|
"\u058A\x07\u0133\x02\x02\u0586\u058A\x076\x02\x02\u0587\u058A\x07\xFA" +
|
|
"\x02\x02\u0588\u058A\x07Z\x02\x02\u0589\u04E1\x03\x02\x02\x02\u0589\u04E3" +
|
|
"\x03\x02\x02\x02\u0589\u04E5\x03\x02\x02\x02\u0589\u04E9\x03\x02\x02\x02" +
|
|
"\u0589\u04ED\x03\x02\x02\x02\u0589\u04EF\x03\x02\x02\x02\u0589\u04F4\x03" +
|
|
"\x02\x02\x02\u0589\u04F6\x03\x02\x02\x02\u0589\u04F8\x03\x02\x02\x02\u0589" +
|
|
"\u04FB\x03\x02\x02\x02\u0589\u04FD\x03\x02\x02\x02\u0589\u04FF\x03\x02" +
|
|
"\x02\x02\u0589\u0501\x03\x02\x02\x02\u0589\u0504\x03\x02\x02\x02\u0589" +
|
|
"\u0506\x03\x02\x02\x02\u0589\u0508\x03\x02\x02\x02\u0589\u050A\x03\x02" +
|
|
"\x02\x02\u0589\u050C\x03\x02\x02\x02\u0589\u050E\x03\x02\x02\x02\u0589" +
|
|
"\u0510\x03\x02\x02\x02\u0589\u0512\x03\x02\x02\x02\u0589\u0514\x03\x02" +
|
|
"\x02\x02\u0589\u0516\x03\x02\x02\x02\u0589\u0518\x03\x02\x02\x02\u0589" +
|
|
"\u051B\x03\x02\x02\x02\u0589\u051E\x03\x02\x02\x02\u0589\u0524\x03\x02" +
|
|
"\x02\x02\u0589\u052A\x03\x02\x02\x02\u0589\u0530\x03\x02\x02\x02\u0589" +
|
|
"\u0536\x03\x02\x02\x02\u0589\u053C\x03\x02\x02\x02\u0589\u0544\x03\x02" +
|
|
"\x02\x02\u0589\u054B\x03\x02\x02\x02\u0589\u0551\x03\x02\x02\x02\u0589" +
|
|
"\u0557\x03\x02\x02\x02\u0589\u055D\x03\x02\x02\x02\u0589\u0562\x03\x02" +
|
|
"\x02\x02\u0589\u056A\x03\x02\x02\x02\u0589\u0572\x03\x02\x02\x02\u0589" +
|
|
"\u057B\x03\x02\x02\x02\u0589\u0584\x03\x02\x02\x02\u0589\u0586\x03\x02" +
|
|
"\x02\x02\u0589\u0587\x03\x02\x02\x02\u0589\u0588\x03\x02\x02\x02\u058A" +
|
|
"\x0F\x03\x02\x02\x02\u058B\u058D\x07=\x02\x02\u058C\u058E\x07\u0125\x02" +
|
|
"\x02\u058D\u058C\x03\x02\x02\x02\u058D\u058E\x03\x02\x02\x02\u058E\u0590" +
|
|
"\x03\x02\x02\x02\u058F\u0591\x07m\x02\x02\u0590\u058F\x03\x02\x02\x02" +
|
|
"\u0590\u0591\x03\x02\x02\x02\u0591\u0592\x03\x02\x02\x02\u0592\u0594\x07" +
|
|
"\u0120\x02\x02\u0593\u0595\x05\xB8]\x02\u0594\u0593\x03\x02\x02\x02\u0594" +
|
|
"\u0595\x03\x02\x02\x02\u0595\u0596\x03\x02\x02\x02\u0596\u0597\x05T+\x02" +
|
|
"\u0597\x11\x03\x02\x02\x02\u0598\u0599\x07=\x02\x02\u0599\u059B\x07\xCC" +
|
|
"\x02\x02\u059A\u0598\x03\x02\x02\x02\u059A\u059B\x03\x02\x02\x02\u059B" +
|
|
"\u059C\x03\x02\x02\x02\u059C\u059D\x07\xF0\x02\x02\u059D\u059E\x07\u0120" +
|
|
"\x02\x02\u059E\u059F\x05T+\x02\u059F\x13\x03\x02\x02\x02\u05A0\u05A1\x07" +
|
|
"/\x02\x02\u05A1\u05A2\x07!\x02\x02\u05A2\u05A6\x05\xCEh\x02\u05A3\u05A4" +
|
|
"\x07\u0112\x02\x02\u05A4\u05A5\x07!\x02\x02\u05A5\u05A7\x05\xD2j\x02\u05A6" +
|
|
"\u05A3\x03\x02\x02\x02\u05A6\u05A7\x03\x02\x02\x02\u05A7\u05A8\x03\x02" +
|
|
"\x02\x02\u05A8\u05A9\x07\x98\x02\x02\u05A9\u05AA\x07\u0178\x02\x02\u05AA" +
|
|
"\u05AB\x07 \x02\x02\u05AB\x15\x03\x02\x02\x02\u05AC\u05AD\x07\u010E\x02" +
|
|
"\x02\u05AD\u05AE\x07!\x02\x02\u05AE\u05AF\x05\xCEh\x02\u05AF\u05B2\x07" +
|
|
"\xC8\x02\x02\u05B0\u05B3\x05B\"\x02\u05B1\u05B3\x05D#\x02\u05B2\u05B0" +
|
|
"\x03\x02\x02\x02\u05B2\u05B1\x03\x02\x02\x02\u05B3\u05B7\x03\x02\x02\x02" +
|
|
"\u05B4\u05B5\x07\u0116\x02\x02\u05B5\u05B6\x07\x16\x02\x02\u05B6\u05B8" +
|
|
"\x07[\x02\x02\u05B7\u05B4\x03\x02\x02\x02\u05B7\u05B8\x03\x02\x02\x02" +
|
|
"\u05B8\x17\x03\x02\x02\x02\u05B9\u05BA\x07\xA9\x02\x02\u05BA\u05BB\x05" +
|
|
"\u0178\xBD\x02\u05BB\x19\x03\x02\x02\x02\u05BC\u05BD\x075\x02\x02\u05BD" +
|
|
"\u05BE\x05\u0178\xBD\x02\u05BE\x1B\x03\x02\x02\x02\u05BF\u05C1\x05.\x18" +
|
|
"\x02\u05C0\u05BF\x03\x02\x02\x02\u05C0\u05C1\x03\x02\x02\x02\u05C1\u05C2" +
|
|
"\x03\x02\x02\x02\u05C2\u05C3\x05b2\x02\u05C3\u05C4\x05^0\x02\u05C4\x1D" +
|
|
"\x03\x02\x02\x02\u05C5\u05C6\x07\x93\x02\x02\u05C6\u05C8\x07\xD4\x02\x02" +
|
|
"\u05C7\u05C9\x07\u0120\x02\x02\u05C8\u05C7\x03\x02\x02\x02\u05C8\u05C9" +
|
|
"\x03\x02\x02\x02\u05C9\u05CA\x03\x02\x02\x02\u05CA\u05CF\x05V,\x02\u05CB" +
|
|
"\u05CD\x05\"\x12\x02\u05CC\u05CE\x05\xB8]\x02\u05CD\u05CC\x03\x02\x02" +
|
|
"\x02\u05CD\u05CE\x03\x02\x02\x02\u05CE\u05D0\x03\x02\x02\x02\u05CF\u05CB" +
|
|
"\x03\x02\x02\x02\u05CF\u05D0\x03\x02\x02\x02\u05D0\u05D4\x03\x02\x02\x02" +
|
|
"\u05D1\u05D2\x07!\x02\x02\u05D2\u05D5\x07\xBB\x02\x02\u05D3\u05D5\x05" +
|
|
"\xCEh\x02\u05D4\u05D1\x03\x02\x02\x02\u05D4\u05D3\x03\x02\x02\x02\u05D4" +
|
|
"\u05D5\x03\x02\x02\x02\u05D5\u060C\x03\x02\x02\x02\u05D6\u05D7\x07\x93" +
|
|
"\x02\x02\u05D7\u05D9\x07\x98\x02\x02\u05D8\u05DA\x07\u0120\x02\x02\u05D9" +
|
|
"\u05D8\x03\x02\x02\x02\u05D9\u05DA\x03\x02\x02\x02\u05DA\u05DB\x03\x02" +
|
|
"\x02\x02\u05DB\u05DD\x05V,\x02\u05DC\u05DE\x05\"\x12\x02\u05DD\u05DC\x03" +
|
|
"\x02\x02\x02\u05DD\u05DE\x03\x02\x02\x02\u05DE\u05E0\x03\x02\x02\x02\u05DF" +
|
|
"\u05E1\x05\xB8]\x02\u05E0\u05DF\x03\x02\x02\x02\u05E0\u05E1\x03\x02\x02" +
|
|
"\x02\u05E1\u05E5\x03\x02\x02\x02\u05E2\u05E3\x07!\x02\x02\u05E3\u05E6" +
|
|
"\x07\xBB\x02\x02\u05E4\u05E6\x05\xCEh\x02\u05E5\u05E2\x03\x02\x02\x02" +
|
|
"\u05E5\u05E4\x03\x02\x02\x02\u05E5\u05E6\x03\x02\x02\x02\u05E6\u060C\x03" +
|
|
"\x02\x02\x02\u05E7\u05E8\x07\x93\x02\x02\u05E8\u05EA\x07\x98\x02\x02\u05E9" +
|
|
"\u05EB\x07\u0120\x02\x02\u05EA\u05E9\x03\x02\x02\x02\u05EA\u05EB\x03\x02" +
|
|
"\x02\x02\u05EB\u05EC\x03\x02\x02\x02\u05EC\u05ED\x05V,\x02\u05ED\u05EE" +
|
|
"\x07\xF0\x02\x02\u05EE\u05EF\x05\x84C\x02\u05EF\u060C\x03\x02\x02\x02" +
|
|
"\u05F0\u05F1\x07\x93\x02\x02\u05F1\u05F3\x07\xD4\x02\x02\u05F2\u05F4\x07" +
|
|
"\xA8\x02\x02\u05F3\u05F2\x03\x02\x02\x02\u05F3\u05F4\x03\x02\x02\x02\u05F4" +
|
|
"\u05F5\x03\x02\x02\x02\u05F5\u05F6\x07\\\x02\x02\u05F6\u05F8\x05\u0178" +
|
|
"\xBD\x02\u05F7\u05F9\x05\xECw\x02\u05F8\u05F7\x03\x02\x02\x02\u05F8\u05F9" +
|
|
"\x03\x02\x02\x02\u05F9\u05FB\x03\x02\x02\x02\u05FA\u05FC\x05F$\x02\u05FB" +
|
|
"\u05FA\x03\x02\x02\x02\u05FB\u05FC\x03\x02\x02\x02\u05FC\u060C\x03\x02" +
|
|
"\x02\x02\u05FD\u05FE\x07\x93\x02\x02\u05FE\u0600\x07\xD4\x02\x02\u05FF" +
|
|
"\u0601\x07\xA8\x02\x02\u0600\u05FF\x03\x02\x02\x02\u0600\u0601\x03\x02" +
|
|
"\x02\x02\u0601\u0602\x03\x02\x02\x02\u0602\u0604\x07\\\x02\x02\u0603\u0605" +
|
|
"\x05\u0178\xBD\x02\u0604\u0603\x03\x02\x02\x02\u0604\u0605\x03\x02\x02" +
|
|
"\x02\u0605\u0606\x03\x02\x02\x02\u0606\u0609\x052\x1A\x02\u0607\u0608" +
|
|
"\x07\xCB\x02\x02\u0608\u060A\x056\x1C\x02\u0609\u0607\x03\x02\x02\x02" +
|
|
"\u0609\u060A\x03\x02\x02\x02\u060A\u060C\x03\x02\x02\x02\u060B\u05C5\x03" +
|
|
"\x02\x02\x02\u060B\u05D6\x03\x02\x02\x02\u060B\u05E7\x03\x02\x02\x02\u060B" +
|
|
"\u05F0\x03\x02\x02\x02\u060B\u05FD\x03\x02\x02\x02\u060C\x1F\x03\x02\x02" +
|
|
"\x02\u060D\u060F\x05\"\x12\x02\u060E\u0610\x05\x18\r\x02\u060F\u060E\x03" +
|
|
"\x02\x02\x02\u060F\u0610\x03\x02\x02\x02\u0610!\x03\x02\x02\x02\u0611" +
|
|
"\u0612\x07\xD5\x02\x02\u0612\u0613\x07\x04\x02\x02\u0613\u0618\x05$\x13" +
|
|
"\x02\u0614\u0615\x07\x06\x02\x02\u0615\u0617\x05$\x13\x02\u0616\u0614" +
|
|
"\x03\x02\x02\x02\u0617\u061A\x03\x02\x02\x02\u0618\u0616\x03\x02\x02\x02" +
|
|
"\u0618\u0619\x03\x02\x02\x02\u0619\u061B\x03\x02\x02\x02\u061A\u0618\x03" +
|
|
"\x02\x02\x02\u061B\u061C\x07\x05\x02\x02\u061C#\x03\x02\x02\x02\u061D" +
|
|
"\u0620\x05\u016C\xB7\x02\u061E\u061F\x07\u015A\x02\x02\u061F\u0621\x05" +
|
|
"\u011A\x8E\x02\u0620\u061E\x03\x02\x02\x02\u0620\u0621\x03\x02\x02\x02" +
|
|
"\u0621\u0627\x03\x02\x02\x02\u0622\u0623\x05\u016C\xB7\x02\u0623\u0624" +
|
|
"\x07\u015A\x02\x02\u0624\u0625\x07T\x02\x02\u0625\u0627\x03\x02\x02\x02" +
|
|
"\u0626\u061D\x03\x02\x02\x02\u0626\u0622\x03\x02\x02\x02\u0627%\x03\x02" +
|
|
"\x02\x02\u0628\u0629\t\r\x02\x02\u0629\'\x03\x02\x02\x02\u062A\u062B\t" +
|
|
"\x0E\x02\x02\u062B)\x03\x02\x02\x02\u062C\u0632\x05\\/\x02\u062D\u0632" +
|
|
"\x05\u0178\xBD\x02\u062E\u0632\x05\u011C\x8F\x02\u062F\u0632\x05\u011E" +
|
|
"\x90\x02\u0630\u0632\x05\u0120\x91\x02\u0631\u062C\x03\x02\x02\x02\u0631" +
|
|
"\u062D\x03\x02\x02\x02\u0631\u062E\x03\x02\x02\x02\u0631\u062F\x03\x02" +
|
|
"\x02\x02\u0631\u0630\x03\x02\x02\x02\u0632+\x03\x02\x02\x02\u0633\u0638" +
|
|
"\x05\u016C\xB7\x02\u0634\u0635\x07\x07\x02\x02\u0635\u0637\x05\u016C\xB7" +
|
|
"\x02\u0636\u0634\x03\x02\x02\x02\u0637\u063A\x03\x02\x02\x02\u0638\u0636" +
|
|
"\x03\x02\x02\x02\u0638\u0639\x03\x02\x02\x02\u0639-\x03\x02\x02\x02\u063A" +
|
|
"\u0638\x03\x02\x02\x02\u063B\u063C\x07\u0155\x02\x02\u063C\u0641\x050" +
|
|
"\x19\x02\u063D\u063E\x07\x06\x02\x02\u063E\u0640\x050\x19\x02\u063F\u063D" +
|
|
"\x03\x02\x02\x02\u0640\u0643\x03\x02\x02\x02\u0641\u063F\x03\x02\x02\x02" +
|
|
"\u0641\u0642\x03\x02\x02\x02\u0642/\x03\x02\x02\x02\u0643\u0641\x03\x02" +
|
|
"\x02\x02\u0644\u0646\x05\u0168\xB5\x02\u0645\u0647\x05\xCEh\x02\u0646" +
|
|
"\u0645\x03\x02\x02\x02\u0646\u0647\x03\x02\x02\x02\u0647\u0649\x03\x02" +
|
|
"\x02\x02\u0648\u064A\x07\x16\x02\x02\u0649\u0648\x03\x02\x02\x02\u0649" +
|
|
"\u064A\x03\x02\x02\x02\u064A\u064B\x03\x02\x02\x02\u064B\u064C\x07\x04" +
|
|
"\x02\x02\u064C\u064D\x05\x1C\x0F\x02\u064D\u064E\x07\x05\x02\x02\u064E" +
|
|
"1\x03\x02\x02\x02\u064F\u0650\x07\u0147\x02\x02\u0650\u0651\x05\xF0y\x02" +
|
|
"\u06513\x03\x02\x02\x02\u0652\u0653\x07\xCB\x02\x02\u0653\u0660\x05> " +
|
|
"\x02\u0654\u0655\x07\xD6\x02\x02\u0655\u0656\x07!\x02\x02\u0656\u0660" +
|
|
"\x05\xFE\x80\x02\u0657\u0660\x05\x16\f\x02\u0658\u0660\x05\x14\v\x02\u0659" +
|
|
"\u0660\x05\xECw\x02\u065A\u0660\x05F$\x02\u065B\u0660\x05\x18\r\x02\u065C" +
|
|
"\u0660\x05\x1A\x0E\x02\u065D\u065E\x07\u0124\x02\x02\u065E\u0660\x056" +
|
|
"\x1C\x02\u065F\u0652\x03\x02\x02\x02\u065F\u0654\x03\x02\x02\x02\u065F" +
|
|
"\u0657\x03\x02\x02\x02\u065F\u0658\x03\x02\x02\x02\u065F\u0659\x03\x02" +
|
|
"\x02\x02\u065F\u065A\x03\x02\x02\x02\u065F\u065B\x03\x02\x02\x02\u065F" +
|
|
"\u065C\x03\x02\x02\x02\u065F\u065D\x03\x02\x02\x02\u0660\u0663\x03\x02" +
|
|
"\x02\x02\u0661\u065F\x03\x02\x02\x02\u0661\u0662\x03\x02\x02\x02\u0662" +
|
|
"5\x03\x02\x02\x02\u0663\u0661\x03\x02\x02\x02\u0664\u0665\x07\x04\x02" +
|
|
"\x02\u0665\u066A\x058\x1D\x02\u0666\u0667\x07\x06\x02\x02\u0667\u0669" +
|
|
"\x058\x1D\x02\u0668\u0666\x03\x02\x02\x02\u0669\u066C\x03\x02\x02\x02" +
|
|
"\u066A\u0668\x03\x02\x02\x02\u066A\u066B\x03\x02\x02\x02\u066B\u066D\x03" +
|
|
"\x02\x02\x02\u066C\u066A\x03\x02\x02\x02\u066D\u066E\x07\x05\x02\x02\u066E" +
|
|
"7\x03\x02\x02\x02\u066F\u0674\x05:\x1E\x02\u0670\u0672\x07\u015A\x02\x02" +
|
|
"\u0671\u0670\x03\x02\x02\x02\u0671\u0672\x03\x02\x02\x02\u0672\u0673\x03" +
|
|
"\x02\x02\x02\u0673\u0675\x05<\x1F\x02\u0674\u0671\x03\x02\x02\x02\u0674" +
|
|
"\u0675\x03\x02\x02\x02\u06759\x03\x02\x02\x02\u0676\u067B\x05\u016C\xB7" +
|
|
"\x02\u0677\u0678\x07\x07\x02\x02\u0678\u067A\x05\u016C\xB7\x02\u0679\u0677" +
|
|
"\x03\x02\x02\x02\u067A\u067D\x03\x02\x02\x02\u067B\u0679\x03";
|
|
private static readonly _serializedATNSegment4: string =
|
|
"\x02\x02\x02\u067B\u067C\x03\x02\x02\x02\u067C\u0680\x03\x02\x02\x02\u067D" +
|
|
"\u067B\x03\x02\x02\x02\u067E\u0680\x05\u0178\xBD\x02\u067F\u0676\x03\x02" +
|
|
"\x02\x02\u067F\u067E\x03\x02\x02\x02\u0680;\x03\x02\x02\x02\u0681\u0686" +
|
|
"\x07\u0178\x02\x02\u0682\u0686\x07\u017A\x02\x02\u0683\u0686\x05\u0122" +
|
|
"\x92\x02\u0684\u0686\x05\u0178\xBD\x02\u0685\u0681\x03\x02\x02\x02\u0685" +
|
|
"\u0682\x03\x02\x02\x02\u0685\u0683\x03\x02\x02\x02\u0685\u0684\x03\x02" +
|
|
"\x02\x02\u0686=\x03\x02\x02\x02\u0687\u0688\x07\x04\x02\x02\u0688\u068D" +
|
|
"\x05@!\x02\u0689\u068A\x07\x06\x02\x02\u068A\u068C\x05@!\x02\u068B\u0689" +
|
|
"\x03\x02\x02\x02\u068C\u068F\x03\x02\x02\x02\u068D\u068B\x03\x02\x02\x02" +
|
|
"\u068D\u068E\x03\x02\x02\x02\u068E\u0690\x03\x02\x02\x02\u068F\u068D\x03" +
|
|
"\x02\x02\x02\u0690\u0691\x07\x05\x02\x02\u0691?\x03\x02\x02\x02\u0692" +
|
|
"\u0697\x05:\x1E\x02\u0693\u0695\x07\u015A\x02\x02\u0694\u0693\x03\x02" +
|
|
"\x02\x02\u0694\u0695\x03\x02\x02\x02\u0695\u0696\x03\x02\x02\x02\u0696" +
|
|
"\u0698\x05\u0106\x84\x02\u0697\u0694\x03\x02\x02\x02\u0697\u0698\x03\x02" +
|
|
"\x02\x02\u0698A\x03\x02\x02\x02\u0699\u069A\x07\x04\x02\x02\u069A\u069F" +
|
|
"\x05\u011A\x8E\x02\u069B\u069C\x07\x06\x02\x02\u069C\u069E\x05\u011A\x8E" +
|
|
"\x02\u069D\u069B\x03\x02\x02\x02\u069E\u06A1\x03\x02\x02\x02\u069F\u069D" +
|
|
"\x03\x02\x02\x02\u069F\u06A0\x03\x02\x02\x02\u06A0\u06A2\x03\x02\x02\x02" +
|
|
"\u06A1\u069F\x03\x02\x02\x02\u06A2\u06A3\x07\x05\x02\x02\u06A3C\x03\x02" +
|
|
"\x02\x02\u06A4\u06A5\x07\x04\x02\x02\u06A5\u06AA\x05B\"\x02\u06A6\u06A7" +
|
|
"\x07\x06\x02\x02\u06A7\u06A9\x05B\"\x02\u06A8\u06A6\x03\x02\x02\x02\u06A9" +
|
|
"\u06AC\x03\x02\x02\x02\u06AA\u06A8\x03\x02\x02\x02\u06AA\u06AB\x03\x02" +
|
|
"\x02\x02\u06AB\u06AD\x03\x02\x02\x02\u06AC\u06AA\x03\x02\x02\x02\u06AD" +
|
|
"\u06AE\x07\x05\x02\x02\u06AEE\x03\x02\x02\x02\u06AF\u06B0\x07\u0116\x02" +
|
|
"\x02\u06B0\u06B1\x07\x16\x02\x02\u06B1\u06B6\x05H%\x02\u06B2\u06B3\x07" +
|
|
"\u0116\x02\x02\u06B3\u06B4\x07!\x02\x02\u06B4\u06B6\x05J&\x02\u06B5\u06AF" +
|
|
"\x03\x02\x02\x02\u06B5\u06B2\x03\x02\x02\x02\u06B6G\x03\x02\x02\x02\u06B7" +
|
|
"\u06B8\x07\x92\x02\x02\u06B8\u06B9\x05\u0178\xBD\x02\u06B9\u06BA\x07\xD0" +
|
|
"\x02\x02\u06BA\u06BB\x05\u0178\xBD\x02\u06BB\u06BE\x03\x02\x02\x02\u06BC" +
|
|
"\u06BE\x05\u016C\xB7\x02\u06BD\u06B7\x03\x02\x02\x02\u06BD\u06BC\x03\x02" +
|
|
"\x02\x02\u06BEI\x03\x02\x02\x02\u06BF\u06C3\x05\u0178\xBD\x02\u06C0\u06C1" +
|
|
"\x07\u0155\x02\x02\u06C1\u06C2\x07\u0106\x02\x02\u06C2\u06C4\x056\x1C" +
|
|
"\x02\u06C3\u06C0\x03\x02\x02\x02\u06C3\u06C4\x03\x02\x02\x02\u06C4K\x03" +
|
|
"\x02\x02\x02\u06C5\u06C6\x05\u016C\xB7\x02\u06C6\u06C7\x05\u0178\xBD\x02" +
|
|
"\u06C7M\x03\x02\x02\x02\u06C8\u06C9\x05\x1E\x10\x02\u06C9\u06CA\x05\x1C" +
|
|
"\x0F\x02\u06CA\u0701\x03\x02\x02\x02\u06CB\u06CD\x05\x8CG\x02\u06CC\u06CE" +
|
|
"\x05`1\x02\u06CD\u06CC\x03\x02\x02\x02\u06CE\u06CF\x03\x02\x02\x02\u06CF" +
|
|
"\u06CD\x03\x02\x02\x02\u06CF\u06D0\x03\x02\x02\x02\u06D0\u0701\x03\x02" +
|
|
"\x02\x02\u06D1\u06D2\x07V\x02\x02\u06D2\u06D3\x07{\x02\x02\u06D3\u06D4" +
|
|
"\x05V,\x02\u06D4\u06D6\x05\xEAv\x02\u06D5\u06D7\x05\x84C\x02\u06D6\u06D5" +
|
|
"\x03\x02\x02\x02\u06D6\u06D7\x03\x02\x02\x02\u06D7\u0701\x03\x02\x02\x02" +
|
|
"\u06D8\u06D9\x07\u0144\x02\x02\u06D9\u06DA\x05V,\x02\u06DA\u06DB\x05\xEA" +
|
|
"v\x02\u06DB\u06DD\x05r:\x02\u06DC\u06DE\x05\x84C\x02\u06DD\u06DC\x03\x02" +
|
|
"\x02\x02\u06DD\u06DE\x03\x02\x02\x02\u06DE\u0701\x03\x02\x02\x02\u06DF" +
|
|
"\u06E0\x07\xB1\x02\x02\u06E0\u06E1\x07\x98\x02\x02\u06E1\u06E2\x05V,\x02" +
|
|
"\u06E2\u06E3\x05\xEAv\x02\u06E3\u06E9\x07\u0147\x02\x02\u06E4\u06EA\x05" +
|
|
"\\/\x02\u06E5\u06E6\x07\x04\x02\x02\u06E6\u06E7\x05\x1C\x0F\x02\u06E7" +
|
|
"\u06E8\x07\x05\x02\x02\u06E8\u06EA\x03\x02\x02\x02\u06E9\u06E4\x03\x02" +
|
|
"\x02\x02\u06E9\u06E5\x03\x02\x02\x02\u06EA\u06EB\x03\x02\x02\x02\u06EB" +
|
|
"\u06EC\x05\xEAv\x02\u06EC\u06ED\x07\xC8\x02\x02\u06ED\u06F1\x05\u010E" +
|
|
"\x88\x02\u06EE\u06F0\x05t;\x02\u06EF\u06EE\x03\x02\x02\x02\u06F0\u06F3" +
|
|
"\x03\x02\x02\x02\u06F1\u06EF\x03\x02\x02\x02\u06F1\u06F2\x03\x02\x02\x02" +
|
|
"\u06F2\u06F7\x03\x02\x02\x02\u06F3\u06F1\x03\x02\x02\x02\u06F4\u06F6\x05" +
|
|
"v<\x02\u06F5\u06F4\x03\x02\x02\x02\u06F6\u06F9\x03\x02\x02\x02\u06F7\u06F5" +
|
|
"\x03\x02\x02\x02\u06F7\u06F8\x03\x02\x02\x02\u06F8\u06FD\x03\x02\x02\x02" +
|
|
"\u06F9\u06F7\x03\x02\x02\x02\u06FA\u06FC\x05x=\x02\u06FB\u06FA\x03\x02" +
|
|
"\x02\x02\u06FC\u06FF\x03\x02\x02\x02\u06FD\u06FB\x03\x02\x02\x02\u06FD" +
|
|
"\u06FE\x03\x02\x02\x02\u06FE\u0701\x03\x02\x02\x02\u06FF\u06FD\x03\x02" +
|
|
"\x02\x02\u0700\u06C8\x03\x02\x02\x02\u0700\u06CB\x03\x02\x02\x02\u0700" +
|
|
"\u06D1\x03\x02\x02\x02\u0700\u06D8\x03\x02\x02\x02\u0700\u06DF\x03\x02" +
|
|
"\x02\x02\u0701O\x03\x02\x02\x02\u0702\u0703\x05\\/\x02\u0703Q\x03\x02" +
|
|
"\x02\x02\u0704\u0705\x05\\/\x02\u0705S\x03\x02\x02\x02\u0706\u0707\x05" +
|
|
"\xF6|\x02\u0707U\x03\x02\x02\x02\u0708\u0709\x05\xF6|\x02\u0709W\x03\x02" +
|
|
"\x02\x02\u070A\u070B\x05\xF8}\x02\u070BY\x03\x02\x02\x02\u070C\u070D\x05" +
|
|
"\xF8}\x02\u070D[\x03\x02\x02\x02\u070E\u070F\x07\x88\x02\x02\u070F\u0710" +
|
|
"\x07\x04\x02\x02\u0710\u0711\x05\u0106\x84\x02\u0711\u0712\x07\x05\x02" +
|
|
"\x02\u0712\u0715\x03\x02\x02\x02\u0713\u0715\x05\xF0y\x02\u0714\u070E" +
|
|
"\x03\x02\x02\x02\u0714\u0713\x03\x02\x02\x02\u0715]\x03\x02\x02\x02\u0716" +
|
|
"\u0717\x07\xCD\x02\x02\u0717\u0718\x07!\x02\x02\u0718\u071D\x05f4\x02" +
|
|
"\u0719\u071A\x07\x06\x02\x02\u071A\u071C\x05f4\x02\u071B\u0719\x03\x02" +
|
|
"\x02\x02\u071C\u071F\x03\x02\x02\x02\u071D\u071B\x03\x02\x02\x02\u071D" +
|
|
"\u071E\x03\x02\x02\x02\u071E\u0721\x03\x02\x02\x02\u071F\u071D\x03\x02" +
|
|
"\x02\x02\u0720\u0716\x03\x02\x02\x02\u0720\u0721\x03\x02\x02\x02\u0721" +
|
|
"\u072C\x03\x02\x02\x02\u0722\u0723\x07.\x02\x02\u0723\u0724\x07!\x02\x02" +
|
|
"\u0724\u0729\x05\u0106\x84\x02\u0725\u0726\x07\x06\x02\x02\u0726\u0728" +
|
|
"\x05\u0106\x84\x02\u0727\u0725\x03\x02\x02\x02\u0728\u072B\x03\x02\x02" +
|
|
"\x02\u0729\u0727\x03\x02\x02\x02\u0729\u072A\x03\x02\x02\x02\u072A\u072D" +
|
|
"\x03\x02\x02\x02\u072B\u0729\x03\x02\x02\x02\u072C\u0722\x03\x02\x02\x02" +
|
|
"\u072C\u072D\x03\x02\x02\x02\u072D\u0738\x03\x02\x02\x02\u072E\u072F\x07" +
|
|
"^\x02\x02\u072F\u0730\x07!\x02\x02\u0730\u0735\x05\u0106\x84\x02\u0731" +
|
|
"\u0732\x07\x06\x02\x02\u0732\u0734\x05\u0106\x84\x02\u0733\u0731\x03\x02" +
|
|
"\x02\x02\u0734\u0737\x03\x02\x02\x02\u0735\u0733\x03\x02\x02\x02\u0735" +
|
|
"\u0736\x03\x02\x02\x02\u0736\u0739\x03\x02\x02\x02\u0737\u0735\x03\x02" +
|
|
"\x02\x02\u0738\u072E\x03\x02\x02\x02\u0738\u0739\x03\x02\x02\x02\u0739" +
|
|
"\u0744\x03\x02\x02\x02\u073A\u073B\x07\u0111\x02\x02\u073B\u073C\x07!" +
|
|
"\x02\x02\u073C\u0741\x05f4\x02\u073D\u073E\x07\x06\x02\x02\u073E\u0740" +
|
|
"\x05f4\x02\u073F\u073D\x03\x02\x02\x02\u0740\u0743\x03\x02\x02\x02\u0741" +
|
|
"\u073F\x03\x02\x02\x02\u0741\u0742\x03\x02\x02\x02\u0742\u0745\x03\x02" +
|
|
"\x02\x02\u0743\u0741\x03\x02\x02\x02\u0744\u073A\x03\x02\x02\x02\u0744" +
|
|
"\u0745\x03\x02\x02\x02\u0745\u0747\x03\x02\x02\x02\u0746\u0748\x05\u0156" +
|
|
"\xAC\x02\u0747\u0746\x03\x02\x02\x02\u0747\u0748\x03\x02\x02\x02\u0748" +
|
|
"\u074E\x03\x02\x02\x02\u0749\u074C\x07\xA4\x02\x02\u074A\u074D\x07\f\x02" +
|
|
"\x02\u074B\u074D\x05\u0106\x84\x02\u074C\u074A\x03\x02\x02\x02\u074C\u074B" +
|
|
"\x03\x02\x02\x02\u074D\u074F\x03\x02\x02\x02\u074E\u0749\x03\x02\x02\x02" +
|
|
"\u074E\u074F\x03\x02\x02\x02\u074F\u0752\x03\x02\x02\x02\u0750\u0751\x07" +
|
|
"\xC7\x02\x02\u0751\u0753\x05\u0106\x84\x02\u0752\u0750\x03\x02\x02\x02" +
|
|
"\u0752\u0753\x03\x02\x02\x02\u0753_\x03\x02\x02\x02\u0754\u0755\x05\x1E" +
|
|
"\x10\x02\u0755\u0756\x05j6\x02\u0756a\x03\x02\x02\x02\u0757\u0758\b2\x01" +
|
|
"\x02\u0758\u0759\x05d3\x02\u0759\u0771\x03\x02\x02\x02\u075A\u075B\f\x05" +
|
|
"\x02\x02\u075B\u075C\x062\x03\x02\u075C\u075E\t\x0F\x02\x02\u075D\u075F" +
|
|
"\x05\xBE`\x02\u075E\u075D\x03\x02\x02\x02\u075E\u075F\x03\x02\x02\x02" +
|
|
"\u075F\u0760\x03\x02\x02\x02\u0760\u0770\x05b2\x06\u0761\u0762\f\x04\x02" +
|
|
"\x02\u0762\u0763\x062\x05\x02\u0763\u0765\x07\x94\x02\x02\u0764\u0766" +
|
|
"\x05\xBE`\x02\u0765\u0764\x03\x02\x02\x02\u0765\u0766\x03\x02\x02\x02" +
|
|
"\u0766\u0767\x03\x02\x02\x02\u0767\u0770\x05b2\x05\u0768\u0769\f\x03\x02" +
|
|
"\x02\u0769\u076A\x062\x07\x02\u076A\u076C\t\x10\x02\x02\u076B\u076D\x05" +
|
|
"\xBE`\x02\u076C\u076B\x03\x02\x02\x02\u076C\u076D\x03\x02\x02\x02\u076D" +
|
|
"\u076E\x03\x02\x02\x02\u076E\u0770\x05b2\x04\u076F\u075A\x03\x02\x02\x02" +
|
|
"\u076F\u0761\x03\x02\x02\x02\u076F\u0768\x03\x02\x02\x02\u0770\u0773\x03" +
|
|
"\x02\x02\x02\u0771\u076F\x03\x02\x02\x02\u0771\u0772\x03\x02\x02\x02\u0772" +
|
|
"c\x03\x02\x02\x02\u0773\u0771\x03\x02\x02\x02\u0774\u077E\x05l7\x02\u0775" +
|
|
"\u077E\x05h5\x02\u0776\u0777\x07\u0120\x02\x02\u0777\u077E\x05V,\x02\u0778" +
|
|
"\u077E\x05\xDCo\x02\u0779\u077A\x07\x04\x02\x02\u077A\u077B\x05\x1C\x0F" +
|
|
"\x02\u077B\u077C\x07\x05\x02\x02\u077C\u077E\x03\x02\x02\x02\u077D\u0774" +
|
|
"\x03\x02\x02\x02\u077D\u0775\x03\x02\x02\x02\u077D\u0776\x03\x02\x02\x02" +
|
|
"\u077D\u0778\x03\x02\x02\x02\u077D\u0779\x03\x02\x02\x02\u077Ee\x03\x02" +
|
|
"\x02\x02\u077F\u0781\x05\u0106\x84\x02\u0780\u0782\t\x11\x02\x02\u0781" +
|
|
"\u0780\x03\x02\x02\x02\u0781\u0782\x03\x02\x02\x02\u0782\u0785\x03\x02" +
|
|
"\x02\x02\u0783\u0784\x07\xC4\x02\x02\u0784\u0786\t\x12\x02\x02\u0785\u0783" +
|
|
"\x03\x02\x02\x02\u0785\u0786\x03\x02\x02\x02\u0786g\x03\x02\x02\x02\u0787" +
|
|
"\u0789\x05\x8CG\x02\u0788\u078A\x05j6\x02\u0789\u0788\x03\x02\x02\x02" +
|
|
"\u078A\u078B\x03\x02\x02\x02\u078B\u0789\x03\x02\x02\x02\u078B\u078C\x03" +
|
|
"\x02\x02\x02\u078Ci\x03\x02\x02\x02\u078D\u078F\x05n8\x02\u078E\u0790" +
|
|
"\x05\x84C\x02\u078F\u078E\x03\x02\x02\x02\u078F\u0790\x03\x02\x02\x02" +
|
|
"\u0790\u0791\x03\x02\x02\x02\u0791\u0792\x05^0\x02\u0792\u07A9\x03\x02" +
|
|
"\x02\x02\u0793\u0797\x05p9\x02\u0794\u0796\x05\xBC_\x02\u0795\u0794\x03" +
|
|
"\x02\x02\x02\u0796\u0799\x03\x02\x02\x02\u0797\u0795\x03\x02\x02\x02\u0797" +
|
|
"\u0798\x03\x02\x02\x02\u0798\u079B\x03\x02\x02\x02\u0799\u0797\x03\x02" +
|
|
"\x02\x02\u079A\u079C\x05\x84C\x02\u079B\u079A\x03\x02\x02\x02\u079B\u079C" +
|
|
"\x03\x02\x02\x02\u079C\u079E\x03\x02\x02\x02\u079D\u079F\x05\x92J\x02" +
|
|
"\u079E\u079D\x03\x02\x02\x02\u079E\u079F\x03\x02\x02\x02\u079F\u07A1\x03" +
|
|
"\x02\x02\x02\u07A0\u07A2\x05\x86D\x02\u07A1\u07A0\x03\x02\x02\x02\u07A1" +
|
|
"\u07A2\x03\x02\x02\x02\u07A2\u07A4\x03\x02\x02\x02\u07A3\u07A5\x05\u0156" +
|
|
"\xAC\x02\u07A4\u07A3\x03\x02\x02\x02\u07A4\u07A5\x03\x02\x02\x02\u07A5" +
|
|
"\u07A6\x03\x02\x02\x02\u07A6\u07A7\x05^0\x02\u07A7\u07A9\x03\x02\x02\x02" +
|
|
"\u07A8\u078D\x03\x02\x02\x02\u07A8\u0793\x03\x02\x02\x02\u07A9k\x03\x02" +
|
|
"\x02\x02\u07AA\u07AC\x05n8\x02\u07AB\u07AD\x05\x8CG\x02\u07AC\u07AB\x03" +
|
|
"\x02\x02\x02\u07AC\u07AD\x03\x02\x02\x02\u07AD\u07B1\x03\x02\x02\x02\u07AE" +
|
|
"\u07B0\x05\xBC_\x02\u07AF\u07AE\x03\x02\x02\x02\u07B0\u07B3\x03\x02\x02" +
|
|
"\x02\u07B1\u07AF\x03\x02\x02\x02\u07B1\u07B2\x03\x02\x02\x02\u07B2\u07B5" +
|
|
"\x03\x02\x02\x02\u07B3\u07B1\x03\x02\x02\x02\u07B4\u07B6\x05\x84C\x02" +
|
|
"\u07B5\u07B4\x03\x02\x02\x02\u07B5\u07B6\x03\x02\x02\x02\u07B6\u07B8\x03" +
|
|
"\x02\x02\x02\u07B7\u07B9\x05\x92J\x02\u07B8\u07B7\x03\x02\x02\x02\u07B8" +
|
|
"\u07B9\x03\x02\x02\x02\u07B9\u07BB\x03\x02\x02\x02\u07BA\u07BC\x05\x86" +
|
|
"D\x02\u07BB\u07BA\x03\x02\x02\x02\u07BB\u07BC\x03\x02\x02\x02\u07BC\u07BE" +
|
|
"\x03\x02\x02\x02\u07BD\u07BF\x05\u0156\xAC\x02\u07BE\u07BD\x03\x02\x02" +
|
|
"\x02\u07BE\u07BF\x03\x02\x02\x02\u07BF\u07D7\x03\x02\x02\x02\u07C0\u07C2" +
|
|
"\x05p9\x02\u07C1\u07C3\x05\x8CG\x02\u07C2\u07C1\x03\x02\x02\x02\u07C2" +
|
|
"\u07C3\x03\x02\x02\x02\u07C3\u07C7\x03\x02\x02\x02\u07C4\u07C6\x05\xBC" +
|
|
"_\x02\u07C5\u07C4\x03\x02\x02\x02\u07C6\u07C9\x03\x02\x02\x02\u07C7\u07C5" +
|
|
"\x03\x02\x02\x02\u07C7\u07C8\x03\x02\x02\x02\u07C8\u07CB\x03\x02\x02\x02" +
|
|
"\u07C9\u07C7\x03\x02\x02\x02\u07CA\u07CC\x05\x84C\x02\u07CB\u07CA\x03" +
|
|
"\x02\x02\x02\u07CB\u07CC\x03\x02\x02\x02\u07CC\u07CE\x03\x02\x02\x02\u07CD" +
|
|
"\u07CF\x05\x92J\x02\u07CE\u07CD\x03\x02\x02\x02\u07CE\u07CF\x03\x02\x02" +
|
|
"\x02\u07CF\u07D1\x03\x02\x02\x02\u07D0\u07D2\x05\x86D\x02\u07D1\u07D0" +
|
|
"\x03\x02\x02\x02\u07D1\u07D2\x03\x02\x02\x02\u07D2\u07D4\x03\x02\x02\x02" +
|
|
"\u07D3\u07D5\x05\u0156\xAC\x02\u07D4\u07D3\x03\x02\x02\x02\u07D4\u07D5" +
|
|
"\x03\x02\x02\x02\u07D5\u07D7\x03\x02\x02\x02\u07D6\u07AA\x03\x02\x02\x02" +
|
|
"\u07D6\u07C0\x03\x02\x02\x02\u07D7m\x03\x02\x02\x02\u07D8\u07D9\x07\u0102" +
|
|
"\x02\x02\u07D9\u07DA\x07\u0135\x02\x02\u07DA\u07DC\x07\x04\x02\x02\u07DB" +
|
|
"\u07DD\x05\xBE`\x02\u07DC\u07DB\x03\x02\x02\x02\u07DC\u07DD\x03\x02\x02" +
|
|
"\x02\u07DD\u07DE\x03\x02\x02\x02\u07DE\u07DF\x05\u010C\x87\x02\u07DF\u07E0" +
|
|
"\x07\x05\x02\x02\u07E0\u07EC\x03\x02\x02\x02\u07E1\u07E3\x07\xAF\x02\x02" +
|
|
"\u07E2\u07E4\x05\xBE`\x02\u07E3\u07E2\x03\x02\x02\x02\u07E3\u07E4\x03" +
|
|
"\x02\x02\x02\u07E4\u07E5\x03\x02\x02\x02\u07E5\u07EC\x05\u010C\x87\x02" +
|
|
"\u07E6\u07E8\x07\xEA\x02\x02\u07E7\u07E9\x05\xBE`\x02\u07E8\u07E7\x03" +
|
|
"\x02\x02\x02\u07E8\u07E9\x03\x02\x02\x02\u07E9\u07EA\x03\x02\x02\x02\u07EA" +
|
|
"\u07EC\x05\u010C\x87\x02\u07EB\u07D8\x03\x02\x02\x02\u07EB\u07E1\x03\x02" +
|
|
"\x02\x02\u07EB\u07E6\x03\x02\x02\x02\u07EC\u07EE\x03\x02\x02\x02\u07ED" +
|
|
"\u07EF\x05\xECw\x02\u07EE\u07ED\x03\x02\x02\x02\u07EE\u07EF\x03\x02\x02" +
|
|
"\x02\u07EF\u07F2\x03\x02\x02\x02\u07F0\u07F1\x07\xE8\x02\x02\u07F1\u07F3" +
|
|
"\x05\u0178\xBD\x02\u07F2\u07F0\x03\x02\x02\x02\u07F2\u07F3\x03\x02\x02" +
|
|
"\x02\u07F3\u07F4\x03\x02\x02\x02\u07F4\u07F5\x07\u0147\x02\x02\u07F5\u0802" +
|
|
"\x05\u0178\xBD\x02\u07F6\u0800\x07\x16\x02\x02\u07F7\u0801\x05\xD0i\x02" +
|
|
"\u07F8\u0801\x05\u0144\xA3\x02\u07F9\u07FC\x07\x04\x02\x02\u07FA\u07FD" +
|
|
"\x05\xD0i\x02\u07FB\u07FD\x05\u0144\xA3\x02\u07FC\u07FA\x03\x02\x02\x02" +
|
|
"\u07FC\u07FB\x03\x02\x02\x02\u07FD\u07FE\x03\x02\x02\x02\u07FE\u07FF\x07" +
|
|
"\x05\x02\x02\u07FF\u0801\x03\x02\x02\x02\u0800\u07F7\x03\x02\x02\x02\u0800" +
|
|
"\u07F8\x03\x02\x02\x02\u0800\u07F9\x03\x02\x02\x02\u0801\u0803\x03\x02" +
|
|
"\x02\x02\u0802\u07F6\x03\x02\x02\x02\u0802\u0803\x03\x02\x02\x02\u0803" +
|
|
"\u0805\x03\x02\x02\x02\u0804\u0806\x05\xECw\x02\u0805\u0804\x03\x02\x02" +
|
|
"\x02\u0805\u0806\x03\x02\x02\x02\u0806\u0809\x03\x02\x02\x02\u0807\u0808" +
|
|
"\x07\xE7\x02\x02\u0808\u080A\x05\u0178\xBD\x02\u0809\u0807\x03\x02\x02" +
|
|
"\x02\u0809\u080A\x03\x02\x02\x02\u080Ao\x03\x02\x02\x02\u080B\u080F\x07" +
|
|
"\u0102\x02\x02\u080C\u080E\x05\x88E\x02\u080D\u080C\x03\x02\x02\x02\u080E" +
|
|
"\u0811\x03\x02\x02\x02\u080F\u080D\x03\x02\x02\x02\u080F\u0810\x03\x02" +
|
|
"\x02\x02\u0810\u0813\x03\x02\x02\x02\u0811\u080F\x03\x02\x02\x02\u0812" +
|
|
"\u0814\x05\xBE`\x02\u0813\u0812\x03\x02\x02\x02\u0813\u0814\x03\x02\x02" +
|
|
"\x02\u0814\u0815\x03\x02\x02\x02\u0815\u0816\x05\xFC\x7F\x02\u0816q\x03" +
|
|
"\x02\x02\x02\u0817\u0818\x07\u0108\x02\x02\u0818\u0819\x05\x80A\x02\u0819" +
|
|
"s\x03\x02\x02\x02\u081A\u081B\x07\u0152\x02\x02\u081B\u081E\x07\xB0\x02" +
|
|
"\x02\u081C\u081D\x07\x10\x02\x02\u081D\u081F\x05\u010E\x88\x02\u081E\u081C" +
|
|
"\x03\x02\x02\x02\u081E\u081F\x03\x02\x02\x02\u081F\u0820\x03\x02\x02\x02" +
|
|
"\u0820\u0821\x07\u0127\x02\x02\u0821\u0822\x05z>\x02\u0822u\x03\x02\x02" +
|
|
"\x02\u0823\u0824\x07\u0152\x02\x02\u0824\u0825\x07\xC2\x02\x02\u0825\u0828" +
|
|
"\x07\xB0\x02\x02\u0826\u0827\x07!\x02\x02\u0827\u0829\x07\u0123\x02\x02" +
|
|
"\u0828\u0826\x03\x02\x02\x02\u0828\u0829\x03\x02\x02\x02\u0829\u082C\x03" +
|
|
"\x02\x02\x02\u082A\u082B\x07\x10\x02\x02\u082B\u082D\x05\u010E\x88\x02" +
|
|
"\u082C\u082A\x03\x02\x02\x02\u082C\u082D\x03\x02\x02\x02\u082D\u082E\x03" +
|
|
"\x02\x02\x02\u082E\u082F\x07\u0127\x02\x02\u082F\u0830\x05|?\x02\u0830" +
|
|
"w\x03\x02\x02\x02\u0831\u0832\x07\u0152\x02\x02\u0832\u0833\x07\xC2\x02" +
|
|
"\x02\u0833\u0834\x07\xB0\x02\x02\u0834\u0835\x07!\x02\x02\u0835\u0838" +
|
|
"\x07\u0113\x02\x02\u0836\u0837\x07\x10\x02\x02\u0837\u0839\x05\u010E\x88" +
|
|
"\x02\u0838\u0836\x03\x02\x02\x02\u0838\u0839\x03\x02\x02\x02\u0839\u083A" +
|
|
"\x03\x02\x02\x02\u083A\u083B\x07\u0127\x02\x02\u083B\u083C\x05~@\x02\u083C" +
|
|
"y\x03\x02\x02\x02\u083D\u0845\x07V\x02\x02\u083E\u083F\x07\u0144\x02\x02" +
|
|
"\u083F\u0840\x07\u0108\x02\x02\u0840\u0845\x07\u0165\x02\x02\u0841\u0842" +
|
|
"\x07\u0144\x02\x02\u0842\u0843\x07\u0108\x02\x02\u0843\u0845\x05\x80A" +
|
|
"\x02\u0844\u083D\x03\x02\x02\x02\u0844\u083E\x03\x02\x02\x02\u0844\u0841" +
|
|
"\x03\x02\x02\x02\u0845{\x03\x02\x02\x02\u0846\u0847\x07\x93\x02\x02\u0847" +
|
|
"\u0859\x07\u0165\x02\x02\u0848\u0849\x07\x93\x02\x02\u0849\u084A\x07\x04" +
|
|
"\x02\x02\u084A\u084B\x05\xEEx\x02\u084B\u084C\x07\x05\x02\x02\u084C\u084D" +
|
|
"\x07\u0148\x02\x02\u084D\u084E\x07\x04\x02\x02\u084E\u0853\x05\u0106\x84" +
|
|
"\x02\u084F\u0850\x07\x06\x02\x02\u0850\u0852\x05\u0106\x84\x02\u0851\u084F" +
|
|
"\x03\x02\x02\x02\u0852\u0855\x03\x02\x02\x02\u0853\u0851\x03\x02\x02\x02" +
|
|
"\u0853\u0854\x03\x02\x02\x02\u0854\u0856\x03\x02\x02\x02\u0855\u0853\x03" +
|
|
"\x02\x02\x02\u0856\u0857\x07\x05\x02\x02\u0857\u0859\x03\x02\x02\x02\u0858" +
|
|
"\u0846\x03\x02\x02\x02\u0858\u0848\x03\x02\x02\x02\u0859}\x03\x02\x02" +
|
|
"\x02\u085A\u085F\x07V\x02\x02\u085B\u085C\x07\u0144\x02\x02\u085C\u085D" +
|
|
"\x07\u0108\x02\x02\u085D\u085F\x05\x80A\x02\u085E\u085A\x03\x02\x02\x02" +
|
|
"\u085E\u085B\x03\x02\x02\x02\u085F\x7F\x03\x02\x02\x02\u0860\u0865\x05" +
|
|
"\x82B\x02\u0861\u0862\x07\x06\x02\x02\u0862\u0864\x05\x82B\x02\u0863\u0861" +
|
|
"\x03\x02\x02\x02\u0864\u0867\x03\x02\x02\x02\u0865\u0863\x03\x02\x02\x02" +
|
|
"\u0865\u0866\x03\x02\x02\x02\u0866\x81\x03\x02\x02\x02\u0867\u0865\x03" +
|
|
"\x02\x02\x02\u0868\u0869\x05\xF0y\x02\u0869\u086A\x07\u015A\x02\x02\u086A" +
|
|
"\u086B\x05\u0106\x84\x02\u086B\x83\x03\x02\x02\x02\u086C\u086D\x07\u0153" +
|
|
"\x02\x02\u086D\u086E\x05\u010E\x88\x02\u086E\x85\x03\x02\x02\x02\u086F" +
|
|
"\u0870\x07\x84\x02\x02\u0870\u0871\x05\u010E\x88\x02\u0871\x87\x03\x02" +
|
|
"\x02\x02\u0872\u0873\x07\u0170\x02\x02\u0873\u087A\x05\x8AF\x02\u0874" +
|
|
"\u0876\x07\x06\x02\x02\u0875\u0874\x03\x02\x02\x02\u0875\u0876\x03\x02" +
|
|
"\x02\x02\u0876\u0877\x03\x02\x02\x02\u0877\u0879\x05\x8AF\x02\u0878\u0875" +
|
|
"\x03\x02\x02\x02\u0879\u087C\x03\x02\x02\x02\u087A\u0878\x03\x02\x02\x02" +
|
|
"\u087A\u087B\x03\x02\x02\x02\u087B\u087D\x03\x02\x02\x02\u087C\u087A\x03" +
|
|
"\x02\x02\x02\u087D\u087E\x07\u0171\x02\x02\u087E\x89\x03\x02\x02\x02\u087F" +
|
|
"\u088D\x05\u016C\xB7\x02\u0880\u0881\x05\u016C\xB7\x02\u0881\u0882\x07" +
|
|
"\x04\x02\x02\u0882\u0887\x05\u0116\x8C\x02\u0883\u0884\x07\x06\x02\x02" +
|
|
"\u0884\u0886\x05\u0116\x8C\x02\u0885\u0883\x03\x02\x02\x02\u0886\u0889" +
|
|
"\x03\x02\x02\x02\u0887\u0885\x03\x02\x02\x02\u0887\u0888\x03\x02\x02\x02" +
|
|
"\u0888\u088A\x03\x02\x02\x02\u0889\u0887\x03\x02\x02\x02\u088A\u088B\x07" +
|
|
"\x05\x02\x02\u088B\u088D\x03\x02\x02\x02\u088C\u087F\x03\x02\x02\x02\u088C" +
|
|
"\u0880\x03\x02\x02\x02\u088D\x8B\x03\x02\x02\x02\u088E\u088F\x07{\x02" +
|
|
"\x02\u088F\u0894\x05\xC0a\x02\u0890\u0891\x07\x06\x02\x02\u0891\u0893" +
|
|
"\x05\xC0a\x02\u0892\u0890\x03\x02\x02\x02\u0893\u0896\x03\x02\x02\x02" +
|
|
"\u0894\u0892\x03\x02\x02\x02\u0894\u0895\x03\x02\x02\x02\u0895\u089A\x03" +
|
|
"\x02\x02\x02\u0896\u0894\x03\x02\x02\x02\u0897\u0899\x05\xBC_\x02\u0898" +
|
|
"\u0897\x03\x02\x02\x02\u0899\u089C\x03\x02\x02\x02\u089A\u0898\x03\x02" +
|
|
"\x02\x02\u089A\u089B\x03\x02\x02\x02\u089B\u089E\x03\x02\x02\x02\u089C" +
|
|
"\u089A\x03\x02\x02\x02\u089D\u089F\x05\x9CO\x02\u089E\u089D\x03\x02\x02" +
|
|
"\x02\u089E\u089F\x03\x02\x02\x02\u089F\u08A1\x03\x02\x02\x02\u08A0\u08A2" +
|
|
"\x05\xA2R\x02\u08A1\u08A0\x03\x02\x02\x02\u08A1\u08A2\x03\x02\x02\x02" +
|
|
"\u08A2\x8D\x03\x02\x02\x02\u08A3\u08A4\t\x13\x02\x02\u08A4\x8F\x03\x02" +
|
|
"\x02\x02\u08A5\u08A7\x07w\x02\x02\u08A6\u08A5\x03\x02\x02\x02\u08A6\u08A7" +
|
|
"\x03\x02\x02\x02\u08A7\u08A8\x03\x02\x02\x02\u08A8\u08A9\t\x14\x02\x02" +
|
|
"\u08A9\u08AA\x07\x16\x02\x02\u08AA\u08AB\x07\xC6\x02\x02\u08AB\u08B4\x05" +
|
|
"\u017C\xBF\x02\u08AC\u08AE\x07w\x02\x02\u08AD\u08AC\x03\x02\x02\x02\u08AD" +
|
|
"\u08AE\x03\x02\x02\x02\u08AE\u08AF\x03\x02\x02\x02\u08AF\u08B0\t\x15\x02" +
|
|
"\x02\u08B0\u08B1\x07\x16\x02\x02\u08B1\u08B2\x07\xC6\x02\x02\u08B2\u08B4" +
|
|
"\x05\u0112\x8A\x02\u08B3\u08A6\x03\x02\x02\x02\u08B3\u08AD\x03\x02\x02" +
|
|
"\x02\u08B4\x91\x03\x02\x02\x02\u08B5\u08B6\x07\x82\x02\x02\u08B6\u08B7" +
|
|
"\x07!\x02\x02\u08B7\u08BC\x05\x94K\x02\u08B8\u08B9\x07\x06\x02\x02\u08B9" +
|
|
"\u08BB\x05\x94K\x02\u08BA\u08B8\x03\x02\x02\x02\u08BB\u08BE\x03\x02\x02" +
|
|
"\x02\u08BC\u08BA\x03\x02\x02\x02\u08BC\u08BD\x03\x02\x02\x02\u08BD\u08DD" +
|
|
"\x03\x02\x02\x02\u08BE\u08BC\x03\x02\x02\x02\u08BF\u08C0\x07\x82\x02\x02" +
|
|
"\u08C0\u08C1\x07!\x02\x02\u08C1\u08C6\x05\u0106\x84\x02\u08C2\u08C3\x07" +
|
|
"\x06\x02\x02\u08C3\u08C5\x05\u0106\x84\x02\u08C4\u08C2\x03\x02\x02\x02" +
|
|
"\u08C5\u08C8\x03\x02\x02\x02\u08C6\u08C4\x03\x02\x02\x02\u08C6\u08C7\x03" +
|
|
"\x02\x02\x02\u08C7\u08DA\x03\x02\x02\x02\u08C8\u08C6\x03\x02\x02\x02\u08C9" +
|
|
"\u08CA\x07\u0155\x02\x02\u08CA\u08DB\x07\xFB\x02\x02\u08CB\u08CC\x07\u0155" +
|
|
"\x02\x02\u08CC\u08DB\x07?\x02\x02\u08CD\u08CE\x07\x83\x02\x02\u08CE\u08CF" +
|
|
"\x07\u010A\x02\x02\u08CF\u08D0\x07\x04\x02\x02\u08D0\u08D5\x05\x9AN\x02" +
|
|
"\u08D1\u08D2\x07\x06\x02\x02\u08D2\u08D4\x05\x9AN\x02\u08D3\u08D1\x03" +
|
|
"\x02\x02\x02\u08D4\u08D7\x03\x02\x02\x02\u08D5\u08D3\x03\x02\x02\x02\u08D5" +
|
|
"\u08D6\x03\x02\x02\x02\u08D6\u08D8\x03\x02\x02\x02\u08D7\u08D5\x03\x02" +
|
|
"\x02\x02\u08D8\u08D9\x07\x05\x02\x02\u08D9\u08DB\x03\x02\x02\x02\u08DA" +
|
|
"\u08C9\x03\x02\x02\x02\u08DA\u08CB\x03\x02\x02\x02\u08DA\u08CD\x03\x02" +
|
|
"\x02\x02\u08DA\u08DB\x03\x02\x02\x02\u08DB\u08DD\x03\x02\x02\x02\u08DC" +
|
|
"\u08B5\x03\x02\x02\x02\u08DC\u08BF\x03\x02\x02\x02\u08DD\x93\x03\x02\x02" +
|
|
"\x02\u08DE\u08E1\x05\x96L\x02\u08DF\u08E1\x05\u0106\x84\x02\u08E0\u08DE" +
|
|
"\x03\x02\x02\x02\u08E0\u08DF\x03\x02\x02\x02\u08E1\x95\x03\x02\x02\x02" +
|
|
"\u08E2\u08E3\t\x16\x02\x02\u08E3\u08E4\x07\x04\x02\x02\u08E4\u08E9\x05" +
|
|
"\x9AN\x02\u08E5\u08E6\x07\x06\x02\x02\u08E6\u08E8\x05\x9AN\x02\u08E7\u08E5" +
|
|
"\x03\x02\x02\x02\u08E8\u08EB\x03\x02\x02\x02\u08E9\u08E7\x03\x02\x02\x02" +
|
|
"\u08E9\u08EA\x03\x02\x02\x02\u08EA\u08EC\x03\x02\x02\x02\u08EB\u08E9\x03" +
|
|
"\x02\x02\x02\u08EC\u08ED\x07\x05\x02\x02\u08ED\u08FC\x03\x02\x02\x02\u08EE" +
|
|
"\u08EF\x07\x83\x02\x02\u08EF\u08F0\x07\u010A\x02\x02\u08F0\u08F1\x07\x04" +
|
|
"\x02\x02\u08F1\u08F6\x05\x98M\x02\u08F2\u08F3\x07\x06\x02\x02\u08F3\u08F5" +
|
|
"\x05\x98M\x02\u08F4\u08F2\x03\x02\x02\x02\u08F5\u08F8\x03\x02\x02\x02" +
|
|
"\u08F6\u08F4\x03\x02\x02\x02\u08F6\u08F7\x03\x02\x02\x02\u08F7\u08F9\x03" +
|
|
"\x02\x02\x02\u08F8\u08F6\x03\x02\x02\x02\u08F9\u08FA\x07\x05\x02\x02\u08FA" +
|
|
"\u08FC\x03\x02\x02\x02\u08FB\u08E2\x03\x02\x02\x02\u08FB\u08EE\x03\x02" +
|
|
"\x02\x02\u08FC\x97\x03\x02\x02\x02\u08FD\u0900\x05\x96L\x02\u08FE\u0900" +
|
|
"\x05\x9AN\x02\u08FF\u08FD\x03\x02\x02\x02\u08FF\u08FE\x03\x02\x02\x02" +
|
|
"\u0900\x99\x03\x02\x02\x02\u0901\u090A\x07\x04\x02\x02\u0902\u0907\x05" +
|
|
"\u0106\x84\x02\u0903\u0904\x07\x06\x02\x02\u0904\u0906\x05\u0106\x84\x02" +
|
|
"\u0905\u0903\x03\x02\x02\x02\u0906\u0909\x03\x02\x02\x02\u0907\u0905\x03" +
|
|
"\x02\x02\x02\u0907\u0908\x03\x02\x02\x02\u0908\u090B\x03\x02\x02\x02\u0909" +
|
|
"\u0907\x03\x02\x02\x02\u090A\u0902\x03\x02\x02\x02\u090A\u090B\x03\x02" +
|
|
"\x02\x02\u090B\u090C\x03\x02\x02\x02\u090C\u090F\x07\x05\x02\x02\u090D" +
|
|
"\u090F\x05\u0106\x84\x02\u090E\u0901\x03\x02\x02\x02\u090E\u090D\x03\x02" +
|
|
"\x02\x02\u090F\x9B\x03\x02\x02\x02\u0910\u0911\x07\xDB\x02\x02\u0911\u0912" +
|
|
"\x07\x04\x02\x02\u0912\u0913\x05\xFC\x7F\x02\u0913\u0914\x07w\x02\x02" +
|
|
"\u0914\u0915\x05\x9EP\x02\u0915\u0916\x07\x8C\x02\x02\u0916\u0917\x07" +
|
|
"\x04\x02\x02\u0917\u091C\x05\xA0Q\x02\u0918\u0919\x07\x06\x02\x02\u0919" +
|
|
"\u091B\x05\xA0Q\x02\u091A\u0918\x03\x02\x02\x02\u091B\u091E\x03\x02\x02" +
|
|
"\x02\u091C\u091A\x03\x02\x02\x02\u091C\u091D\x03\x02\x02\x02\u091D\u091F" +
|
|
"\x03\x02\x02\x02\u091E\u091C\x03\x02\x02\x02\u091F\u0920\x07\x05\x02\x02" +
|
|
"\u0920\u0921\x07\x05\x02\x02\u0921\x9D\x03\x02\x02\x02\u0922\u092F\x05" +
|
|
"\u016C\xB7\x02\u0923\u0924\x07\x04\x02\x02\u0924\u0929\x05\u016C\xB7\x02" +
|
|
"\u0925\u0926\x07\x06\x02\x02\u0926\u0928\x05\u016C\xB7\x02\u0927\u0925" +
|
|
"\x03\x02\x02\x02\u0928\u092B\x03\x02\x02\x02\u0929\u0927\x03\x02\x02\x02" +
|
|
"\u0929\u092A\x03\x02\x02\x02\u092A\u092C\x03\x02\x02\x02\u092B\u0929\x03" +
|
|
"\x02\x02\x02\u092C\u092D\x07\x05\x02\x02\u092D\u092F\x03\x02\x02\x02\u092E" +
|
|
"\u0922\x03\x02\x02\x02\u092E\u0923\x03\x02\x02\x02\u092F\x9F\x03\x02\x02" +
|
|
"\x02\u0930\u0935\x05\u0106\x84\x02\u0931\u0933\x07\x16\x02\x02\u0932\u0931" +
|
|
"\x03\x02\x02\x02\u0932\u0933\x03\x02\x02\x02\u0933\u0934\x03\x02\x02\x02" +
|
|
"\u0934\u0936\x05\u016C\xB7\x02\u0935\u0932\x03\x02\x02\x02\u0935\u0936" +
|
|
"\x03\x02\x02\x02\u0936\xA1\x03\x02\x02\x02\u0937\u0939\x07\u0142\x02\x02" +
|
|
"\u0938\u093A\x05\xA4S\x02\u0939\u0938\x03\x02\x02\x02\u0939\u093A\x03" +
|
|
"\x02\x02\x02\u093A\u093B\x03\x02\x02\x02\u093B\u093C\x07\x04\x02\x02\u093C" +
|
|
"\u093D\x05\xA6T\x02\u093D\u0942\x07\x05\x02";
|
|
private static readonly _serializedATNSegment5: string =
|
|
"\x02\u093E\u0940\x07\x16\x02\x02\u093F\u093E\x03\x02\x02\x02\u093F\u0940" +
|
|
"\x03\x02\x02\x02\u0940\u0941\x03\x02\x02\x02\u0941\u0943\x05\u016C\xB7" +
|
|
"\x02\u0942\u093F\x03\x02\x02\x02\u0942\u0943\x03\x02\x02\x02\u0943\xA3" +
|
|
"\x03\x02\x02\x02\u0944\u0945\t\x17\x02\x02\u0945\u0946\x07\xC4\x02\x02" +
|
|
"\u0946\xA5\x03\x02\x02\x02\u0947\u094A\x05\xA8U\x02\u0948\u094A\x05\xAA" +
|
|
"V\x02\u0949\u0947\x03\x02\x02\x02\u0949\u0948\x03\x02\x02\x02\u094A\xA7" +
|
|
"\x03\x02\x02\x02\u094B\u094C\x05\xAEX\x02\u094C\u094D\x07w\x02\x02\u094D" +
|
|
"\u094E\x05\xB0Y\x02\u094E\u094F\x07\x8C\x02\x02\u094F\u0950\x07\x04\x02" +
|
|
"\x02\u0950\u0955\x05\xB2Z\x02\u0951\u0952\x07\x06\x02\x02\u0952\u0954" +
|
|
"\x05\xB2Z\x02\u0953\u0951\x03\x02\x02\x02\u0954\u0957\x03\x02\x02\x02" +
|
|
"\u0955\u0953\x03\x02\x02\x02\u0955\u0956\x03\x02\x02\x02\u0956\u0958\x03" +
|
|
"\x02\x02\x02\u0957\u0955\x03\x02\x02\x02\u0958\u0959\x07\x05\x02\x02\u0959" +
|
|
"\xA9\x03\x02\x02\x02\u095A\u095B\x07\x04\x02\x02\u095B\u0960\x05\xAEX" +
|
|
"\x02\u095C\u095D\x07\x06\x02\x02\u095D\u095F\x05\xAEX\x02\u095E\u095C" +
|
|
"\x03\x02\x02\x02\u095F\u0962\x03\x02\x02\x02\u0960\u095E\x03\x02\x02\x02" +
|
|
"\u0960\u0961\x03\x02\x02\x02\u0961\u0963\x03\x02\x02\x02\u0962\u0960\x03" +
|
|
"\x02\x02\x02\u0963\u0964\x07\x05\x02\x02\u0964\u0965\x07w\x02\x02\u0965" +
|
|
"\u0966\x05\xB0Y\x02\u0966\u0967\x07\x8C\x02\x02\u0967\u0968\x07\x04\x02" +
|
|
"\x02\u0968\u096D\x05\xACW\x02\u0969\u096A\x07\x06\x02\x02\u096A\u096C" +
|
|
"\x05\xACW\x02\u096B\u0969\x03\x02\x02\x02\u096C\u096F\x03\x02\x02\x02" +
|
|
"\u096D\u096B\x03\x02\x02\x02\u096D\u096E\x03\x02\x02\x02\u096E\u0970\x03" +
|
|
"\x02\x02\x02\u096F\u096D\x03\x02\x02\x02\u0970\u0971\x07\x05\x02\x02\u0971" +
|
|
"\xAB\x03\x02\x02\x02\u0972\u0973\x07\x04\x02\x02\u0973\u0978\x05\xB4[" +
|
|
"\x02\u0974\u0975\x07\x06\x02\x02\u0975\u0977\x05\xB4[\x02\u0976\u0974" +
|
|
"\x03\x02\x02\x02\u0977\u097A\x03\x02\x02\x02\u0978\u0976\x03\x02\x02\x02" +
|
|
"\u0978\u0979\x03\x02\x02\x02\u0979\u097B\x03\x02\x02\x02\u097A\u0978\x03" +
|
|
"\x02\x02\x02\u097B\u097D\x07\x05\x02\x02\u097C\u097E\x05\xB6\\\x02\u097D" +
|
|
"\u097C\x03\x02\x02\x02\u097D\u097E\x03\x02\x02\x02\u097E\xAD\x03\x02\x02" +
|
|
"\x02\u097F\u0980\x05\u016C\xB7\x02\u0980\xAF\x03\x02\x02\x02\u0981\u0982" +
|
|
"\x05\u016C\xB7\x02\u0982\xB1\x03\x02\x02\x02\u0983\u0985\x05\xB4[\x02" +
|
|
"\u0984\u0986\x05\xB6\\\x02\u0985\u0984\x03\x02\x02\x02\u0985\u0986\x03" +
|
|
"\x02\x02\x02\u0986\xB3\x03\x02\x02\x02\u0987\u0988\x05\xF0y\x02\u0988" +
|
|
"\xB5\x03\x02\x02\x02\u0989\u098B\x07\x16\x02\x02\u098A\u0989\x03\x02\x02" +
|
|
"\x02\u098A\u098B\x03\x02\x02\x02\u098B\u098C\x03\x02\x02\x02\u098C\u098D" +
|
|
"\x05\u016C\xB7\x02\u098D\xB7\x03\x02\x02\x02\u098E\u098F\x07\x89\x02\x02" +
|
|
"\u098F\u0990\x07\xC2\x02\x02\u0990\u0991\x07i\x02\x02\u0991\xB9\x03\x02" +
|
|
"\x02\x02\u0992\u0993\x07\x89\x02\x02\u0993\u0994\x07i\x02\x02\u0994\xBB" +
|
|
"\x03\x02\x02\x02\u0995\u0996\x07\x9E\x02\x02\u0996\u0998\x07\u014D\x02" +
|
|
"\x02\u0997\u0999\x07\xCF\x02\x02\u0998\u0997\x03\x02\x02\x02\u0998\u0999" +
|
|
"\x03\x02\x02\x02\u0999\u099A\x03\x02\x02\x02\u099A\u099B\x05Z.\x02\u099B" +
|
|
"\u09A4\x07\x04\x02\x02\u099C\u09A1\x05\u0106\x84\x02\u099D\u099E\x07\x06" +
|
|
"\x02\x02\u099E\u09A0\x05\u0106\x84\x02\u099F\u099D\x03\x02\x02\x02\u09A0" +
|
|
"\u09A3\x03\x02\x02\x02\u09A1\u099F\x03\x02\x02\x02\u09A1\u09A2\x03\x02" +
|
|
"\x02\x02\u09A2\u09A5\x03\x02\x02\x02\u09A3\u09A1\x03\x02\x02\x02\u09A4" +
|
|
"\u099C\x03\x02\x02\x02\u09A4\u09A5\x03\x02\x02\x02\u09A5\u09A6\x03\x02" +
|
|
"\x02\x02\u09A6\u09A7\x07\x05\x02\x02\u09A7\u09B3\x05\xEAv\x02\u09A8\u09AA" +
|
|
"\x07\x16\x02\x02\u09A9\u09A8\x03\x02\x02\x02\u09A9\u09AA\x03\x02\x02\x02" +
|
|
"\u09AA\u09AB\x03\x02\x02\x02\u09AB\u09B0\x05\u016C\xB7\x02\u09AC\u09AD" +
|
|
"\x07\x06\x02\x02\u09AD\u09AF\x05\u016C\xB7\x02\u09AE\u09AC\x03\x02\x02" +
|
|
"\x02\u09AF\u09B2\x03\x02\x02\x02\u09B0\u09AE\x03\x02\x02\x02\u09B0\u09B1" +
|
|
"\x03\x02\x02\x02\u09B1\u09B4\x03\x02\x02\x02\u09B2\u09B0\x03\x02\x02\x02" +
|
|
"\u09B3\u09A9\x03\x02\x02\x02\u09B3\u09B4\x03\x02\x02\x02\u09B4\xBD\x03" +
|
|
"\x02\x02\x02\u09B5\u09B6\t\x18\x02\x02\u09B6\xBF\x03\x02\x02\x02\u09B7" +
|
|
"\u09B9\x07\x9E\x02\x02\u09B8\u09B7\x03\x02\x02\x02\u09B8\u09B9\x03\x02" +
|
|
"\x02\x02\u09B9\u09BA\x03\x02\x02\x02\u09BA\u09BE\x05\xDAn\x02\u09BB\u09BD" +
|
|
"\x05\xC2b\x02\u09BC\u09BB\x03\x02\x02\x02\u09BD\u09C0\x03\x02\x02\x02" +
|
|
"\u09BE\u09BC\x03\x02\x02\x02\u09BE\u09BF\x03\x02\x02\x02\u09BF\u09C3\x03" +
|
|
"\x02\x02\x02\u09C0\u09BE\x03\x02\x02\x02\u09C1\u09C3\x05V,\x02\u09C2\u09B8" +
|
|
"\x03\x02\x02\x02\u09C2\u09C1\x03\x02\x02\x02\u09C3\xC1\x03\x02\x02\x02" +
|
|
"\u09C4\u09C8\x05\xC4c\x02\u09C5\u09C8\x05\x9CO\x02\u09C6\u09C8\x05\xA2" +
|
|
"R\x02\u09C7\u09C4\x03\x02\x02\x02\u09C7\u09C5\x03\x02\x02\x02\u09C7\u09C6" +
|
|
"\x03\x02\x02\x02\u09C8\xC3\x03\x02\x02\x02\u09C9\u09CA\x05\xC6d\x02\u09CA" +
|
|
"\u09CC\x07\x9B\x02\x02\u09CB\u09CD\x07\x9E\x02\x02\u09CC\u09CB\x03\x02" +
|
|
"\x02\x02\u09CC\u09CD\x03\x02\x02\x02\u09CD\u09CE\x03\x02\x02\x02\u09CE" +
|
|
"\u09D0\x05\xDAn\x02\u09CF\u09D1\x05\xC8e\x02\u09D0\u09CF\x03\x02\x02\x02" +
|
|
"\u09D0\u09D1\x03\x02\x02\x02\u09D1\u09DB\x03\x02\x02\x02\u09D2\u09D3\x07" +
|
|
"\xC0\x02\x02\u09D3\u09D4\x05\xC6d\x02\u09D4\u09D6\x07\x9B\x02\x02\u09D5" +
|
|
"\u09D7\x07\x9E\x02\x02\u09D6\u09D5\x03\x02\x02\x02\u09D6\u09D7\x03\x02" +
|
|
"\x02\x02\u09D7\u09D8\x03\x02\x02\x02\u09D8\u09D9\x05\xDAn\x02\u09D9\u09DB" +
|
|
"\x03\x02\x02\x02\u09DA\u09C9\x03\x02\x02\x02\u09DA\u09D2\x03\x02\x02\x02" +
|
|
"\u09DB\xC5\x03\x02\x02\x02\u09DC\u09DE\x07\x90\x02\x02\u09DD\u09DC\x03" +
|
|
"\x02\x02\x02\u09DD\u09DE\x03\x02\x02\x02\u09DE\u09F5\x03\x02\x02\x02\u09DF" +
|
|
"\u09F5\x07>\x02\x02\u09E0\u09E2\x07\xA1\x02\x02\u09E1\u09E3\x07\xCF\x02" +
|
|
"\x02\u09E2\u09E1\x03\x02\x02\x02\u09E2\u09E3\x03\x02\x02\x02\u09E3\u09F5" +
|
|
"\x03\x02\x02\x02\u09E4\u09E6\x07\xA1\x02\x02\u09E5\u09E4\x03\x02\x02\x02" +
|
|
"\u09E5\u09E6\x03\x02\x02\x02\u09E6\u09E7\x03\x02\x02\x02\u09E7\u09F5\x07" +
|
|
"\u0103\x02\x02\u09E8\u09EA\x07\xF5\x02\x02\u09E9\u09EB\x07\xCF\x02\x02" +
|
|
"\u09EA\u09E9\x03\x02\x02\x02\u09EA\u09EB\x03\x02\x02\x02\u09EB\u09F5\x03" +
|
|
"\x02\x02\x02\u09EC\u09EE\x07|\x02\x02\u09ED\u09EF\x07\xCF\x02\x02\u09EE" +
|
|
"\u09ED\x03\x02\x02\x02\u09EE\u09EF\x03\x02\x02\x02\u09EF\u09F5\x03\x02" +
|
|
"\x02\x02\u09F0\u09F2\x07\xA1\x02\x02\u09F1\u09F0\x03\x02\x02\x02\u09F1" +
|
|
"\u09F2\x03\x02\x02\x02\u09F2\u09F3\x03\x02\x02\x02\u09F3\u09F5\x07\x11" +
|
|
"\x02\x02\u09F4\u09DD\x03\x02\x02\x02\u09F4\u09DF\x03\x02\x02\x02\u09F4" +
|
|
"\u09E0\x03\x02\x02\x02\u09F4\u09E5\x03\x02\x02\x02\u09F4\u09E8\x03\x02" +
|
|
"\x02\x02\u09F4\u09EC\x03\x02\x02\x02\u09F4\u09F1\x03\x02\x02\x02\u09F5" +
|
|
"\xC7\x03\x02\x02\x02\u09F6\u09F7\x07\xC8\x02\x02\u09F7\u09FB\x05\u010E" +
|
|
"\x88\x02\u09F8\u09F9\x07\u0147\x02\x02\u09F9\u09FB\x05\xCEh\x02\u09FA" +
|
|
"\u09F6\x03\x02\x02\x02\u09FA\u09F8\x03\x02\x02\x02\u09FB\xC9\x03\x02\x02" +
|
|
"\x02\u09FC\u09FD\x07\u0122\x02\x02\u09FD\u09FF\x07\x04\x02\x02\u09FE\u0A00" +
|
|
"\x05\xCCg\x02\u09FF\u09FE\x03\x02\x02\x02\u09FF\u0A00\x03\x02\x02\x02" +
|
|
"\u0A00\u0A01\x03\x02\x02\x02\u0A01\u0A06\x07\x05\x02\x02\u0A02\u0A03\x07" +
|
|
"\xEF\x02\x02\u0A03\u0A04\x07\x04\x02\x02\u0A04\u0A05\x07\u0178\x02\x02" +
|
|
"\u0A05\u0A07\x07\x05\x02\x02\u0A06\u0A02\x03\x02\x02\x02\u0A06\u0A07\x03" +
|
|
"\x02\x02\x02\u0A07\xCB\x03\x02\x02\x02\u0A08\u0A0A\x07\u0164\x02\x02\u0A09" +
|
|
"\u0A08\x03\x02\x02\x02\u0A09\u0A0A\x03\x02\x02\x02\u0A0A\u0A0B\x03\x02" +
|
|
"\x02\x02\u0A0B\u0A0C\t\x19\x02\x02\u0A0C\u0A21\x07\xDA\x02\x02\u0A0D\u0A0E" +
|
|
"\x05\u0106\x84\x02\u0A0E\u0A0F\x07\xFD\x02\x02\u0A0F\u0A21\x03\x02\x02" +
|
|
"\x02\u0A10\u0A11\x07\x1F\x02\x02\u0A11\u0A12\x07\u0178\x02\x02\u0A12\u0A13" +
|
|
"\x07\xCE\x02\x02\u0A13\u0A14\x07\xC6\x02\x02\u0A14\u0A1D\x07\u0178\x02" +
|
|
"\x02\u0A15\u0A1B\x07\xC8\x02\x02\u0A16\u0A1C\x05\u016C\xB7\x02\u0A17\u0A18" +
|
|
"\x05\u0166\xB4\x02\u0A18\u0A19\x07\x04\x02\x02\u0A19\u0A1A\x07\x05\x02" +
|
|
"\x02\u0A1A\u0A1C\x03\x02\x02\x02\u0A1B\u0A16\x03\x02\x02\x02\u0A1B\u0A17" +
|
|
"\x03\x02\x02\x02\u0A1C\u0A1E\x03\x02\x02\x02\u0A1D\u0A15\x03\x02\x02\x02" +
|
|
"\u0A1D\u0A1E\x03\x02\x02\x02\u0A1E\u0A21\x03\x02\x02\x02\u0A1F\u0A21\x05" +
|
|
"\u0106\x84\x02\u0A20\u0A09\x03\x02\x02\x02\u0A20\u0A0D\x03\x02\x02\x02" +
|
|
"\u0A20\u0A10\x03\x02\x02\x02\u0A20\u0A1F\x03\x02\x02\x02\u0A21\xCD\x03" +
|
|
"\x02\x02\x02\u0A22\u0A23\x07\x04\x02\x02\u0A23\u0A24\x05\xD0i\x02\u0A24" +
|
|
"\u0A25\x07\x05\x02\x02\u0A25\xCF\x03\x02\x02\x02\u0A26\u0A2B\x05\u0168" +
|
|
"\xB5\x02\u0A27\u0A28\x07\x06\x02\x02\u0A28\u0A2A\x05\u0168\xB5\x02\u0A29" +
|
|
"\u0A27\x03\x02\x02\x02\u0A2A\u0A2D\x03\x02\x02\x02\u0A2B\u0A29\x03\x02" +
|
|
"\x02\x02\u0A2B\u0A2C\x03\x02\x02\x02\u0A2C\xD1\x03\x02\x02\x02\u0A2D\u0A2B" +
|
|
"\x03\x02\x02\x02\u0A2E\u0A2F\x07\x04\x02\x02\u0A2F\u0A34\x05\xD4k\x02" +
|
|
"\u0A30\u0A31\x07\x06\x02\x02\u0A31\u0A33\x05\xD4k\x02\u0A32\u0A30\x03" +
|
|
"\x02\x02\x02\u0A33\u0A36\x03\x02\x02\x02\u0A34\u0A32\x03\x02\x02\x02\u0A34" +
|
|
"\u0A35\x03\x02\x02\x02\u0A35\u0A37\x03\x02\x02\x02\u0A36\u0A34\x03\x02" +
|
|
"\x02\x02\u0A37\u0A38\x07\x05\x02\x02\u0A38\xD3\x03\x02\x02\x02\u0A39\u0A3B" +
|
|
"\x05\u0168\xB5\x02\u0A3A\u0A3C\t\x11\x02\x02\u0A3B\u0A3A\x03\x02\x02\x02" +
|
|
"\u0A3B\u0A3C\x03\x02\x02\x02\u0A3C\xD5\x03\x02\x02\x02\u0A3D\u0A3E\x07" +
|
|
"\x04\x02\x02\u0A3E\u0A43\x05\xD8m\x02\u0A3F\u0A40\x07\x06\x02\x02\u0A40" +
|
|
"\u0A42\x05\xD8m\x02\u0A41\u0A3F\x03\x02\x02\x02\u0A42\u0A45\x03\x02\x02" +
|
|
"\x02\u0A43\u0A41\x03\x02\x02\x02\u0A43\u0A44\x03\x02\x02\x02\u0A44\u0A46" +
|
|
"\x03\x02\x02\x02\u0A45\u0A43\x03\x02\x02\x02\u0A46\u0A47\x07\x05\x02\x02" +
|
|
"\u0A47\xD7\x03\x02\x02\x02\u0A48\u0A4A\x05\u016C\xB7\x02\u0A49\u0A4B\x05" +
|
|
"\x1A\x0E\x02\u0A4A\u0A49\x03\x02\x02\x02\u0A4A\u0A4B\x03\x02\x02\x02\u0A4B" +
|
|
"\xD9\x03\x02\x02\x02\u0A4C\u0A4E\x05\\/\x02\u0A4D\u0A4F\x05\x90I\x02\u0A4E" +
|
|
"\u0A4D\x03\x02\x02\x02\u0A4E\u0A4F\x03\x02\x02\x02\u0A4F\u0A51\x03\x02" +
|
|
"\x02\x02\u0A50\u0A52\x05\xCAf\x02\u0A51\u0A50\x03\x02\x02\x02\u0A51\u0A52" +
|
|
"\x03\x02\x02\x02\u0A52\u0A53\x03\x02\x02\x02\u0A53\u0A54\x05\xEAv\x02" +
|
|
"\u0A54\u0A68\x03\x02\x02\x02\u0A55\u0A56\x07\x04\x02\x02\u0A56\u0A57\x05" +
|
|
"\x1C\x0F\x02\u0A57\u0A59\x07\x05\x02\x02\u0A58\u0A5A\x05\xCAf\x02\u0A59" +
|
|
"\u0A58\x03\x02\x02\x02\u0A59\u0A5A\x03\x02\x02\x02\u0A5A\u0A5B\x03\x02" +
|
|
"\x02\x02\u0A5B\u0A5C\x05\xEAv\x02\u0A5C\u0A68\x03\x02\x02\x02\u0A5D\u0A5E" +
|
|
"\x07\x04\x02\x02\u0A5E\u0A5F\x05\xC0a\x02\u0A5F\u0A61\x07\x05\x02\x02" +
|
|
"\u0A60\u0A62\x05\xCAf\x02\u0A61\u0A60\x03\x02\x02\x02\u0A61\u0A62\x03" +
|
|
"\x02\x02\x02\u0A62\u0A63\x03\x02\x02\x02\u0A63\u0A64\x05\xEAv\x02\u0A64" +
|
|
"\u0A68\x03\x02\x02\x02\u0A65\u0A68\x05\xDCo\x02\u0A66\u0A68\x05\xE8u\x02" +
|
|
"\u0A67\u0A4C\x03\x02\x02\x02\u0A67\u0A55\x03\x02\x02\x02\u0A67\u0A5D\x03" +
|
|
"\x02\x02\x02\u0A67\u0A65\x03\x02\x02\x02\u0A67\u0A66\x03\x02\x02\x02\u0A68" +
|
|
"\xDB\x03\x02\x02\x02\u0A69\u0A6A\x07\u0148\x02\x02\u0A6A\u0A6F\x05\u0106" +
|
|
"\x84\x02\u0A6B\u0A6C\x07\x06\x02\x02\u0A6C\u0A6E\x05\u0106\x84\x02\u0A6D" +
|
|
"\u0A6B\x03\x02\x02\x02\u0A6E\u0A71\x03\x02\x02\x02\u0A6F\u0A6D\x03\x02" +
|
|
"\x02\x02\u0A6F\u0A70\x03\x02\x02\x02\u0A70\u0A72\x03\x02\x02\x02\u0A71" +
|
|
"\u0A6F\x03\x02\x02\x02\u0A72\u0A73\x05\xEAv\x02\u0A73\xDD\x03\x02\x02" +
|
|
"\x02\u0A74\u0A75\x07\u0120\x02\x02\u0A75\u0A77\x05V,\x02\u0A76\u0A78\x05" +
|
|
"\xE0q\x02\u0A77\u0A76\x03\x02\x02\x02\u0A77\u0A78\x03\x02\x02\x02\u0A78" +
|
|
"\u0A88\x03\x02\x02\x02\u0A79\u0A7A\x07\u0120\x02\x02\u0A7A\u0A7B\x07\x04" +
|
|
"\x02\x02\u0A7B\u0A7C\x05V,\x02\u0A7C\u0A7E\x07\x05\x02\x02\u0A7D\u0A7F" +
|
|
"\x05\xE0q\x02\u0A7E\u0A7D\x03\x02\x02\x02\u0A7E\u0A7F\x03\x02\x02\x02" +
|
|
"\u0A7F\u0A88\x03\x02\x02\x02\u0A80\u0A81\x07\u0120\x02\x02\u0A81\u0A82" +
|
|
"\x07\x04\x02\x02\u0A82\u0A83\x05\x1C\x0F\x02\u0A83\u0A85\x07\x05\x02\x02" +
|
|
"\u0A84\u0A86\x05\xE0q\x02\u0A85\u0A84\x03\x02\x02\x02\u0A85\u0A86\x03" +
|
|
"\x02\x02\x02\u0A86\u0A88\x03\x02\x02\x02\u0A87\u0A74\x03\x02\x02\x02\u0A87" +
|
|
"\u0A79\x03\x02\x02\x02\u0A87\u0A80\x03\x02\x02\x02\u0A88\xDF\x03\x02\x02" +
|
|
"\x02\u0A89\u0A8A\x07\u0155\x02\x02\u0A8A\u0A8B\x07\u010D\x02\x02\u0A8B" +
|
|
"\u0A9D\x07\xD5\x02\x02\u0A8C\u0A8D\t\x1A\x02\x02\u0A8D\u0A9A\x07!\x02" +
|
|
"\x02\u0A8E\u0A8F\x07\x04\x02\x02\u0A8F\u0A94\x05\u0106\x84\x02\u0A90\u0A91" +
|
|
"\x07\x06\x02\x02\u0A91\u0A93\x05\u0106\x84\x02\u0A92\u0A90\x03\x02\x02" +
|
|
"\x02\u0A93\u0A96\x03\x02\x02\x02\u0A94\u0A92\x03\x02\x02\x02\u0A94\u0A95" +
|
|
"\x03\x02\x02\x02\u0A95\u0A97\x03\x02\x02\x02\u0A96\u0A94\x03\x02\x02\x02" +
|
|
"\u0A97\u0A98\x07\x05\x02\x02\u0A98\u0A9B\x03\x02\x02\x02\u0A99\u0A9B\x05" +
|
|
"\u0106\x84\x02\u0A9A\u0A8E\x03\x02\x02\x02\u0A9A\u0A99\x03\x02\x02\x02" +
|
|
"\u0A9B\u0A9D\x03\x02\x02\x02\u0A9C\u0A89\x03\x02\x02\x02\u0A9C\u0A8C\x03" +
|
|
"\x02\x02\x02\u0A9D\u0AAE\x03\x02\x02\x02\u0A9E\u0A9F\t\x1B\x02\x02\u0A9F" +
|
|
"\u0AAC\x07!\x02\x02\u0AA0\u0AA1\x07\x04\x02\x02\u0AA1\u0AA6\x05f4\x02" +
|
|
"\u0AA2\u0AA3\x07\x06\x02\x02\u0AA3\u0AA5\x05f4\x02\u0AA4\u0AA2\x03\x02" +
|
|
"\x02\x02\u0AA5\u0AA8\x03\x02\x02\x02\u0AA6\u0AA4\x03\x02\x02\x02\u0AA6" +
|
|
"\u0AA7\x03\x02\x02\x02\u0AA7\u0AA9\x03\x02\x02\x02\u0AA8\u0AA6\x03\x02" +
|
|
"\x02\x02\u0AA9\u0AAA\x07\x05\x02\x02\u0AAA\u0AAD\x03\x02\x02\x02\u0AAB" +
|
|
"\u0AAD\x05f4\x02\u0AAC\u0AA0\x03\x02\x02\x02\u0AAC\u0AAB\x03\x02\x02\x02" +
|
|
"\u0AAD\u0AAF\x03\x02\x02\x02\u0AAE\u0A9E\x03\x02\x02\x02\u0AAE\u0AAF\x03" +
|
|
"\x02\x02\x02\u0AAF\xE1\x03\x02\x02\x02\u0AB0\u0AB1\x05\u016C\xB7\x02\u0AB1" +
|
|
"\u0AB2\x07\u016F\x02\x02\u0AB2\u0AB3\x05\xDEp\x02\u0AB3\xE3\x03\x02\x02" +
|
|
"\x02\u0AB4\u0AB7\x05\xDEp\x02\u0AB5\u0AB7\x05\xE2r\x02\u0AB6\u0AB4\x03" +
|
|
"\x02\x02\x02\u0AB6\u0AB5\x03\x02\x02\x02\u0AB7\xE5\x03\x02\x02\x02\u0AB8" +
|
|
"\u0ABB\x05\xE4s\x02\u0AB9\u0ABB\x05\u010A\x86\x02\u0ABA\u0AB8\x03\x02" +
|
|
"\x02\x02\u0ABA\u0AB9\x03\x02\x02\x02\u0ABB\xE7\x03\x02\x02\x02\u0ABC\u0ABD" +
|
|
"\x05\u0162\xB2\x02\u0ABD\u0AC6\x07\x04\x02\x02\u0ABE\u0AC3\x05\xE6t\x02" +
|
|
"\u0ABF\u0AC0\x07\x06\x02\x02\u0AC0\u0AC2\x05\xE6t\x02\u0AC1\u0ABF\x03" +
|
|
"\x02\x02\x02\u0AC2\u0AC5\x03\x02\x02\x02\u0AC3\u0AC1\x03\x02\x02\x02\u0AC3" +
|
|
"\u0AC4\x03\x02\x02\x02\u0AC4\u0AC7\x03\x02\x02\x02\u0AC5\u0AC3\x03\x02" +
|
|
"\x02\x02\u0AC6\u0ABE\x03\x02\x02\x02\u0AC6\u0AC7\x03\x02\x02\x02\u0AC7" +
|
|
"\u0AC8\x03\x02\x02\x02\u0AC8\u0AC9\x07\x05\x02\x02\u0AC9\u0ACA\x05\xEA" +
|
|
"v\x02\u0ACA\xE9\x03\x02\x02\x02\u0ACB\u0ACD\x07\x16\x02\x02\u0ACC\u0ACB" +
|
|
"\x03\x02\x02\x02\u0ACC\u0ACD\x03\x02\x02\x02\u0ACD\u0ACE\x03\x02\x02\x02" +
|
|
"\u0ACE\u0AD0\x05\u016E\xB8\x02\u0ACF\u0AD1\x05\xCEh\x02\u0AD0\u0ACF\x03" +
|
|
"\x02\x02\x02\u0AD0\u0AD1\x03\x02\x02\x02\u0AD1\u0AD3\x03\x02\x02\x02\u0AD2" +
|
|
"\u0ACC\x03\x02\x02\x02\u0AD2\u0AD3\x03\x02\x02\x02\u0AD3\xEB\x03\x02\x02" +
|
|
"\x02\u0AD4\u0AD5\x07\xFC\x02\x02\u0AD5\u0AD6\x07y\x02\x02\u0AD6\u0AD7" +
|
|
"\x07\u0105\x02\x02\u0AD7\u0ADB\x05\u0178\xBD\x02\u0AD8\u0AD9\x07\u0155" +
|
|
"\x02\x02\u0AD9\u0ADA\x07\u0106\x02\x02\u0ADA\u0ADC\x056\x1C\x02\u0ADB" +
|
|
"\u0AD8\x03\x02\x02\x02\u0ADB\u0ADC\x03\x02\x02\x02\u0ADC\u0B06\x03\x02" +
|
|
"\x02\x02\u0ADD\u0ADE\x07\xFC\x02\x02\u0ADE\u0ADF\x07y\x02\x02\u0ADF\u0AE9" +
|
|
"\x07W\x02\x02\u0AE0\u0AE1\x07q\x02\x02\u0AE1\u0AE2\x07\u0126\x02\x02\u0AE2" +
|
|
"\u0AE3\x07!\x02\x02\u0AE3\u0AE7\x05\u0178\xBD\x02\u0AE4\u0AE5\x07e\x02" +
|
|
"\x02\u0AE5\u0AE6\x07!\x02\x02\u0AE6\u0AE8\x05\u0178\xBD\x02\u0AE7\u0AE4" +
|
|
"\x03\x02\x02\x02\u0AE7\u0AE8\x03\x02\x02\x02\u0AE8\u0AEA\x03\x02\x02\x02" +
|
|
"\u0AE9\u0AE0\x03\x02\x02\x02\u0AE9\u0AEA\x03\x02\x02\x02\u0AEA\u0AF0\x03" +
|
|
"\x02\x02\x02\u0AEB\u0AEC\x072\x02\x02\u0AEC\u0AED\x07\x9A\x02\x02\u0AED" +
|
|
"\u0AEE\x07\u0126\x02\x02\u0AEE\u0AEF\x07!\x02\x02\u0AEF\u0AF1\x05\u0178" +
|
|
"\xBD\x02\u0AF0\u0AEB\x03\x02\x02\x02\u0AF0\u0AF1\x03\x02\x02\x02\u0AF1" +
|
|
"\u0AF7\x03\x02\x02\x02\u0AF2\u0AF3\x07\xAF\x02\x02\u0AF3\u0AF4\x07\x9C" +
|
|
"\x02\x02\u0AF4\u0AF5\x07\u0126\x02\x02\u0AF5\u0AF6\x07!\x02\x02\u0AF6" +
|
|
"\u0AF8\x05\u0178\xBD\x02\u0AF7\u0AF2\x03\x02\x02\x02\u0AF7\u0AF8\x03\x02" +
|
|
"\x02\x02\u0AF8\u0AFD\x03\x02\x02\x02\u0AF9\u0AFA\x07\xA5\x02\x02\u0AFA" +
|
|
"\u0AFB\x07\u0126\x02\x02\u0AFB\u0AFC\x07!\x02\x02\u0AFC\u0AFE\x05\u0178" +
|
|
"\xBD\x02\u0AFD\u0AF9\x03\x02\x02\x02\u0AFD\u0AFE\x03\x02\x02\x02\u0AFE" +
|
|
"\u0B03\x03\x02\x02\x02\u0AFF\u0B00\x07\xC3\x02\x02\u0B00\u0B01\x07U\x02" +
|
|
"\x02\u0B01\u0B02\x07\x16\x02\x02\u0B02\u0B04\x05\u0178\xBD\x02\u0B03\u0AFF" +
|
|
"\x03\x02\x02\x02\u0B03\u0B04\x03\x02\x02\x02\u0B04\u0B06\x03\x02\x02\x02" +
|
|
"\u0B05\u0AD4\x03\x02\x02\x02\u0B05\u0ADD\x03\x02\x02\x02\u0B06\xED\x03" +
|
|
"\x02\x02\x02\u0B07\u0B0C\x05\xF0y\x02\u0B08\u0B09\x07\x06\x02\x02\u0B09" +
|
|
"\u0B0B\x05\xF0y\x02\u0B0A\u0B08\x03\x02\x02\x02\u0B0B\u0B0E\x03\x02\x02" +
|
|
"\x02\u0B0C\u0B0A\x03\x02\x02\x02\u0B0C\u0B0D\x03\x02\x02\x02\u0B0D\xEF" +
|
|
"\x03\x02\x02\x02\u0B0E\u0B0C\x03\x02\x02\x02\u0B0F\u0B14\x05\u0168\xB5" +
|
|
"\x02\u0B10\u0B11\x07\x07\x02\x02\u0B11\u0B13\x05\u0168\xB5\x02\u0B12\u0B10" +
|
|
"\x03\x02\x02\x02\u0B13\u0B16\x03\x02\x02\x02\u0B14\u0B12\x03\x02\x02\x02" +
|
|
"\u0B14\u0B15\x03\x02\x02\x02\u0B15\xF1\x03\x02\x02\x02\u0B16\u0B14\x03" +
|
|
"\x02\x02\x02\u0B17\u0B1C\x05\xF4{\x02\u0B18\u0B19\x07\x06\x02\x02\u0B19" +
|
|
"\u0B1B\x05\xF4{\x02\u0B1A\u0B18\x03\x02\x02\x02\u0B1B\u0B1E\x03\x02\x02" +
|
|
"\x02\u0B1C\u0B1A\x03\x02\x02\x02\u0B1C\u0B1D\x03\x02\x02\x02\u0B1D\xF3" +
|
|
"\x03\x02\x02\x02\u0B1E\u0B1C\x03\x02\x02\x02\u0B1F\u0B22\x05\xF0y\x02" +
|
|
"\u0B20\u0B21\x07\xCB\x02\x02\u0B21\u0B23\x056\x1C\x02\u0B22\u0B20\x03" +
|
|
"\x02\x02\x02\u0B22\u0B23\x03\x02\x02\x02\u0B23\xF5\x03\x02\x02\x02\u0B24" +
|
|
"\u0B25\x05\u0168\xB5\x02\u0B25\u0B26\x07\x07\x02\x02\u0B26\u0B28\x03\x02" +
|
|
"\x02\x02\u0B27\u0B24\x03\x02\x02\x02\u0B27\u0B28\x03\x02\x02\x02\u0B28" +
|
|
"\u0B29\x03\x02\x02\x02\u0B29\u0B2A\x05\u0168\xB5\x02\u0B2A\xF7\x03\x02" +
|
|
"\x02\x02\u0B2B\u0B2C\x05\u0168\xB5\x02\u0B2C\u0B2D\x07\x07\x02\x02\u0B2D" +
|
|
"\u0B2F\x03\x02\x02\x02\u0B2E\u0B2B\x03\x02\x02\x02\u0B2E\u0B2F\x03\x02" +
|
|
"\x02\x02\u0B2F\u0B30\x03\x02\x02\x02\u0B30\u0B31\x05\u0168\xB5\x02\u0B31" +
|
|
"\xF9\x03\x02\x02\x02\u0B32\u0B3A\x05\u0106\x84\x02\u0B33\u0B35\x07\x16" +
|
|
"\x02\x02\u0B34\u0B33\x03\x02\x02\x02\u0B34\u0B35\x03\x02\x02\x02\u0B35" +
|
|
"\u0B38\x03\x02\x02\x02\u0B36\u0B39\x05\u0168\xB5\x02\u0B37\u0B39\x05\xCE" +
|
|
"h\x02\u0B38\u0B36\x03\x02\x02\x02\u0B38\u0B37\x03\x02\x02\x02\u0B39\u0B3B" +
|
|
"\x03\x02\x02\x02\u0B3A\u0B34\x03\x02\x02\x02\u0B3A\u0B3B\x03\x02\x02\x02" +
|
|
"\u0B3B\xFB\x03\x02\x02\x02\u0B3C\u0B41\x05\xFA~\x02\u0B3D\u0B3E\x07\x06" +
|
|
"\x02\x02\u0B3E\u0B40\x05\xFA~\x02\u0B3F\u0B3D\x03\x02\x02\x02\u0B40\u0B43" +
|
|
"\x03\x02\x02\x02\u0B41\u0B3F\x03\x02\x02\x02\u0B41\u0B42\x03\x02\x02\x02" +
|
|
"\u0B42\xFD\x03\x02\x02\x02\u0B43\u0B41\x03\x02\x02\x02\u0B44\u0B45\x07" +
|
|
"\x04\x02\x02\u0B45\u0B4A\x05\u0100\x81\x02\u0B46\u0B47\x07\x06\x02\x02" +
|
|
"\u0B47\u0B49\x05\u0100\x81\x02\u0B48\u0B46\x03\x02\x02\x02\u0B49\u0B4C" +
|
|
"\x03\x02\x02\x02\u0B4A\u0B48\x03\x02\x02\x02\u0B4A\u0B4B\x03\x02\x02\x02" +
|
|
"\u0B4B\u0B4D\x03\x02\x02\x02\u0B4C\u0B4A\x03\x02\x02\x02\u0B4D\u0B4E\x07" +
|
|
"\x05\x02\x02\u0B4E\xFF\x03\x02\x02\x02\u0B4F\u0B52\x05\u0102\x82\x02\u0B50" +
|
|
"\u0B52\x05\u0146\xA4\x02\u0B51\u0B4F\x03\x02\x02\x02\u0B51\u0B50\x03\x02" +
|
|
"\x02\x02\u0B52\u0101\x03\x02\x02\x02\u0B53\u0B61\x05\u0166\xB4\x02\u0B54" +
|
|
"\u0B55\x05\u016C\xB7\x02\u0B55\u0B56\x07\x04\x02\x02\u0B56\u0B5B\x05\u0104" +
|
|
"\x83\x02\u0B57\u0B58\x07\x06\x02\x02\u0B58\u0B5A\x05\u0104\x83\x02\u0B59" +
|
|
"\u0B57\x03\x02\x02\x02\u0B5A\u0B5D\x03\x02\x02\x02\u0B5B\u0B59\x03\x02" +
|
|
"\x02\x02\u0B5B\u0B5C\x03\x02\x02\x02\u0B5C\u0B5E\x03\x02\x02\x02\u0B5D" +
|
|
"\u0B5B\x03\x02\x02\x02\u0B5E\u0B5F\x07\x05\x02\x02\u0B5F\u0B61\x03\x02" +
|
|
"\x02\x02\u0B60\u0B53\x03\x02\x02\x02\u0B60\u0B54\x03\x02\x02\x02\u0B61" +
|
|
"\u0103\x03\x02\x02\x02\u0B62\u0B65\x05\u0166\xB4\x02\u0B63\u0B65\x05\u011A" +
|
|
"\x8E\x02\u0B64\u0B62\x03\x02\x02\x02\u0B64\u0B63\x03\x02\x02\x02\u0B65" +
|
|
"\u0105\x03\x02\x02\x02\u0B66\u0B67\x05\u010E\x88\x02\u0B67\u0107\x03\x02" +
|
|
"\x02\x02\u0B68\u0B69\x05\u016C\xB7\x02\u0B69\u0B6A\x07\u016F\x02\x02\u0B6A" +
|
|
"\u0B6B\x05\u0106\x84\x02\u0B6B\u0109\x03\x02\x02\x02\u0B6C\u0B6F\x05\u0106" +
|
|
"\x84\x02\u0B6D\u0B6F\x05\u0108\x85\x02\u0B6E\u0B6C\x03\x02\x02\x02\u0B6E" +
|
|
"\u0B6D\x03\x02\x02\x02\u0B6F\u010B\x03\x02\x02\x02\u0B70\u0B75\x05\u0106" +
|
|
"\x84\x02\u0B71\u0B72\x07\x06\x02\x02\u0B72\u0B74\x05\u0106\x84\x02\u0B73" +
|
|
"\u0B71\x03\x02\x02\x02\u0B74\u0B77\x03\x02\x02\x02\u0B75\u0B73\x03\x02" +
|
|
"\x02\x02\u0B75\u0B76\x03\x02\x02\x02\u0B76\u010D\x03\x02\x02\x02\u0B77" +
|
|
"\u0B75\x03\x02\x02\x02\u0B78\u0B79\b\x88\x01\x02\u0B79\u0B7A\t\x1C\x02" +
|
|
"\x02\u0B7A\u0B85\x05\u010E\x88\x07\u0B7B\u0B7C\x07i\x02\x02\u0B7C\u0B7D" +
|
|
"\x07\x04\x02\x02\u0B7D\u0B7E\x05\x1C\x0F\x02\u0B7E\u0B7F\x07\x05\x02\x02" +
|
|
"\u0B7F\u0B85\x03\x02\x02\x02\u0B80\u0B82\x05\u0112\x8A\x02\u0B81\u0B83" +
|
|
"\x05\u0110\x89\x02\u0B82\u0B81\x03\x02\x02\x02\u0B82\u0B83\x03\x02\x02" +
|
|
"\x02\u0B83\u0B85\x03\x02\x02\x02\u0B84\u0B78\x03\x02\x02\x02\u0B84\u0B7B" +
|
|
"\x03\x02\x02\x02\u0B84\u0B80\x03\x02\x02\x02\u0B85\u0B8E\x03\x02\x02\x02" +
|
|
"\u0B86\u0B87\f\x04\x02\x02\u0B87\u0B88\x07\x10\x02\x02\u0B88\u0B8D\x05" +
|
|
"\u010E\x88\x05\u0B89\u0B8A\f\x03\x02\x02\u0B8A\u0B8B\x07\xCC\x02\x02\u0B8B" +
|
|
"\u0B8D\x05\u010E\x88\x04\u0B8C\u0B86\x03\x02\x02\x02\u0B8C\u0B89\x03\x02" +
|
|
"\x02\x02\u0B8D\u0B90\x03\x02\x02\x02\u0B8E\u0B8C\x03\x02\x02\x02\u0B8E" +
|
|
"\u0B8F\x03\x02\x02\x02\u0B8F\u010F\x03\x02\x02\x02\u0B90\u0B8E\x03\x02" +
|
|
"\x02\x02\u0B91\u0B93\x07\xC2\x02\x02\u0B92\u0B91\x03\x02\x02\x02\u0B92" +
|
|
"\u0B93\x03\x02\x02\x02\u0B93\u0B94\x03\x02\x02\x02\u0B94\u0B95\x07\x1A" +
|
|
"\x02\x02\u0B95\u0B96\x05\u0112\x8A\x02\u0B96\u0B97\x07\x10\x02\x02\u0B97" +
|
|
"\u0B98\x05\u0112\x8A\x02\u0B98\u0BE4\x03\x02\x02\x02\u0B99\u0B9B\x07\xC2" +
|
|
"\x02\x02\u0B9A\u0B99\x03\x02\x02\x02\u0B9A\u0B9B\x03\x02\x02\x02\u0B9B" +
|
|
"\u0B9C\x03\x02\x02\x02\u0B9C\u0B9D\x07\x8C\x02\x02\u0B9D\u0B9E\x07\x04" +
|
|
"\x02\x02\u0B9E\u0BA3\x05\u0106\x84\x02\u0B9F\u0BA0\x07\x06\x02\x02\u0BA0" +
|
|
"\u0BA2\x05\u0106\x84\x02\u0BA1\u0B9F\x03\x02\x02\x02\u0BA2\u0BA5\x03\x02" +
|
|
"\x02\x02\u0BA3\u0BA1\x03\x02\x02\x02\u0BA3\u0BA4\x03\x02\x02\x02\u0BA4" +
|
|
"\u0BA6\x03\x02\x02\x02\u0BA5\u0BA3\x03\x02\x02\x02\u0BA6\u0BA7\x07\x05" +
|
|
"\x02\x02\u0BA7\u0BE4\x03\x02\x02\x02\u0BA8\u0BAA\x07\xC2\x02\x02\u0BA9" +
|
|
"\u0BA8\x03\x02\x02\x02\u0BA9\u0BAA\x03\x02\x02\x02\u0BAA\u0BAB\x03\x02" +
|
|
"\x02\x02\u0BAB\u0BAC\x07\x8C\x02\x02\u0BAC\u0BAD\x07\x04\x02\x02\u0BAD" +
|
|
"\u0BAE\x05\x1C\x0F\x02\u0BAE\u0BAF\x07\x05\x02\x02\u0BAF\u0BE4\x03\x02" +
|
|
"\x02\x02\u0BB0\u0BB2\x07\xC2\x02\x02\u0BB1\u0BB0\x03\x02\x02\x02\u0BB1" +
|
|
"\u0BB2\x03\x02\x02\x02\u0BB2\u0BB3\x03\x02\x02\x02\u0BB3\u0BB4\t\x1D\x02" +
|
|
"\x02\u0BB4\u0BE4\x05\u0112\x8A\x02\u0BB5\u0BB7\x07\xC2\x02\x02\u0BB6\u0BB5" +
|
|
"\x03\x02\x02\x02\u0BB6\u0BB7\x03\x02\x02\x02\u0BB7\u0BB8\x03\x02\x02\x02" +
|
|
"\u0BB8\u0BB9\t\x1E\x02\x02\u0BB9\u0BC7\t\x1F\x02\x02\u0BBA\u0BBB\x07\x04" +
|
|
"\x02\x02\u0BBB\u0BC8\x07\x05\x02\x02\u0BBC\u0BBD\x07\x04\x02\x02\u0BBD" +
|
|
"\u0BC2\x05\u0106\x84\x02\u0BBE\u0BBF\x07\x06\x02\x02\u0BBF\u0BC1\x05\u0106" +
|
|
"\x84\x02\u0BC0\u0BBE\x03\x02\x02\x02\u0BC1\u0BC4\x03\x02\x02\x02\u0BC2" +
|
|
"\u0BC0\x03\x02\x02\x02\u0BC2\u0BC3\x03\x02\x02\x02\u0BC3\u0BC5\x03\x02" +
|
|
"\x02\x02\u0BC4\u0BC2\x03\x02\x02\x02\u0BC5\u0BC6\x07\x05\x02\x02\u0BC6" +
|
|
"\u0BC8\x03\x02\x02\x02\u0BC7\u0BBA\x03\x02\x02\x02\u0BC7\u0BBC\x03\x02" +
|
|
"\x02\x02\u0BC8\u0BE4\x03\x02\x02\x02\u0BC9\u0BCB\x07\xC2\x02\x02\u0BCA" +
|
|
"\u0BC9\x03\x02\x02\x02\u0BCA\u0BCB\x03\x02\x02\x02\u0BCB\u0BCC\x03\x02" +
|
|
"\x02\x02\u0BCC\u0BCD\t\x1E\x02\x02\u0BCD\u0BD0\x05\u0112\x8A\x02\u0BCE" +
|
|
"\u0BCF\x07d\x02\x02\u0BCF\u0BD1\x05\u0178\xBD\x02\u0BD0\u0BCE\x03\x02" +
|
|
"\x02\x02\u0BD0\u0BD1\x03\x02\x02\x02\u0BD1\u0BE4\x03\x02\x02\x02\u0BD2" +
|
|
"\u0BD4\x07\x99\x02\x02\u0BD3\u0BD5\x07\xC2\x02\x02\u0BD4\u0BD3\x03\x02" +
|
|
"\x02\x02\u0BD4\u0BD5\x03\x02\x02\x02\u0BD5\u0BD6\x03\x02\x02\x02\u0BD6" +
|
|
"\u0BE4\x07\xC3\x02\x02\u0BD7\u0BD9\x07\x99\x02\x02\u0BD8\u0BDA\x07\xC2" +
|
|
"\x02\x02\u0BD9\u0BD8\x03\x02\x02\x02\u0BD9\u0BDA\x03\x02\x02\x02\u0BDA" +
|
|
"\u0BDB\x03\x02\x02\x02\u0BDB\u0BE4\t \x02\x02\u0BDC\u0BDE\x07\x99\x02" +
|
|
"\x02\u0BDD\u0BDF\x07\xC2\x02\x02\u0BDE\u0BDD\x03\x02\x02\x02\u0BDE\u0BDF" +
|
|
"\x03\x02\x02\x02\u0BDF\u0BE0\x03\x02\x02\x02\u0BE0\u0BE1\x07]\x02\x02" +
|
|
"\u0BE1\u0BE2\x07{\x02\x02\u0BE2\u0BE4\x05\u0112\x8A\x02\u0BE3\u0B92\x03" +
|
|
"\x02\x02\x02\u0BE3\u0B9A\x03\x02\x02\x02\u0BE3\u0BA9\x03\x02\x02\x02\u0BE3" +
|
|
"\u0BB1\x03\x02\x02\x02\u0BE3\u0BB6\x03\x02\x02\x02\u0BE3\u0BCA\x03\x02" +
|
|
"\x02\x02\u0BE3\u0BD2\x03\x02\x02\x02\u0BE3\u0BD7\x03\x02\x02\x02\u0BE3" +
|
|
"\u0BDC\x03\x02\x02\x02\u0BE4\u0111\x03\x02\x02\x02\u0BE5\u0BE6\b\x8A\x01" +
|
|
"\x02\u0BE6\u0BEA\x05\u0116\x8C\x02\u0BE7\u0BE8\t!\x02\x02\u0BE8\u0BEA" +
|
|
"\x05\u0112\x8A\t\u0BE9\u0BE5\x03\x02\x02\x02\u0BE9\u0BE7\x03\x02\x02\x02" +
|
|
"\u0BEA\u0C00\x03\x02\x02\x02\u0BEB\u0BEC\f\b\x02\x02\u0BEC\u0BED\t\"\x02" +
|
|
"\x02\u0BED\u0BFF\x05\u0112\x8A\t\u0BEE\u0BEF\f\x07\x02\x02\u0BEF\u0BF0" +
|
|
"\t#\x02\x02\u0BF0\u0BFF\x05\u0112\x8A\b\u0BF1\u0BF2\f\x06\x02\x02\u0BF2" +
|
|
"\u0BF3\x07\u0169\x02\x02\u0BF3\u0BFF\x05\u0112\x8A\x07\u0BF4\u0BF5\f\x05" +
|
|
"\x02\x02\u0BF5\u0BF6\x07\u016C\x02\x02\u0BF6\u0BFF\x05\u0112\x8A\x06\u0BF7" +
|
|
"\u0BF8\f\x04\x02\x02\u0BF8\u0BF9\x07\u016A\x02\x02\u0BF9\u0BFF\x05\u0112" +
|
|
"\x8A\x05\u0BFA\u0BFB\f\x03\x02\x02\u0BFB\u0BFC\x05\u011C\x8F\x02\u0BFC" +
|
|
"\u0BFD\x05\u0112\x8A\x04\u0BFD";
|
|
private static readonly _serializedATNSegment6: string =
|
|
"\u0BFF\x03\x02\x02\x02\u0BFE\u0BEB\x03\x02\x02\x02\u0BFE\u0BEE\x03\x02" +
|
|
"\x02\x02\u0BFE\u0BF1\x03\x02\x02\x02\u0BFE\u0BF4\x03\x02\x02\x02\u0BFE" +
|
|
"\u0BF7\x03\x02\x02\x02\u0BFE\u0BFA\x03\x02\x02\x02\u0BFF\u0C02\x03\x02" +
|
|
"\x02\x02\u0C00\u0BFE\x03\x02\x02\x02\u0C00\u0C01\x03\x02\x02\x02\u0C01" +
|
|
"\u0113\x03\x02\x02\x02\u0C02\u0C00\x03\x02\x02\x02\u0C03\u0C04\t$\x02" +
|
|
"\x02\u0C04\u0115\x03\x02\x02\x02\u0C05\u0C06\b\x8C\x01\x02\u0C06\u0CFF" +
|
|
"\t%\x02\x02\u0C07\u0C08\t&\x02\x02\u0C08\u0C0B\x07\x04\x02\x02\u0C09\u0C0C" +
|
|
"\x05\u0114\x8B\x02\u0C0A\u0C0C\x05\u0178\xBD\x02\u0C0B\u0C09\x03\x02\x02" +
|
|
"\x02\u0C0B\u0C0A\x03\x02\x02\x02\u0C0C\u0C0D\x03\x02\x02\x02\u0C0D\u0C0E" +
|
|
"\x07\x06\x02\x02\u0C0E\u0C0F\x05\u0112\x8A\x02\u0C0F\u0C10\x07\x06\x02" +
|
|
"\x02\u0C10\u0C11\x05\u0112\x8A\x02\u0C11\u0C12\x07\x05\x02\x02\u0C12\u0CFF" +
|
|
"\x03\x02\x02\x02\u0C13\u0C14\t\'\x02\x02\u0C14\u0C17\x07\x04\x02\x02\u0C15" +
|
|
"\u0C18\x05\u0114\x8B\x02\u0C16\u0C18\x05\u0178\xBD\x02\u0C17\u0C15\x03" +
|
|
"\x02\x02\x02\u0C17\u0C16\x03\x02\x02\x02\u0C18\u0C19\x03\x02\x02\x02\u0C19" +
|
|
"\u0C1A\x07\x06\x02\x02\u0C1A\u0C1B\x05\u0112\x8A\x02\u0C1B\u0C1C\x07\x06" +
|
|
"\x02\x02\u0C1C\u0C1D\x05\u0112\x8A\x02\u0C1D\u0C1E\x07\x05\x02\x02\u0C1E" +
|
|
"\u0CFF\x03\x02\x02\x02\u0C1F\u0C21\x07%\x02\x02\u0C20\u0C22\x05\u0154" +
|
|
"\xAB\x02\u0C21\u0C20\x03\x02\x02\x02\u0C22\u0C23\x03\x02\x02\x02\u0C23" +
|
|
"\u0C21\x03\x02\x02\x02\u0C23\u0C24\x03\x02\x02\x02\u0C24\u0C27\x03\x02" +
|
|
"\x02\x02\u0C25\u0C26\x07b\x02\x02\u0C26\u0C28\x05\u0106\x84\x02\u0C27" +
|
|
"\u0C25\x03\x02\x02\x02\u0C27\u0C28\x03\x02\x02\x02\u0C28\u0C29\x03\x02" +
|
|
"\x02\x02\u0C29\u0C2A\x07c\x02\x02\u0C2A\u0CFF\x03\x02\x02\x02\u0C2B\u0C2C" +
|
|
"\x07%\x02\x02\u0C2C\u0C2E\x05\u0106\x84\x02\u0C2D\u0C2F\x05\u0154\xAB" +
|
|
"\x02\u0C2E\u0C2D\x03\x02\x02\x02\u0C2F\u0C30\x03\x02\x02\x02\u0C30\u0C2E" +
|
|
"\x03\x02\x02\x02\u0C30\u0C31\x03\x02\x02\x02\u0C31\u0C34\x03\x02\x02\x02" +
|
|
"\u0C32\u0C33\x07b\x02\x02\u0C33\u0C35\x05\u0106\x84\x02\u0C34\u0C32\x03" +
|
|
"\x02\x02\x02\u0C34\u0C35\x03\x02\x02\x02\u0C35\u0C36\x03\x02\x02\x02\u0C36" +
|
|
"\u0C37\x07c\x02\x02\u0C37\u0CFF\x03\x02\x02\x02\u0C38\u0C39\t(\x02\x02" +
|
|
"\u0C39\u0C3A\x07\x04\x02\x02\u0C3A\u0C3B\x05\u0106\x84\x02\u0C3B\u0C3C" +
|
|
"\x07\x16\x02\x02\u0C3C\u0C3D\x05\u0138\x9D\x02\u0C3D\u0C3E\x07\x05\x02" +
|
|
"\x02\u0C3E\u0CFF\x03\x02\x02\x02\u0C3F\u0C40\x07\u0119\x02\x02\u0C40\u0C49" +
|
|
"\x07\x04\x02\x02\u0C41\u0C46\x05\xFA~\x02\u0C42\u0C43\x07\x06\x02\x02" +
|
|
"\u0C43\u0C45\x05\xFA~\x02\u0C44\u0C42\x03\x02\x02\x02\u0C45\u0C48\x03" +
|
|
"\x02\x02\x02\u0C46\u0C44\x03\x02\x02\x02\u0C46\u0C47\x03\x02\x02\x02\u0C47" +
|
|
"\u0C4A\x03\x02\x02\x02\u0C48\u0C46\x03\x02\x02\x02\u0C49\u0C41\x03\x02" +
|
|
"\x02\x02\u0C49\u0C4A\x03\x02\x02\x02\u0C4A\u0C4B\x03\x02\x02\x02\u0C4B" +
|
|
"\u0CFF\x07\x05\x02\x02\u0C4C\u0C4D\x07t\x02\x02\u0C4D\u0C4E\x07\x04\x02" +
|
|
"\x02\u0C4E\u0C51\x05\u0106\x84\x02\u0C4F\u0C50\x07\x8A\x02\x02\u0C50\u0C52" +
|
|
"\x07\xC4\x02\x02\u0C51\u0C4F\x03\x02\x02\x02\u0C51\u0C52\x03\x02\x02\x02" +
|
|
"\u0C52\u0C53\x03\x02\x02\x02\u0C53\u0C54\x07\x05\x02\x02\u0C54\u0CFF\x03" +
|
|
"\x02\x02\x02\u0C55\u0C56\x07\x13\x02\x02\u0C56\u0C57\x07\x04\x02\x02\u0C57" +
|
|
"\u0C5A\x05\u0106\x84\x02\u0C58\u0C59\x07\x8A\x02\x02\u0C59\u0C5B\x07\xC4" +
|
|
"\x02\x02\u0C5A\u0C58\x03\x02\x02\x02\u0C5A\u0C5B\x03\x02\x02\x02\u0C5B" +
|
|
"\u0C5C\x03\x02\x02\x02\u0C5C\u0C5D\x07\x05\x02\x02\u0C5D\u0CFF\x03\x02" +
|
|
"\x02\x02\u0C5E\u0C5F\x07\x9D\x02\x02\u0C5F\u0C60\x07\x04\x02\x02\u0C60" +
|
|
"\u0C63\x05\u0106\x84\x02\u0C61\u0C62\x07\x8A\x02\x02\u0C62\u0C64\x07\xC4" +
|
|
"\x02\x02\u0C63\u0C61\x03\x02\x02\x02\u0C63\u0C64\x03\x02\x02\x02\u0C64" +
|
|
"\u0C65\x03\x02\x02\x02\u0C65\u0C66\x07\x05\x02\x02\u0C66\u0CFF\x03\x02" +
|
|
"\x02\x02\u0C67\u0C68\x07\xDD\x02\x02\u0C68\u0C69\x07\x04\x02\x02\u0C69" +
|
|
"\u0C6A\x05\u0112\x8A\x02\u0C6A\u0C6B\x07\x8C\x02\x02\u0C6B\u0C6C\x05\u0112" +
|
|
"\x8A\x02\u0C6C\u0C6D\x07\x05\x02\x02\u0C6D\u0CFF\x03\x02\x02\x02\u0C6E" +
|
|
"\u0CFF\x05\u011A\x8E\x02\u0C6F\u0CFF\x07\u0165\x02\x02\u0C70\u0C71\x05" +
|
|
"\u0166\xB4\x02\u0C71\u0C72\x07\x07\x02\x02\u0C72\u0C73\x07\u0165\x02\x02" +
|
|
"\u0C73\u0CFF\x03\x02\x02\x02\u0C74\u0C75\x07\x04\x02\x02\u0C75\u0C78\x05" +
|
|
"\xFA~\x02\u0C76\u0C77\x07\x06\x02\x02\u0C77\u0C79\x05\xFA~\x02\u0C78\u0C76" +
|
|
"\x03\x02\x02\x02\u0C79\u0C7A\x03\x02\x02\x02\u0C7A\u0C78\x03\x02\x02\x02" +
|
|
"\u0C7A\u0C7B\x03\x02\x02\x02\u0C7B\u0C7C\x03\x02\x02\x02\u0C7C\u0C7D\x07" +
|
|
"\x05\x02\x02\u0C7D\u0CFF\x03\x02\x02\x02\u0C7E\u0C7F\x07\x04\x02\x02\u0C7F" +
|
|
"\u0C80\x05\x1C\x0F\x02\u0C80\u0C81\x07\x05\x02\x02\u0C81\u0CFF\x03\x02" +
|
|
"\x02\x02\u0C82\u0C83\x07\x88\x02\x02\u0C83\u0C84\x07\x04\x02\x02\u0C84" +
|
|
"\u0C85\x05\u0106\x84\x02\u0C85\u0C86\x07\x05\x02\x02\u0C86\u0CFF\x03\x02" +
|
|
"\x02\x02\u0C87\u0C88\x05\u0162\xB2\x02\u0C88\u0C94\x07\x04\x02\x02\u0C89" +
|
|
"\u0C8B\x05\xBE`\x02\u0C8A\u0C89\x03\x02\x02\x02\u0C8A\u0C8B\x03\x02\x02" +
|
|
"\x02\u0C8B\u0C8C\x03\x02\x02\x02\u0C8C\u0C91\x05\u010A\x86\x02\u0C8D\u0C8E" +
|
|
"\x07\x06\x02\x02\u0C8E\u0C90\x05\u010A\x86\x02\u0C8F\u0C8D\x03\x02\x02" +
|
|
"\x02\u0C90\u0C93\x03\x02\x02\x02\u0C91\u0C8F\x03\x02\x02\x02\u0C91\u0C92" +
|
|
"\x03\x02\x02\x02\u0C92\u0C95\x03\x02\x02\x02\u0C93\u0C91\x03\x02\x02\x02" +
|
|
"\u0C94\u0C8A\x03\x02\x02\x02\u0C94\u0C95\x03\x02\x02\x02\u0C95\u0C96\x03" +
|
|
"\x02\x02\x02\u0C96\u0C9D\x07\x05\x02\x02\u0C97\u0C98\x07r\x02\x02\u0C98" +
|
|
"\u0C99\x07\x04\x02\x02\u0C99\u0C9A\x07\u0153\x02\x02\u0C9A\u0C9B\x05\u010E" +
|
|
"\x88\x02\u0C9B\u0C9C\x07\x05\x02\x02\u0C9C\u0C9E\x03\x02\x02\x02\u0C9D" +
|
|
"\u0C97\x03\x02\x02\x02\u0C9D\u0C9E\x03\x02\x02\x02\u0C9E\u0CA1\x03\x02" +
|
|
"\x02\x02\u0C9F\u0CA0\t)\x02\x02\u0CA0\u0CA2\x07\xC4\x02\x02\u0CA1\u0C9F" +
|
|
"\x03\x02\x02\x02\u0CA1\u0CA2\x03\x02\x02\x02\u0CA2\u0CA5\x03\x02\x02\x02" +
|
|
"\u0CA3\u0CA4\x07\xD1\x02\x02\u0CA4\u0CA6\x05\u015A\xAE\x02\u0CA5\u0CA3" +
|
|
"\x03\x02\x02\x02\u0CA5\u0CA6\x03\x02\x02\x02\u0CA6\u0CFF\x03\x02\x02\x02" +
|
|
"\u0CA7\u0CA8\x05\u016C\xB7\x02\u0CA8\u0CA9\x07\u016E\x02\x02\u0CA9\u0CAA" +
|
|
"\x05\u0106\x84\x02\u0CAA\u0CFF\x03\x02\x02\x02\u0CAB\u0CAC\x07\x04\x02" +
|
|
"\x02\u0CAC\u0CAF\x05\u016C\xB7\x02\u0CAD\u0CAE\x07\x06\x02\x02\u0CAE\u0CB0" +
|
|
"\x05\u016C\xB7\x02\u0CAF\u0CAD\x03\x02\x02\x02\u0CB0\u0CB1\x03\x02\x02" +
|
|
"\x02\u0CB1\u0CAF\x03\x02\x02\x02\u0CB1\u0CB2\x03\x02\x02\x02\u0CB2\u0CB3" +
|
|
"\x03\x02\x02\x02\u0CB3\u0CB4\x07\x05\x02\x02\u0CB4\u0CB5\x07\u016E\x02" +
|
|
"\x02\u0CB5\u0CB6\x05\u0106\x84\x02\u0CB6\u0CFF\x03\x02\x02\x02\u0CB7\u0CFF" +
|
|
"\x05\u016C\xB7\x02\u0CB8\u0CB9\x07\x04\x02\x02\u0CB9\u0CBA\x05\u0106\x84" +
|
|
"\x02\u0CBA\u0CBB\x07\x05\x02\x02\u0CBB\u0CFF\x03\x02\x02\x02\u0CBC\u0CBD" +
|
|
"\x07n\x02\x02\u0CBD\u0CBE\x07\x04\x02\x02\u0CBE\u0CBF\x05\u016C\xB7\x02" +
|
|
"\u0CBF\u0CC0\x07{\x02\x02\u0CC0\u0CC1\x05\u0112\x8A\x02\u0CC1\u0CC2\x07" +
|
|
"\x05\x02\x02\u0CC2\u0CFF\x03\x02\x02\x02\u0CC3\u0CC4\t*\x02\x02\u0CC4" +
|
|
"\u0CC5\x07\x04\x02\x02\u0CC5\u0CC6\x05\u0112\x8A\x02\u0CC6\u0CC7\t+\x02" +
|
|
"\x02\u0CC7\u0CCA\x05\u0112\x8A\x02\u0CC8\u0CC9\t,\x02\x02\u0CC9\u0CCB" +
|
|
"\x05\u0112\x8A\x02\u0CCA\u0CC8\x03\x02\x02\x02\u0CCA\u0CCB\x03\x02\x02" +
|
|
"\x02\u0CCB\u0CCC\x03\x02\x02\x02\u0CCC\u0CCD\x07\x05\x02\x02\u0CCD\u0CFF" +
|
|
"\x03\x02\x02\x02\u0CCE\u0CCF\x07\u0136\x02\x02\u0CCF\u0CD1\x07\x04\x02" +
|
|
"\x02\u0CD0\u0CD2\t-\x02\x02\u0CD1\u0CD0\x03\x02\x02\x02\u0CD1\u0CD2\x03" +
|
|
"\x02\x02\x02\u0CD2\u0CD4\x03\x02\x02\x02\u0CD3\u0CD5\x05\u0112\x8A\x02" +
|
|
"\u0CD4\u0CD3\x03\x02\x02\x02\u0CD4\u0CD5\x03\x02\x02\x02\u0CD5\u0CD6\x03" +
|
|
"\x02\x02\x02\u0CD6\u0CD7\x07{\x02\x02\u0CD7\u0CD8\x05\u0112\x8A\x02\u0CD8" +
|
|
"\u0CD9\x07\x05\x02\x02\u0CD9\u0CFF\x03\x02\x02\x02\u0CDA\u0CDB\x07\xD3" +
|
|
"\x02\x02\u0CDB\u0CDC\x07\x04\x02\x02\u0CDC\u0CDD\x05\u0112\x8A\x02\u0CDD" +
|
|
"\u0CDE\x07\xDC\x02\x02\u0CDE\u0CDF\x05\u0112\x8A\x02\u0CDF\u0CE0\x07{" +
|
|
"\x02\x02\u0CE0\u0CE3\x05\u0112\x8A\x02\u0CE1\u0CE2\x07w\x02\x02\u0CE2" +
|
|
"\u0CE4\x05\u0112\x8A\x02\u0CE3\u0CE1\x03\x02\x02\x02\u0CE3\u0CE4\x03\x02" +
|
|
"\x02\x02\u0CE4\u0CE5\x03\x02\x02\x02\u0CE5\u0CE6\x07\x05\x02\x02\u0CE6" +
|
|
"\u0CFF\x03\x02\x02\x02\u0CE7\u0CE8\t.\x02\x02\u0CE8\u0CE9\x07\x04\x02" +
|
|
"\x02\u0CE9\u0CEA\x05\u0112\x8A\x02\u0CEA\u0CEB\x07\x05\x02\x02\u0CEB\u0CEC" +
|
|
"\x07\u0156\x02\x02\u0CEC\u0CED\x07\x82\x02\x02\u0CED\u0CEE\x07\x04\x02" +
|
|
"\x02\u0CEE\u0CEF\x07\xCD\x02\x02\u0CEF\u0CF0\x07!\x02\x02\u0CF0\u0CF1" +
|
|
"\x05f4\x02\u0CF1\u0CF8\x07\x05\x02\x02\u0CF2\u0CF3\x07r\x02\x02\u0CF3" +
|
|
"\u0CF4\x07\x04\x02\x02\u0CF4\u0CF5\x07\u0153\x02\x02\u0CF5\u0CF6\x05\u010E" +
|
|
"\x88\x02\u0CF6\u0CF7\x07\x05\x02\x02\u0CF7\u0CF9\x03\x02\x02\x02\u0CF8" +
|
|
"\u0CF2\x03\x02\x02\x02\u0CF8\u0CF9\x03\x02\x02\x02\u0CF9\u0CFC\x03\x02" +
|
|
"\x02\x02\u0CFA\u0CFB\x07\xD1\x02\x02\u0CFB\u0CFD\x05\u015A\xAE\x02\u0CFC" +
|
|
"\u0CFA\x03\x02\x02\x02\u0CFC\u0CFD\x03\x02\x02\x02\u0CFD\u0CFF\x03\x02" +
|
|
"\x02\x02\u0CFE\u0C05\x03\x02\x02\x02\u0CFE\u0C07\x03\x02\x02\x02\u0CFE" +
|
|
"\u0C13\x03\x02\x02\x02\u0CFE\u0C1F\x03\x02\x02\x02\u0CFE\u0C2B\x03\x02" +
|
|
"\x02\x02\u0CFE\u0C38\x03\x02\x02\x02\u0CFE\u0C3F\x03\x02\x02\x02\u0CFE" +
|
|
"\u0C4C\x03\x02\x02\x02\u0CFE\u0C55\x03\x02\x02\x02\u0CFE\u0C5E\x03\x02" +
|
|
"\x02\x02\u0CFE\u0C67\x03\x02\x02\x02\u0CFE\u0C6E\x03\x02\x02\x02\u0CFE" +
|
|
"\u0C6F\x03\x02\x02\x02\u0CFE\u0C70\x03\x02\x02\x02\u0CFE\u0C74\x03\x02" +
|
|
"\x02\x02\u0CFE\u0C7E\x03\x02\x02\x02\u0CFE\u0C82\x03\x02\x02\x02\u0CFE" +
|
|
"\u0C87\x03\x02\x02\x02\u0CFE\u0CA7\x03\x02\x02\x02\u0CFE\u0CAB\x03\x02" +
|
|
"\x02\x02\u0CFE\u0CB7\x03\x02\x02\x02\u0CFE\u0CB8\x03\x02\x02\x02\u0CFE" +
|
|
"\u0CBC\x03\x02\x02\x02\u0CFE\u0CC3\x03\x02\x02\x02\u0CFE\u0CCE\x03\x02" +
|
|
"\x02\x02\u0CFE\u0CDA\x03\x02\x02\x02\u0CFE\u0CE7\x03\x02\x02\x02\u0CFF" +
|
|
"\u0D0A\x03\x02\x02\x02\u0D00\u0D01\f\v\x02\x02\u0D01\u0D02\x07\b\x02\x02" +
|
|
"\u0D02\u0D03\x05\u0112\x8A\x02\u0D03\u0D04\x07\t\x02\x02\u0D04\u0D09\x03" +
|
|
"\x02\x02\x02\u0D05\u0D06\f\t\x02\x02\u0D06\u0D07\x07\x07\x02\x02\u0D07" +
|
|
"\u0D09\x05\u016C\xB7\x02\u0D08\u0D00\x03\x02\x02\x02\u0D08\u0D05\x03\x02" +
|
|
"\x02\x02\u0D09\u0D0C\x03\x02\x02\x02\u0D0A\u0D08\x03\x02\x02\x02\u0D0A" +
|
|
"\u0D0B\x03\x02\x02\x02\u0D0B\u0117\x03\x02\x02\x02\u0D0C\u0D0A\x03\x02" +
|
|
"\x02\x02\u0D0D\u0D15\x07I\x02\x02\u0D0E\u0D15\x07\u012A\x02\x02\u0D0F" +
|
|
"\u0D15\x07\u012B\x02\x02\u0D10\u0D15\x07\u012C\x02\x02\u0D11\u0D15\x07" +
|
|
"\x95\x02\x02\u0D12\u0D15\x07\x85\x02\x02\u0D13\u0D15\x05\u016C\xB7\x02" +
|
|
"\u0D14\u0D0D\x03\x02\x02\x02\u0D14\u0D0E\x03\x02\x02\x02\u0D14\u0D0F\x03" +
|
|
"\x02\x02\x02\u0D14\u0D10\x03\x02\x02\x02\u0D14\u0D11\x03\x02\x02\x02\u0D14" +
|
|
"\u0D12\x03\x02\x02\x02\u0D14\u0D13\x03\x02\x02\x02\u0D15\u0119\x03\x02" +
|
|
"\x02\x02\u0D16\u0D26\x07\xC3\x02\x02\u0D17\u0D26\x07\u0172\x02\x02\u0D18" +
|
|
"\u0D19\x07\u016D\x02\x02\u0D19\u0D26\x05\u016C\xB7\x02\u0D1A\u0D26\x05" +
|
|
"\u0124\x93\x02\u0D1B\u0D1C\x05\u0118\x8D\x02\u0D1C\u0D1D\x05\u0178\xBD" +
|
|
"\x02\u0D1D\u0D26\x03\x02\x02\x02\u0D1E\u0D26\x05\u0174\xBB\x02\u0D1F\u0D26" +
|
|
"\x05\u0122\x92\x02\u0D20\u0D22\x05\u0178\xBD\x02\u0D21\u0D20\x03\x02\x02" +
|
|
"\x02\u0D22\u0D23\x03\x02\x02\x02\u0D23\u0D21\x03\x02\x02\x02\u0D23\u0D24" +
|
|
"\x03\x02\x02\x02\u0D24\u0D26\x03\x02\x02\x02\u0D25\u0D16\x03\x02\x02\x02" +
|
|
"\u0D25\u0D17\x03\x02\x02\x02\u0D25\u0D18\x03\x02\x02\x02\u0D25\u0D1A\x03" +
|
|
"\x02\x02\x02\u0D25\u0D1B\x03\x02\x02\x02\u0D25\u0D1E\x03\x02\x02\x02\u0D25" +
|
|
"\u0D1F\x03\x02\x02\x02\u0D25\u0D21\x03\x02\x02\x02\u0D26\u011B\x03\x02" +
|
|
"\x02\x02\u0D27\u0D28\t/\x02\x02\u0D28\u011D\x03\x02\x02\x02\u0D29\u0D2A" +
|
|
"\t0\x02\x02\u0D2A\u011F\x03\x02\x02\x02\u0D2B\u0D2C\t1\x02\x02\u0D2C\u0121" +
|
|
"\x03\x02\x02\x02\u0D2D\u0D2E\t2\x02\x02\u0D2E\u0123\x03\x02\x02\x02\u0D2F" +
|
|
"\u0D32\x07\x95\x02\x02\u0D30\u0D33\x05\u0126\x94\x02\u0D31\u0D33\x05\u012A" +
|
|
"\x96\x02\u0D32\u0D30\x03\x02\x02\x02\u0D32\u0D31\x03\x02\x02\x02\u0D33" +
|
|
"\u0125\x03\x02\x02\x02\u0D34\u0D36\x05\u0128\x95\x02\u0D35\u0D37\x05\u012C" +
|
|
"\x97\x02\u0D36\u0D35\x03\x02\x02\x02\u0D36\u0D37\x03\x02\x02\x02\u0D37" +
|
|
"\u0127\x03\x02\x02\x02\u0D38\u0D39\x05\u012E\x98\x02\u0D39\u0D3A\x05\u0130" +
|
|
"\x99\x02\u0D3A\u0D3C\x03\x02\x02\x02\u0D3B\u0D38\x03\x02\x02\x02\u0D3C" +
|
|
"\u0D3D\x03\x02\x02\x02\u0D3D\u0D3B\x03\x02\x02\x02\u0D3D\u0D3E\x03\x02" +
|
|
"\x02\x02\u0D3E\u0129\x03\x02\x02\x02\u0D3F\u0D42\x05\u012C\x97\x02\u0D40" +
|
|
"\u0D43\x05\u0128\x95\x02\u0D41\u0D43\x05\u012C\x97\x02\u0D42\u0D40\x03" +
|
|
"\x02\x02\x02\u0D42\u0D41\x03\x02\x02\x02\u0D42\u0D43\x03\x02\x02\x02\u0D43" +
|
|
"\u012B\x03\x02\x02\x02\u0D44\u0D45\x05\u012E\x98\x02\u0D45\u0D46\x05\u0132" +
|
|
"\x9A\x02\u0D46\u0D47\x07\u0130\x02\x02\u0D47\u0D48\x05\u0132\x9A\x02\u0D48" +
|
|
"\u012D\x03\x02\x02\x02\u0D49\u0D4B\t3\x02\x02\u0D4A\u0D49\x03\x02\x02" +
|
|
"\x02\u0D4A\u0D4B\x03\x02\x02\x02\u0D4B\u0D4F\x03\x02\x02\x02\u0D4C\u0D50" +
|
|
"\x07\u0178\x02\x02\u0D4D\u0D50\x07\u017A\x02\x02\u0D4E\u0D50\x05\u0178" +
|
|
"\xBD\x02\u0D4F\u0D4C\x03\x02\x02\x02\u0D4F\u0D4D\x03\x02\x02\x02\u0D4F" +
|
|
"\u0D4E\x03\x02\x02\x02\u0D50\u012F\x03\x02\x02\x02\u0D51\u0D52\t4\x02" +
|
|
"\x02\u0D52\u0131\x03\x02\x02\x02\u0D53\u0D54\t5\x02\x02\u0D54\u0133\x03" +
|
|
"\x02\x02\x02\u0D55\u0D59\x07t\x02\x02\u0D56\u0D57\x07\v\x02\x02\u0D57" +
|
|
"\u0D59\x05\u0168\xB5\x02\u0D58\u0D55\x03\x02\x02\x02\u0D58\u0D56\x03\x02" +
|
|
"\x02\x02\u0D59\u0135\x03\x02\x02\x02\u0D5A\u0D79\x07\x1D\x02\x02\u0D5B" +
|
|
"\u0D79\x07\u012F\x02\x02\u0D5C\u0D79\x07\"\x02\x02\u0D5D\u0D79\x07\u010F" +
|
|
"\x02\x02\u0D5E\u0D79\x07\u010B\x02\x02\u0D5F\u0D79\x07\x96\x02\x02\u0D60" +
|
|
"\u0D79\x07\x97\x02\x02\u0D61\u0D79\x07\x1B\x02\x02\u0D62\u0D79\x07\xAD" +
|
|
"\x02\x02\u0D63\u0D79\x07u\x02\x02\u0D64\u0D79\x07\xE6\x02\x02\u0D65\u0D79" +
|
|
"\x07`\x02\x02\u0D66\u0D79\x07I\x02\x02\u0D67\u0D79\x07\u012A\x02\x02\u0D68" +
|
|
"\u0D79\x07\u012C\x02\x02\u0D69\u0D79\x07\u012B\x02\x02\u0D6A\u0D79\x07" +
|
|
"\u0118\x02\x02\u0D6B\u0D79\x07+\x02\x02\u0D6C\u0D79\x07*\x02\x02\u0D6D" +
|
|
"\u0D79\x07\u0149\x02\x02\u0D6E\u0D79\x07\x1C\x02\x02\u0D6F\u0D79\x07R" +
|
|
"\x02\x02\u0D70\u0D79\x07Q\x02\x02\u0D71\u0D79\x07\xC5\x02\x02\u0D72\u0D79" +
|
|
"\x07\u014F\x02\x02\u0D73\u0D79\x07\x95\x02\x02\u0D74\u0D79\x07\x15\x02" +
|
|
"\x02\u0D75\u0D79\x07\u0119\x02\x02\u0D76\u0D79\x07\xAF\x02\x02\u0D77\u0D79" +
|
|
"\x05\u016C\xB7\x02\u0D78\u0D5A\x03\x02\x02\x02\u0D78\u0D5B\x03\x02\x02" +
|
|
"\x02\u0D78\u0D5C\x03\x02\x02\x02\u0D78\u0D5D\x03\x02\x02\x02\u0D78\u0D5E" +
|
|
"\x03\x02\x02\x02\u0D78\u0D5F\x03\x02\x02\x02\u0D78\u0D60\x03\x02\x02\x02" +
|
|
"\u0D78\u0D61\x03\x02\x02\x02\u0D78\u0D62\x03\x02\x02\x02\u0D78\u0D63\x03" +
|
|
"\x02\x02\x02\u0D78\u0D64\x03\x02\x02\x02\u0D78\u0D65\x03\x02\x02\x02\u0D78" +
|
|
"\u0D66\x03\x02\x02\x02\u0D78\u0D67\x03\x02\x02\x02\u0D78\u0D68\x03\x02" +
|
|
"\x02\x02\u0D78\u0D69\x03\x02\x02\x02\u0D78\u0D6A\x03\x02\x02\x02\u0D78" +
|
|
"\u0D6B\x03\x02\x02\x02\u0D78\u0D6C\x03\x02\x02\x02\u0D78\u0D6D\x03\x02" +
|
|
"\x02\x02\u0D78\u0D6E\x03\x02\x02\x02\u0D78\u0D6F\x03\x02\x02\x02\u0D78" +
|
|
"\u0D70\x03\x02\x02\x02\u0D78\u0D71\x03\x02\x02\x02\u0D78\u0D72\x03\x02" +
|
|
"\x02\x02\u0D78\u0D73\x03\x02\x02\x02\u0D78\u0D74\x03\x02\x02\x02\u0D78" +
|
|
"\u0D75\x03\x02\x02\x02\u0D78\u0D76\x03\x02\x02\x02\u0D78\u0D77\x03\x02" +
|
|
"\x02\x02\u0D79\u0137\x03\x02\x02\x02\u0D7A\u0D7B\x07\x15\x02\x02\u0D7B" +
|
|
"\u0D7C\x07\u015E\x02\x02\u0D7C\u0D7D\x05\u0138\x9D\x02\u0D7D\u0D7E\x07" +
|
|
"\u0160\x02\x02\u0D7E\u0DA9\x03\x02\x02\x02\u0D7F\u0D80\x07\xAF\x02\x02" +
|
|
"\u0D80\u0D81\x07\u015E\x02\x02\u0D81\u0D82\x05\u0138\x9D\x02\u0D82\u0D83" +
|
|
"\x07\x06\x02\x02\u0D83\u0D84\x05\u0138\x9D\x02\u0D84\u0D85\x07\u0160\x02" +
|
|
"\x02\u0D85\u0DA9\x03\x02\x02\x02\u0D86\u0D8D\x07\u0119\x02\x02\u0D87\u0D89" +
|
|
"\x07\u015E\x02\x02\u0D88\u0D8A\x05\u0150\xA9\x02\u0D89\u0D88\x03\x02\x02" +
|
|
"\x02\u0D89\u0D8A\x03\x02\x02\x02\u0D8A\u0D8B\x03\x02\x02\x02\u0D8B\u0D8E" +
|
|
"\x07\u0160\x02\x02\u0D8C\u0D8E\x07\u015C\x02\x02\u0D8D\u0D87\x03\x02\x02" +
|
|
"\x02\u0D8D\u0D8C\x03\x02\x02\x02\u0D8E\u0DA9\x03\x02\x02\x02\u0D8F\u0D90" +
|
|
"\x07\x95\x02\x02\u0D90\u0D93\t6\x02\x02\u0D91\u0D92\x07\u0130\x02\x02" +
|
|
"\u0D92\u0D94\x07\xB8\x02\x02\u0D93\u0D91\x03\x02\x02\x02\u0D93\u0D94\x03" +
|
|
"\x02\x02\x02\u0D94\u0DA9\x03\x02\x02\x02\u0D95\u0D96\x07\x95\x02\x02\u0D96" +
|
|
"\u0D99\t7\x02\x02\u0D97\u0D98\x07\u0130\x02\x02\u0D98\u0D9A\t8\x02\x02" +
|
|
"\u0D99\u0D97\x03\x02\x02\x02\u0D99\u0D9A\x03\x02\x02\x02\u0D9A\u0DA9\x03" +
|
|
"\x02\x02\x02\u0D9B\u0DA6\x05\u0136\x9C\x02\u0D9C\u0D9D\x07\x04\x02\x02" +
|
|
"\u0D9D\u0DA2\x07\u0178\x02\x02\u0D9E\u0D9F\x07\x06\x02\x02\u0D9F\u0DA1" +
|
|
"\x07\u0178\x02\x02\u0DA0\u0D9E\x03\x02\x02\x02\u0DA1\u0DA4\x03\x02\x02" +
|
|
"\x02\u0DA2\u0DA0\x03\x02\x02\x02\u0DA2\u0DA3\x03\x02\x02\x02\u0DA3\u0DA5" +
|
|
"\x03\x02\x02\x02\u0DA4\u0DA2\x03\x02\x02\x02\u0DA5\u0DA7\x07\x05\x02\x02" +
|
|
"\u0DA6\u0D9C\x03\x02\x02\x02\u0DA6\u0DA7\x03\x02\x02\x02\u0DA7\u0DA9\x03" +
|
|
"\x02\x02\x02\u0DA8\u0D7A\x03\x02\x02\x02\u0DA8\u0D7F\x03\x02\x02\x02\u0DA8" +
|
|
"\u0D86\x03\x02\x02\x02\u0DA8\u0D8F\x03\x02\x02\x02\u0DA8\u0D95\x03\x02" +
|
|
"\x02\x02\u0DA8\u0D9B\x03\x02\x02\x02\u0DA9\u0139\x03\x02\x02\x02\u0DAA" +
|
|
"\u0DAF\x05\u013C\x9F\x02\u0DAB\u0DAC\x07\x06\x02\x02\u0DAC\u0DAE\x05\u013C" +
|
|
"\x9F\x02\u0DAD\u0DAB\x03\x02\x02\x02\u0DAE\u0DB1\x03\x02\x02\x02\u0DAF" +
|
|
"\u0DAD\x03\x02\x02\x02\u0DAF\u0DB0\x03\x02\x02\x02\u0DB0\u013B\x03\x02" +
|
|
"\x02\x02\u0DB1\u0DAF\x03\x02\x02\x02\u0DB2\u0DB3\x05\xF0y\x02\u0DB3\u0DB7" +
|
|
"\x05\u0138\x9D\x02\u0DB4\u0DB6\x05\u013E\xA0\x02\u0DB5\u0DB4\x03\x02\x02" +
|
|
"\x02\u0DB6\u0DB9\x03\x02\x02\x02\u0DB7\u0DB5\x03\x02\x02\x02\u0DB7\u0DB8" +
|
|
"\x03\x02\x02\x02\u0DB8\u013D\x03\x02\x02\x02\u0DB9\u0DB7\x03\x02\x02\x02" +
|
|
"\u0DBA\u0DBB\x07\xC2\x02\x02\u0DBB\u0DC0\x07\xC3\x02\x02\u0DBC\u0DC0\x05" +
|
|
"\u0140\xA1\x02\u0DBD\u0DC0\x05\x1A\x0E\x02\u0DBE\u0DC0\x05\u0134\x9B\x02" +
|
|
"\u0DBF\u0DBA\x03\x02\x02\x02\u0DBF\u0DBC\x03\x02\x02\x02\u0DBF\u0DBD\x03" +
|
|
"\x02\x02\x02\u0DBF\u0DBE\x03\x02\x02\x02\u0DC0\u013F\x03\x02\x02\x02\u0DC1" +
|
|
"\u0DC2\x07T\x02\x02\u0DC2\u0DC3\x05\u0106\x84\x02\u0DC3\u0141\x03\x02" +
|
|
"\x02\x02\u0DC4\u0DC5\t9\x02\x02\u0DC5\u0DC6\x05\u0106\x84\x02\u0DC6\u0143" +
|
|
"\x03\x02\x02\x02\u0DC7\u0DCC\x05\u0146\xA4\x02\u0DC8\u0DC9\x07\x06\x02" +
|
|
"\x02\u0DC9\u0DCB\x05\u0146\xA4\x02\u0DCA\u0DC8\x03\x02\x02\x02\u0DCB\u0DCE" +
|
|
"\x03\x02\x02\x02\u0DCC\u0DCA\x03\x02\x02\x02\u0DCC\u0DCD\x03\x02\x02\x02" +
|
|
"\u0DCD\u0145\x03\x02\x02\x02\u0DCE\u0DCC\x03\x02\x02\x02\u0DCF\u0DD0\x05" +
|
|
"\u0168\xB5\x02\u0DD0\u0DD3\x05\u0138\x9D\x02\u0DD1\u0DD2\x07\xC2\x02\x02" +
|
|
"\u0DD2\u0DD4\x07\xC3\x02\x02\u0DD3\u0DD1\x03\x02\x02\x02\u0DD3\u0DD4\x03" +
|
|
"\x02\x02\x02\u0DD4\u0DD6\x03\x02\x02\x02\u0DD5\u0DD7\x05\x1A\x0E\x02\u0DD6" +
|
|
"\u0DD5\x03\x02\x02\x02\u0DD6\u0DD7\x03\x02\x02\x02\u0DD7\u0147\x03\x02" +
|
|
"\x02\x02\u0DD8\u0DDD\x05\u014A\xA6\x02\u0DD9\u0DDA\x07\x06\x02\x02\u0DDA" +
|
|
"\u0DDC\x05\u014A\xA6\x02\u0DDB\u0DD9\x03\x02\x02\x02\u0DDC\u0DDF\x03\x02" +
|
|
"\x02\x02\u0DDD\u0DDB\x03\x02\x02\x02\u0DDD\u0DDE\x03\x02\x02\x02\u0DDE" +
|
|
"\u0149\x03\x02\x02\x02\u0DDF\u0DDD\x03\x02\x02\x02\u0DE0\u0DE1\x05\u0168" +
|
|
"\xB5\x02\u0DE1\u0DE5\x05\u0138\x9D\x02\u0DE2\u0DE4\x05\u014C\xA7\x02\u0DE3" +
|
|
"\u0DE2\x03\x02\x02\x02\u0DE4\u0DE7\x03\x02\x02\x02\u0DE5\u0DE3\x03\x02" +
|
|
"\x02\x02\u0DE5\u0DE6\x03\x02\x02\x02\u0DE6\u014B\x03\x02\x02\x02\u0DE7" +
|
|
"\u0DE5\x03\x02\x02\x02\u0DE8\u0DE9\x07\xC2\x02\x02\u0DE9\u0DEE\x07\xC3" +
|
|
"\x02\x02\u0DEA\u0DEE\x05\u0140\xA1\x02\u0DEB\u0DEE\x05\u014E\xA8\x02\u0DEC" +
|
|
"\u0DEE\x05\x1A\x0E\x02\u0DED\u0DE8\x03\x02\x02\x02\u0DED\u0DEA\x03\x02" +
|
|
"\x02\x02\u0DED\u0DEB\x03\x02\x02\x02\u0DED\u0DEC\x03\x02\x02\x02\u0DEE" +
|
|
"\u014D\x03\x02\x02\x02\u0DEF\u0DF0\x07\x7F\x02\x02\u0DF0\u0DF1\x07\x0E" +
|
|
"\x02\x02\u0DF1\u0DF2\x07\x16\x02\x02\u0DF2\u0DF3\x07\x04\x02\x02\u0DF3" +
|
|
"\u0DF4\x05\u0106\x84\x02\u0DF4\u0DF5\x07\x05\x02\x02\u0DF5\u014F\x03\x02" +
|
|
"\x02\x02\u0DF6\u0DFB\x05\u0152\xAA\x02\u0DF7\u0DF8\x07\x06\x02\x02\u0DF8" +
|
|
"\u0DFA\x05\u0152\xAA\x02\u0DF9\u0DF7\x03\x02\x02\x02\u0DFA\u0DFD\x03\x02" +
|
|
"\x02\x02\u0DFB\u0DF9\x03\x02\x02\x02\u0DFB\u0DFC\x03\x02\x02\x02\u0DFC" +
|
|
"\u0151\x03\x02\x02\x02\u0DFD\u0DFB\x03\x02\x02\x02\u0DFE\u0E00\x05\u016C" +
|
|
"\xB7\x02\u0DFF\u0E01\x07\u016D\x02\x02\u0E00\u0DFF\x03\x02\x02\x02\u0E00" +
|
|
"\u0E01\x03\x02\x02\x02\u0E01\u0E02\x03\x02\x02\x02\u0E02\u0E05\x05\u0138" +
|
|
"\x9D\x02\u0E03\u0E04\x07\xC2\x02\x02\u0E04\u0E06\x07\xC3\x02\x02\u0E05" +
|
|
"\u0E03\x03\x02\x02\x02\u0E05\u0E06\x03\x02\x02\x02\u0E06\u0E08\x03\x02" +
|
|
"\x02\x02\u0E07\u0E09\x05\x1A\x0E\x02\u0E08\u0E07\x03\x02\x02\x02\u0E08" +
|
|
"\u0E09\x03\x02\x02\x02\u0E09\u0153\x03\x02\x02\x02\u0E0A\u0E0B\x07\u0152" +
|
|
"\x02\x02\u0E0B\u0E0C\x05\u0106\x84\x02\u0E0C\u0E0D\x07\u0127\x02\x02\u0E0D" +
|
|
"\u0E0E\x05\u0106\x84\x02\u0E0E\u0155\x03\x02\x02\x02\u0E0F\u0E10\x07\u0154" +
|
|
"\x02\x02\u0E10\u0E15\x05\u0158\xAD\x02\u0E11\u0E12\x07\x06\x02\x02\u0E12" +
|
|
"\u0E14\x05\u0158\xAD\x02\u0E13\u0E11\x03\x02\x02\x02\u0E14\u0E17\x03\x02" +
|
|
"\x02\x02\u0E15\u0E13\x03\x02\x02\x02\u0E15\u0E16\x03\x02\x02\x02\u0E16" +
|
|
"\u0157\x03\x02\x02\x02\u0E17\u0E15\x03\x02\x02\x02\u0E18\u0E19\x05\u0168" +
|
|
"\xB5\x02\u0E19\u0E1A\x07\x16\x02\x02\u0E1A\u0E1B\x05\u015A\xAE\x02\u0E1B" +
|
|
"\u0159\x03\x02\x02\x02\u0E1C\u0E4B\x05\u0168\xB5\x02\u0E1D\u0E1E\x07\x04" +
|
|
"\x02\x02\u0E1E\u0E1F\x05\u0168\xB5\x02\u0E1F\u0E20\x07\x05\x02\x02\u0E20" +
|
|
"\u0E4B\x03\x02\x02\x02\u0E21\u0E44\x07\x04\x02\x02\u0E22\u0E23\x07.\x02" +
|
|
"\x02\u0E23\u0E24\x07!\x02\x02\u0E24\u0E29\x05\u0106\x84\x02\u0E25\u0E26" +
|
|
"\x07\x06\x02\x02\u0E26\u0E28\x05\u0106\x84\x02\u0E27\u0E25\x03\x02\x02" +
|
|
"\x02\u0E28\u0E2B\x03\x02\x02\x02\u0E29\u0E27\x03\x02\x02\x02\u0E29\u0E2A" +
|
|
"\x03\x02\x02\x02\u0E2A\u0E45\x03\x02\x02\x02\u0E2B\u0E29\x03\x02\x02\x02" +
|
|
"\u0E2C\u0E2D\t\x1A\x02\x02\u0E2D\u0E2E\x07!\x02\x02\u0E2E\u0E33\x05\u0106" +
|
|
"\x84\x02\u0E2F\u0E30\x07\x06\x02\x02\u0E30\u0E32\x05\u0106\x84\x02\u0E31" +
|
|
"\u0E2F\x03\x02\x02\x02\u0E32\u0E35\x03\x02\x02\x02\u0E33\u0E31\x03\x02" +
|
|
"\x02\x02\u0E33\u0E34\x03\x02\x02\x02\u0E34\u0E37\x03\x02\x02\x02\u0E35" +
|
|
"\u0E33\x03\x02\x02\x02\u0E36\u0E2C\x03\x02\x02\x02\u0E36\u0E37\x03\x02" +
|
|
"\x02\x02\u0E37\u0E42\x03\x02\x02\x02\u0E38\u0E39\t\x1B\x02\x02\u0E39\u0E3A" +
|
|
"\x07!\x02\x02\u0E3A\u0E3F\x05f4\x02\u0E3B\u0E3C\x07\x06\x02\x02\u0E3C" +
|
|
"\u0E3E\x05f4\x02\u0E3D\u0E3B\x03\x02\x02\x02\u0E3E\u0E41\x03\x02\x02\x02" +
|
|
"\u0E3F\u0E3D\x03\x02\x02\x02\u0E3F\u0E40\x03\x02\x02\x02\u0E40\u0E43\x03" +
|
|
"\x02\x02\x02\u0E41\u0E3F\x03\x02\x02\x02\u0E42\u0E38\x03\x02\x02\x02\u0E42" +
|
|
"\u0E43\x03\x02\x02\x02\u0E43\u0E45\x03\x02\x02\x02\u0E44\u0E22\x03\x02" +
|
|
"\x02\x02\u0E44\u0E36\x03\x02\x02\x02\u0E45\u0E47\x03\x02\x02\x02\u0E46" +
|
|
"\u0E48\x05\u015C\xAF\x02\u0E47\u0E46\x03\x02\x02\x02\u0E47\u0E48\x03\x02" +
|
|
"\x02\x02\u0E48\u0E49\x03\x02\x02\x02\u0E49\u0E4B\x07\x05\x02\x02\u0E4A" +
|
|
"\u0E1C\x03\x02\x02\x02\u0E4A\u0E1D\x03\x02\x02\x02\u0E4A\u0E21\x03\x02" +
|
|
"\x02\x02\u0E4B\u015B\x03\x02\x02\x02\u0E4C\u0E4D\x07\xE5\x02\x02\u0E4D" +
|
|
"\u0E5D\x05\u015E\xB0\x02\u0E4E\u0E4F\x07\xFD\x02\x02\u0E4F\u0E5D\x05\u015E" +
|
|
"\xB0\x02\u0E50\u0E51\x07\xE5\x02\x02\u0E51\u0E52\x07\x1A\x02\x02\u0E52" +
|
|
"\u0E53\x05\u015E\xB0\x02\u0E53\u0E54\x07\x10\x02\x02\u0E54\u0E55\x05\u015E" +
|
|
"\xB0\x02\u0E55\u0E5D\x03\x02\x02\x02\u0E56\u0E57\x07\xFD\x02\x02\u0E57" +
|
|
"\u0E58\x07\x1A\x02\x02\u0E58\u0E59\x05\u015E\xB0\x02\u0E59\u0E5A\x07\x10" +
|
|
"\x02\x02\u0E5A\u0E5B\x05\u015E\xB0\x02\u0E5B\u0E5D\x03\x02\x02\x02\u0E5C" +
|
|
"\u0E4C\x03\x02\x02\x02\u0E5C\u0E4E\x03\x02\x02\x02\u0E5C\u0E50\x03\x02" +
|
|
"\x02\x02\u0E5C\u0E56\x03\x02\x02\x02\u0E5D\u015D\x03\x02\x02\x02\u0E5E" +
|
|
"\u0E5F\x07\u013C\x02\x02\u0E5F\u0E66\t:\x02\x02\u0E60\u0E61\x07@\x02\x02" +
|
|
"\u0E61\u0E66\x07\xFC\x02\x02\u0E62\u0E63\x05\u0106\x84\x02\u0E63\u0E64" +
|
|
"\t:\x02\x02\u0E64\u0E66\x03\x02\x02\x02\u0E65\u0E5E\x03\x02\x02\x02\u0E65" +
|
|
"\u0E60\x03\x02\x02\x02\u0E65\u0E62\x03\x02\x02\x02\u0E66\u015F\x03\x02" +
|
|
"\x02\x02\u0E67\u0E6C\x05\u0166\xB4\x02\u0E68\u0E69\x07\x06\x02\x02\u0E69" +
|
|
"\u0E6B\x05\u0166\xB4\x02\u0E6A\u0E68\x03\x02\x02\x02\u0E6B\u0E6E\x03\x02" +
|
|
"\x02\x02\u0E6C\u0E6A\x03\x02\x02\x02\u0E6C\u0E6D\x03\x02\x02\x02\u0E6D" +
|
|
"\u0161\x03\x02\x02\x02\u0E6E\u0E6C\x03\x02\x02\x02\u0E6F\u0E70\x07\x88" +
|
|
"\x02\x02\u0E70\u0E71\x07\x04\x02\x02\u0E71\u0E72\x05\u0106\x84\x02\u0E72" +
|
|
"\u0E73\x07\x05\x02\x02\u0E73\u0E79\x03\x02\x02\x02\u0E74\u0E79\x05\u0166" +
|
|
"\xB4\x02\u0E75\u0E79\x07r\x02\x02\u0E76\u0E79\x07\xA1\x02\x02\u0E77\u0E79" +
|
|
"\x07\xF5\x02\x02\u0E78\u0E6F\x03\x02\x02\x02\u0E78\u0E74\x03\x02\x02\x02" +
|
|
"\u0E78\u0E75\x03\x02\x02\x02\u0E78\u0E76\x03\x02\x02\x02\u0E78\u0E77\x03" +
|
|
"\x02\x02\x02\u0E79\u0163\x03\x02\x02\x02\u0E7A\u0E7B\x05\u0166\xB4\x02" +
|
|
"\u0E7B\u0165\x03\x02\x02\x02\u0E7C\u0E81\x05\u016C\xB7\x02\u0E7D\u0E7E" +
|
|
"\x07\x07\x02\x02\u0E7E\u0E80\x05\u016C\xB7\x02\u0E7F\u0E7D\x03\x02\x02" +
|
|
"\x02\u0E80\u0E83\x03\x02\x02\x02\u0E81\u0E7F\x03\x02\x02\x02\u0E81\u0E82" +
|
|
"\x03\x02\x02\x02\u0E82\u0167\x03\x02\x02\x02\u0E83\u0E81\x03\x02\x02\x02" +
|
|
"\u0E84\u0E85\x05\u016C\xB7\x02\u0E85\u0E86\x05\u016A\xB6\x02\u0E86\u0169" +
|
|
"\x03\x02\x02\x02\u0E87\u0E88\x07\u0164\x02\x02\u0E88\u0E8A\x05\u016C\xB7" +
|
|
"\x02\u0E89\u0E87\x03\x02\x02\x02\u0E8A\u0E8B\x03\x02\x02\x02\u0E8B\u0E89" +
|
|
"\x03\x02\x02\x02\u0E8B\u0E8C\x03\x02\x02\x02\u0E8C\u0E8F\x03\x02\x02\x02" +
|
|
"\u0E8D\u0E8F\x03\x02\x02\x02\u0E8E\u0E89\x03\x02\x02\x02\u0E8E\u0E8D\x03" +
|
|
"\x02\x02\x02\u0E8F\u016B\x03\x02\x02\x02\u0E90\u0E94\x05\u016E\xB8\x02" +
|
|
"\u0E91\u0E92\x06\xB7\x12\x02\u0E92\u0E94\x05\u0180\xC1\x02\u0E93\u0E90" +
|
|
"\x03\x02\x02\x02\u0E93\u0E91\x03\x02\x02\x02\u0E94\u016D\x03\x02\x02\x02" +
|
|
"\u0E95\u0E9C\x07\u017E\x02\x02\u0E96\u0E9C\x05\u0170\xB9\x02\u0E97\u0E98" +
|
|
"\x06\xB8\x13\x02\u0E98\u0E9C\x05\u017E\xC0\x02\u0E99\u0E9A\x06\xB8\x14" +
|
|
"\x02\u0E9A\u0E9C\x05\u0182\xC2\x02\u0E9B\u0E95\x03";
|
|
private static readonly _serializedATNSegment7: string =
|
|
"\x02\x02\x02\u0E9B\u0E96\x03\x02\x02\x02\u0E9B\u0E97\x03\x02\x02\x02\u0E9B" +
|
|
"\u0E99\x03\x02\x02\x02\u0E9C\u016F\x03\x02\x02\x02\u0E9D\u0EA1\x07\u017F" +
|
|
"\x02\x02\u0E9E\u0E9F\x06\xB9\x15\x02\u0E9F\u0EA1\x07\u0174\x02\x02\u0EA0" +
|
|
"\u0E9D\x03\x02\x02\x02\u0EA0\u0E9E\x03\x02\x02\x02\u0EA1\u0171\x03\x02" +
|
|
"\x02\x02\u0EA2\u0EA3\x07\u017F\x02\x02\u0EA3\u0173\x03\x02\x02\x02\u0EA4" +
|
|
"\u0EA6\x06\xBB\x16\x02\u0EA5\u0EA7\x07\u0164\x02\x02\u0EA6\u0EA5\x03\x02" +
|
|
"\x02\x02\u0EA6\u0EA7\x03\x02\x02\x02\u0EA7\u0EA8\x03\x02\x02\x02\u0EA8" +
|
|
"\u0ED0\x07\u0179\x02\x02\u0EA9\u0EAB\x06\xBB\x17\x02\u0EAA\u0EAC\x07\u0164" +
|
|
"\x02\x02\u0EAB\u0EAA\x03\x02\x02\x02\u0EAB\u0EAC\x03\x02\x02\x02\u0EAC" +
|
|
"\u0EAD\x03\x02\x02\x02\u0EAD\u0ED0\x07\u017A\x02\x02\u0EAE\u0EB0\x06\xBB" +
|
|
"\x18\x02\u0EAF\u0EB1\x07\u0164\x02\x02\u0EB0\u0EAF\x03\x02\x02\x02\u0EB0" +
|
|
"\u0EB1\x03\x02\x02\x02\u0EB1\u0EB2\x03\x02\x02\x02\u0EB2\u0ED0\t;\x02" +
|
|
"\x02\u0EB3\u0EB5\x07\u0164\x02\x02\u0EB4\u0EB3\x03\x02\x02\x02\u0EB4\u0EB5" +
|
|
"\x03\x02\x02\x02\u0EB5\u0EB6\x03\x02\x02\x02\u0EB6\u0ED0\x07\u0178\x02" +
|
|
"\x02\u0EB7\u0EB9\x07\u0164\x02\x02\u0EB8\u0EB7\x03\x02\x02\x02\u0EB8\u0EB9" +
|
|
"\x03\x02\x02\x02\u0EB9\u0EBA\x03\x02\x02\x02\u0EBA\u0ED0\x07\u0175\x02" +
|
|
"\x02\u0EBB\u0EBD\x07\u0164\x02\x02\u0EBC\u0EBB\x03\x02\x02\x02\u0EBC\u0EBD" +
|
|
"\x03\x02\x02\x02\u0EBD\u0EBE\x03\x02\x02\x02\u0EBE\u0ED0\x07\u0176\x02" +
|
|
"\x02\u0EBF\u0EC1\x07\u0164\x02\x02\u0EC0\u0EBF\x03\x02\x02\x02\u0EC0\u0EC1" +
|
|
"\x03\x02\x02\x02\u0EC1\u0EC2\x03\x02\x02\x02\u0EC2\u0ED0\x07\u0177\x02" +
|
|
"\x02\u0EC3\u0EC5\x07\u0164\x02\x02\u0EC4\u0EC3\x03\x02\x02\x02\u0EC4\u0EC5" +
|
|
"\x03\x02\x02\x02\u0EC5\u0EC6\x03\x02\x02\x02\u0EC6\u0ED0\x07\u017C\x02" +
|
|
"\x02\u0EC7\u0EC9\x07\u0164\x02\x02\u0EC8\u0EC7\x03\x02\x02\x02\u0EC8\u0EC9" +
|
|
"\x03\x02\x02\x02\u0EC9\u0ECA\x03\x02\x02\x02\u0ECA\u0ED0\x07\u017B\x02" +
|
|
"\x02\u0ECB\u0ECD\x07\u0164\x02\x02\u0ECC\u0ECB\x03\x02\x02\x02\u0ECC\u0ECD" +
|
|
"\x03\x02\x02\x02\u0ECD\u0ECE\x03\x02\x02\x02\u0ECE\u0ED0\x07\u017D\x02" +
|
|
"\x02\u0ECF\u0EA4\x03\x02\x02\x02\u0ECF\u0EA9\x03\x02\x02\x02\u0ECF\u0EAE" +
|
|
"\x03\x02\x02\x02\u0ECF\u0EB4\x03\x02\x02\x02\u0ECF\u0EB8\x03\x02\x02\x02" +
|
|
"\u0ECF\u0EBC\x03\x02\x02\x02\u0ECF\u0EC0\x03\x02\x02\x02\u0ECF\u0EC4\x03" +
|
|
"\x02\x02\x02\u0ECF\u0EC8\x03\x02\x02\x02\u0ECF\u0ECC\x03\x02\x02\x02\u0ED0" +
|
|
"\u0175\x03\x02\x02\x02\u0ED1\u0ED2\x07\u013A\x02\x02\u0ED2\u0EDD\x05\u0138" +
|
|
"\x9D\x02\u0ED3\u0EDD\x05\x1A\x0E\x02\u0ED4\u0EDD\x05\u0134\x9B\x02\u0ED5" +
|
|
"\u0ED6\t<\x02\x02\u0ED6\u0ED7\x07\xC2\x02\x02\u0ED7\u0EDD\x07\xC3\x02" +
|
|
"\x02\u0ED8\u0ED9\x07\u0108\x02\x02\u0ED9\u0EDD\x05\u0140\xA1\x02\u0EDA" +
|
|
"\u0EDB\x07a\x02\x02\u0EDB\u0EDD\x07T\x02\x02\u0EDC\u0ED1\x03\x02\x02\x02" +
|
|
"\u0EDC\u0ED3\x03\x02\x02\x02\u0EDC\u0ED4\x03\x02\x02\x02\u0EDC\u0ED5\x03" +
|
|
"\x02\x02\x02\u0EDC\u0ED8\x03\x02\x02\x02\u0EDC\u0EDA\x03\x02\x02\x02\u0EDD" +
|
|
"\u0177\x03\x02\x02\x02\u0EDE\u0EE2\x07\u0173\x02\x02\u0EDF\u0EE0\x06\xBD" +
|
|
"\x19\x02\u0EE0\u0EE2\x07\u0174\x02\x02\u0EE1\u0EDE\x03\x02\x02\x02\u0EE1" +
|
|
"\u0EDF\x03\x02\x02\x02\u0EE2\u0179\x03\x02\x02\x02\u0EE3\u0EE6\x05\u0178" +
|
|
"\xBD\x02\u0EE4\u0EE6\x07\xC3\x02\x02\u0EE5\u0EE3\x03\x02\x02\x02\u0EE5" +
|
|
"\u0EE4\x03\x02\x02\x02\u0EE6\u017B\x03\x02\x02\x02\u0EE7\u0EEA\x07\u0178" +
|
|
"\x02\x02\u0EE8\u0EEA\x05\u0178\xBD\x02\u0EE9\u0EE7\x03\x02\x02\x02\u0EE9" +
|
|
"\u0EE8\x03\x02\x02\x02\u0EEA\u017D\x03\x02\x02\x02\u0EEB\u0EEC\t=\x02" +
|
|
"\x02\u0EEC\u017F\x03\x02\x02\x02\u0EED\u0EEE\t>\x02\x02\u0EEE\u0181\x03" +
|
|
"\x02\x02\x02\u0EEF\u0EF0\t?\x02\x02\u0EF0\u0183\x03\x02\x02\x02\u01F5" +
|
|
"\u0187\u018E\u0192\u019F\u01A4\u01AC\u01AE\u01C1\u01C5\u01CB\u01CE\u01D1" +
|
|
"\u01D8\u01DB\u01DF\u01E2\u01E7\u01F2\u01F4\u01FC\u01FF\u0203\u0206\u020C" +
|
|
"\u0217\u021D\u0222\u0243\u024F\u0258\u0263\u026E\u0273\u027C\u0280\u0286" +
|
|
"\u028A\u028F\u0295\u02A1\u02A9\u02AF\u02BA\u02BE\u02C3\u02D2\u02D6\u02DD" +
|
|
"\u02E1\u02E7\u02F5\u02F9\u02FE\u0304\u0307\u030A\u030E\u0312\u031A\u031C" +
|
|
"\u0325\u0328\u0331\u0336\u033C\u0343\u0346\u034A\u0355\u0358\u035C\u0360" +
|
|
"\u0366\u0369\u036D\u0370\u0376\u037B\u037F\u0386\u0389\u038C\u0393\u0398" +
|
|
"\u03A1\u03A9\u03AF\u03B2\u03B5\u03BB\u03BF\u03C4\u03C7\u03CB\u03CD\u03D5" +
|
|
"\u03DD\u03E0\u03E5\u03EB\u03F0\u03F3\u03F7\u03FA\u03FE\u041A\u041D\u0421" +
|
|
"\u0427\u042A\u042D\u0432\u043A\u043F\u0445\u044B\u044E\u0455\u045C\u0464" +
|
|
"\u0475\u0490\u0493\u0499\u04A2\u04AB\u04B1\u04B6\u04BB\u04C2\u04C7\u04CC" +
|
|
"\u04D4\u04D7\u04DB\u04E7\u04EB\u04F2\u0566\u056E\u0576\u057F\u0589\u058D" +
|
|
"\u0590\u0594\u059A\u05A6\u05B2\u05B7\u05C0\u05C8\u05CD\u05CF\u05D4\u05D9" +
|
|
"\u05DD\u05E0\u05E5\u05EA\u05F3\u05F8\u05FB\u0600\u0604\u0609\u060B\u060F" +
|
|
"\u0618\u0620\u0626\u0631\u0638\u0641\u0646\u0649\u065F\u0661\u066A\u0671" +
|
|
"\u0674\u067B\u067F\u0685\u068D\u0694\u0697\u069F\u06AA\u06B5\u06BD\u06C3" +
|
|
"\u06CF\u06D6\u06DD\u06E9\u06F1\u06F7\u06FD\u0700\u0714\u071D\u0720\u0729" +
|
|
"\u072C\u0735\u0738\u0741\u0744\u0747\u074C\u074E\u0752\u075E\u0765\u076C" +
|
|
"\u076F\u0771\u077D\u0781\u0785\u078B\u078F\u0797\u079B\u079E\u07A1\u07A4" +
|
|
"\u07A8\u07AC\u07B1\u07B5\u07B8\u07BB\u07BE\u07C2\u07C7\u07CB\u07CE\u07D1" +
|
|
"\u07D4\u07D6\u07DC\u07E3\u07E8\u07EB\u07EE\u07F2\u07FC\u0800\u0802\u0805" +
|
|
"\u0809\u080F\u0813\u081E\u0828\u082C\u0838\u0844\u0853\u0858\u085E\u0865" +
|
|
"\u0875\u087A\u0887\u088C\u0894\u089A\u089E\u08A1\u08A6\u08AD\u08B3\u08BC" +
|
|
"\u08C6\u08D5\u08DA\u08DC\u08E0\u08E9\u08F6\u08FB\u08FF\u0907\u090A\u090E" +
|
|
"\u091C\u0929\u092E\u0932\u0935\u0939\u093F\u0942\u0949\u0955\u0960\u096D" +
|
|
"\u0978\u097D\u0985\u098A\u0998\u09A1\u09A4\u09A9\u09B0\u09B3\u09B8\u09BE" +
|
|
"\u09C2\u09C7\u09CC\u09D0\u09D6\u09DA\u09DD\u09E2\u09E5\u09EA\u09EE\u09F1" +
|
|
"\u09F4\u09FA\u09FF\u0A06\u0A09\u0A1B\u0A1D\u0A20\u0A2B\u0A34\u0A3B\u0A43" +
|
|
"\u0A4A\u0A4E\u0A51\u0A59\u0A61\u0A67\u0A6F\u0A77\u0A7E\u0A85\u0A87\u0A94" +
|
|
"\u0A9A\u0A9C\u0AA6\u0AAC\u0AAE\u0AB6\u0ABA\u0AC3\u0AC6\u0ACC\u0AD0\u0AD2" +
|
|
"\u0ADB\u0AE7\u0AE9\u0AF0\u0AF7\u0AFD\u0B03\u0B05\u0B0C\u0B14\u0B1C\u0B22" +
|
|
"\u0B27\u0B2E\u0B34\u0B38\u0B3A\u0B41\u0B4A\u0B51\u0B5B\u0B60\u0B64\u0B6E" +
|
|
"\u0B75\u0B82\u0B84\u0B8C\u0B8E\u0B92\u0B9A\u0BA3\u0BA9\u0BB1\u0BB6\u0BC2" +
|
|
"\u0BC7\u0BCA\u0BD0\u0BD4\u0BD9\u0BDE\u0BE3\u0BE9\u0BFE\u0C00\u0C0B\u0C17" +
|
|
"\u0C23\u0C27\u0C30\u0C34\u0C46\u0C49\u0C51\u0C5A\u0C63\u0C7A\u0C8A\u0C91" +
|
|
"\u0C94\u0C9D\u0CA1\u0CA5\u0CB1\u0CCA\u0CD1\u0CD4\u0CE3\u0CF8\u0CFC\u0CFE" +
|
|
"\u0D08\u0D0A\u0D14\u0D23\u0D25\u0D32\u0D36\u0D3D\u0D42\u0D4A\u0D4F\u0D58" +
|
|
"\u0D78\u0D89\u0D8D\u0D93\u0D99\u0DA2\u0DA6\u0DA8\u0DAF\u0DB7\u0DBF\u0DCC" +
|
|
"\u0DD3\u0DD6\u0DDD\u0DE5\u0DED\u0DFB\u0E00\u0E05\u0E08\u0E15\u0E29\u0E33" +
|
|
"\u0E36\u0E3F\u0E42\u0E44\u0E47\u0E4A\u0E5C\u0E65\u0E6C\u0E78\u0E81\u0E8B" +
|
|
"\u0E8E\u0E93\u0E9B\u0EA0\u0EA6\u0EAB\u0EB0\u0EB4\u0EB8\u0EBC\u0EC0\u0EC4" +
|
|
"\u0EC8\u0ECC\u0ECF\u0EDC\u0EE1\u0EE5\u0EE9";
|
|
public static readonly _serializedATN: string = Utils.join(
|
|
[
|
|
SparkSqlParser._serializedATNSegment0,
|
|
SparkSqlParser._serializedATNSegment1,
|
|
SparkSqlParser._serializedATNSegment2,
|
|
SparkSqlParser._serializedATNSegment3,
|
|
SparkSqlParser._serializedATNSegment4,
|
|
SparkSqlParser._serializedATNSegment5,
|
|
SparkSqlParser._serializedATNSegment6,
|
|
SparkSqlParser._serializedATNSegment7,
|
|
],
|
|
"",
|
|
);
|
|
public static __ATN: ATN;
|
|
public static get _ATN(): ATN {
|
|
if (!SparkSqlParser.__ATN) {
|
|
SparkSqlParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(SparkSqlParser._serializedATN));
|
|
}
|
|
|
|
return SparkSqlParser.__ATN;
|
|
}
|
|
|
|
}
|
|
|
|
export class ProgramContext extends ParserRuleContext {
|
|
public EOF(): TerminalNode { return this.getToken(SparkSqlParser.EOF, 0); }
|
|
public singleStatement(): SingleStatementContext[];
|
|
public singleStatement(i: number): SingleStatementContext;
|
|
public singleStatement(i?: number): SingleStatementContext | SingleStatementContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(SingleStatementContext);
|
|
} else {
|
|
return this.getRuleContext(i, SingleStatementContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_program; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterProgram) {
|
|
listener.enterProgram(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitProgram) {
|
|
listener.exitProgram(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitProgram) {
|
|
return visitor.visitProgram(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SingleStatementContext extends ParserRuleContext {
|
|
public statement(): StatementContext {
|
|
return this.getRuleContext(0, StatementContext);
|
|
}
|
|
public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SEMICOLON, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_singleStatement; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSingleStatement) {
|
|
listener.enterSingleStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSingleStatement) {
|
|
listener.exitSingleStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSingleStatement) {
|
|
return visitor.visitSingleStatement(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StatementContext extends ParserRuleContext {
|
|
public _pattern!: StringLitContext;
|
|
public _target!: TableNameCreateContext;
|
|
public _source!: TableNameContext;
|
|
public _tableProps!: PropertyListContext;
|
|
public _table!: TableNameContext;
|
|
public _column!: MultipartIdentifierContext;
|
|
public _colName!: MultipartIdentifierContext;
|
|
public _className!: StringLitContext;
|
|
public _ns!: DbSchemaNameContext;
|
|
public _key!: PropertyKeyContext;
|
|
public _legacy!: MultipartIdentifierContext;
|
|
public _option!: Token;
|
|
public _options!: PropertyListContext;
|
|
public _path!: StringLitContext;
|
|
public _op!: Token;
|
|
public _indexType!: IdentifierContext;
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
public dmlStatementNoWith(): DmlStatementNoWithContext | undefined {
|
|
return this.tryGetRuleContext(0, DmlStatementNoWithContext);
|
|
}
|
|
public ctes(): CtesContext | undefined {
|
|
return this.tryGetRuleContext(0, CtesContext);
|
|
}
|
|
public KW_USE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USE, 0); }
|
|
public dbSchemaName(): DbSchemaNameContext | undefined {
|
|
return this.tryGetRuleContext(0, DbSchemaNameContext);
|
|
}
|
|
public dbSchema(): DbSchemaContext | undefined {
|
|
return this.tryGetRuleContext(0, DbSchemaContext);
|
|
}
|
|
public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
|
|
public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOG, 0); }
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
|
|
public dbSchemaNameCreate(): DbSchemaNameCreateContext | undefined {
|
|
return this.tryGetRuleContext(0, DbSchemaNameCreateContext);
|
|
}
|
|
public ifNotExists(): IfNotExistsContext | undefined {
|
|
return this.tryGetRuleContext(0, IfNotExistsContext);
|
|
}
|
|
public commentSpec(): CommentSpecContext[];
|
|
public commentSpec(i: number): CommentSpecContext;
|
|
public commentSpec(i?: number): CommentSpecContext | CommentSpecContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(CommentSpecContext);
|
|
} else {
|
|
return this.getRuleContext(i, CommentSpecContext);
|
|
}
|
|
}
|
|
public locationSpec(): LocationSpecContext[];
|
|
public locationSpec(i: number): LocationSpecContext;
|
|
public locationSpec(i?: number): LocationSpecContext | LocationSpecContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(LocationSpecContext);
|
|
} else {
|
|
return this.getRuleContext(i, LocationSpecContext);
|
|
}
|
|
}
|
|
public KW_WITH(): TerminalNode[];
|
|
public KW_WITH(i: number): TerminalNode;
|
|
public KW_WITH(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_WITH);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_WITH, i);
|
|
}
|
|
}
|
|
public propertyList(): PropertyListContext[];
|
|
public propertyList(i: number): PropertyListContext;
|
|
public propertyList(i?: number): PropertyListContext | PropertyListContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PropertyListContext);
|
|
} else {
|
|
return this.getRuleContext(i, PropertyListContext);
|
|
}
|
|
}
|
|
public KW_DBPROPERTIES(): TerminalNode[];
|
|
public KW_DBPROPERTIES(i: number): TerminalNode;
|
|
public KW_DBPROPERTIES(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_DBPROPERTIES);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_DBPROPERTIES, i);
|
|
}
|
|
}
|
|
public KW_PROPERTIES(): TerminalNode[];
|
|
public KW_PROPERTIES(i: number): TerminalNode;
|
|
public KW_PROPERTIES(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_PROPERTIES);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_PROPERTIES, i);
|
|
}
|
|
}
|
|
public KW_ALTER(): TerminalNode[];
|
|
public KW_ALTER(i: number): TerminalNode;
|
|
public KW_ALTER(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_ALTER);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_ALTER, i);
|
|
}
|
|
}
|
|
public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
|
|
public ifExists(): IfExistsContext | undefined {
|
|
return this.tryGetRuleContext(0, IfExistsContext);
|
|
}
|
|
public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESTRICT, 0); }
|
|
public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASCADE, 0); }
|
|
public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
|
|
public dbSchemas(): DbSchemasContext | undefined {
|
|
return this.tryGetRuleContext(0, DbSchemasContext);
|
|
}
|
|
public multipartIdentifier(): MultipartIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, MultipartIdentifierContext);
|
|
}
|
|
public KW_FROM(): TerminalNode[];
|
|
public KW_FROM(i: number): TerminalNode;
|
|
public KW_FROM(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_FROM);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_FROM, i);
|
|
}
|
|
}
|
|
public KW_IN(): TerminalNode[];
|
|
public KW_IN(i: number): TerminalNode;
|
|
public KW_IN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_IN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_IN, i);
|
|
}
|
|
}
|
|
public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
|
|
public createTableHeader(): CreateTableHeaderContext | undefined {
|
|
return this.tryGetRuleContext(0, CreateTableHeaderContext);
|
|
}
|
|
public createTableClauses(): CreateTableClausesContext | undefined {
|
|
return this.tryGetRuleContext(0, CreateTableClausesContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext | undefined {
|
|
return this.tryGetRuleContext(0, CreateOrReplaceTableColTypeListContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public tableProvider(): TableProviderContext[];
|
|
public tableProvider(i: number): TableProviderContext;
|
|
public tableProvider(i?: number): TableProviderContext | TableProviderContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(TableProviderContext);
|
|
} else {
|
|
return this.getRuleContext(i, TableProviderContext);
|
|
}
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public tableNameCreate(): TableNameCreateContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameCreateContext);
|
|
}
|
|
public tableName(): TableNameContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameContext);
|
|
}
|
|
public rowFormat(): RowFormatContext[];
|
|
public rowFormat(i: number): RowFormatContext;
|
|
public rowFormat(i?: number): RowFormatContext | RowFormatContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(RowFormatContext);
|
|
} else {
|
|
return this.getRuleContext(i, RowFormatContext);
|
|
}
|
|
}
|
|
public createFileFormat(): CreateFileFormatContext[];
|
|
public createFileFormat(i: number): CreateFileFormatContext;
|
|
public createFileFormat(i?: number): CreateFileFormatContext | CreateFileFormatContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(CreateFileFormatContext);
|
|
} else {
|
|
return this.getRuleContext(i, CreateFileFormatContext);
|
|
}
|
|
}
|
|
public KW_TBLPROPERTIES(): TerminalNode[];
|
|
public KW_TBLPROPERTIES(i: number): TerminalNode;
|
|
public KW_TBLPROPERTIES(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_TBLPROPERTIES);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, i);
|
|
}
|
|
}
|
|
public replaceTableHeader(): ReplaceTableHeaderContext | undefined {
|
|
return this.tryGetRuleContext(0, ReplaceTableHeaderContext);
|
|
}
|
|
public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANALYZE, 0); }
|
|
public KW_COMPUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPUTE, 0); }
|
|
public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STATISTICS, 0); }
|
|
public partitionSpec(): PartitionSpecContext[];
|
|
public partitionSpec(i: number): PartitionSpecContext;
|
|
public partitionSpec(i?: number): PartitionSpecContext | PartitionSpecContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PartitionSpecContext);
|
|
} else {
|
|
return this.getRuleContext(i, PartitionSpecContext);
|
|
}
|
|
}
|
|
public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
|
|
public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
|
|
public identifierSeq(): IdentifierSeqContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierSeqContext);
|
|
}
|
|
public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
|
|
public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLES, 0); }
|
|
public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ADD, 0); }
|
|
public qualifiedColTypeWithPositionList(): QualifiedColTypeWithPositionListContext | undefined {
|
|
return this.tryGetRuleContext(0, QualifiedColTypeWithPositionListContext);
|
|
}
|
|
public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMN, 0); }
|
|
public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RENAME, 0); }
|
|
public KW_TO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TO, 0); }
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
public multipartIdentifierList(): MultipartIdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, MultipartIdentifierListContext);
|
|
}
|
|
public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEW, 0); }
|
|
public viewName(): ViewNameContext | undefined {
|
|
return this.tryGetRuleContext(0, ViewNameContext);
|
|
}
|
|
public KW_UNSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNSET, 0); }
|
|
public KW_CHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHANGE, 0); }
|
|
public alterColumnAction(): AlterColumnActionContext | undefined {
|
|
return this.tryGetRuleContext(0, AlterColumnActionContext);
|
|
}
|
|
public colType(): ColTypeContext | undefined {
|
|
return this.tryGetRuleContext(0, ColTypeContext);
|
|
}
|
|
public colPosition(): ColPositionContext | undefined {
|
|
return this.tryGetRuleContext(0, ColPositionContext);
|
|
}
|
|
public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
|
|
public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
|
|
public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
|
|
public partitionSpecLocation(): PartitionSpecLocationContext[];
|
|
public partitionSpecLocation(i: number): PartitionSpecLocationContext;
|
|
public partitionSpecLocation(i?: number): PartitionSpecLocationContext | PartitionSpecLocationContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PartitionSpecLocationContext);
|
|
} else {
|
|
return this.getRuleContext(i, PartitionSpecLocationContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PURGE, 0); }
|
|
public KW_RECOVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECOVER, 0); }
|
|
public KW_PARTITIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONS, 0); }
|
|
public viewNameCreate(): ViewNameCreateContext | undefined {
|
|
return this.tryGetRuleContext(0, ViewNameCreateContext);
|
|
}
|
|
public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
|
|
public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
|
|
public identifierCommentList(): IdentifierCommentListContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierCommentListContext);
|
|
}
|
|
public KW_PARTITIONED(): TerminalNode[];
|
|
public KW_PARTITIONED(i: number): TerminalNode;
|
|
public KW_PARTITIONED(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_PARTITIONED);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_PARTITIONED, i);
|
|
}
|
|
}
|
|
public KW_ON(): TerminalNode[];
|
|
public KW_ON(i: number): TerminalNode;
|
|
public KW_ON(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_ON);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_ON, i);
|
|
}
|
|
}
|
|
public identifierList(): IdentifierListContext[];
|
|
public identifierList(i: number): IdentifierListContext;
|
|
public identifierList(i?: number): IdentifierListContext | IdentifierListContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierListContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierListContext);
|
|
}
|
|
}
|
|
public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GLOBAL, 0); }
|
|
public colTypeList(): ColTypeListContext | undefined {
|
|
return this.tryGetRuleContext(0, ColTypeListContext);
|
|
}
|
|
public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
|
|
public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTION, 0); }
|
|
public functionNameCreate(): FunctionNameCreateContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionNameCreateContext);
|
|
}
|
|
public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
|
|
public resource(): ResourceContext[];
|
|
public resource(i: number): ResourceContext;
|
|
public resource(i?: number): ResourceContext | ResourceContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ResourceContext);
|
|
} else {
|
|
return this.getRuleContext(i, ResourceContext);
|
|
}
|
|
}
|
|
public functionName(): FunctionNameContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionNameContext);
|
|
}
|
|
public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECLARE, 0); }
|
|
public KW_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARIABLE, 0); }
|
|
public dataType(): DataTypeContext | undefined {
|
|
return this.tryGetRuleContext(0, DataTypeContext);
|
|
}
|
|
public variableDefaultExpression(): VariableDefaultExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, VariableDefaultExpressionContext);
|
|
}
|
|
public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPLAIN, 0); }
|
|
public statement(): StatementContext | undefined {
|
|
return this.tryGetRuleContext(0, StatementContext);
|
|
}
|
|
public KW_LOGICAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOGICAL, 0); }
|
|
public KW_FORMATTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMATTED, 0); }
|
|
public KW_EXTENDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTENDED, 0); }
|
|
public KW_CODEGEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CODEGEN, 0); }
|
|
public KW_COST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COST, 0); }
|
|
public propertyKey(): PropertyKeyContext | undefined {
|
|
return this.tryGetRuleContext(0, PropertyKeyContext);
|
|
}
|
|
public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEWS, 0); }
|
|
public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTIONS, 0); }
|
|
public functionKind(): FunctionKindContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionKindContext);
|
|
}
|
|
public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
|
|
public KW_CATALOGS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOGS, 0); }
|
|
public describeFuncName(): DescribeFuncNameContext | undefined {
|
|
return this.tryGetRuleContext(0, DescribeFuncNameContext);
|
|
}
|
|
public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
|
|
public KW_DESCRIBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESCRIBE, 0); }
|
|
public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
|
|
public describeColName(): DescribeColNameContext | undefined {
|
|
return this.tryGetRuleContext(0, DescribeColNameContext);
|
|
}
|
|
public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUERY, 0); }
|
|
public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMENT, 0); }
|
|
public KW_IS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IS, 0); }
|
|
public comment(): CommentContext | undefined {
|
|
return this.tryGetRuleContext(0, CommentContext);
|
|
}
|
|
public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFRESH, 0); }
|
|
public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CACHE, 0); }
|
|
public KW_LAZY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAZY, 0); }
|
|
public KW_UNCACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNCACHE, 0); }
|
|
public KW_CLEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLEAR, 0); }
|
|
public KW_LOAD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOAD, 0); }
|
|
public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATA, 0); }
|
|
public KW_INPATH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPATH, 0); }
|
|
public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
|
|
public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
|
|
public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
|
|
public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUNCATE, 0); }
|
|
public KW_REPAIR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPAIR, 0); }
|
|
public KW_MSCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MSCK, 0); }
|
|
public KW_SYNC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYNC, 0); }
|
|
public KW_LIST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIST, 0); }
|
|
public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
|
|
public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIME, 0); }
|
|
public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ZONE, 0); }
|
|
public interval(): IntervalContext | undefined {
|
|
return this.tryGetRuleContext(0, IntervalContext);
|
|
}
|
|
public timezone(): TimezoneContext | undefined {
|
|
return this.tryGetRuleContext(0, TimezoneContext);
|
|
}
|
|
public assignmentList(): AssignmentListContext | undefined {
|
|
return this.tryGetRuleContext(0, AssignmentListContext);
|
|
}
|
|
public KW_VAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VAR, 0); }
|
|
public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
|
|
public configKey(): ConfigKeyContext | undefined {
|
|
return this.tryGetRuleContext(0, ConfigKeyContext);
|
|
}
|
|
public configValue(): ConfigValueContext | undefined {
|
|
return this.tryGetRuleContext(0, ConfigValueContext);
|
|
}
|
|
public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESET, 0); }
|
|
public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
|
|
public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext | undefined {
|
|
return this.tryGetRuleContext(0, MultipartIdentifierPropertyListContext);
|
|
}
|
|
public unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext | undefined {
|
|
return this.tryGetRuleContext(0, UnsupportedHiveNativeCommandsContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_statement; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterStatement) {
|
|
listener.enterStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitStatement) {
|
|
listener.exitStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitStatement) {
|
|
return visitor.visitStatement(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TimezoneContext extends ParserRuleContext {
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_timezone; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTimezone) {
|
|
listener.enterTimezone(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTimezone) {
|
|
listener.exitTimezone(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTimezone) {
|
|
return visitor.visitTimezone(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConfigKeyContext extends ParserRuleContext {
|
|
public quotedIdentifier(): QuotedIdentifierContext {
|
|
return this.getRuleContext(0, QuotedIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_configKey; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterConfigKey) {
|
|
listener.enterConfigKey(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitConfigKey) {
|
|
listener.exitConfigKey(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitConfigKey) {
|
|
return visitor.visitConfigKey(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConfigValueContext extends ParserRuleContext {
|
|
public backQuotedIdentifier(): BackQuotedIdentifierContext {
|
|
return this.getRuleContext(0, BackQuotedIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_configValue; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterConfigValue) {
|
|
listener.enterConfigValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitConfigValue) {
|
|
listener.exitConfigValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitConfigValue) {
|
|
return visitor.visitConfigValue(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnsupportedHiveNativeCommandsContext extends ParserRuleContext {
|
|
public _kw1!: Token;
|
|
public _kw2!: Token;
|
|
public _kw3!: Token;
|
|
public _kw4!: Token;
|
|
public _kw5!: Token;
|
|
public _kw6!: Token;
|
|
public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
|
|
public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
|
|
public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
|
|
public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GRANT, 0); }
|
|
public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REVOKE, 0); }
|
|
public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
|
|
public KW_PRINCIPALS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRINCIPALS, 0); }
|
|
public KW_ROLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLES, 0); }
|
|
public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
|
|
public KW_EXPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPORT, 0); }
|
|
public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public KW_IMPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IMPORT, 0); }
|
|
public KW_COMPACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACTIONS, 0); }
|
|
public KW_TRANSACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTIONS, 0); }
|
|
public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEXES, 0); }
|
|
public KW_LOCKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCKS, 0); }
|
|
public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
|
|
public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALTER, 0); }
|
|
public KW_LOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCK, 0); }
|
|
public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
|
|
public KW_UNLOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNLOCK, 0); }
|
|
public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
|
|
public KW_MACRO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MACRO, 0); }
|
|
public tableName(): TableNameContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameContext);
|
|
}
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_CLUSTERED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTERED, 0); }
|
|
public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
|
|
public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
|
|
public KW_SKEWED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SKEWED, 0); }
|
|
public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
|
|
public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
|
|
public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCATION, 0); }
|
|
public KW_EXCHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCHANGE, 0); }
|
|
public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
|
|
public KW_ARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARCHIVE, 0); }
|
|
public KW_UNARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNARCHIVE, 0); }
|
|
public KW_TOUCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TOUCH, 0); }
|
|
public KW_COMPACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACT, 0); }
|
|
public partitionSpec(): PartitionSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, PartitionSpecContext);
|
|
}
|
|
public KW_CONCATENATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONCATENATE, 0); }
|
|
public KW_FILEFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILEFORMAT, 0); }
|
|
public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
|
|
public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
|
|
public KW_START(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_START, 0); }
|
|
public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTION, 0); }
|
|
public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMIT, 0); }
|
|
public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLBACK, 0); }
|
|
public KW_DFS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DFS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unsupportedHiveNativeCommands; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnsupportedHiveNativeCommands) {
|
|
listener.enterUnsupportedHiveNativeCommands(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnsupportedHiveNativeCommands) {
|
|
listener.exitUnsupportedHiveNativeCommands(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnsupportedHiveNativeCommands) {
|
|
return visitor.visitUnsupportedHiveNativeCommands(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CreateTableHeaderContext extends ParserRuleContext {
|
|
public KW_CREATE(): TerminalNode { return this.getToken(SparkSqlParser.KW_CREATE, 0); }
|
|
public KW_TABLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public tableNameCreate(): TableNameCreateContext {
|
|
return this.getRuleContext(0, TableNameCreateContext);
|
|
}
|
|
public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
|
|
public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTERNAL, 0); }
|
|
public ifNotExists(): IfNotExistsContext | undefined {
|
|
return this.tryGetRuleContext(0, IfNotExistsContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_createTableHeader; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterCreateTableHeader) {
|
|
listener.enterCreateTableHeader(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitCreateTableHeader) {
|
|
listener.exitCreateTableHeader(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitCreateTableHeader) {
|
|
return visitor.visitCreateTableHeader(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ReplaceTableHeaderContext extends ParserRuleContext {
|
|
public KW_REPLACE(): TerminalNode { return this.getToken(SparkSqlParser.KW_REPLACE, 0); }
|
|
public KW_TABLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public tableNameCreate(): TableNameCreateContext {
|
|
return this.getRuleContext(0, TableNameCreateContext);
|
|
}
|
|
public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
|
|
public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_replaceTableHeader; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterReplaceTableHeader) {
|
|
listener.enterReplaceTableHeader(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitReplaceTableHeader) {
|
|
listener.exitReplaceTableHeader(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitReplaceTableHeader) {
|
|
return visitor.visitReplaceTableHeader(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class BucketSpecContext extends ParserRuleContext {
|
|
public KW_CLUSTERED(): TerminalNode { return this.getToken(SparkSqlParser.KW_CLUSTERED, 0); }
|
|
public KW_BY(): TerminalNode[];
|
|
public KW_BY(i: number): TerminalNode;
|
|
public KW_BY(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_BY);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_BY, i);
|
|
}
|
|
}
|
|
public identifierList(): IdentifierListContext {
|
|
return this.getRuleContext(0, IdentifierListContext);
|
|
}
|
|
public KW_INTO(): TerminalNode { return this.getToken(SparkSqlParser.KW_INTO, 0); }
|
|
public INTEGER_VALUE(): TerminalNode { return this.getToken(SparkSqlParser.INTEGER_VALUE, 0); }
|
|
public KW_BUCKETS(): TerminalNode { return this.getToken(SparkSqlParser.KW_BUCKETS, 0); }
|
|
public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
|
|
public orderedIdentifierList(): OrderedIdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, OrderedIdentifierListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_bucketSpec; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterBucketSpec) {
|
|
listener.enterBucketSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitBucketSpec) {
|
|
listener.exitBucketSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitBucketSpec) {
|
|
return visitor.visitBucketSpec(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SkewSpecContext extends ParserRuleContext {
|
|
public KW_SKEWED(): TerminalNode { return this.getToken(SparkSqlParser.KW_SKEWED, 0); }
|
|
public KW_BY(): TerminalNode { return this.getToken(SparkSqlParser.KW_BY, 0); }
|
|
public identifierList(): IdentifierListContext {
|
|
return this.getRuleContext(0, IdentifierListContext);
|
|
}
|
|
public KW_ON(): TerminalNode { return this.getToken(SparkSqlParser.KW_ON, 0); }
|
|
public constantList(): ConstantListContext | undefined {
|
|
return this.tryGetRuleContext(0, ConstantListContext);
|
|
}
|
|
public nestedConstantList(): NestedConstantListContext | undefined {
|
|
return this.tryGetRuleContext(0, NestedConstantListContext);
|
|
}
|
|
public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_skewSpec; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSkewSpec) {
|
|
listener.enterSkewSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSkewSpec) {
|
|
listener.exitSkewSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSkewSpec) {
|
|
return visitor.visitSkewSpec(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class LocationSpecContext extends ParserRuleContext {
|
|
public KW_LOCATION(): TerminalNode { return this.getToken(SparkSqlParser.KW_LOCATION, 0); }
|
|
public stringLit(): StringLitContext {
|
|
return this.getRuleContext(0, StringLitContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_locationSpec; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterLocationSpec) {
|
|
listener.enterLocationSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitLocationSpec) {
|
|
listener.exitLocationSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitLocationSpec) {
|
|
return visitor.visitLocationSpec(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CommentSpecContext extends ParserRuleContext {
|
|
public KW_COMMENT(): TerminalNode { return this.getToken(SparkSqlParser.KW_COMMENT, 0); }
|
|
public stringLit(): StringLitContext {
|
|
return this.getRuleContext(0, StringLitContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_commentSpec; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterCommentSpec) {
|
|
listener.enterCommentSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitCommentSpec) {
|
|
listener.exitCommentSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitCommentSpec) {
|
|
return visitor.visitCommentSpec(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QueryContext extends ParserRuleContext {
|
|
public queryTerm(): QueryTermContext {
|
|
return this.getRuleContext(0, QueryTermContext);
|
|
}
|
|
public queryOrganization(): QueryOrganizationContext {
|
|
return this.getRuleContext(0, QueryOrganizationContext);
|
|
}
|
|
public ctes(): CtesContext | undefined {
|
|
return this.tryGetRuleContext(0, CtesContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_query; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQuery) {
|
|
listener.enterQuery(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQuery) {
|
|
listener.exitQuery(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQuery) {
|
|
return visitor.visitQuery(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class InsertIntoContext extends ParserRuleContext {
|
|
public _path!: StringLitContext;
|
|
public _options!: PropertyListContext;
|
|
public KW_INSERT(): TerminalNode { return this.getToken(SparkSqlParser.KW_INSERT, 0); }
|
|
public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
|
|
public tableName(): TableNameContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameContext);
|
|
}
|
|
public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public partitionSpec(): PartitionSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, PartitionSpecContext);
|
|
}
|
|
public identifierList(): IdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierListContext);
|
|
}
|
|
public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
|
|
public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAME, 0); }
|
|
public ifNotExists(): IfNotExistsContext | undefined {
|
|
return this.tryGetRuleContext(0, IfNotExistsContext);
|
|
}
|
|
public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
|
|
public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
|
|
public whereClause(): WhereClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, WhereClauseContext);
|
|
}
|
|
public KW_DIRECTORY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORY, 0); }
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
|
|
public rowFormat(): RowFormatContext | undefined {
|
|
return this.tryGetRuleContext(0, RowFormatContext);
|
|
}
|
|
public createFileFormat(): CreateFileFormatContext | undefined {
|
|
return this.tryGetRuleContext(0, CreateFileFormatContext);
|
|
}
|
|
public tableProvider(): TableProviderContext | undefined {
|
|
return this.tryGetRuleContext(0, TableProviderContext);
|
|
}
|
|
public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
|
|
public propertyList(): PropertyListContext | undefined {
|
|
return this.tryGetRuleContext(0, PropertyListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_insertInto; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterInsertInto) {
|
|
listener.enterInsertInto(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitInsertInto) {
|
|
listener.exitInsertInto(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitInsertInto) {
|
|
return visitor.visitInsertInto(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PartitionSpecLocationContext extends ParserRuleContext {
|
|
public partitionSpec(): PartitionSpecContext {
|
|
return this.getRuleContext(0, PartitionSpecContext);
|
|
}
|
|
public locationSpec(): LocationSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, LocationSpecContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_partitionSpecLocation; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPartitionSpecLocation) {
|
|
listener.enterPartitionSpecLocation(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPartitionSpecLocation) {
|
|
listener.exitPartitionSpecLocation(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPartitionSpecLocation) {
|
|
return visitor.visitPartitionSpecLocation(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PartitionSpecContext extends ParserRuleContext {
|
|
public KW_PARTITION(): TerminalNode { return this.getToken(SparkSqlParser.KW_PARTITION, 0); }
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public partitionVal(): PartitionValContext[];
|
|
public partitionVal(i: number): PartitionValContext;
|
|
public partitionVal(i?: number): PartitionValContext | PartitionValContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PartitionValContext);
|
|
} else {
|
|
return this.getRuleContext(i, PartitionValContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_partitionSpec; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPartitionSpec) {
|
|
listener.enterPartitionSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPartitionSpec) {
|
|
listener.exitPartitionSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPartitionSpec) {
|
|
return visitor.visitPartitionSpec(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PartitionValContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
|
|
public constant(): ConstantContext | undefined {
|
|
return this.tryGetRuleContext(0, ConstantContext);
|
|
}
|
|
public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_partitionVal; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPartitionVal) {
|
|
listener.enterPartitionVal(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPartitionVal) {
|
|
listener.exitPartitionVal(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPartitionVal) {
|
|
return visitor.visitPartitionVal(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DbSchemaContext extends ParserRuleContext {
|
|
public KW_NAMESPACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACE, 0); }
|
|
public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
|
|
public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMA, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchema; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDbSchema) {
|
|
listener.enterDbSchema(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDbSchema) {
|
|
listener.exitDbSchema(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDbSchema) {
|
|
return visitor.visitDbSchema(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DbSchemasContext extends ParserRuleContext {
|
|
public KW_NAMESPACES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACES, 0); }
|
|
public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASES, 0); }
|
|
public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMAS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchemas; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDbSchemas) {
|
|
listener.enterDbSchemas(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDbSchemas) {
|
|
listener.exitDbSchemas(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDbSchemas) {
|
|
return visitor.visitDbSchemas(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DescribeFuncNameContext extends ParserRuleContext {
|
|
public identifierReference(): IdentifierReferenceContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierReferenceContext);
|
|
}
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public comparisonOperator(): ComparisonOperatorContext | undefined {
|
|
return this.tryGetRuleContext(0, ComparisonOperatorContext);
|
|
}
|
|
public arithmeticOperator(): ArithmeticOperatorContext | undefined {
|
|
return this.tryGetRuleContext(0, ArithmeticOperatorContext);
|
|
}
|
|
public predicateOperator(): PredicateOperatorContext | undefined {
|
|
return this.tryGetRuleContext(0, PredicateOperatorContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_describeFuncName; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDescribeFuncName) {
|
|
listener.enterDescribeFuncName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDescribeFuncName) {
|
|
listener.exitDescribeFuncName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDescribeFuncName) {
|
|
return visitor.visitDescribeFuncName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DescribeColNameContext extends ParserRuleContext {
|
|
public _identifier!: IdentifierContext;
|
|
public _nameParts: IdentifierContext[] = [];
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
public DOT(): TerminalNode[];
|
|
public DOT(i: number): TerminalNode;
|
|
public DOT(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.DOT);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.DOT, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_describeColName; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDescribeColName) {
|
|
listener.enterDescribeColName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDescribeColName) {
|
|
listener.exitDescribeColName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDescribeColName) {
|
|
return visitor.visitDescribeColName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CtesContext extends ParserRuleContext {
|
|
public KW_WITH(): TerminalNode { return this.getToken(SparkSqlParser.KW_WITH, 0); }
|
|
public namedQuery(): NamedQueryContext[];
|
|
public namedQuery(i: number): NamedQueryContext;
|
|
public namedQuery(i?: number): NamedQueryContext | NamedQueryContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(NamedQueryContext);
|
|
} else {
|
|
return this.getRuleContext(i, NamedQueryContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_ctes; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterCtes) {
|
|
listener.enterCtes(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitCtes) {
|
|
listener.exitCtes(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitCtes) {
|
|
return visitor.visitCtes(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NamedQueryContext extends ParserRuleContext {
|
|
public _name!: ErrorCapturingIdentifierContext;
|
|
public _columnAliases!: IdentifierListContext;
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public query(): QueryContext {
|
|
return this.getRuleContext(0, QueryContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
|
|
return this.getRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public identifierList(): IdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_namedQuery; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNamedQuery) {
|
|
listener.enterNamedQuery(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNamedQuery) {
|
|
listener.exitNamedQuery(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNamedQuery) {
|
|
return visitor.visitNamedQuery(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TableProviderContext extends ParserRuleContext {
|
|
public KW_USING(): TerminalNode { return this.getToken(SparkSqlParser.KW_USING, 0); }
|
|
public multipartIdentifier(): MultipartIdentifierContext {
|
|
return this.getRuleContext(0, MultipartIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_tableProvider; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTableProvider) {
|
|
listener.enterTableProvider(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTableProvider) {
|
|
listener.exitTableProvider(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTableProvider) {
|
|
return visitor.visitTableProvider(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CreateTableClausesContext extends ParserRuleContext {
|
|
public _options!: ExpressionPropertyListContext;
|
|
public _partitioning!: PartitionFieldListContext;
|
|
public _tableProps!: PropertyListContext;
|
|
public skewSpec(): SkewSpecContext[];
|
|
public skewSpec(i: number): SkewSpecContext;
|
|
public skewSpec(i?: number): SkewSpecContext | SkewSpecContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(SkewSpecContext);
|
|
} else {
|
|
return this.getRuleContext(i, SkewSpecContext);
|
|
}
|
|
}
|
|
public bucketSpec(): BucketSpecContext[];
|
|
public bucketSpec(i: number): BucketSpecContext;
|
|
public bucketSpec(i?: number): BucketSpecContext | BucketSpecContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(BucketSpecContext);
|
|
} else {
|
|
return this.getRuleContext(i, BucketSpecContext);
|
|
}
|
|
}
|
|
public rowFormat(): RowFormatContext[];
|
|
public rowFormat(i: number): RowFormatContext;
|
|
public rowFormat(i?: number): RowFormatContext | RowFormatContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(RowFormatContext);
|
|
} else {
|
|
return this.getRuleContext(i, RowFormatContext);
|
|
}
|
|
}
|
|
public createFileFormat(): CreateFileFormatContext[];
|
|
public createFileFormat(i: number): CreateFileFormatContext;
|
|
public createFileFormat(i?: number): CreateFileFormatContext | CreateFileFormatContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(CreateFileFormatContext);
|
|
} else {
|
|
return this.getRuleContext(i, CreateFileFormatContext);
|
|
}
|
|
}
|
|
public locationSpec(): LocationSpecContext[];
|
|
public locationSpec(i: number): LocationSpecContext;
|
|
public locationSpec(i?: number): LocationSpecContext | LocationSpecContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(LocationSpecContext);
|
|
} else {
|
|
return this.getRuleContext(i, LocationSpecContext);
|
|
}
|
|
}
|
|
public commentSpec(): CommentSpecContext[];
|
|
public commentSpec(i: number): CommentSpecContext;
|
|
public commentSpec(i?: number): CommentSpecContext | CommentSpecContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(CommentSpecContext);
|
|
} else {
|
|
return this.getRuleContext(i, CommentSpecContext);
|
|
}
|
|
}
|
|
public KW_OPTIONS(): TerminalNode[];
|
|
public KW_OPTIONS(i: number): TerminalNode;
|
|
public KW_OPTIONS(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_OPTIONS);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_OPTIONS, i);
|
|
}
|
|
}
|
|
public KW_PARTITIONED(): TerminalNode[];
|
|
public KW_PARTITIONED(i: number): TerminalNode;
|
|
public KW_PARTITIONED(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_PARTITIONED);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_PARTITIONED, i);
|
|
}
|
|
}
|
|
public KW_BY(): TerminalNode[];
|
|
public KW_BY(i: number): TerminalNode;
|
|
public KW_BY(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_BY);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_BY, i);
|
|
}
|
|
}
|
|
public KW_TBLPROPERTIES(): TerminalNode[];
|
|
public KW_TBLPROPERTIES(i: number): TerminalNode;
|
|
public KW_TBLPROPERTIES(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_TBLPROPERTIES);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, i);
|
|
}
|
|
}
|
|
public expressionPropertyList(): ExpressionPropertyListContext[];
|
|
public expressionPropertyList(i: number): ExpressionPropertyListContext;
|
|
public expressionPropertyList(i?: number): ExpressionPropertyListContext | ExpressionPropertyListContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionPropertyListContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionPropertyListContext);
|
|
}
|
|
}
|
|
public partitionFieldList(): PartitionFieldListContext[];
|
|
public partitionFieldList(i: number): PartitionFieldListContext;
|
|
public partitionFieldList(i?: number): PartitionFieldListContext | PartitionFieldListContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PartitionFieldListContext);
|
|
} else {
|
|
return this.getRuleContext(i, PartitionFieldListContext);
|
|
}
|
|
}
|
|
public propertyList(): PropertyListContext[];
|
|
public propertyList(i: number): PropertyListContext;
|
|
public propertyList(i?: number): PropertyListContext | PropertyListContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PropertyListContext);
|
|
} else {
|
|
return this.getRuleContext(i, PropertyListContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_createTableClauses; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterCreateTableClauses) {
|
|
listener.enterCreateTableClauses(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitCreateTableClauses) {
|
|
listener.exitCreateTableClauses(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitCreateTableClauses) {
|
|
return visitor.visitCreateTableClauses(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PropertyListContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public property(): PropertyContext[];
|
|
public property(i: number): PropertyContext;
|
|
public property(i?: number): PropertyContext | PropertyContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PropertyContext);
|
|
} else {
|
|
return this.getRuleContext(i, PropertyContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_propertyList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPropertyList) {
|
|
listener.enterPropertyList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPropertyList) {
|
|
listener.exitPropertyList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPropertyList) {
|
|
return visitor.visitPropertyList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PropertyContext extends ParserRuleContext {
|
|
public _key!: PropertyKeyContext;
|
|
public _value!: PropertyValueContext;
|
|
public propertyKey(): PropertyKeyContext {
|
|
return this.getRuleContext(0, PropertyKeyContext);
|
|
}
|
|
public propertyValue(): PropertyValueContext | undefined {
|
|
return this.tryGetRuleContext(0, PropertyValueContext);
|
|
}
|
|
public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_property; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterProperty) {
|
|
listener.enterProperty(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitProperty) {
|
|
listener.exitProperty(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitProperty) {
|
|
return visitor.visitProperty(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PropertyKeyContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
public DOT(): TerminalNode[];
|
|
public DOT(i: number): TerminalNode;
|
|
public DOT(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.DOT);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.DOT, i);
|
|
}
|
|
}
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_propertyKey; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPropertyKey) {
|
|
listener.enterPropertyKey(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPropertyKey) {
|
|
listener.exitPropertyKey(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPropertyKey) {
|
|
return visitor.visitPropertyKey(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PropertyValueContext extends ParserRuleContext {
|
|
public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
|
|
public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
|
|
public booleanValue(): BooleanValueContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanValueContext);
|
|
}
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_propertyValue; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPropertyValue) {
|
|
listener.enterPropertyValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPropertyValue) {
|
|
listener.exitPropertyValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPropertyValue) {
|
|
return visitor.visitPropertyValue(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ExpressionPropertyListContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public expressionProperty(): ExpressionPropertyContext[];
|
|
public expressionProperty(i: number): ExpressionPropertyContext;
|
|
public expressionProperty(i?: number): ExpressionPropertyContext | ExpressionPropertyContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionPropertyContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionPropertyContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_expressionPropertyList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterExpressionPropertyList) {
|
|
listener.enterExpressionPropertyList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitExpressionPropertyList) {
|
|
listener.exitExpressionPropertyList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitExpressionPropertyList) {
|
|
return visitor.visitExpressionPropertyList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ExpressionPropertyContext extends ParserRuleContext {
|
|
public _key!: PropertyKeyContext;
|
|
public _value!: ExpressionContext;
|
|
public propertyKey(): PropertyKeyContext {
|
|
return this.getRuleContext(0, PropertyKeyContext);
|
|
}
|
|
public expression(): ExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionContext);
|
|
}
|
|
public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_expressionProperty; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterExpressionProperty) {
|
|
listener.enterExpressionProperty(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitExpressionProperty) {
|
|
listener.exitExpressionProperty(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitExpressionProperty) {
|
|
return visitor.visitExpressionProperty(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConstantListContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public constant(): ConstantContext[];
|
|
public constant(i: number): ConstantContext;
|
|
public constant(i?: number): ConstantContext | ConstantContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ConstantContext);
|
|
} else {
|
|
return this.getRuleContext(i, ConstantContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_constantList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterConstantList) {
|
|
listener.enterConstantList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitConstantList) {
|
|
listener.exitConstantList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitConstantList) {
|
|
return visitor.visitConstantList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NestedConstantListContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public constantList(): ConstantListContext[];
|
|
public constantList(i: number): ConstantListContext;
|
|
public constantList(i?: number): ConstantListContext | ConstantListContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ConstantListContext);
|
|
} else {
|
|
return this.getRuleContext(i, ConstantListContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_nestedConstantList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNestedConstantList) {
|
|
listener.enterNestedConstantList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNestedConstantList) {
|
|
listener.exitNestedConstantList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNestedConstantList) {
|
|
return visitor.visitNestedConstantList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CreateFileFormatContext extends ParserRuleContext {
|
|
public KW_STORED(): TerminalNode { return this.getToken(SparkSqlParser.KW_STORED, 0); }
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public fileFormat(): FileFormatContext | undefined {
|
|
return this.tryGetRuleContext(0, FileFormatContext);
|
|
}
|
|
public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
|
|
public storageHandler(): StorageHandlerContext | undefined {
|
|
return this.tryGetRuleContext(0, StorageHandlerContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_createFileFormat; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterCreateFileFormat) {
|
|
listener.enterCreateFileFormat(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitCreateFileFormat) {
|
|
listener.exitCreateFileFormat(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitCreateFileFormat) {
|
|
return visitor.visitCreateFileFormat(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FileFormatContext extends ParserRuleContext {
|
|
public _inFmt!: StringLitContext;
|
|
public _outFmt!: StringLitContext;
|
|
public KW_INPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPUTFORMAT, 0); }
|
|
public KW_OUTPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTPUTFORMAT, 0); }
|
|
public stringLit(): StringLitContext[];
|
|
public stringLit(i: number): StringLitContext;
|
|
public stringLit(i?: number): StringLitContext | StringLitContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLitContext);
|
|
} else {
|
|
return this.getRuleContext(i, StringLitContext);
|
|
}
|
|
}
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_fileFormat; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFileFormat) {
|
|
listener.enterFileFormat(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFileFormat) {
|
|
listener.exitFileFormat(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFileFormat) {
|
|
return visitor.visitFileFormat(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StorageHandlerContext extends ParserRuleContext {
|
|
public stringLit(): StringLitContext {
|
|
return this.getRuleContext(0, StringLitContext);
|
|
}
|
|
public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
|
|
public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
|
|
public propertyList(): PropertyListContext | undefined {
|
|
return this.tryGetRuleContext(0, PropertyListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_storageHandler; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterStorageHandler) {
|
|
listener.enterStorageHandler(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitStorageHandler) {
|
|
listener.exitStorageHandler(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitStorageHandler) {
|
|
return visitor.visitStorageHandler(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ResourceContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public stringLit(): StringLitContext {
|
|
return this.getRuleContext(0, StringLitContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_resource; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterResource) {
|
|
listener.enterResource(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitResource) {
|
|
listener.exitResource(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitResource) {
|
|
return visitor.visitResource(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DmlStatementNoWithContext extends ParserRuleContext {
|
|
public _target!: TableNameContext;
|
|
public _targetAlias!: TableAliasContext;
|
|
public _source!: IdentifierReferenceContext;
|
|
public _sourceQuery!: QueryContext;
|
|
public _sourceAlias!: TableAliasContext;
|
|
public _mergeCondition!: BooleanExpressionContext;
|
|
public insertInto(): InsertIntoContext | undefined {
|
|
return this.tryGetRuleContext(0, InsertIntoContext);
|
|
}
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
public fromClause(): FromClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, FromClauseContext);
|
|
}
|
|
public multiInsertQueryBody(): MultiInsertQueryBodyContext[];
|
|
public multiInsertQueryBody(i: number): MultiInsertQueryBodyContext;
|
|
public multiInsertQueryBody(i?: number): MultiInsertQueryBodyContext | MultiInsertQueryBodyContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(MultiInsertQueryBodyContext);
|
|
} else {
|
|
return this.getRuleContext(i, MultiInsertQueryBodyContext);
|
|
}
|
|
}
|
|
public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
|
|
public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
|
|
public tableName(): TableNameContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameContext);
|
|
}
|
|
public tableAlias(): TableAliasContext[];
|
|
public tableAlias(i: number): TableAliasContext;
|
|
public tableAlias(i?: number): TableAliasContext | TableAliasContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(TableAliasContext);
|
|
} else {
|
|
return this.getRuleContext(i, TableAliasContext);
|
|
}
|
|
}
|
|
public whereClause(): WhereClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, WhereClauseContext);
|
|
}
|
|
public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
|
|
public setClause(): SetClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, SetClauseContext);
|
|
}
|
|
public KW_MERGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MERGE, 0); }
|
|
public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
|
|
public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
|
|
public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
|
|
public booleanExpression(): BooleanExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public identifierReference(): IdentifierReferenceContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierReferenceContext);
|
|
}
|
|
public matchedClause(): MatchedClauseContext[];
|
|
public matchedClause(i: number): MatchedClauseContext;
|
|
public matchedClause(i?: number): MatchedClauseContext | MatchedClauseContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(MatchedClauseContext);
|
|
} else {
|
|
return this.getRuleContext(i, MatchedClauseContext);
|
|
}
|
|
}
|
|
public notMatchedClause(): NotMatchedClauseContext[];
|
|
public notMatchedClause(i: number): NotMatchedClauseContext;
|
|
public notMatchedClause(i?: number): NotMatchedClauseContext | NotMatchedClauseContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(NotMatchedClauseContext);
|
|
} else {
|
|
return this.getRuleContext(i, NotMatchedClauseContext);
|
|
}
|
|
}
|
|
public notMatchedBySourceClause(): NotMatchedBySourceClauseContext[];
|
|
public notMatchedBySourceClause(i: number): NotMatchedBySourceClauseContext;
|
|
public notMatchedBySourceClause(i?: number): NotMatchedBySourceClauseContext | NotMatchedBySourceClauseContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(NotMatchedBySourceClauseContext);
|
|
} else {
|
|
return this.getRuleContext(i, NotMatchedBySourceClauseContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_dmlStatementNoWith; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDmlStatementNoWith) {
|
|
listener.enterDmlStatementNoWith(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDmlStatementNoWith) {
|
|
listener.exitDmlStatementNoWith(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDmlStatementNoWith) {
|
|
return visitor.visitDmlStatementNoWith(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DbSchemaNameContext extends ParserRuleContext {
|
|
public identifierReference(): IdentifierReferenceContext {
|
|
return this.getRuleContext(0, IdentifierReferenceContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchemaName; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDbSchemaName) {
|
|
listener.enterDbSchemaName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDbSchemaName) {
|
|
listener.exitDbSchemaName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDbSchemaName) {
|
|
return visitor.visitDbSchemaName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DbSchemaNameCreateContext extends ParserRuleContext {
|
|
public identifierReference(): IdentifierReferenceContext {
|
|
return this.getRuleContext(0, IdentifierReferenceContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchemaNameCreate; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDbSchemaNameCreate) {
|
|
listener.enterDbSchemaNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDbSchemaNameCreate) {
|
|
listener.exitDbSchemaNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDbSchemaNameCreate) {
|
|
return visitor.visitDbSchemaNameCreate(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TableNameCreateContext extends ParserRuleContext {
|
|
public tableIdentifier(): TableIdentifierContext {
|
|
return this.getRuleContext(0, TableIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_tableNameCreate; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTableNameCreate) {
|
|
listener.enterTableNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTableNameCreate) {
|
|
listener.exitTableNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTableNameCreate) {
|
|
return visitor.visitTableNameCreate(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TableNameContext extends ParserRuleContext {
|
|
public tableIdentifier(): TableIdentifierContext {
|
|
return this.getRuleContext(0, TableIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_tableName; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTableName) {
|
|
listener.enterTableName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTableName) {
|
|
listener.exitTableName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTableName) {
|
|
return visitor.visitTableName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ViewNameCreateContext extends ParserRuleContext {
|
|
public viewIdentifier(): ViewIdentifierContext {
|
|
return this.getRuleContext(0, ViewIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_viewNameCreate; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterViewNameCreate) {
|
|
listener.enterViewNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitViewNameCreate) {
|
|
listener.exitViewNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitViewNameCreate) {
|
|
return visitor.visitViewNameCreate(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ViewNameContext extends ParserRuleContext {
|
|
public viewIdentifier(): ViewIdentifierContext {
|
|
return this.getRuleContext(0, ViewIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_viewName; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterViewName) {
|
|
listener.enterViewName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitViewName) {
|
|
listener.exitViewName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitViewName) {
|
|
return visitor.visitViewName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierReferenceContext extends ParserRuleContext {
|
|
public KW_IDENTIFIER_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 0); }
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public expression(): ExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public multipartIdentifier(): MultipartIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, MultipartIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_identifierReference; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIdentifierReference) {
|
|
listener.enterIdentifierReference(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIdentifierReference) {
|
|
listener.exitIdentifierReference(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIdentifierReference) {
|
|
return visitor.visitIdentifierReference(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QueryOrganizationContext extends ParserRuleContext {
|
|
public _sortItem!: SortItemContext;
|
|
public _order: SortItemContext[] = [];
|
|
public _expression!: ExpressionContext;
|
|
public _clusterBy: ExpressionContext[] = [];
|
|
public _distributeBy: ExpressionContext[] = [];
|
|
public _sort: SortItemContext[] = [];
|
|
public _limit!: ExpressionContext;
|
|
public _offset!: ExpressionContext;
|
|
public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
|
|
public KW_BY(): TerminalNode[];
|
|
public KW_BY(i: number): TerminalNode;
|
|
public KW_BY(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_BY);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_BY, i);
|
|
}
|
|
}
|
|
public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
|
|
public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
|
|
public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
|
|
public windowClause(): WindowClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, WindowClauseContext);
|
|
}
|
|
public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIMIT, 0); }
|
|
public KW_OFFSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OFFSET, 0); }
|
|
public sortItem(): SortItemContext[];
|
|
public sortItem(i: number): SortItemContext;
|
|
public sortItem(i?: number): SortItemContext | SortItemContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(SortItemContext);
|
|
} else {
|
|
return this.getRuleContext(i, SortItemContext);
|
|
}
|
|
}
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_queryOrganization; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQueryOrganization) {
|
|
listener.enterQueryOrganization(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQueryOrganization) {
|
|
listener.exitQueryOrganization(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQueryOrganization) {
|
|
return visitor.visitQueryOrganization(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MultiInsertQueryBodyContext extends ParserRuleContext {
|
|
public insertInto(): InsertIntoContext {
|
|
return this.getRuleContext(0, InsertIntoContext);
|
|
}
|
|
public fromStatementBody(): FromStatementBodyContext {
|
|
return this.getRuleContext(0, FromStatementBodyContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_multiInsertQueryBody; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMultiInsertQueryBody) {
|
|
listener.enterMultiInsertQueryBody(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMultiInsertQueryBody) {
|
|
listener.exitMultiInsertQueryBody(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMultiInsertQueryBody) {
|
|
return visitor.visitMultiInsertQueryBody(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QueryTermContext extends ParserRuleContext {
|
|
public _left!: QueryTermContext;
|
|
public _operator!: Token;
|
|
public _right!: QueryTermContext;
|
|
public queryPrimary(): QueryPrimaryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryPrimaryContext);
|
|
}
|
|
public queryTerm(): QueryTermContext[];
|
|
public queryTerm(i: number): QueryTermContext;
|
|
public queryTerm(i?: number): QueryTermContext | QueryTermContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(QueryTermContext);
|
|
} else {
|
|
return this.getRuleContext(i, QueryTermContext);
|
|
}
|
|
}
|
|
public KW_INTERSECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERSECT, 0); }
|
|
public KW_UNION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNION, 0); }
|
|
public KW_EXCEPT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCEPT, 0); }
|
|
public KW_SETMINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETMINUS, 0); }
|
|
public setQuantifier(): SetQuantifierContext | undefined {
|
|
return this.tryGetRuleContext(0, SetQuantifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_queryTerm; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQueryTerm) {
|
|
listener.enterQueryTerm(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQueryTerm) {
|
|
listener.exitQueryTerm(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQueryTerm) {
|
|
return visitor.visitQueryTerm(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QueryPrimaryContext extends ParserRuleContext {
|
|
public querySpecification(): QuerySpecificationContext | undefined {
|
|
return this.tryGetRuleContext(0, QuerySpecificationContext);
|
|
}
|
|
public fromStatement(): FromStatementContext | undefined {
|
|
return this.tryGetRuleContext(0, FromStatementContext);
|
|
}
|
|
public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public tableName(): TableNameContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameContext);
|
|
}
|
|
public inlineTable(): InlineTableContext | undefined {
|
|
return this.tryGetRuleContext(0, InlineTableContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_queryPrimary; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQueryPrimary) {
|
|
listener.enterQueryPrimary(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQueryPrimary) {
|
|
listener.exitQueryPrimary(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQueryPrimary) {
|
|
return visitor.visitQueryPrimary(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SortItemContext extends ParserRuleContext {
|
|
public _ordering!: Token;
|
|
public _nullOrder!: Token;
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
|
|
public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
|
|
public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
|
|
public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
|
|
public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_sortItem; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSortItem) {
|
|
listener.enterSortItem(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSortItem) {
|
|
listener.exitSortItem(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSortItem) {
|
|
return visitor.visitSortItem(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FromStatementContext extends ParserRuleContext {
|
|
public fromClause(): FromClauseContext {
|
|
return this.getRuleContext(0, FromClauseContext);
|
|
}
|
|
public fromStatementBody(): FromStatementBodyContext[];
|
|
public fromStatementBody(i: number): FromStatementBodyContext;
|
|
public fromStatementBody(i?: number): FromStatementBodyContext | FromStatementBodyContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(FromStatementBodyContext);
|
|
} else {
|
|
return this.getRuleContext(i, FromStatementBodyContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_fromStatement; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFromStatement) {
|
|
listener.enterFromStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFromStatement) {
|
|
listener.exitFromStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFromStatement) {
|
|
return visitor.visitFromStatement(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FromStatementBodyContext extends ParserRuleContext {
|
|
public transformClause(): TransformClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, TransformClauseContext);
|
|
}
|
|
public queryOrganization(): QueryOrganizationContext {
|
|
return this.getRuleContext(0, QueryOrganizationContext);
|
|
}
|
|
public whereClause(): WhereClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, WhereClauseContext);
|
|
}
|
|
public selectClause(): SelectClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, SelectClauseContext);
|
|
}
|
|
public lateralView(): LateralViewContext[];
|
|
public lateralView(i: number): LateralViewContext;
|
|
public lateralView(i?: number): LateralViewContext | LateralViewContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(LateralViewContext);
|
|
} else {
|
|
return this.getRuleContext(i, LateralViewContext);
|
|
}
|
|
}
|
|
public aggregationClause(): AggregationClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, AggregationClauseContext);
|
|
}
|
|
public havingClause(): HavingClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, HavingClauseContext);
|
|
}
|
|
public windowClause(): WindowClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, WindowClauseContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_fromStatementBody; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFromStatementBody) {
|
|
listener.enterFromStatementBody(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFromStatementBody) {
|
|
listener.exitFromStatementBody(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFromStatementBody) {
|
|
return visitor.visitFromStatementBody(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QuerySpecificationContext extends ParserRuleContext {
|
|
public transformClause(): TransformClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, TransformClauseContext);
|
|
}
|
|
public fromClause(): FromClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, FromClauseContext);
|
|
}
|
|
public lateralView(): LateralViewContext[];
|
|
public lateralView(i: number): LateralViewContext;
|
|
public lateralView(i?: number): LateralViewContext | LateralViewContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(LateralViewContext);
|
|
} else {
|
|
return this.getRuleContext(i, LateralViewContext);
|
|
}
|
|
}
|
|
public whereClause(): WhereClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, WhereClauseContext);
|
|
}
|
|
public aggregationClause(): AggregationClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, AggregationClauseContext);
|
|
}
|
|
public havingClause(): HavingClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, HavingClauseContext);
|
|
}
|
|
public windowClause(): WindowClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, WindowClauseContext);
|
|
}
|
|
public selectClause(): SelectClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, SelectClauseContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_querySpecification; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQuerySpecification) {
|
|
listener.enterQuerySpecification(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQuerySpecification) {
|
|
listener.exitQuerySpecification(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQuerySpecification) {
|
|
return visitor.visitQuerySpecification(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TransformClauseContext extends ParserRuleContext {
|
|
public _kind!: Token;
|
|
public _inRowFormat!: RowFormatContext;
|
|
public _recordWriter!: StringLitContext;
|
|
public _script!: StringLitContext;
|
|
public _outRowFormat!: RowFormatContext;
|
|
public _recordReader!: StringLitContext;
|
|
public KW_USING(): TerminalNode { return this.getToken(SparkSqlParser.KW_USING, 0); }
|
|
public stringLit(): StringLitContext[];
|
|
public stringLit(i: number): StringLitContext;
|
|
public stringLit(i?: number): StringLitContext | StringLitContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLitContext);
|
|
} else {
|
|
return this.getRuleContext(i, StringLitContext);
|
|
}
|
|
}
|
|
public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SELECT, 0); }
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public expressionSeq(): ExpressionSeqContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionSeqContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSFORM, 0); }
|
|
public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
|
|
public KW_REDUCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REDUCE, 0); }
|
|
public KW_RECORDWRITER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDWRITER, 0); }
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public KW_RECORDREADER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDREADER, 0); }
|
|
public rowFormat(): RowFormatContext[];
|
|
public rowFormat(i: number): RowFormatContext;
|
|
public rowFormat(i?: number): RowFormatContext | RowFormatContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(RowFormatContext);
|
|
} else {
|
|
return this.getRuleContext(i, RowFormatContext);
|
|
}
|
|
}
|
|
public setQuantifier(): SetQuantifierContext | undefined {
|
|
return this.tryGetRuleContext(0, SetQuantifierContext);
|
|
}
|
|
public identifierSeq(): IdentifierSeqContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierSeqContext);
|
|
}
|
|
public colTypeList(): ColTypeListContext | undefined {
|
|
return this.tryGetRuleContext(0, ColTypeListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_transformClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTransformClause) {
|
|
listener.enterTransformClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTransformClause) {
|
|
listener.exitTransformClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTransformClause) {
|
|
return visitor.visitTransformClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SelectClauseContext extends ParserRuleContext {
|
|
public _hint!: HintContext;
|
|
public _hints: HintContext[] = [];
|
|
public KW_SELECT(): TerminalNode { return this.getToken(SparkSqlParser.KW_SELECT, 0); }
|
|
public namedExpressionSeq(): NamedExpressionSeqContext {
|
|
return this.getRuleContext(0, NamedExpressionSeqContext);
|
|
}
|
|
public setQuantifier(): SetQuantifierContext | undefined {
|
|
return this.tryGetRuleContext(0, SetQuantifierContext);
|
|
}
|
|
public hint(): HintContext[];
|
|
public hint(i: number): HintContext;
|
|
public hint(i?: number): HintContext | HintContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(HintContext);
|
|
} else {
|
|
return this.getRuleContext(i, HintContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_selectClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSelectClause) {
|
|
listener.enterSelectClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSelectClause) {
|
|
listener.exitSelectClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSelectClause) {
|
|
return visitor.visitSelectClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SetClauseContext extends ParserRuleContext {
|
|
public KW_SET(): TerminalNode { return this.getToken(SparkSqlParser.KW_SET, 0); }
|
|
public assignmentList(): AssignmentListContext {
|
|
return this.getRuleContext(0, AssignmentListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_setClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSetClause) {
|
|
listener.enterSetClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSetClause) {
|
|
listener.exitSetClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSetClause) {
|
|
return visitor.visitSetClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MatchedClauseContext extends ParserRuleContext {
|
|
public _matchedCond!: BooleanExpressionContext;
|
|
public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
|
|
public KW_MATCHED(): TerminalNode { return this.getToken(SparkSqlParser.KW_MATCHED, 0); }
|
|
public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
|
|
public matchedAction(): MatchedActionContext {
|
|
return this.getRuleContext(0, MatchedActionContext);
|
|
}
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
public booleanExpression(): BooleanExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_matchedClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMatchedClause) {
|
|
listener.enterMatchedClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMatchedClause) {
|
|
listener.exitMatchedClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMatchedClause) {
|
|
return visitor.visitMatchedClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NotMatchedClauseContext extends ParserRuleContext {
|
|
public _notMatchedCond!: BooleanExpressionContext;
|
|
public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
|
|
public KW_NOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_MATCHED(): TerminalNode { return this.getToken(SparkSqlParser.KW_MATCHED, 0); }
|
|
public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
|
|
public notMatchedAction(): NotMatchedActionContext {
|
|
return this.getRuleContext(0, NotMatchedActionContext);
|
|
}
|
|
public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
|
|
public KW_TARGET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TARGET, 0); }
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
public booleanExpression(): BooleanExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNotMatchedClause) {
|
|
listener.enterNotMatchedClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNotMatchedClause) {
|
|
listener.exitNotMatchedClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNotMatchedClause) {
|
|
return visitor.visitNotMatchedClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NotMatchedBySourceClauseContext extends ParserRuleContext {
|
|
public _notMatchedBySourceCond!: BooleanExpressionContext;
|
|
public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
|
|
public KW_NOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_MATCHED(): TerminalNode { return this.getToken(SparkSqlParser.KW_MATCHED, 0); }
|
|
public KW_BY(): TerminalNode { return this.getToken(SparkSqlParser.KW_BY, 0); }
|
|
public KW_SOURCE(): TerminalNode { return this.getToken(SparkSqlParser.KW_SOURCE, 0); }
|
|
public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
|
|
public notMatchedBySourceAction(): NotMatchedBySourceActionContext {
|
|
return this.getRuleContext(0, NotMatchedBySourceActionContext);
|
|
}
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
public booleanExpression(): BooleanExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedBySourceClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNotMatchedBySourceClause) {
|
|
listener.enterNotMatchedBySourceClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNotMatchedBySourceClause) {
|
|
listener.exitNotMatchedBySourceClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNotMatchedBySourceClause) {
|
|
return visitor.visitNotMatchedBySourceClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MatchedActionContext extends ParserRuleContext {
|
|
public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
|
|
public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
|
|
public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
|
|
public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
|
|
public assignmentList(): AssignmentListContext | undefined {
|
|
return this.tryGetRuleContext(0, AssignmentListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_matchedAction; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMatchedAction) {
|
|
listener.enterMatchedAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMatchedAction) {
|
|
listener.exitMatchedAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMatchedAction) {
|
|
return visitor.visitMatchedAction(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NotMatchedActionContext extends ParserRuleContext {
|
|
public KW_INSERT(): TerminalNode { return this.getToken(SparkSqlParser.KW_INSERT, 0); }
|
|
public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public multipartIdentifierList(): MultipartIdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, MultipartIdentifierListContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VALUES, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedAction; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNotMatchedAction) {
|
|
listener.enterNotMatchedAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNotMatchedAction) {
|
|
listener.exitNotMatchedAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNotMatchedAction) {
|
|
return visitor.visitNotMatchedAction(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NotMatchedBySourceActionContext extends ParserRuleContext {
|
|
public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
|
|
public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
|
|
public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
|
|
public assignmentList(): AssignmentListContext | undefined {
|
|
return this.tryGetRuleContext(0, AssignmentListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedBySourceAction; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNotMatchedBySourceAction) {
|
|
listener.enterNotMatchedBySourceAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNotMatchedBySourceAction) {
|
|
listener.exitNotMatchedBySourceAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNotMatchedBySourceAction) {
|
|
return visitor.visitNotMatchedBySourceAction(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AssignmentListContext extends ParserRuleContext {
|
|
public assignment(): AssignmentContext[];
|
|
public assignment(i: number): AssignmentContext;
|
|
public assignment(i?: number): AssignmentContext | AssignmentContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(AssignmentContext);
|
|
} else {
|
|
return this.getRuleContext(i, AssignmentContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_assignmentList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterAssignmentList) {
|
|
listener.enterAssignmentList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitAssignmentList) {
|
|
listener.exitAssignmentList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitAssignmentList) {
|
|
return visitor.visitAssignmentList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AssignmentContext extends ParserRuleContext {
|
|
public _key!: MultipartIdentifierContext;
|
|
public _value!: ExpressionContext;
|
|
public EQ(): TerminalNode { return this.getToken(SparkSqlParser.EQ, 0); }
|
|
public multipartIdentifier(): MultipartIdentifierContext {
|
|
return this.getRuleContext(0, MultipartIdentifierContext);
|
|
}
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_assignment; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterAssignment) {
|
|
listener.enterAssignment(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitAssignment) {
|
|
listener.exitAssignment(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitAssignment) {
|
|
return visitor.visitAssignment(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class WhereClauseContext extends ParserRuleContext {
|
|
public KW_WHERE(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHERE, 0); }
|
|
public booleanExpression(): BooleanExpressionContext {
|
|
return this.getRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_whereClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterWhereClause) {
|
|
listener.enterWhereClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitWhereClause) {
|
|
listener.exitWhereClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitWhereClause) {
|
|
return visitor.visitWhereClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class HavingClauseContext extends ParserRuleContext {
|
|
public KW_HAVING(): TerminalNode { return this.getToken(SparkSqlParser.KW_HAVING, 0); }
|
|
public booleanExpression(): BooleanExpressionContext {
|
|
return this.getRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_havingClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterHavingClause) {
|
|
listener.enterHavingClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitHavingClause) {
|
|
listener.exitHavingClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitHavingClause) {
|
|
return visitor.visitHavingClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class HintContext extends ParserRuleContext {
|
|
public _hintStatement!: HintStatementContext;
|
|
public _hintStatements: HintStatementContext[] = [];
|
|
public HENT_START(): TerminalNode { return this.getToken(SparkSqlParser.HENT_START, 0); }
|
|
public HENT_END(): TerminalNode { return this.getToken(SparkSqlParser.HENT_END, 0); }
|
|
public hintStatement(): HintStatementContext[];
|
|
public hintStatement(i: number): HintStatementContext;
|
|
public hintStatement(i?: number): HintStatementContext | HintStatementContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(HintStatementContext);
|
|
} else {
|
|
return this.getRuleContext(i, HintStatementContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_hint; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterHint) {
|
|
listener.enterHint(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitHint) {
|
|
listener.exitHint(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitHint) {
|
|
return visitor.visitHint(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class HintStatementContext extends ParserRuleContext {
|
|
public _hintName!: IdentifierContext;
|
|
public _primaryExpression!: PrimaryExpressionContext;
|
|
public _parameters: PrimaryExpressionContext[] = [];
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public primaryExpression(): PrimaryExpressionContext[];
|
|
public primaryExpression(i: number): PrimaryExpressionContext;
|
|
public primaryExpression(i?: number): PrimaryExpressionContext | PrimaryExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PrimaryExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, PrimaryExpressionContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_hintStatement; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterHintStatement) {
|
|
listener.enterHintStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitHintStatement) {
|
|
listener.exitHintStatement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitHintStatement) {
|
|
return visitor.visitHintStatement(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FromClauseContext extends ParserRuleContext {
|
|
public KW_FROM(): TerminalNode { return this.getToken(SparkSqlParser.KW_FROM, 0); }
|
|
public relation(): RelationContext[];
|
|
public relation(i: number): RelationContext;
|
|
public relation(i?: number): RelationContext | RelationContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(RelationContext);
|
|
} else {
|
|
return this.getRuleContext(i, RelationContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public lateralView(): LateralViewContext[];
|
|
public lateralView(i: number): LateralViewContext;
|
|
public lateralView(i?: number): LateralViewContext | LateralViewContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(LateralViewContext);
|
|
} else {
|
|
return this.getRuleContext(i, LateralViewContext);
|
|
}
|
|
}
|
|
public pivotClause(): PivotClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, PivotClauseContext);
|
|
}
|
|
public unpivotClause(): UnpivotClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, UnpivotClauseContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_fromClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFromClause) {
|
|
listener.enterFromClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFromClause) {
|
|
listener.exitFromClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFromClause) {
|
|
return visitor.visitFromClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionKindContext extends ParserRuleContext {
|
|
public KW_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USER, 0); }
|
|
public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM, 0); }
|
|
public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionKind; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionKind) {
|
|
listener.enterFunctionKind(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionKind) {
|
|
listener.exitFunctionKind(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionKind) {
|
|
return visitor.visitFunctionKind(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TemporalClauseContext extends ParserRuleContext {
|
|
public _timestamp!: ValueExpressionContext;
|
|
public KW_AS(): TerminalNode { return this.getToken(SparkSqlParser.KW_AS, 0); }
|
|
public KW_OF(): TerminalNode { return this.getToken(SparkSqlParser.KW_OF, 0); }
|
|
public version(): VersionContext | undefined {
|
|
return this.tryGetRuleContext(0, VersionContext);
|
|
}
|
|
public KW_SYSTEM_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_VERSION, 0); }
|
|
public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VERSION, 0); }
|
|
public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
|
|
public KW_SYSTEM_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_TIME, 0); }
|
|
public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
|
|
public valueExpression(): ValueExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ValueExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_temporalClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTemporalClause) {
|
|
listener.enterTemporalClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTemporalClause) {
|
|
listener.exitTemporalClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTemporalClause) {
|
|
return visitor.visitTemporalClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AggregationClauseContext extends ParserRuleContext {
|
|
public _groupByClause!: GroupByClauseContext;
|
|
public _groupingExpressionsWithGroupingAnalytics: GroupByClauseContext[] = [];
|
|
public _expression!: ExpressionContext;
|
|
public _groupingExpressions: ExpressionContext[] = [];
|
|
public _kind!: Token;
|
|
public KW_GROUP(): TerminalNode { return this.getToken(SparkSqlParser.KW_GROUP, 0); }
|
|
public KW_BY(): TerminalNode { return this.getToken(SparkSqlParser.KW_BY, 0); }
|
|
public groupByClause(): GroupByClauseContext[];
|
|
public groupByClause(i: number): GroupByClauseContext;
|
|
public groupByClause(i?: number): GroupByClauseContext | GroupByClauseContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(GroupByClauseContext);
|
|
} else {
|
|
return this.getRuleContext(i, GroupByClauseContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
|
|
public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public groupingSet(): GroupingSetContext[];
|
|
public groupingSet(i: number): GroupingSetContext;
|
|
public groupingSet(i?: number): GroupingSetContext | GroupingSetContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(GroupingSetContext);
|
|
} else {
|
|
return this.getRuleContext(i, GroupingSetContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
|
|
public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
|
|
public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_aggregationClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterAggregationClause) {
|
|
listener.enterAggregationClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitAggregationClause) {
|
|
listener.exitAggregationClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitAggregationClause) {
|
|
return visitor.visitAggregationClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class GroupByClauseContext extends ParserRuleContext {
|
|
public groupingAnalytics(): GroupingAnalyticsContext | undefined {
|
|
return this.tryGetRuleContext(0, GroupingAnalyticsContext);
|
|
}
|
|
public expression(): ExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_groupByClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterGroupByClause) {
|
|
listener.enterGroupByClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitGroupByClause) {
|
|
listener.exitGroupByClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitGroupByClause) {
|
|
return visitor.visitGroupByClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class GroupingAnalyticsContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public groupingSet(): GroupingSetContext[];
|
|
public groupingSet(i: number): GroupingSetContext;
|
|
public groupingSet(i?: number): GroupingSetContext | GroupingSetContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(GroupingSetContext);
|
|
} else {
|
|
return this.getRuleContext(i, GroupingSetContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
|
|
public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
|
|
public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
|
|
public groupingElement(): GroupingElementContext[];
|
|
public groupingElement(i: number): GroupingElementContext;
|
|
public groupingElement(i?: number): GroupingElementContext | GroupingElementContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(GroupingElementContext);
|
|
} else {
|
|
return this.getRuleContext(i, GroupingElementContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_groupingAnalytics; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterGroupingAnalytics) {
|
|
listener.enterGroupingAnalytics(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitGroupingAnalytics) {
|
|
listener.exitGroupingAnalytics(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitGroupingAnalytics) {
|
|
return visitor.visitGroupingAnalytics(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class GroupingElementContext extends ParserRuleContext {
|
|
public groupingAnalytics(): GroupingAnalyticsContext | undefined {
|
|
return this.tryGetRuleContext(0, GroupingAnalyticsContext);
|
|
}
|
|
public groupingSet(): GroupingSetContext | undefined {
|
|
return this.tryGetRuleContext(0, GroupingSetContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_groupingElement; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterGroupingElement) {
|
|
listener.enterGroupingElement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitGroupingElement) {
|
|
listener.exitGroupingElement(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitGroupingElement) {
|
|
return visitor.visitGroupingElement(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class GroupingSetContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_groupingSet; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterGroupingSet) {
|
|
listener.enterGroupingSet(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitGroupingSet) {
|
|
listener.exitGroupingSet(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitGroupingSet) {
|
|
return visitor.visitGroupingSet(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PivotClauseContext extends ParserRuleContext {
|
|
public _aggregates!: NamedExpressionSeqContext;
|
|
public _pivotValue!: PivotValueContext;
|
|
public _pivotValues: PivotValueContext[] = [];
|
|
public KW_PIVOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_PIVOT, 0); }
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public KW_FOR(): TerminalNode { return this.getToken(SparkSqlParser.KW_FOR, 0); }
|
|
public pivotColumn(): PivotColumnContext {
|
|
return this.getRuleContext(0, PivotColumnContext);
|
|
}
|
|
public KW_IN(): TerminalNode { return this.getToken(SparkSqlParser.KW_IN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public namedExpressionSeq(): NamedExpressionSeqContext {
|
|
return this.getRuleContext(0, NamedExpressionSeqContext);
|
|
}
|
|
public pivotValue(): PivotValueContext[];
|
|
public pivotValue(i: number): PivotValueContext;
|
|
public pivotValue(i?: number): PivotValueContext | PivotValueContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PivotValueContext);
|
|
} else {
|
|
return this.getRuleContext(i, PivotValueContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_pivotClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPivotClause) {
|
|
listener.enterPivotClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPivotClause) {
|
|
listener.exitPivotClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPivotClause) {
|
|
return visitor.visitPivotClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PivotColumnContext extends ParserRuleContext {
|
|
public _identifier!: IdentifierContext;
|
|
public _identifiers: IdentifierContext[] = [];
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_pivotColumn; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPivotColumn) {
|
|
listener.enterPivotColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPivotColumn) {
|
|
listener.exitPivotColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPivotColumn) {
|
|
return visitor.visitPivotColumn(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PivotValueContext extends ParserRuleContext {
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_pivotValue; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPivotValue) {
|
|
listener.enterPivotValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPivotValue) {
|
|
listener.exitPivotValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPivotValue) {
|
|
return visitor.visitPivotValue(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotClauseContext extends ParserRuleContext {
|
|
public _nullOperator!: UnpivotNullClauseContext;
|
|
public _operator!: UnpivotOperatorContext;
|
|
public KW_UNPIVOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_UNPIVOT, 0); }
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public unpivotOperator(): UnpivotOperatorContext {
|
|
return this.getRuleContext(0, UnpivotOperatorContext);
|
|
}
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
public unpivotNullClause(): UnpivotNullClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, UnpivotNullClauseContext);
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotClause) {
|
|
listener.enterUnpivotClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotClause) {
|
|
listener.exitUnpivotClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotClause) {
|
|
return visitor.visitUnpivotClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotNullClauseContext extends ParserRuleContext {
|
|
public KW_NULLS(): TerminalNode { return this.getToken(SparkSqlParser.KW_NULLS, 0); }
|
|
public KW_INCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INCLUDE, 0); }
|
|
public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCLUDE, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotNullClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotNullClause) {
|
|
listener.enterUnpivotNullClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotNullClause) {
|
|
listener.exitUnpivotNullClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotNullClause) {
|
|
return visitor.visitUnpivotNullClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotOperatorContext extends ParserRuleContext {
|
|
public unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, UnpivotSingleValueColumnClauseContext);
|
|
}
|
|
public unpivotMultiValueColumnClause(): UnpivotMultiValueColumnClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, UnpivotMultiValueColumnClauseContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotOperator; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotOperator) {
|
|
listener.enterUnpivotOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotOperator) {
|
|
listener.exitUnpivotOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotOperator) {
|
|
return visitor.visitUnpivotOperator(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotSingleValueColumnClauseContext extends ParserRuleContext {
|
|
public _unpivotColumnAndAlias!: UnpivotColumnAndAliasContext;
|
|
public _unpivotColumns: UnpivotColumnAndAliasContext[] = [];
|
|
public unpivotValueColumn(): UnpivotValueColumnContext {
|
|
return this.getRuleContext(0, UnpivotValueColumnContext);
|
|
}
|
|
public KW_FOR(): TerminalNode { return this.getToken(SparkSqlParser.KW_FOR, 0); }
|
|
public unpivotNameColumn(): UnpivotNameColumnContext {
|
|
return this.getRuleContext(0, UnpivotNameColumnContext);
|
|
}
|
|
public KW_IN(): TerminalNode { return this.getToken(SparkSqlParser.KW_IN, 0); }
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext[];
|
|
public unpivotColumnAndAlias(i: number): UnpivotColumnAndAliasContext;
|
|
public unpivotColumnAndAlias(i?: number): UnpivotColumnAndAliasContext | UnpivotColumnAndAliasContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(UnpivotColumnAndAliasContext);
|
|
} else {
|
|
return this.getRuleContext(i, UnpivotColumnAndAliasContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotSingleValueColumnClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotSingleValueColumnClause) {
|
|
listener.enterUnpivotSingleValueColumnClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotSingleValueColumnClause) {
|
|
listener.exitUnpivotSingleValueColumnClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotSingleValueColumnClause) {
|
|
return visitor.visitUnpivotSingleValueColumnClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotMultiValueColumnClauseContext extends ParserRuleContext {
|
|
public _unpivotValueColumn!: UnpivotValueColumnContext;
|
|
public _unpivotValueColumns: UnpivotValueColumnContext[] = [];
|
|
public _unpivotColumnSet!: UnpivotColumnSetContext;
|
|
public _unpivotColumnSets: UnpivotColumnSetContext[] = [];
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public KW_FOR(): TerminalNode { return this.getToken(SparkSqlParser.KW_FOR, 0); }
|
|
public unpivotNameColumn(): UnpivotNameColumnContext {
|
|
return this.getRuleContext(0, UnpivotNameColumnContext);
|
|
}
|
|
public KW_IN(): TerminalNode { return this.getToken(SparkSqlParser.KW_IN, 0); }
|
|
public unpivotValueColumn(): UnpivotValueColumnContext[];
|
|
public unpivotValueColumn(i: number): UnpivotValueColumnContext;
|
|
public unpivotValueColumn(i?: number): UnpivotValueColumnContext | UnpivotValueColumnContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(UnpivotValueColumnContext);
|
|
} else {
|
|
return this.getRuleContext(i, UnpivotValueColumnContext);
|
|
}
|
|
}
|
|
public unpivotColumnSet(): UnpivotColumnSetContext[];
|
|
public unpivotColumnSet(i: number): UnpivotColumnSetContext;
|
|
public unpivotColumnSet(i?: number): UnpivotColumnSetContext | UnpivotColumnSetContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(UnpivotColumnSetContext);
|
|
} else {
|
|
return this.getRuleContext(i, UnpivotColumnSetContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotMultiValueColumnClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotMultiValueColumnClause) {
|
|
listener.enterUnpivotMultiValueColumnClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotMultiValueColumnClause) {
|
|
listener.exitUnpivotMultiValueColumnClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotMultiValueColumnClause) {
|
|
return visitor.visitUnpivotMultiValueColumnClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotColumnSetContext extends ParserRuleContext {
|
|
public _unpivotColumn!: UnpivotColumnContext;
|
|
public _unpivotColumns: UnpivotColumnContext[] = [];
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public unpivotColumn(): UnpivotColumnContext[];
|
|
public unpivotColumn(i: number): UnpivotColumnContext;
|
|
public unpivotColumn(i?: number): UnpivotColumnContext | UnpivotColumnContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(UnpivotColumnContext);
|
|
} else {
|
|
return this.getRuleContext(i, UnpivotColumnContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public unpivotAlias(): UnpivotAliasContext | undefined {
|
|
return this.tryGetRuleContext(0, UnpivotAliasContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotColumnSet; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotColumnSet) {
|
|
listener.enterUnpivotColumnSet(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotColumnSet) {
|
|
listener.exitUnpivotColumnSet(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotColumnSet) {
|
|
return visitor.visitUnpivotColumnSet(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotValueColumnContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotValueColumn; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotValueColumn) {
|
|
listener.enterUnpivotValueColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotValueColumn) {
|
|
listener.exitUnpivotValueColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotValueColumn) {
|
|
return visitor.visitUnpivotValueColumn(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotNameColumnContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotNameColumn; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotNameColumn) {
|
|
listener.enterUnpivotNameColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotNameColumn) {
|
|
listener.exitUnpivotNameColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotNameColumn) {
|
|
return visitor.visitUnpivotNameColumn(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotColumnAndAliasContext extends ParserRuleContext {
|
|
public unpivotColumn(): UnpivotColumnContext {
|
|
return this.getRuleContext(0, UnpivotColumnContext);
|
|
}
|
|
public unpivotAlias(): UnpivotAliasContext | undefined {
|
|
return this.tryGetRuleContext(0, UnpivotAliasContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotColumnAndAlias; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotColumnAndAlias) {
|
|
listener.enterUnpivotColumnAndAlias(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotColumnAndAlias) {
|
|
listener.exitUnpivotColumnAndAlias(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotColumnAndAlias) {
|
|
return visitor.visitUnpivotColumnAndAlias(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotColumnContext extends ParserRuleContext {
|
|
public multipartIdentifier(): MultipartIdentifierContext {
|
|
return this.getRuleContext(0, MultipartIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotColumn; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotColumn) {
|
|
listener.enterUnpivotColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotColumn) {
|
|
listener.exitUnpivotColumn(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotColumn) {
|
|
return visitor.visitUnpivotColumn(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnpivotAliasContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotAlias; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnpivotAlias) {
|
|
listener.enterUnpivotAlias(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnpivotAlias) {
|
|
listener.exitUnpivotAlias(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnpivotAlias) {
|
|
return visitor.visitUnpivotAlias(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IfNotExistsContext extends ParserRuleContext {
|
|
public KW_IF(): TerminalNode { return this.getToken(SparkSqlParser.KW_IF, 0); }
|
|
public KW_NOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_EXISTS(): TerminalNode { return this.getToken(SparkSqlParser.KW_EXISTS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_ifNotExists; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIfNotExists) {
|
|
listener.enterIfNotExists(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIfNotExists) {
|
|
listener.exitIfNotExists(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIfNotExists) {
|
|
return visitor.visitIfNotExists(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IfExistsContext extends ParserRuleContext {
|
|
public KW_IF(): TerminalNode { return this.getToken(SparkSqlParser.KW_IF, 0); }
|
|
public KW_EXISTS(): TerminalNode { return this.getToken(SparkSqlParser.KW_EXISTS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_ifExists; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIfExists) {
|
|
listener.enterIfExists(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIfExists) {
|
|
listener.exitIfExists(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIfExists) {
|
|
return visitor.visitIfExists(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class LateralViewContext extends ParserRuleContext {
|
|
public _identifier!: IdentifierContext;
|
|
public _colName: IdentifierContext[] = [];
|
|
public KW_LATERAL(): TerminalNode { return this.getToken(SparkSqlParser.KW_LATERAL, 0); }
|
|
public KW_VIEW(): TerminalNode { return this.getToken(SparkSqlParser.KW_VIEW, 0); }
|
|
public viewName(): ViewNameContext {
|
|
return this.getRuleContext(0, ViewNameContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public tableAlias(): TableAliasContext {
|
|
return this.getRuleContext(0, TableAliasContext);
|
|
}
|
|
public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTER, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_lateralView; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterLateralView) {
|
|
listener.enterLateralView(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitLateralView) {
|
|
listener.exitLateralView(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitLateralView) {
|
|
return visitor.visitLateralView(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SetQuantifierContext extends ParserRuleContext {
|
|
public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTINCT, 0); }
|
|
public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_setQuantifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSetQuantifier) {
|
|
listener.enterSetQuantifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSetQuantifier) {
|
|
listener.exitSetQuantifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSetQuantifier) {
|
|
return visitor.visitSetQuantifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RelationContext extends ParserRuleContext {
|
|
public relationPrimary(): RelationPrimaryContext | undefined {
|
|
return this.tryGetRuleContext(0, RelationPrimaryContext);
|
|
}
|
|
public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LATERAL, 0); }
|
|
public relationExtension(): RelationExtensionContext[];
|
|
public relationExtension(i: number): RelationExtensionContext;
|
|
public relationExtension(i?: number): RelationExtensionContext | RelationExtensionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(RelationExtensionContext);
|
|
} else {
|
|
return this.getRuleContext(i, RelationExtensionContext);
|
|
}
|
|
}
|
|
public tableName(): TableNameContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_relation; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterRelation) {
|
|
listener.enterRelation(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitRelation) {
|
|
listener.exitRelation(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitRelation) {
|
|
return visitor.visitRelation(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RelationExtensionContext extends ParserRuleContext {
|
|
public joinRelation(): JoinRelationContext | undefined {
|
|
return this.tryGetRuleContext(0, JoinRelationContext);
|
|
}
|
|
public pivotClause(): PivotClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, PivotClauseContext);
|
|
}
|
|
public unpivotClause(): UnpivotClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, UnpivotClauseContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_relationExtension; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterRelationExtension) {
|
|
listener.enterRelationExtension(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitRelationExtension) {
|
|
listener.exitRelationExtension(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitRelationExtension) {
|
|
return visitor.visitRelationExtension(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class JoinRelationContext extends ParserRuleContext {
|
|
public _right!: RelationPrimaryContext;
|
|
public KW_JOIN(): TerminalNode { return this.getToken(SparkSqlParser.KW_JOIN, 0); }
|
|
public relationPrimary(): RelationPrimaryContext {
|
|
return this.getRuleContext(0, RelationPrimaryContext);
|
|
}
|
|
public joinType(): JoinTypeContext | undefined {
|
|
return this.tryGetRuleContext(0, JoinTypeContext);
|
|
}
|
|
public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LATERAL, 0); }
|
|
public joinCriteria(): JoinCriteriaContext | undefined {
|
|
return this.tryGetRuleContext(0, JoinCriteriaContext);
|
|
}
|
|
public KW_NATURAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NATURAL, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_joinRelation; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterJoinRelation) {
|
|
listener.enterJoinRelation(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitJoinRelation) {
|
|
listener.exitJoinRelation(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitJoinRelation) {
|
|
return visitor.visitJoinRelation(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class JoinTypeContext extends ParserRuleContext {
|
|
public KW_INNER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INNER, 0); }
|
|
public KW_CROSS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CROSS, 0); }
|
|
public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEFT, 0); }
|
|
public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTER, 0); }
|
|
public KW_SEMI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEMI, 0); }
|
|
public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RIGHT, 0); }
|
|
public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FULL, 0); }
|
|
public KW_ANTI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANTI, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_joinType; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterJoinType) {
|
|
listener.enterJoinType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitJoinType) {
|
|
listener.exitJoinType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitJoinType) {
|
|
return visitor.visitJoinType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class JoinCriteriaContext extends ParserRuleContext {
|
|
public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
|
|
public booleanExpression(): BooleanExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
|
|
public identifierList(): IdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_joinCriteria; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterJoinCriteria) {
|
|
listener.enterJoinCriteria(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitJoinCriteria) {
|
|
listener.exitJoinCriteria(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitJoinCriteria) {
|
|
return visitor.visitJoinCriteria(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SampleContext extends ParserRuleContext {
|
|
public _seed!: Token;
|
|
public KW_TABLESAMPLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLESAMPLE, 0); }
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public sampleMethod(): SampleMethodContext | undefined {
|
|
return this.tryGetRuleContext(0, SampleMethodContext);
|
|
}
|
|
public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPEATABLE, 0); }
|
|
public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_sample; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSample) {
|
|
listener.enterSample(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSample) {
|
|
listener.exitSample(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSample) {
|
|
return visitor.visitSample(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class SampleMethodContext extends ParserRuleContext {
|
|
public _negativeSign!: Token;
|
|
public _percentage!: Token;
|
|
public _sampleType!: Token;
|
|
public _numerator!: Token;
|
|
public _denominator!: Token;
|
|
public _bytes!: ExpressionContext;
|
|
public KW_PERCENTLIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTLIT, 0); }
|
|
public INTEGER_VALUE(): TerminalNode[];
|
|
public INTEGER_VALUE(i: number): TerminalNode;
|
|
public INTEGER_VALUE(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.INTEGER_VALUE);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.INTEGER_VALUE, i);
|
|
}
|
|
}
|
|
public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
|
|
public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
|
|
public expression(): ExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionContext);
|
|
}
|
|
public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
|
|
public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUT, 0); }
|
|
public KW_OF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OF, 0); }
|
|
public KW_BUCKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKET, 0); }
|
|
public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
public qualifiedName(): QualifiedNameContext | undefined {
|
|
return this.tryGetRuleContext(0, QualifiedNameContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_sampleMethod; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterSampleMethod) {
|
|
listener.enterSampleMethod(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitSampleMethod) {
|
|
listener.exitSampleMethod(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitSampleMethod) {
|
|
return visitor.visitSampleMethod(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierListContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public identifierSeq(): IdentifierSeqContext {
|
|
return this.getRuleContext(0, IdentifierSeqContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_identifierList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIdentifierList) {
|
|
listener.enterIdentifierList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIdentifierList) {
|
|
listener.exitIdentifierList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIdentifierList) {
|
|
return visitor.visitIdentifierList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierSeqContext extends ParserRuleContext {
|
|
public _errorCapturingIdentifier!: ErrorCapturingIdentifierContext;
|
|
public _ident: ErrorCapturingIdentifierContext[] = [];
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
|
|
public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
|
|
public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ErrorCapturingIdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, ErrorCapturingIdentifierContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_identifierSeq; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIdentifierSeq) {
|
|
listener.enterIdentifierSeq(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIdentifierSeq) {
|
|
listener.exitIdentifierSeq(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIdentifierSeq) {
|
|
return visitor.visitIdentifierSeq(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class OrderedIdentifierListContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public orderedIdentifier(): OrderedIdentifierContext[];
|
|
public orderedIdentifier(i: number): OrderedIdentifierContext;
|
|
public orderedIdentifier(i?: number): OrderedIdentifierContext | OrderedIdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(OrderedIdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, OrderedIdentifierContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_orderedIdentifierList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterOrderedIdentifierList) {
|
|
listener.enterOrderedIdentifierList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitOrderedIdentifierList) {
|
|
listener.exitOrderedIdentifierList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitOrderedIdentifierList) {
|
|
return visitor.visitOrderedIdentifierList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class OrderedIdentifierContext extends ParserRuleContext {
|
|
public _ident!: ErrorCapturingIdentifierContext;
|
|
public _ordering!: Token;
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
|
|
return this.getRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
|
|
public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_orderedIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterOrderedIdentifier) {
|
|
listener.enterOrderedIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitOrderedIdentifier) {
|
|
listener.exitOrderedIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitOrderedIdentifier) {
|
|
return visitor.visitOrderedIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierCommentListContext extends ParserRuleContext {
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public identifierComment(): IdentifierCommentContext[];
|
|
public identifierComment(i: number): IdentifierCommentContext;
|
|
public identifierComment(i?: number): IdentifierCommentContext | IdentifierCommentContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierCommentContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierCommentContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_identifierCommentList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIdentifierCommentList) {
|
|
listener.enterIdentifierCommentList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIdentifierCommentList) {
|
|
listener.exitIdentifierCommentList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIdentifierCommentList) {
|
|
return visitor.visitIdentifierCommentList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierCommentContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public commentSpec(): CommentSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, CommentSpecContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_identifierComment; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIdentifierComment) {
|
|
listener.enterIdentifierComment(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIdentifierComment) {
|
|
listener.exitIdentifierComment(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIdentifierComment) {
|
|
return visitor.visitIdentifierComment(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RelationPrimaryContext extends ParserRuleContext {
|
|
public identifierReference(): IdentifierReferenceContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierReferenceContext);
|
|
}
|
|
public tableAlias(): TableAliasContext | undefined {
|
|
return this.tryGetRuleContext(0, TableAliasContext);
|
|
}
|
|
public temporalClause(): TemporalClauseContext | undefined {
|
|
return this.tryGetRuleContext(0, TemporalClauseContext);
|
|
}
|
|
public sample(): SampleContext | undefined {
|
|
return this.tryGetRuleContext(0, SampleContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public relation(): RelationContext | undefined {
|
|
return this.tryGetRuleContext(0, RelationContext);
|
|
}
|
|
public inlineTable(): InlineTableContext | undefined {
|
|
return this.tryGetRuleContext(0, InlineTableContext);
|
|
}
|
|
public functionTable(): FunctionTableContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionTableContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_relationPrimary; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterRelationPrimary) {
|
|
listener.enterRelationPrimary(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitRelationPrimary) {
|
|
listener.exitRelationPrimary(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitRelationPrimary) {
|
|
return visitor.visitRelationPrimary(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class InlineTableContext extends ParserRuleContext {
|
|
public KW_VALUES(): TerminalNode { return this.getToken(SparkSqlParser.KW_VALUES, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public tableAlias(): TableAliasContext {
|
|
return this.getRuleContext(0, TableAliasContext);
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_inlineTable; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterInlineTable) {
|
|
listener.enterInlineTable(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitInlineTable) {
|
|
listener.exitInlineTable(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitInlineTable) {
|
|
return visitor.visitInlineTable(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionTableSubqueryArgumentContext extends ParserRuleContext {
|
|
public KW_TABLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public tableName(): TableNameContext | undefined {
|
|
return this.tryGetRuleContext(0, TableNameContext);
|
|
}
|
|
public tableArgumentPartitioning(): TableArgumentPartitioningContext | undefined {
|
|
return this.tryGetRuleContext(0, TableArgumentPartitioningContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableSubqueryArgument; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionTableSubqueryArgument) {
|
|
listener.enterFunctionTableSubqueryArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionTableSubqueryArgument) {
|
|
listener.exitFunctionTableSubqueryArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionTableSubqueryArgument) {
|
|
return visitor.visitFunctionTableSubqueryArgument(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TableArgumentPartitioningContext extends ParserRuleContext {
|
|
public _expression!: ExpressionContext;
|
|
public _partition: ExpressionContext[] = [];
|
|
public KW_BY(): TerminalNode[];
|
|
public KW_BY(i: number): TerminalNode;
|
|
public KW_BY(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_BY);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_BY, i);
|
|
}
|
|
}
|
|
public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
|
|
public KW_SINGLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SINGLE, 0); }
|
|
public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
|
|
public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
|
|
public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
|
|
public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public sortItem(): SortItemContext[];
|
|
public sortItem(i: number): SortItemContext;
|
|
public sortItem(i?: number): SortItemContext | SortItemContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(SortItemContext);
|
|
} else {
|
|
return this.getRuleContext(i, SortItemContext);
|
|
}
|
|
}
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_tableArgumentPartitioning; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTableArgumentPartitioning) {
|
|
listener.enterTableArgumentPartitioning(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTableArgumentPartitioning) {
|
|
listener.exitTableArgumentPartitioning(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTableArgumentPartitioning) {
|
|
return visitor.visitTableArgumentPartitioning(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionTableNamedArgumentExpressionContext extends ParserRuleContext {
|
|
public _key!: IdentifierContext;
|
|
public _table!: FunctionTableSubqueryArgumentContext;
|
|
public FAT_ARROW(): TerminalNode { return this.getToken(SparkSqlParser.FAT_ARROW, 0); }
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext {
|
|
return this.getRuleContext(0, FunctionTableSubqueryArgumentContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableNamedArgumentExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionTableNamedArgumentExpression) {
|
|
listener.enterFunctionTableNamedArgumentExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionTableNamedArgumentExpression) {
|
|
listener.exitFunctionTableNamedArgumentExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionTableNamedArgumentExpression) {
|
|
return visitor.visitFunctionTableNamedArgumentExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionTableReferenceArgumentContext extends ParserRuleContext {
|
|
public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionTableSubqueryArgumentContext);
|
|
}
|
|
public functionTableNamedArgumentExpression(): FunctionTableNamedArgumentExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionTableNamedArgumentExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableReferenceArgument; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionTableReferenceArgument) {
|
|
listener.enterFunctionTableReferenceArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionTableReferenceArgument) {
|
|
listener.exitFunctionTableReferenceArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionTableReferenceArgument) {
|
|
return visitor.visitFunctionTableReferenceArgument(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionTableArgumentContext extends ParserRuleContext {
|
|
public functionTableReferenceArgument(): FunctionTableReferenceArgumentContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionTableReferenceArgumentContext);
|
|
}
|
|
public functionArgument(): FunctionArgumentContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionArgumentContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableArgument; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionTableArgument) {
|
|
listener.enterFunctionTableArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionTableArgument) {
|
|
listener.exitFunctionTableArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionTableArgument) {
|
|
return visitor.visitFunctionTableArgument(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionTableContext extends ParserRuleContext {
|
|
public functionName(): FunctionNameContext {
|
|
return this.getRuleContext(0, FunctionNameContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public tableAlias(): TableAliasContext {
|
|
return this.getRuleContext(0, TableAliasContext);
|
|
}
|
|
public functionTableArgument(): FunctionTableArgumentContext[];
|
|
public functionTableArgument(i: number): FunctionTableArgumentContext;
|
|
public functionTableArgument(i?: number): FunctionTableArgumentContext | FunctionTableArgumentContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(FunctionTableArgumentContext);
|
|
} else {
|
|
return this.getRuleContext(i, FunctionTableArgumentContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionTable; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionTable) {
|
|
listener.enterFunctionTable(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionTable) {
|
|
listener.exitFunctionTable(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionTable) {
|
|
return visitor.visitFunctionTable(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TableAliasContext extends ParserRuleContext {
|
|
public strictIdentifier(): StrictIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, StrictIdentifierContext);
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public identifierList(): IdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_tableAlias; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTableAlias) {
|
|
listener.enterTableAlias(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTableAlias) {
|
|
listener.exitTableAlias(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTableAlias) {
|
|
return visitor.visitTableAlias(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class RowFormatContext extends ParserRuleContext {
|
|
public _name!: StringLitContext;
|
|
public _props!: PropertyListContext;
|
|
public _fieldsTerminatedBy!: StringLitContext;
|
|
public _escapedBy!: StringLitContext;
|
|
public _collectionItemsTerminatedBy!: StringLitContext;
|
|
public _keysTerminatedBy!: StringLitContext;
|
|
public _linesSeparatedBy!: StringLitContext;
|
|
public _nullDefinedAs!: StringLitContext;
|
|
public KW_ROW(): TerminalNode { return this.getToken(SparkSqlParser.KW_ROW, 0); }
|
|
public KW_FORMAT(): TerminalNode { return this.getToken(SparkSqlParser.KW_FORMAT, 0); }
|
|
public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
|
|
public stringLit(): StringLitContext[];
|
|
public stringLit(i: number): StringLitContext;
|
|
public stringLit(i?: number): StringLitContext | StringLitContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLitContext);
|
|
} else {
|
|
return this.getRuleContext(i, StringLitContext);
|
|
}
|
|
}
|
|
public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
|
|
public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
|
|
public propertyList(): PropertyListContext | undefined {
|
|
return this.tryGetRuleContext(0, PropertyListContext);
|
|
}
|
|
public KW_DELIMITED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELIMITED, 0); }
|
|
public KW_FIELDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIELDS, 0); }
|
|
public KW_TERMINATED(): TerminalNode[];
|
|
public KW_TERMINATED(i: number): TerminalNode;
|
|
public KW_TERMINATED(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_TERMINATED);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_TERMINATED, i);
|
|
}
|
|
}
|
|
public KW_BY(): TerminalNode[];
|
|
public KW_BY(i: number): TerminalNode;
|
|
public KW_BY(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_BY);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_BY, i);
|
|
}
|
|
}
|
|
public KW_COLLECTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLECTION, 0); }
|
|
public KW_ITEMS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ITEMS, 0); }
|
|
public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
|
|
public KW_KEYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_KEYS, 0); }
|
|
public KW_LINES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LINES, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public KW_DEFINED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFINED, 0); }
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public KW_ESCAPED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPED, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_rowFormat; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterRowFormat) {
|
|
listener.enterRowFormat(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitRowFormat) {
|
|
listener.exitRowFormat(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitRowFormat) {
|
|
return visitor.visitRowFormat(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MultipartIdentifierListContext extends ParserRuleContext {
|
|
public multipartIdentifier(): MultipartIdentifierContext[];
|
|
public multipartIdentifier(i: number): MultipartIdentifierContext;
|
|
public multipartIdentifier(i?: number): MultipartIdentifierContext | MultipartIdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(MultipartIdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, MultipartIdentifierContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifierList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMultipartIdentifierList) {
|
|
listener.enterMultipartIdentifierList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMultipartIdentifierList) {
|
|
listener.exitMultipartIdentifierList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMultipartIdentifierList) {
|
|
return visitor.visitMultipartIdentifierList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MultipartIdentifierContext extends ParserRuleContext {
|
|
public _errorCapturingIdentifier!: ErrorCapturingIdentifierContext;
|
|
public _parts: ErrorCapturingIdentifierContext[] = [];
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
|
|
public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
|
|
public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ErrorCapturingIdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, ErrorCapturingIdentifierContext);
|
|
}
|
|
}
|
|
public DOT(): TerminalNode[];
|
|
public DOT(i: number): TerminalNode;
|
|
public DOT(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.DOT);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.DOT, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMultipartIdentifier) {
|
|
listener.enterMultipartIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMultipartIdentifier) {
|
|
listener.exitMultipartIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMultipartIdentifier) {
|
|
return visitor.visitMultipartIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MultipartIdentifierPropertyListContext extends ParserRuleContext {
|
|
public multipartIdentifierProperty(): MultipartIdentifierPropertyContext[];
|
|
public multipartIdentifierProperty(i: number): MultipartIdentifierPropertyContext;
|
|
public multipartIdentifierProperty(i?: number): MultipartIdentifierPropertyContext | MultipartIdentifierPropertyContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(MultipartIdentifierPropertyContext);
|
|
} else {
|
|
return this.getRuleContext(i, MultipartIdentifierPropertyContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifierPropertyList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMultipartIdentifierPropertyList) {
|
|
listener.enterMultipartIdentifierPropertyList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMultipartIdentifierPropertyList) {
|
|
listener.exitMultipartIdentifierPropertyList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMultipartIdentifierPropertyList) {
|
|
return visitor.visitMultipartIdentifierPropertyList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MultipartIdentifierPropertyContext extends ParserRuleContext {
|
|
public _options!: PropertyListContext;
|
|
public multipartIdentifier(): MultipartIdentifierContext {
|
|
return this.getRuleContext(0, MultipartIdentifierContext);
|
|
}
|
|
public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
|
|
public propertyList(): PropertyListContext | undefined {
|
|
return this.tryGetRuleContext(0, PropertyListContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifierProperty; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMultipartIdentifierProperty) {
|
|
listener.enterMultipartIdentifierProperty(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMultipartIdentifierProperty) {
|
|
listener.exitMultipartIdentifierProperty(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMultipartIdentifierProperty) {
|
|
return visitor.visitMultipartIdentifierProperty(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TableIdentifierContext extends ParserRuleContext {
|
|
public _db!: ErrorCapturingIdentifierContext;
|
|
public _table!: ErrorCapturingIdentifierContext;
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
|
|
public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
|
|
public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ErrorCapturingIdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, ErrorCapturingIdentifierContext);
|
|
}
|
|
}
|
|
public DOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_tableIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTableIdentifier) {
|
|
listener.enterTableIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTableIdentifier) {
|
|
listener.exitTableIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTableIdentifier) {
|
|
return visitor.visitTableIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ViewIdentifierContext extends ParserRuleContext {
|
|
public _db!: ErrorCapturingIdentifierContext;
|
|
public _view!: ErrorCapturingIdentifierContext;
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
|
|
public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
|
|
public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ErrorCapturingIdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, ErrorCapturingIdentifierContext);
|
|
}
|
|
}
|
|
public DOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_viewIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterViewIdentifier) {
|
|
listener.enterViewIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitViewIdentifier) {
|
|
listener.exitViewIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitViewIdentifier) {
|
|
return visitor.visitViewIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NamedExpressionContext extends ParserRuleContext {
|
|
public _name!: ErrorCapturingIdentifierContext;
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
public identifierList(): IdentifierListContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierListContext);
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_namedExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNamedExpression) {
|
|
listener.enterNamedExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNamedExpression) {
|
|
listener.exitNamedExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNamedExpression) {
|
|
return visitor.visitNamedExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NamedExpressionSeqContext extends ParserRuleContext {
|
|
public namedExpression(): NamedExpressionContext[];
|
|
public namedExpression(i: number): NamedExpressionContext;
|
|
public namedExpression(i?: number): NamedExpressionContext | NamedExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(NamedExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, NamedExpressionContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_namedExpressionSeq; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNamedExpressionSeq) {
|
|
listener.enterNamedExpressionSeq(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNamedExpressionSeq) {
|
|
listener.exitNamedExpressionSeq(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNamedExpressionSeq) {
|
|
return visitor.visitNamedExpressionSeq(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PartitionFieldListContext extends ParserRuleContext {
|
|
public _partitionField!: PartitionFieldContext;
|
|
public _fields: PartitionFieldContext[] = [];
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public partitionField(): PartitionFieldContext[];
|
|
public partitionField(i: number): PartitionFieldContext;
|
|
public partitionField(i?: number): PartitionFieldContext | PartitionFieldContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(PartitionFieldContext);
|
|
} else {
|
|
return this.getRuleContext(i, PartitionFieldContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_partitionFieldList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPartitionFieldList) {
|
|
listener.enterPartitionFieldList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPartitionFieldList) {
|
|
listener.exitPartitionFieldList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPartitionFieldList) {
|
|
return visitor.visitPartitionFieldList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PartitionFieldContext extends ParserRuleContext {
|
|
public transform(): TransformContext | undefined {
|
|
return this.tryGetRuleContext(0, TransformContext);
|
|
}
|
|
public colType(): ColTypeContext | undefined {
|
|
return this.tryGetRuleContext(0, ColTypeContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_partitionField; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPartitionField) {
|
|
listener.enterPartitionField(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPartitionField) {
|
|
listener.exitPartitionField(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPartitionField) {
|
|
return visitor.visitPartitionField(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TransformContext extends ParserRuleContext {
|
|
public _transformName!: IdentifierContext;
|
|
public qualifiedName(): QualifiedNameContext | undefined {
|
|
return this.tryGetRuleContext(0, QualifiedNameContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public transformArgument(): TransformArgumentContext[];
|
|
public transformArgument(i: number): TransformArgumentContext;
|
|
public transformArgument(i?: number): TransformArgumentContext | TransformArgumentContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(TransformArgumentContext);
|
|
} else {
|
|
return this.getRuleContext(i, TransformArgumentContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_transform; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTransform) {
|
|
listener.enterTransform(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTransform) {
|
|
listener.exitTransform(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTransform) {
|
|
return visitor.visitTransform(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TransformArgumentContext extends ParserRuleContext {
|
|
public qualifiedName(): QualifiedNameContext | undefined {
|
|
return this.tryGetRuleContext(0, QualifiedNameContext);
|
|
}
|
|
public constant(): ConstantContext | undefined {
|
|
return this.tryGetRuleContext(0, ConstantContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_transformArgument; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterTransformArgument) {
|
|
listener.enterTransformArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitTransformArgument) {
|
|
listener.exitTransformArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitTransformArgument) {
|
|
return visitor.visitTransformArgument(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ExpressionContext extends ParserRuleContext {
|
|
public booleanExpression(): BooleanExpressionContext {
|
|
return this.getRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_expression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterExpression) {
|
|
listener.enterExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitExpression) {
|
|
listener.exitExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitExpression) {
|
|
return visitor.visitExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NamedArgumentExpressionContext extends ParserRuleContext {
|
|
public _key!: IdentifierContext;
|
|
public _value!: ExpressionContext;
|
|
public FAT_ARROW(): TerminalNode { return this.getToken(SparkSqlParser.FAT_ARROW, 0); }
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_namedArgumentExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNamedArgumentExpression) {
|
|
listener.enterNamedArgumentExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNamedArgumentExpression) {
|
|
listener.exitNamedArgumentExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNamedArgumentExpression) {
|
|
return visitor.visitNamedArgumentExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionArgumentContext extends ParserRuleContext {
|
|
public expression(): ExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionContext);
|
|
}
|
|
public namedArgumentExpression(): NamedArgumentExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, NamedArgumentExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionArgument; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionArgument) {
|
|
listener.enterFunctionArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionArgument) {
|
|
listener.exitFunctionArgument(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionArgument) {
|
|
return visitor.visitFunctionArgument(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ExpressionSeqContext extends ParserRuleContext {
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_expressionSeq; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterExpressionSeq) {
|
|
listener.enterExpressionSeq(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitExpressionSeq) {
|
|
listener.exitExpressionSeq(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitExpressionSeq) {
|
|
return visitor.visitExpressionSeq(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class BooleanExpressionContext extends ParserRuleContext {
|
|
public _left!: BooleanExpressionContext;
|
|
public _operator!: Token;
|
|
public _right!: BooleanExpressionContext;
|
|
public booleanExpression(): BooleanExpressionContext[];
|
|
public booleanExpression(i: number): BooleanExpressionContext;
|
|
public booleanExpression(i?: number): BooleanExpressionContext | BooleanExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(BooleanExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, BooleanExpressionContext);
|
|
}
|
|
}
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NOT, 0); }
|
|
public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXISTS, 0); }
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public valueExpression(): ValueExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ValueExpressionContext);
|
|
}
|
|
public predicate(): PredicateContext | undefined {
|
|
return this.tryGetRuleContext(0, PredicateContext);
|
|
}
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_booleanExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterBooleanExpression) {
|
|
listener.enterBooleanExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitBooleanExpression) {
|
|
listener.exitBooleanExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitBooleanExpression) {
|
|
return visitor.visitBooleanExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PredicateContext extends ParserRuleContext {
|
|
public _kind!: Token;
|
|
public _lower!: ValueExpressionContext;
|
|
public _upper!: ValueExpressionContext;
|
|
public _pattern!: ValueExpressionContext;
|
|
public _quantifier!: Token;
|
|
public _escapeChar!: StringLitContext;
|
|
public _right!: ValueExpressionContext;
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
|
|
public valueExpression(): ValueExpressionContext[];
|
|
public valueExpression(i: number): ValueExpressionContext;
|
|
public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ValueExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ValueExpressionContext);
|
|
}
|
|
}
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
public KW_RLIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RLIKE, 0); }
|
|
public KW_REGEXP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REGEXP, 0); }
|
|
public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
|
|
public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ILIKE, 0); }
|
|
public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY, 0); }
|
|
public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOME, 0); }
|
|
public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
|
|
public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPE, 0); }
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public KW_IS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IS, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
|
|
public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FALSE, 0); }
|
|
public KW_UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNKNOWN, 0); }
|
|
public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
|
|
public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTINCT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_predicate; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPredicate) {
|
|
listener.enterPredicate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPredicate) {
|
|
listener.exitPredicate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPredicate) {
|
|
return visitor.visitPredicate(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ValueExpressionContext extends ParserRuleContext {
|
|
public _left!: ValueExpressionContext;
|
|
public _operator!: Token;
|
|
public _right!: ValueExpressionContext;
|
|
public primaryExpression(): PrimaryExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, PrimaryExpressionContext);
|
|
}
|
|
public valueExpression(): ValueExpressionContext[];
|
|
public valueExpression(i: number): ValueExpressionContext;
|
|
public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ValueExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ValueExpressionContext);
|
|
}
|
|
}
|
|
public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
|
|
public PLUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PLUS, 0); }
|
|
public TILDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.TILDE, 0); }
|
|
public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
|
|
public SLASH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SLASH, 0); }
|
|
public PERCENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PERCENT, 0); }
|
|
public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
|
|
public CONCAT_PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.CONCAT_PIPE, 0); }
|
|
public AMPERSAND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.AMPERSAND, 0); }
|
|
public HAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.HAT, 0); }
|
|
public PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PIPE, 0); }
|
|
public comparisonOperator(): ComparisonOperatorContext | undefined {
|
|
return this.tryGetRuleContext(0, ComparisonOperatorContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_valueExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterValueExpression) {
|
|
listener.enterValueExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitValueExpression) {
|
|
listener.exitValueExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitValueExpression) {
|
|
return visitor.visitValueExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DatetimeUnitContext extends ParserRuleContext {
|
|
public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
|
|
public KW_QUARTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUARTER, 0); }
|
|
public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
|
|
public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
|
|
public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
|
|
public KW_DAYOFYEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYOFYEAR, 0); }
|
|
public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
|
|
public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
|
|
public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
|
|
public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
|
|
public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_datetimeUnit; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDatetimeUnit) {
|
|
listener.enterDatetimeUnit(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDatetimeUnit) {
|
|
listener.exitDatetimeUnit(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDatetimeUnit) {
|
|
return visitor.visitDatetimeUnit(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PrimaryExpressionContext extends ParserRuleContext {
|
|
public _value!: PrimaryExpressionContext;
|
|
public _base!: PrimaryExpressionContext;
|
|
public _name!: Token;
|
|
public _unit!: DatetimeUnitContext;
|
|
public _invalidUnit!: StringLitContext;
|
|
public _unitsAmount!: ValueExpressionContext;
|
|
public _timestamp!: ValueExpressionContext;
|
|
public _startTimestamp!: ValueExpressionContext;
|
|
public _endTimestamp!: ValueExpressionContext;
|
|
public _elseExpression!: ExpressionContext;
|
|
public _substr!: ValueExpressionContext;
|
|
public _str!: ValueExpressionContext;
|
|
public _where!: BooleanExpressionContext;
|
|
public _nullsOption!: Token;
|
|
public _field!: IdentifierContext;
|
|
public _source!: ValueExpressionContext;
|
|
public _pos!: ValueExpressionContext;
|
|
public _len!: ValueExpressionContext;
|
|
public _trimOption!: Token;
|
|
public _trimStr!: ValueExpressionContext;
|
|
public _srcStr!: ValueExpressionContext;
|
|
public _input!: ValueExpressionContext;
|
|
public _replace!: ValueExpressionContext;
|
|
public _position!: ValueExpressionContext;
|
|
public _length!: ValueExpressionContext;
|
|
public _percentage!: ValueExpressionContext;
|
|
public _index!: ValueExpressionContext;
|
|
public _fieldName!: IdentifierContext;
|
|
public KW_CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_DATE, 0); }
|
|
public KW_CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_TIMESTAMP, 0); }
|
|
public KW_CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_USER, 0); }
|
|
public KW_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USER, 0); }
|
|
public KW_SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SESSION_USER, 0); }
|
|
public LEFT_PAREN(): TerminalNode[];
|
|
public LEFT_PAREN(i: number): TerminalNode;
|
|
public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.LEFT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.LEFT_PAREN, i);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode[];
|
|
public RIGHT_PAREN(i: number): TerminalNode;
|
|
public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.RIGHT_PAREN);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
|
|
}
|
|
}
|
|
public valueExpression(): ValueExpressionContext[];
|
|
public valueExpression(i: number): ValueExpressionContext;
|
|
public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ValueExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ValueExpressionContext);
|
|
}
|
|
}
|
|
public KW_TIMESTAMPADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPADD, 0); }
|
|
public KW_DATEADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEADD, 0); }
|
|
public KW_DATE_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_ADD, 0); }
|
|
public datetimeUnit(): DatetimeUnitContext | undefined {
|
|
return this.tryGetRuleContext(0, DatetimeUnitContext);
|
|
}
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public KW_TIMESTAMPDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPDIFF, 0); }
|
|
public KW_DATEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEDIFF, 0); }
|
|
public KW_DATE_DIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_DIFF, 0); }
|
|
public KW_TIMEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMEDIFF, 0); }
|
|
public KW_CASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASE, 0); }
|
|
public KW_END(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_END, 0); }
|
|
public whenClause(): WhenClauseContext[];
|
|
public whenClause(i: number): WhenClauseContext;
|
|
public whenClause(i?: number): WhenClauseContext | WhenClauseContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(WhenClauseContext);
|
|
} else {
|
|
return this.getRuleContext(i, WhenClauseContext);
|
|
}
|
|
}
|
|
public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ELSE, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public dataType(): DataTypeContext | undefined {
|
|
return this.tryGetRuleContext(0, DataTypeContext);
|
|
}
|
|
public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CAST, 0); }
|
|
public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRY_CAST, 0); }
|
|
public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
|
|
public namedExpression(): NamedExpressionContext[];
|
|
public namedExpression(i: number): NamedExpressionContext;
|
|
public namedExpression(i?: number): NamedExpressionContext | NamedExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(NamedExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, NamedExpressionContext);
|
|
}
|
|
}
|
|
public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
|
|
public KW_IGNORE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IGNORE, 0); }
|
|
public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
|
|
public KW_ANY_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY_VALUE, 0); }
|
|
public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
|
|
public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_POSITION, 0); }
|
|
public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
|
|
public constant(): ConstantContext | undefined {
|
|
return this.tryGetRuleContext(0, ConstantContext);
|
|
}
|
|
public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
|
|
public qualifiedName(): QualifiedNameContext | undefined {
|
|
return this.tryGetRuleContext(0, QualifiedNameContext);
|
|
}
|
|
public DOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOT, 0); }
|
|
public query(): QueryContext | undefined {
|
|
return this.tryGetRuleContext(0, QueryContext);
|
|
}
|
|
public KW_IDENTIFIER_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 0); }
|
|
public functionName(): FunctionNameContext | undefined {
|
|
return this.tryGetRuleContext(0, FunctionNameContext);
|
|
}
|
|
public functionArgument(): FunctionArgumentContext[];
|
|
public functionArgument(i: number): FunctionArgumentContext;
|
|
public functionArgument(i?: number): FunctionArgumentContext | FunctionArgumentContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(FunctionArgumentContext);
|
|
} else {
|
|
return this.getRuleContext(i, FunctionArgumentContext);
|
|
}
|
|
}
|
|
public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILTER, 0); }
|
|
public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WHERE, 0); }
|
|
public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVER, 0); }
|
|
public windowSpec(): WindowSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, WindowSpecContext);
|
|
}
|
|
public booleanExpression(): BooleanExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanExpressionContext);
|
|
}
|
|
public KW_RESPECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESPECT, 0); }
|
|
public setQuantifier(): SetQuantifierContext | undefined {
|
|
return this.tryGetRuleContext(0, SetQuantifierContext);
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
public ARROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ARROW, 0); }
|
|
public LEFT_BRACKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_BRACKET, 0); }
|
|
public RIGHT_BRACKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_BRACKET, 0); }
|
|
public primaryExpression(): PrimaryExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, PrimaryExpressionContext);
|
|
}
|
|
public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTRACT, 0); }
|
|
public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
|
|
public KW_SUBSTR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTR, 0); }
|
|
public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTRING, 0); }
|
|
public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
|
|
public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRIM, 0); }
|
|
public KW_BOTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOTH, 0); }
|
|
public KW_LEADING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEADING, 0); }
|
|
public KW_TRAILING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRAILING, 0); }
|
|
public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAY, 0); }
|
|
public KW_PLACING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PLACING, 0); }
|
|
public KW_WITHIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITHIN, 0); }
|
|
public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUP, 0); }
|
|
public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
|
|
public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
|
|
public sortItem(): SortItemContext | undefined {
|
|
return this.tryGetRuleContext(0, SortItemContext);
|
|
}
|
|
public KW_PERCENTILE_CONT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_CONT, 0); }
|
|
public KW_PERCENTILE_DISC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_DISC, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_primaryExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPrimaryExpression) {
|
|
listener.enterPrimaryExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPrimaryExpression) {
|
|
listener.exitPrimaryExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPrimaryExpression) {
|
|
return visitor.visitPrimaryExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class LiteralTypeContext extends ParserRuleContext {
|
|
public _unsupportedType!: IdentifierContext;
|
|
public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
|
|
public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
|
|
public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
|
|
public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
|
|
public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
|
|
public KW_BINARY_HEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY_HEX, 0); }
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_literalType; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterLiteralType) {
|
|
listener.enterLiteralType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitLiteralType) {
|
|
listener.exitLiteralType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitLiteralType) {
|
|
return visitor.visitLiteralType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ConstantContext extends ParserRuleContext {
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public QUESTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.QUESTION, 0); }
|
|
public COLON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.COLON, 0); }
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
public interval(): IntervalContext | undefined {
|
|
return this.tryGetRuleContext(0, IntervalContext);
|
|
}
|
|
public literalType(): LiteralTypeContext | undefined {
|
|
return this.tryGetRuleContext(0, LiteralTypeContext);
|
|
}
|
|
public stringLit(): StringLitContext[];
|
|
public stringLit(i: number): StringLitContext;
|
|
public stringLit(i?: number): StringLitContext | StringLitContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(StringLitContext);
|
|
} else {
|
|
return this.getRuleContext(i, StringLitContext);
|
|
}
|
|
}
|
|
public number(): NumberContext | undefined {
|
|
return this.tryGetRuleContext(0, NumberContext);
|
|
}
|
|
public booleanValue(): BooleanValueContext | undefined {
|
|
return this.tryGetRuleContext(0, BooleanValueContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_constant; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterConstant) {
|
|
listener.enterConstant(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitConstant) {
|
|
listener.exitConstant(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitConstant) {
|
|
return visitor.visitConstant(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ComparisonOperatorContext extends ParserRuleContext {
|
|
public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
|
|
public NEQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NEQ, 0); }
|
|
public NEQJ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NEQJ, 0); }
|
|
public LT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LT, 0); }
|
|
public LTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LTE, 0); }
|
|
public GT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.GT, 0); }
|
|
public GTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.GTE, 0); }
|
|
public NSEQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NSEQ, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_comparisonOperator; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterComparisonOperator) {
|
|
listener.enterComparisonOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitComparisonOperator) {
|
|
listener.exitComparisonOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitComparisonOperator) {
|
|
return visitor.visitComparisonOperator(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ArithmeticOperatorContext extends ParserRuleContext {
|
|
public PLUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PLUS, 0); }
|
|
public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
|
|
public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
|
|
public SLASH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SLASH, 0); }
|
|
public PERCENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PERCENT, 0); }
|
|
public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
|
|
public TILDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.TILDE, 0); }
|
|
public AMPERSAND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.AMPERSAND, 0); }
|
|
public PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PIPE, 0); }
|
|
public CONCAT_PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.CONCAT_PIPE, 0); }
|
|
public HAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.HAT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_arithmeticOperator; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterArithmeticOperator) {
|
|
listener.enterArithmeticOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitArithmeticOperator) {
|
|
listener.exitArithmeticOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitArithmeticOperator) {
|
|
return visitor.visitArithmeticOperator(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class PredicateOperatorContext extends ParserRuleContext {
|
|
public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_predicateOperator; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterPredicateOperator) {
|
|
listener.enterPredicateOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitPredicateOperator) {
|
|
listener.exitPredicateOperator(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitPredicateOperator) {
|
|
return visitor.visitPredicateOperator(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class BooleanValueContext extends ParserRuleContext {
|
|
public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
|
|
public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FALSE, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_booleanValue; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterBooleanValue) {
|
|
listener.enterBooleanValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitBooleanValue) {
|
|
listener.exitBooleanValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitBooleanValue) {
|
|
return visitor.visitBooleanValue(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IntervalContext extends ParserRuleContext {
|
|
public KW_INTERVAL(): TerminalNode { return this.getToken(SparkSqlParser.KW_INTERVAL, 0); }
|
|
public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext | undefined {
|
|
return this.tryGetRuleContext(0, ErrorCapturingMultiUnitsIntervalContext);
|
|
}
|
|
public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext | undefined {
|
|
return this.tryGetRuleContext(0, ErrorCapturingUnitToUnitIntervalContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_interval; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterInterval) {
|
|
listener.enterInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitInterval) {
|
|
listener.exitInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitInterval) {
|
|
return visitor.visitInterval(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ErrorCapturingMultiUnitsIntervalContext extends ParserRuleContext {
|
|
public _body!: MultiUnitsIntervalContext;
|
|
public multiUnitsInterval(): MultiUnitsIntervalContext {
|
|
return this.getRuleContext(0, MultiUnitsIntervalContext);
|
|
}
|
|
public unitToUnitInterval(): UnitToUnitIntervalContext | undefined {
|
|
return this.tryGetRuleContext(0, UnitToUnitIntervalContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingMultiUnitsInterval; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterErrorCapturingMultiUnitsInterval) {
|
|
listener.enterErrorCapturingMultiUnitsInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitErrorCapturingMultiUnitsInterval) {
|
|
listener.exitErrorCapturingMultiUnitsInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitErrorCapturingMultiUnitsInterval) {
|
|
return visitor.visitErrorCapturingMultiUnitsInterval(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class MultiUnitsIntervalContext extends ParserRuleContext {
|
|
public _unitInMultiUnits!: UnitInMultiUnitsContext;
|
|
public _unit: UnitInMultiUnitsContext[] = [];
|
|
public intervalValue(): IntervalValueContext[];
|
|
public intervalValue(i: number): IntervalValueContext;
|
|
public intervalValue(i?: number): IntervalValueContext | IntervalValueContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IntervalValueContext);
|
|
} else {
|
|
return this.getRuleContext(i, IntervalValueContext);
|
|
}
|
|
}
|
|
public unitInMultiUnits(): UnitInMultiUnitsContext[];
|
|
public unitInMultiUnits(i: number): UnitInMultiUnitsContext;
|
|
public unitInMultiUnits(i?: number): UnitInMultiUnitsContext | UnitInMultiUnitsContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(UnitInMultiUnitsContext);
|
|
} else {
|
|
return this.getRuleContext(i, UnitInMultiUnitsContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_multiUnitsInterval; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterMultiUnitsInterval) {
|
|
listener.enterMultiUnitsInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitMultiUnitsInterval) {
|
|
listener.exitMultiUnitsInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitMultiUnitsInterval) {
|
|
return visitor.visitMultiUnitsInterval(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ErrorCapturingUnitToUnitIntervalContext extends ParserRuleContext {
|
|
public _body!: UnitToUnitIntervalContext;
|
|
public _error1!: MultiUnitsIntervalContext;
|
|
public _error2!: UnitToUnitIntervalContext;
|
|
public unitToUnitInterval(): UnitToUnitIntervalContext[];
|
|
public unitToUnitInterval(i: number): UnitToUnitIntervalContext;
|
|
public unitToUnitInterval(i?: number): UnitToUnitIntervalContext | UnitToUnitIntervalContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(UnitToUnitIntervalContext);
|
|
} else {
|
|
return this.getRuleContext(i, UnitToUnitIntervalContext);
|
|
}
|
|
}
|
|
public multiUnitsInterval(): MultiUnitsIntervalContext | undefined {
|
|
return this.tryGetRuleContext(0, MultiUnitsIntervalContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingUnitToUnitInterval; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterErrorCapturingUnitToUnitInterval) {
|
|
listener.enterErrorCapturingUnitToUnitInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitErrorCapturingUnitToUnitInterval) {
|
|
listener.exitErrorCapturingUnitToUnitInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitErrorCapturingUnitToUnitInterval) {
|
|
return visitor.visitErrorCapturingUnitToUnitInterval(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnitToUnitIntervalContext extends ParserRuleContext {
|
|
public _value!: IntervalValueContext;
|
|
public unitInUnitToUnit(): UnitInUnitToUnitContext[];
|
|
public unitInUnitToUnit(i: number): UnitInUnitToUnitContext;
|
|
public unitInUnitToUnit(i?: number): UnitInUnitToUnitContext | UnitInUnitToUnitContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(UnitInUnitToUnitContext);
|
|
} else {
|
|
return this.getRuleContext(i, UnitInUnitToUnitContext);
|
|
}
|
|
}
|
|
public KW_TO(): TerminalNode { return this.getToken(SparkSqlParser.KW_TO, 0); }
|
|
public intervalValue(): IntervalValueContext {
|
|
return this.getRuleContext(0, IntervalValueContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unitToUnitInterval; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnitToUnitInterval) {
|
|
listener.enterUnitToUnitInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnitToUnitInterval) {
|
|
listener.exitUnitToUnitInterval(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnitToUnitInterval) {
|
|
return visitor.visitUnitToUnitInterval(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IntervalValueContext extends ParserRuleContext {
|
|
public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
|
|
public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public PLUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PLUS, 0); }
|
|
public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_intervalValue; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIntervalValue) {
|
|
listener.enterIntervalValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIntervalValue) {
|
|
listener.exitIntervalValue(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIntervalValue) {
|
|
return visitor.visitIntervalValue(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnitInMultiUnitsContext extends ParserRuleContext {
|
|
public KW_NANOSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECOND, 0); }
|
|
public KW_NANOSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECONDS, 0); }
|
|
public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
|
|
public KW_MICROSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECONDS, 0); }
|
|
public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
|
|
public KW_MILLISECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECONDS, 0); }
|
|
public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
|
|
public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECONDS, 0); }
|
|
public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
|
|
public KW_MINUTES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTES, 0); }
|
|
public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
|
|
public KW_HOURS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOURS, 0); }
|
|
public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
|
|
public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYS, 0); }
|
|
public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
|
|
public KW_WEEKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEKS, 0); }
|
|
public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
|
|
public KW_MONTHS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTHS, 0); }
|
|
public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
|
|
public KW_YEARS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEARS, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unitInMultiUnits; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnitInMultiUnits) {
|
|
listener.enterUnitInMultiUnits(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnitInMultiUnits) {
|
|
listener.exitUnitInMultiUnits(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnitInMultiUnits) {
|
|
return visitor.visitUnitInMultiUnits(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class UnitInUnitToUnitContext extends ParserRuleContext {
|
|
public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
|
|
public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
|
|
public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
|
|
public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
|
|
public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
|
|
public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_unitInUnitToUnit; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterUnitInUnitToUnit) {
|
|
listener.enterUnitInUnitToUnit(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitUnitInUnitToUnit) {
|
|
listener.exitUnitInUnitToUnit(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitUnitInUnitToUnit) {
|
|
return visitor.visitUnitInUnitToUnit(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ColPositionContext extends ParserRuleContext {
|
|
public _position!: Token;
|
|
public _afterCol!: ErrorCapturingIdentifierContext;
|
|
public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
|
|
public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AFTER, 0); }
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_colPosition; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterColPosition) {
|
|
listener.enterColPosition(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitColPosition) {
|
|
listener.exitColPosition(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitColPosition) {
|
|
return visitor.visitColPosition(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class TypeContext extends ParserRuleContext {
|
|
public _unsupportedType!: IdentifierContext;
|
|
public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOOLEAN, 0); }
|
|
public KW_TINYINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TINYINT, 0); }
|
|
public KW_BYTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BYTE, 0); }
|
|
public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SMALLINT, 0); }
|
|
public KW_SHORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHORT, 0); }
|
|
public KW_INT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INT, 0); }
|
|
public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTEGER, 0); }
|
|
public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BIGINT, 0); }
|
|
public KW_LONG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LONG, 0); }
|
|
public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FLOAT, 0); }
|
|
public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REAL, 0); }
|
|
public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DOUBLE, 0); }
|
|
public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
|
|
public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
|
|
public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
|
|
public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
|
|
public KW_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRING, 0); }
|
|
public KW_CHARACTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHARACTER, 0); }
|
|
public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHAR, 0); }
|
|
public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARCHAR, 0); }
|
|
public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY, 0); }
|
|
public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECIMAL, 0); }
|
|
public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEC, 0); }
|
|
public KW_NUMERIC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NUMERIC, 0); }
|
|
public KW_VOID(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VOID, 0); }
|
|
public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
|
|
public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
|
|
public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
|
|
public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
|
|
public identifier(): IdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, IdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_type; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterType) {
|
|
listener.enterType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitType) {
|
|
listener.exitType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitType) {
|
|
return visitor.visitType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DataTypeContext extends ParserRuleContext {
|
|
public _complex!: Token;
|
|
public LT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LT, 0); }
|
|
public dataType(): DataTypeContext[];
|
|
public dataType(i: number): DataTypeContext;
|
|
public dataType(i?: number): DataTypeContext | DataTypeContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(DataTypeContext);
|
|
} else {
|
|
return this.getRuleContext(i, DataTypeContext);
|
|
}
|
|
}
|
|
public GT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.GT, 0); }
|
|
public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
|
|
public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
|
|
public NEQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NEQ, 0); }
|
|
public complexColTypeList(): ComplexColTypeListContext | undefined {
|
|
return this.tryGetRuleContext(0, ComplexColTypeListContext);
|
|
}
|
|
public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
|
|
public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
|
|
public KW_MONTH(): TerminalNode[];
|
|
public KW_MONTH(i: number): TerminalNode;
|
|
public KW_MONTH(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_MONTH);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_MONTH, i);
|
|
}
|
|
}
|
|
public KW_TO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TO, 0); }
|
|
public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
|
|
public KW_HOUR(): TerminalNode[];
|
|
public KW_HOUR(i: number): TerminalNode;
|
|
public KW_HOUR(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_HOUR);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_HOUR, i);
|
|
}
|
|
}
|
|
public KW_MINUTE(): TerminalNode[];
|
|
public KW_MINUTE(i: number): TerminalNode;
|
|
public KW_MINUTE(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_MINUTE);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_MINUTE, i);
|
|
}
|
|
}
|
|
public KW_SECOND(): TerminalNode[];
|
|
public KW_SECOND(i: number): TerminalNode;
|
|
public KW_SECOND(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_SECOND);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_SECOND, i);
|
|
}
|
|
}
|
|
public type(): TypeContext | undefined {
|
|
return this.tryGetRuleContext(0, TypeContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public INTEGER_VALUE(): TerminalNode[];
|
|
public INTEGER_VALUE(i: number): TerminalNode;
|
|
public INTEGER_VALUE(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.INTEGER_VALUE);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.INTEGER_VALUE, i);
|
|
}
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_dataType; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDataType) {
|
|
listener.enterDataType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDataType) {
|
|
listener.exitDataType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDataType) {
|
|
return visitor.visitDataType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QualifiedColTypeWithPositionListContext extends ParserRuleContext {
|
|
public qualifiedColTypeWithPosition(): QualifiedColTypeWithPositionContext[];
|
|
public qualifiedColTypeWithPosition(i: number): QualifiedColTypeWithPositionContext;
|
|
public qualifiedColTypeWithPosition(i?: number): QualifiedColTypeWithPositionContext | QualifiedColTypeWithPositionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(QualifiedColTypeWithPositionContext);
|
|
} else {
|
|
return this.getRuleContext(i, QualifiedColTypeWithPositionContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedColTypeWithPositionList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQualifiedColTypeWithPositionList) {
|
|
listener.enterQualifiedColTypeWithPositionList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQualifiedColTypeWithPositionList) {
|
|
listener.exitQualifiedColTypeWithPositionList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQualifiedColTypeWithPositionList) {
|
|
return visitor.visitQualifiedColTypeWithPositionList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QualifiedColTypeWithPositionContext extends ParserRuleContext {
|
|
public _name!: MultipartIdentifierContext;
|
|
public dataType(): DataTypeContext {
|
|
return this.getRuleContext(0, DataTypeContext);
|
|
}
|
|
public multipartIdentifier(): MultipartIdentifierContext {
|
|
return this.getRuleContext(0, MultipartIdentifierContext);
|
|
}
|
|
public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext[];
|
|
public colDefinitionDescriptorWithPosition(i: number): ColDefinitionDescriptorWithPositionContext;
|
|
public colDefinitionDescriptorWithPosition(i?: number): ColDefinitionDescriptorWithPositionContext | ColDefinitionDescriptorWithPositionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ColDefinitionDescriptorWithPositionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ColDefinitionDescriptorWithPositionContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedColTypeWithPosition; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQualifiedColTypeWithPosition) {
|
|
listener.enterQualifiedColTypeWithPosition(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQualifiedColTypeWithPosition) {
|
|
listener.exitQualifiedColTypeWithPosition(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQualifiedColTypeWithPosition) {
|
|
return visitor.visitQualifiedColTypeWithPosition(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ColDefinitionDescriptorWithPositionContext extends ParserRuleContext {
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public defaultExpression(): DefaultExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, DefaultExpressionContext);
|
|
}
|
|
public commentSpec(): CommentSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, CommentSpecContext);
|
|
}
|
|
public colPosition(): ColPositionContext | undefined {
|
|
return this.tryGetRuleContext(0, ColPositionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_colDefinitionDescriptorWithPosition; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterColDefinitionDescriptorWithPosition) {
|
|
listener.enterColDefinitionDescriptorWithPosition(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitColDefinitionDescriptorWithPosition) {
|
|
listener.exitColDefinitionDescriptorWithPosition(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitColDefinitionDescriptorWithPosition) {
|
|
return visitor.visitColDefinitionDescriptorWithPosition(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class DefaultExpressionContext extends ParserRuleContext {
|
|
public KW_DEFAULT(): TerminalNode { return this.getToken(SparkSqlParser.KW_DEFAULT, 0); }
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_defaultExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterDefaultExpression) {
|
|
listener.enterDefaultExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitDefaultExpression) {
|
|
listener.exitDefaultExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitDefaultExpression) {
|
|
return visitor.visitDefaultExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class VariableDefaultExpressionContext extends ParserRuleContext {
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
|
|
public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_variableDefaultExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterVariableDefaultExpression) {
|
|
listener.enterVariableDefaultExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitVariableDefaultExpression) {
|
|
listener.exitVariableDefaultExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitVariableDefaultExpression) {
|
|
return visitor.visitVariableDefaultExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ColTypeListContext extends ParserRuleContext {
|
|
public colType(): ColTypeContext[];
|
|
public colType(i: number): ColTypeContext;
|
|
public colType(i?: number): ColTypeContext | ColTypeContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ColTypeContext);
|
|
} else {
|
|
return this.getRuleContext(i, ColTypeContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_colTypeList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterColTypeList) {
|
|
listener.enterColTypeList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitColTypeList) {
|
|
listener.exitColTypeList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitColTypeList) {
|
|
return visitor.visitColTypeList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ColTypeContext extends ParserRuleContext {
|
|
public _colName!: ErrorCapturingIdentifierContext;
|
|
public dataType(): DataTypeContext {
|
|
return this.getRuleContext(0, DataTypeContext);
|
|
}
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
|
|
return this.getRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public commentSpec(): CommentSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, CommentSpecContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_colType; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterColType) {
|
|
listener.enterColType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitColType) {
|
|
listener.exitColType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitColType) {
|
|
return visitor.visitColType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CreateOrReplaceTableColTypeListContext extends ParserRuleContext {
|
|
public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext[];
|
|
public createOrReplaceTableColType(i: number): CreateOrReplaceTableColTypeContext;
|
|
public createOrReplaceTableColType(i?: number): CreateOrReplaceTableColTypeContext | CreateOrReplaceTableColTypeContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(CreateOrReplaceTableColTypeContext);
|
|
} else {
|
|
return this.getRuleContext(i, CreateOrReplaceTableColTypeContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_createOrReplaceTableColTypeList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterCreateOrReplaceTableColTypeList) {
|
|
listener.enterCreateOrReplaceTableColTypeList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitCreateOrReplaceTableColTypeList) {
|
|
listener.exitCreateOrReplaceTableColTypeList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitCreateOrReplaceTableColTypeList) {
|
|
return visitor.visitCreateOrReplaceTableColTypeList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CreateOrReplaceTableColTypeContext extends ParserRuleContext {
|
|
public _colName!: ErrorCapturingIdentifierContext;
|
|
public dataType(): DataTypeContext {
|
|
return this.getRuleContext(0, DataTypeContext);
|
|
}
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
|
|
return this.getRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
public colDefinitionOption(): ColDefinitionOptionContext[];
|
|
public colDefinitionOption(i: number): ColDefinitionOptionContext;
|
|
public colDefinitionOption(i?: number): ColDefinitionOptionContext | ColDefinitionOptionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ColDefinitionOptionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ColDefinitionOptionContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_createOrReplaceTableColType; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterCreateOrReplaceTableColType) {
|
|
listener.enterCreateOrReplaceTableColType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitCreateOrReplaceTableColType) {
|
|
listener.exitCreateOrReplaceTableColType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitCreateOrReplaceTableColType) {
|
|
return visitor.visitCreateOrReplaceTableColType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ColDefinitionOptionContext extends ParserRuleContext {
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public defaultExpression(): DefaultExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, DefaultExpressionContext);
|
|
}
|
|
public generationExpression(): GenerationExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, GenerationExpressionContext);
|
|
}
|
|
public commentSpec(): CommentSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, CommentSpecContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_colDefinitionOption; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterColDefinitionOption) {
|
|
listener.enterColDefinitionOption(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitColDefinitionOption) {
|
|
listener.exitColDefinitionOption(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitColDefinitionOption) {
|
|
return visitor.visitColDefinitionOption(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class GenerationExpressionContext extends ParserRuleContext {
|
|
public KW_GENERATED(): TerminalNode { return this.getToken(SparkSqlParser.KW_GENERATED, 0); }
|
|
public KW_ALWAYS(): TerminalNode { return this.getToken(SparkSqlParser.KW_ALWAYS, 0); }
|
|
public KW_AS(): TerminalNode { return this.getToken(SparkSqlParser.KW_AS, 0); }
|
|
public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public expression(): ExpressionContext {
|
|
return this.getRuleContext(0, ExpressionContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_generationExpression; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterGenerationExpression) {
|
|
listener.enterGenerationExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitGenerationExpression) {
|
|
listener.exitGenerationExpression(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitGenerationExpression) {
|
|
return visitor.visitGenerationExpression(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ComplexColTypeListContext extends ParserRuleContext {
|
|
public complexColType(): ComplexColTypeContext[];
|
|
public complexColType(i: number): ComplexColTypeContext;
|
|
public complexColType(i?: number): ComplexColTypeContext | ComplexColTypeContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ComplexColTypeContext);
|
|
} else {
|
|
return this.getRuleContext(i, ComplexColTypeContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_complexColTypeList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterComplexColTypeList) {
|
|
listener.enterComplexColTypeList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitComplexColTypeList) {
|
|
listener.exitComplexColTypeList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitComplexColTypeList) {
|
|
return visitor.visitComplexColTypeList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ComplexColTypeContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public dataType(): DataTypeContext {
|
|
return this.getRuleContext(0, DataTypeContext);
|
|
}
|
|
public COLON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.COLON, 0); }
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public commentSpec(): CommentSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, CommentSpecContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_complexColType; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterComplexColType) {
|
|
listener.enterComplexColType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitComplexColType) {
|
|
listener.exitComplexColType(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitComplexColType) {
|
|
return visitor.visitComplexColType(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class WhenClauseContext extends ParserRuleContext {
|
|
public _condition!: ExpressionContext;
|
|
public _result!: ExpressionContext;
|
|
public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
|
|
public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_whenClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterWhenClause) {
|
|
listener.enterWhenClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitWhenClause) {
|
|
listener.exitWhenClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitWhenClause) {
|
|
return visitor.visitWhenClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class WindowClauseContext extends ParserRuleContext {
|
|
public KW_WINDOW(): TerminalNode { return this.getToken(SparkSqlParser.KW_WINDOW, 0); }
|
|
public namedWindow(): NamedWindowContext[];
|
|
public namedWindow(i: number): NamedWindowContext;
|
|
public namedWindow(i?: number): NamedWindowContext | NamedWindowContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(NamedWindowContext);
|
|
} else {
|
|
return this.getRuleContext(i, NamedWindowContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_windowClause; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterWindowClause) {
|
|
listener.enterWindowClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitWindowClause) {
|
|
listener.exitWindowClause(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitWindowClause) {
|
|
return visitor.visitWindowClause(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NamedWindowContext extends ParserRuleContext {
|
|
public _name!: ErrorCapturingIdentifierContext;
|
|
public KW_AS(): TerminalNode { return this.getToken(SparkSqlParser.KW_AS, 0); }
|
|
public windowSpec(): WindowSpecContext {
|
|
return this.getRuleContext(0, WindowSpecContext);
|
|
}
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
|
|
return this.getRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_namedWindow; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNamedWindow) {
|
|
listener.enterNamedWindow(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNamedWindow) {
|
|
listener.exitNamedWindow(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNamedWindow) {
|
|
return visitor.visitNamedWindow(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class WindowSpecContext extends ParserRuleContext {
|
|
public _name!: ErrorCapturingIdentifierContext;
|
|
public _expression!: ExpressionContext;
|
|
public _partition: ExpressionContext[] = [];
|
|
public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, ErrorCapturingIdentifierContext);
|
|
}
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
|
|
public KW_BY(): TerminalNode[];
|
|
public KW_BY(i: number): TerminalNode;
|
|
public KW_BY(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.KW_BY);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.KW_BY, i);
|
|
}
|
|
}
|
|
public expression(): ExpressionContext[];
|
|
public expression(i: number): ExpressionContext;
|
|
public expression(i?: number): ExpressionContext | ExpressionContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(ExpressionContext);
|
|
} else {
|
|
return this.getRuleContext(i, ExpressionContext);
|
|
}
|
|
}
|
|
public windowFrame(): WindowFrameContext | undefined {
|
|
return this.tryGetRuleContext(0, WindowFrameContext);
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
public sortItem(): SortItemContext[];
|
|
public sortItem(i: number): SortItemContext;
|
|
public sortItem(i?: number): SortItemContext | SortItemContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(SortItemContext);
|
|
} else {
|
|
return this.getRuleContext(i, SortItemContext);
|
|
}
|
|
}
|
|
public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
|
|
public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
|
|
public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
|
|
public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_windowSpec; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterWindowSpec) {
|
|
listener.enterWindowSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitWindowSpec) {
|
|
listener.exitWindowSpec(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitWindowSpec) {
|
|
return visitor.visitWindowSpec(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class WindowFrameContext extends ParserRuleContext {
|
|
public _frameType!: Token;
|
|
public _start_!: FrameBoundContext;
|
|
public _end!: FrameBoundContext;
|
|
public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RANGE, 0); }
|
|
public frameBound(): FrameBoundContext[];
|
|
public frameBound(i: number): FrameBoundContext;
|
|
public frameBound(i?: number): FrameBoundContext | FrameBoundContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(FrameBoundContext);
|
|
} else {
|
|
return this.getRuleContext(i, FrameBoundContext);
|
|
}
|
|
}
|
|
public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
|
|
public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_windowFrame; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterWindowFrame) {
|
|
listener.enterWindowFrame(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitWindowFrame) {
|
|
listener.exitWindowFrame(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitWindowFrame) {
|
|
return visitor.visitWindowFrame(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FrameBoundContext extends ParserRuleContext {
|
|
public _boundType!: Token;
|
|
public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNBOUNDED, 0); }
|
|
public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRECEDING, 0); }
|
|
public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOLLOWING, 0); }
|
|
public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROW, 0); }
|
|
public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
|
|
public expression(): ExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_frameBound; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFrameBound) {
|
|
listener.enterFrameBound(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFrameBound) {
|
|
listener.exitFrameBound(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFrameBound) {
|
|
return visitor.visitFrameBound(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QualifiedNameListContext extends ParserRuleContext {
|
|
public qualifiedName(): QualifiedNameContext[];
|
|
public qualifiedName(i: number): QualifiedNameContext;
|
|
public qualifiedName(i?: number): QualifiedNameContext | QualifiedNameContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(QualifiedNameContext);
|
|
} else {
|
|
return this.getRuleContext(i, QualifiedNameContext);
|
|
}
|
|
}
|
|
public COMMA(): TerminalNode[];
|
|
public COMMA(i: number): TerminalNode;
|
|
public COMMA(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.COMMA);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.COMMA, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedNameList; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQualifiedNameList) {
|
|
listener.enterQualifiedNameList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQualifiedNameList) {
|
|
listener.exitQualifiedNameList(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQualifiedNameList) {
|
|
return visitor.visitQualifiedNameList(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionNameContext extends ParserRuleContext {
|
|
public KW_IDENTIFIER_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 0); }
|
|
public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
|
|
public expression(): ExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, ExpressionContext);
|
|
}
|
|
public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
|
|
public qualifiedName(): QualifiedNameContext | undefined {
|
|
return this.tryGetRuleContext(0, QualifiedNameContext);
|
|
}
|
|
public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILTER, 0); }
|
|
public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEFT, 0); }
|
|
public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RIGHT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionName; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionName) {
|
|
listener.enterFunctionName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionName) {
|
|
listener.exitFunctionName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionName) {
|
|
return visitor.visitFunctionName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class FunctionNameCreateContext extends ParserRuleContext {
|
|
public qualifiedName(): QualifiedNameContext {
|
|
return this.getRuleContext(0, QualifiedNameContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_functionNameCreate; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterFunctionNameCreate) {
|
|
listener.enterFunctionNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitFunctionNameCreate) {
|
|
listener.exitFunctionNameCreate(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitFunctionNameCreate) {
|
|
return visitor.visitFunctionNameCreate(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QualifiedNameContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
public DOT(): TerminalNode[];
|
|
public DOT(i: number): TerminalNode;
|
|
public DOT(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.DOT);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.DOT, i);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedName; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQualifiedName) {
|
|
listener.enterQualifiedName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQualifiedName) {
|
|
listener.exitQualifiedName(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQualifiedName) {
|
|
return visitor.visitQualifiedName(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ErrorCapturingIdentifierContext extends ParserRuleContext {
|
|
public identifier(): IdentifierContext {
|
|
return this.getRuleContext(0, IdentifierContext);
|
|
}
|
|
public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext {
|
|
return this.getRuleContext(0, ErrorCapturingIdentifierExtraContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterErrorCapturingIdentifier) {
|
|
listener.enterErrorCapturingIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitErrorCapturingIdentifier) {
|
|
listener.exitErrorCapturingIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitErrorCapturingIdentifier) {
|
|
return visitor.visitErrorCapturingIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class ErrorCapturingIdentifierExtraContext extends ParserRuleContext {
|
|
public MINUS(): TerminalNode[];
|
|
public MINUS(i: number): TerminalNode;
|
|
public MINUS(i?: number): TerminalNode | TerminalNode[] {
|
|
if (i === undefined) {
|
|
return this.getTokens(SparkSqlParser.MINUS);
|
|
} else {
|
|
return this.getToken(SparkSqlParser.MINUS, i);
|
|
}
|
|
}
|
|
public identifier(): IdentifierContext[];
|
|
public identifier(i: number): IdentifierContext;
|
|
public identifier(i?: number): IdentifierContext | IdentifierContext[] {
|
|
if (i === undefined) {
|
|
return this.getRuleContexts(IdentifierContext);
|
|
} else {
|
|
return this.getRuleContext(i, IdentifierContext);
|
|
}
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingIdentifierExtra; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterErrorCapturingIdentifierExtra) {
|
|
listener.enterErrorCapturingIdentifierExtra(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitErrorCapturingIdentifierExtra) {
|
|
listener.exitErrorCapturingIdentifierExtra(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitErrorCapturingIdentifierExtra) {
|
|
return visitor.visitErrorCapturingIdentifierExtra(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class IdentifierContext extends ParserRuleContext {
|
|
public strictIdentifier(): StrictIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, StrictIdentifierContext);
|
|
}
|
|
public strictNonReserved(): StrictNonReservedContext | undefined {
|
|
return this.tryGetRuleContext(0, StrictNonReservedContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_identifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterIdentifier) {
|
|
listener.enterIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitIdentifier) {
|
|
listener.exitIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitIdentifier) {
|
|
return visitor.visitIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StrictIdentifierContext extends ParserRuleContext {
|
|
public IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.IDENTIFIER, 0); }
|
|
public quotedIdentifier(): QuotedIdentifierContext | undefined {
|
|
return this.tryGetRuleContext(0, QuotedIdentifierContext);
|
|
}
|
|
public ansiNonReserved(): AnsiNonReservedContext | undefined {
|
|
return this.tryGetRuleContext(0, AnsiNonReservedContext);
|
|
}
|
|
public nonReserved(): NonReservedContext | undefined {
|
|
return this.tryGetRuleContext(0, NonReservedContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_strictIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterStrictIdentifier) {
|
|
listener.enterStrictIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitStrictIdentifier) {
|
|
listener.exitStrictIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitStrictIdentifier) {
|
|
return visitor.visitStrictIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class QuotedIdentifierContext extends ParserRuleContext {
|
|
public BACKQUOTED_IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.BACKQUOTED_IDENTIFIER, 0); }
|
|
public DOUBLEQUOTED_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOUBLEQUOTED_STRING, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_quotedIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterQuotedIdentifier) {
|
|
listener.enterQuotedIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitQuotedIdentifier) {
|
|
listener.exitQuotedIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitQuotedIdentifier) {
|
|
return visitor.visitQuotedIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class BackQuotedIdentifierContext extends ParserRuleContext {
|
|
public BACKQUOTED_IDENTIFIER(): TerminalNode { return this.getToken(SparkSqlParser.BACKQUOTED_IDENTIFIER, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_backQuotedIdentifier; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterBackQuotedIdentifier) {
|
|
listener.enterBackQuotedIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitBackQuotedIdentifier) {
|
|
listener.exitBackQuotedIdentifier(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitBackQuotedIdentifier) {
|
|
return visitor.visitBackQuotedIdentifier(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NumberContext extends ParserRuleContext {
|
|
public EXPONENT_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EXPONENT_VALUE, 0); }
|
|
public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
|
|
public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
|
|
public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
|
|
public BIGINT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.BIGINT_LITERAL, 0); }
|
|
public SMALLINT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SMALLINT_LITERAL, 0); }
|
|
public TINYINT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.TINYINT_LITERAL, 0); }
|
|
public DOUBLE_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOUBLE_LITERAL, 0); }
|
|
public FLOAT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.FLOAT_LITERAL, 0); }
|
|
public BIGDECIMAL_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.BIGDECIMAL_LITERAL, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_number; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNumber) {
|
|
listener.enterNumber(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNumber) {
|
|
listener.exitNumber(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNumber) {
|
|
return visitor.visitNumber(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AlterColumnActionContext extends ParserRuleContext {
|
|
public _setOrDrop!: Token;
|
|
public _dropDefault!: Token;
|
|
public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TYPE, 0); }
|
|
public dataType(): DataTypeContext | undefined {
|
|
return this.tryGetRuleContext(0, DataTypeContext);
|
|
}
|
|
public commentSpec(): CommentSpecContext | undefined {
|
|
return this.tryGetRuleContext(0, CommentSpecContext);
|
|
}
|
|
public colPosition(): ColPositionContext | undefined {
|
|
return this.tryGetRuleContext(0, ColPositionContext);
|
|
}
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
|
|
public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
|
|
public defaultExpression(): DefaultExpressionContext | undefined {
|
|
return this.tryGetRuleContext(0, DefaultExpressionContext);
|
|
}
|
|
public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_alterColumnAction; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterAlterColumnAction) {
|
|
listener.enterAlterColumnAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitAlterColumnAction) {
|
|
listener.exitAlterColumnAction(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitAlterColumnAction) {
|
|
return visitor.visitAlterColumnAction(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StringLitContext extends ParserRuleContext {
|
|
public STRING_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.STRING_LITERAL, 0); }
|
|
public DOUBLEQUOTED_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOUBLEQUOTED_STRING, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_stringLit; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterStringLit) {
|
|
listener.enterStringLit(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitStringLit) {
|
|
listener.exitStringLit(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitStringLit) {
|
|
return visitor.visitStringLit(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class CommentContext extends ParserRuleContext {
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_comment; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterComment) {
|
|
listener.enterComment(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitComment) {
|
|
listener.exitComment(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitComment) {
|
|
return visitor.visitComment(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class VersionContext extends ParserRuleContext {
|
|
public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
|
|
public stringLit(): StringLitContext | undefined {
|
|
return this.tryGetRuleContext(0, StringLitContext);
|
|
}
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_version; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterVersion) {
|
|
listener.enterVersion(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitVersion) {
|
|
listener.exitVersion(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitVersion) {
|
|
return visitor.visitVersion(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class AnsiNonReservedContext extends ParserRuleContext {
|
|
public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ADD, 0); }
|
|
public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AFTER, 0); }
|
|
public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALTER, 0); }
|
|
public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALWAYS, 0); }
|
|
public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANALYZE, 0); }
|
|
public KW_ANTI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANTI, 0); }
|
|
public KW_ANY_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY_VALUE, 0); }
|
|
public KW_ARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARCHIVE, 0); }
|
|
public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
|
|
public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
|
|
public KW_AT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AT, 0); }
|
|
public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
|
|
public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BIGINT, 0); }
|
|
public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY, 0); }
|
|
public KW_BINARY_HEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY_HEX, 0); }
|
|
public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOOLEAN, 0); }
|
|
public KW_BUCKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKET, 0); }
|
|
public KW_BUCKETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKETS, 0); }
|
|
public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
|
|
public KW_BYTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BYTE, 0); }
|
|
public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CACHE, 0); }
|
|
public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASCADE, 0); }
|
|
public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOG, 0); }
|
|
public KW_CATALOGS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOGS, 0); }
|
|
public KW_CHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHANGE, 0); }
|
|
public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHAR, 0); }
|
|
public KW_CHARACTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHARACTER, 0); }
|
|
public KW_CLEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLEAR, 0); }
|
|
public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
|
|
public KW_CLUSTERED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTERED, 0); }
|
|
public KW_CODEGEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CODEGEN, 0); }
|
|
public KW_COLLECTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLECTION, 0); }
|
|
public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
|
|
public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMENT, 0); }
|
|
public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMIT, 0); }
|
|
public KW_COMPACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACT, 0); }
|
|
public KW_COMPACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACTIONS, 0); }
|
|
public KW_COMPUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPUTE, 0); }
|
|
public KW_CONCATENATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONCATENATE, 0); }
|
|
public KW_COST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COST, 0); }
|
|
public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
|
|
public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
|
|
public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATA, 0); }
|
|
public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
|
|
public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASES, 0); }
|
|
public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
|
|
public KW_DATEADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEADD, 0); }
|
|
public KW_DATE_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_ADD, 0); }
|
|
public KW_DATEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEDIFF, 0); }
|
|
public KW_DATE_DIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_DIFF, 0); }
|
|
public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
|
|
public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYS, 0); }
|
|
public KW_DAYOFYEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYOFYEAR, 0); }
|
|
public KW_DBPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DBPROPERTIES, 0); }
|
|
public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEC, 0); }
|
|
public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECIMAL, 0); }
|
|
public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECLARE, 0); }
|
|
public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
|
|
public KW_DEFINED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFINED, 0); }
|
|
public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
|
|
public KW_DELIMITED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELIMITED, 0); }
|
|
public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
|
|
public KW_DESCRIBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESCRIBE, 0); }
|
|
public KW_DFS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DFS, 0); }
|
|
public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
|
|
public KW_DIRECTORY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORY, 0); }
|
|
public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
|
|
public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
|
|
public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DOUBLE, 0); }
|
|
public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
|
|
public KW_ESCAPED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPED, 0); }
|
|
public KW_EXCHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCHANGE, 0); }
|
|
public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCLUDE, 0); }
|
|
public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXISTS, 0); }
|
|
public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPLAIN, 0); }
|
|
public KW_EXPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPORT, 0); }
|
|
public KW_EXTENDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTENDED, 0); }
|
|
public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTERNAL, 0); }
|
|
public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTRACT, 0); }
|
|
public KW_FIELDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIELDS, 0); }
|
|
public KW_FILEFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILEFORMAT, 0); }
|
|
public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
|
|
public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FLOAT, 0); }
|
|
public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOLLOWING, 0); }
|
|
public KW_FORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMAT, 0); }
|
|
public KW_FORMATTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMATTED, 0); }
|
|
public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTION, 0); }
|
|
public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTIONS, 0); }
|
|
public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GENERATED, 0); }
|
|
public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GLOBAL, 0); }
|
|
public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
|
|
public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
|
|
public KW_HOURS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOURS, 0); }
|
|
public KW_IDENTIFIER_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 0); }
|
|
public KW_IF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IF, 0); }
|
|
public KW_IGNORE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IGNORE, 0); }
|
|
public KW_IMPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IMPORT, 0); }
|
|
public KW_INCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INCLUDE, 0); }
|
|
public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
|
|
public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEXES, 0); }
|
|
public KW_INPATH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPATH, 0); }
|
|
public KW_INPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPUTFORMAT, 0); }
|
|
public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INSERT, 0); }
|
|
public KW_INT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INT, 0); }
|
|
public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTEGER, 0); }
|
|
public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
|
|
public KW_ITEMS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ITEMS, 0); }
|
|
public KW_KEYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_KEYS, 0); }
|
|
public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
|
|
public KW_LAZY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAZY, 0); }
|
|
public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
|
|
public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ILIKE, 0); }
|
|
public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIMIT, 0); }
|
|
public KW_LINES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LINES, 0); }
|
|
public KW_LIST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIST, 0); }
|
|
public KW_LOAD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOAD, 0); }
|
|
public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
|
|
public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCATION, 0); }
|
|
public KW_LOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCK, 0); }
|
|
public KW_LOCKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCKS, 0); }
|
|
public KW_LOGICAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOGICAL, 0); }
|
|
public KW_LONG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LONG, 0); }
|
|
public KW_MACRO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MACRO, 0); }
|
|
public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
|
|
public KW_MATCHED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MATCHED, 0); }
|
|
public KW_MERGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MERGE, 0); }
|
|
public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
|
|
public KW_MICROSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECONDS, 0); }
|
|
public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
|
|
public KW_MILLISECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECONDS, 0); }
|
|
public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
|
|
public KW_MINUTES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTES, 0); }
|
|
public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
|
|
public KW_MONTHS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTHS, 0); }
|
|
public KW_MSCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MSCK, 0); }
|
|
public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAME, 0); }
|
|
public KW_NAMESPACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACE, 0); }
|
|
public KW_NAMESPACES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACES, 0); }
|
|
public KW_NANOSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECOND, 0); }
|
|
public KW_NANOSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECONDS, 0); }
|
|
public KW_NO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NO, 0); }
|
|
public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
|
|
public KW_NUMERIC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NUMERIC, 0); }
|
|
public KW_OF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OF, 0); }
|
|
public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTION, 0); }
|
|
public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
|
|
public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUT, 0); }
|
|
public KW_OUTPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTPUTFORMAT, 0); }
|
|
public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVER, 0); }
|
|
public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAY, 0); }
|
|
public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
|
|
public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
|
|
public KW_PARTITIONED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONED, 0); }
|
|
public KW_PARTITIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONS, 0); }
|
|
public KW_PERCENTLIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTLIT, 0); }
|
|
public KW_PIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PIVOT, 0); }
|
|
public KW_PLACING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PLACING, 0); }
|
|
public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_POSITION, 0); }
|
|
public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRECEDING, 0); }
|
|
public KW_PRINCIPALS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRINCIPALS, 0); }
|
|
public KW_PROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PROPERTIES, 0); }
|
|
public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PURGE, 0); }
|
|
public KW_QUARTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUARTER, 0); }
|
|
public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUERY, 0); }
|
|
public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RANGE, 0); }
|
|
public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REAL, 0); }
|
|
public KW_RECORDREADER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDREADER, 0); }
|
|
public KW_RECORDWRITER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDWRITER, 0); }
|
|
public KW_RECOVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECOVER, 0); }
|
|
public KW_REDUCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REDUCE, 0); }
|
|
public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFRESH, 0); }
|
|
public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RENAME, 0); }
|
|
public KW_REPAIR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPAIR, 0); }
|
|
public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPEATABLE, 0); }
|
|
public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
|
|
public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESET, 0); }
|
|
public KW_RESPECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESPECT, 0); }
|
|
public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESTRICT, 0); }
|
|
public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REVOKE, 0); }
|
|
public KW_RLIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RLIKE, 0); }
|
|
public KW_REGEXP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REGEXP, 0); }
|
|
public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
|
|
public KW_ROLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLES, 0); }
|
|
public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLBACK, 0); }
|
|
public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
|
|
public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROW, 0); }
|
|
public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
|
|
public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMA, 0); }
|
|
public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMAS, 0); }
|
|
public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
|
|
public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECONDS, 0); }
|
|
public KW_SEMI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEMI, 0); }
|
|
public KW_SEPARATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEPARATED, 0); }
|
|
public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
|
|
public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
|
|
public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
|
|
public KW_SETMINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETMINUS, 0); }
|
|
public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
|
|
public KW_SHORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHORT, 0); }
|
|
public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
|
|
public KW_SINGLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SINGLE, 0); }
|
|
public KW_SKEWED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SKEWED, 0); }
|
|
public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SMALLINT, 0); }
|
|
public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
|
|
public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
|
|
public KW_SOURCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOURCE, 0); }
|
|
public KW_START(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_START, 0); }
|
|
public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STATISTICS, 0); }
|
|
public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
|
|
public KW_STRATIFY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRATIFY, 0); }
|
|
public KW_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRING, 0); }
|
|
public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
|
|
public KW_SUBSTR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTR, 0); }
|
|
public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTRING, 0); }
|
|
public KW_SYNC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYNC, 0); }
|
|
public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM, 0); }
|
|
public KW_SYSTEM_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_TIME, 0); }
|
|
public KW_SYSTEM_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_VERSION, 0); }
|
|
public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLES, 0); }
|
|
public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLESAMPLE, 0); }
|
|
public KW_TARGET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TARGET, 0); }
|
|
public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TBLPROPERTIES, 0); }
|
|
public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
|
|
public KW_TERMINATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TERMINATED, 0); }
|
|
public KW_TIMEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMEDIFF, 0); }
|
|
public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
|
|
public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
|
|
public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
|
|
public KW_TIMESTAMPADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPADD, 0); }
|
|
public KW_TIMESTAMPDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPDIFF, 0); }
|
|
public KW_TINYINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TINYINT, 0); }
|
|
public KW_TOUCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TOUCH, 0); }
|
|
public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTION, 0); }
|
|
public KW_TRANSACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTIONS, 0); }
|
|
public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSFORM, 0); }
|
|
public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRIM, 0); }
|
|
public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
|
|
public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUNCATE, 0); }
|
|
public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRY_CAST, 0); }
|
|
public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TYPE, 0); }
|
|
public KW_UNARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNARCHIVE, 0); }
|
|
public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNBOUNDED, 0); }
|
|
public KW_UNCACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNCACHE, 0); }
|
|
public KW_UNLOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNLOCK, 0); }
|
|
public KW_UNPIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNPIVOT, 0); }
|
|
public KW_UNSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNSET, 0); }
|
|
public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
|
|
public KW_USE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USE, 0); }
|
|
public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VALUES, 0); }
|
|
public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARCHAR, 0); }
|
|
public KW_VAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VAR, 0); }
|
|
public KW_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARIABLE, 0); }
|
|
public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VERSION, 0); }
|
|
public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEW, 0); }
|
|
public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEWS, 0); }
|
|
public KW_VOID(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VOID, 0); }
|
|
public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
|
|
public KW_WEEKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEKS, 0); }
|
|
public KW_WINDOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WINDOW, 0); }
|
|
public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
|
|
public KW_YEARS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEARS, 0); }
|
|
public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ZONE, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_ansiNonReserved; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterAnsiNonReserved) {
|
|
listener.enterAnsiNonReserved(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitAnsiNonReserved) {
|
|
listener.exitAnsiNonReserved(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitAnsiNonReserved) {
|
|
return visitor.visitAnsiNonReserved(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class StrictNonReservedContext extends ParserRuleContext {
|
|
public KW_ANTI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANTI, 0); }
|
|
public KW_CROSS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CROSS, 0); }
|
|
public KW_EXCEPT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCEPT, 0); }
|
|
public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FULL, 0); }
|
|
public KW_INNER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INNER, 0); }
|
|
public KW_INTERSECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERSECT, 0); }
|
|
public KW_JOIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_JOIN, 0); }
|
|
public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LATERAL, 0); }
|
|
public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEFT, 0); }
|
|
public KW_NATURAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NATURAL, 0); }
|
|
public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
|
|
public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RIGHT, 0); }
|
|
public KW_SEMI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEMI, 0); }
|
|
public KW_SETMINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETMINUS, 0); }
|
|
public KW_UNION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNION, 0); }
|
|
public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_strictNonReserved; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterStrictNonReserved) {
|
|
listener.enterStrictNonReserved(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitStrictNonReserved) {
|
|
listener.exitStrictNonReserved(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitStrictNonReserved) {
|
|
return visitor.visitStrictNonReserved(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
export class NonReservedContext extends ParserRuleContext {
|
|
public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ADD, 0); }
|
|
public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AFTER, 0); }
|
|
public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
|
|
public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALTER, 0); }
|
|
public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALWAYS, 0); }
|
|
public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANALYZE, 0); }
|
|
public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
|
|
public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY, 0); }
|
|
public KW_ANY_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY_VALUE, 0); }
|
|
public KW_ARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARCHIVE, 0); }
|
|
public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
|
|
public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
|
|
public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
|
|
public KW_AT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AT, 0); }
|
|
public KW_AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AUTHORIZATION, 0); }
|
|
public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
|
|
public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BIGINT, 0); }
|
|
public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY, 0); }
|
|
public KW_BINARY_HEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY_HEX, 0); }
|
|
public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOOLEAN, 0); }
|
|
public KW_BOTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOTH, 0); }
|
|
public KW_BUCKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKET, 0); }
|
|
public KW_BUCKETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKETS, 0); }
|
|
public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
|
|
public KW_BYTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BYTE, 0); }
|
|
public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CACHE, 0); }
|
|
public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASCADE, 0); }
|
|
public KW_CASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASE, 0); }
|
|
public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CAST, 0); }
|
|
public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOG, 0); }
|
|
public KW_CATALOGS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOGS, 0); }
|
|
public KW_CHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHANGE, 0); }
|
|
public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHAR, 0); }
|
|
public KW_CHARACTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHARACTER, 0); }
|
|
public KW_CHECK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHECK, 0); }
|
|
public KW_CLEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLEAR, 0); }
|
|
public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
|
|
public KW_CLUSTERED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTERED, 0); }
|
|
public KW_CODEGEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CODEGEN, 0); }
|
|
public KW_COLLATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLATE, 0); }
|
|
public KW_COLLECTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLECTION, 0); }
|
|
public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMN, 0); }
|
|
public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
|
|
public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMENT, 0); }
|
|
public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMIT, 0); }
|
|
public KW_COMPACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACT, 0); }
|
|
public KW_COMPACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACTIONS, 0); }
|
|
public KW_COMPUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPUTE, 0); }
|
|
public KW_CONCATENATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONCATENATE, 0); }
|
|
public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONSTRAINT, 0); }
|
|
public KW_COST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COST, 0); }
|
|
public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
|
|
public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
|
|
public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
|
|
public KW_CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_DATE, 0); }
|
|
public KW_CURRENT_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_TIME, 0); }
|
|
public KW_CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_TIMESTAMP, 0); }
|
|
public KW_CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_USER, 0); }
|
|
public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATA, 0); }
|
|
public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
|
|
public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASES, 0); }
|
|
public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
|
|
public KW_DATEADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEADD, 0); }
|
|
public KW_DATE_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_ADD, 0); }
|
|
public KW_DATEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEDIFF, 0); }
|
|
public KW_DATE_DIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_DIFF, 0); }
|
|
public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
|
|
public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYS, 0); }
|
|
public KW_DAYOFYEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYOFYEAR, 0); }
|
|
public KW_DBPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DBPROPERTIES, 0); }
|
|
public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEC, 0); }
|
|
public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECIMAL, 0); }
|
|
public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECLARE, 0); }
|
|
public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
|
|
public KW_DEFINED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFINED, 0); }
|
|
public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
|
|
public KW_DELIMITED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELIMITED, 0); }
|
|
public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
|
|
public KW_DESCRIBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESCRIBE, 0); }
|
|
public KW_DFS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DFS, 0); }
|
|
public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
|
|
public KW_DIRECTORY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORY, 0); }
|
|
public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTINCT, 0); }
|
|
public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
|
|
public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
|
|
public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DOUBLE, 0); }
|
|
public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
|
|
public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ELSE, 0); }
|
|
public KW_END(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_END, 0); }
|
|
public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPE, 0); }
|
|
public KW_ESCAPED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPED, 0); }
|
|
public KW_EXCHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCHANGE, 0); }
|
|
public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCLUDE, 0); }
|
|
public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXISTS, 0); }
|
|
public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPLAIN, 0); }
|
|
public KW_EXPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPORT, 0); }
|
|
public KW_EXTENDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTENDED, 0); }
|
|
public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTERNAL, 0); }
|
|
public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTRACT, 0); }
|
|
public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FALSE, 0); }
|
|
public KW_FETCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FETCH, 0); }
|
|
public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILTER, 0); }
|
|
public KW_FIELDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIELDS, 0); }
|
|
public KW_FILEFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILEFORMAT, 0); }
|
|
public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
|
|
public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FLOAT, 0); }
|
|
public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOLLOWING, 0); }
|
|
public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
|
|
public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOREIGN, 0); }
|
|
public KW_FORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMAT, 0); }
|
|
public KW_FORMATTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMATTED, 0); }
|
|
public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
|
|
public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTION, 0); }
|
|
public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTIONS, 0); }
|
|
public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GENERATED, 0); }
|
|
public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GLOBAL, 0); }
|
|
public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GRANT, 0); }
|
|
public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUP, 0); }
|
|
public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
|
|
public KW_HAVING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HAVING, 0); }
|
|
public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
|
|
public KW_HOURS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOURS, 0); }
|
|
public KW_IDENTIFIER_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 0); }
|
|
public KW_IF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IF, 0); }
|
|
public KW_IGNORE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IGNORE, 0); }
|
|
public KW_IMPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IMPORT, 0); }
|
|
public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
|
|
public KW_INCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INCLUDE, 0); }
|
|
public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
|
|
public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEXES, 0); }
|
|
public KW_INPATH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPATH, 0); }
|
|
public KW_INPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPUTFORMAT, 0); }
|
|
public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INSERT, 0); }
|
|
public KW_INT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INT, 0); }
|
|
public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTEGER, 0); }
|
|
public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
|
|
public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
|
|
public KW_IS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IS, 0); }
|
|
public KW_ITEMS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ITEMS, 0); }
|
|
public KW_KEYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_KEYS, 0); }
|
|
public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
|
|
public KW_LAZY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAZY, 0); }
|
|
public KW_LEADING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEADING, 0); }
|
|
public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
|
|
public KW_LONG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LONG, 0); }
|
|
public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ILIKE, 0); }
|
|
public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIMIT, 0); }
|
|
public KW_LINES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LINES, 0); }
|
|
public KW_LIST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIST, 0); }
|
|
public KW_LOAD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOAD, 0); }
|
|
public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
|
|
public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCATION, 0); }
|
|
public KW_LOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCK, 0); }
|
|
public KW_LOCKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCKS, 0); }
|
|
public KW_LOGICAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOGICAL, 0); }
|
|
public KW_MACRO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MACRO, 0); }
|
|
public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
|
|
public KW_MATCHED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MATCHED, 0); }
|
|
public KW_MERGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MERGE, 0); }
|
|
public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
|
|
public KW_MICROSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECONDS, 0); }
|
|
public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
|
|
public KW_MILLISECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECONDS, 0); }
|
|
public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
|
|
public KW_MINUTES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTES, 0); }
|
|
public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
|
|
public KW_MONTHS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTHS, 0); }
|
|
public KW_MSCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MSCK, 0); }
|
|
public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAME, 0); }
|
|
public KW_NAMESPACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACE, 0); }
|
|
public KW_NAMESPACES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACES, 0); }
|
|
public KW_NANOSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECOND, 0); }
|
|
public KW_NANOSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECONDS, 0); }
|
|
public KW_NO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NO, 0); }
|
|
public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
|
|
public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
|
|
public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
|
|
public KW_NUMERIC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NUMERIC, 0); }
|
|
public KW_OF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OF, 0); }
|
|
public KW_OFFSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OFFSET, 0); }
|
|
public KW_ONLY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ONLY, 0); }
|
|
public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTION, 0); }
|
|
public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
|
|
public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
|
|
public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
|
|
public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUT, 0); }
|
|
public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTER, 0); }
|
|
public KW_OUTPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTPUTFORMAT, 0); }
|
|
public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVER, 0); }
|
|
public KW_OVERLAPS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAPS, 0); }
|
|
public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAY, 0); }
|
|
public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
|
|
public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
|
|
public KW_PARTITIONED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONED, 0); }
|
|
public KW_PARTITIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONS, 0); }
|
|
public KW_PERCENTILE_CONT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_CONT, 0); }
|
|
public KW_PERCENTILE_DISC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_DISC, 0); }
|
|
public KW_PERCENTLIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTLIT, 0); }
|
|
public KW_PIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PIVOT, 0); }
|
|
public KW_PLACING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PLACING, 0); }
|
|
public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_POSITION, 0); }
|
|
public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRECEDING, 0); }
|
|
public KW_PRIMARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRIMARY, 0); }
|
|
public KW_PRINCIPALS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRINCIPALS, 0); }
|
|
public KW_PROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PROPERTIES, 0); }
|
|
public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PURGE, 0); }
|
|
public KW_QUARTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUARTER, 0); }
|
|
public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUERY, 0); }
|
|
public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RANGE, 0); }
|
|
public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REAL, 0); }
|
|
public KW_RECORDREADER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDREADER, 0); }
|
|
public KW_RECORDWRITER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDWRITER, 0); }
|
|
public KW_RECOVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECOVER, 0); }
|
|
public KW_REDUCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REDUCE, 0); }
|
|
public KW_REFERENCES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFERENCES, 0); }
|
|
public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFRESH, 0); }
|
|
public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RENAME, 0); }
|
|
public KW_REPAIR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPAIR, 0); }
|
|
public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPEATABLE, 0); }
|
|
public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
|
|
public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESET, 0); }
|
|
public KW_RESPECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESPECT, 0); }
|
|
public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESTRICT, 0); }
|
|
public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REVOKE, 0); }
|
|
public KW_RLIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RLIKE, 0); }
|
|
public KW_REGEXP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REGEXP, 0); }
|
|
public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
|
|
public KW_ROLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLES, 0); }
|
|
public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLBACK, 0); }
|
|
public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
|
|
public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROW, 0); }
|
|
public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
|
|
public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMA, 0); }
|
|
public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMAS, 0); }
|
|
public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
|
|
public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECONDS, 0); }
|
|
public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SELECT, 0); }
|
|
public KW_SEPARATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEPARATED, 0); }
|
|
public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
|
|
public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
|
|
public KW_SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SESSION_USER, 0); }
|
|
public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
|
|
public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
|
|
public KW_SHORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHORT, 0); }
|
|
public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
|
|
public KW_SINGLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SINGLE, 0); }
|
|
public KW_SKEWED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SKEWED, 0); }
|
|
public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SMALLINT, 0); }
|
|
public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOME, 0); }
|
|
public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
|
|
public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
|
|
public KW_SOURCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOURCE, 0); }
|
|
public KW_START(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_START, 0); }
|
|
public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STATISTICS, 0); }
|
|
public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
|
|
public KW_STRATIFY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRATIFY, 0); }
|
|
public KW_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRING, 0); }
|
|
public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
|
|
public KW_SUBSTR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTR, 0); }
|
|
public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTRING, 0); }
|
|
public KW_SYNC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYNC, 0); }
|
|
public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM, 0); }
|
|
public KW_SYSTEM_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_TIME, 0); }
|
|
public KW_SYSTEM_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_VERSION, 0); }
|
|
public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
|
|
public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLES, 0); }
|
|
public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLESAMPLE, 0); }
|
|
public KW_TARGET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TARGET, 0); }
|
|
public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TBLPROPERTIES, 0); }
|
|
public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
|
|
public KW_TERMINATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TERMINATED, 0); }
|
|
public KW_THEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_THEN, 0); }
|
|
public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIME, 0); }
|
|
public KW_TIMEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMEDIFF, 0); }
|
|
public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
|
|
public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
|
|
public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
|
|
public KW_TIMESTAMPADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPADD, 0); }
|
|
public KW_TIMESTAMPDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPDIFF, 0); }
|
|
public KW_TINYINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TINYINT, 0); }
|
|
public KW_TO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TO, 0); }
|
|
public KW_TOUCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TOUCH, 0); }
|
|
public KW_TRAILING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRAILING, 0); }
|
|
public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTION, 0); }
|
|
public KW_TRANSACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTIONS, 0); }
|
|
public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSFORM, 0); }
|
|
public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRIM, 0); }
|
|
public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
|
|
public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUNCATE, 0); }
|
|
public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRY_CAST, 0); }
|
|
public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TYPE, 0); }
|
|
public KW_UNARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNARCHIVE, 0); }
|
|
public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNBOUNDED, 0); }
|
|
public KW_UNCACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNCACHE, 0); }
|
|
public KW_UNIQUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNIQUE, 0); }
|
|
public KW_UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNKNOWN, 0); }
|
|
public KW_UNLOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNLOCK, 0); }
|
|
public KW_UNPIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNPIVOT, 0); }
|
|
public KW_UNSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNSET, 0); }
|
|
public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
|
|
public KW_USE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USE, 0); }
|
|
public KW_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USER, 0); }
|
|
public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VALUES, 0); }
|
|
public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARCHAR, 0); }
|
|
public KW_VAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VAR, 0); }
|
|
public KW_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARIABLE, 0); }
|
|
public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VERSION, 0); }
|
|
public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEW, 0); }
|
|
public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEWS, 0); }
|
|
public KW_VOID(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VOID, 0); }
|
|
public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
|
|
public KW_WEEKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEKS, 0); }
|
|
public KW_WHEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WHEN, 0); }
|
|
public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WHERE, 0); }
|
|
public KW_WINDOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WINDOW, 0); }
|
|
public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
|
|
public KW_WITHIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITHIN, 0); }
|
|
public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
|
|
public KW_YEARS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEARS, 0); }
|
|
public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ZONE, 0); }
|
|
constructor(parent: ParserRuleContext | undefined, invokingState: number) {
|
|
super(parent, invokingState);
|
|
}
|
|
// @Override
|
|
public get ruleIndex(): number { return SparkSqlParser.RULE_nonReserved; }
|
|
// @Override
|
|
public enterRule(listener: SparkSqlParserListener): void {
|
|
if (listener.enterNonReserved) {
|
|
listener.enterNonReserved(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public exitRule(listener: SparkSqlParserListener): void {
|
|
if (listener.exitNonReserved) {
|
|
listener.exitNonReserved(this);
|
|
}
|
|
}
|
|
// @Override
|
|
public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
|
|
if (visitor.visitNonReserved) {
|
|
return visitor.visitNonReserved(this);
|
|
} else {
|
|
return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|