dt-sql-parser 4.0.0-ng.2 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (142) hide show
  1. package/README.md +119 -112
  2. package/dist/index.d.ts +14 -6
  3. package/dist/index.js +11 -4
  4. package/dist/lib/SQLParserBase.d.ts +8 -0
  5. package/dist/lib/SQLParserBase.js +14 -0
  6. package/dist/lib/{flinksql → flink}/FlinkSqlLexer.d.ts +2 -2
  7. package/dist/lib/{flinksql → flink}/FlinkSqlLexer.js +2 -1
  8. package/dist/lib/{flinksql → flink}/FlinkSqlParser.d.ts +5 -11
  9. package/dist/lib/{flinksql → flink}/FlinkSqlParser.js +2065 -2054
  10. package/dist/lib/{flinksql → flink}/FlinkSqlParserListener.d.ts +0 -13
  11. package/dist/lib/{flinksql → flink}/FlinkSqlParserListener.js +1 -1
  12. package/dist/lib/{flinksql → flink}/FlinkSqlParserVisitor.d.ts +0 -8
  13. package/dist/lib/{flinksql → flink}/FlinkSqlParserVisitor.js +2 -1
  14. package/dist/lib/hive/HiveSqlLexer.d.ts +258 -257
  15. package/dist/lib/hive/HiveSqlLexer.js +1794 -1786
  16. package/dist/lib/hive/HiveSqlParser.d.ts +1266 -3176
  17. package/dist/lib/hive/HiveSqlParser.js +23046 -33454
  18. package/dist/lib/hive/HiveSqlParserListener.d.ts +141 -2036
  19. package/dist/lib/hive/HiveSqlParserVisitor.d.ts +151 -1358
  20. package/dist/lib/hive/HiveSqlParserVisitor.js +1 -0
  21. package/dist/lib/impala/ImpalaSqlLexer.d.ts +170 -154
  22. package/dist/lib/impala/ImpalaSqlLexer.js +1179 -1099
  23. package/dist/lib/impala/ImpalaSqlParser.d.ts +282 -240
  24. package/dist/lib/impala/ImpalaSqlParser.js +3881 -3744
  25. package/dist/lib/impala/ImpalaSqlParserListener.d.ts +22 -11
  26. package/dist/lib/impala/ImpalaSqlParserVisitor.d.ts +14 -7
  27. package/dist/lib/impala/ImpalaSqlParserVisitor.js +1 -0
  28. package/dist/lib/index.d.ts +6 -6
  29. package/dist/lib/index.js +6 -6
  30. package/dist/lib/mysql/MySqlLexer.d.ts +2 -2
  31. package/dist/lib/mysql/MySqlLexer.js +1 -0
  32. package/dist/lib/mysql/MySqlParser.d.ts +347 -418
  33. package/dist/lib/mysql/MySqlParser.js +10484 -11099
  34. package/dist/lib/mysql/MySqlParserListener.d.ts +41 -126
  35. package/dist/lib/mysql/MySqlParserVisitor.d.ts +23 -76
  36. package/dist/lib/mysql/MySqlParserVisitor.js +1 -0
  37. package/dist/lib/plsql/PlSqlBaseLexer.d.ts +1 -2
  38. package/dist/lib/plsql/PlSqlBaseLexer.js +1 -1
  39. package/dist/lib/plsql/PlSqlBaseParser.d.ts +3 -2
  40. package/dist/lib/plsql/PlSqlBaseParser.js +2 -2
  41. package/dist/lib/plsql/PlSqlLexer.d.ts +3 -3
  42. package/dist/lib/plsql/PlSqlLexer.js +2 -1
  43. package/dist/lib/plsql/PlSqlParser.d.ts +3 -3
  44. package/dist/lib/plsql/PlSqlParser.js +2 -1
  45. package/dist/lib/plsql/PlSqlParserVisitor.js +1 -0
  46. package/dist/lib/{pgsql/PostgreSQLLexer.d.ts → postgresql/PostgreSqlLexer.d.ts} +3 -3
  47. package/dist/lib/{pgsql/PostgreSQLLexer.js → postgresql/PostgreSqlLexer.js} +618 -617
  48. package/dist/lib/{pgsql/PostgreSQLParser.d.ts → postgresql/PostgreSqlParser.d.ts} +3598 -3484
  49. package/dist/lib/{pgsql/PostgreSQLParser.js → postgresql/PostgreSqlParser.js} +41502 -42831
  50. package/dist/lib/{pgsql/PostgreSQLParserListener.d.ts → postgresql/PostgreSqlParserListener.d.ts} +2797 -2730
  51. package/dist/lib/{pgsql/PostgreSQLParserListener.js → postgresql/PostgreSqlParserListener.js} +3 -3
  52. package/dist/lib/{pgsql/PostgreSQLParserVisitor.d.ts → postgresql/PostgreSqlParserVisitor.d.ts} +1845 -1810
  53. package/dist/lib/{pgsql/PostgreSQLParserVisitor.js → postgresql/PostgreSqlParserVisitor.js} +4 -3
  54. package/dist/lib/spark/SparkSqlLexer.d.ts +305 -298
  55. package/dist/lib/spark/SparkSqlLexer.js +1777 -1735
  56. package/dist/lib/spark/SparkSqlParser.d.ts +1764 -669
  57. package/dist/lib/spark/SparkSqlParser.js +15460 -10769
  58. package/dist/lib/spark/SparkSqlParserListener.d.ts +1285 -35
  59. package/dist/lib/spark/SparkSqlParserVisitor.d.ts +790 -21
  60. package/dist/lib/spark/SparkSqlParserVisitor.js +1 -0
  61. package/dist/lib/{trinosql → trino}/TrinoSqlLexer.d.ts +2 -2
  62. package/dist/lib/{trinosql → trino}/TrinoSqlLexer.js +2 -1
  63. package/dist/lib/{trinosql → trino}/TrinoSqlListener.d.ts +7 -5
  64. package/dist/lib/{trinosql → trino}/TrinoSqlListener.js +1 -1
  65. package/dist/lib/{trinosql → trino}/TrinoSqlParser.d.ts +11 -5
  66. package/dist/lib/{trinosql → trino}/TrinoSqlParser.js +360 -320
  67. package/dist/lib/{trinosql → trino}/TrinoSqlVisitor.d.ts +4 -3
  68. package/dist/lib/{trinosql → trino}/TrinoSqlVisitor.js +2 -1
  69. package/dist/parser/common/{basicParser.d.ts → basicSQL.d.ts} +22 -19
  70. package/dist/parser/common/{basicParser.js → basicSQL.js} +52 -34
  71. package/dist/parser/common/entityCollector.d.ts +78 -0
  72. package/dist/parser/common/entityCollector.js +191 -0
  73. package/dist/parser/common/{utils/findCaretTokenIndex.d.ts → findCaretTokenIndex.d.ts} +2 -2
  74. package/dist/parser/common/{utils/findCaretTokenIndex.js → findCaretTokenIndex.js} +3 -2
  75. package/dist/parser/common/parseErrorListener.d.ts +6 -6
  76. package/dist/parser/common/parseErrorListener.js +1 -1
  77. package/dist/parser/common/simpleStack.d.ts +10 -0
  78. package/dist/parser/common/simpleStack.js +23 -0
  79. package/dist/parser/common/splitListener.d.ts +8 -0
  80. package/dist/parser/common/splitListener.js +12 -0
  81. package/dist/parser/common/textAndWord.d.ts +52 -0
  82. package/dist/parser/common/textAndWord.js +58 -0
  83. package/dist/parser/common/{basic-parser-types.d.ts → types.d.ts} +4 -31
  84. package/dist/parser/common/types.js +34 -0
  85. package/dist/parser/flink/flinkEntityCollector.d.ts +33 -0
  86. package/dist/parser/flink/flinkEntityCollector.js +84 -0
  87. package/dist/parser/flink/flinkSplitListener.d.ts +6 -0
  88. package/dist/parser/flink/flinkSplitListener.js +6 -0
  89. package/dist/parser/flink/index.d.ts +17 -0
  90. package/dist/parser/{flinksql.js → flink/index.js} +26 -37
  91. package/dist/parser/hive/hiveEntityCollector.d.ts +35 -0
  92. package/dist/parser/hive/hiveEntityCollector.js +90 -0
  93. package/dist/parser/hive/hiveSplitListener.d.ts +6 -0
  94. package/dist/parser/hive/hiveSplitListener.js +6 -0
  95. package/dist/parser/hive/index.d.ts +17 -0
  96. package/dist/parser/{hive.js → hive/index.js} +24 -34
  97. package/dist/parser/impala/impalaEntityCollector.d.ts +35 -0
  98. package/dist/parser/impala/impalaEntityCollector.js +90 -0
  99. package/dist/parser/impala/impalaSplitListener.d.ts +6 -0
  100. package/dist/parser/impala/impalaSplitListener.js +6 -0
  101. package/dist/parser/impala/index.d.ts +17 -0
  102. package/dist/parser/{impala.js → impala/index.js} +24 -34
  103. package/dist/parser/index.d.ts +8 -8
  104. package/dist/parser/index.js +8 -8
  105. package/dist/parser/mysql/index.d.ts +17 -0
  106. package/dist/parser/{mysql.js → mysql/index.js} +24 -34
  107. package/dist/parser/mysql/mysqlEntityCollector.d.ts +37 -0
  108. package/dist/parser/mysql/mysqlEntityCollector.js +96 -0
  109. package/dist/parser/mysql/mysqlSplitListener.d.ts +6 -0
  110. package/dist/parser/mysql/mysqlSplitListener.js +6 -0
  111. package/dist/parser/plsql.d.ts +7 -6
  112. package/dist/parser/plsql.js +6 -4
  113. package/dist/parser/postgresql/index.d.ts +17 -0
  114. package/dist/parser/postgresql/index.js +130 -0
  115. package/dist/parser/postgresql/postgreEntityCollector.d.ts +37 -0
  116. package/dist/parser/postgresql/postgreEntityCollector.js +96 -0
  117. package/dist/parser/postgresql/postgreSplitListener.d.ts +6 -0
  118. package/dist/parser/postgresql/postgreSplitListener.js +6 -0
  119. package/dist/parser/spark/index.d.ts +17 -0
  120. package/dist/parser/{spark.js → spark/index.js} +29 -40
  121. package/dist/parser/spark/sparkEntityCollector.d.ts +37 -0
  122. package/dist/parser/spark/sparkEntityCollector.js +96 -0
  123. package/dist/parser/spark/sparkSplitListener.d.ts +6 -0
  124. package/dist/parser/spark/sparkSplitListener.js +6 -0
  125. package/dist/parser/trino/index.d.ts +17 -0
  126. package/dist/parser/{trinosql.js → trino/index.js} +25 -36
  127. package/dist/parser/trino/trinoEntityCollector.d.ts +30 -0
  128. package/dist/parser/trino/trinoEntityCollector.js +75 -0
  129. package/dist/parser/trino/trinoSplitListener.d.ts +6 -0
  130. package/dist/parser/trino/trinoSplitListener.js +6 -0
  131. package/dist/utils/index.d.ts +1 -1
  132. package/dist/utils/token.d.ts +1 -1
  133. package/package.json +1 -1
  134. package/dist/parser/common/basic-parser-types.js +0 -34
  135. package/dist/parser/flinksql.d.ts +0 -23
  136. package/dist/parser/hive.d.ts +0 -23
  137. package/dist/parser/impala.d.ts +0 -23
  138. package/dist/parser/mysql.d.ts +0 -23
  139. package/dist/parser/pgsql.d.ts +0 -23
  140. package/dist/parser/pgsql.js +0 -140
  141. package/dist/parser/spark.d.ts +0 -23
  142. package/dist/parser/trinosql.d.ts +0 -23
@@ -1,625 +1,626 @@
1
- // Generated from dt-sql-parser/src/grammar/pgsql/PostgreSQLLexer.g4 by ANTLR 4.13.1
1
+ // Generated from dt-sql-parser/src/grammar/postgresql/PostgreSqlLexer.g4 by ANTLR 4.13.1
2
+ // @ts-nocheck
2
3
  import * as antlr from "antlr4ng";
3
- class PostgreSQLLexer extends antlr.Lexer {
4
+ class PostgreSqlLexer extends antlr.Lexer {
4
5
  constructor(input) {
5
6
  super(input);
6
- this.interpreter = new antlr.LexerATNSimulator(this, PostgreSQLLexer._ATN, PostgreSQLLexer.decisionsToDFA, new antlr.PredictionContextCache());
7
+ this.interpreter = new antlr.LexerATNSimulator(this, PostgreSqlLexer._ATN, PostgreSqlLexer.decisionsToDFA, new antlr.PredictionContextCache());
7
8
  }
8
- get grammarFileName() { return "PostgreSQLLexer.g4"; }
9
- get literalNames() { return PostgreSQLLexer.literalNames; }
10
- get symbolicNames() { return PostgreSQLLexer.symbolicNames; }
11
- get ruleNames() { return PostgreSQLLexer.ruleNames; }
12
- get serializedATN() { return PostgreSQLLexer._serializedATN; }
13
- get channelNames() { return PostgreSQLLexer.channelNames; }
14
- get modeNames() { return PostgreSQLLexer.modeNames; }
9
+ get grammarFileName() { return "PostgreSqlLexer.g4"; }
10
+ get literalNames() { return PostgreSqlLexer.literalNames; }
11
+ get symbolicNames() { return PostgreSqlLexer.symbolicNames; }
12
+ get ruleNames() { return PostgreSqlLexer.ruleNames; }
13
+ get serializedATN() { return PostgreSqlLexer._serializedATN; }
14
+ get channelNames() { return PostgreSqlLexer.channelNames; }
15
+ get modeNames() { return PostgreSqlLexer.modeNames; }
15
16
  static get _ATN() {
16
- if (!PostgreSQLLexer.__ATN) {
17
- PostgreSQLLexer.__ATN = new antlr.ATNDeserializer().deserialize(PostgreSQLLexer._serializedATN);
17
+ if (!PostgreSqlLexer.__ATN) {
18
+ PostgreSqlLexer.__ATN = new antlr.ATNDeserializer().deserialize(PostgreSqlLexer._serializedATN);
18
19
  }
19
- return PostgreSQLLexer.__ATN;
20
+ return PostgreSqlLexer.__ATN;
20
21
  }
21
22
  get vocabulary() {
22
- return PostgreSQLLexer.vocabulary;
23
+ return PostgreSqlLexer.vocabulary;
23
24
  }
24
25
  }
25
- PostgreSQLLexer.Dollar = 1;
26
- PostgreSQLLexer.OPEN_PAREN = 2;
27
- PostgreSQLLexer.CLOSE_PAREN = 3;
28
- PostgreSQLLexer.OPEN_BRACKET = 4;
29
- PostgreSQLLexer.CLOSE_BRACKET = 5;
30
- PostgreSQLLexer.COMMA = 6;
31
- PostgreSQLLexer.SEMI = 7;
32
- PostgreSQLLexer.COLON = 8;
33
- PostgreSQLLexer.STAR = 9;
34
- PostgreSQLLexer.EQUAL = 10;
35
- PostgreSQLLexer.DOT = 11;
36
- PostgreSQLLexer.PLUS = 12;
37
- PostgreSQLLexer.MINUS = 13;
38
- PostgreSQLLexer.SLASH = 14;
39
- PostgreSQLLexer.CARET = 15;
40
- PostgreSQLLexer.LT = 16;
41
- PostgreSQLLexer.GT = 17;
42
- PostgreSQLLexer.LESS_LESS = 18;
43
- PostgreSQLLexer.GREATER_GREATER = 19;
44
- PostgreSQLLexer.COLON_EQUALS = 20;
45
- PostgreSQLLexer.LESS_EQUALS = 21;
46
- PostgreSQLLexer.EQUALS_GREATER = 22;
47
- PostgreSQLLexer.GREATER_EQUALS = 23;
48
- PostgreSQLLexer.DOT_DOT = 24;
49
- PostgreSQLLexer.NOT_EQUALS = 25;
50
- PostgreSQLLexer.TYPECAST = 26;
51
- PostgreSQLLexer.PERCENT = 27;
52
- PostgreSQLLexer.PARAM = 28;
53
- PostgreSQLLexer.Operator = 29;
54
- PostgreSQLLexer.KW_ALL = 30;
55
- PostgreSQLLexer.KW_ANALYSE = 31;
56
- PostgreSQLLexer.KW_ANALYZE = 32;
57
- PostgreSQLLexer.KW_AND = 33;
58
- PostgreSQLLexer.KW_ANY = 34;
59
- PostgreSQLLexer.KW_ARRAY = 35;
60
- PostgreSQLLexer.KW_AS = 36;
61
- PostgreSQLLexer.KW_ASC = 37;
62
- PostgreSQLLexer.KW_ASYMMETRIC = 38;
63
- PostgreSQLLexer.KW_BOTH = 39;
64
- PostgreSQLLexer.KW_CASE = 40;
65
- PostgreSQLLexer.KW_CAST = 41;
66
- PostgreSQLLexer.KW_CHECK = 42;
67
- PostgreSQLLexer.KW_COLLATE = 43;
68
- PostgreSQLLexer.KW_COLUMN = 44;
69
- PostgreSQLLexer.KW_CONSTRAINT = 45;
70
- PostgreSQLLexer.KW_CREATE = 46;
71
- PostgreSQLLexer.KW_CURRENT_CATALOG = 47;
72
- PostgreSQLLexer.KW_CURRENT_DATE = 48;
73
- PostgreSQLLexer.KW_CURRENT_ROLE = 49;
74
- PostgreSQLLexer.KW_CURRENT_TIME = 50;
75
- PostgreSQLLexer.KW_CURRENT_TIMESTAMP = 51;
76
- PostgreSQLLexer.KW_CURRENT_USER = 52;
77
- PostgreSQLLexer.KW_DEFAULT = 53;
78
- PostgreSQLLexer.KW_DEFERRABLE = 54;
79
- PostgreSQLLexer.KW_DESC = 55;
80
- PostgreSQLLexer.KW_DISTINCT = 56;
81
- PostgreSQLLexer.KW_DO = 57;
82
- PostgreSQLLexer.KW_ELSE = 58;
83
- PostgreSQLLexer.KW_EXCEPT = 59;
84
- PostgreSQLLexer.KW_FALSE = 60;
85
- PostgreSQLLexer.KW_FETCH = 61;
86
- PostgreSQLLexer.KW_FOR = 62;
87
- PostgreSQLLexer.KW_FOREIGN = 63;
88
- PostgreSQLLexer.KW_FROM = 64;
89
- PostgreSQLLexer.KW_GRANT = 65;
90
- PostgreSQLLexer.KW_GROUP = 66;
91
- PostgreSQLLexer.KW_HAVING = 67;
92
- PostgreSQLLexer.KW_IN = 68;
93
- PostgreSQLLexer.KW_INITIALLY = 69;
94
- PostgreSQLLexer.KW_INTERSECT = 70;
95
- PostgreSQLLexer.KW_INTO = 71;
96
- PostgreSQLLexer.KW_LATERAL = 72;
97
- PostgreSQLLexer.KW_LEADING = 73;
98
- PostgreSQLLexer.KW_LIMIT = 74;
99
- PostgreSQLLexer.KW_LOCALTIME = 75;
100
- PostgreSQLLexer.KW_LOCALTIMESTAMP = 76;
101
- PostgreSQLLexer.KW_NOT = 77;
102
- PostgreSQLLexer.KW_NULL = 78;
103
- PostgreSQLLexer.KW_OFFSET = 79;
104
- PostgreSQLLexer.KW_ON = 80;
105
- PostgreSQLLexer.KW_ONLY = 81;
106
- PostgreSQLLexer.KW_OR = 82;
107
- PostgreSQLLexer.KW_ORDER = 83;
108
- PostgreSQLLexer.KW_PLACING = 84;
109
- PostgreSQLLexer.KW_PRIMARY = 85;
110
- PostgreSQLLexer.KW_REFERENCES = 86;
111
- PostgreSQLLexer.KW_RETURNING = 87;
112
- PostgreSQLLexer.KW_SELECT = 88;
113
- PostgreSQLLexer.KW_SESSION_USER = 89;
114
- PostgreSQLLexer.KW_SOME = 90;
115
- PostgreSQLLexer.KW_SYMMETRIC = 91;
116
- PostgreSQLLexer.KW_TABLE = 92;
117
- PostgreSQLLexer.KW_THEN = 93;
118
- PostgreSQLLexer.KW_TO = 94;
119
- PostgreSQLLexer.KW_TRAILING = 95;
120
- PostgreSQLLexer.KW_TRUE = 96;
121
- PostgreSQLLexer.KW_UNION = 97;
122
- PostgreSQLLexer.KW_UNIQUE = 98;
123
- PostgreSQLLexer.KW_USER = 99;
124
- PostgreSQLLexer.KW_USING = 100;
125
- PostgreSQLLexer.KW_VARIADIC = 101;
126
- PostgreSQLLexer.KW_WHEN = 102;
127
- PostgreSQLLexer.KW_WHERE = 103;
128
- PostgreSQLLexer.KW_WINDOW = 104;
129
- PostgreSQLLexer.KW_WITH = 105;
130
- PostgreSQLLexer.KW_AUTHORIZATION = 106;
131
- PostgreSQLLexer.KW_BINARY = 107;
132
- PostgreSQLLexer.KW_COLLATION = 108;
133
- PostgreSQLLexer.KW_CONCURRENTLY = 109;
134
- PostgreSQLLexer.KW_CROSS = 110;
135
- PostgreSQLLexer.KW_CURRENT_SCHEMA = 111;
136
- PostgreSQLLexer.KW_FREEZE = 112;
137
- PostgreSQLLexer.KW_FULL = 113;
138
- PostgreSQLLexer.KW_ILIKE = 114;
139
- PostgreSQLLexer.KW_INNER = 115;
140
- PostgreSQLLexer.KW_IS = 116;
141
- PostgreSQLLexer.KW_ISNULL = 117;
142
- PostgreSQLLexer.KW_JOIN = 118;
143
- PostgreSQLLexer.KW_LEFT = 119;
144
- PostgreSQLLexer.KW_LIKE = 120;
145
- PostgreSQLLexer.KW_NATURAL = 121;
146
- PostgreSQLLexer.KW_NOTNULL = 122;
147
- PostgreSQLLexer.KW_OUTER = 123;
148
- PostgreSQLLexer.KW_OVER = 124;
149
- PostgreSQLLexer.KW_OVERLAPS = 125;
150
- PostgreSQLLexer.KW_RIGHT = 126;
151
- PostgreSQLLexer.KW_SIMILAR = 127;
152
- PostgreSQLLexer.KW_VERBOSE = 128;
153
- PostgreSQLLexer.KW_ABORT = 129;
154
- PostgreSQLLexer.KW_ABSOLUTE = 130;
155
- PostgreSQLLexer.KW_ACCESS = 131;
156
- PostgreSQLLexer.KW_ACTION = 132;
157
- PostgreSQLLexer.KW_ADD = 133;
158
- PostgreSQLLexer.KW_ADMIN = 134;
159
- PostgreSQLLexer.KW_AFTER = 135;
160
- PostgreSQLLexer.KW_AGGREGATE = 136;
161
- PostgreSQLLexer.KW_ALSO = 137;
162
- PostgreSQLLexer.KW_ALTER = 138;
163
- PostgreSQLLexer.KW_ALWAYS = 139;
164
- PostgreSQLLexer.KW_ASSERTION = 140;
165
- PostgreSQLLexer.KW_ASSIGNMENT = 141;
166
- PostgreSQLLexer.KW_AT = 142;
167
- PostgreSQLLexer.KW_ATTRIBUTE = 143;
168
- PostgreSQLLexer.KW_BACKWARD = 144;
169
- PostgreSQLLexer.KW_BEFORE = 145;
170
- PostgreSQLLexer.KW_BEGIN = 146;
171
- PostgreSQLLexer.KW_BY = 147;
172
- PostgreSQLLexer.KW_CACHE = 148;
173
- PostgreSQLLexer.KW_CALLED = 149;
174
- PostgreSQLLexer.KW_CASCADE = 150;
175
- PostgreSQLLexer.KW_CASCADED = 151;
176
- PostgreSQLLexer.KW_CATALOG = 152;
177
- PostgreSQLLexer.KW_CHAIN = 153;
178
- PostgreSQLLexer.KW_CHARACTERISTICS = 154;
179
- PostgreSQLLexer.KW_CHECKPOINT = 155;
180
- PostgreSQLLexer.KW_CLASS = 156;
181
- PostgreSQLLexer.KW_CLOSE = 157;
182
- PostgreSQLLexer.KW_CLUSTER = 158;
183
- PostgreSQLLexer.KW_COMMENT = 159;
184
- PostgreSQLLexer.KW_COMMENTS = 160;
185
- PostgreSQLLexer.KW_COMMIT = 161;
186
- PostgreSQLLexer.KW_COMMITTED = 162;
187
- PostgreSQLLexer.KW_CONFIGURATION = 163;
188
- PostgreSQLLexer.KW_CONNECTION = 164;
189
- PostgreSQLLexer.KW_CONSTRAINTS = 165;
190
- PostgreSQLLexer.KW_CONTENT = 166;
191
- PostgreSQLLexer.KW_CONTINUE = 167;
192
- PostgreSQLLexer.KW_CONVERSION = 168;
193
- PostgreSQLLexer.KW_COPY = 169;
194
- PostgreSQLLexer.KW_COST = 170;
195
- PostgreSQLLexer.KW_CSV = 171;
196
- PostgreSQLLexer.KW_CURSOR = 172;
197
- PostgreSQLLexer.KW_CYCLE = 173;
198
- PostgreSQLLexer.KW_DATA = 174;
199
- PostgreSQLLexer.KW_DATABASE = 175;
200
- PostgreSQLLexer.KW_DAY = 176;
201
- PostgreSQLLexer.KW_DEALLOCATE = 177;
202
- PostgreSQLLexer.KW_DECLARE = 178;
203
- PostgreSQLLexer.KW_DEFAULTS = 179;
204
- PostgreSQLLexer.KW_DEFERRED = 180;
205
- PostgreSQLLexer.KW_DEFINER = 181;
206
- PostgreSQLLexer.KW_DELETE = 182;
207
- PostgreSQLLexer.KW_DELIMITER = 183;
208
- PostgreSQLLexer.KW_DELIMITERS = 184;
209
- PostgreSQLLexer.KW_DICTIONARY = 185;
210
- PostgreSQLLexer.KW_DISABLE = 186;
211
- PostgreSQLLexer.KW_DISCARD = 187;
212
- PostgreSQLLexer.KW_DOCUMENT = 188;
213
- PostgreSQLLexer.KW_DOMAIN = 189;
214
- PostgreSQLLexer.KW_DOUBLE = 190;
215
- PostgreSQLLexer.KW_DROP = 191;
216
- PostgreSQLLexer.KW_EACH = 192;
217
- PostgreSQLLexer.KW_ENABLE = 193;
218
- PostgreSQLLexer.KW_ENCODING = 194;
219
- PostgreSQLLexer.KW_ENCRYPTED = 195;
220
- PostgreSQLLexer.KW_ENUM = 196;
221
- PostgreSQLLexer.KW_ESCAPE = 197;
222
- PostgreSQLLexer.KW_EVENT = 198;
223
- PostgreSQLLexer.KW_EXCLUDE = 199;
224
- PostgreSQLLexer.KW_EXCLUDING = 200;
225
- PostgreSQLLexer.KW_EXCLUSIVE = 201;
226
- PostgreSQLLexer.KW_EXECUTE = 202;
227
- PostgreSQLLexer.KW_EXPLAIN = 203;
228
- PostgreSQLLexer.KW_EXTENSION = 204;
229
- PostgreSQLLexer.KW_EXTERNAL = 205;
230
- PostgreSQLLexer.KW_FAMILY = 206;
231
- PostgreSQLLexer.KW_FIRST = 207;
232
- PostgreSQLLexer.KW_FOLLOWING = 208;
233
- PostgreSQLLexer.KW_FORCE = 209;
234
- PostgreSQLLexer.KW_FORWARD = 210;
235
- PostgreSQLLexer.KW_FUNCTION = 211;
236
- PostgreSQLLexer.KW_FUNCTIONS = 212;
237
- PostgreSQLLexer.KW_GLOBAL = 213;
238
- PostgreSQLLexer.KW_GRANTED = 214;
239
- PostgreSQLLexer.KW_HANDLER = 215;
240
- PostgreSQLLexer.KW_HEADER = 216;
241
- PostgreSQLLexer.KW_HOLD = 217;
242
- PostgreSQLLexer.KW_HOUR = 218;
243
- PostgreSQLLexer.KW_IDENTITY = 219;
244
- PostgreSQLLexer.KW_IF = 220;
245
- PostgreSQLLexer.KW_IMMEDIATE = 221;
246
- PostgreSQLLexer.KW_IMMUTABLE = 222;
247
- PostgreSQLLexer.KW_IMPLICIT = 223;
248
- PostgreSQLLexer.KW_INCLUDING = 224;
249
- PostgreSQLLexer.KW_INCREMENT = 225;
250
- PostgreSQLLexer.KW_INDEX = 226;
251
- PostgreSQLLexer.KW_INDEXES = 227;
252
- PostgreSQLLexer.KW_INHERIT = 228;
253
- PostgreSQLLexer.KW_NOINHERIT = 229;
254
- PostgreSQLLexer.KW_SUPERUSER = 230;
255
- PostgreSQLLexer.KW_NOSUPERUSER = 231;
256
- PostgreSQLLexer.KW_CREATEDB = 232;
257
- PostgreSQLLexer.KW_NOCREATEDB = 233;
258
- PostgreSQLLexer.KW_CREATEROLE = 234;
259
- PostgreSQLLexer.KW_NOCREATEROLE = 235;
260
- PostgreSQLLexer.KW_CREATEUSER = 236;
261
- PostgreSQLLexer.KW_NOCREATEUSER = 237;
262
- PostgreSQLLexer.KW_INHERITS = 238;
263
- PostgreSQLLexer.KW_INLINE = 239;
264
- PostgreSQLLexer.KW_INSENSITIVE = 240;
265
- PostgreSQLLexer.KW_INSERT = 241;
266
- PostgreSQLLexer.KW_INSTEAD = 242;
267
- PostgreSQLLexer.KW_INVOKER = 243;
268
- PostgreSQLLexer.KW_ISOLATION = 244;
269
- PostgreSQLLexer.KW_KEY = 245;
270
- PostgreSQLLexer.KW_LABEL = 246;
271
- PostgreSQLLexer.KW_LANGUAGE = 247;
272
- PostgreSQLLexer.KW_LARGE = 248;
273
- PostgreSQLLexer.KW_LAST = 249;
274
- PostgreSQLLexer.KW_LEAKPROOF = 250;
275
- PostgreSQLLexer.KW_LEVEL = 251;
276
- PostgreSQLLexer.KW_LISTEN = 252;
277
- PostgreSQLLexer.KW_LOAD = 253;
278
- PostgreSQLLexer.KW_LOCAL = 254;
279
- PostgreSQLLexer.KW_LOCATION = 255;
280
- PostgreSQLLexer.KW_LOCK = 256;
281
- PostgreSQLLexer.KW_MAPPING = 257;
282
- PostgreSQLLexer.KW_MATCH = 258;
283
- PostgreSQLLexer.KW_MATERIALIZED = 259;
284
- PostgreSQLLexer.KW_MAXVALUE = 260;
285
- PostgreSQLLexer.KW_MINUTE = 261;
286
- PostgreSQLLexer.KW_MINVALUE = 262;
287
- PostgreSQLLexer.KW_MODE = 263;
288
- PostgreSQLLexer.KW_MONTH = 264;
289
- PostgreSQLLexer.KW_MOVE = 265;
290
- PostgreSQLLexer.KW_NAME = 266;
291
- PostgreSQLLexer.KW_NAMES = 267;
292
- PostgreSQLLexer.KW_NEXT = 268;
293
- PostgreSQLLexer.KW_NO = 269;
294
- PostgreSQLLexer.KW_NOTHING = 270;
295
- PostgreSQLLexer.KW_NOTIFY = 271;
296
- PostgreSQLLexer.KW_NOWAIT = 272;
297
- PostgreSQLLexer.KW_NULLS = 273;
298
- PostgreSQLLexer.KW_OBJECT = 274;
299
- PostgreSQLLexer.KW_OF = 275;
300
- PostgreSQLLexer.KW_OFF = 276;
301
- PostgreSQLLexer.KW_OIDS = 277;
302
- PostgreSQLLexer.KW_OPERATOR = 278;
303
- PostgreSQLLexer.KW_OPTION = 279;
304
- PostgreSQLLexer.KW_OPTIONS = 280;
305
- PostgreSQLLexer.KW_OWNED = 281;
306
- PostgreSQLLexer.KW_OWNER = 282;
307
- PostgreSQLLexer.KW_PARSER = 283;
308
- PostgreSQLLexer.KW_PARTIAL = 284;
309
- PostgreSQLLexer.KW_PARTITION = 285;
310
- PostgreSQLLexer.KW_PASSING = 286;
311
- PostgreSQLLexer.KW_PASSWORD = 287;
312
- PostgreSQLLexer.KW_PLANS = 288;
313
- PostgreSQLLexer.KW_PRECEDING = 289;
314
- PostgreSQLLexer.KW_PREPARE = 290;
315
- PostgreSQLLexer.KW_PREPARED = 291;
316
- PostgreSQLLexer.KW_PRESERVE = 292;
317
- PostgreSQLLexer.KW_PRIOR = 293;
318
- PostgreSQLLexer.KW_PRIVILEGES = 294;
319
- PostgreSQLLexer.KW_PROCEDURAL = 295;
320
- PostgreSQLLexer.KW_PROCEDURE = 296;
321
- PostgreSQLLexer.KW_PROGRAM = 297;
322
- PostgreSQLLexer.KW_QUOTE = 298;
323
- PostgreSQLLexer.KW_RANGE = 299;
324
- PostgreSQLLexer.KW_READ = 300;
325
- PostgreSQLLexer.KW_REASSIGN = 301;
326
- PostgreSQLLexer.KW_RECHECK = 302;
327
- PostgreSQLLexer.KW_RECURSIVE = 303;
328
- PostgreSQLLexer.KW_REF = 304;
329
- PostgreSQLLexer.KW_REFRESH = 305;
330
- PostgreSQLLexer.KW_REINDEX = 306;
331
- PostgreSQLLexer.KW_RELATIVE = 307;
332
- PostgreSQLLexer.KW_RELEASE = 308;
333
- PostgreSQLLexer.KW_RENAME = 309;
334
- PostgreSQLLexer.KW_REPEATABLE = 310;
335
- PostgreSQLLexer.KW_REPLACE = 311;
336
- PostgreSQLLexer.KW_REPLICA = 312;
337
- PostgreSQLLexer.KW_RESET = 313;
338
- PostgreSQLLexer.KW_RESTART = 314;
339
- PostgreSQLLexer.KW_RESTRICT = 315;
340
- PostgreSQLLexer.KW_RETURNS = 316;
341
- PostgreSQLLexer.KW_REVOKE = 317;
342
- PostgreSQLLexer.KW_ROLE = 318;
343
- PostgreSQLLexer.KW_ROLLBACK = 319;
344
- PostgreSQLLexer.KW_ROWS = 320;
345
- PostgreSQLLexer.KW_RULE = 321;
346
- PostgreSQLLexer.KW_SAVEPOINT = 322;
347
- PostgreSQLLexer.KW_SCHEMA = 323;
348
- PostgreSQLLexer.KW_SCROLL = 324;
349
- PostgreSQLLexer.KW_SEARCH = 325;
350
- PostgreSQLLexer.KW_SECOND = 326;
351
- PostgreSQLLexer.KW_SECURITY = 327;
352
- PostgreSQLLexer.KW_SEQUENCE = 328;
353
- PostgreSQLLexer.KW_SEQUENCES = 329;
354
- PostgreSQLLexer.KW_SERIALIZABLE = 330;
355
- PostgreSQLLexer.KW_SERVER = 331;
356
- PostgreSQLLexer.KW_SESSION = 332;
357
- PostgreSQLLexer.KW_SET = 333;
358
- PostgreSQLLexer.KW_SHARE = 334;
359
- PostgreSQLLexer.KW_SHOW = 335;
360
- PostgreSQLLexer.KW_SIMPLE = 336;
361
- PostgreSQLLexer.KW_SNAPSHOT = 337;
362
- PostgreSQLLexer.KW_STABLE = 338;
363
- PostgreSQLLexer.KW_STANDALONE = 339;
364
- PostgreSQLLexer.KW_START = 340;
365
- PostgreSQLLexer.KW_STATEMENT = 341;
366
- PostgreSQLLexer.KW_STATISTICS = 342;
367
- PostgreSQLLexer.KW_STDIN = 343;
368
- PostgreSQLLexer.KW_STDOUT = 344;
369
- PostgreSQLLexer.KW_STORAGE = 345;
370
- PostgreSQLLexer.KW_STRICT = 346;
371
- PostgreSQLLexer.KW_STRIP = 347;
372
- PostgreSQLLexer.KW_SYSID = 348;
373
- PostgreSQLLexer.KW_SYSTEM = 349;
374
- PostgreSQLLexer.KW_TABLES = 350;
375
- PostgreSQLLexer.KW_TABLESPACE = 351;
376
- PostgreSQLLexer.KW_TEMP = 352;
377
- PostgreSQLLexer.KW_TEMPLATE = 353;
378
- PostgreSQLLexer.KW_TEMPORARY = 354;
379
- PostgreSQLLexer.KW_TEXT = 355;
380
- PostgreSQLLexer.KW_TRANSACTION = 356;
381
- PostgreSQLLexer.KW_TRIGGER = 357;
382
- PostgreSQLLexer.KW_TRUNCATE = 358;
383
- PostgreSQLLexer.KW_TRUSTED = 359;
384
- PostgreSQLLexer.KW_TYPE = 360;
385
- PostgreSQLLexer.KW_TYPES = 361;
386
- PostgreSQLLexer.KW_UNBOUNDED = 362;
387
- PostgreSQLLexer.KW_UNCOMMITTED = 363;
388
- PostgreSQLLexer.KW_UNENCRYPTED = 364;
389
- PostgreSQLLexer.KW_UNKNOWN = 365;
390
- PostgreSQLLexer.KW_UNLISTEN = 366;
391
- PostgreSQLLexer.KW_UNLOGGED = 367;
392
- PostgreSQLLexer.KW_UNTIL = 368;
393
- PostgreSQLLexer.KW_UPDATE = 369;
394
- PostgreSQLLexer.KW_VACUUM = 370;
395
- PostgreSQLLexer.KW_VALID = 371;
396
- PostgreSQLLexer.KW_VALIDATE = 372;
397
- PostgreSQLLexer.KW_VALIDATOR = 373;
398
- PostgreSQLLexer.KW_VARYING = 374;
399
- PostgreSQLLexer.KW_VERSION = 375;
400
- PostgreSQLLexer.KW_VIEW = 376;
401
- PostgreSQLLexer.KW_VOLATILE = 377;
402
- PostgreSQLLexer.KW_WHITESPACE = 378;
403
- PostgreSQLLexer.KW_WITHOUT = 379;
404
- PostgreSQLLexer.KW_WORK = 380;
405
- PostgreSQLLexer.KW_WRAPPER = 381;
406
- PostgreSQLLexer.KW_WRITE = 382;
407
- PostgreSQLLexer.KW_XML = 383;
408
- PostgreSQLLexer.KW_YEAR = 384;
409
- PostgreSQLLexer.KW_YES = 385;
410
- PostgreSQLLexer.KW_ZONE = 386;
411
- PostgreSQLLexer.KW_BETWEEN = 387;
412
- PostgreSQLLexer.KW_BIGINT = 388;
413
- PostgreSQLLexer.KW_BIT = 389;
414
- PostgreSQLLexer.KW_BOOLEAN = 390;
415
- PostgreSQLLexer.KW_CHAR = 391;
416
- PostgreSQLLexer.KW_CHARACTER = 392;
417
- PostgreSQLLexer.KW_COALESCE = 393;
418
- PostgreSQLLexer.KW_DEC = 394;
419
- PostgreSQLLexer.KW_DECIMAL = 395;
420
- PostgreSQLLexer.KW_EXISTS = 396;
421
- PostgreSQLLexer.KW_EXTRACT = 397;
422
- PostgreSQLLexer.KW_FLOAT = 398;
423
- PostgreSQLLexer.KW_GREATEST = 399;
424
- PostgreSQLLexer.KW_INOUT = 400;
425
- PostgreSQLLexer.KW_INT = 401;
426
- PostgreSQLLexer.KW_INTEGER = 402;
427
- PostgreSQLLexer.KW_INTERVAL = 403;
428
- PostgreSQLLexer.KW_LEAST = 404;
429
- PostgreSQLLexer.KW_NATIONAL = 405;
430
- PostgreSQLLexer.KW_NCHAR = 406;
431
- PostgreSQLLexer.KW_NONE = 407;
432
- PostgreSQLLexer.KW_NULLIF = 408;
433
- PostgreSQLLexer.KW_NUMERIC = 409;
434
- PostgreSQLLexer.KW_OVERLAY = 410;
435
- PostgreSQLLexer.KW_POSITION = 411;
436
- PostgreSQLLexer.KW_PRECISION = 412;
437
- PostgreSQLLexer.KW_REAL = 413;
438
- PostgreSQLLexer.KW_ROW = 414;
439
- PostgreSQLLexer.KW_SETOF = 415;
440
- PostgreSQLLexer.KW_SMALLINT = 416;
441
- PostgreSQLLexer.KW_SUBSTRING = 417;
442
- PostgreSQLLexer.KW_TIME = 418;
443
- PostgreSQLLexer.KW_TIMESTAMP = 419;
444
- PostgreSQLLexer.KW_TREAT = 420;
445
- PostgreSQLLexer.KW_TRIM = 421;
446
- PostgreSQLLexer.KW_VALUES = 422;
447
- PostgreSQLLexer.KW_VARCHAR = 423;
448
- PostgreSQLLexer.KW_XMLATTRIBUTES = 424;
449
- PostgreSQLLexer.KW_XMLCONCAT = 425;
450
- PostgreSQLLexer.KW_XMLELEMENT = 426;
451
- PostgreSQLLexer.KW_XMLEXISTS = 427;
452
- PostgreSQLLexer.KW_XMLFOREST = 428;
453
- PostgreSQLLexer.KW_XMLPARSE = 429;
454
- PostgreSQLLexer.KW_XMLPI = 430;
455
- PostgreSQLLexer.KW_XMLROOT = 431;
456
- PostgreSQLLexer.KW_XMLSERIALIZE = 432;
457
- PostgreSQLLexer.KW_CALL = 433;
458
- PostgreSQLLexer.KW_CURRENT = 434;
459
- PostgreSQLLexer.KW_ATTACH = 435;
460
- PostgreSQLLexer.KW_DETACH = 436;
461
- PostgreSQLLexer.KW_EXPRESSION = 437;
462
- PostgreSQLLexer.KW_GENERATED = 438;
463
- PostgreSQLLexer.KW_LOGGED = 439;
464
- PostgreSQLLexer.KW_STORED = 440;
465
- PostgreSQLLexer.KW_INCLUDE = 441;
466
- PostgreSQLLexer.KW_ROUTINE = 442;
467
- PostgreSQLLexer.KW_TRANSFORM = 443;
468
- PostgreSQLLexer.KW_IMPORT = 444;
469
- PostgreSQLLexer.KW_POLICY = 445;
470
- PostgreSQLLexer.KW_METHOD = 446;
471
- PostgreSQLLexer.KW_REFERENCING = 447;
472
- PostgreSQLLexer.KW_NEW = 448;
473
- PostgreSQLLexer.KW_OLD = 449;
474
- PostgreSQLLexer.KW_VALUE = 450;
475
- PostgreSQLLexer.KW_SUBSCRIPTION = 451;
476
- PostgreSQLLexer.KW_PUBLICATION = 452;
477
- PostgreSQLLexer.KW_OUT = 453;
478
- PostgreSQLLexer.KW_END = 454;
479
- PostgreSQLLexer.KW_ROUTINES = 455;
480
- PostgreSQLLexer.KW_SCHEMAS = 456;
481
- PostgreSQLLexer.KW_PROCEDURES = 457;
482
- PostgreSQLLexer.KW_INPUT = 458;
483
- PostgreSQLLexer.KW_SUPPORT = 459;
484
- PostgreSQLLexer.KW_PARALLEL = 460;
485
- PostgreSQLLexer.KW_SQL = 461;
486
- PostgreSQLLexer.KW_DEPENDS = 462;
487
- PostgreSQLLexer.KW_OVERRIDING = 463;
488
- PostgreSQLLexer.KW_CONFLICT = 464;
489
- PostgreSQLLexer.KW_SKIP = 465;
490
- PostgreSQLLexer.KW_LOCKED = 466;
491
- PostgreSQLLexer.KW_TIES = 467;
492
- PostgreSQLLexer.KW_ROLLUP = 468;
493
- PostgreSQLLexer.KW_CUBE = 469;
494
- PostgreSQLLexer.KW_GROUPING = 470;
495
- PostgreSQLLexer.KW_SETS = 471;
496
- PostgreSQLLexer.KW_TABLESAMPLE = 472;
497
- PostgreSQLLexer.KW_ORDINALITY = 473;
498
- PostgreSQLLexer.KW_XMLTABLE = 474;
499
- PostgreSQLLexer.KW_COLUMNS = 475;
500
- PostgreSQLLexer.KW_XMLNAMESPACES = 476;
501
- PostgreSQLLexer.KW_ROWTYPE = 477;
502
- PostgreSQLLexer.KW_NORMALIZED = 478;
503
- PostgreSQLLexer.KW_WITHIN = 479;
504
- PostgreSQLLexer.KW_FILTER = 480;
505
- PostgreSQLLexer.KW_GROUPS = 481;
506
- PostgreSQLLexer.KW_OTHERS = 482;
507
- PostgreSQLLexer.KW_NFC = 483;
508
- PostgreSQLLexer.KW_NFD = 484;
509
- PostgreSQLLexer.KW_NFKC = 485;
510
- PostgreSQLLexer.KW_NFKD = 486;
511
- PostgreSQLLexer.KW_UESCAPE = 487;
512
- PostgreSQLLexer.KW_VIEWS = 488;
513
- PostgreSQLLexer.KW_NORMALIZE = 489;
514
- PostgreSQLLexer.KW_DUMP = 490;
515
- PostgreSQLLexer.KW_PRINT_STRICT_PARAMS = 491;
516
- PostgreSQLLexer.KW_VARIABLE_CONFLICT = 492;
517
- PostgreSQLLexer.KW_ERROR = 493;
518
- PostgreSQLLexer.KW_USE_VARIABLE = 494;
519
- PostgreSQLLexer.KW_USE_COLUMN = 495;
520
- PostgreSQLLexer.KW_ALIAS = 496;
521
- PostgreSQLLexer.KW_CONSTANT = 497;
522
- PostgreSQLLexer.KW_PERFORM = 498;
523
- PostgreSQLLexer.KW_GET = 499;
524
- PostgreSQLLexer.KW_DIAGNOSTICS = 500;
525
- PostgreSQLLexer.KW_STACKED = 501;
526
- PostgreSQLLexer.KW_ELSIF = 502;
527
- PostgreSQLLexer.KW_WHILE = 503;
528
- PostgreSQLLexer.KW_REVERSE = 504;
529
- PostgreSQLLexer.KW_FOREACH = 505;
530
- PostgreSQLLexer.KW_SLICE = 506;
531
- PostgreSQLLexer.KW_EXIT = 507;
532
- PostgreSQLLexer.KW_RETURN = 508;
533
- PostgreSQLLexer.KW_QUERY = 509;
534
- PostgreSQLLexer.KW_RAISE = 510;
535
- PostgreSQLLexer.KW_SQLSTATE = 511;
536
- PostgreSQLLexer.KW_DEBUG = 512;
537
- PostgreSQLLexer.KW_LOG = 513;
538
- PostgreSQLLexer.KW_INFO = 514;
539
- PostgreSQLLexer.KW_NOTICE = 515;
540
- PostgreSQLLexer.KW_WARNING = 516;
541
- PostgreSQLLexer.KW_EXCEPTION = 517;
542
- PostgreSQLLexer.KW_ASSERT = 518;
543
- PostgreSQLLexer.KW_LOOP = 519;
544
- PostgreSQLLexer.KW_OPEN = 520;
545
- PostgreSQLLexer.KW_PEFERENCES = 521;
546
- PostgreSQLLexer.KW_USAGE = 522;
547
- PostgreSQLLexer.KW_CONNECT = 523;
548
- PostgreSQLLexer.KW_PUBLIC = 524;
549
- PostgreSQLLexer.KW_MERGE = 525;
550
- PostgreSQLLexer.KW_MATCHED = 526;
551
- PostgreSQLLexer.KW_BREADTH = 527;
552
- PostgreSQLLexer.KW_DEPTH = 528;
553
- PostgreSQLLexer.KW_UNSAFE = 529;
554
- PostgreSQLLexer.KW_RESTRICTED = 530;
555
- PostgreSQLLexer.KW_SAFE = 531;
556
- PostgreSQLLexer.KW_FINALIZE = 532;
557
- PostgreSQLLexer.KW_MODULUS = 533;
558
- PostgreSQLLexer.KW_REMAINDER = 534;
559
- PostgreSQLLexer.KW_LOGIN = 535;
560
- PostgreSQLLexer.KW_NOLOGIN = 536;
561
- PostgreSQLLexer.KW_REPLICATION = 537;
562
- PostgreSQLLexer.KW_NOREPLICATION = 538;
563
- PostgreSQLLexer.KW_BYPASSRLS = 539;
564
- PostgreSQLLexer.KW_NOBYPASSRLS = 540;
565
- PostgreSQLLexer.KW_PERMISSIVE = 541;
566
- PostgreSQLLexer.KW_RESTRICTIVE = 542;
567
- PostgreSQLLexer.KW_COMPRESSION = 543;
568
- PostgreSQLLexer.KW_PLAIN = 544;
569
- PostgreSQLLexer.KW_EXTENDED = 545;
570
- PostgreSQLLexer.KW_MAIN = 546;
571
- PostgreSQLLexer.KW_SKIP_LOCKED = 547;
572
- PostgreSQLLexer.KW_BUFFER_USAGE_LIMIT = 548;
573
- PostgreSQLLexer.Identifier = 549;
574
- PostgreSQLLexer.QuotedIdentifier = 550;
575
- PostgreSQLLexer.UnterminatedQuotedIdentifier = 551;
576
- PostgreSQLLexer.InvalidQuotedIdentifier = 552;
577
- PostgreSQLLexer.InvalidUnterminatedQuotedIdentifier = 553;
578
- PostgreSQLLexer.UnicodeQuotedIdentifier = 554;
579
- PostgreSQLLexer.UnterminatedUnicodeQuotedIdentifier = 555;
580
- PostgreSQLLexer.InvalidUnicodeQuotedIdentifier = 556;
581
- PostgreSQLLexer.InvalidUnterminatedUnicodeQuotedIdentifier = 557;
582
- PostgreSQLLexer.StringConstant = 558;
583
- PostgreSQLLexer.UnterminatedStringConstant = 559;
584
- PostgreSQLLexer.UnicodeEscapeStringConstant = 560;
585
- PostgreSQLLexer.UnterminatedUnicodeEscapeStringConstant = 561;
586
- PostgreSQLLexer.BeginDollarStringConstant = 562;
587
- PostgreSQLLexer.BinaryStringConstant = 563;
588
- PostgreSQLLexer.UnterminatedBinaryStringConstant = 564;
589
- PostgreSQLLexer.InvalidBinaryStringConstant = 565;
590
- PostgreSQLLexer.InvalidUnterminatedBinaryStringConstant = 566;
591
- PostgreSQLLexer.HexadecimalStringConstant = 567;
592
- PostgreSQLLexer.UnterminatedHexadecimalStringConstant = 568;
593
- PostgreSQLLexer.InvalidHexadecimalStringConstant = 569;
594
- PostgreSQLLexer.InvalidUnterminatedHexadecimalStringConstant = 570;
595
- PostgreSQLLexer.Integral = 571;
596
- PostgreSQLLexer.NumericFail = 572;
597
- PostgreSQLLexer.Numeric = 573;
598
- PostgreSQLLexer.PLSQLVARIABLENAME = 574;
599
- PostgreSQLLexer.PLSQLIDENTIFIER = 575;
600
- PostgreSQLLexer.Whitespace = 576;
601
- PostgreSQLLexer.Newline = 577;
602
- PostgreSQLLexer.LineComment = 578;
603
- PostgreSQLLexer.BlockComment = 579;
604
- PostgreSQLLexer.UnterminatedBlockComment = 580;
605
- PostgreSQLLexer.MetaCommand = 581;
606
- PostgreSQLLexer.EndMetaCommand = 582;
607
- PostgreSQLLexer.ErrorCharacter = 583;
608
- PostgreSQLLexer.EscapeStringConstant = 584;
609
- PostgreSQLLexer.UnterminatedEscapeStringConstant = 585;
610
- PostgreSQLLexer.InvalidEscapeStringConstant = 586;
611
- PostgreSQLLexer.InvalidUnterminatedEscapeStringConstant = 587;
612
- PostgreSQLLexer.DollarText = 588;
613
- PostgreSQLLexer.EndDollarStringConstant = 589;
614
- PostgreSQLLexer.AfterEscapeStringConstantWithNewlineMode_Continued = 590;
615
- PostgreSQLLexer.EscapeStringConstantMode = 1;
616
- PostgreSQLLexer.AfterEscapeStringConstantMode = 2;
617
- PostgreSQLLexer.AfterEscapeStringConstantWithNewlineMode = 3;
618
- PostgreSQLLexer.DollarQuotedStringMode = 4;
619
- PostgreSQLLexer.channelNames = [
26
+ PostgreSqlLexer.Dollar = 1;
27
+ PostgreSqlLexer.OPEN_PAREN = 2;
28
+ PostgreSqlLexer.CLOSE_PAREN = 3;
29
+ PostgreSqlLexer.OPEN_BRACKET = 4;
30
+ PostgreSqlLexer.CLOSE_BRACKET = 5;
31
+ PostgreSqlLexer.COMMA = 6;
32
+ PostgreSqlLexer.SEMI = 7;
33
+ PostgreSqlLexer.COLON = 8;
34
+ PostgreSqlLexer.STAR = 9;
35
+ PostgreSqlLexer.EQUAL = 10;
36
+ PostgreSqlLexer.DOT = 11;
37
+ PostgreSqlLexer.PLUS = 12;
38
+ PostgreSqlLexer.MINUS = 13;
39
+ PostgreSqlLexer.SLASH = 14;
40
+ PostgreSqlLexer.CARET = 15;
41
+ PostgreSqlLexer.LT = 16;
42
+ PostgreSqlLexer.GT = 17;
43
+ PostgreSqlLexer.LESS_LESS = 18;
44
+ PostgreSqlLexer.GREATER_GREATER = 19;
45
+ PostgreSqlLexer.COLON_EQUALS = 20;
46
+ PostgreSqlLexer.LESS_EQUALS = 21;
47
+ PostgreSqlLexer.EQUALS_GREATER = 22;
48
+ PostgreSqlLexer.GREATER_EQUALS = 23;
49
+ PostgreSqlLexer.DOT_DOT = 24;
50
+ PostgreSqlLexer.NOT_EQUALS = 25;
51
+ PostgreSqlLexer.TYPECAST = 26;
52
+ PostgreSqlLexer.PERCENT = 27;
53
+ PostgreSqlLexer.PARAM = 28;
54
+ PostgreSqlLexer.Operator = 29;
55
+ PostgreSqlLexer.KW_ALL = 30;
56
+ PostgreSqlLexer.KW_ANALYSE = 31;
57
+ PostgreSqlLexer.KW_ANALYZE = 32;
58
+ PostgreSqlLexer.KW_AND = 33;
59
+ PostgreSqlLexer.KW_ANY = 34;
60
+ PostgreSqlLexer.KW_ARRAY = 35;
61
+ PostgreSqlLexer.KW_AS = 36;
62
+ PostgreSqlLexer.KW_ASC = 37;
63
+ PostgreSqlLexer.KW_ASYMMETRIC = 38;
64
+ PostgreSqlLexer.KW_BOTH = 39;
65
+ PostgreSqlLexer.KW_CASE = 40;
66
+ PostgreSqlLexer.KW_CAST = 41;
67
+ PostgreSqlLexer.KW_CHECK = 42;
68
+ PostgreSqlLexer.KW_COLLATE = 43;
69
+ PostgreSqlLexer.KW_COLUMN = 44;
70
+ PostgreSqlLexer.KW_CONSTRAINT = 45;
71
+ PostgreSqlLexer.KW_CREATE = 46;
72
+ PostgreSqlLexer.KW_CURRENT_CATALOG = 47;
73
+ PostgreSqlLexer.KW_CURRENT_DATE = 48;
74
+ PostgreSqlLexer.KW_CURRENT_ROLE = 49;
75
+ PostgreSqlLexer.KW_CURRENT_TIME = 50;
76
+ PostgreSqlLexer.KW_CURRENT_TIMESTAMP = 51;
77
+ PostgreSqlLexer.KW_CURRENT_USER = 52;
78
+ PostgreSqlLexer.KW_DEFAULT = 53;
79
+ PostgreSqlLexer.KW_DEFERRABLE = 54;
80
+ PostgreSqlLexer.KW_DESC = 55;
81
+ PostgreSqlLexer.KW_DISTINCT = 56;
82
+ PostgreSqlLexer.KW_DO = 57;
83
+ PostgreSqlLexer.KW_ELSE = 58;
84
+ PostgreSqlLexer.KW_EXCEPT = 59;
85
+ PostgreSqlLexer.KW_FALSE = 60;
86
+ PostgreSqlLexer.KW_FETCH = 61;
87
+ PostgreSqlLexer.KW_FOR = 62;
88
+ PostgreSqlLexer.KW_FOREIGN = 63;
89
+ PostgreSqlLexer.KW_FROM = 64;
90
+ PostgreSqlLexer.KW_GRANT = 65;
91
+ PostgreSqlLexer.KW_GROUP = 66;
92
+ PostgreSqlLexer.KW_HAVING = 67;
93
+ PostgreSqlLexer.KW_IN = 68;
94
+ PostgreSqlLexer.KW_INITIALLY = 69;
95
+ PostgreSqlLexer.KW_INTERSECT = 70;
96
+ PostgreSqlLexer.KW_INTO = 71;
97
+ PostgreSqlLexer.KW_LATERAL = 72;
98
+ PostgreSqlLexer.KW_LEADING = 73;
99
+ PostgreSqlLexer.KW_LIMIT = 74;
100
+ PostgreSqlLexer.KW_LOCALTIME = 75;
101
+ PostgreSqlLexer.KW_LOCALTIMESTAMP = 76;
102
+ PostgreSqlLexer.KW_NOT = 77;
103
+ PostgreSqlLexer.KW_NULL = 78;
104
+ PostgreSqlLexer.KW_OFFSET = 79;
105
+ PostgreSqlLexer.KW_ON = 80;
106
+ PostgreSqlLexer.KW_ONLY = 81;
107
+ PostgreSqlLexer.KW_OR = 82;
108
+ PostgreSqlLexer.KW_ORDER = 83;
109
+ PostgreSqlLexer.KW_PLACING = 84;
110
+ PostgreSqlLexer.KW_PRIMARY = 85;
111
+ PostgreSqlLexer.KW_REFERENCES = 86;
112
+ PostgreSqlLexer.KW_RETURNING = 87;
113
+ PostgreSqlLexer.KW_SELECT = 88;
114
+ PostgreSqlLexer.KW_SESSION_USER = 89;
115
+ PostgreSqlLexer.KW_SOME = 90;
116
+ PostgreSqlLexer.KW_SYMMETRIC = 91;
117
+ PostgreSqlLexer.KW_TABLE = 92;
118
+ PostgreSqlLexer.KW_THEN = 93;
119
+ PostgreSqlLexer.KW_TO = 94;
120
+ PostgreSqlLexer.KW_TRAILING = 95;
121
+ PostgreSqlLexer.KW_TRUE = 96;
122
+ PostgreSqlLexer.KW_UNION = 97;
123
+ PostgreSqlLexer.KW_UNIQUE = 98;
124
+ PostgreSqlLexer.KW_USER = 99;
125
+ PostgreSqlLexer.KW_USING = 100;
126
+ PostgreSqlLexer.KW_VARIADIC = 101;
127
+ PostgreSqlLexer.KW_WHEN = 102;
128
+ PostgreSqlLexer.KW_WHERE = 103;
129
+ PostgreSqlLexer.KW_WINDOW = 104;
130
+ PostgreSqlLexer.KW_WITH = 105;
131
+ PostgreSqlLexer.KW_AUTHORIZATION = 106;
132
+ PostgreSqlLexer.KW_BINARY = 107;
133
+ PostgreSqlLexer.KW_COLLATION = 108;
134
+ PostgreSqlLexer.KW_CONCURRENTLY = 109;
135
+ PostgreSqlLexer.KW_CROSS = 110;
136
+ PostgreSqlLexer.KW_CURRENT_SCHEMA = 111;
137
+ PostgreSqlLexer.KW_FREEZE = 112;
138
+ PostgreSqlLexer.KW_FULL = 113;
139
+ PostgreSqlLexer.KW_ILIKE = 114;
140
+ PostgreSqlLexer.KW_INNER = 115;
141
+ PostgreSqlLexer.KW_IS = 116;
142
+ PostgreSqlLexer.KW_ISNULL = 117;
143
+ PostgreSqlLexer.KW_JOIN = 118;
144
+ PostgreSqlLexer.KW_LEFT = 119;
145
+ PostgreSqlLexer.KW_LIKE = 120;
146
+ PostgreSqlLexer.KW_NATURAL = 121;
147
+ PostgreSqlLexer.KW_NOTNULL = 122;
148
+ PostgreSqlLexer.KW_OUTER = 123;
149
+ PostgreSqlLexer.KW_OVER = 124;
150
+ PostgreSqlLexer.KW_OVERLAPS = 125;
151
+ PostgreSqlLexer.KW_RIGHT = 126;
152
+ PostgreSqlLexer.KW_SIMILAR = 127;
153
+ PostgreSqlLexer.KW_VERBOSE = 128;
154
+ PostgreSqlLexer.KW_ABORT = 129;
155
+ PostgreSqlLexer.KW_ABSOLUTE = 130;
156
+ PostgreSqlLexer.KW_ACCESS = 131;
157
+ PostgreSqlLexer.KW_ACTION = 132;
158
+ PostgreSqlLexer.KW_ADD = 133;
159
+ PostgreSqlLexer.KW_ADMIN = 134;
160
+ PostgreSqlLexer.KW_AFTER = 135;
161
+ PostgreSqlLexer.KW_AGGREGATE = 136;
162
+ PostgreSqlLexer.KW_ALSO = 137;
163
+ PostgreSqlLexer.KW_ALTER = 138;
164
+ PostgreSqlLexer.KW_ALWAYS = 139;
165
+ PostgreSqlLexer.KW_ASSERTION = 140;
166
+ PostgreSqlLexer.KW_ASSIGNMENT = 141;
167
+ PostgreSqlLexer.KW_AT = 142;
168
+ PostgreSqlLexer.KW_ATTRIBUTE = 143;
169
+ PostgreSqlLexer.KW_BACKWARD = 144;
170
+ PostgreSqlLexer.KW_BEFORE = 145;
171
+ PostgreSqlLexer.KW_BEGIN = 146;
172
+ PostgreSqlLexer.KW_BY = 147;
173
+ PostgreSqlLexer.KW_CACHE = 148;
174
+ PostgreSqlLexer.KW_CALLED = 149;
175
+ PostgreSqlLexer.KW_CASCADE = 150;
176
+ PostgreSqlLexer.KW_CASCADED = 151;
177
+ PostgreSqlLexer.KW_CATALOG = 152;
178
+ PostgreSqlLexer.KW_CHAIN = 153;
179
+ PostgreSqlLexer.KW_CHARACTERISTICS = 154;
180
+ PostgreSqlLexer.KW_CHECKPOINT = 155;
181
+ PostgreSqlLexer.KW_CLASS = 156;
182
+ PostgreSqlLexer.KW_CLOSE = 157;
183
+ PostgreSqlLexer.KW_CLUSTER = 158;
184
+ PostgreSqlLexer.KW_COMMENT = 159;
185
+ PostgreSqlLexer.KW_COMMENTS = 160;
186
+ PostgreSqlLexer.KW_COMMIT = 161;
187
+ PostgreSqlLexer.KW_COMMITTED = 162;
188
+ PostgreSqlLexer.KW_CONFIGURATION = 163;
189
+ PostgreSqlLexer.KW_CONNECTION = 164;
190
+ PostgreSqlLexer.KW_CONSTRAINTS = 165;
191
+ PostgreSqlLexer.KW_CONTENT = 166;
192
+ PostgreSqlLexer.KW_CONTINUE = 167;
193
+ PostgreSqlLexer.KW_CONVERSION = 168;
194
+ PostgreSqlLexer.KW_COPY = 169;
195
+ PostgreSqlLexer.KW_COST = 170;
196
+ PostgreSqlLexer.KW_CSV = 171;
197
+ PostgreSqlLexer.KW_CURSOR = 172;
198
+ PostgreSqlLexer.KW_CYCLE = 173;
199
+ PostgreSqlLexer.KW_DATA = 174;
200
+ PostgreSqlLexer.KW_DATABASE = 175;
201
+ PostgreSqlLexer.KW_DAY = 176;
202
+ PostgreSqlLexer.KW_DEALLOCATE = 177;
203
+ PostgreSqlLexer.KW_DECLARE = 178;
204
+ PostgreSqlLexer.KW_DEFAULTS = 179;
205
+ PostgreSqlLexer.KW_DEFERRED = 180;
206
+ PostgreSqlLexer.KW_DEFINER = 181;
207
+ PostgreSqlLexer.KW_DELETE = 182;
208
+ PostgreSqlLexer.KW_DELIMITER = 183;
209
+ PostgreSqlLexer.KW_DELIMITERS = 184;
210
+ PostgreSqlLexer.KW_DICTIONARY = 185;
211
+ PostgreSqlLexer.KW_DISABLE = 186;
212
+ PostgreSqlLexer.KW_DISCARD = 187;
213
+ PostgreSqlLexer.KW_DOCUMENT = 188;
214
+ PostgreSqlLexer.KW_DOMAIN = 189;
215
+ PostgreSqlLexer.KW_DOUBLE = 190;
216
+ PostgreSqlLexer.KW_DROP = 191;
217
+ PostgreSqlLexer.KW_EACH = 192;
218
+ PostgreSqlLexer.KW_ENABLE = 193;
219
+ PostgreSqlLexer.KW_ENCODING = 194;
220
+ PostgreSqlLexer.KW_ENCRYPTED = 195;
221
+ PostgreSqlLexer.KW_ENUM = 196;
222
+ PostgreSqlLexer.KW_ESCAPE = 197;
223
+ PostgreSqlLexer.KW_EVENT = 198;
224
+ PostgreSqlLexer.KW_EXCLUDE = 199;
225
+ PostgreSqlLexer.KW_EXCLUDING = 200;
226
+ PostgreSqlLexer.KW_EXCLUSIVE = 201;
227
+ PostgreSqlLexer.KW_EXECUTE = 202;
228
+ PostgreSqlLexer.KW_EXPLAIN = 203;
229
+ PostgreSqlLexer.KW_EXTENSION = 204;
230
+ PostgreSqlLexer.KW_EXTERNAL = 205;
231
+ PostgreSqlLexer.KW_FAMILY = 206;
232
+ PostgreSqlLexer.KW_FIRST = 207;
233
+ PostgreSqlLexer.KW_FOLLOWING = 208;
234
+ PostgreSqlLexer.KW_FORCE = 209;
235
+ PostgreSqlLexer.KW_FORWARD = 210;
236
+ PostgreSqlLexer.KW_FUNCTION = 211;
237
+ PostgreSqlLexer.KW_FUNCTIONS = 212;
238
+ PostgreSqlLexer.KW_GLOBAL = 213;
239
+ PostgreSqlLexer.KW_GRANTED = 214;
240
+ PostgreSqlLexer.KW_HANDLER = 215;
241
+ PostgreSqlLexer.KW_HEADER = 216;
242
+ PostgreSqlLexer.KW_HOLD = 217;
243
+ PostgreSqlLexer.KW_HOUR = 218;
244
+ PostgreSqlLexer.KW_IDENTITY = 219;
245
+ PostgreSqlLexer.KW_IF = 220;
246
+ PostgreSqlLexer.KW_IMMEDIATE = 221;
247
+ PostgreSqlLexer.KW_IMMUTABLE = 222;
248
+ PostgreSqlLexer.KW_IMPLICIT = 223;
249
+ PostgreSqlLexer.KW_INCLUDING = 224;
250
+ PostgreSqlLexer.KW_INCREMENT = 225;
251
+ PostgreSqlLexer.KW_INDEX = 226;
252
+ PostgreSqlLexer.KW_INDEXES = 227;
253
+ PostgreSqlLexer.KW_INHERIT = 228;
254
+ PostgreSqlLexer.KW_NOINHERIT = 229;
255
+ PostgreSqlLexer.KW_SUPERUSER = 230;
256
+ PostgreSqlLexer.KW_NOSUPERUSER = 231;
257
+ PostgreSqlLexer.KW_CREATEDB = 232;
258
+ PostgreSqlLexer.KW_NOCREATEDB = 233;
259
+ PostgreSqlLexer.KW_CREATEROLE = 234;
260
+ PostgreSqlLexer.KW_NOCREATEROLE = 235;
261
+ PostgreSqlLexer.KW_CREATEUSER = 236;
262
+ PostgreSqlLexer.KW_NOCREATEUSER = 237;
263
+ PostgreSqlLexer.KW_INHERITS = 238;
264
+ PostgreSqlLexer.KW_INLINE = 239;
265
+ PostgreSqlLexer.KW_INSENSITIVE = 240;
266
+ PostgreSqlLexer.KW_INSERT = 241;
267
+ PostgreSqlLexer.KW_INSTEAD = 242;
268
+ PostgreSqlLexer.KW_INVOKER = 243;
269
+ PostgreSqlLexer.KW_ISOLATION = 244;
270
+ PostgreSqlLexer.KW_KEY = 245;
271
+ PostgreSqlLexer.KW_LABEL = 246;
272
+ PostgreSqlLexer.KW_LANGUAGE = 247;
273
+ PostgreSqlLexer.KW_LARGE = 248;
274
+ PostgreSqlLexer.KW_LAST = 249;
275
+ PostgreSqlLexer.KW_LEAKPROOF = 250;
276
+ PostgreSqlLexer.KW_LEVEL = 251;
277
+ PostgreSqlLexer.KW_LISTEN = 252;
278
+ PostgreSqlLexer.KW_LOAD = 253;
279
+ PostgreSqlLexer.KW_LOCAL = 254;
280
+ PostgreSqlLexer.KW_LOCATION = 255;
281
+ PostgreSqlLexer.KW_LOCK = 256;
282
+ PostgreSqlLexer.KW_MAPPING = 257;
283
+ PostgreSqlLexer.KW_MATCH = 258;
284
+ PostgreSqlLexer.KW_MATERIALIZED = 259;
285
+ PostgreSqlLexer.KW_MAXVALUE = 260;
286
+ PostgreSqlLexer.KW_MINUTE = 261;
287
+ PostgreSqlLexer.KW_MINVALUE = 262;
288
+ PostgreSqlLexer.KW_MODE = 263;
289
+ PostgreSqlLexer.KW_MONTH = 264;
290
+ PostgreSqlLexer.KW_MOVE = 265;
291
+ PostgreSqlLexer.KW_NAME = 266;
292
+ PostgreSqlLexer.KW_NAMES = 267;
293
+ PostgreSqlLexer.KW_NEXT = 268;
294
+ PostgreSqlLexer.KW_NO = 269;
295
+ PostgreSqlLexer.KW_NOTHING = 270;
296
+ PostgreSqlLexer.KW_NOTIFY = 271;
297
+ PostgreSqlLexer.KW_NOWAIT = 272;
298
+ PostgreSqlLexer.KW_NULLS = 273;
299
+ PostgreSqlLexer.KW_OBJECT = 274;
300
+ PostgreSqlLexer.KW_OF = 275;
301
+ PostgreSqlLexer.KW_OFF = 276;
302
+ PostgreSqlLexer.KW_OIDS = 277;
303
+ PostgreSqlLexer.KW_OPERATOR = 278;
304
+ PostgreSqlLexer.KW_OPTION = 279;
305
+ PostgreSqlLexer.KW_OPTIONS = 280;
306
+ PostgreSqlLexer.KW_OWNED = 281;
307
+ PostgreSqlLexer.KW_OWNER = 282;
308
+ PostgreSqlLexer.KW_PARSER = 283;
309
+ PostgreSqlLexer.KW_PARTIAL = 284;
310
+ PostgreSqlLexer.KW_PARTITION = 285;
311
+ PostgreSqlLexer.KW_PASSING = 286;
312
+ PostgreSqlLexer.KW_PASSWORD = 287;
313
+ PostgreSqlLexer.KW_PLANS = 288;
314
+ PostgreSqlLexer.KW_PRECEDING = 289;
315
+ PostgreSqlLexer.KW_PREPARE = 290;
316
+ PostgreSqlLexer.KW_PREPARED = 291;
317
+ PostgreSqlLexer.KW_PRESERVE = 292;
318
+ PostgreSqlLexer.KW_PRIOR = 293;
319
+ PostgreSqlLexer.KW_PRIVILEGES = 294;
320
+ PostgreSqlLexer.KW_PROCEDURAL = 295;
321
+ PostgreSqlLexer.KW_PROCEDURE = 296;
322
+ PostgreSqlLexer.KW_PROGRAM = 297;
323
+ PostgreSqlLexer.KW_QUOTE = 298;
324
+ PostgreSqlLexer.KW_RANGE = 299;
325
+ PostgreSqlLexer.KW_READ = 300;
326
+ PostgreSqlLexer.KW_REASSIGN = 301;
327
+ PostgreSqlLexer.KW_RECHECK = 302;
328
+ PostgreSqlLexer.KW_RECURSIVE = 303;
329
+ PostgreSqlLexer.KW_REF = 304;
330
+ PostgreSqlLexer.KW_REFRESH = 305;
331
+ PostgreSqlLexer.KW_REINDEX = 306;
332
+ PostgreSqlLexer.KW_RELATIVE = 307;
333
+ PostgreSqlLexer.KW_RELEASE = 308;
334
+ PostgreSqlLexer.KW_RENAME = 309;
335
+ PostgreSqlLexer.KW_REPEATABLE = 310;
336
+ PostgreSqlLexer.KW_REPLACE = 311;
337
+ PostgreSqlLexer.KW_REPLICA = 312;
338
+ PostgreSqlLexer.KW_RESET = 313;
339
+ PostgreSqlLexer.KW_RESTART = 314;
340
+ PostgreSqlLexer.KW_RESTRICT = 315;
341
+ PostgreSqlLexer.KW_RETURNS = 316;
342
+ PostgreSqlLexer.KW_REVOKE = 317;
343
+ PostgreSqlLexer.KW_ROLE = 318;
344
+ PostgreSqlLexer.KW_ROLLBACK = 319;
345
+ PostgreSqlLexer.KW_ROWS = 320;
346
+ PostgreSqlLexer.KW_RULE = 321;
347
+ PostgreSqlLexer.KW_SAVEPOINT = 322;
348
+ PostgreSqlLexer.KW_SCHEMA = 323;
349
+ PostgreSqlLexer.KW_SCROLL = 324;
350
+ PostgreSqlLexer.KW_SEARCH = 325;
351
+ PostgreSqlLexer.KW_SECOND = 326;
352
+ PostgreSqlLexer.KW_SECURITY = 327;
353
+ PostgreSqlLexer.KW_SEQUENCE = 328;
354
+ PostgreSqlLexer.KW_SEQUENCES = 329;
355
+ PostgreSqlLexer.KW_SERIALIZABLE = 330;
356
+ PostgreSqlLexer.KW_SERVER = 331;
357
+ PostgreSqlLexer.KW_SESSION = 332;
358
+ PostgreSqlLexer.KW_SET = 333;
359
+ PostgreSqlLexer.KW_SHARE = 334;
360
+ PostgreSqlLexer.KW_SHOW = 335;
361
+ PostgreSqlLexer.KW_SIMPLE = 336;
362
+ PostgreSqlLexer.KW_SNAPSHOT = 337;
363
+ PostgreSqlLexer.KW_STABLE = 338;
364
+ PostgreSqlLexer.KW_STANDALONE = 339;
365
+ PostgreSqlLexer.KW_START = 340;
366
+ PostgreSqlLexer.KW_STATEMENT = 341;
367
+ PostgreSqlLexer.KW_STATISTICS = 342;
368
+ PostgreSqlLexer.KW_STDIN = 343;
369
+ PostgreSqlLexer.KW_STDOUT = 344;
370
+ PostgreSqlLexer.KW_STORAGE = 345;
371
+ PostgreSqlLexer.KW_STRICT = 346;
372
+ PostgreSqlLexer.KW_STRIP = 347;
373
+ PostgreSqlLexer.KW_SYSID = 348;
374
+ PostgreSqlLexer.KW_SYSTEM = 349;
375
+ PostgreSqlLexer.KW_TABLES = 350;
376
+ PostgreSqlLexer.KW_TABLESPACE = 351;
377
+ PostgreSqlLexer.KW_TEMP = 352;
378
+ PostgreSqlLexer.KW_TEMPLATE = 353;
379
+ PostgreSqlLexer.KW_TEMPORARY = 354;
380
+ PostgreSqlLexer.KW_TEXT = 355;
381
+ PostgreSqlLexer.KW_TRANSACTION = 356;
382
+ PostgreSqlLexer.KW_TRIGGER = 357;
383
+ PostgreSqlLexer.KW_TRUNCATE = 358;
384
+ PostgreSqlLexer.KW_TRUSTED = 359;
385
+ PostgreSqlLexer.KW_TYPE = 360;
386
+ PostgreSqlLexer.KW_TYPES = 361;
387
+ PostgreSqlLexer.KW_UNBOUNDED = 362;
388
+ PostgreSqlLexer.KW_UNCOMMITTED = 363;
389
+ PostgreSqlLexer.KW_UNENCRYPTED = 364;
390
+ PostgreSqlLexer.KW_UNKNOWN = 365;
391
+ PostgreSqlLexer.KW_UNLISTEN = 366;
392
+ PostgreSqlLexer.KW_UNLOGGED = 367;
393
+ PostgreSqlLexer.KW_UNTIL = 368;
394
+ PostgreSqlLexer.KW_UPDATE = 369;
395
+ PostgreSqlLexer.KW_VACUUM = 370;
396
+ PostgreSqlLexer.KW_VALID = 371;
397
+ PostgreSqlLexer.KW_VALIDATE = 372;
398
+ PostgreSqlLexer.KW_VALIDATOR = 373;
399
+ PostgreSqlLexer.KW_VARYING = 374;
400
+ PostgreSqlLexer.KW_VERSION = 375;
401
+ PostgreSqlLexer.KW_VIEW = 376;
402
+ PostgreSqlLexer.KW_VOLATILE = 377;
403
+ PostgreSqlLexer.KW_WHITESPACE = 378;
404
+ PostgreSqlLexer.KW_WITHOUT = 379;
405
+ PostgreSqlLexer.KW_WORK = 380;
406
+ PostgreSqlLexer.KW_WRAPPER = 381;
407
+ PostgreSqlLexer.KW_WRITE = 382;
408
+ PostgreSqlLexer.KW_XML = 383;
409
+ PostgreSqlLexer.KW_YEAR = 384;
410
+ PostgreSqlLexer.KW_YES = 385;
411
+ PostgreSqlLexer.KW_ZONE = 386;
412
+ PostgreSqlLexer.KW_BETWEEN = 387;
413
+ PostgreSqlLexer.KW_BIGINT = 388;
414
+ PostgreSqlLexer.KW_BIT = 389;
415
+ PostgreSqlLexer.KW_BOOLEAN = 390;
416
+ PostgreSqlLexer.KW_CHAR = 391;
417
+ PostgreSqlLexer.KW_CHARACTER = 392;
418
+ PostgreSqlLexer.KW_COALESCE = 393;
419
+ PostgreSqlLexer.KW_DEC = 394;
420
+ PostgreSqlLexer.KW_DECIMAL = 395;
421
+ PostgreSqlLexer.KW_EXISTS = 396;
422
+ PostgreSqlLexer.KW_EXTRACT = 397;
423
+ PostgreSqlLexer.KW_FLOAT = 398;
424
+ PostgreSqlLexer.KW_GREATEST = 399;
425
+ PostgreSqlLexer.KW_INOUT = 400;
426
+ PostgreSqlLexer.KW_INT = 401;
427
+ PostgreSqlLexer.KW_INTEGER = 402;
428
+ PostgreSqlLexer.KW_INTERVAL = 403;
429
+ PostgreSqlLexer.KW_LEAST = 404;
430
+ PostgreSqlLexer.KW_NATIONAL = 405;
431
+ PostgreSqlLexer.KW_NCHAR = 406;
432
+ PostgreSqlLexer.KW_NONE = 407;
433
+ PostgreSqlLexer.KW_NULLIF = 408;
434
+ PostgreSqlLexer.KW_NUMERIC = 409;
435
+ PostgreSqlLexer.KW_OVERLAY = 410;
436
+ PostgreSqlLexer.KW_POSITION = 411;
437
+ PostgreSqlLexer.KW_PRECISION = 412;
438
+ PostgreSqlLexer.KW_REAL = 413;
439
+ PostgreSqlLexer.KW_ROW = 414;
440
+ PostgreSqlLexer.KW_SETOF = 415;
441
+ PostgreSqlLexer.KW_SMALLINT = 416;
442
+ PostgreSqlLexer.KW_SUBSTRING = 417;
443
+ PostgreSqlLexer.KW_TIME = 418;
444
+ PostgreSqlLexer.KW_TIMESTAMP = 419;
445
+ PostgreSqlLexer.KW_TREAT = 420;
446
+ PostgreSqlLexer.KW_TRIM = 421;
447
+ PostgreSqlLexer.KW_VALUES = 422;
448
+ PostgreSqlLexer.KW_VARCHAR = 423;
449
+ PostgreSqlLexer.KW_XMLATTRIBUTES = 424;
450
+ PostgreSqlLexer.KW_XMLCONCAT = 425;
451
+ PostgreSqlLexer.KW_XMLELEMENT = 426;
452
+ PostgreSqlLexer.KW_XMLEXISTS = 427;
453
+ PostgreSqlLexer.KW_XMLFOREST = 428;
454
+ PostgreSqlLexer.KW_XMLPARSE = 429;
455
+ PostgreSqlLexer.KW_XMLPI = 430;
456
+ PostgreSqlLexer.KW_XMLROOT = 431;
457
+ PostgreSqlLexer.KW_XMLSERIALIZE = 432;
458
+ PostgreSqlLexer.KW_CALL = 433;
459
+ PostgreSqlLexer.KW_CURRENT = 434;
460
+ PostgreSqlLexer.KW_ATTACH = 435;
461
+ PostgreSqlLexer.KW_DETACH = 436;
462
+ PostgreSqlLexer.KW_EXPRESSION = 437;
463
+ PostgreSqlLexer.KW_GENERATED = 438;
464
+ PostgreSqlLexer.KW_LOGGED = 439;
465
+ PostgreSqlLexer.KW_STORED = 440;
466
+ PostgreSqlLexer.KW_INCLUDE = 441;
467
+ PostgreSqlLexer.KW_ROUTINE = 442;
468
+ PostgreSqlLexer.KW_TRANSFORM = 443;
469
+ PostgreSqlLexer.KW_IMPORT = 444;
470
+ PostgreSqlLexer.KW_POLICY = 445;
471
+ PostgreSqlLexer.KW_METHOD = 446;
472
+ PostgreSqlLexer.KW_REFERENCING = 447;
473
+ PostgreSqlLexer.KW_NEW = 448;
474
+ PostgreSqlLexer.KW_OLD = 449;
475
+ PostgreSqlLexer.KW_VALUE = 450;
476
+ PostgreSqlLexer.KW_SUBSCRIPTION = 451;
477
+ PostgreSqlLexer.KW_PUBLICATION = 452;
478
+ PostgreSqlLexer.KW_OUT = 453;
479
+ PostgreSqlLexer.KW_END = 454;
480
+ PostgreSqlLexer.KW_ROUTINES = 455;
481
+ PostgreSqlLexer.KW_SCHEMAS = 456;
482
+ PostgreSqlLexer.KW_PROCEDURES = 457;
483
+ PostgreSqlLexer.KW_INPUT = 458;
484
+ PostgreSqlLexer.KW_SUPPORT = 459;
485
+ PostgreSqlLexer.KW_PARALLEL = 460;
486
+ PostgreSqlLexer.KW_SQL = 461;
487
+ PostgreSqlLexer.KW_DEPENDS = 462;
488
+ PostgreSqlLexer.KW_OVERRIDING = 463;
489
+ PostgreSqlLexer.KW_CONFLICT = 464;
490
+ PostgreSqlLexer.KW_SKIP = 465;
491
+ PostgreSqlLexer.KW_LOCKED = 466;
492
+ PostgreSqlLexer.KW_TIES = 467;
493
+ PostgreSqlLexer.KW_ROLLUP = 468;
494
+ PostgreSqlLexer.KW_CUBE = 469;
495
+ PostgreSqlLexer.KW_GROUPING = 470;
496
+ PostgreSqlLexer.KW_SETS = 471;
497
+ PostgreSqlLexer.KW_TABLESAMPLE = 472;
498
+ PostgreSqlLexer.KW_ORDINALITY = 473;
499
+ PostgreSqlLexer.KW_XMLTABLE = 474;
500
+ PostgreSqlLexer.KW_COLUMNS = 475;
501
+ PostgreSqlLexer.KW_XMLNAMESPACES = 476;
502
+ PostgreSqlLexer.KW_ROWTYPE = 477;
503
+ PostgreSqlLexer.KW_NORMALIZED = 478;
504
+ PostgreSqlLexer.KW_WITHIN = 479;
505
+ PostgreSqlLexer.KW_FILTER = 480;
506
+ PostgreSqlLexer.KW_GROUPS = 481;
507
+ PostgreSqlLexer.KW_OTHERS = 482;
508
+ PostgreSqlLexer.KW_NFC = 483;
509
+ PostgreSqlLexer.KW_NFD = 484;
510
+ PostgreSqlLexer.KW_NFKC = 485;
511
+ PostgreSqlLexer.KW_NFKD = 486;
512
+ PostgreSqlLexer.KW_UESCAPE = 487;
513
+ PostgreSqlLexer.KW_VIEWS = 488;
514
+ PostgreSqlLexer.KW_NORMALIZE = 489;
515
+ PostgreSqlLexer.KW_DUMP = 490;
516
+ PostgreSqlLexer.KW_PRINT_STRICT_PARAMS = 491;
517
+ PostgreSqlLexer.KW_VARIABLE_CONFLICT = 492;
518
+ PostgreSqlLexer.KW_ERROR = 493;
519
+ PostgreSqlLexer.KW_USE_VARIABLE = 494;
520
+ PostgreSqlLexer.KW_USE_COLUMN = 495;
521
+ PostgreSqlLexer.KW_ALIAS = 496;
522
+ PostgreSqlLexer.KW_CONSTANT = 497;
523
+ PostgreSqlLexer.KW_PERFORM = 498;
524
+ PostgreSqlLexer.KW_GET = 499;
525
+ PostgreSqlLexer.KW_DIAGNOSTICS = 500;
526
+ PostgreSqlLexer.KW_STACKED = 501;
527
+ PostgreSqlLexer.KW_ELSIF = 502;
528
+ PostgreSqlLexer.KW_WHILE = 503;
529
+ PostgreSqlLexer.KW_REVERSE = 504;
530
+ PostgreSqlLexer.KW_FOREACH = 505;
531
+ PostgreSqlLexer.KW_SLICE = 506;
532
+ PostgreSqlLexer.KW_EXIT = 507;
533
+ PostgreSqlLexer.KW_RETURN = 508;
534
+ PostgreSqlLexer.KW_QUERY = 509;
535
+ PostgreSqlLexer.KW_RAISE = 510;
536
+ PostgreSqlLexer.KW_SQLSTATE = 511;
537
+ PostgreSqlLexer.KW_DEBUG = 512;
538
+ PostgreSqlLexer.KW_LOG = 513;
539
+ PostgreSqlLexer.KW_INFO = 514;
540
+ PostgreSqlLexer.KW_NOTICE = 515;
541
+ PostgreSqlLexer.KW_WARNING = 516;
542
+ PostgreSqlLexer.KW_EXCEPTION = 517;
543
+ PostgreSqlLexer.KW_ASSERT = 518;
544
+ PostgreSqlLexer.KW_LOOP = 519;
545
+ PostgreSqlLexer.KW_OPEN = 520;
546
+ PostgreSqlLexer.KW_PEFERENCES = 521;
547
+ PostgreSqlLexer.KW_USAGE = 522;
548
+ PostgreSqlLexer.KW_CONNECT = 523;
549
+ PostgreSqlLexer.KW_PUBLIC = 524;
550
+ PostgreSqlLexer.KW_MERGE = 525;
551
+ PostgreSqlLexer.KW_MATCHED = 526;
552
+ PostgreSqlLexer.KW_BREADTH = 527;
553
+ PostgreSqlLexer.KW_DEPTH = 528;
554
+ PostgreSqlLexer.KW_UNSAFE = 529;
555
+ PostgreSqlLexer.KW_RESTRICTED = 530;
556
+ PostgreSqlLexer.KW_SAFE = 531;
557
+ PostgreSqlLexer.KW_FINALIZE = 532;
558
+ PostgreSqlLexer.KW_MODULUS = 533;
559
+ PostgreSqlLexer.KW_REMAINDER = 534;
560
+ PostgreSqlLexer.KW_LOGIN = 535;
561
+ PostgreSqlLexer.KW_NOLOGIN = 536;
562
+ PostgreSqlLexer.KW_REPLICATION = 537;
563
+ PostgreSqlLexer.KW_NOREPLICATION = 538;
564
+ PostgreSqlLexer.KW_BYPASSRLS = 539;
565
+ PostgreSqlLexer.KW_NOBYPASSRLS = 540;
566
+ PostgreSqlLexer.KW_PERMISSIVE = 541;
567
+ PostgreSqlLexer.KW_RESTRICTIVE = 542;
568
+ PostgreSqlLexer.KW_COMPRESSION = 543;
569
+ PostgreSqlLexer.KW_PLAIN = 544;
570
+ PostgreSqlLexer.KW_EXTENDED = 545;
571
+ PostgreSqlLexer.KW_MAIN = 546;
572
+ PostgreSqlLexer.KW_SKIP_LOCKED = 547;
573
+ PostgreSqlLexer.KW_BUFFER_USAGE_LIMIT = 548;
574
+ PostgreSqlLexer.Identifier = 549;
575
+ PostgreSqlLexer.QuotedIdentifier = 550;
576
+ PostgreSqlLexer.UnterminatedQuotedIdentifier = 551;
577
+ PostgreSqlLexer.InvalidQuotedIdentifier = 552;
578
+ PostgreSqlLexer.InvalidUnterminatedQuotedIdentifier = 553;
579
+ PostgreSqlLexer.UnicodeQuotedIdentifier = 554;
580
+ PostgreSqlLexer.UnterminatedUnicodeQuotedIdentifier = 555;
581
+ PostgreSqlLexer.InvalidUnicodeQuotedIdentifier = 556;
582
+ PostgreSqlLexer.InvalidUnterminatedUnicodeQuotedIdentifier = 557;
583
+ PostgreSqlLexer.StringConstant = 558;
584
+ PostgreSqlLexer.UnterminatedStringConstant = 559;
585
+ PostgreSqlLexer.UnicodeEscapeStringConstant = 560;
586
+ PostgreSqlLexer.UnterminatedUnicodeEscapeStringConstant = 561;
587
+ PostgreSqlLexer.BeginDollarStringConstant = 562;
588
+ PostgreSqlLexer.BinaryStringConstant = 563;
589
+ PostgreSqlLexer.UnterminatedBinaryStringConstant = 564;
590
+ PostgreSqlLexer.InvalidBinaryStringConstant = 565;
591
+ PostgreSqlLexer.InvalidUnterminatedBinaryStringConstant = 566;
592
+ PostgreSqlLexer.HexadecimalStringConstant = 567;
593
+ PostgreSqlLexer.UnterminatedHexadecimalStringConstant = 568;
594
+ PostgreSqlLexer.InvalidHexadecimalStringConstant = 569;
595
+ PostgreSqlLexer.InvalidUnterminatedHexadecimalStringConstant = 570;
596
+ PostgreSqlLexer.Integral = 571;
597
+ PostgreSqlLexer.NumericFail = 572;
598
+ PostgreSqlLexer.Numeric = 573;
599
+ PostgreSqlLexer.PLSQLVARIABLENAME = 574;
600
+ PostgreSqlLexer.PLSQLIDENTIFIER = 575;
601
+ PostgreSqlLexer.Whitespace = 576;
602
+ PostgreSqlLexer.Newline = 577;
603
+ PostgreSqlLexer.LineComment = 578;
604
+ PostgreSqlLexer.BlockComment = 579;
605
+ PostgreSqlLexer.UnterminatedBlockComment = 580;
606
+ PostgreSqlLexer.MetaCommand = 581;
607
+ PostgreSqlLexer.EndMetaCommand = 582;
608
+ PostgreSqlLexer.ErrorCharacter = 583;
609
+ PostgreSqlLexer.EscapeStringConstant = 584;
610
+ PostgreSqlLexer.UnterminatedEscapeStringConstant = 585;
611
+ PostgreSqlLexer.InvalidEscapeStringConstant = 586;
612
+ PostgreSqlLexer.InvalidUnterminatedEscapeStringConstant = 587;
613
+ PostgreSqlLexer.DollarText = 588;
614
+ PostgreSqlLexer.EndDollarStringConstant = 589;
615
+ PostgreSqlLexer.AfterEscapeStringConstantWithNewlineMode_Continued = 590;
616
+ PostgreSqlLexer.EscapeStringConstantMode = 1;
617
+ PostgreSqlLexer.AfterEscapeStringConstantMode = 2;
618
+ PostgreSqlLexer.AfterEscapeStringConstantWithNewlineMode = 3;
619
+ PostgreSqlLexer.DollarQuotedStringMode = 4;
620
+ PostgreSqlLexer.channelNames = [
620
621
  "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
621
622
  ];
622
- PostgreSQLLexer.literalNames = [
623
+ PostgreSqlLexer.literalNames = [
623
624
  null, "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'*'",
624
625
  "'='", "'.'", "'+'", "'-'", "'/'", "'^'", "'<'", "'>'", "'<<'",
625
626
  "'>>'", "':='", "'<='", "'=>'", "'>='", "'..'", "'<>'", "'::'",
@@ -723,7 +724,7 @@ PostgreSQLLexer.literalNames = [
723
724
  null, null, null, null, "'\\\\'", null, null, null, null, null,
724
725
  null, null, "'''"
725
726
  ];
726
- PostgreSQLLexer.symbolicNames = [
727
+ PostgreSqlLexer.symbolicNames = [
727
728
  null, "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET",
728
729
  "COMMA", "SEMI", "COLON", "STAR", "EQUAL", "DOT", "PLUS", "MINUS",
729
730
  "SLASH", "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS",
@@ -846,11 +847,11 @@ PostgreSQLLexer.symbolicNames = [
846
847
  "InvalidUnterminatedEscapeStringConstant", "DollarText", "EndDollarStringConstant",
847
848
  "AfterEscapeStringConstantWithNewlineMode_Continued"
848
849
  ];
849
- PostgreSQLLexer.modeNames = [
850
+ PostgreSqlLexer.modeNames = [
850
851
  "DEFAULT_MODE", "EscapeStringConstantMode", "AfterEscapeStringConstantMode",
851
852
  "AfterEscapeStringConstantWithNewlineMode", "DollarQuotedStringMode",
852
853
  ];
853
- PostgreSQLLexer.ruleNames = [
854
+ PostgreSqlLexer.ruleNames = [
854
855
  "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET",
855
856
  "COMMA", "SEMI", "COLON", "STAR", "EQUAL", "DOT", "PLUS", "MINUS",
856
857
  "SLASH", "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS",
@@ -979,7 +980,7 @@ PostgreSQLLexer.ruleNames = [
979
980
  "AfterEscapeStringConstantWithNewlineMode_Newline", "AfterEscapeStringConstantWithNewlineMode_Continued",
980
981
  "DollarText", "EndDollarStringConstant",
981
982
  ];
982
- PostgreSQLLexer._serializedATN = [
983
+ PostgreSqlLexer._serializedATN = [
983
984
  4, 0, 590, 5802, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2,
984
985
  3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10,
985
986
  2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17,
@@ -3214,6 +3215,6 @@ PostgreSQLLexer._serializedATN = [
3214
3215
  5789, 5792, 5796, 11, 7, 29, 0, 3, 0, 0, 5, 1, 0, 5, 4, 0, 0, 1, 0, 2, 2, 0, 7, 576, 0, 7,
3215
3216
  577, 0, 2, 3, 0, 2, 1, 0, 4, 0, 0
3216
3217
  ];
3217
- PostgreSQLLexer.vocabulary = new antlr.Vocabulary(PostgreSQLLexer.literalNames, PostgreSQLLexer.symbolicNames, []);
3218
- PostgreSQLLexer.decisionsToDFA = PostgreSQLLexer._ATN.decisionToState.map((ds, index) => new antlr.DFA(ds, index));
3219
- export { PostgreSQLLexer };
3218
+ PostgreSqlLexer.vocabulary = new antlr.Vocabulary(PostgreSqlLexer.literalNames, PostgreSqlLexer.symbolicNames, []);
3219
+ PostgreSqlLexer.decisionsToDFA = PostgreSqlLexer._ATN.decisionToState.map((ds, index) => new antlr.DFA(ds, index));
3220
+ export { PostgreSqlLexer };