/src/tdengine/src/query/src/sql.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | ** 2000-05-29 |
3 | | ** |
4 | | ** The author disclaims copyright to this source code. In place of |
5 | | ** a legal notice, here is a blessing: |
6 | | ** |
7 | | ** May you do good and not evil. |
8 | | ** May you find forgiveness for yourself and forgive others. |
9 | | ** May you share freely, never taking more than you give. |
10 | | ** |
11 | | ************************************************************************* |
12 | | ** Driver template for the LEMON parser generator. |
13 | | ** |
14 | | ** The "lemon" program processes an LALR(1) input grammar file, then uses |
15 | | ** this template to construct a parser. The "lemon" program inserts text |
16 | | ** at each "%%" line. Also, any "P-a-r-s-e" identifer prefix (without the |
17 | | ** interstitial "-" characters) contained in this template is changed into |
18 | | ** the value of the %name directive from the grammar. Otherwise, the content |
19 | | ** of this template is copied straight through into the generate parser |
20 | | ** source file. |
21 | | ** |
22 | | ** The following is the concatenation of all %include directives from the |
23 | | ** input grammar file: |
24 | | */ |
25 | | #include <stdio.h> |
26 | | /************ Begin %include sections from the grammar ************************/ |
27 | | |
28 | | #include <stdio.h> |
29 | | #include <stdlib.h> |
30 | | #include <string.h> |
31 | | #include <assert.h> |
32 | | #include <stdbool.h> |
33 | | #include "qSqlparser.h" |
34 | | #include "tcmdtype.h" |
35 | | #include "ttoken.h" |
36 | | #include "ttokendef.h" |
37 | | #include "tutil.h" |
38 | | #include "tvariant.h" |
39 | | /**************** End of %include directives **********************************/ |
40 | | /* These constants specify the various numeric values for terminal symbols |
41 | | ** in a format understandable to "makeheaders". This section is blank unless |
42 | | ** "lemon" is run with the "-m" command-line option. |
43 | | ***************** Begin makeheaders token definitions *************************/ |
44 | | /**************** End makeheaders token definitions ***************************/ |
45 | | |
46 | | /* The next sections is a series of control #defines. |
47 | | ** various aspects of the generated parser. |
48 | | ** YYCODETYPE is the data type used to store the integer codes |
49 | | ** that represent terminal and non-terminal symbols. |
50 | | ** "unsigned char" is used if there are fewer than |
51 | | ** 256 symbols. Larger types otherwise. |
52 | | ** YYNOCODE is a number of type YYCODETYPE that is not used for |
53 | | ** any terminal or nonterminal symbol. |
54 | | ** YYFALLBACK If defined, this indicates that one or more tokens |
55 | | ** (also known as: "terminal symbols") have fall-back |
56 | | ** values which should be used if the original symbol |
57 | | ** would not parse. This permits keywords to sometimes |
58 | | ** be used as identifiers, for example. |
59 | | ** YYACTIONTYPE is the data type used for "action codes" - numbers |
60 | | ** that indicate what to do in response to the next |
61 | | ** token. |
62 | | ** ParseTOKENTYPE is the data type used for minor type for terminal |
63 | | ** symbols. Background: A "minor type" is a semantic |
64 | | ** value associated with a terminal or non-terminal |
65 | | ** symbols. For example, for an "ID" terminal symbol, |
66 | | ** the minor type might be the name of the identifier. |
67 | | ** Each non-terminal can have a different minor type. |
68 | | ** Terminal symbols all have the same minor type, though. |
69 | | ** This macros defines the minor type for terminal |
70 | | ** symbols. |
71 | | ** YYMINORTYPE is the data type used for all minor types. |
72 | | ** This is typically a union of many types, one of |
73 | | ** which is ParseTOKENTYPE. The entry in the union |
74 | | ** for terminal symbols is called "yy0". |
75 | | ** YYSTACKDEPTH is the maximum depth of the parser's stack. If |
76 | | ** zero the stack is dynamically sized using realloc() |
77 | | ** ParseARG_SDECL A static variable declaration for the %extra_argument |
78 | | ** ParseARG_PDECL A parameter declaration for the %extra_argument |
79 | | ** ParseARG_STORE Code to store %extra_argument into yypParser |
80 | | ** ParseARG_FETCH Code to extract %extra_argument from yypParser |
81 | | ** YYERRORSYMBOL is the code number of the error symbol. If not |
82 | | ** defined, then do no error processing. |
83 | | ** YYNSTATE the combined number of states. |
84 | | ** YYNRULE the number of rules in the grammar |
85 | | ** YYNTOKEN Number of terminal symbols |
86 | | ** YY_MAX_SHIFT Maximum value for shift actions |
87 | | ** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions |
88 | | ** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions |
89 | | ** YY_ERROR_ACTION The yy_action[] code for syntax error |
90 | | ** YY_ACCEPT_ACTION The yy_action[] code for accept |
91 | | ** YY_NO_ACTION The yy_action[] code for no-op |
92 | | ** YY_MIN_REDUCE Minimum value for reduce actions |
93 | | ** YY_MAX_REDUCE Maximum value for reduce actions |
94 | | */ |
95 | | #ifndef INTERFACE |
96 | | # define INTERFACE 1 |
97 | | #endif |
98 | | /************* Begin control #defines *****************************************/ |
99 | 3.52M | #define YYCODETYPE unsigned short int |
100 | 30.6M | #define YYNOCODE 293 |
101 | | #define YYACTIONTYPE unsigned short int |
102 | | #define ParseTOKENTYPE SStrToken |
103 | | typedef union { |
104 | | int yyinit; |
105 | | ParseTOKENTYPE yy0; |
106 | | tVariant yy42; |
107 | | int32_t yy44; |
108 | | SCreateTableSql* yy78; |
109 | | SRangeVal yy132; |
110 | | int yy133; |
111 | | SSqlNode* yy144; |
112 | | SLimitVal yy190; |
113 | | tSqlExpr* yy194; |
114 | | SIntervalVal yy200; |
115 | | SSessionWindowVal yy235; |
116 | | SWindowStateVal yy248; |
117 | | TAOS_FIELD yy263; |
118 | | int64_t yy277; |
119 | | SCreateAcctInfo yy299; |
120 | | SArray* yy333; |
121 | | SCreateDbInfo yy342; |
122 | | SCreatedTableInfo yy400; |
123 | | SRelationInfo* yy516; |
124 | | } YYMINORTYPE; |
125 | | #ifndef YYSTACKDEPTH |
126 | 5.52k | #define YYSTACKDEPTH 100 |
127 | | #endif |
128 | | #define ParseARG_SDECL SSqlInfo* pInfo; |
129 | | #define ParseARG_PDECL ,SSqlInfo* pInfo |
130 | 7.47M | #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo |
131 | 6.16M | #define ParseARG_STORE yypParser->pInfo = pInfo |
132 | | #define YYFALLBACK 1 |
133 | 0 | #define YYNSTATE 405 |
134 | | #define YYNRULE 322 |
135 | | #define YYNTOKEN 205 |
136 | 18.3M | #define YY_MAX_SHIFT 404 |
137 | 356k | #define YY_MIN_SHIFTREDUCE 633 |
138 | 6.14M | #define YY_MAX_SHIFTREDUCE 954 |
139 | | #define YY_ERROR_ACTION 955 |
140 | 5.20k | #define YY_ACCEPT_ACTION 956 |
141 | | #define YY_NO_ACTION 957 |
142 | 18.6M | #define YY_MIN_REDUCE 958 |
143 | | #define YY_MAX_REDUCE 1279 |
144 | | /************* End control #defines *******************************************/ |
145 | | |
146 | | /* Define the yytestcase() macro to be a no-op if is not already defined |
147 | | ** otherwise. |
148 | | ** |
149 | | ** Applications can choose to define yytestcase() in the %include section |
150 | | ** to a macro that can assist in verifying code coverage. For production |
151 | | ** code the yytestcase() macro should be turned off. But it is useful |
152 | | ** for testing. |
153 | | */ |
154 | | #ifndef yytestcase |
155 | | # define yytestcase(X) |
156 | | #endif |
157 | | |
158 | | |
159 | | /* Next are the tables used to determine what action to take based on the |
160 | | ** current state and lookahead token. These tables are used to implement |
161 | | ** functions that take a state number and lookahead value and return an |
162 | | ** action integer. |
163 | | ** |
164 | | ** Suppose the action integer is N. Then the action is determined as |
165 | | ** follows |
166 | | ** |
167 | | ** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead |
168 | | ** token onto the stack and goto state N. |
169 | | ** |
170 | | ** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then |
171 | | ** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE. |
172 | | ** |
173 | | ** N == YY_ERROR_ACTION A syntax error has occurred. |
174 | | ** |
175 | | ** N == YY_ACCEPT_ACTION The parser accepts its input. |
176 | | ** |
177 | | ** N == YY_NO_ACTION No such action. Denotes unused |
178 | | ** slots in the yy_action[] table. |
179 | | ** |
180 | | ** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE |
181 | | ** and YY_MAX_REDUCE |
182 | | ** |
183 | | ** The action table is constructed as a single large table named yy_action[]. |
184 | | ** Given state S and lookahead X, the action is computed as either: |
185 | | ** |
186 | | ** (A) N = yy_action[ yy_shift_ofst[S] + X ] |
187 | | ** (B) N = yy_default[S] |
188 | | ** |
189 | | ** The (A) formula is preferred. The B formula is used instead if |
190 | | ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X. |
191 | | ** |
192 | | ** The formulas above are for computing the action when the lookahead is |
193 | | ** a terminal symbol. If the lookahead is a non-terminal (as occurs after |
194 | | ** a reduce action) then the yy_reduce_ofst[] array is used in place of |
195 | | ** the yy_shift_ofst[] array. |
196 | | ** |
197 | | ** The following are the tables generated in this section: |
198 | | ** |
199 | | ** yy_action[] A single table containing all actions. |
200 | | ** yy_lookahead[] A table containing the lookahead for each entry in |
201 | | ** yy_action. Used to detect hash collisions. |
202 | | ** yy_shift_ofst[] For each state, the offset into yy_action for |
203 | | ** shifting terminals. |
204 | | ** yy_reduce_ofst[] For each state, the offset into yy_action for |
205 | | ** shifting non-terminals after a reduce. |
206 | | ** yy_default[] Default action for each state. |
207 | | ** |
208 | | *********** Begin parsing tables **********************************************/ |
209 | | #define YY_ACTTAB_COUNT (889) |
210 | | static const YYACTIONTYPE yy_action[] = { |
211 | | /* 0 */ 223, 684, 1107, 168, 956, 404, 24, 768, 1141, 685, |
212 | | /* 10 */ 1252, 684, 1254, 256, 38, 39, 1252, 42, 43, 685, |
213 | | /* 20 */ 1117, 271, 31, 30, 29, 403, 249, 41, 354, 46, |
214 | | /* 30 */ 44, 47, 45, 32, 110, 258, 221, 37, 36, 379, |
215 | | /* 40 */ 378, 35, 34, 33, 38, 39, 1252, 42, 43, 264, |
216 | | /* 50 */ 183, 271, 31, 30, 29, 303, 1132, 41, 354, 46, |
217 | | /* 60 */ 44, 47, 45, 32, 35, 34, 33, 37, 36, 311, |
218 | | /* 70 */ 1101, 35, 34, 33, 295, 684, 302, 301, 38, 39, |
219 | | /* 80 */ 1138, 42, 43, 685, 720, 271, 31, 30, 29, 60, |
220 | | /* 90 */ 90, 41, 354, 46, 44, 47, 45, 32, 402, 400, |
221 | | /* 100 */ 661, 37, 36, 222, 227, 35, 34, 33, 38, 39, |
222 | | /* 110 */ 13, 42, 43, 1252, 1252, 271, 31, 30, 29, 296, |
223 | | /* 120 */ 59, 41, 354, 46, 44, 47, 45, 32, 161, 159, |
224 | | /* 130 */ 158, 37, 36, 61, 251, 35, 34, 33, 350, 38, |
225 | | /* 140 */ 40, 1114, 42, 43, 109, 88, 271, 31, 30, 29, |
226 | | /* 150 */ 281, 882, 41, 354, 46, 44, 47, 45, 32, 389, |
227 | | /* 160 */ 52, 190, 37, 36, 228, 684, 35, 34, 33, 39, |
228 | | /* 170 */ 229, 42, 43, 685, 1252, 271, 31, 30, 29, 240, |
229 | | /* 180 */ 1252, 41, 354, 46, 44, 47, 45, 32, 60, 1252, |
230 | | /* 190 */ 96, 37, 36, 842, 843, 35, 34, 33, 68, 348, |
231 | | /* 200 */ 396, 395, 347, 346, 345, 394, 344, 343, 342, 393, |
232 | | /* 210 */ 341, 392, 391, 634, 635, 636, 637, 638, 639, 640, |
233 | | /* 220 */ 641, 642, 643, 644, 645, 646, 647, 162, 60, 250, |
234 | | /* 230 */ 69, 42, 43, 261, 1116, 271, 31, 30, 29, 287, |
235 | | /* 240 */ 1114, 41, 354, 46, 44, 47, 45, 32, 291, 290, |
236 | | /* 250 */ 811, 37, 36, 60, 1274, 35, 34, 33, 25, 352, |
237 | | /* 260 */ 1075, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, |
238 | | /* 270 */ 1072, 1073, 1074, 1076, 1077, 233, 324, 243, 898, 10, |
239 | | /* 280 */ 1113, 886, 235, 889, 1193, 892, 1194, 321, 149, 148, |
240 | | /* 290 */ 147, 234, 1243, 243, 898, 362, 96, 886, 262, 889, |
241 | | /* 300 */ 304, 892, 1252, 359, 1191, 1114, 1192, 46, 44, 47, |
242 | | /* 310 */ 45, 32, 1242, 247, 248, 37, 36, 356, 1241, 35, |
243 | | /* 320 */ 34, 33, 1252, 1204, 5, 63, 194, 245, 1252, 247, |
244 | | /* 330 */ 248, 193, 116, 121, 112, 120, 69, 1252, 796, 325, |
245 | | /* 340 */ 102, 793, 101, 794, 32, 795, 1266, 830, 37, 36, |
246 | | /* 350 */ 337, 833, 35, 34, 33, 1099, 214, 212, 210, 294, |
247 | | /* 360 */ 60, 86, 48, 209, 153, 152, 151, 150, 244, 274, |
248 | | /* 370 */ 268, 267, 284, 276, 277, 133, 127, 138, 48, 307, |
249 | | /* 380 */ 308, 888, 137, 891, 143, 146, 136, 280, 272, 887, |
250 | | /* 390 */ 104, 890, 103, 140, 246, 1083, 1203, 1081, 1082, 899, |
251 | | /* 400 */ 893, 895, 1084, 107, 1252, 366, 1085, 263, 1086, 1087, |
252 | | /* 410 */ 903, 60, 1114, 259, 1117, 899, 893, 895, 68, 353, |
253 | | /* 420 */ 396, 395, 37, 36, 894, 394, 35, 34, 33, 393, |
254 | | /* 430 */ 60, 392, 391, 60, 219, 223, 1096, 1097, 56, 1100, |
255 | | /* 440 */ 894, 352, 60, 350, 1252, 1252, 1255, 1255, 186, 275, |
256 | | /* 450 */ 60, 273, 223, 365, 364, 60, 367, 281, 270, 797, |
257 | | /* 460 */ 278, 60, 1252, 1114, 1255, 814, 254, 282, 191, 279, |
258 | | /* 470 */ 265, 374, 373, 281, 164, 368, 225, 1117, 369, 226, |
259 | | /* 480 */ 6, 230, 1114, 224, 355, 1114, 1252, 375, 231, 1252, |
260 | | /* 490 */ 87, 1252, 281, 1252, 1114, 376, 862, 1006, 1252, 93, |
261 | | /* 500 */ 377, 896, 1114, 1115, 204, 232, 381, 1114, 135, 897, |
262 | | /* 510 */ 105, 237, 238, 1114, 1132, 1252, 239, 236, 220, 1132, |
263 | | /* 520 */ 389, 1252, 1252, 94, 1098, 91, 1252, 1252, 1252, 397, |
264 | | /* 530 */ 1044, 1016, 252, 1007, 839, 1, 192, 253, 204, 298, |
265 | | /* 540 */ 204, 3, 205, 306, 305, 849, 850, 77, 170, 269, |
266 | | /* 550 */ 778, 80, 329, 818, 780, 331, 861, 779, 55, 72, |
267 | | /* 560 */ 49, 928, 358, 298, 61, 900, 61, 683, 72, 108, |
268 | | /* 570 */ 15, 72, 14, 84, 126, 9, 125, 292, 17, 9, |
269 | | /* 580 */ 16, 9, 371, 370, 357, 803, 801, 804, 802, 885, |
270 | | /* 590 */ 166, 332, 78, 19, 81, 18, 132, 21, 131, 20, |
271 | | /* 600 */ 145, 144, 1200, 167, 1199, 767, 260, 380, 1112, 1140, |
272 | | /* 610 */ 26, 1151, 1148, 1149, 1153, 1133, 169, 174, 299, 317, |
273 | | /* 620 */ 1108, 1183, 1182, 1181, 185, 1180, 187, 1106, 188, 1279, |
274 | | /* 630 */ 189, 1021, 160, 829, 398, 334, 335, 336, 339, 340, |
275 | | /* 640 */ 70, 217, 66, 351, 27, 1015, 363, 1273, 1130, 123, |
276 | | /* 650 */ 1272, 310, 82, 1269, 255, 312, 195, 372, 314, 1265, |
277 | | /* 660 */ 129, 1264, 1261, 196, 1041, 67, 79, 175, 62, 71, |
278 | | /* 670 */ 218, 326, 1003, 28, 139, 176, 322, 1001, 178, 141, |
279 | | /* 680 */ 320, 142, 177, 999, 998, 283, 318, 207, 316, 208, |
280 | | /* 690 */ 995, 994, 993, 992, 991, 313, 990, 989, 211, 213, |
281 | | /* 700 */ 981, 215, 978, 216, 974, 309, 89, 338, 163, 390, |
282 | | /* 710 */ 85, 297, 1110, 92, 97, 315, 134, 382, 383, 384, |
283 | | /* 720 */ 385, 386, 387, 83, 388, 165, 266, 333, 953, 286, |
284 | | /* 730 */ 285, 952, 288, 241, 242, 289, 951, 934, 933, 1020, |
285 | | /* 740 */ 1019, 117, 118, 293, 298, 328, 11, 95, 806, 300, |
286 | | /* 750 */ 997, 53, 996, 199, 154, 198, 1042, 197, 200, 202, |
287 | | /* 760 */ 201, 203, 838, 155, 156, 988, 987, 2, 157, 1079, |
288 | | /* 770 */ 179, 327, 1043, 980, 979, 184, 180, 4, 181, 182, |
289 | | /* 780 */ 54, 98, 75, 836, 835, 1089, 832, 831, 76, 173, |
290 | | /* 790 */ 840, 171, 257, 851, 172, 64, 845, 99, 357, 847, |
291 | | /* 800 */ 100, 319, 323, 22, 12, 65, 23, 106, 50, 330, |
292 | | /* 810 */ 111, 51, 109, 114, 698, 733, 731, 730, 57, 113, |
293 | | /* 820 */ 729, 727, 726, 58, 115, 725, 722, 688, 119, 349, |
294 | | /* 830 */ 7, 925, 923, 926, 902, 901, 924, 361, 8, 904, |
295 | | /* 840 */ 122, 124, 360, 73, 61, 800, 799, 74, 128, 770, |
296 | | /* 850 */ 130, 769, 766, 714, 712, 704, 710, 706, 708, 702, |
297 | | /* 860 */ 700, 736, 735, 734, 732, 728, 724, 723, 206, 686, |
298 | | /* 870 */ 958, 651, 660, 957, 658, 957, 957, 957, 957, 957, |
299 | | /* 880 */ 957, 957, 957, 957, 957, 957, 399, 957, 401, |
300 | | }; |
301 | | static const YYCODETYPE yy_lookahead[] = { |
302 | | /* 0 */ 279, 1, 208, 208, 206, 207, 279, 5, 208, 9, |
303 | | /* 10 */ 289, 1, 291, 254, 14, 15, 289, 17, 18, 9, |
304 | | /* 20 */ 261, 21, 22, 23, 24, 208, 209, 27, 28, 29, |
305 | | /* 30 */ 30, 31, 32, 33, 216, 1, 279, 37, 38, 37, |
306 | | /* 40 */ 38, 41, 42, 43, 14, 15, 289, 17, 18, 255, |
307 | | /* 50 */ 266, 21, 22, 23, 24, 284, 258, 27, 28, 29, |
308 | | /* 60 */ 30, 31, 32, 33, 41, 42, 43, 37, 38, 285, |
309 | | /* 70 */ 252, 41, 42, 43, 276, 1, 281, 282, 14, 15, |
310 | | /* 80 */ 280, 17, 18, 9, 5, 21, 22, 23, 24, 208, |
311 | | /* 90 */ 90, 27, 28, 29, 30, 31, 32, 33, 69, 70, |
312 | | /* 100 */ 71, 37, 38, 279, 279, 41, 42, 43, 14, 15, |
313 | | /* 110 */ 86, 17, 18, 289, 289, 21, 22, 23, 24, 87, |
314 | | /* 120 */ 90, 27, 28, 29, 30, 31, 32, 33, 66, 67, |
315 | | /* 130 */ 68, 37, 38, 101, 253, 41, 42, 43, 88, 14, |
316 | | /* 140 */ 15, 260, 17, 18, 120, 121, 21, 22, 23, 24, |
317 | | /* 150 */ 208, 87, 27, 28, 29, 30, 31, 32, 33, 94, |
318 | | /* 160 */ 86, 219, 37, 38, 279, 1, 41, 42, 43, 15, |
319 | | /* 170 */ 279, 17, 18, 9, 289, 21, 22, 23, 24, 279, |
320 | | /* 180 */ 289, 27, 28, 29, 30, 31, 32, 33, 208, 289, |
321 | | /* 190 */ 86, 37, 38, 132, 133, 41, 42, 43, 102, 103, |
322 | | /* 200 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, |
323 | | /* 210 */ 114, 115, 116, 49, 50, 51, 52, 53, 54, 55, |
324 | | /* 220 */ 56, 57, 58, 59, 60, 61, 62, 63, 208, 65, |
325 | | /* 230 */ 126, 17, 18, 253, 261, 21, 22, 23, 24, 150, |
326 | | /* 240 */ 260, 27, 28, 29, 30, 31, 32, 33, 159, 160, |
327 | | /* 250 */ 101, 37, 38, 208, 261, 41, 42, 43, 48, 47, |
328 | | /* 260 */ 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, |
329 | | /* 270 */ 242, 243, 244, 245, 246, 65, 64, 1, 2, 130, |
330 | | /* 280 */ 260, 5, 72, 7, 287, 9, 289, 290, 78, 79, |
331 | | /* 290 */ 80, 81, 279, 1, 2, 85, 86, 5, 253, 7, |
332 | | /* 300 */ 284, 9, 289, 16, 287, 260, 289, 29, 30, 31, |
333 | | /* 310 */ 32, 33, 279, 37, 38, 37, 38, 41, 279, 41, |
334 | | /* 320 */ 42, 43, 289, 248, 66, 67, 68, 279, 289, 37, |
335 | | /* 330 */ 38, 73, 74, 75, 76, 77, 126, 289, 2, 286, |
336 | | /* 340 */ 287, 5, 289, 7, 33, 9, 261, 5, 37, 38, |
337 | | /* 350 */ 92, 9, 41, 42, 43, 0, 66, 67, 68, 149, |
338 | | /* 360 */ 208, 151, 86, 73, 74, 75, 76, 77, 158, 72, |
339 | | /* 370 */ 215, 215, 162, 37, 38, 66, 67, 68, 86, 37, |
340 | | /* 380 */ 38, 5, 73, 7, 75, 76, 77, 72, 215, 5, |
341 | | /* 390 */ 287, 7, 289, 84, 279, 232, 248, 234, 235, 123, |
342 | | /* 400 */ 124, 125, 239, 216, 289, 253, 243, 254, 245, 246, |
343 | | /* 410 */ 123, 208, 260, 248, 261, 123, 124, 125, 102, 25, |
344 | | /* 420 */ 104, 105, 37, 38, 148, 109, 41, 42, 43, 113, |
345 | | /* 430 */ 208, 115, 116, 208, 279, 279, 249, 250, 251, 252, |
346 | | /* 440 */ 148, 47, 208, 88, 289, 289, 291, 291, 256, 152, |
347 | | /* 450 */ 208, 154, 279, 156, 157, 208, 253, 208, 64, 123, |
348 | | /* 460 */ 124, 208, 289, 260, 291, 41, 124, 152, 219, 154, |
349 | | /* 470 */ 254, 156, 157, 208, 208, 253, 279, 261, 253, 279, |
350 | | /* 480 */ 86, 279, 260, 279, 219, 260, 289, 253, 279, 289, |
351 | | /* 490 */ 216, 289, 208, 289, 260, 253, 80, 214, 289, 87, |
352 | | /* 500 */ 253, 125, 260, 219, 221, 279, 253, 260, 82, 125, |
353 | | /* 510 */ 262, 279, 279, 260, 258, 289, 279, 279, 279, 258, |
354 | | /* 520 */ 94, 289, 289, 87, 250, 277, 289, 289, 289, 230, |
355 | | /* 530 */ 231, 214, 276, 214, 87, 217, 218, 276, 221, 127, |
356 | | /* 540 */ 221, 212, 213, 37, 38, 87, 87, 101, 101, 1, |
357 | | /* 550 */ 87, 101, 87, 129, 87, 87, 140, 87, 86, 101, |
358 | | /* 560 */ 101, 87, 25, 127, 101, 87, 101, 87, 101, 101, |
359 | | /* 570 */ 153, 101, 155, 86, 153, 101, 155, 208, 153, 101, |
360 | | /* 580 */ 155, 101, 37, 38, 47, 5, 5, 7, 7, 41, |
361 | | /* 590 */ 208, 119, 146, 153, 144, 155, 153, 153, 155, 155, |
362 | | /* 600 */ 82, 83, 248, 208, 248, 118, 248, 248, 208, 208, |
363 | | /* 610 */ 278, 208, 208, 208, 208, 258, 208, 208, 258, 208, |
364 | | /* 620 */ 258, 288, 288, 288, 263, 288, 208, 208, 208, 264, |
365 | | /* 630 */ 208, 208, 64, 125, 88, 208, 208, 208, 208, 208, |
366 | | /* 640 */ 208, 208, 208, 208, 147, 208, 208, 208, 275, 208, |
367 | | /* 650 */ 208, 283, 143, 208, 283, 283, 208, 208, 283, 208, |
368 | | /* 660 */ 208, 208, 208, 208, 208, 208, 145, 274, 208, 208, |
369 | | /* 670 */ 208, 138, 208, 142, 208, 273, 141, 208, 271, 208, |
370 | | /* 680 */ 136, 208, 272, 208, 208, 208, 135, 208, 134, 208, |
371 | | /* 690 */ 208, 208, 208, 208, 208, 137, 208, 208, 208, 208, |
372 | | /* 700 */ 208, 208, 208, 208, 208, 131, 122, 93, 210, 117, |
373 | | /* 710 */ 211, 210, 210, 210, 210, 210, 100, 99, 55, 96, |
374 | | /* 720 */ 98, 59, 97, 210, 95, 130, 210, 210, 5, 5, |
375 | | /* 730 */ 161, 5, 161, 210, 210, 5, 5, 104, 103, 220, |
376 | | /* 740 */ 220, 216, 216, 150, 127, 119, 86, 128, 87, 101, |
377 | | /* 750 */ 210, 86, 210, 223, 211, 227, 229, 228, 226, 225, |
378 | | /* 760 */ 224, 222, 87, 211, 211, 210, 210, 217, 211, 247, |
379 | | /* 770 */ 270, 257, 231, 210, 210, 264, 269, 212, 268, 267, |
380 | | /* 780 */ 265, 101, 101, 125, 125, 247, 5, 5, 86, 101, |
381 | | /* 790 */ 87, 86, 1, 87, 86, 101, 87, 86, 47, 87, |
382 | | /* 800 */ 86, 86, 1, 139, 86, 101, 139, 90, 86, 119, |
383 | | /* 810 */ 82, 86, 120, 74, 5, 9, 5, 5, 91, 90, |
384 | | /* 820 */ 5, 5, 5, 91, 90, 5, 5, 89, 82, 16, |
385 | | /* 830 */ 86, 9, 9, 9, 87, 87, 9, 63, 86, 123, |
386 | | /* 840 */ 155, 155, 28, 17, 101, 125, 125, 17, 155, 5, |
387 | | /* 850 */ 155, 5, 87, 5, 5, 5, 5, 5, 5, 5, |
388 | | /* 860 */ 5, 5, 5, 5, 5, 5, 5, 5, 101, 89, |
389 | | /* 870 */ 0, 64, 9, 292, 9, 292, 292, 292, 292, 292, |
390 | | /* 880 */ 292, 292, 292, 292, 292, 292, 22, 292, 22, 292, |
391 | | /* 890 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
392 | | /* 900 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
393 | | /* 910 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
394 | | /* 920 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
395 | | /* 930 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
396 | | /* 940 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
397 | | /* 950 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
398 | | /* 960 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
399 | | /* 970 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
400 | | /* 980 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
401 | | /* 990 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
402 | | /* 1000 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
403 | | /* 1010 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
404 | | /* 1020 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
405 | | /* 1030 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
406 | | /* 1040 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
407 | | /* 1050 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
408 | | /* 1060 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
409 | | /* 1070 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
410 | | /* 1080 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
411 | | /* 1090 */ 292, 292, 292, 292, |
412 | | }; |
413 | | #define YY_SHIFT_COUNT (404) |
414 | | #define YY_SHIFT_MIN (0) |
415 | | #define YY_SHIFT_MAX (870) |
416 | | static const unsigned short int yy_shift_ofst[] = { |
417 | | /* 0 */ 210, 96, 96, 316, 316, 50, 276, 292, 292, 292, |
418 | | /* 10 */ 74, 10, 10, 10, 10, 10, 10, 10, 10, 10, |
419 | | /* 20 */ 10, 10, 34, 34, 0, 164, 292, 292, 292, 292, |
420 | | /* 30 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 292, |
421 | | /* 40 */ 292, 292, 292, 292, 292, 292, 292, 292, 292, 336, |
422 | | /* 50 */ 336, 336, 104, 104, 61, 10, 355, 10, 10, 10, |
423 | | /* 60 */ 10, 10, 426, 50, 34, 34, 65, 65, 79, 889, |
424 | | /* 70 */ 889, 889, 336, 336, 336, 342, 342, 2, 2, 2, |
425 | | /* 80 */ 2, 2, 2, 24, 2, 10, 10, 10, 10, 10, |
426 | | /* 90 */ 10, 424, 10, 10, 10, 104, 104, 10, 10, 10, |
427 | | /* 100 */ 10, 416, 416, 416, 416, 149, 104, 10, 10, 10, |
428 | | /* 110 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, |
429 | | /* 120 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, |
430 | | /* 130 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, |
431 | | /* 140 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, |
432 | | /* 150 */ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, |
433 | | /* 160 */ 10, 10, 10, 497, 568, 546, 568, 568, 568, 568, |
434 | | /* 170 */ 508, 508, 508, 508, 568, 509, 521, 533, 531, 535, |
435 | | /* 180 */ 544, 551, 554, 558, 574, 497, 584, 568, 568, 568, |
436 | | /* 190 */ 614, 614, 592, 50, 50, 568, 568, 616, 618, 663, |
437 | | /* 200 */ 623, 622, 662, 625, 629, 592, 79, 568, 568, 546, |
438 | | /* 210 */ 546, 568, 546, 568, 546, 568, 568, 889, 889, 30, |
439 | | /* 220 */ 64, 94, 94, 94, 125, 154, 214, 278, 278, 278, |
440 | | /* 230 */ 278, 278, 278, 258, 309, 290, 311, 311, 311, 311, |
441 | | /* 240 */ 385, 297, 315, 394, 89, 23, 23, 376, 384, 29, |
442 | | /* 250 */ 62, 32, 412, 436, 506, 447, 458, 459, 212, 446, |
443 | | /* 260 */ 450, 463, 465, 467, 468, 470, 472, 474, 478, 537, |
444 | | /* 270 */ 548, 287, 480, 417, 421, 425, 580, 581, 545, 440, |
445 | | /* 280 */ 443, 487, 444, 518, 595, 723, 569, 724, 726, 571, |
446 | | /* 290 */ 730, 731, 633, 635, 593, 617, 626, 660, 619, 661, |
447 | | /* 300 */ 665, 648, 680, 675, 681, 658, 659, 781, 782, 702, |
448 | | /* 310 */ 703, 705, 706, 708, 709, 688, 711, 712, 714, 791, |
449 | | /* 320 */ 715, 694, 664, 751, 801, 704, 667, 717, 718, 626, |
450 | | /* 330 */ 722, 690, 725, 692, 728, 727, 729, 739, 809, 732, |
451 | | /* 340 */ 734, 806, 811, 812, 815, 816, 817, 820, 821, 738, |
452 | | /* 350 */ 813, 746, 822, 823, 744, 747, 748, 824, 827, 716, |
453 | | /* 360 */ 752, 814, 774, 826, 685, 686, 743, 743, 743, 743, |
454 | | /* 370 */ 720, 721, 830, 693, 695, 743, 743, 743, 844, 846, |
455 | | /* 380 */ 765, 743, 848, 849, 850, 851, 852, 853, 854, 855, |
456 | | /* 390 */ 856, 857, 858, 859, 860, 861, 862, 767, 780, 863, |
457 | | /* 400 */ 864, 865, 866, 807, 870, |
458 | | }; |
459 | | #define YY_REDUCE_COUNT (218) |
460 | | #define YY_REDUCE_MIN (-279) |
461 | | #define YY_REDUCE_MAX (565) |
462 | | static const short yy_reduce_ofst[] = { |
463 | | /* 0 */ -202, 28, 28, 163, 163, 187, 155, 156, 173, -279, |
464 | | /* 10 */ -205, -119, -20, 45, 152, 203, 222, 225, 234, 242, |
465 | | /* 20 */ 247, 253, -3, 53, -200, -183, -273, -243, -176, -175, |
466 | | /* 30 */ -115, -109, -100, 13, 33, 39, 48, 115, 197, 200, |
467 | | /* 40 */ 202, 204, 209, 226, 232, 233, 237, 238, 239, -241, |
468 | | /* 50 */ 153, 216, 256, 261, -216, -206, -182, -58, 249, 265, |
469 | | /* 60 */ 284, 20, 283, 274, 17, 103, 317, 319, 299, 248, |
470 | | /* 70 */ 318, 329, -27, -7, 85, -229, 16, 75, 148, 165, |
471 | | /* 80 */ 354, 356, 358, 192, 359, 266, 369, 382, 395, 400, |
472 | | /* 90 */ 401, 332, 403, 404, 405, 357, 360, 406, 408, 409, |
473 | | /* 100 */ 411, 333, 334, 335, 337, 361, 362, 418, 419, 420, |
474 | | /* 110 */ 422, 423, 427, 428, 429, 430, 431, 432, 433, 434, |
475 | | /* 120 */ 435, 437, 438, 439, 441, 442, 445, 448, 449, 451, |
476 | | /* 130 */ 452, 453, 454, 455, 456, 457, 460, 461, 462, 464, |
477 | | /* 140 */ 466, 469, 471, 473, 475, 476, 477, 479, 481, 482, |
478 | | /* 150 */ 483, 484, 485, 486, 488, 489, 490, 491, 492, 493, |
479 | | /* 160 */ 494, 495, 496, 365, 498, 499, 501, 502, 503, 504, |
480 | | /* 170 */ 368, 371, 372, 375, 505, 373, 393, 402, 410, 407, |
481 | | /* 180 */ 500, 507, 510, 512, 515, 511, 514, 513, 516, 517, |
482 | | /* 190 */ 519, 520, 522, 525, 526, 523, 524, 527, 529, 528, |
483 | | /* 200 */ 530, 532, 536, 534, 539, 538, 541, 540, 542, 543, |
484 | | /* 210 */ 552, 555, 553, 556, 557, 563, 564, 550, 565, |
485 | | }; |
486 | | static const YYACTIONTYPE yy_default[] = { |
487 | | /* 0 */ 955, 1078, 1017, 1088, 1004, 1014, 1257, 1257, 1257, 1257, |
488 | | /* 10 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
489 | | /* 20 */ 955, 955, 955, 955, 1142, 975, 955, 955, 955, 955, |
490 | | /* 30 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
491 | | /* 40 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
492 | | /* 50 */ 955, 955, 955, 955, 1166, 955, 1014, 955, 955, 955, |
493 | | /* 60 */ 955, 955, 1024, 1014, 955, 955, 1024, 1024, 955, 1137, |
494 | | /* 70 */ 1062, 1080, 955, 955, 955, 955, 955, 955, 955, 955, |
495 | | /* 80 */ 955, 955, 955, 1109, 955, 955, 955, 955, 955, 955, |
496 | | /* 90 */ 955, 1144, 1150, 1147, 955, 955, 955, 1152, 955, 955, |
497 | | /* 100 */ 955, 1188, 1188, 1188, 1188, 1135, 955, 955, 955, 955, |
498 | | /* 110 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
499 | | /* 120 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
500 | | /* 130 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 1002, |
501 | | /* 140 */ 955, 1000, 955, 955, 955, 955, 955, 955, 955, 955, |
502 | | /* 150 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
503 | | /* 160 */ 955, 955, 973, 1205, 977, 1012, 977, 977, 977, 977, |
504 | | /* 170 */ 955, 955, 955, 955, 977, 1197, 1201, 1178, 1195, 1189, |
505 | | /* 180 */ 1173, 1171, 1169, 1177, 1162, 1205, 1111, 977, 977, 977, |
506 | | /* 190 */ 1022, 1022, 1018, 1014, 1014, 977, 977, 1040, 1038, 1036, |
507 | | /* 200 */ 1028, 1034, 1030, 1032, 1026, 1005, 955, 977, 977, 1012, |
508 | | /* 210 */ 1012, 977, 1012, 977, 1012, 977, 977, 1062, 1080, 1256, |
509 | | /* 220 */ 955, 1206, 1196, 1256, 955, 1238, 1237, 1247, 1246, 1245, |
510 | | /* 230 */ 1236, 1235, 1234, 955, 955, 955, 1230, 1233, 1232, 1231, |
511 | | /* 240 */ 1244, 955, 955, 1208, 955, 1240, 1239, 955, 955, 955, |
512 | | /* 250 */ 955, 955, 955, 955, 1159, 955, 955, 955, 1184, 1202, |
513 | | /* 260 */ 1198, 955, 955, 955, 955, 955, 955, 955, 955, 1209, |
514 | | /* 270 */ 955, 955, 955, 955, 955, 955, 955, 955, 1123, 955, |
515 | | /* 280 */ 955, 1090, 955, 955, 955, 955, 955, 955, 955, 955, |
516 | | /* 290 */ 955, 955, 955, 955, 955, 1134, 955, 955, 955, 955, |
517 | | /* 300 */ 955, 1146, 1145, 955, 955, 955, 955, 955, 955, 955, |
518 | | /* 310 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
519 | | /* 320 */ 955, 1190, 955, 1185, 955, 1179, 955, 955, 955, 1102, |
520 | | /* 330 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
521 | | /* 340 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
522 | | /* 350 */ 955, 955, 955, 955, 955, 955, 955, 955, 955, 955, |
523 | | /* 360 */ 955, 955, 955, 955, 955, 955, 1275, 1270, 1271, 1268, |
524 | | /* 370 */ 955, 955, 955, 955, 955, 1267, 1262, 1263, 955, 955, |
525 | | /* 380 */ 955, 1260, 955, 955, 955, 955, 955, 955, 955, 955, |
526 | | /* 390 */ 955, 955, 955, 955, 955, 955, 955, 1046, 955, 955, |
527 | | /* 400 */ 984, 955, 982, 955, 955, |
528 | | }; |
529 | | /********** End of lemon-generated parsing tables *****************************/ |
530 | | |
531 | | /* The next table maps tokens (terminal symbols) into fallback tokens. |
532 | | ** If a construct like the following: |
533 | | ** |
534 | | ** %fallback ID X Y Z. |
535 | | ** |
536 | | ** appears in the grammar, then ID becomes a fallback token for X, Y, |
537 | | ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser |
538 | | ** but it does not parse, the type of the token is changed to ID and |
539 | | ** the parse is retried before an error is thrown. |
540 | | ** |
541 | | ** This feature can be used, for example, to cause some keywords in a language |
542 | | ** to revert to identifiers if they keyword does not apply in the context where |
543 | | ** it appears. |
544 | | */ |
545 | | #ifdef YYFALLBACK |
546 | | static const YYCODETYPE yyFallback[] = { |
547 | | 0, /* $ => nothing */ |
548 | | 0, /* ID => nothing */ |
549 | | 1, /* BOOL => ID */ |
550 | | 1, /* TINYINT => ID */ |
551 | | 1, /* SMALLINT => ID */ |
552 | | 1, /* INTEGER => ID */ |
553 | | 1, /* BIGINT => ID */ |
554 | | 1, /* FLOAT => ID */ |
555 | | 1, /* DOUBLE => ID */ |
556 | | 1, /* STRING => ID */ |
557 | | 1, /* TIMESTAMP => ID */ |
558 | | 1, /* BINARY => ID */ |
559 | | 1, /* NCHAR => ID */ |
560 | | 1, /* JSON => ID */ |
561 | | 0, /* OR => nothing */ |
562 | | 0, /* AND => nothing */ |
563 | | 0, /* NOT => nothing */ |
564 | | 0, /* EQ => nothing */ |
565 | | 0, /* NE => nothing */ |
566 | | 0, /* ISNULL => nothing */ |
567 | | 0, /* NOTNULL => nothing */ |
568 | | 0, /* IS => nothing */ |
569 | | 1, /* LIKE => ID */ |
570 | | 1, /* MATCH => ID */ |
571 | | 1, /* NMATCH => ID */ |
572 | | 0, /* CONTAINS => nothing */ |
573 | | 1, /* GLOB => ID */ |
574 | | 0, /* BETWEEN => nothing */ |
575 | | 0, /* IN => nothing */ |
576 | | 0, /* GT => nothing */ |
577 | | 0, /* GE => nothing */ |
578 | | 0, /* LT => nothing */ |
579 | | 0, /* LE => nothing */ |
580 | | 0, /* BITAND => nothing */ |
581 | | 0, /* BITOR => nothing */ |
582 | | 0, /* LSHIFT => nothing */ |
583 | | 0, /* RSHIFT => nothing */ |
584 | | 0, /* PLUS => nothing */ |
585 | | 0, /* MINUS => nothing */ |
586 | | 0, /* DIVIDE => nothing */ |
587 | | 0, /* TIMES => nothing */ |
588 | | 0, /* STAR => nothing */ |
589 | | 0, /* SLASH => nothing */ |
590 | | 0, /* REM => nothing */ |
591 | | 0, /* UMINUS => nothing */ |
592 | | 0, /* UPLUS => nothing */ |
593 | | 0, /* BITNOT => nothing */ |
594 | | 0, /* ARROW => nothing */ |
595 | | 0, /* SHOW => nothing */ |
596 | | 0, /* DATABASES => nothing */ |
597 | | 0, /* TOPICS => nothing */ |
598 | | 0, /* FUNCTIONS => nothing */ |
599 | | 0, /* MNODES => nothing */ |
600 | | 0, /* DNODES => nothing */ |
601 | | 0, /* ACCOUNTS => nothing */ |
602 | | 0, /* USERS => nothing */ |
603 | | 0, /* MODULES => nothing */ |
604 | | 0, /* QUERIES => nothing */ |
605 | | 0, /* CONNECTIONS => nothing */ |
606 | | 0, /* STREAMS => nothing */ |
607 | | 0, /* VARIABLES => nothing */ |
608 | | 0, /* SCORES => nothing */ |
609 | | 0, /* GRANTS => nothing */ |
610 | | 0, /* VNODES => nothing */ |
611 | | 0, /* DOT => nothing */ |
612 | | 0, /* CREATE => nothing */ |
613 | | 0, /* TABLE => nothing */ |
614 | | 1, /* STABLE => ID */ |
615 | | 1, /* DATABASE => ID */ |
616 | | 0, /* TABLES => nothing */ |
617 | | 0, /* STABLES => nothing */ |
618 | | 0, /* VGROUPS => nothing */ |
619 | | 0, /* DROP => nothing */ |
620 | | 0, /* TOPIC => nothing */ |
621 | | 0, /* FUNCTION => nothing */ |
622 | | 0, /* DNODE => nothing */ |
623 | | 0, /* USER => nothing */ |
624 | | 0, /* ACCOUNT => nothing */ |
625 | | 0, /* USE => nothing */ |
626 | | 0, /* DESCRIBE => nothing */ |
627 | | 1, /* DESC => ID */ |
628 | | 0, /* ALTER => nothing */ |
629 | | 0, /* PASS => nothing */ |
630 | | 0, /* PRIVILEGE => nothing */ |
631 | | 0, /* LOCAL => nothing */ |
632 | | 0, /* COMPACT => nothing */ |
633 | | 0, /* LP => nothing */ |
634 | | 0, /* RP => nothing */ |
635 | | 0, /* IF => nothing */ |
636 | | 0, /* EXISTS => nothing */ |
637 | | 0, /* AS => nothing */ |
638 | | 0, /* OUTPUTTYPE => nothing */ |
639 | | 0, /* AGGREGATE => nothing */ |
640 | | 0, /* BUFSIZE => nothing */ |
641 | | 0, /* PPS => nothing */ |
642 | | 0, /* TSERIES => nothing */ |
643 | | 0, /* DBS => nothing */ |
644 | | 0, /* STORAGE => nothing */ |
645 | | 0, /* QTIME => nothing */ |
646 | | 0, /* CONNS => nothing */ |
647 | | 0, /* STATE => nothing */ |
648 | | 0, /* COMMA => nothing */ |
649 | | 0, /* KEEP => nothing */ |
650 | | 0, /* CACHE => nothing */ |
651 | | 0, /* REPLICA => nothing */ |
652 | | 0, /* QUORUM => nothing */ |
653 | | 0, /* DAYS => nothing */ |
654 | | 0, /* MINROWS => nothing */ |
655 | | 0, /* MAXROWS => nothing */ |
656 | | 0, /* BLOCKS => nothing */ |
657 | | 0, /* CTIME => nothing */ |
658 | | 0, /* WAL => nothing */ |
659 | | 0, /* FSYNC => nothing */ |
660 | | 0, /* COMP => nothing */ |
661 | | 0, /* PRECISION => nothing */ |
662 | | 0, /* UPDATE => nothing */ |
663 | | 0, /* CACHELAST => nothing */ |
664 | | 0, /* PARTITIONS => nothing */ |
665 | | 0, /* UNSIGNED => nothing */ |
666 | | 0, /* TAGS => nothing */ |
667 | | 0, /* USING => nothing */ |
668 | | 0, /* TO => nothing */ |
669 | | 0, /* SPLIT => nothing */ |
670 | | 1, /* NULL => ID */ |
671 | | 1, /* NOW => ID */ |
672 | | 0, /* VARIABLE => nothing */ |
673 | | 0, /* SELECT => nothing */ |
674 | | 0, /* UNION => nothing */ |
675 | | 1, /* ALL => ID */ |
676 | | 0, /* DISTINCT => nothing */ |
677 | | 0, /* FROM => nothing */ |
678 | | 0, /* RANGE => nothing */ |
679 | | 0, /* INTERVAL => nothing */ |
680 | | 0, /* EVERY => nothing */ |
681 | | 0, /* SESSION => nothing */ |
682 | | 0, /* STATE_WINDOW => nothing */ |
683 | | 0, /* FILL => nothing */ |
684 | | 0, /* SLIDING => nothing */ |
685 | | 0, /* ORDER => nothing */ |
686 | | 0, /* BY => nothing */ |
687 | | 1, /* ASC => ID */ |
688 | | 0, /* GROUP => nothing */ |
689 | | 0, /* HAVING => nothing */ |
690 | | 0, /* LIMIT => nothing */ |
691 | | 1, /* OFFSET => ID */ |
692 | | 0, /* SLIMIT => nothing */ |
693 | | 0, /* SOFFSET => nothing */ |
694 | | 0, /* WHERE => nothing */ |
695 | | 1, /* TODAY => ID */ |
696 | | 0, /* RESET => nothing */ |
697 | | 0, /* QUERY => nothing */ |
698 | | 0, /* SYNCDB => nothing */ |
699 | | 0, /* ADD => nothing */ |
700 | | 0, /* COLUMN => nothing */ |
701 | | 0, /* MODIFY => nothing */ |
702 | | 0, /* TAG => nothing */ |
703 | | 0, /* CHANGE => nothing */ |
704 | | 0, /* SET => nothing */ |
705 | | 0, /* KILL => nothing */ |
706 | | 0, /* CONNECTION => nothing */ |
707 | | 0, /* STREAM => nothing */ |
708 | | 0, /* COLON => nothing */ |
709 | | 0, /* DELETE => nothing */ |
710 | | 1, /* ABORT => ID */ |
711 | | 1, /* AFTER => ID */ |
712 | | 1, /* ATTACH => ID */ |
713 | | 1, /* BEFORE => ID */ |
714 | | 1, /* BEGIN => ID */ |
715 | | 1, /* CASCADE => ID */ |
716 | | 1, /* CLUSTER => ID */ |
717 | | 1, /* CONFLICT => ID */ |
718 | | 1, /* COPY => ID */ |
719 | | 1, /* DEFERRED => ID */ |
720 | | 1, /* DELIMITERS => ID */ |
721 | | 1, /* DETACH => ID */ |
722 | | 1, /* EACH => ID */ |
723 | | 1, /* END => ID */ |
724 | | 1, /* EXPLAIN => ID */ |
725 | | 1, /* FAIL => ID */ |
726 | | 1, /* FOR => ID */ |
727 | | 1, /* IGNORE => ID */ |
728 | | 1, /* IMMEDIATE => ID */ |
729 | | 1, /* INITIALLY => ID */ |
730 | | 1, /* INSTEAD => ID */ |
731 | | 1, /* KEY => ID */ |
732 | | 1, /* OF => ID */ |
733 | | 1, /* RAISE => ID */ |
734 | | 1, /* REPLACE => ID */ |
735 | | 1, /* RESTRICT => ID */ |
736 | | 1, /* ROW => ID */ |
737 | | 1, /* STATEMENT => ID */ |
738 | | 1, /* TRIGGER => ID */ |
739 | | 1, /* VIEW => ID */ |
740 | | 1, /* IPTOKEN => ID */ |
741 | | 1, /* SEMI => ID */ |
742 | | 1, /* NONE => ID */ |
743 | | 1, /* PREV => ID */ |
744 | | 1, /* LINEAR => ID */ |
745 | | 1, /* IMPORT => ID */ |
746 | | 1, /* TBNAME => ID */ |
747 | | 1, /* JOIN => ID */ |
748 | | 1, /* INSERT => ID */ |
749 | | 1, /* INTO => ID */ |
750 | | 1, /* VALUES => ID */ |
751 | | 1, /* FILE => ID */ |
752 | | }; |
753 | | #endif /* YYFALLBACK */ |
754 | | |
755 | | /* The following structure represents a single element of the |
756 | | ** parser's stack. Information stored includes: |
757 | | ** |
758 | | ** + The state number for the parser at this level of the stack. |
759 | | ** |
760 | | ** + The value of the token stored at this level of the stack. |
761 | | ** (In other words, the "major" token.) |
762 | | ** |
763 | | ** + The semantic value stored at this level of the stack. This is |
764 | | ** the information used by the action routines in the grammar. |
765 | | ** It is sometimes called the "minor" token. |
766 | | ** |
767 | | ** After the "shift" half of a SHIFTREDUCE action, the stateno field |
768 | | ** actually contains the reduce action for the second half of the |
769 | | ** SHIFTREDUCE. |
770 | | */ |
771 | | struct yyStackEntry { |
772 | | YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */ |
773 | | YYCODETYPE major; /* The major token value. This is the code |
774 | | ** number for the token at this stack level */ |
775 | | YYMINORTYPE minor; /* The user-supplied minor token value. This |
776 | | ** is the value of the token */ |
777 | | }; |
778 | | typedef struct yyStackEntry yyStackEntry; |
779 | | |
780 | | /* The state of the parser is completely contained in an instance of |
781 | | ** the following structure */ |
782 | | struct yyParser { |
783 | | yyStackEntry *yytos; /* Pointer to top element of the stack */ |
784 | | #ifdef YYTRACKMAXSTACKDEPTH |
785 | | int yyhwm; /* High-water mark of the stack */ |
786 | | #endif |
787 | | #ifndef YYNOERRORRECOVERY |
788 | | int yyerrcnt; /* Shifts left before out of the error */ |
789 | | #endif |
790 | | ParseARG_SDECL /* A place to hold %extra_argument */ |
791 | | #if YYSTACKDEPTH<=0 |
792 | | int yystksz; /* Current side of the stack */ |
793 | | yyStackEntry *yystack; /* The parser's stack */ |
794 | | yyStackEntry yystk0; /* First stack entry */ |
795 | | #else |
796 | | yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ |
797 | | yyStackEntry *yystackEnd; /* Last entry in the stack */ |
798 | | #endif |
799 | | }; |
800 | | typedef struct yyParser yyParser; |
801 | | |
802 | | #ifndef NDEBUG |
803 | | #include <stdio.h> |
804 | | static FILE *yyTraceFILE = 0; |
805 | | static char *yyTracePrompt = 0; |
806 | | #endif /* NDEBUG */ |
807 | | |
808 | | #ifndef NDEBUG |
809 | | /* |
810 | | ** Turn parser tracing on by giving a stream to which to write the trace |
811 | | ** and a prompt to preface each trace message. Tracing is turned off |
812 | | ** by making either argument NULL |
813 | | ** |
814 | | ** Inputs: |
815 | | ** <ul> |
816 | | ** <li> A FILE* to which trace output should be written. |
817 | | ** If NULL, then tracing is turned off. |
818 | | ** <li> A prefix string written at the beginning of every |
819 | | ** line of trace output. If NULL, then tracing is |
820 | | ** turned off. |
821 | | ** </ul> |
822 | | ** |
823 | | ** Outputs: |
824 | | ** None. |
825 | | */ |
826 | 0 | void ParseTrace(FILE *TraceFILE, char *zTracePrompt){ |
827 | 0 | yyTraceFILE = TraceFILE; |
828 | 0 | yyTracePrompt = zTracePrompt; |
829 | 0 | if( yyTraceFILE==0 ) yyTracePrompt = 0; |
830 | 0 | else if( yyTracePrompt==0 ) yyTraceFILE = 0; |
831 | 0 | } |
832 | | #endif /* NDEBUG */ |
833 | | |
834 | | #if defined(YYCOVERAGE) || !defined(NDEBUG) |
835 | | /* For tracing shifts, the names of all terminals and nonterminals |
836 | | ** are required. The following table supplies these names */ |
837 | | static const char *const yyTokenName[] = { |
838 | | /* 0 */ "$", |
839 | | /* 1 */ "ID", |
840 | | /* 2 */ "BOOL", |
841 | | /* 3 */ "TINYINT", |
842 | | /* 4 */ "SMALLINT", |
843 | | /* 5 */ "INTEGER", |
844 | | /* 6 */ "BIGINT", |
845 | | /* 7 */ "FLOAT", |
846 | | /* 8 */ "DOUBLE", |
847 | | /* 9 */ "STRING", |
848 | | /* 10 */ "TIMESTAMP", |
849 | | /* 11 */ "BINARY", |
850 | | /* 12 */ "NCHAR", |
851 | | /* 13 */ "JSON", |
852 | | /* 14 */ "OR", |
853 | | /* 15 */ "AND", |
854 | | /* 16 */ "NOT", |
855 | | /* 17 */ "EQ", |
856 | | /* 18 */ "NE", |
857 | | /* 19 */ "ISNULL", |
858 | | /* 20 */ "NOTNULL", |
859 | | /* 21 */ "IS", |
860 | | /* 22 */ "LIKE", |
861 | | /* 23 */ "MATCH", |
862 | | /* 24 */ "NMATCH", |
863 | | /* 25 */ "CONTAINS", |
864 | | /* 26 */ "GLOB", |
865 | | /* 27 */ "BETWEEN", |
866 | | /* 28 */ "IN", |
867 | | /* 29 */ "GT", |
868 | | /* 30 */ "GE", |
869 | | /* 31 */ "LT", |
870 | | /* 32 */ "LE", |
871 | | /* 33 */ "BITAND", |
872 | | /* 34 */ "BITOR", |
873 | | /* 35 */ "LSHIFT", |
874 | | /* 36 */ "RSHIFT", |
875 | | /* 37 */ "PLUS", |
876 | | /* 38 */ "MINUS", |
877 | | /* 39 */ "DIVIDE", |
878 | | /* 40 */ "TIMES", |
879 | | /* 41 */ "STAR", |
880 | | /* 42 */ "SLASH", |
881 | | /* 43 */ "REM", |
882 | | /* 44 */ "UMINUS", |
883 | | /* 45 */ "UPLUS", |
884 | | /* 46 */ "BITNOT", |
885 | | /* 47 */ "ARROW", |
886 | | /* 48 */ "SHOW", |
887 | | /* 49 */ "DATABASES", |
888 | | /* 50 */ "TOPICS", |
889 | | /* 51 */ "FUNCTIONS", |
890 | | /* 52 */ "MNODES", |
891 | | /* 53 */ "DNODES", |
892 | | /* 54 */ "ACCOUNTS", |
893 | | /* 55 */ "USERS", |
894 | | /* 56 */ "MODULES", |
895 | | /* 57 */ "QUERIES", |
896 | | /* 58 */ "CONNECTIONS", |
897 | | /* 59 */ "STREAMS", |
898 | | /* 60 */ "VARIABLES", |
899 | | /* 61 */ "SCORES", |
900 | | /* 62 */ "GRANTS", |
901 | | /* 63 */ "VNODES", |
902 | | /* 64 */ "DOT", |
903 | | /* 65 */ "CREATE", |
904 | | /* 66 */ "TABLE", |
905 | | /* 67 */ "STABLE", |
906 | | /* 68 */ "DATABASE", |
907 | | /* 69 */ "TABLES", |
908 | | /* 70 */ "STABLES", |
909 | | /* 71 */ "VGROUPS", |
910 | | /* 72 */ "DROP", |
911 | | /* 73 */ "TOPIC", |
912 | | /* 74 */ "FUNCTION", |
913 | | /* 75 */ "DNODE", |
914 | | /* 76 */ "USER", |
915 | | /* 77 */ "ACCOUNT", |
916 | | /* 78 */ "USE", |
917 | | /* 79 */ "DESCRIBE", |
918 | | /* 80 */ "DESC", |
919 | | /* 81 */ "ALTER", |
920 | | /* 82 */ "PASS", |
921 | | /* 83 */ "PRIVILEGE", |
922 | | /* 84 */ "LOCAL", |
923 | | /* 85 */ "COMPACT", |
924 | | /* 86 */ "LP", |
925 | | /* 87 */ "RP", |
926 | | /* 88 */ "IF", |
927 | | /* 89 */ "EXISTS", |
928 | | /* 90 */ "AS", |
929 | | /* 91 */ "OUTPUTTYPE", |
930 | | /* 92 */ "AGGREGATE", |
931 | | /* 93 */ "BUFSIZE", |
932 | | /* 94 */ "PPS", |
933 | | /* 95 */ "TSERIES", |
934 | | /* 96 */ "DBS", |
935 | | /* 97 */ "STORAGE", |
936 | | /* 98 */ "QTIME", |
937 | | /* 99 */ "CONNS", |
938 | | /* 100 */ "STATE", |
939 | | /* 101 */ "COMMA", |
940 | | /* 102 */ "KEEP", |
941 | | /* 103 */ "CACHE", |
942 | | /* 104 */ "REPLICA", |
943 | | /* 105 */ "QUORUM", |
944 | | /* 106 */ "DAYS", |
945 | | /* 107 */ "MINROWS", |
946 | | /* 108 */ "MAXROWS", |
947 | | /* 109 */ "BLOCKS", |
948 | | /* 110 */ "CTIME", |
949 | | /* 111 */ "WAL", |
950 | | /* 112 */ "FSYNC", |
951 | | /* 113 */ "COMP", |
952 | | /* 114 */ "PRECISION", |
953 | | /* 115 */ "UPDATE", |
954 | | /* 116 */ "CACHELAST", |
955 | | /* 117 */ "PARTITIONS", |
956 | | /* 118 */ "UNSIGNED", |
957 | | /* 119 */ "TAGS", |
958 | | /* 120 */ "USING", |
959 | | /* 121 */ "TO", |
960 | | /* 122 */ "SPLIT", |
961 | | /* 123 */ "NULL", |
962 | | /* 124 */ "NOW", |
963 | | /* 125 */ "VARIABLE", |
964 | | /* 126 */ "SELECT", |
965 | | /* 127 */ "UNION", |
966 | | /* 128 */ "ALL", |
967 | | /* 129 */ "DISTINCT", |
968 | | /* 130 */ "FROM", |
969 | | /* 131 */ "RANGE", |
970 | | /* 132 */ "INTERVAL", |
971 | | /* 133 */ "EVERY", |
972 | | /* 134 */ "SESSION", |
973 | | /* 135 */ "STATE_WINDOW", |
974 | | /* 136 */ "FILL", |
975 | | /* 137 */ "SLIDING", |
976 | | /* 138 */ "ORDER", |
977 | | /* 139 */ "BY", |
978 | | /* 140 */ "ASC", |
979 | | /* 141 */ "GROUP", |
980 | | /* 142 */ "HAVING", |
981 | | /* 143 */ "LIMIT", |
982 | | /* 144 */ "OFFSET", |
983 | | /* 145 */ "SLIMIT", |
984 | | /* 146 */ "SOFFSET", |
985 | | /* 147 */ "WHERE", |
986 | | /* 148 */ "TODAY", |
987 | | /* 149 */ "RESET", |
988 | | /* 150 */ "QUERY", |
989 | | /* 151 */ "SYNCDB", |
990 | | /* 152 */ "ADD", |
991 | | /* 153 */ "COLUMN", |
992 | | /* 154 */ "MODIFY", |
993 | | /* 155 */ "TAG", |
994 | | /* 156 */ "CHANGE", |
995 | | /* 157 */ "SET", |
996 | | /* 158 */ "KILL", |
997 | | /* 159 */ "CONNECTION", |
998 | | /* 160 */ "STREAM", |
999 | | /* 161 */ "COLON", |
1000 | | /* 162 */ "DELETE", |
1001 | | /* 163 */ "ABORT", |
1002 | | /* 164 */ "AFTER", |
1003 | | /* 165 */ "ATTACH", |
1004 | | /* 166 */ "BEFORE", |
1005 | | /* 167 */ "BEGIN", |
1006 | | /* 168 */ "CASCADE", |
1007 | | /* 169 */ "CLUSTER", |
1008 | | /* 170 */ "CONFLICT", |
1009 | | /* 171 */ "COPY", |
1010 | | /* 172 */ "DEFERRED", |
1011 | | /* 173 */ "DELIMITERS", |
1012 | | /* 174 */ "DETACH", |
1013 | | /* 175 */ "EACH", |
1014 | | /* 176 */ "END", |
1015 | | /* 177 */ "EXPLAIN", |
1016 | | /* 178 */ "FAIL", |
1017 | | /* 179 */ "FOR", |
1018 | | /* 180 */ "IGNORE", |
1019 | | /* 181 */ "IMMEDIATE", |
1020 | | /* 182 */ "INITIALLY", |
1021 | | /* 183 */ "INSTEAD", |
1022 | | /* 184 */ "KEY", |
1023 | | /* 185 */ "OF", |
1024 | | /* 186 */ "RAISE", |
1025 | | /* 187 */ "REPLACE", |
1026 | | /* 188 */ "RESTRICT", |
1027 | | /* 189 */ "ROW", |
1028 | | /* 190 */ "STATEMENT", |
1029 | | /* 191 */ "TRIGGER", |
1030 | | /* 192 */ "VIEW", |
1031 | | /* 193 */ "IPTOKEN", |
1032 | | /* 194 */ "SEMI", |
1033 | | /* 195 */ "NONE", |
1034 | | /* 196 */ "PREV", |
1035 | | /* 197 */ "LINEAR", |
1036 | | /* 198 */ "IMPORT", |
1037 | | /* 199 */ "TBNAME", |
1038 | | /* 200 */ "JOIN", |
1039 | | /* 201 */ "INSERT", |
1040 | | /* 202 */ "INTO", |
1041 | | /* 203 */ "VALUES", |
1042 | | /* 204 */ "FILE", |
1043 | | /* 205 */ "error", |
1044 | | /* 206 */ "program", |
1045 | | /* 207 */ "cmd", |
1046 | | /* 208 */ "ids", |
1047 | | /* 209 */ "dbPrefix", |
1048 | | /* 210 */ "cpxName", |
1049 | | /* 211 */ "ifexists", |
1050 | | /* 212 */ "alter_db_optr", |
1051 | | /* 213 */ "alter_topic_optr", |
1052 | | /* 214 */ "acct_optr", |
1053 | | /* 215 */ "exprlist", |
1054 | | /* 216 */ "ifnotexists", |
1055 | | /* 217 */ "db_optr", |
1056 | | /* 218 */ "topic_optr", |
1057 | | /* 219 */ "typename", |
1058 | | /* 220 */ "bufsize", |
1059 | | /* 221 */ "pps", |
1060 | | /* 222 */ "tseries", |
1061 | | /* 223 */ "dbs", |
1062 | | /* 224 */ "streams", |
1063 | | /* 225 */ "storage", |
1064 | | /* 226 */ "qtime", |
1065 | | /* 227 */ "users", |
1066 | | /* 228 */ "conns", |
1067 | | /* 229 */ "state", |
1068 | | /* 230 */ "intitemlist", |
1069 | | /* 231 */ "intitem", |
1070 | | /* 232 */ "keep", |
1071 | | /* 233 */ "cache", |
1072 | | /* 234 */ "replica", |
1073 | | /* 235 */ "quorum", |
1074 | | /* 236 */ "days", |
1075 | | /* 237 */ "minrows", |
1076 | | /* 238 */ "maxrows", |
1077 | | /* 239 */ "blocks", |
1078 | | /* 240 */ "ctime", |
1079 | | /* 241 */ "wal", |
1080 | | /* 242 */ "fsync", |
1081 | | /* 243 */ "comp", |
1082 | | /* 244 */ "prec", |
1083 | | /* 245 */ "update", |
1084 | | /* 246 */ "cachelast", |
1085 | | /* 247 */ "partitions", |
1086 | | /* 248 */ "signed", |
1087 | | /* 249 */ "create_table_args", |
1088 | | /* 250 */ "create_stable_args", |
1089 | | /* 251 */ "create_table_list", |
1090 | | /* 252 */ "create_from_stable", |
1091 | | /* 253 */ "columnlist", |
1092 | | /* 254 */ "tagitemlist", |
1093 | | /* 255 */ "tagNamelist", |
1094 | | /* 256 */ "to_opt", |
1095 | | /* 257 */ "split_opt", |
1096 | | /* 258 */ "select", |
1097 | | /* 259 */ "to_split", |
1098 | | /* 260 */ "column", |
1099 | | /* 261 */ "tagitem", |
1100 | | /* 262 */ "selcollist", |
1101 | | /* 263 */ "from", |
1102 | | /* 264 */ "where_opt", |
1103 | | /* 265 */ "range_option", |
1104 | | /* 266 */ "interval_option", |
1105 | | /* 267 */ "sliding_opt", |
1106 | | /* 268 */ "session_option", |
1107 | | /* 269 */ "windowstate_option", |
1108 | | /* 270 */ "fill_opt", |
1109 | | /* 271 */ "groupby_opt", |
1110 | | /* 272 */ "having_opt", |
1111 | | /* 273 */ "orderby_opt", |
1112 | | /* 274 */ "slimit_opt", |
1113 | | /* 275 */ "limit_opt", |
1114 | | /* 276 */ "union", |
1115 | | /* 277 */ "sclp", |
1116 | | /* 278 */ "distinct", |
1117 | | /* 279 */ "expr", |
1118 | | /* 280 */ "as", |
1119 | | /* 281 */ "tablelist", |
1120 | | /* 282 */ "sub", |
1121 | | /* 283 */ "tmvar", |
1122 | | /* 284 */ "timestamp", |
1123 | | /* 285 */ "intervalKey", |
1124 | | /* 286 */ "sortlist", |
1125 | | /* 287 */ "item", |
1126 | | /* 288 */ "sortorder", |
1127 | | /* 289 */ "arrow", |
1128 | | /* 290 */ "grouplist", |
1129 | | /* 291 */ "expritem", |
1130 | | }; |
1131 | | #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */ |
1132 | | |
1133 | | #ifndef NDEBUG |
1134 | | /* For tracing reduce actions, the names of all rules are required. |
1135 | | */ |
1136 | | static const char *const yyRuleName[] = { |
1137 | | /* 0 */ "program ::= cmd", |
1138 | | /* 1 */ "cmd ::= SHOW DATABASES", |
1139 | | /* 2 */ "cmd ::= SHOW TOPICS", |
1140 | | /* 3 */ "cmd ::= SHOW FUNCTIONS", |
1141 | | /* 4 */ "cmd ::= SHOW MNODES", |
1142 | | /* 5 */ "cmd ::= SHOW DNODES", |
1143 | | /* 6 */ "cmd ::= SHOW ACCOUNTS", |
1144 | | /* 7 */ "cmd ::= SHOW USERS", |
1145 | | /* 8 */ "cmd ::= SHOW MODULES", |
1146 | | /* 9 */ "cmd ::= SHOW QUERIES", |
1147 | | /* 10 */ "cmd ::= SHOW CONNECTIONS", |
1148 | | /* 11 */ "cmd ::= SHOW STREAMS", |
1149 | | /* 12 */ "cmd ::= SHOW VARIABLES", |
1150 | | /* 13 */ "cmd ::= SHOW SCORES", |
1151 | | /* 14 */ "cmd ::= SHOW GRANTS", |
1152 | | /* 15 */ "cmd ::= SHOW VNODES", |
1153 | | /* 16 */ "cmd ::= SHOW VNODES ids", |
1154 | | /* 17 */ "dbPrefix ::=", |
1155 | | /* 18 */ "dbPrefix ::= ids DOT", |
1156 | | /* 19 */ "cpxName ::=", |
1157 | | /* 20 */ "cpxName ::= DOT ids", |
1158 | | /* 21 */ "cmd ::= SHOW CREATE TABLE ids cpxName", |
1159 | | /* 22 */ "cmd ::= SHOW CREATE STABLE ids cpxName", |
1160 | | /* 23 */ "cmd ::= SHOW CREATE DATABASE ids", |
1161 | | /* 24 */ "cmd ::= SHOW dbPrefix TABLES", |
1162 | | /* 25 */ "cmd ::= SHOW dbPrefix TABLES LIKE STRING", |
1163 | | /* 26 */ "cmd ::= SHOW dbPrefix STABLES", |
1164 | | /* 27 */ "cmd ::= SHOW dbPrefix STABLES LIKE STRING", |
1165 | | /* 28 */ "cmd ::= SHOW dbPrefix VGROUPS", |
1166 | | /* 29 */ "cmd ::= DROP TABLE ifexists ids cpxName", |
1167 | | /* 30 */ "cmd ::= DROP STABLE ifexists ids cpxName", |
1168 | | /* 31 */ "cmd ::= DROP DATABASE ifexists ids", |
1169 | | /* 32 */ "cmd ::= DROP TOPIC ifexists ids", |
1170 | | /* 33 */ "cmd ::= DROP FUNCTION ids", |
1171 | | /* 34 */ "cmd ::= DROP DNODE ids", |
1172 | | /* 35 */ "cmd ::= DROP USER ids", |
1173 | | /* 36 */ "cmd ::= DROP ACCOUNT ids", |
1174 | | /* 37 */ "cmd ::= USE ids", |
1175 | | /* 38 */ "cmd ::= DESCRIBE ids cpxName", |
1176 | | /* 39 */ "cmd ::= DESC ids cpxName", |
1177 | | /* 40 */ "cmd ::= ALTER USER ids PASS ids", |
1178 | | /* 41 */ "cmd ::= ALTER USER ids PRIVILEGE ids", |
1179 | | /* 42 */ "cmd ::= ALTER DNODE ids ids", |
1180 | | /* 43 */ "cmd ::= ALTER DNODE ids ids ids", |
1181 | | /* 44 */ "cmd ::= ALTER LOCAL ids", |
1182 | | /* 45 */ "cmd ::= ALTER LOCAL ids ids", |
1183 | | /* 46 */ "cmd ::= ALTER DATABASE ids alter_db_optr", |
1184 | | /* 47 */ "cmd ::= ALTER TOPIC ids alter_topic_optr", |
1185 | | /* 48 */ "cmd ::= ALTER ACCOUNT ids acct_optr", |
1186 | | /* 49 */ "cmd ::= ALTER ACCOUNT ids PASS ids acct_optr", |
1187 | | /* 50 */ "cmd ::= COMPACT VNODES IN LP exprlist RP", |
1188 | | /* 51 */ "ids ::= ID", |
1189 | | /* 52 */ "ids ::= STRING", |
1190 | | /* 53 */ "ifexists ::= IF EXISTS", |
1191 | | /* 54 */ "ifexists ::=", |
1192 | | /* 55 */ "ifnotexists ::= IF NOT EXISTS", |
1193 | | /* 56 */ "ifnotexists ::=", |
1194 | | /* 57 */ "cmd ::= CREATE DNODE ids", |
1195 | | /* 58 */ "cmd ::= CREATE ACCOUNT ids PASS ids acct_optr", |
1196 | | /* 59 */ "cmd ::= CREATE DATABASE ifnotexists ids db_optr", |
1197 | | /* 60 */ "cmd ::= CREATE TOPIC ifnotexists ids topic_optr", |
1198 | | /* 61 */ "cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize", |
1199 | | /* 62 */ "cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize", |
1200 | | /* 63 */ "cmd ::= CREATE USER ids PASS ids", |
1201 | | /* 64 */ "bufsize ::=", |
1202 | | /* 65 */ "bufsize ::= BUFSIZE INTEGER", |
1203 | | /* 66 */ "pps ::=", |
1204 | | /* 67 */ "pps ::= PPS INTEGER", |
1205 | | /* 68 */ "tseries ::=", |
1206 | | /* 69 */ "tseries ::= TSERIES INTEGER", |
1207 | | /* 70 */ "dbs ::=", |
1208 | | /* 71 */ "dbs ::= DBS INTEGER", |
1209 | | /* 72 */ "streams ::=", |
1210 | | /* 73 */ "streams ::= STREAMS INTEGER", |
1211 | | /* 74 */ "storage ::=", |
1212 | | /* 75 */ "storage ::= STORAGE INTEGER", |
1213 | | /* 76 */ "qtime ::=", |
1214 | | /* 77 */ "qtime ::= QTIME INTEGER", |
1215 | | /* 78 */ "users ::=", |
1216 | | /* 79 */ "users ::= USERS INTEGER", |
1217 | | /* 80 */ "conns ::=", |
1218 | | /* 81 */ "conns ::= CONNS INTEGER", |
1219 | | /* 82 */ "state ::=", |
1220 | | /* 83 */ "state ::= STATE ids", |
1221 | | /* 84 */ "acct_optr ::= pps tseries storage streams qtime dbs users conns state", |
1222 | | /* 85 */ "intitemlist ::= intitemlist COMMA intitem", |
1223 | | /* 86 */ "intitemlist ::= intitem", |
1224 | | /* 87 */ "intitem ::= INTEGER", |
1225 | | /* 88 */ "keep ::= KEEP intitemlist", |
1226 | | /* 89 */ "cache ::= CACHE INTEGER", |
1227 | | /* 90 */ "replica ::= REPLICA INTEGER", |
1228 | | /* 91 */ "quorum ::= QUORUM INTEGER", |
1229 | | /* 92 */ "days ::= DAYS INTEGER", |
1230 | | /* 93 */ "minrows ::= MINROWS INTEGER", |
1231 | | /* 94 */ "maxrows ::= MAXROWS INTEGER", |
1232 | | /* 95 */ "blocks ::= BLOCKS INTEGER", |
1233 | | /* 96 */ "ctime ::= CTIME INTEGER", |
1234 | | /* 97 */ "wal ::= WAL INTEGER", |
1235 | | /* 98 */ "fsync ::= FSYNC INTEGER", |
1236 | | /* 99 */ "comp ::= COMP INTEGER", |
1237 | | /* 100 */ "prec ::= PRECISION STRING", |
1238 | | /* 101 */ "update ::= UPDATE INTEGER", |
1239 | | /* 102 */ "cachelast ::= CACHELAST INTEGER", |
1240 | | /* 103 */ "partitions ::= PARTITIONS INTEGER", |
1241 | | /* 104 */ "db_optr ::=", |
1242 | | /* 105 */ "db_optr ::= db_optr cache", |
1243 | | /* 106 */ "db_optr ::= db_optr replica", |
1244 | | /* 107 */ "db_optr ::= db_optr quorum", |
1245 | | /* 108 */ "db_optr ::= db_optr days", |
1246 | | /* 109 */ "db_optr ::= db_optr minrows", |
1247 | | /* 110 */ "db_optr ::= db_optr maxrows", |
1248 | | /* 111 */ "db_optr ::= db_optr blocks", |
1249 | | /* 112 */ "db_optr ::= db_optr ctime", |
1250 | | /* 113 */ "db_optr ::= db_optr wal", |
1251 | | /* 114 */ "db_optr ::= db_optr fsync", |
1252 | | /* 115 */ "db_optr ::= db_optr comp", |
1253 | | /* 116 */ "db_optr ::= db_optr prec", |
1254 | | /* 117 */ "db_optr ::= db_optr keep", |
1255 | | /* 118 */ "db_optr ::= db_optr update", |
1256 | | /* 119 */ "db_optr ::= db_optr cachelast", |
1257 | | /* 120 */ "topic_optr ::= db_optr", |
1258 | | /* 121 */ "topic_optr ::= topic_optr partitions", |
1259 | | /* 122 */ "alter_db_optr ::=", |
1260 | | /* 123 */ "alter_db_optr ::= alter_db_optr replica", |
1261 | | /* 124 */ "alter_db_optr ::= alter_db_optr quorum", |
1262 | | /* 125 */ "alter_db_optr ::= alter_db_optr keep", |
1263 | | /* 126 */ "alter_db_optr ::= alter_db_optr blocks", |
1264 | | /* 127 */ "alter_db_optr ::= alter_db_optr comp", |
1265 | | /* 128 */ "alter_db_optr ::= alter_db_optr update", |
1266 | | /* 129 */ "alter_db_optr ::= alter_db_optr cachelast", |
1267 | | /* 130 */ "alter_topic_optr ::= alter_db_optr", |
1268 | | /* 131 */ "alter_topic_optr ::= alter_topic_optr partitions", |
1269 | | /* 132 */ "typename ::= ids", |
1270 | | /* 133 */ "typename ::= ids LP signed RP", |
1271 | | /* 134 */ "typename ::= ids UNSIGNED", |
1272 | | /* 135 */ "signed ::= INTEGER", |
1273 | | /* 136 */ "signed ::= PLUS INTEGER", |
1274 | | /* 137 */ "signed ::= MINUS INTEGER", |
1275 | | /* 138 */ "cmd ::= CREATE TABLE create_table_args", |
1276 | | /* 139 */ "cmd ::= CREATE TABLE create_stable_args", |
1277 | | /* 140 */ "cmd ::= CREATE STABLE create_stable_args", |
1278 | | /* 141 */ "cmd ::= CREATE TABLE create_table_list", |
1279 | | /* 142 */ "create_table_list ::= create_from_stable", |
1280 | | /* 143 */ "create_table_list ::= create_table_list create_from_stable", |
1281 | | /* 144 */ "create_table_args ::= ifnotexists ids cpxName LP columnlist RP", |
1282 | | /* 145 */ "create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP", |
1283 | | /* 146 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP", |
1284 | | /* 147 */ "create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP", |
1285 | | /* 148 */ "tagNamelist ::= tagNamelist COMMA ids", |
1286 | | /* 149 */ "tagNamelist ::= ids", |
1287 | | /* 150 */ "create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select", |
1288 | | /* 151 */ "to_opt ::=", |
1289 | | /* 152 */ "to_opt ::= TO ids cpxName", |
1290 | | /* 153 */ "split_opt ::=", |
1291 | | /* 154 */ "split_opt ::= SPLIT ids", |
1292 | | /* 155 */ "columnlist ::= columnlist COMMA column", |
1293 | | /* 156 */ "columnlist ::= column", |
1294 | | /* 157 */ "column ::= ids typename", |
1295 | | /* 158 */ "tagitemlist ::= tagitemlist COMMA tagitem", |
1296 | | /* 159 */ "tagitemlist ::= tagitem", |
1297 | | /* 160 */ "tagitem ::= INTEGER", |
1298 | | /* 161 */ "tagitem ::= FLOAT", |
1299 | | /* 162 */ "tagitem ::= STRING", |
1300 | | /* 163 */ "tagitem ::= BOOL", |
1301 | | /* 164 */ "tagitem ::= NULL", |
1302 | | /* 165 */ "tagitem ::= NOW", |
1303 | | /* 166 */ "tagitem ::= NOW PLUS VARIABLE", |
1304 | | /* 167 */ "tagitem ::= NOW MINUS VARIABLE", |
1305 | | /* 168 */ "tagitem ::= MINUS INTEGER", |
1306 | | /* 169 */ "tagitem ::= MINUS FLOAT", |
1307 | | /* 170 */ "tagitem ::= PLUS INTEGER", |
1308 | | /* 171 */ "tagitem ::= PLUS FLOAT", |
1309 | | /* 172 */ "select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt", |
1310 | | /* 173 */ "select ::= LP select RP", |
1311 | | /* 174 */ "union ::= select", |
1312 | | /* 175 */ "union ::= union UNION ALL select", |
1313 | | /* 176 */ "cmd ::= union", |
1314 | | /* 177 */ "select ::= SELECT selcollist", |
1315 | | /* 178 */ "sclp ::= selcollist COMMA", |
1316 | | /* 179 */ "sclp ::=", |
1317 | | /* 180 */ "selcollist ::= sclp distinct expr as", |
1318 | | /* 181 */ "selcollist ::= sclp STAR", |
1319 | | /* 182 */ "as ::= AS ids", |
1320 | | /* 183 */ "as ::= ids", |
1321 | | /* 184 */ "as ::=", |
1322 | | /* 185 */ "distinct ::= DISTINCT", |
1323 | | /* 186 */ "distinct ::=", |
1324 | | /* 187 */ "from ::= FROM tablelist", |
1325 | | /* 188 */ "from ::= FROM sub", |
1326 | | /* 189 */ "sub ::= LP union RP", |
1327 | | /* 190 */ "sub ::= LP union RP ids", |
1328 | | /* 191 */ "sub ::= sub COMMA LP union RP ids", |
1329 | | /* 192 */ "tablelist ::= ids cpxName", |
1330 | | /* 193 */ "tablelist ::= ids cpxName ids", |
1331 | | /* 194 */ "tablelist ::= tablelist COMMA ids cpxName", |
1332 | | /* 195 */ "tablelist ::= tablelist COMMA ids cpxName ids", |
1333 | | /* 196 */ "tmvar ::= VARIABLE", |
1334 | | /* 197 */ "timestamp ::= INTEGER", |
1335 | | /* 198 */ "timestamp ::= MINUS INTEGER", |
1336 | | /* 199 */ "timestamp ::= PLUS INTEGER", |
1337 | | /* 200 */ "timestamp ::= STRING", |
1338 | | /* 201 */ "timestamp ::= NOW", |
1339 | | /* 202 */ "timestamp ::= NOW PLUS VARIABLE", |
1340 | | /* 203 */ "timestamp ::= NOW MINUS VARIABLE", |
1341 | | /* 204 */ "range_option ::=", |
1342 | | /* 205 */ "range_option ::= RANGE LP timestamp COMMA timestamp RP", |
1343 | | /* 206 */ "interval_option ::= intervalKey LP tmvar RP", |
1344 | | /* 207 */ "interval_option ::= intervalKey LP tmvar COMMA tmvar RP", |
1345 | | /* 208 */ "interval_option ::=", |
1346 | | /* 209 */ "intervalKey ::= INTERVAL", |
1347 | | /* 210 */ "intervalKey ::= EVERY", |
1348 | | /* 211 */ "session_option ::=", |
1349 | | /* 212 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP", |
1350 | | /* 213 */ "windowstate_option ::=", |
1351 | | /* 214 */ "windowstate_option ::= STATE_WINDOW LP ids RP", |
1352 | | /* 215 */ "fill_opt ::=", |
1353 | | /* 216 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP", |
1354 | | /* 217 */ "fill_opt ::= FILL LP ID RP", |
1355 | | /* 218 */ "sliding_opt ::= SLIDING LP tmvar RP", |
1356 | | /* 219 */ "sliding_opt ::=", |
1357 | | /* 220 */ "orderby_opt ::=", |
1358 | | /* 221 */ "orderby_opt ::= ORDER BY sortlist", |
1359 | | /* 222 */ "sortlist ::= sortlist COMMA item sortorder", |
1360 | | /* 223 */ "sortlist ::= sortlist COMMA arrow sortorder", |
1361 | | /* 224 */ "sortlist ::= item sortorder", |
1362 | | /* 225 */ "sortlist ::= arrow sortorder", |
1363 | | /* 226 */ "item ::= ID", |
1364 | | /* 227 */ "item ::= ID DOT ID", |
1365 | | /* 228 */ "sortorder ::= ASC", |
1366 | | /* 229 */ "sortorder ::= DESC", |
1367 | | /* 230 */ "sortorder ::=", |
1368 | | /* 231 */ "groupby_opt ::=", |
1369 | | /* 232 */ "groupby_opt ::= GROUP BY grouplist", |
1370 | | /* 233 */ "grouplist ::= grouplist COMMA item", |
1371 | | /* 234 */ "grouplist ::= grouplist COMMA arrow", |
1372 | | /* 235 */ "grouplist ::= item", |
1373 | | /* 236 */ "grouplist ::= arrow", |
1374 | | /* 237 */ "having_opt ::=", |
1375 | | /* 238 */ "having_opt ::= HAVING expr", |
1376 | | /* 239 */ "limit_opt ::=", |
1377 | | /* 240 */ "limit_opt ::= LIMIT signed", |
1378 | | /* 241 */ "limit_opt ::= LIMIT signed OFFSET signed", |
1379 | | /* 242 */ "limit_opt ::= LIMIT signed COMMA signed", |
1380 | | /* 243 */ "slimit_opt ::=", |
1381 | | /* 244 */ "slimit_opt ::= SLIMIT signed", |
1382 | | /* 245 */ "slimit_opt ::= SLIMIT signed SOFFSET signed", |
1383 | | /* 246 */ "slimit_opt ::= SLIMIT signed COMMA signed", |
1384 | | /* 247 */ "where_opt ::=", |
1385 | | /* 248 */ "where_opt ::= WHERE expr", |
1386 | | /* 249 */ "expr ::= LP expr RP", |
1387 | | /* 250 */ "expr ::= ID", |
1388 | | /* 251 */ "expr ::= ID DOT ID", |
1389 | | /* 252 */ "expr ::= ID DOT STAR", |
1390 | | /* 253 */ "expr ::= INTEGER", |
1391 | | /* 254 */ "expr ::= MINUS INTEGER", |
1392 | | /* 255 */ "expr ::= PLUS INTEGER", |
1393 | | /* 256 */ "expr ::= FLOAT", |
1394 | | /* 257 */ "expr ::= MINUS FLOAT", |
1395 | | /* 258 */ "expr ::= PLUS FLOAT", |
1396 | | /* 259 */ "expr ::= STRING", |
1397 | | /* 260 */ "expr ::= NOW", |
1398 | | /* 261 */ "expr ::= TODAY", |
1399 | | /* 262 */ "expr ::= VARIABLE", |
1400 | | /* 263 */ "expr ::= PLUS VARIABLE", |
1401 | | /* 264 */ "expr ::= MINUS VARIABLE", |
1402 | | /* 265 */ "expr ::= BOOL", |
1403 | | /* 266 */ "expr ::= NULL", |
1404 | | /* 267 */ "expr ::= ID LP exprlist RP", |
1405 | | /* 268 */ "expr ::= ID LP STAR RP", |
1406 | | /* 269 */ "expr ::= ID LP expr AS typename RP", |
1407 | | /* 270 */ "expr ::= expr IS NULL", |
1408 | | /* 271 */ "expr ::= expr IS NOT NULL", |
1409 | | /* 272 */ "expr ::= expr LT expr", |
1410 | | /* 273 */ "expr ::= expr GT expr", |
1411 | | /* 274 */ "expr ::= expr LE expr", |
1412 | | /* 275 */ "expr ::= expr GE expr", |
1413 | | /* 276 */ "expr ::= expr NE expr", |
1414 | | /* 277 */ "expr ::= expr EQ expr", |
1415 | | /* 278 */ "expr ::= expr BETWEEN expr AND expr", |
1416 | | /* 279 */ "expr ::= expr AND expr", |
1417 | | /* 280 */ "expr ::= expr OR expr", |
1418 | | /* 281 */ "expr ::= expr PLUS expr", |
1419 | | /* 282 */ "expr ::= expr MINUS expr", |
1420 | | /* 283 */ "expr ::= expr STAR expr", |
1421 | | /* 284 */ "expr ::= expr SLASH expr", |
1422 | | /* 285 */ "expr ::= expr REM expr", |
1423 | | /* 286 */ "expr ::= expr BITAND expr", |
1424 | | /* 287 */ "expr ::= expr LIKE expr", |
1425 | | /* 288 */ "expr ::= expr MATCH expr", |
1426 | | /* 289 */ "expr ::= expr NMATCH expr", |
1427 | | /* 290 */ "expr ::= ID CONTAINS STRING", |
1428 | | /* 291 */ "expr ::= ID DOT ID CONTAINS STRING", |
1429 | | /* 292 */ "arrow ::= ID ARROW STRING", |
1430 | | /* 293 */ "arrow ::= ID DOT ID ARROW STRING", |
1431 | | /* 294 */ "expr ::= arrow", |
1432 | | /* 295 */ "expr ::= expr IN LP exprlist RP", |
1433 | | /* 296 */ "exprlist ::= exprlist COMMA expritem", |
1434 | | /* 297 */ "exprlist ::= expritem", |
1435 | | /* 298 */ "expritem ::= expr", |
1436 | | /* 299 */ "expritem ::=", |
1437 | | /* 300 */ "cmd ::= RESET QUERY CACHE", |
1438 | | /* 301 */ "cmd ::= SYNCDB ids REPLICA", |
1439 | | /* 302 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist", |
1440 | | /* 303 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids", |
1441 | | /* 304 */ "cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist", |
1442 | | /* 305 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist", |
1443 | | /* 306 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids", |
1444 | | /* 307 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids", |
1445 | | /* 308 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem", |
1446 | | /* 309 */ "cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist", |
1447 | | /* 310 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist", |
1448 | | /* 311 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids", |
1449 | | /* 312 */ "cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist", |
1450 | | /* 313 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist", |
1451 | | /* 314 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids", |
1452 | | /* 315 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids", |
1453 | | /* 316 */ "cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem", |
1454 | | /* 317 */ "cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist", |
1455 | | /* 318 */ "cmd ::= KILL CONNECTION INTEGER", |
1456 | | /* 319 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER", |
1457 | | /* 320 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER", |
1458 | | /* 321 */ "cmd ::= DELETE FROM ifexists ids cpxName where_opt", |
1459 | | }; |
1460 | | #endif /* NDEBUG */ |
1461 | | |
1462 | | |
1463 | | #if YYSTACKDEPTH<=0 |
1464 | | /* |
1465 | | ** Try to increase the size of the parser stack. Return the number |
1466 | | ** of errors. Return 0 on success. |
1467 | | */ |
1468 | | static int yyGrowStack(yyParser *p){ |
1469 | | int newSize; |
1470 | | int idx; |
1471 | | yyStackEntry *pNew; |
1472 | | |
1473 | | newSize = p->yystksz*2 + 100; |
1474 | | idx = p->yytos ? (int)(p->yytos - p->yystack) : 0; |
1475 | | if( p->yystack==&p->yystk0 ){ |
1476 | | pNew = malloc(newSize*sizeof(pNew[0])); |
1477 | | if( pNew ) pNew[0] = p->yystk0; |
1478 | | }else{ |
1479 | | pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); |
1480 | | } |
1481 | | if( pNew ){ |
1482 | | p->yystack = pNew; |
1483 | | p->yytos = &p->yystack[idx]; |
1484 | | #ifndef NDEBUG |
1485 | | if( yyTraceFILE ){ |
1486 | | fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n", |
1487 | | yyTracePrompt, p->yystksz, newSize); |
1488 | | } |
1489 | | #endif |
1490 | | p->yystksz = newSize; |
1491 | | } |
1492 | | return pNew==0; |
1493 | | } |
1494 | | #endif |
1495 | | |
1496 | | /* Datatype of the argument to the memory allocated passed as the |
1497 | | ** second argument to ParseAlloc() below. This can be changed by |
1498 | | ** putting an appropriate #define in the %include section of the input |
1499 | | ** grammar. |
1500 | | */ |
1501 | | #ifndef YYMALLOCARGTYPE |
1502 | | # define YYMALLOCARGTYPE size_t |
1503 | | #endif |
1504 | | |
1505 | | /* Initialize a new parser that has already been allocated. |
1506 | | */ |
1507 | 5.52k | void ParseInit(void *yypParser){ |
1508 | 5.52k | yyParser *pParser = (yyParser*)yypParser; |
1509 | | #ifdef YYTRACKMAXSTACKDEPTH |
1510 | | pParser->yyhwm = 0; |
1511 | | #endif |
1512 | | #if YYSTACKDEPTH<=0 |
1513 | | pParser->yytos = NULL; |
1514 | | pParser->yystack = NULL; |
1515 | | pParser->yystksz = 0; |
1516 | | if( yyGrowStack(pParser) ){ |
1517 | | pParser->yystack = &pParser->yystk0; |
1518 | | pParser->yystksz = 1; |
1519 | | } |
1520 | | #endif |
1521 | 5.52k | #ifndef YYNOERRORRECOVERY |
1522 | 5.52k | pParser->yyerrcnt = -1; |
1523 | 5.52k | #endif |
1524 | 5.52k | pParser->yytos = pParser->yystack; |
1525 | 5.52k | pParser->yystack[0].stateno = 0; |
1526 | 5.52k | pParser->yystack[0].major = 0; |
1527 | 5.52k | #if YYSTACKDEPTH>0 |
1528 | 5.52k | pParser->yystackEnd = &pParser->yystack[YYSTACKDEPTH-1]; |
1529 | 5.52k | #endif |
1530 | 5.52k | } |
1531 | | |
1532 | | #ifndef Parse_ENGINEALWAYSONSTACK |
1533 | | /* |
1534 | | ** This function allocates a new parser. |
1535 | | ** The only argument is a pointer to a function which works like |
1536 | | ** malloc. |
1537 | | ** |
1538 | | ** Inputs: |
1539 | | ** A pointer to the function used to allocate memory. |
1540 | | ** |
1541 | | ** Outputs: |
1542 | | ** A pointer to a parser. This pointer is used in subsequent calls |
1543 | | ** to Parse and ParseFree. |
1544 | | */ |
1545 | 5.52k | void *ParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE)){ |
1546 | 5.52k | yyParser *pParser; |
1547 | 5.52k | pParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); |
1548 | 5.52k | if( pParser ) ParseInit(pParser); |
1549 | 5.52k | return pParser; |
1550 | 5.52k | } |
1551 | | #endif /* Parse_ENGINEALWAYSONSTACK */ |
1552 | | |
1553 | | |
1554 | | /* The following function deletes the "minor type" or semantic value |
1555 | | ** associated with a symbol. The symbol can be either a terminal |
1556 | | ** or nonterminal. "yymajor" is the symbol code, and "yypminor" is |
1557 | | ** a pointer to the value to be deleted. The code used to do the |
1558 | | ** deletions is derived from the %destructor and/or %token_destructor |
1559 | | ** directives of the input grammar. |
1560 | | */ |
1561 | | static void yy_destructor( |
1562 | | yyParser *yypParser, /* The parser */ |
1563 | | YYCODETYPE yymajor, /* Type code for object to destroy */ |
1564 | | YYMINORTYPE *yypminor /* The object to be destroyed */ |
1565 | 1.36M | ){ |
1566 | 1.36M | ParseARG_FETCH; |
1567 | 1.36M | switch( yymajor ){ |
1568 | | /* Here is inserted the actions which take place when a |
1569 | | ** terminal or non-terminal is destroyed. This can happen |
1570 | | ** when the symbol is popped from the stack during a |
1571 | | ** reduce or during error processing or when a parser is |
1572 | | ** being destroyed before it is finished parsing. |
1573 | | ** |
1574 | | ** Note: during a reduce, the only symbols destroyed are those |
1575 | | ** which appear on the RHS of the rule, but which are *not* used |
1576 | | ** inside the C code. |
1577 | | */ |
1578 | | /********* Begin destructor definitions ***************************************/ |
1579 | 30.1k | case 215: /* exprlist */ |
1580 | 32.1k | case 262: /* selcollist */ |
1581 | 34.7k | case 277: /* sclp */ |
1582 | 34.7k | { |
1583 | 34.7k | tSqlExprListDestroy((yypminor->yy333)); |
1584 | 34.7k | } |
1585 | 34.7k | break; |
1586 | 0 | case 230: /* intitemlist */ |
1587 | 0 | case 232: /* keep */ |
1588 | 96 | case 253: /* columnlist */ |
1589 | 96 | case 254: /* tagitemlist */ |
1590 | 96 | case 255: /* tagNamelist */ |
1591 | 1.47k | case 270: /* fill_opt */ |
1592 | 2.84k | case 271: /* groupby_opt */ |
1593 | 4.11k | case 273: /* orderby_opt */ |
1594 | 4.11k | case 286: /* sortlist */ |
1595 | 4.11k | case 290: /* grouplist */ |
1596 | 4.11k | { |
1597 | 4.11k | taosArrayDestroy(&(yypminor->yy333)); |
1598 | 4.11k | } |
1599 | 4.11k | break; |
1600 | 0 | case 251: /* create_table_list */ |
1601 | 0 | { |
1602 | 0 | destroyCreateTableSql((yypminor->yy78)); |
1603 | 0 | } |
1604 | 0 | break; |
1605 | 42 | case 258: /* select */ |
1606 | 42 | { |
1607 | 42 | destroySqlNode((yypminor->yy144)); |
1608 | 42 | } |
1609 | 42 | break; |
1610 | 1.38k | case 263: /* from */ |
1611 | 1.58k | case 281: /* tablelist */ |
1612 | 1.70k | case 282: /* sub */ |
1613 | 1.70k | { |
1614 | 1.70k | destroyRelationInfo((yypminor->yy516)); |
1615 | 1.70k | } |
1616 | 1.70k | break; |
1617 | 1.38k | case 264: /* where_opt */ |
1618 | 2.74k | case 272: /* having_opt */ |
1619 | 4.40k | case 279: /* expr */ |
1620 | 4.40k | case 284: /* timestamp */ |
1621 | 4.40k | case 289: /* arrow */ |
1622 | 4.40k | case 291: /* expritem */ |
1623 | 4.40k | { |
1624 | 4.40k | tSqlExprDestroy((yypminor->yy194)); |
1625 | 4.40k | } |
1626 | 4.40k | break; |
1627 | 21 | case 276: /* union */ |
1628 | 21 | { |
1629 | 21 | destroyAllSqlNode((yypminor->yy333)); |
1630 | 21 | } |
1631 | 21 | break; |
1632 | | /********* End destructor definitions *****************************************/ |
1633 | 1.31M | default: break; /* If no destructor action specified: do nothing */ |
1634 | 1.36M | } |
1635 | 1.36M | } |
1636 | | |
1637 | | /* |
1638 | | ** Pop the parser's stack once. |
1639 | | ** |
1640 | | ** If there is a destructor routine associated with the token which |
1641 | | ** is popped from the stack, then call it. |
1642 | | */ |
1643 | 1.35M | static void yy_pop_parser_stack(yyParser *pParser){ |
1644 | 1.35M | yyStackEntry *yytos; |
1645 | 1.35M | assert( pParser->yytos!=0 ); |
1646 | 1.35M | assert( pParser->yytos > pParser->yystack ); |
1647 | 1.35M | yytos = pParser->yytos--; |
1648 | 1.35M | #ifndef NDEBUG |
1649 | 1.35M | if( yyTraceFILE ){ |
1650 | 0 | fprintf(yyTraceFILE,"%sPopping %s\n", |
1651 | 0 | yyTracePrompt, |
1652 | 0 | yyTokenName[yytos->major]); |
1653 | 0 | } |
1654 | 1.35M | #endif |
1655 | 1.35M | yy_destructor(pParser, yytos->major, &yytos->minor); |
1656 | 1.35M | } |
1657 | | |
1658 | | /* |
1659 | | ** Clear all secondary memory allocations from the parser |
1660 | | */ |
1661 | 5.52k | void ParseFinalize(void *p){ |
1662 | 5.52k | yyParser *pParser = (yyParser*)p; |
1663 | 7.44k | while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser); |
1664 | | #if YYSTACKDEPTH<=0 |
1665 | | if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack); |
1666 | | #endif |
1667 | 5.52k | } |
1668 | | |
1669 | | #ifndef Parse_ENGINEALWAYSONSTACK |
1670 | | /* |
1671 | | ** Deallocate and destroy a parser. Destructors are called for |
1672 | | ** all stack elements before shutting the parser down. |
1673 | | ** |
1674 | | ** If the YYPARSEFREENEVERNULL macro exists (for example because it |
1675 | | ** is defined in a %include section of the input grammar) then it is |
1676 | | ** assumed that the input pointer is never NULL. |
1677 | | */ |
1678 | | void ParseFree( |
1679 | | void *p, /* The parser to be deleted */ |
1680 | | void (*freeProc)(void*) /* Function used to reclaim memory */ |
1681 | 5.52k | ){ |
1682 | 5.52k | #ifndef YYPARSEFREENEVERNULL |
1683 | 5.52k | if( p==0 ) return; |
1684 | 5.52k | #endif |
1685 | 5.52k | ParseFinalize(p); |
1686 | 5.52k | (*freeProc)(p); |
1687 | 5.52k | } |
1688 | | #endif /* Parse_ENGINEALWAYSONSTACK */ |
1689 | | |
1690 | | /* |
1691 | | ** Return the peak depth of the stack for a parser. |
1692 | | */ |
1693 | | #ifdef YYTRACKMAXSTACKDEPTH |
1694 | | int ParseStackPeak(void *p){ |
1695 | | yyParser *pParser = (yyParser*)p; |
1696 | | return pParser->yyhwm; |
1697 | | } |
1698 | | #endif |
1699 | | |
1700 | | /* This array of booleans keeps track of the parser statement |
1701 | | ** coverage. The element yycoverage[X][Y] is set when the parser |
1702 | | ** is in state X and has a lookahead token Y. In a well-tested |
1703 | | ** systems, every element of this matrix should end up being set. |
1704 | | */ |
1705 | | #if defined(YYCOVERAGE) |
1706 | | static unsigned char yycoverage[YYNSTATE][YYNTOKEN]; |
1707 | | #endif |
1708 | | |
1709 | | /* |
1710 | | ** Write into out a description of every state/lookahead combination that |
1711 | | ** |
1712 | | ** (1) has not been used by the parser, and |
1713 | | ** (2) is not a syntax error. |
1714 | | ** |
1715 | | ** Return the number of missed state/lookahead combinations. |
1716 | | */ |
1717 | | #if defined(YYCOVERAGE) |
1718 | | int ParseCoverage(FILE *out){ |
1719 | | int stateno, iLookAhead, i; |
1720 | | int nMissed = 0; |
1721 | | for(stateno=0; stateno<YYNSTATE; stateno++){ |
1722 | | i = yy_shift_ofst[stateno]; |
1723 | | for(iLookAhead=0; iLookAhead<YYNTOKEN; iLookAhead++){ |
1724 | | if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue; |
1725 | | if( yycoverage[stateno][iLookAhead]==0 ) nMissed++; |
1726 | | if( out ){ |
1727 | | fprintf(out,"State %d lookahead %s %s\n", stateno, |
1728 | | yyTokenName[iLookAhead], |
1729 | | yycoverage[stateno][iLookAhead] ? "ok" : "missed"); |
1730 | | } |
1731 | | } |
1732 | | } |
1733 | | return nMissed; |
1734 | | } |
1735 | | #endif |
1736 | | |
1737 | | /* |
1738 | | ** Find the appropriate action for a parser given the terminal |
1739 | | ** look-ahead token iLookAhead. |
1740 | | */ |
1741 | | static unsigned int yy_find_shift_action( |
1742 | | yyParser *pParser, /* The parser */ |
1743 | | YYCODETYPE iLookAhead /* The look-ahead token */ |
1744 | 12.2M | ){ |
1745 | 12.2M | int i; |
1746 | 12.2M | int stateno = pParser->yytos->stateno; |
1747 | | |
1748 | 12.2M | if( stateno>YY_MAX_SHIFT ) return stateno; |
1749 | 9.50M | assert( stateno <= YY_SHIFT_COUNT ); |
1750 | | #if defined(YYCOVERAGE) |
1751 | | yycoverage[stateno][iLookAhead] = 1; |
1752 | | #endif |
1753 | 9.66M | do{ |
1754 | 9.66M | i = yy_shift_ofst[stateno]; |
1755 | 9.66M | assert( i>=0 && i+YYNTOKEN<=sizeof(yy_lookahead)/sizeof(yy_lookahead[0]) ); |
1756 | 9.66M | assert( iLookAhead!=YYNOCODE ); |
1757 | 9.66M | assert( iLookAhead < YYNTOKEN ); |
1758 | 9.66M | i += iLookAhead; |
1759 | 9.66M | if( yy_lookahead[i]!=iLookAhead ){ |
1760 | 3.52M | #ifdef YYFALLBACK |
1761 | 3.52M | YYCODETYPE iFallback; /* Fallback token */ |
1762 | 3.52M | if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) |
1763 | 3.52M | && (iFallback = yyFallback[iLookAhead])!=0 ){ |
1764 | 153k | #ifndef NDEBUG |
1765 | 153k | if( yyTraceFILE ){ |
1766 | 0 | fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n", |
1767 | 0 | yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); |
1768 | 0 | } |
1769 | 153k | #endif |
1770 | 153k | assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */ |
1771 | 153k | iLookAhead = iFallback; |
1772 | 153k | continue; |
1773 | 153k | } |
1774 | 3.37M | #endif |
1775 | | #ifdef YYWILDCARD |
1776 | | { |
1777 | | int j = i - iLookAhead + YYWILDCARD; |
1778 | | if( |
1779 | | #if YY_SHIFT_MIN+YYWILDCARD<0 |
1780 | | j>=0 && |
1781 | | #endif |
1782 | | #if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT |
1783 | | j<YY_ACTTAB_COUNT && |
1784 | | #endif |
1785 | | yy_lookahead[j]==YYWILDCARD && iLookAhead>0 |
1786 | | ){ |
1787 | | #ifndef NDEBUG |
1788 | | if( yyTraceFILE ){ |
1789 | | fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", |
1790 | | yyTracePrompt, yyTokenName[iLookAhead], |
1791 | | yyTokenName[YYWILDCARD]); |
1792 | | } |
1793 | | #endif /* NDEBUG */ |
1794 | | return yy_action[j]; |
1795 | | } |
1796 | | } |
1797 | | #endif /* YYWILDCARD */ |
1798 | 3.37M | return yy_default[stateno]; |
1799 | 6.13M | }else{ |
1800 | 6.13M | return yy_action[i]; |
1801 | 6.13M | } |
1802 | 9.66M | }while(1); |
1803 | 9.50M | } |
1804 | | |
1805 | | /* |
1806 | | ** Find the appropriate action for a parser given the non-terminal |
1807 | | ** look-ahead token iLookAhead. |
1808 | | */ |
1809 | | static int yy_find_reduce_action( |
1810 | | int stateno, /* Current state number */ |
1811 | | YYCODETYPE iLookAhead /* The look-ahead token */ |
1812 | 6.08M | ){ |
1813 | 6.08M | int i; |
1814 | | #ifdef YYERRORSYMBOL |
1815 | | if( stateno>YY_REDUCE_COUNT ){ |
1816 | | return yy_default[stateno]; |
1817 | | } |
1818 | | #else |
1819 | 6.08M | assert( stateno<=YY_REDUCE_COUNT ); |
1820 | 6.08M | #endif |
1821 | 6.08M | i = yy_reduce_ofst[stateno]; |
1822 | 6.08M | assert( iLookAhead!=YYNOCODE ); |
1823 | 6.08M | i += iLookAhead; |
1824 | | #ifdef YYERRORSYMBOL |
1825 | | if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ |
1826 | | return yy_default[stateno]; |
1827 | | } |
1828 | | #else |
1829 | 6.08M | assert( i>=0 && i<YY_ACTTAB_COUNT ); |
1830 | 6.08M | assert( yy_lookahead[i]==iLookAhead ); |
1831 | 6.08M | #endif |
1832 | 6.08M | return yy_action[i]; |
1833 | 6.08M | } |
1834 | | |
1835 | | /* |
1836 | | ** The following routine is called if the stack overflows. |
1837 | | */ |
1838 | 13.5k | static void yyStackOverflow(yyParser *yypParser){ |
1839 | 13.5k | ParseARG_FETCH; |
1840 | 13.5k | #ifndef NDEBUG |
1841 | 13.5k | if( yyTraceFILE ){ |
1842 | 0 | fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); |
1843 | 0 | } |
1844 | 13.5k | #endif |
1845 | 1.35M | while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); |
1846 | | /* Here code is inserted which will execute if the parser |
1847 | | ** stack every overflows */ |
1848 | | /******** Begin %stack_overflow code ******************************************/ |
1849 | | /******** End %stack_overflow code ********************************************/ |
1850 | 13.5k | ParseARG_STORE; /* Suppress warning about unused %extra_argument var */ |
1851 | 13.5k | } |
1852 | | |
1853 | | /* |
1854 | | ** Print tracing information for a SHIFT action |
1855 | | */ |
1856 | | #ifndef NDEBUG |
1857 | 12.2M | static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){ |
1858 | 12.2M | if( yyTraceFILE ){ |
1859 | 0 | if( yyNewState<YYNSTATE ){ |
1860 | 0 | fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n", |
1861 | 0 | yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major], |
1862 | 0 | yyNewState); |
1863 | 0 | }else{ |
1864 | 0 | fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n", |
1865 | 0 | yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major], |
1866 | 0 | yyNewState - YY_MIN_REDUCE); |
1867 | 0 | } |
1868 | 0 | } |
1869 | 12.2M | } |
1870 | | #else |
1871 | | # define yyTraceShift(X,Y,Z) |
1872 | | #endif |
1873 | | |
1874 | | /* |
1875 | | ** Perform a shift action. |
1876 | | */ |
1877 | | static void yy_shift( |
1878 | | yyParser *yypParser, /* The parser to be shifted */ |
1879 | | int yyNewState, /* The new state to shift in */ |
1880 | | int yyMajor, /* The major token to shift in */ |
1881 | | ParseTOKENTYPE yyMinor /* The minor token to shift in */ |
1882 | 6.13M | ){ |
1883 | 6.13M | yyStackEntry *yytos; |
1884 | 6.13M | yypParser->yytos++; |
1885 | | #ifdef YYTRACKMAXSTACKDEPTH |
1886 | | if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ |
1887 | | yypParser->yyhwm++; |
1888 | | assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) ); |
1889 | | } |
1890 | | #endif |
1891 | 6.13M | #if YYSTACKDEPTH>0 |
1892 | 6.13M | if( yypParser->yytos>yypParser->yystackEnd ){ |
1893 | 11.8k | yypParser->yytos--; |
1894 | 11.8k | yyStackOverflow(yypParser); |
1895 | 11.8k | return; |
1896 | 11.8k | } |
1897 | | #else |
1898 | | if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){ |
1899 | | if( yyGrowStack(yypParser) ){ |
1900 | | yypParser->yytos--; |
1901 | | yyStackOverflow(yypParser); |
1902 | | return; |
1903 | | } |
1904 | | } |
1905 | | #endif |
1906 | 6.12M | if( yyNewState > YY_MAX_SHIFT ){ |
1907 | 356k | yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE; |
1908 | 356k | } |
1909 | 6.12M | yytos = yypParser->yytos; |
1910 | 6.12M | yytos->stateno = (YYACTIONTYPE)yyNewState; |
1911 | 6.12M | yytos->major = (YYCODETYPE)yyMajor; |
1912 | 6.12M | yytos->minor.yy0 = yyMinor; |
1913 | 6.12M | yyTraceShift(yypParser, yyNewState, "Shift"); |
1914 | 6.12M | } |
1915 | | |
1916 | | /* The following table contains information about every rule that |
1917 | | ** is used during the reduce. |
1918 | | */ |
1919 | | static const struct { |
1920 | | YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ |
1921 | | signed char nrhs; /* Negative of the number of RHS symbols in the rule */ |
1922 | | } yyRuleInfo[] = { |
1923 | | { 206, -1 }, /* (0) program ::= cmd */ |
1924 | | { 207, -2 }, /* (1) cmd ::= SHOW DATABASES */ |
1925 | | { 207, -2 }, /* (2) cmd ::= SHOW TOPICS */ |
1926 | | { 207, -2 }, /* (3) cmd ::= SHOW FUNCTIONS */ |
1927 | | { 207, -2 }, /* (4) cmd ::= SHOW MNODES */ |
1928 | | { 207, -2 }, /* (5) cmd ::= SHOW DNODES */ |
1929 | | { 207, -2 }, /* (6) cmd ::= SHOW ACCOUNTS */ |
1930 | | { 207, -2 }, /* (7) cmd ::= SHOW USERS */ |
1931 | | { 207, -2 }, /* (8) cmd ::= SHOW MODULES */ |
1932 | | { 207, -2 }, /* (9) cmd ::= SHOW QUERIES */ |
1933 | | { 207, -2 }, /* (10) cmd ::= SHOW CONNECTIONS */ |
1934 | | { 207, -2 }, /* (11) cmd ::= SHOW STREAMS */ |
1935 | | { 207, -2 }, /* (12) cmd ::= SHOW VARIABLES */ |
1936 | | { 207, -2 }, /* (13) cmd ::= SHOW SCORES */ |
1937 | | { 207, -2 }, /* (14) cmd ::= SHOW GRANTS */ |
1938 | | { 207, -2 }, /* (15) cmd ::= SHOW VNODES */ |
1939 | | { 207, -3 }, /* (16) cmd ::= SHOW VNODES ids */ |
1940 | | { 209, 0 }, /* (17) dbPrefix ::= */ |
1941 | | { 209, -2 }, /* (18) dbPrefix ::= ids DOT */ |
1942 | | { 210, 0 }, /* (19) cpxName ::= */ |
1943 | | { 210, -2 }, /* (20) cpxName ::= DOT ids */ |
1944 | | { 207, -5 }, /* (21) cmd ::= SHOW CREATE TABLE ids cpxName */ |
1945 | | { 207, -5 }, /* (22) cmd ::= SHOW CREATE STABLE ids cpxName */ |
1946 | | { 207, -4 }, /* (23) cmd ::= SHOW CREATE DATABASE ids */ |
1947 | | { 207, -3 }, /* (24) cmd ::= SHOW dbPrefix TABLES */ |
1948 | | { 207, -5 }, /* (25) cmd ::= SHOW dbPrefix TABLES LIKE STRING */ |
1949 | | { 207, -3 }, /* (26) cmd ::= SHOW dbPrefix STABLES */ |
1950 | | { 207, -5 }, /* (27) cmd ::= SHOW dbPrefix STABLES LIKE STRING */ |
1951 | | { 207, -3 }, /* (28) cmd ::= SHOW dbPrefix VGROUPS */ |
1952 | | { 207, -5 }, /* (29) cmd ::= DROP TABLE ifexists ids cpxName */ |
1953 | | { 207, -5 }, /* (30) cmd ::= DROP STABLE ifexists ids cpxName */ |
1954 | | { 207, -4 }, /* (31) cmd ::= DROP DATABASE ifexists ids */ |
1955 | | { 207, -4 }, /* (32) cmd ::= DROP TOPIC ifexists ids */ |
1956 | | { 207, -3 }, /* (33) cmd ::= DROP FUNCTION ids */ |
1957 | | { 207, -3 }, /* (34) cmd ::= DROP DNODE ids */ |
1958 | | { 207, -3 }, /* (35) cmd ::= DROP USER ids */ |
1959 | | { 207, -3 }, /* (36) cmd ::= DROP ACCOUNT ids */ |
1960 | | { 207, -2 }, /* (37) cmd ::= USE ids */ |
1961 | | { 207, -3 }, /* (38) cmd ::= DESCRIBE ids cpxName */ |
1962 | | { 207, -3 }, /* (39) cmd ::= DESC ids cpxName */ |
1963 | | { 207, -5 }, /* (40) cmd ::= ALTER USER ids PASS ids */ |
1964 | | { 207, -5 }, /* (41) cmd ::= ALTER USER ids PRIVILEGE ids */ |
1965 | | { 207, -4 }, /* (42) cmd ::= ALTER DNODE ids ids */ |
1966 | | { 207, -5 }, /* (43) cmd ::= ALTER DNODE ids ids ids */ |
1967 | | { 207, -3 }, /* (44) cmd ::= ALTER LOCAL ids */ |
1968 | | { 207, -4 }, /* (45) cmd ::= ALTER LOCAL ids ids */ |
1969 | | { 207, -4 }, /* (46) cmd ::= ALTER DATABASE ids alter_db_optr */ |
1970 | | { 207, -4 }, /* (47) cmd ::= ALTER TOPIC ids alter_topic_optr */ |
1971 | | { 207, -4 }, /* (48) cmd ::= ALTER ACCOUNT ids acct_optr */ |
1972 | | { 207, -6 }, /* (49) cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ |
1973 | | { 207, -6 }, /* (50) cmd ::= COMPACT VNODES IN LP exprlist RP */ |
1974 | | { 208, -1 }, /* (51) ids ::= ID */ |
1975 | | { 208, -1 }, /* (52) ids ::= STRING */ |
1976 | | { 211, -2 }, /* (53) ifexists ::= IF EXISTS */ |
1977 | | { 211, 0 }, /* (54) ifexists ::= */ |
1978 | | { 216, -3 }, /* (55) ifnotexists ::= IF NOT EXISTS */ |
1979 | | { 216, 0 }, /* (56) ifnotexists ::= */ |
1980 | | { 207, -3 }, /* (57) cmd ::= CREATE DNODE ids */ |
1981 | | { 207, -6 }, /* (58) cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ |
1982 | | { 207, -5 }, /* (59) cmd ::= CREATE DATABASE ifnotexists ids db_optr */ |
1983 | | { 207, -5 }, /* (60) cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ |
1984 | | { 207, -8 }, /* (61) cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ |
1985 | | { 207, -9 }, /* (62) cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ |
1986 | | { 207, -5 }, /* (63) cmd ::= CREATE USER ids PASS ids */ |
1987 | | { 220, 0 }, /* (64) bufsize ::= */ |
1988 | | { 220, -2 }, /* (65) bufsize ::= BUFSIZE INTEGER */ |
1989 | | { 221, 0 }, /* (66) pps ::= */ |
1990 | | { 221, -2 }, /* (67) pps ::= PPS INTEGER */ |
1991 | | { 222, 0 }, /* (68) tseries ::= */ |
1992 | | { 222, -2 }, /* (69) tseries ::= TSERIES INTEGER */ |
1993 | | { 223, 0 }, /* (70) dbs ::= */ |
1994 | | { 223, -2 }, /* (71) dbs ::= DBS INTEGER */ |
1995 | | { 224, 0 }, /* (72) streams ::= */ |
1996 | | { 224, -2 }, /* (73) streams ::= STREAMS INTEGER */ |
1997 | | { 225, 0 }, /* (74) storage ::= */ |
1998 | | { 225, -2 }, /* (75) storage ::= STORAGE INTEGER */ |
1999 | | { 226, 0 }, /* (76) qtime ::= */ |
2000 | | { 226, -2 }, /* (77) qtime ::= QTIME INTEGER */ |
2001 | | { 227, 0 }, /* (78) users ::= */ |
2002 | | { 227, -2 }, /* (79) users ::= USERS INTEGER */ |
2003 | | { 228, 0 }, /* (80) conns ::= */ |
2004 | | { 228, -2 }, /* (81) conns ::= CONNS INTEGER */ |
2005 | | { 229, 0 }, /* (82) state ::= */ |
2006 | | { 229, -2 }, /* (83) state ::= STATE ids */ |
2007 | | { 214, -9 }, /* (84) acct_optr ::= pps tseries storage streams qtime dbs users conns state */ |
2008 | | { 230, -3 }, /* (85) intitemlist ::= intitemlist COMMA intitem */ |
2009 | | { 230, -1 }, /* (86) intitemlist ::= intitem */ |
2010 | | { 231, -1 }, /* (87) intitem ::= INTEGER */ |
2011 | | { 232, -2 }, /* (88) keep ::= KEEP intitemlist */ |
2012 | | { 233, -2 }, /* (89) cache ::= CACHE INTEGER */ |
2013 | | { 234, -2 }, /* (90) replica ::= REPLICA INTEGER */ |
2014 | | { 235, -2 }, /* (91) quorum ::= QUORUM INTEGER */ |
2015 | | { 236, -2 }, /* (92) days ::= DAYS INTEGER */ |
2016 | | { 237, -2 }, /* (93) minrows ::= MINROWS INTEGER */ |
2017 | | { 238, -2 }, /* (94) maxrows ::= MAXROWS INTEGER */ |
2018 | | { 239, -2 }, /* (95) blocks ::= BLOCKS INTEGER */ |
2019 | | { 240, -2 }, /* (96) ctime ::= CTIME INTEGER */ |
2020 | | { 241, -2 }, /* (97) wal ::= WAL INTEGER */ |
2021 | | { 242, -2 }, /* (98) fsync ::= FSYNC INTEGER */ |
2022 | | { 243, -2 }, /* (99) comp ::= COMP INTEGER */ |
2023 | | { 244, -2 }, /* (100) prec ::= PRECISION STRING */ |
2024 | | { 245, -2 }, /* (101) update ::= UPDATE INTEGER */ |
2025 | | { 246, -2 }, /* (102) cachelast ::= CACHELAST INTEGER */ |
2026 | | { 247, -2 }, /* (103) partitions ::= PARTITIONS INTEGER */ |
2027 | | { 217, 0 }, /* (104) db_optr ::= */ |
2028 | | { 217, -2 }, /* (105) db_optr ::= db_optr cache */ |
2029 | | { 217, -2 }, /* (106) db_optr ::= db_optr replica */ |
2030 | | { 217, -2 }, /* (107) db_optr ::= db_optr quorum */ |
2031 | | { 217, -2 }, /* (108) db_optr ::= db_optr days */ |
2032 | | { 217, -2 }, /* (109) db_optr ::= db_optr minrows */ |
2033 | | { 217, -2 }, /* (110) db_optr ::= db_optr maxrows */ |
2034 | | { 217, -2 }, /* (111) db_optr ::= db_optr blocks */ |
2035 | | { 217, -2 }, /* (112) db_optr ::= db_optr ctime */ |
2036 | | { 217, -2 }, /* (113) db_optr ::= db_optr wal */ |
2037 | | { 217, -2 }, /* (114) db_optr ::= db_optr fsync */ |
2038 | | { 217, -2 }, /* (115) db_optr ::= db_optr comp */ |
2039 | | { 217, -2 }, /* (116) db_optr ::= db_optr prec */ |
2040 | | { 217, -2 }, /* (117) db_optr ::= db_optr keep */ |
2041 | | { 217, -2 }, /* (118) db_optr ::= db_optr update */ |
2042 | | { 217, -2 }, /* (119) db_optr ::= db_optr cachelast */ |
2043 | | { 218, -1 }, /* (120) topic_optr ::= db_optr */ |
2044 | | { 218, -2 }, /* (121) topic_optr ::= topic_optr partitions */ |
2045 | | { 212, 0 }, /* (122) alter_db_optr ::= */ |
2046 | | { 212, -2 }, /* (123) alter_db_optr ::= alter_db_optr replica */ |
2047 | | { 212, -2 }, /* (124) alter_db_optr ::= alter_db_optr quorum */ |
2048 | | { 212, -2 }, /* (125) alter_db_optr ::= alter_db_optr keep */ |
2049 | | { 212, -2 }, /* (126) alter_db_optr ::= alter_db_optr blocks */ |
2050 | | { 212, -2 }, /* (127) alter_db_optr ::= alter_db_optr comp */ |
2051 | | { 212, -2 }, /* (128) alter_db_optr ::= alter_db_optr update */ |
2052 | | { 212, -2 }, /* (129) alter_db_optr ::= alter_db_optr cachelast */ |
2053 | | { 213, -1 }, /* (130) alter_topic_optr ::= alter_db_optr */ |
2054 | | { 213, -2 }, /* (131) alter_topic_optr ::= alter_topic_optr partitions */ |
2055 | | { 219, -1 }, /* (132) typename ::= ids */ |
2056 | | { 219, -4 }, /* (133) typename ::= ids LP signed RP */ |
2057 | | { 219, -2 }, /* (134) typename ::= ids UNSIGNED */ |
2058 | | { 248, -1 }, /* (135) signed ::= INTEGER */ |
2059 | | { 248, -2 }, /* (136) signed ::= PLUS INTEGER */ |
2060 | | { 248, -2 }, /* (137) signed ::= MINUS INTEGER */ |
2061 | | { 207, -3 }, /* (138) cmd ::= CREATE TABLE create_table_args */ |
2062 | | { 207, -3 }, /* (139) cmd ::= CREATE TABLE create_stable_args */ |
2063 | | { 207, -3 }, /* (140) cmd ::= CREATE STABLE create_stable_args */ |
2064 | | { 207, -3 }, /* (141) cmd ::= CREATE TABLE create_table_list */ |
2065 | | { 251, -1 }, /* (142) create_table_list ::= create_from_stable */ |
2066 | | { 251, -2 }, /* (143) create_table_list ::= create_table_list create_from_stable */ |
2067 | | { 249, -6 }, /* (144) create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ |
2068 | | { 250, -10 }, /* (145) create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ |
2069 | | { 252, -10 }, /* (146) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ |
2070 | | { 252, -13 }, /* (147) create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ |
2071 | | { 255, -3 }, /* (148) tagNamelist ::= tagNamelist COMMA ids */ |
2072 | | { 255, -1 }, /* (149) tagNamelist ::= ids */ |
2073 | | { 249, -7 }, /* (150) create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */ |
2074 | | { 256, 0 }, /* (151) to_opt ::= */ |
2075 | | { 256, -3 }, /* (152) to_opt ::= TO ids cpxName */ |
2076 | | { 257, 0 }, /* (153) split_opt ::= */ |
2077 | | { 257, -2 }, /* (154) split_opt ::= SPLIT ids */ |
2078 | | { 253, -3 }, /* (155) columnlist ::= columnlist COMMA column */ |
2079 | | { 253, -1 }, /* (156) columnlist ::= column */ |
2080 | | { 260, -2 }, /* (157) column ::= ids typename */ |
2081 | | { 254, -3 }, /* (158) tagitemlist ::= tagitemlist COMMA tagitem */ |
2082 | | { 254, -1 }, /* (159) tagitemlist ::= tagitem */ |
2083 | | { 261, -1 }, /* (160) tagitem ::= INTEGER */ |
2084 | | { 261, -1 }, /* (161) tagitem ::= FLOAT */ |
2085 | | { 261, -1 }, /* (162) tagitem ::= STRING */ |
2086 | | { 261, -1 }, /* (163) tagitem ::= BOOL */ |
2087 | | { 261, -1 }, /* (164) tagitem ::= NULL */ |
2088 | | { 261, -1 }, /* (165) tagitem ::= NOW */ |
2089 | | { 261, -3 }, /* (166) tagitem ::= NOW PLUS VARIABLE */ |
2090 | | { 261, -3 }, /* (167) tagitem ::= NOW MINUS VARIABLE */ |
2091 | | { 261, -2 }, /* (168) tagitem ::= MINUS INTEGER */ |
2092 | | { 261, -2 }, /* (169) tagitem ::= MINUS FLOAT */ |
2093 | | { 261, -2 }, /* (170) tagitem ::= PLUS INTEGER */ |
2094 | | { 261, -2 }, /* (171) tagitem ::= PLUS FLOAT */ |
2095 | | { 258, -15 }, /* (172) select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ |
2096 | | { 258, -3 }, /* (173) select ::= LP select RP */ |
2097 | | { 276, -1 }, /* (174) union ::= select */ |
2098 | | { 276, -4 }, /* (175) union ::= union UNION ALL select */ |
2099 | | { 207, -1 }, /* (176) cmd ::= union */ |
2100 | | { 258, -2 }, /* (177) select ::= SELECT selcollist */ |
2101 | | { 277, -2 }, /* (178) sclp ::= selcollist COMMA */ |
2102 | | { 277, 0 }, /* (179) sclp ::= */ |
2103 | | { 262, -4 }, /* (180) selcollist ::= sclp distinct expr as */ |
2104 | | { 262, -2 }, /* (181) selcollist ::= sclp STAR */ |
2105 | | { 280, -2 }, /* (182) as ::= AS ids */ |
2106 | | { 280, -1 }, /* (183) as ::= ids */ |
2107 | | { 280, 0 }, /* (184) as ::= */ |
2108 | | { 278, -1 }, /* (185) distinct ::= DISTINCT */ |
2109 | | { 278, 0 }, /* (186) distinct ::= */ |
2110 | | { 263, -2 }, /* (187) from ::= FROM tablelist */ |
2111 | | { 263, -2 }, /* (188) from ::= FROM sub */ |
2112 | | { 282, -3 }, /* (189) sub ::= LP union RP */ |
2113 | | { 282, -4 }, /* (190) sub ::= LP union RP ids */ |
2114 | | { 282, -6 }, /* (191) sub ::= sub COMMA LP union RP ids */ |
2115 | | { 281, -2 }, /* (192) tablelist ::= ids cpxName */ |
2116 | | { 281, -3 }, /* (193) tablelist ::= ids cpxName ids */ |
2117 | | { 281, -4 }, /* (194) tablelist ::= tablelist COMMA ids cpxName */ |
2118 | | { 281, -5 }, /* (195) tablelist ::= tablelist COMMA ids cpxName ids */ |
2119 | | { 283, -1 }, /* (196) tmvar ::= VARIABLE */ |
2120 | | { 284, -1 }, /* (197) timestamp ::= INTEGER */ |
2121 | | { 284, -2 }, /* (198) timestamp ::= MINUS INTEGER */ |
2122 | | { 284, -2 }, /* (199) timestamp ::= PLUS INTEGER */ |
2123 | | { 284, -1 }, /* (200) timestamp ::= STRING */ |
2124 | | { 284, -1 }, /* (201) timestamp ::= NOW */ |
2125 | | { 284, -3 }, /* (202) timestamp ::= NOW PLUS VARIABLE */ |
2126 | | { 284, -3 }, /* (203) timestamp ::= NOW MINUS VARIABLE */ |
2127 | | { 265, 0 }, /* (204) range_option ::= */ |
2128 | | { 265, -6 }, /* (205) range_option ::= RANGE LP timestamp COMMA timestamp RP */ |
2129 | | { 266, -4 }, /* (206) interval_option ::= intervalKey LP tmvar RP */ |
2130 | | { 266, -6 }, /* (207) interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ |
2131 | | { 266, 0 }, /* (208) interval_option ::= */ |
2132 | | { 285, -1 }, /* (209) intervalKey ::= INTERVAL */ |
2133 | | { 285, -1 }, /* (210) intervalKey ::= EVERY */ |
2134 | | { 268, 0 }, /* (211) session_option ::= */ |
2135 | | { 268, -7 }, /* (212) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ |
2136 | | { 269, 0 }, /* (213) windowstate_option ::= */ |
2137 | | { 269, -4 }, /* (214) windowstate_option ::= STATE_WINDOW LP ids RP */ |
2138 | | { 270, 0 }, /* (215) fill_opt ::= */ |
2139 | | { 270, -6 }, /* (216) fill_opt ::= FILL LP ID COMMA tagitemlist RP */ |
2140 | | { 270, -4 }, /* (217) fill_opt ::= FILL LP ID RP */ |
2141 | | { 267, -4 }, /* (218) sliding_opt ::= SLIDING LP tmvar RP */ |
2142 | | { 267, 0 }, /* (219) sliding_opt ::= */ |
2143 | | { 273, 0 }, /* (220) orderby_opt ::= */ |
2144 | | { 273, -3 }, /* (221) orderby_opt ::= ORDER BY sortlist */ |
2145 | | { 286, -4 }, /* (222) sortlist ::= sortlist COMMA item sortorder */ |
2146 | | { 286, -4 }, /* (223) sortlist ::= sortlist COMMA arrow sortorder */ |
2147 | | { 286, -2 }, /* (224) sortlist ::= item sortorder */ |
2148 | | { 286, -2 }, /* (225) sortlist ::= arrow sortorder */ |
2149 | | { 287, -1 }, /* (226) item ::= ID */ |
2150 | | { 287, -3 }, /* (227) item ::= ID DOT ID */ |
2151 | | { 288, -1 }, /* (228) sortorder ::= ASC */ |
2152 | | { 288, -1 }, /* (229) sortorder ::= DESC */ |
2153 | | { 288, 0 }, /* (230) sortorder ::= */ |
2154 | | { 271, 0 }, /* (231) groupby_opt ::= */ |
2155 | | { 271, -3 }, /* (232) groupby_opt ::= GROUP BY grouplist */ |
2156 | | { 290, -3 }, /* (233) grouplist ::= grouplist COMMA item */ |
2157 | | { 290, -3 }, /* (234) grouplist ::= grouplist COMMA arrow */ |
2158 | | { 290, -1 }, /* (235) grouplist ::= item */ |
2159 | | { 290, -1 }, /* (236) grouplist ::= arrow */ |
2160 | | { 272, 0 }, /* (237) having_opt ::= */ |
2161 | | { 272, -2 }, /* (238) having_opt ::= HAVING expr */ |
2162 | | { 275, 0 }, /* (239) limit_opt ::= */ |
2163 | | { 275, -2 }, /* (240) limit_opt ::= LIMIT signed */ |
2164 | | { 275, -4 }, /* (241) limit_opt ::= LIMIT signed OFFSET signed */ |
2165 | | { 275, -4 }, /* (242) limit_opt ::= LIMIT signed COMMA signed */ |
2166 | | { 274, 0 }, /* (243) slimit_opt ::= */ |
2167 | | { 274, -2 }, /* (244) slimit_opt ::= SLIMIT signed */ |
2168 | | { 274, -4 }, /* (245) slimit_opt ::= SLIMIT signed SOFFSET signed */ |
2169 | | { 274, -4 }, /* (246) slimit_opt ::= SLIMIT signed COMMA signed */ |
2170 | | { 264, 0 }, /* (247) where_opt ::= */ |
2171 | | { 264, -2 }, /* (248) where_opt ::= WHERE expr */ |
2172 | | { 279, -3 }, /* (249) expr ::= LP expr RP */ |
2173 | | { 279, -1 }, /* (250) expr ::= ID */ |
2174 | | { 279, -3 }, /* (251) expr ::= ID DOT ID */ |
2175 | | { 279, -3 }, /* (252) expr ::= ID DOT STAR */ |
2176 | | { 279, -1 }, /* (253) expr ::= INTEGER */ |
2177 | | { 279, -2 }, /* (254) expr ::= MINUS INTEGER */ |
2178 | | { 279, -2 }, /* (255) expr ::= PLUS INTEGER */ |
2179 | | { 279, -1 }, /* (256) expr ::= FLOAT */ |
2180 | | { 279, -2 }, /* (257) expr ::= MINUS FLOAT */ |
2181 | | { 279, -2 }, /* (258) expr ::= PLUS FLOAT */ |
2182 | | { 279, -1 }, /* (259) expr ::= STRING */ |
2183 | | { 279, -1 }, /* (260) expr ::= NOW */ |
2184 | | { 279, -1 }, /* (261) expr ::= TODAY */ |
2185 | | { 279, -1 }, /* (262) expr ::= VARIABLE */ |
2186 | | { 279, -2 }, /* (263) expr ::= PLUS VARIABLE */ |
2187 | | { 279, -2 }, /* (264) expr ::= MINUS VARIABLE */ |
2188 | | { 279, -1 }, /* (265) expr ::= BOOL */ |
2189 | | { 279, -1 }, /* (266) expr ::= NULL */ |
2190 | | { 279, -4 }, /* (267) expr ::= ID LP exprlist RP */ |
2191 | | { 279, -4 }, /* (268) expr ::= ID LP STAR RP */ |
2192 | | { 279, -6 }, /* (269) expr ::= ID LP expr AS typename RP */ |
2193 | | { 279, -3 }, /* (270) expr ::= expr IS NULL */ |
2194 | | { 279, -4 }, /* (271) expr ::= expr IS NOT NULL */ |
2195 | | { 279, -3 }, /* (272) expr ::= expr LT expr */ |
2196 | | { 279, -3 }, /* (273) expr ::= expr GT expr */ |
2197 | | { 279, -3 }, /* (274) expr ::= expr LE expr */ |
2198 | | { 279, -3 }, /* (275) expr ::= expr GE expr */ |
2199 | | { 279, -3 }, /* (276) expr ::= expr NE expr */ |
2200 | | { 279, -3 }, /* (277) expr ::= expr EQ expr */ |
2201 | | { 279, -5 }, /* (278) expr ::= expr BETWEEN expr AND expr */ |
2202 | | { 279, -3 }, /* (279) expr ::= expr AND expr */ |
2203 | | { 279, -3 }, /* (280) expr ::= expr OR expr */ |
2204 | | { 279, -3 }, /* (281) expr ::= expr PLUS expr */ |
2205 | | { 279, -3 }, /* (282) expr ::= expr MINUS expr */ |
2206 | | { 279, -3 }, /* (283) expr ::= expr STAR expr */ |
2207 | | { 279, -3 }, /* (284) expr ::= expr SLASH expr */ |
2208 | | { 279, -3 }, /* (285) expr ::= expr REM expr */ |
2209 | | { 279, -3 }, /* (286) expr ::= expr BITAND expr */ |
2210 | | { 279, -3 }, /* (287) expr ::= expr LIKE expr */ |
2211 | | { 279, -3 }, /* (288) expr ::= expr MATCH expr */ |
2212 | | { 279, -3 }, /* (289) expr ::= expr NMATCH expr */ |
2213 | | { 279, -3 }, /* (290) expr ::= ID CONTAINS STRING */ |
2214 | | { 279, -5 }, /* (291) expr ::= ID DOT ID CONTAINS STRING */ |
2215 | | { 289, -3 }, /* (292) arrow ::= ID ARROW STRING */ |
2216 | | { 289, -5 }, /* (293) arrow ::= ID DOT ID ARROW STRING */ |
2217 | | { 279, -1 }, /* (294) expr ::= arrow */ |
2218 | | { 279, -5 }, /* (295) expr ::= expr IN LP exprlist RP */ |
2219 | | { 215, -3 }, /* (296) exprlist ::= exprlist COMMA expritem */ |
2220 | | { 215, -1 }, /* (297) exprlist ::= expritem */ |
2221 | | { 291, -1 }, /* (298) expritem ::= expr */ |
2222 | | { 291, 0 }, /* (299) expritem ::= */ |
2223 | | { 207, -3 }, /* (300) cmd ::= RESET QUERY CACHE */ |
2224 | | { 207, -3 }, /* (301) cmd ::= SYNCDB ids REPLICA */ |
2225 | | { 207, -7 }, /* (302) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ |
2226 | | { 207, -7 }, /* (303) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ |
2227 | | { 207, -7 }, /* (304) cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ |
2228 | | { 207, -7 }, /* (305) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ |
2229 | | { 207, -7 }, /* (306) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ |
2230 | | { 207, -8 }, /* (307) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ |
2231 | | { 207, -9 }, /* (308) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ |
2232 | | { 207, -7 }, /* (309) cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ |
2233 | | { 207, -7 }, /* (310) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ |
2234 | | { 207, -7 }, /* (311) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ |
2235 | | { 207, -7 }, /* (312) cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ |
2236 | | { 207, -7 }, /* (313) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ |
2237 | | { 207, -7 }, /* (314) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ |
2238 | | { 207, -8 }, /* (315) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ |
2239 | | { 207, -9 }, /* (316) cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ |
2240 | | { 207, -7 }, /* (317) cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ |
2241 | | { 207, -3 }, /* (318) cmd ::= KILL CONNECTION INTEGER */ |
2242 | | { 207, -5 }, /* (319) cmd ::= KILL STREAM INTEGER COLON INTEGER */ |
2243 | | { 207, -5 }, /* (320) cmd ::= KILL QUERY INTEGER COLON INTEGER */ |
2244 | | { 207, -6 }, /* (321) cmd ::= DELETE FROM ifexists ids cpxName where_opt */ |
2245 | | }; |
2246 | | |
2247 | | static void yy_accept(yyParser*); /* Forward Declaration */ |
2248 | | |
2249 | | /* |
2250 | | ** Perform a reduce action and the shift that must immediately |
2251 | | ** follow the reduce. |
2252 | | ** |
2253 | | ** The yyLookahead and yyLookaheadToken parameters provide reduce actions |
2254 | | ** access to the lookahead token (if any). The yyLookahead will be YYNOCODE |
2255 | | ** if the lookahead token has already been consumed. As this procedure is |
2256 | | ** only called from one place, optimizing compilers will in-line it, which |
2257 | | ** means that the extra parameters have no performance impact. |
2258 | | */ |
2259 | | static void yy_reduce( |
2260 | | yyParser *yypParser, /* The parser */ |
2261 | | unsigned int yyruleno, /* Number of the rule by which to reduce */ |
2262 | | int yyLookahead, /* Lookahead token, or YYNOCODE if none */ |
2263 | | ParseTOKENTYPE yyLookaheadToken /* Value of the lookahead token */ |
2264 | 6.09M | ){ |
2265 | 6.09M | int yygoto; /* The next state */ |
2266 | 6.09M | int yyact; /* The next action */ |
2267 | 6.09M | yyStackEntry *yymsp; /* The top of the parser's stack */ |
2268 | 6.09M | int yysize; /* Amount to pop the stack */ |
2269 | 6.09M | ParseARG_FETCH; |
2270 | 6.09M | (void)yyLookahead; |
2271 | 6.09M | (void)yyLookaheadToken; |
2272 | 6.09M | yymsp = yypParser->yytos; |
2273 | 6.09M | #ifndef NDEBUG |
2274 | 6.09M | if( yyTraceFILE && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ |
2275 | 0 | yysize = yyRuleInfo[yyruleno].nrhs; |
2276 | 0 | if( yysize ){ |
2277 | 0 | fprintf(yyTraceFILE, "%sReduce %d [%s], go to state %d.\n", |
2278 | 0 | yyTracePrompt, |
2279 | 0 | yyruleno, yyRuleName[yyruleno], yymsp[yysize].stateno); |
2280 | 0 | }else{ |
2281 | 0 | fprintf(yyTraceFILE, "%sReduce %d [%s].\n", |
2282 | 0 | yyTracePrompt, yyruleno, yyRuleName[yyruleno]); |
2283 | 0 | } |
2284 | 0 | } |
2285 | 6.09M | #endif /* NDEBUG */ |
2286 | | |
2287 | | /* Check that the stack is large enough to grow by a single entry |
2288 | | ** if the RHS of the rule is empty. This ensures that there is room |
2289 | | ** enough on the stack to push the LHS value */ |
2290 | 6.09M | if( yyRuleInfo[yyruleno].nrhs==0 ){ |
2291 | | #ifdef YYTRACKMAXSTACKDEPTH |
2292 | | if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){ |
2293 | | yypParser->yyhwm++; |
2294 | | assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack)); |
2295 | | } |
2296 | | #endif |
2297 | 343k | #if YYSTACKDEPTH>0 |
2298 | 343k | if( yypParser->yytos>=yypParser->yystackEnd ){ |
2299 | 1.75k | yyStackOverflow(yypParser); |
2300 | 1.75k | return; |
2301 | 1.75k | } |
2302 | | #else |
2303 | | if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz-1] ){ |
2304 | | if( yyGrowStack(yypParser) ){ |
2305 | | yyStackOverflow(yypParser); |
2306 | | return; |
2307 | | } |
2308 | | yymsp = yypParser->yytos; |
2309 | | } |
2310 | | #endif |
2311 | 343k | } |
2312 | | |
2313 | 6.08M | switch( yyruleno ){ |
2314 | | /* Beginning here are the reduction cases. A typical example |
2315 | | ** follows: |
2316 | | ** case 0: |
2317 | | ** #line <lineno> <grammarfile> |
2318 | | ** { ... } // User supplied code |
2319 | | ** #line <lineno> <thisfile> |
2320 | | ** break; |
2321 | | */ |
2322 | | /********** Begin reduce actions **********************************************/ |
2323 | 0 | YYMINORTYPE yylhsminor; |
2324 | 2.37k | case 0: /* program ::= cmd */ |
2325 | 2.37k | case 138: /* cmd ::= CREATE TABLE create_table_args */ yytestcase(yyruleno==138); |
2326 | 2.37k | case 139: /* cmd ::= CREATE TABLE create_stable_args */ yytestcase(yyruleno==139); |
2327 | 2.37k | case 140: /* cmd ::= CREATE STABLE create_stable_args */ yytestcase(yyruleno==140); |
2328 | 2.37k | {} |
2329 | 2.37k | break; |
2330 | 0 | case 1: /* cmd ::= SHOW DATABASES */ |
2331 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_DB, 0, 0);} |
2332 | 0 | break; |
2333 | 1 | case 2: /* cmd ::= SHOW TOPICS */ |
2334 | 1 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_TP, 0, 0);} |
2335 | 1 | break; |
2336 | 0 | case 3: /* cmd ::= SHOW FUNCTIONS */ |
2337 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_FUNCTION, 0, 0);} |
2338 | 0 | break; |
2339 | 0 | case 4: /* cmd ::= SHOW MNODES */ |
2340 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_MNODE, 0, 0);} |
2341 | 0 | break; |
2342 | 0 | case 5: /* cmd ::= SHOW DNODES */ |
2343 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_DNODE, 0, 0);} |
2344 | 0 | break; |
2345 | 0 | case 6: /* cmd ::= SHOW ACCOUNTS */ |
2346 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_ACCT, 0, 0);} |
2347 | 0 | break; |
2348 | 0 | case 7: /* cmd ::= SHOW USERS */ |
2349 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_USER, 0, 0);} |
2350 | 0 | break; |
2351 | 0 | case 8: /* cmd ::= SHOW MODULES */ |
2352 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_MODULE, 0, 0); } |
2353 | 0 | break; |
2354 | 1 | case 9: /* cmd ::= SHOW QUERIES */ |
2355 | 1 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_QUERIES, 0, 0); } |
2356 | 1 | break; |
2357 | 0 | case 10: /* cmd ::= SHOW CONNECTIONS */ |
2358 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_CONNS, 0, 0);} |
2359 | 0 | break; |
2360 | 0 | case 11: /* cmd ::= SHOW STREAMS */ |
2361 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_STREAMS, 0, 0); } |
2362 | 0 | break; |
2363 | 0 | case 12: /* cmd ::= SHOW VARIABLES */ |
2364 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_VARIABLES, 0, 0); } |
2365 | 0 | break; |
2366 | 1 | case 13: /* cmd ::= SHOW SCORES */ |
2367 | 1 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_SCORES, 0, 0); } |
2368 | 1 | break; |
2369 | 0 | case 14: /* cmd ::= SHOW GRANTS */ |
2370 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_GRANTS, 0, 0); } |
2371 | 0 | break; |
2372 | 0 | case 15: /* cmd ::= SHOW VNODES */ |
2373 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, 0, 0); } |
2374 | 0 | break; |
2375 | 0 | case 16: /* cmd ::= SHOW VNODES ids */ |
2376 | 0 | { setShowOptions(pInfo, TSDB_MGMT_TABLE_VNODES, &yymsp[0].minor.yy0, 0); } |
2377 | 0 | break; |
2378 | 6 | case 17: /* dbPrefix ::= */ |
2379 | 6 | {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.type = 0;} |
2380 | 6 | break; |
2381 | 4 | case 18: /* dbPrefix ::= ids DOT */ |
2382 | 4 | {yylhsminor.yy0 = yymsp[-1].minor.yy0; } |
2383 | 4 | yymsp[-1].minor.yy0 = yylhsminor.yy0; |
2384 | 4 | break; |
2385 | 2.84k | case 19: /* cpxName ::= */ |
2386 | 2.84k | {yymsp[1].minor.yy0.n = 0; } |
2387 | 2.84k | break; |
2388 | 197 | case 20: /* cpxName ::= DOT ids */ |
2389 | 197 | {yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n += 1; } |
2390 | 197 | break; |
2391 | 1 | case 21: /* cmd ::= SHOW CREATE TABLE ids cpxName */ |
2392 | 1 | { |
2393 | 1 | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2394 | 1 | setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_TABLE, 1, &yymsp[-1].minor.yy0); |
2395 | 1 | } |
2396 | 1 | break; |
2397 | 1 | case 22: /* cmd ::= SHOW CREATE STABLE ids cpxName */ |
2398 | 1 | { |
2399 | 1 | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2400 | 1 | setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_STABLE, 1, &yymsp[-1].minor.yy0); |
2401 | 1 | } |
2402 | 1 | break; |
2403 | 0 | case 23: /* cmd ::= SHOW CREATE DATABASE ids */ |
2404 | 0 | { |
2405 | 0 | setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &yymsp[0].minor.yy0); |
2406 | 0 | } |
2407 | 0 | break; |
2408 | 3 | case 24: /* cmd ::= SHOW dbPrefix TABLES */ |
2409 | 3 | { |
2410 | 3 | setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-1].minor.yy0, 0); |
2411 | 3 | } |
2412 | 3 | break; |
2413 | 0 | case 25: /* cmd ::= SHOW dbPrefix TABLES LIKE STRING */ |
2414 | 0 | { |
2415 | 0 | setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0); |
2416 | 0 | } |
2417 | 0 | break; |
2418 | 1 | case 26: /* cmd ::= SHOW dbPrefix STABLES */ |
2419 | 1 | { |
2420 | 1 | setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &yymsp[-1].minor.yy0, 0); |
2421 | 1 | } |
2422 | 1 | break; |
2423 | 0 | case 27: /* cmd ::= SHOW dbPrefix STABLES LIKE STRING */ |
2424 | 0 | { |
2425 | 0 | SStrToken token; |
2426 | 0 | tSetDbName(&token, &yymsp[-3].minor.yy0); |
2427 | 0 | setShowOptions(pInfo, TSDB_MGMT_TABLE_METRIC, &token, &yymsp[0].minor.yy0); |
2428 | 0 | } |
2429 | 0 | break; |
2430 | 0 | case 28: /* cmd ::= SHOW dbPrefix VGROUPS */ |
2431 | 0 | { |
2432 | 0 | SStrToken token; |
2433 | 0 | tSetDbName(&token, &yymsp[-1].minor.yy0); |
2434 | 0 | setShowOptions(pInfo, TSDB_MGMT_TABLE_VGROUP, &token, 0); |
2435 | 0 | } |
2436 | 0 | break; |
2437 | 0 | case 29: /* cmd ::= DROP TABLE ifexists ids cpxName */ |
2438 | 0 | { |
2439 | 0 | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2440 | 0 | setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1, -1); |
2441 | 0 | } |
2442 | 0 | break; |
2443 | 0 | case 30: /* cmd ::= DROP STABLE ifexists ids cpxName */ |
2444 | 0 | { |
2445 | 0 | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2446 | 0 | setDropDbTableInfo(pInfo, TSDB_SQL_DROP_TABLE, &yymsp[-1].minor.yy0, &yymsp[-2].minor.yy0, -1, TSDB_SUPER_TABLE); |
2447 | 0 | } |
2448 | 0 | break; |
2449 | 0 | case 31: /* cmd ::= DROP DATABASE ifexists ids */ |
2450 | 0 | { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, TSDB_DB_TYPE_DEFAULT, -1); } |
2451 | 0 | break; |
2452 | 0 | case 32: /* cmd ::= DROP TOPIC ifexists ids */ |
2453 | 0 | { setDropDbTableInfo(pInfo, TSDB_SQL_DROP_DB, &yymsp[0].minor.yy0, &yymsp[-1].minor.yy0, TSDB_DB_TYPE_TOPIC, -1); } |
2454 | 0 | break; |
2455 | 0 | case 33: /* cmd ::= DROP FUNCTION ids */ |
2456 | 0 | { setDropFuncInfo(pInfo, TSDB_SQL_DROP_FUNCTION, &yymsp[0].minor.yy0); } |
2457 | 0 | break; |
2458 | 0 | case 34: /* cmd ::= DROP DNODE ids */ |
2459 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_DROP_DNODE, 1, &yymsp[0].minor.yy0); } |
2460 | 0 | break; |
2461 | 0 | case 35: /* cmd ::= DROP USER ids */ |
2462 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_DROP_USER, 1, &yymsp[0].minor.yy0); } |
2463 | 0 | break; |
2464 | 0 | case 36: /* cmd ::= DROP ACCOUNT ids */ |
2465 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_DROP_ACCT, 1, &yymsp[0].minor.yy0); } |
2466 | 0 | break; |
2467 | 29 | case 37: /* cmd ::= USE ids */ |
2468 | 29 | { setDCLSqlElems(pInfo, TSDB_SQL_USE_DB, 1, &yymsp[0].minor.yy0);} |
2469 | 29 | break; |
2470 | 1 | case 38: /* cmd ::= DESCRIBE ids cpxName */ |
2471 | 6 | case 39: /* cmd ::= DESC ids cpxName */ yytestcase(yyruleno==39); |
2472 | 6 | { |
2473 | 6 | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2474 | 6 | setDCLSqlElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &yymsp[-1].minor.yy0); |
2475 | 6 | } |
2476 | 6 | break; |
2477 | 0 | case 40: /* cmd ::= ALTER USER ids PASS ids */ |
2478 | 0 | { setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, NULL); } |
2479 | 0 | break; |
2480 | 0 | case 41: /* cmd ::= ALTER USER ids PRIVILEGE ids */ |
2481 | 0 | { setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &yymsp[-2].minor.yy0, NULL, &yymsp[0].minor.yy0);} |
2482 | 0 | break; |
2483 | 0 | case 42: /* cmd ::= ALTER DNODE ids ids */ |
2484 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_CFG_DNODE, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } |
2485 | 0 | break; |
2486 | 0 | case 43: /* cmd ::= ALTER DNODE ids ids ids */ |
2487 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_CFG_DNODE, 3, &yymsp[-2].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } |
2488 | 0 | break; |
2489 | 0 | case 44: /* cmd ::= ALTER LOCAL ids */ |
2490 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 1, &yymsp[0].minor.yy0); } |
2491 | 0 | break; |
2492 | 0 | case 45: /* cmd ::= ALTER LOCAL ids ids */ |
2493 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_CFG_LOCAL, 2, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0); } |
2494 | 0 | break; |
2495 | 0 | case 46: /* cmd ::= ALTER DATABASE ids alter_db_optr */ |
2496 | 0 | case 47: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==47); |
2497 | 0 | { SStrToken t = {0}; setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy342, &t);} |
2498 | 0 | break; |
2499 | 0 | case 48: /* cmd ::= ALTER ACCOUNT ids acct_optr */ |
2500 | 0 | { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy299);} |
2501 | 0 | break; |
2502 | 0 | case 49: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */ |
2503 | 0 | { setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy299);} |
2504 | 0 | break; |
2505 | 0 | case 50: /* cmd ::= COMPACT VNODES IN LP exprlist RP */ |
2506 | 0 | { setCompactVnodeSql(pInfo, TSDB_SQL_COMPACT_VNODE, yymsp[-1].minor.yy333);} |
2507 | 0 | break; |
2508 | 45.9k | case 51: /* ids ::= ID */ |
2509 | 48.7k | case 52: /* ids ::= STRING */ yytestcase(yyruleno==52); |
2510 | 48.7k | {yylhsminor.yy0 = yymsp[0].minor.yy0; } |
2511 | 48.7k | yymsp[0].minor.yy0 = yylhsminor.yy0; |
2512 | 48.7k | break; |
2513 | 0 | case 53: /* ifexists ::= IF EXISTS */ |
2514 | 0 | { yymsp[-1].minor.yy0.n = 1;} |
2515 | 0 | break; |
2516 | 0 | case 54: /* ifexists ::= */ |
2517 | 102 | case 56: /* ifnotexists ::= */ yytestcase(yyruleno==56); |
2518 | 118k | case 186: /* distinct ::= */ yytestcase(yyruleno==186); |
2519 | 118k | { yymsp[1].minor.yy0.n = 0;} |
2520 | 118k | break; |
2521 | 0 | case 55: /* ifnotexists ::= IF NOT EXISTS */ |
2522 | 0 | { yymsp[-2].minor.yy0.n = 1;} |
2523 | 0 | break; |
2524 | 0 | case 57: /* cmd ::= CREATE DNODE ids */ |
2525 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);} |
2526 | 0 | break; |
2527 | 0 | case 58: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */ |
2528 | 0 | { setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy299);} |
2529 | 0 | break; |
2530 | 0 | case 59: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */ |
2531 | 1 | case 60: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==60); |
2532 | 1 | { setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy342, &yymsp[-2].minor.yy0);} |
2533 | 1 | break; |
2534 | 0 | case 61: /* cmd ::= CREATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ |
2535 | 0 | { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy263, &yymsp[0].minor.yy0, 1);} |
2536 | 0 | break; |
2537 | 0 | case 62: /* cmd ::= CREATE AGGREGATE FUNCTION ids AS ids OUTPUTTYPE typename bufsize */ |
2538 | 0 | { setCreateFuncInfo(pInfo, TSDB_SQL_CREATE_FUNCTION, &yymsp[-5].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy263, &yymsp[0].minor.yy0, 2);} |
2539 | 0 | break; |
2540 | 0 | case 63: /* cmd ::= CREATE USER ids PASS ids */ |
2541 | 0 | { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);} |
2542 | 0 | break; |
2543 | 0 | case 64: /* bufsize ::= */ |
2544 | 0 | case 66: /* pps ::= */ yytestcase(yyruleno==66); |
2545 | 0 | case 68: /* tseries ::= */ yytestcase(yyruleno==68); |
2546 | 0 | case 70: /* dbs ::= */ yytestcase(yyruleno==70); |
2547 | 0 | case 72: /* streams ::= */ yytestcase(yyruleno==72); |
2548 | 0 | case 74: /* storage ::= */ yytestcase(yyruleno==74); |
2549 | 0 | case 76: /* qtime ::= */ yytestcase(yyruleno==76); |
2550 | 0 | case 78: /* users ::= */ yytestcase(yyruleno==78); |
2551 | 0 | case 80: /* conns ::= */ yytestcase(yyruleno==80); |
2552 | 0 | case 82: /* state ::= */ yytestcase(yyruleno==82); |
2553 | 0 | { yymsp[1].minor.yy0.n = 0; } |
2554 | 0 | break; |
2555 | 0 | case 65: /* bufsize ::= BUFSIZE INTEGER */ |
2556 | 0 | case 67: /* pps ::= PPS INTEGER */ yytestcase(yyruleno==67); |
2557 | 0 | case 69: /* tseries ::= TSERIES INTEGER */ yytestcase(yyruleno==69); |
2558 | 0 | case 71: /* dbs ::= DBS INTEGER */ yytestcase(yyruleno==71); |
2559 | 0 | case 73: /* streams ::= STREAMS INTEGER */ yytestcase(yyruleno==73); |
2560 | 0 | case 75: /* storage ::= STORAGE INTEGER */ yytestcase(yyruleno==75); |
2561 | 0 | case 77: /* qtime ::= QTIME INTEGER */ yytestcase(yyruleno==77); |
2562 | 0 | case 79: /* users ::= USERS INTEGER */ yytestcase(yyruleno==79); |
2563 | 0 | case 81: /* conns ::= CONNS INTEGER */ yytestcase(yyruleno==81); |
2564 | 0 | case 83: /* state ::= STATE ids */ yytestcase(yyruleno==83); |
2565 | 0 | { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } |
2566 | 0 | break; |
2567 | 0 | case 84: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */ |
2568 | 0 | { |
2569 | 0 | yylhsminor.yy299.maxUsers = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1; |
2570 | 0 | yylhsminor.yy299.maxDbs = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1; |
2571 | 0 | yylhsminor.yy299.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1; |
2572 | 0 | yylhsminor.yy299.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1; |
2573 | 0 | yylhsminor.yy299.maxPointsPerSecond = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1; |
2574 | 0 | yylhsminor.yy299.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1; |
2575 | 0 | yylhsminor.yy299.maxQueryTime = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1; |
2576 | 0 | yylhsminor.yy299.maxConnections = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1; |
2577 | 0 | yylhsminor.yy299.stat = yymsp[0].minor.yy0; |
2578 | 0 | } |
2579 | 0 | yymsp[-8].minor.yy299 = yylhsminor.yy299; |
2580 | 0 | break; |
2581 | 0 | case 85: /* intitemlist ::= intitemlist COMMA intitem */ |
2582 | 0 | case 158: /* tagitemlist ::= tagitemlist COMMA tagitem */ yytestcase(yyruleno==158); |
2583 | 0 | { yylhsminor.yy333 = tVariantListAppend(yymsp[-2].minor.yy333, &yymsp[0].minor.yy42, -1); } |
2584 | 0 | yymsp[-2].minor.yy333 = yylhsminor.yy333; |
2585 | 0 | break; |
2586 | 0 | case 86: /* intitemlist ::= intitem */ |
2587 | 0 | case 159: /* tagitemlist ::= tagitem */ yytestcase(yyruleno==159); |
2588 | 0 | { yylhsminor.yy333 = tVariantListAppend(NULL, &yymsp[0].minor.yy42, -1); } |
2589 | 0 | yymsp[0].minor.yy333 = yylhsminor.yy333; |
2590 | 0 | break; |
2591 | 0 | case 87: /* intitem ::= INTEGER */ |
2592 | 0 | case 160: /* tagitem ::= INTEGER */ yytestcase(yyruleno==160); |
2593 | 0 | case 161: /* tagitem ::= FLOAT */ yytestcase(yyruleno==161); |
2594 | 0 | case 162: /* tagitem ::= STRING */ yytestcase(yyruleno==162); |
2595 | 0 | case 163: /* tagitem ::= BOOL */ yytestcase(yyruleno==163); |
2596 | 0 | { toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0); } |
2597 | 0 | yymsp[0].minor.yy42 = yylhsminor.yy42; |
2598 | 0 | break; |
2599 | 0 | case 88: /* keep ::= KEEP intitemlist */ |
2600 | 0 | { yymsp[-1].minor.yy333 = yymsp[0].minor.yy333; } |
2601 | 0 | break; |
2602 | 0 | case 89: /* cache ::= CACHE INTEGER */ |
2603 | 0 | case 90: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==90); |
2604 | 0 | case 91: /* quorum ::= QUORUM INTEGER */ yytestcase(yyruleno==91); |
2605 | 0 | case 92: /* days ::= DAYS INTEGER */ yytestcase(yyruleno==92); |
2606 | 0 | case 93: /* minrows ::= MINROWS INTEGER */ yytestcase(yyruleno==93); |
2607 | 0 | case 94: /* maxrows ::= MAXROWS INTEGER */ yytestcase(yyruleno==94); |
2608 | 0 | case 95: /* blocks ::= BLOCKS INTEGER */ yytestcase(yyruleno==95); |
2609 | 0 | case 96: /* ctime ::= CTIME INTEGER */ yytestcase(yyruleno==96); |
2610 | 0 | case 97: /* wal ::= WAL INTEGER */ yytestcase(yyruleno==97); |
2611 | 0 | case 98: /* fsync ::= FSYNC INTEGER */ yytestcase(yyruleno==98); |
2612 | 0 | case 99: /* comp ::= COMP INTEGER */ yytestcase(yyruleno==99); |
2613 | 0 | case 100: /* prec ::= PRECISION STRING */ yytestcase(yyruleno==100); |
2614 | 0 | case 101: /* update ::= UPDATE INTEGER */ yytestcase(yyruleno==101); |
2615 | 0 | case 102: /* cachelast ::= CACHELAST INTEGER */ yytestcase(yyruleno==102); |
2616 | 0 | case 103: /* partitions ::= PARTITIONS INTEGER */ yytestcase(yyruleno==103); |
2617 | 0 | { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } |
2618 | 0 | break; |
2619 | 1 | case 104: /* db_optr ::= */ |
2620 | 1 | {setDefaultCreateDbOption(&yymsp[1].minor.yy342); yymsp[1].minor.yy342.dbType = TSDB_DB_TYPE_DEFAULT;} |
2621 | 1 | break; |
2622 | 0 | case 105: /* db_optr ::= db_optr cache */ |
2623 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2624 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2625 | 0 | break; |
2626 | 0 | case 106: /* db_optr ::= db_optr replica */ |
2627 | 0 | case 123: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==123); |
2628 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2629 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2630 | 0 | break; |
2631 | 0 | case 107: /* db_optr ::= db_optr quorum */ |
2632 | 0 | case 124: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==124); |
2633 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2634 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2635 | 0 | break; |
2636 | 0 | case 108: /* db_optr ::= db_optr days */ |
2637 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2638 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2639 | 0 | break; |
2640 | 0 | case 109: /* db_optr ::= db_optr minrows */ |
2641 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } |
2642 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2643 | 0 | break; |
2644 | 0 | case 110: /* db_optr ::= db_optr maxrows */ |
2645 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); } |
2646 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2647 | 0 | break; |
2648 | 0 | case 111: /* db_optr ::= db_optr blocks */ |
2649 | 0 | case 126: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==126); |
2650 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2651 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2652 | 0 | break; |
2653 | 0 | case 112: /* db_optr ::= db_optr ctime */ |
2654 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2655 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2656 | 0 | break; |
2657 | 0 | case 113: /* db_optr ::= db_optr wal */ |
2658 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2659 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2660 | 0 | break; |
2661 | 0 | case 114: /* db_optr ::= db_optr fsync */ |
2662 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2663 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2664 | 0 | break; |
2665 | 0 | case 115: /* db_optr ::= db_optr comp */ |
2666 | 0 | case 127: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==127); |
2667 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2668 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2669 | 0 | break; |
2670 | 0 | case 116: /* db_optr ::= db_optr prec */ |
2671 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.precision = yymsp[0].minor.yy0; } |
2672 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2673 | 0 | break; |
2674 | 0 | case 117: /* db_optr ::= db_optr keep */ |
2675 | 0 | case 125: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==125); |
2676 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.keep = yymsp[0].minor.yy333; } |
2677 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2678 | 0 | break; |
2679 | 0 | case 118: /* db_optr ::= db_optr update */ |
2680 | 0 | case 128: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==128); |
2681 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2682 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2683 | 0 | break; |
2684 | 0 | case 119: /* db_optr ::= db_optr cachelast */ |
2685 | 0 | case 129: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==129); |
2686 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2687 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2688 | 0 | break; |
2689 | 1 | case 120: /* topic_optr ::= db_optr */ |
2690 | 1 | case 130: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==130); |
2691 | 1 | { yylhsminor.yy342 = yymsp[0].minor.yy342; yylhsminor.yy342.dbType = TSDB_DB_TYPE_TOPIC; } |
2692 | 1 | yymsp[0].minor.yy342 = yylhsminor.yy342; |
2693 | 1 | break; |
2694 | 0 | case 121: /* topic_optr ::= topic_optr partitions */ |
2695 | 0 | case 131: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==131); |
2696 | 0 | { yylhsminor.yy342 = yymsp[-1].minor.yy342; yylhsminor.yy342.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2697 | 0 | yymsp[-1].minor.yy342 = yylhsminor.yy342; |
2698 | 0 | break; |
2699 | 0 | case 122: /* alter_db_optr ::= */ |
2700 | 0 | { setDefaultCreateDbOption(&yymsp[1].minor.yy342); yymsp[1].minor.yy342.dbType = TSDB_DB_TYPE_DEFAULT;} |
2701 | 0 | break; |
2702 | 2.02k | case 132: /* typename ::= ids */ |
2703 | 2.02k | { |
2704 | 2.02k | yymsp[0].minor.yy0.type = 0; |
2705 | 2.02k | tSetColumnType (&yylhsminor.yy263, &yymsp[0].minor.yy0); |
2706 | 2.02k | } |
2707 | 2.02k | yymsp[0].minor.yy263 = yylhsminor.yy263; |
2708 | 2.02k | break; |
2709 | 2.18k | case 133: /* typename ::= ids LP signed RP */ |
2710 | 2.18k | { |
2711 | 2.18k | if (yymsp[-1].minor.yy277 <= 0) { |
2712 | 548 | yymsp[-3].minor.yy0.type = 0; |
2713 | 548 | tSetColumnType(&yylhsminor.yy263, &yymsp[-3].minor.yy0); |
2714 | 1.63k | } else { |
2715 | 1.63k | yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy277; // negative value of name length |
2716 | 1.63k | tSetColumnType(&yylhsminor.yy263, &yymsp[-3].minor.yy0); |
2717 | 1.63k | } |
2718 | 2.18k | } |
2719 | 2.18k | yymsp[-3].minor.yy263 = yylhsminor.yy263; |
2720 | 2.18k | break; |
2721 | 257 | case 134: /* typename ::= ids UNSIGNED */ |
2722 | 257 | { |
2723 | 257 | yymsp[-1].minor.yy0.type = 0; |
2724 | 257 | yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z); |
2725 | 257 | tSetColumnType (&yylhsminor.yy263, &yymsp[-1].minor.yy0); |
2726 | 257 | } |
2727 | 257 | yymsp[-1].minor.yy263 = yylhsminor.yy263; |
2728 | 257 | break; |
2729 | 1.73k | case 135: /* signed ::= INTEGER */ |
2730 | 1.73k | { yylhsminor.yy277 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2731 | 1.73k | yymsp[0].minor.yy277 = yylhsminor.yy277; |
2732 | 1.73k | break; |
2733 | 197 | case 136: /* signed ::= PLUS INTEGER */ |
2734 | 197 | { yymsp[-1].minor.yy277 = strtol(yymsp[0].minor.yy0.z, NULL, 10); } |
2735 | 197 | break; |
2736 | 279 | case 137: /* signed ::= MINUS INTEGER */ |
2737 | 279 | { yymsp[-1].minor.yy277 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);} |
2738 | 279 | break; |
2739 | 0 | case 141: /* cmd ::= CREATE TABLE create_table_list */ |
2740 | 0 | { pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy78;} |
2741 | 0 | break; |
2742 | 0 | case 142: /* create_table_list ::= create_from_stable */ |
2743 | 0 | { |
2744 | 0 | SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql)); |
2745 | 0 | pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo)); |
2746 | |
|
2747 | 0 | taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy400); |
2748 | 0 | pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE; |
2749 | 0 | yylhsminor.yy78 = pCreateTable; |
2750 | 0 | } |
2751 | 0 | yymsp[0].minor.yy78 = yylhsminor.yy78; |
2752 | 0 | break; |
2753 | 0 | case 143: /* create_table_list ::= create_table_list create_from_stable */ |
2754 | 0 | { |
2755 | 0 | taosArrayPush(yymsp[-1].minor.yy78->childTableInfo, &yymsp[0].minor.yy400); |
2756 | 0 | yylhsminor.yy78 = yymsp[-1].minor.yy78; |
2757 | 0 | } |
2758 | 0 | yymsp[-1].minor.yy78 = yylhsminor.yy78; |
2759 | 0 | break; |
2760 | 1 | case 144: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */ |
2761 | 1 | { |
2762 | 1 | yylhsminor.yy78 = tSetCreateTableInfo(yymsp[-1].minor.yy333, NULL, NULL, TSQL_CREATE_TABLE); |
2763 | 1 | setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE); |
2764 | | |
2765 | 1 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
2766 | 1 | setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0); |
2767 | 1 | } |
2768 | 1 | yymsp[-5].minor.yy78 = yylhsminor.yy78; |
2769 | 1 | break; |
2770 | 0 | case 145: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */ |
2771 | 0 | { |
2772 | 0 | yylhsminor.yy78 = tSetCreateTableInfo(yymsp[-5].minor.yy333, yymsp[-1].minor.yy333, NULL, TSQL_CREATE_STABLE); |
2773 | 0 | setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE); |
2774 | |
|
2775 | 0 | yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; |
2776 | 0 | setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); |
2777 | 0 | } |
2778 | 0 | yymsp[-9].minor.yy78 = yylhsminor.yy78; |
2779 | 0 | break; |
2780 | 0 | case 146: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */ |
2781 | 0 | { |
2782 | 0 | yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; |
2783 | 0 | yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; |
2784 | 0 | yylhsminor.yy400 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy333, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0); |
2785 | 0 | } |
2786 | 0 | yymsp[-9].minor.yy400 = yylhsminor.yy400; |
2787 | 0 | break; |
2788 | 0 | case 147: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */ |
2789 | 0 | { |
2790 | 0 | yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n; |
2791 | 0 | yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n; |
2792 | 0 | yylhsminor.yy400 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy333, yymsp[-1].minor.yy333, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0); |
2793 | 0 | } |
2794 | 0 | yymsp[-12].minor.yy400 = yylhsminor.yy400; |
2795 | 0 | break; |
2796 | 0 | case 148: /* tagNamelist ::= tagNamelist COMMA ids */ |
2797 | 0 | {taosArrayPush(yymsp[-2].minor.yy333, &yymsp[0].minor.yy0); yylhsminor.yy333 = yymsp[-2].minor.yy333; } |
2798 | 0 | yymsp[-2].minor.yy333 = yylhsminor.yy333; |
2799 | 0 | break; |
2800 | 0 | case 149: /* tagNamelist ::= ids */ |
2801 | 0 | {yylhsminor.yy333 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy333, &yymsp[0].minor.yy0);} |
2802 | 0 | yymsp[0].minor.yy333 = yylhsminor.yy333; |
2803 | 0 | break; |
2804 | 0 | case 150: /* create_table_args ::= ifnotexists ids cpxName to_opt split_opt AS select */ |
2805 | 0 | { |
2806 | 0 | yylhsminor.yy78 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy144, TSQL_CREATE_STREAM); |
2807 | 0 | setSqlInfo(pInfo, yylhsminor.yy78, NULL, TSDB_SQL_CREATE_TABLE); |
2808 | |
|
2809 | 0 | setCreatedStreamOpt(pInfo, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0); |
2810 | 0 | yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; |
2811 | 0 | setCreatedTableName(pInfo, &yymsp[-5].minor.yy0, &yymsp[-6].minor.yy0); |
2812 | 0 | } |
2813 | 0 | yymsp[-6].minor.yy78 = yylhsminor.yy78; |
2814 | 0 | break; |
2815 | 1 | case 151: /* to_opt ::= */ |
2816 | 3 | case 153: /* split_opt ::= */ yytestcase(yyruleno==153); |
2817 | 3 | {yymsp[1].minor.yy0.n = 0;} |
2818 | 3 | break; |
2819 | 1 | case 152: /* to_opt ::= TO ids cpxName */ |
2820 | 1 | { |
2821 | 1 | yymsp[-2].minor.yy0 = yymsp[-1].minor.yy0; |
2822 | 1 | yymsp[-2].minor.yy0.n += yymsp[0].minor.yy0.n; |
2823 | 1 | } |
2824 | 1 | break; |
2825 | 0 | case 154: /* split_opt ::= SPLIT ids */ |
2826 | 0 | { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;} |
2827 | 0 | break; |
2828 | 1.36k | case 155: /* columnlist ::= columnlist COMMA column */ |
2829 | 1.36k | {taosArrayPush(yymsp[-2].minor.yy333, &yymsp[0].minor.yy263); yylhsminor.yy333 = yymsp[-2].minor.yy333; } |
2830 | 1.36k | yymsp[-2].minor.yy333 = yylhsminor.yy333; |
2831 | 1.36k | break; |
2832 | 97 | case 156: /* columnlist ::= column */ |
2833 | 97 | {yylhsminor.yy333 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy333, &yymsp[0].minor.yy263);} |
2834 | 97 | yymsp[0].minor.yy333 = yylhsminor.yy333; |
2835 | 97 | break; |
2836 | 1.46k | case 157: /* column ::= ids typename */ |
2837 | 1.46k | { |
2838 | 1.46k | tSetColumnInfo(&yylhsminor.yy263, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy263); |
2839 | 1.46k | } |
2840 | 1.46k | yymsp[-1].minor.yy263 = yylhsminor.yy263; |
2841 | 1.46k | break; |
2842 | 0 | case 164: /* tagitem ::= NULL */ |
2843 | 0 | { yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0); } |
2844 | 0 | yymsp[0].minor.yy42 = yylhsminor.yy42; |
2845 | 0 | break; |
2846 | 0 | case 165: /* tagitem ::= NOW */ |
2847 | 0 | { yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; tVariantCreateExt(&yylhsminor.yy42, &yymsp[0].minor.yy0, TK_NOW, true);} |
2848 | 0 | yymsp[0].minor.yy42 = yylhsminor.yy42; |
2849 | 0 | break; |
2850 | 0 | case 166: /* tagitem ::= NOW PLUS VARIABLE */ |
2851 | 0 | { |
2852 | 0 | yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; |
2853 | 0 | tVariantCreateExt(&yymsp[-2].minor.yy42, &yymsp[0].minor.yy0, TK_PLUS, true); |
2854 | 0 | } |
2855 | 0 | break; |
2856 | 0 | case 167: /* tagitem ::= NOW MINUS VARIABLE */ |
2857 | 0 | { |
2858 | 0 | yymsp[0].minor.yy0.type = TSDB_DATA_TYPE_TIMESTAMP; |
2859 | 0 | tVariantCreateExt(&yymsp[-2].minor.yy42, &yymsp[0].minor.yy0, TK_MINUS, true); |
2860 | 0 | } |
2861 | 0 | break; |
2862 | 0 | case 168: /* tagitem ::= MINUS INTEGER */ |
2863 | 0 | case 169: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==169); |
2864 | 0 | case 170: /* tagitem ::= PLUS INTEGER */ yytestcase(yyruleno==170); |
2865 | 0 | case 171: /* tagitem ::= PLUS FLOAT */ yytestcase(yyruleno==171); |
2866 | 0 | { |
2867 | 0 | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2868 | 0 | yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type; |
2869 | 0 | toTSDBType(yymsp[-1].minor.yy0.type); |
2870 | 0 | tVariantCreate(&yylhsminor.yy42, &yymsp[-1].minor.yy0); |
2871 | 0 | } |
2872 | 0 | yymsp[-1].minor.yy42 = yylhsminor.yy42; |
2873 | 0 | break; |
2874 | 1.17k | case 172: /* select ::= SELECT selcollist from where_opt range_option interval_option sliding_opt session_option windowstate_option fill_opt groupby_opt having_opt orderby_opt slimit_opt limit_opt */ |
2875 | 1.17k | { |
2876 | 1.17k | yylhsminor.yy144 = tSetQuerySqlNode(&yymsp[-14].minor.yy0, yymsp[-13].minor.yy333, yymsp[-12].minor.yy516, yymsp[-11].minor.yy194, yymsp[-4].minor.yy333, yymsp[-2].minor.yy333, &yymsp[-9].minor.yy200, &yymsp[-7].minor.yy235, &yymsp[-6].minor.yy248, &yymsp[-8].minor.yy0, yymsp[-5].minor.yy333, &yymsp[0].minor.yy190, &yymsp[-1].minor.yy190, yymsp[-3].minor.yy194, &yymsp[-10].minor.yy132); |
2877 | 1.17k | } |
2878 | 1.17k | yymsp[-14].minor.yy144 = yylhsminor.yy144; |
2879 | 1.17k | break; |
2880 | 84 | case 173: /* select ::= LP select RP */ |
2881 | 84 | {yymsp[-2].minor.yy144 = yymsp[-1].minor.yy144;} |
2882 | 84 | break; |
2883 | 37.9k | case 174: /* union ::= select */ |
2884 | 37.9k | { yylhsminor.yy333 = setSubclause(NULL, yymsp[0].minor.yy144); } |
2885 | 37.9k | yymsp[0].minor.yy333 = yylhsminor.yy333; |
2886 | 37.9k | break; |
2887 | 0 | case 175: /* union ::= union UNION ALL select */ |
2888 | 0 | { yylhsminor.yy333 = appendSelectClause(yymsp[-3].minor.yy333, yymsp[0].minor.yy144); } |
2889 | 0 | yymsp[-3].minor.yy333 = yylhsminor.yy333; |
2890 | 0 | break; |
2891 | 2.48k | case 176: /* cmd ::= union */ |
2892 | 2.48k | { setSqlInfo(pInfo, yymsp[0].minor.yy333, NULL, TSDB_SQL_SELECT); } |
2893 | 2.48k | break; |
2894 | 36.8k | case 177: /* select ::= SELECT selcollist */ |
2895 | 36.8k | { |
2896 | 36.8k | yylhsminor.yy144 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy333, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); |
2897 | 36.8k | } |
2898 | 36.8k | yymsp[-1].minor.yy144 = yylhsminor.yy144; |
2899 | 36.8k | break; |
2900 | 112k | case 178: /* sclp ::= selcollist COMMA */ |
2901 | 112k | {yylhsminor.yy333 = yymsp[-1].minor.yy333;} |
2902 | 112k | yymsp[-1].minor.yy333 = yylhsminor.yy333; |
2903 | 112k | break; |
2904 | 42.6k | case 179: /* sclp ::= */ |
2905 | 45.1k | case 220: /* orderby_opt ::= */ yytestcase(yyruleno==220); |
2906 | 45.1k | {yymsp[1].minor.yy333 = 0;} |
2907 | 45.1k | break; |
2908 | 115k | case 180: /* selcollist ::= sclp distinct expr as */ |
2909 | 115k | { |
2910 | 115k | yylhsminor.yy333 = tSqlExprListAppend(yymsp[-3].minor.yy333, yymsp[-1].minor.yy194, yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0); |
2911 | 115k | } |
2912 | 115k | yymsp[-3].minor.yy333 = yylhsminor.yy333; |
2913 | 115k | break; |
2914 | 37.4k | case 181: /* selcollist ::= sclp STAR */ |
2915 | 37.4k | { |
2916 | 37.4k | tSqlExpr *pNode = tSqlExprCreateIdValue(pInfo, NULL, TK_ALL); |
2917 | 37.4k | yylhsminor.yy333 = tSqlExprListAppend(yymsp[-1].minor.yy333, pNode, 0, 0); |
2918 | 37.4k | } |
2919 | 37.4k | yymsp[-1].minor.yy333 = yylhsminor.yy333; |
2920 | 37.4k | break; |
2921 | 194 | case 182: /* as ::= AS ids */ |
2922 | 194 | { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; } |
2923 | 194 | break; |
2924 | 3.62k | case 183: /* as ::= ids */ |
2925 | 3.62k | { yylhsminor.yy0 = yymsp[0].minor.yy0; } |
2926 | 3.62k | yymsp[0].minor.yy0 = yylhsminor.yy0; |
2927 | 3.62k | break; |
2928 | 111k | case 184: /* as ::= */ |
2929 | 111k | { yymsp[1].minor.yy0.n = 0; } |
2930 | 111k | break; |
2931 | 228 | case 185: /* distinct ::= DISTINCT */ |
2932 | 228 | { yylhsminor.yy0 = yymsp[0].minor.yy0; } |
2933 | 228 | yymsp[0].minor.yy0 = yylhsminor.yy0; |
2934 | 228 | break; |
2935 | 1.45k | case 187: /* from ::= FROM tablelist */ |
2936 | 2.55k | case 188: /* from ::= FROM sub */ yytestcase(yyruleno==188); |
2937 | 2.55k | {yymsp[-1].minor.yy516 = yymsp[0].minor.yy516;} |
2938 | 2.55k | break; |
2939 | 488 | case 189: /* sub ::= LP union RP */ |
2940 | 488 | {yymsp[-2].minor.yy516 = addSubqueryElem(NULL, yymsp[-1].minor.yy333, NULL);} |
2941 | 488 | break; |
2942 | 728 | case 190: /* sub ::= LP union RP ids */ |
2943 | 728 | {yymsp[-3].minor.yy516 = addSubqueryElem(NULL, yymsp[-2].minor.yy333, &yymsp[0].minor.yy0);} |
2944 | 728 | break; |
2945 | 34.2k | case 191: /* sub ::= sub COMMA LP union RP ids */ |
2946 | 34.2k | {yylhsminor.yy516 = addSubqueryElem(yymsp[-5].minor.yy516, yymsp[-2].minor.yy333, &yymsp[0].minor.yy0);} |
2947 | 34.2k | yymsp[-5].minor.yy516 = yylhsminor.yy516; |
2948 | 34.2k | break; |
2949 | 1.31k | case 192: /* tablelist ::= ids cpxName */ |
2950 | 1.31k | { |
2951 | 1.31k | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2952 | 1.31k | yylhsminor.yy516 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL); |
2953 | 1.31k | } |
2954 | 1.31k | yymsp[-1].minor.yy516 = yylhsminor.yy516; |
2955 | 1.31k | break; |
2956 | 337 | case 193: /* tablelist ::= ids cpxName ids */ |
2957 | 337 | { |
2958 | 337 | yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; |
2959 | 337 | yylhsminor.yy516 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); |
2960 | 337 | } |
2961 | 337 | yymsp[-2].minor.yy516 = yylhsminor.yy516; |
2962 | 337 | break; |
2963 | 737 | case 194: /* tablelist ::= tablelist COMMA ids cpxName */ |
2964 | 737 | { |
2965 | 737 | yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; |
2966 | 737 | yylhsminor.yy516 = setTableNameList(yymsp[-3].minor.yy516, &yymsp[-1].minor.yy0, NULL); |
2967 | 737 | } |
2968 | 737 | yymsp[-3].minor.yy516 = yylhsminor.yy516; |
2969 | 737 | break; |
2970 | 359 | case 195: /* tablelist ::= tablelist COMMA ids cpxName ids */ |
2971 | 359 | { |
2972 | 359 | yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; |
2973 | 359 | yylhsminor.yy516 = setTableNameList(yymsp[-4].minor.yy516, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0); |
2974 | 359 | } |
2975 | 359 | yymsp[-4].minor.yy516 = yylhsminor.yy516; |
2976 | 359 | break; |
2977 | 6 | case 196: /* tmvar ::= VARIABLE */ |
2978 | 6 | {yylhsminor.yy0 = yymsp[0].minor.yy0;} |
2979 | 6 | yymsp[0].minor.yy0 = yylhsminor.yy0; |
2980 | 6 | break; |
2981 | 0 | case 197: /* timestamp ::= INTEGER */ |
2982 | 0 | { yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_INTEGER);} |
2983 | 0 | yymsp[0].minor.yy194 = yylhsminor.yy194; |
2984 | 0 | break; |
2985 | 0 | case 198: /* timestamp ::= MINUS INTEGER */ |
2986 | 0 | case 199: /* timestamp ::= PLUS INTEGER */ yytestcase(yyruleno==199); |
2987 | 0 | { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[-1].minor.yy0, TK_INTEGER);} |
2988 | 0 | yymsp[-1].minor.yy194 = yylhsminor.yy194; |
2989 | 0 | break; |
2990 | 0 | case 200: /* timestamp ::= STRING */ |
2991 | 0 | { yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_STRING);} |
2992 | 0 | yymsp[0].minor.yy194 = yylhsminor.yy194; |
2993 | 0 | break; |
2994 | 0 | case 201: /* timestamp ::= NOW */ |
2995 | 0 | { yylhsminor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_NOW); } |
2996 | 0 | yymsp[0].minor.yy194 = yylhsminor.yy194; |
2997 | 0 | break; |
2998 | 0 | case 202: /* timestamp ::= NOW PLUS VARIABLE */ |
2999 | 0 | {yymsp[-2].minor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_PLUS); } |
3000 | 0 | break; |
3001 | 0 | case 203: /* timestamp ::= NOW MINUS VARIABLE */ |
3002 | 0 | {yymsp[-2].minor.yy194 = tSqlExprCreateTimestamp(&yymsp[0].minor.yy0, TK_MINUS); } |
3003 | 0 | break; |
3004 | 2.55k | case 204: /* range_option ::= */ |
3005 | 2.55k | {yymsp[1].minor.yy132.start = 0; yymsp[1].minor.yy132.end = 0;} |
3006 | 2.55k | break; |
3007 | 0 | case 205: /* range_option ::= RANGE LP timestamp COMMA timestamp RP */ |
3008 | 0 | {yymsp[-5].minor.yy132.start = yymsp[-3].minor.yy194; yymsp[-5].minor.yy132.end = yymsp[-1].minor.yy194;} |
3009 | 0 | break; |
3010 | 1 | case 206: /* interval_option ::= intervalKey LP tmvar RP */ |
3011 | 1 | {yylhsminor.yy200.interval = yymsp[-1].minor.yy0; yylhsminor.yy200.offset.n = 0; yylhsminor.yy200.token = yymsp[-3].minor.yy44;} |
3012 | 1 | yymsp[-3].minor.yy200 = yylhsminor.yy200; |
3013 | 1 | break; |
3014 | 1 | case 207: /* interval_option ::= intervalKey LP tmvar COMMA tmvar RP */ |
3015 | 1 | {yylhsminor.yy200.interval = yymsp[-3].minor.yy0; yylhsminor.yy200.offset = yymsp[-1].minor.yy0; yylhsminor.yy200.token = yymsp[-5].minor.yy44;} |
3016 | 1 | yymsp[-5].minor.yy200 = yylhsminor.yy200; |
3017 | 1 | break; |
3018 | 2.54k | case 208: /* interval_option ::= */ |
3019 | 2.54k | {memset(&yymsp[1].minor.yy200, 0, sizeof(yymsp[1].minor.yy200));} |
3020 | 2.54k | break; |
3021 | 1 | case 209: /* intervalKey ::= INTERVAL */ |
3022 | 1 | {yymsp[0].minor.yy44 = TK_INTERVAL;} |
3023 | 1 | break; |
3024 | 5 | case 210: /* intervalKey ::= EVERY */ |
3025 | 5 | {yymsp[0].minor.yy44 = TK_EVERY; } |
3026 | 5 | break; |
3027 | 2.55k | case 211: /* session_option ::= */ |
3028 | 2.55k | {yymsp[1].minor.yy235.col.n = 0; yymsp[1].minor.yy235.gap.n = 0;} |
3029 | 2.55k | break; |
3030 | 0 | case 212: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */ |
3031 | 0 | { |
3032 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3033 | 0 | yymsp[-6].minor.yy235.col = yymsp[-4].minor.yy0; |
3034 | 0 | yymsp[-6].minor.yy235.gap = yymsp[-1].minor.yy0; |
3035 | 0 | } |
3036 | 0 | break; |
3037 | 2.55k | case 213: /* windowstate_option ::= */ |
3038 | 2.55k | { yymsp[1].minor.yy248.col.n = 0; yymsp[1].minor.yy248.col.z = NULL;} |
3039 | 2.55k | break; |
3040 | 0 | case 214: /* windowstate_option ::= STATE_WINDOW LP ids RP */ |
3041 | 0 | { yymsp[-3].minor.yy248.col = yymsp[-1].minor.yy0; } |
3042 | 0 | break; |
3043 | 2.55k | case 215: /* fill_opt ::= */ |
3044 | 2.55k | { yymsp[1].minor.yy333 = 0; } |
3045 | 2.55k | break; |
3046 | 0 | case 216: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */ |
3047 | 0 | { |
3048 | 0 | tVariant A = {0}; |
3049 | 0 | toTSDBType(yymsp[-3].minor.yy0.type); |
3050 | 0 | tVariantCreate(&A, &yymsp[-3].minor.yy0); |
3051 | |
|
3052 | 0 | tVariantListInsert(yymsp[-1].minor.yy333, &A, -1, 0); |
3053 | 0 | yymsp[-5].minor.yy333 = yymsp[-1].minor.yy333; |
3054 | 0 | } |
3055 | 0 | break; |
3056 | 0 | case 217: /* fill_opt ::= FILL LP ID RP */ |
3057 | 0 | { |
3058 | 0 | toTSDBType(yymsp[-1].minor.yy0.type); |
3059 | 0 | yymsp[-3].minor.yy333 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, true); |
3060 | 0 | } |
3061 | 0 | break; |
3062 | 0 | case 218: /* sliding_opt ::= SLIDING LP tmvar RP */ |
3063 | 0 | {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0; } |
3064 | 0 | break; |
3065 | 2.55k | case 219: /* sliding_opt ::= */ |
3066 | 2.55k | {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0; } |
3067 | 2.55k | break; |
3068 | 0 | case 221: /* orderby_opt ::= ORDER BY sortlist */ |
3069 | 0 | {yymsp[-2].minor.yy333 = yymsp[0].minor.yy333;} |
3070 | 0 | break; |
3071 | 0 | case 222: /* sortlist ::= sortlist COMMA item sortorder */ |
3072 | 0 | { |
3073 | 0 | yylhsminor.yy333 = commonItemAppend(yymsp[-3].minor.yy333, &yymsp[-1].minor.yy42, NULL, false, yymsp[0].minor.yy133); |
3074 | 0 | } |
3075 | 0 | yymsp[-3].minor.yy333 = yylhsminor.yy333; |
3076 | 0 | break; |
3077 | 0 | case 223: /* sortlist ::= sortlist COMMA arrow sortorder */ |
3078 | 0 | { |
3079 | 0 | yylhsminor.yy333 = commonItemAppend(yymsp[-3].minor.yy333, NULL, yymsp[-1].minor.yy194, true, yymsp[0].minor.yy133); |
3080 | 0 | } |
3081 | 0 | yymsp[-3].minor.yy333 = yylhsminor.yy333; |
3082 | 0 | break; |
3083 | 0 | case 224: /* sortlist ::= item sortorder */ |
3084 | 0 | { |
3085 | 0 | yylhsminor.yy333 = commonItemAppend(NULL, &yymsp[-1].minor.yy42, NULL, false, yymsp[0].minor.yy133); |
3086 | 0 | } |
3087 | 0 | yymsp[-1].minor.yy333 = yylhsminor.yy333; |
3088 | 0 | break; |
3089 | 0 | case 225: /* sortlist ::= arrow sortorder */ |
3090 | 0 | { |
3091 | 0 | yylhsminor.yy333 = commonItemAppend(NULL, NULL, yymsp[-1].minor.yy194, true, yymsp[0].minor.yy133); |
3092 | 0 | } |
3093 | 0 | yymsp[-1].minor.yy333 = yylhsminor.yy333; |
3094 | 0 | break; |
3095 | 0 | case 226: /* item ::= ID */ |
3096 | 0 | { |
3097 | 0 | toTSDBType(yymsp[0].minor.yy0.type); |
3098 | 0 | tVariantCreate(&yylhsminor.yy42, &yymsp[0].minor.yy0); |
3099 | 0 | } |
3100 | 0 | yymsp[0].minor.yy42 = yylhsminor.yy42; |
3101 | 0 | break; |
3102 | 0 | case 227: /* item ::= ID DOT ID */ |
3103 | 0 | { |
3104 | 0 | toTSDBType(yymsp[-2].minor.yy0.type); |
3105 | 0 | yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); |
3106 | 0 | tVariantCreate(&yylhsminor.yy42, &yymsp[-2].minor.yy0); |
3107 | 0 | } |
3108 | 0 | yymsp[-2].minor.yy42 = yylhsminor.yy42; |
3109 | 0 | break; |
3110 | 0 | case 228: /* sortorder ::= ASC */ |
3111 | 0 | { yymsp[0].minor.yy133 = TSDB_ORDER_ASC; } |
3112 | 0 | break; |
3113 | 0 | case 229: /* sortorder ::= DESC */ |
3114 | 0 | { yymsp[0].minor.yy133 = TSDB_ORDER_DESC;} |
3115 | 0 | break; |
3116 | 0 | case 230: /* sortorder ::= */ |
3117 | 0 | { yymsp[1].minor.yy133 = TSDB_ORDER_ASC; } |
3118 | 0 | break; |
3119 | 2.54k | case 231: /* groupby_opt ::= */ |
3120 | 2.54k | { yymsp[1].minor.yy333 = 0;} |
3121 | 2.54k | break; |
3122 | 0 | case 232: /* groupby_opt ::= GROUP BY grouplist */ |
3123 | 0 | { yymsp[-2].minor.yy333 = yymsp[0].minor.yy333;} |
3124 | 0 | break; |
3125 | 0 | case 233: /* grouplist ::= grouplist COMMA item */ |
3126 | 0 | { |
3127 | 0 | yylhsminor.yy333 = commonItemAppend(yymsp[-2].minor.yy333, &yymsp[0].minor.yy42, NULL, false, -1); |
3128 | 0 | } |
3129 | 0 | yymsp[-2].minor.yy333 = yylhsminor.yy333; |
3130 | 0 | break; |
3131 | 0 | case 234: /* grouplist ::= grouplist COMMA arrow */ |
3132 | 0 | { |
3133 | 0 | yylhsminor.yy333 = commonItemAppend(yymsp[-2].minor.yy333, NULL, yymsp[0].minor.yy194, true, -1); |
3134 | 0 | } |
3135 | 0 | yymsp[-2].minor.yy333 = yylhsminor.yy333; |
3136 | 0 | break; |
3137 | 0 | case 235: /* grouplist ::= item */ |
3138 | 0 | { |
3139 | 0 | yylhsminor.yy333 = commonItemAppend(NULL, &yymsp[0].minor.yy42, NULL, false, -1); |
3140 | 0 | } |
3141 | 0 | yymsp[0].minor.yy333 = yylhsminor.yy333; |
3142 | 0 | break; |
3143 | 0 | case 236: /* grouplist ::= arrow */ |
3144 | 0 | { |
3145 | 0 | yylhsminor.yy333 = commonItemAppend(NULL, NULL, yymsp[0].minor.yy194, true, -1); |
3146 | 0 | } |
3147 | 0 | yymsp[0].minor.yy333 = yylhsminor.yy333; |
3148 | 0 | break; |
3149 | 2.53k | case 237: /* having_opt ::= */ |
3150 | 5.08k | case 247: /* where_opt ::= */ yytestcase(yyruleno==247); |
3151 | 42.8k | case 299: /* expritem ::= */ yytestcase(yyruleno==299); |
3152 | 42.8k | {yymsp[1].minor.yy194 = 0;} |
3153 | 42.8k | break; |
3154 | 1 | case 238: /* having_opt ::= HAVING expr */ |
3155 | 1 | case 248: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==248); |
3156 | 1 | {yymsp[-1].minor.yy194 = yymsp[0].minor.yy194;} |
3157 | 1 | break; |
3158 | 1.16k | case 239: /* limit_opt ::= */ |
3159 | 3.53k | case 243: /* slimit_opt ::= */ yytestcase(yyruleno==243); |
3160 | 3.53k | {yymsp[1].minor.yy190.limit = -1; yymsp[1].minor.yy190.offset = 0;} |
3161 | 3.53k | break; |
3162 | 1 | case 240: /* limit_opt ::= LIMIT signed */ |
3163 | 2 | case 244: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==244); |
3164 | 2 | {yymsp[-1].minor.yy190.limit = yymsp[0].minor.yy277; yymsp[-1].minor.yy190.offset = 0;} |
3165 | 2 | break; |
3166 | 0 | case 241: /* limit_opt ::= LIMIT signed OFFSET signed */ |
3167 | 0 | { yymsp[-3].minor.yy190.limit = yymsp[-2].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[0].minor.yy277;} |
3168 | 0 | break; |
3169 | 2 | case 242: /* limit_opt ::= LIMIT signed COMMA signed */ |
3170 | 2 | { yymsp[-3].minor.yy190.limit = yymsp[0].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[-2].minor.yy277;} |
3171 | 2 | break; |
3172 | 0 | case 245: /* slimit_opt ::= SLIMIT signed SOFFSET signed */ |
3173 | 0 | {yymsp[-3].minor.yy190.limit = yymsp[-2].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[0].minor.yy277;} |
3174 | 0 | break; |
3175 | 1 | case 246: /* slimit_opt ::= SLIMIT signed COMMA signed */ |
3176 | 1 | {yymsp[-3].minor.yy190.limit = yymsp[0].minor.yy277; yymsp[-3].minor.yy190.offset = yymsp[-2].minor.yy277;} |
3177 | 1 | break; |
3178 | 373 | case 249: /* expr ::= LP expr RP */ |
3179 | 373 | {yylhsminor.yy194 = yymsp[-1].minor.yy194; yylhsminor.yy194->exprToken.z = yymsp[-2].minor.yy0.z; yylhsminor.yy194->exprToken.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);} |
3180 | 373 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3181 | 373 | break; |
3182 | 2.12M | case 250: /* expr ::= ID */ |
3183 | 2.12M | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_ID);} |
3184 | 2.12M | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3185 | 2.12M | break; |
3186 | 932 | case 251: /* expr ::= ID DOT ID */ |
3187 | 932 | { yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID);} |
3188 | 932 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3189 | 932 | break; |
3190 | 195 | case 252: /* expr ::= ID DOT STAR */ |
3191 | 195 | { yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ALL);} |
3192 | 195 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3193 | 195 | break; |
3194 | 119k | case 253: /* expr ::= INTEGER */ |
3195 | 119k | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_INTEGER);} |
3196 | 119k | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3197 | 119k | break; |
3198 | 1.39k | case 254: /* expr ::= MINUS INTEGER */ |
3199 | 2.48k | case 255: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==255); |
3200 | 2.48k | { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_INTEGER);} |
3201 | 2.48k | yymsp[-1].minor.yy194 = yylhsminor.yy194; |
3202 | 2.48k | break; |
3203 | 6.72k | case 256: /* expr ::= FLOAT */ |
3204 | 6.72k | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_FLOAT);} |
3205 | 6.72k | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3206 | 6.72k | break; |
3207 | 476 | case 257: /* expr ::= MINUS FLOAT */ |
3208 | 681 | case 258: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==258); |
3209 | 681 | { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_FLOAT);} |
3210 | 681 | yymsp[-1].minor.yy194 = yylhsminor.yy194; |
3211 | 681 | break; |
3212 | 2.94k | case 259: /* expr ::= STRING */ |
3213 | 2.94k | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING);} |
3214 | 2.94k | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3215 | 2.94k | break; |
3216 | 295 | case 260: /* expr ::= NOW */ |
3217 | 295 | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NOW); } |
3218 | 295 | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3219 | 295 | break; |
3220 | 198 | case 261: /* expr ::= TODAY */ |
3221 | 198 | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_TODAY); } |
3222 | 198 | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3223 | 198 | break; |
3224 | 6.84k | case 262: /* expr ::= VARIABLE */ |
3225 | 6.84k | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_VARIABLE);} |
3226 | 6.84k | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3227 | 6.84k | break; |
3228 | 261 | case 263: /* expr ::= PLUS VARIABLE */ |
3229 | 1.86k | case 264: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==264); |
3230 | 1.86k | { yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[-1].minor.yy0, TK_VARIABLE);} |
3231 | 1.86k | yymsp[-1].minor.yy194 = yylhsminor.yy194; |
3232 | 1.86k | break; |
3233 | 1.69k | case 265: /* expr ::= BOOL */ |
3234 | 1.69k | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_BOOL);} |
3235 | 1.69k | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3236 | 1.69k | break; |
3237 | 196 | case 266: /* expr ::= NULL */ |
3238 | 196 | { yylhsminor.yy194 = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_NULL);} |
3239 | 196 | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3240 | 196 | break; |
3241 | 4.45k | case 267: /* expr ::= ID LP exprlist RP */ |
3242 | 4.45k | { tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFunction(yymsp[-1].minor.yy333, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } |
3243 | 4.45k | yymsp[-3].minor.yy194 = yylhsminor.yy194; |
3244 | 4.45k | break; |
3245 | 194 | case 268: /* expr ::= ID LP STAR RP */ |
3246 | 194 | { tStrTokenAppend(pInfo->funcs, &yymsp[-3].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); } |
3247 | 194 | yymsp[-3].minor.yy194 = yylhsminor.yy194; |
3248 | 194 | break; |
3249 | 2.30k | case 269: /* expr ::= ID LP expr AS typename RP */ |
3250 | 2.30k | { tStrTokenAppend(pInfo->funcs, &yymsp[-5].minor.yy0); yylhsminor.yy194 = tSqlExprCreateFuncWithParams(pInfo, yymsp[-3].minor.yy194, &yymsp[-1].minor.yy263, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0, yymsp[-5].minor.yy0.type); } |
3251 | 2.30k | yymsp[-5].minor.yy194 = yylhsminor.yy194; |
3252 | 2.30k | break; |
3253 | 0 | case 270: /* expr ::= expr IS NULL */ |
3254 | 0 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, NULL, TK_ISNULL);} |
3255 | 0 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3256 | 0 | break; |
3257 | 0 | case 271: /* expr ::= expr IS NOT NULL */ |
3258 | 0 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-3].minor.yy194, NULL, TK_NOTNULL);} |
3259 | 0 | yymsp[-3].minor.yy194 = yylhsminor.yy194; |
3260 | 0 | break; |
3261 | 3.98k | case 272: /* expr ::= expr LT expr */ |
3262 | 3.98k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LT);} |
3263 | 3.98k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3264 | 3.98k | break; |
3265 | 3.09k | case 273: /* expr ::= expr GT expr */ |
3266 | 3.09k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_GT);} |
3267 | 3.09k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3268 | 3.09k | break; |
3269 | 1.10k | case 274: /* expr ::= expr LE expr */ |
3270 | 1.10k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LE);} |
3271 | 1.10k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3272 | 1.10k | break; |
3273 | 1.08k | case 275: /* expr ::= expr GE expr */ |
3274 | 1.08k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_GE);} |
3275 | 1.08k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3276 | 1.08k | break; |
3277 | 1.24k | case 276: /* expr ::= expr NE expr */ |
3278 | 1.24k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_NE);} |
3279 | 1.24k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3280 | 1.24k | break; |
3281 | 4.48k | case 277: /* expr ::= expr EQ expr */ |
3282 | 4.48k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_EQ);} |
3283 | 4.48k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3284 | 4.48k | break; |
3285 | 0 | case 278: /* expr ::= expr BETWEEN expr AND expr */ |
3286 | 0 | { tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy194); yylhsminor.yy194 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy194, yymsp[-2].minor.yy194, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy194, TK_LE), TK_AND);} |
3287 | 0 | yymsp[-4].minor.yy194 = yylhsminor.yy194; |
3288 | 0 | break; |
3289 | 1.17k | case 279: /* expr ::= expr AND expr */ |
3290 | 1.17k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_AND);} |
3291 | 1.17k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3292 | 1.17k | break; |
3293 | 941 | case 280: /* expr ::= expr OR expr */ |
3294 | 941 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_OR); } |
3295 | 941 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3296 | 941 | break; |
3297 | 3.31k | case 281: /* expr ::= expr PLUS expr */ |
3298 | 3.31k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_PLUS); } |
3299 | 3.31k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3300 | 3.31k | break; |
3301 | 8.80k | case 282: /* expr ::= expr MINUS expr */ |
3302 | 8.80k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_MINUS); } |
3303 | 8.80k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3304 | 8.80k | break; |
3305 | 3.23k | case 283: /* expr ::= expr STAR expr */ |
3306 | 3.23k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_STAR); } |
3307 | 3.23k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3308 | 3.23k | break; |
3309 | 1.30M | case 284: /* expr ::= expr SLASH expr */ |
3310 | 1.30M | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_DIVIDE);} |
3311 | 1.30M | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3312 | 1.30M | break; |
3313 | 2.47k | case 285: /* expr ::= expr REM expr */ |
3314 | 2.47k | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_REM); } |
3315 | 2.47k | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3316 | 2.47k | break; |
3317 | 236 | case 286: /* expr ::= expr BITAND expr */ |
3318 | 236 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_BITAND);} |
3319 | 236 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3320 | 236 | break; |
3321 | 196 | case 287: /* expr ::= expr LIKE expr */ |
3322 | 196 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_LIKE); } |
3323 | 196 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3324 | 196 | break; |
3325 | 196 | case 288: /* expr ::= expr MATCH expr */ |
3326 | 196 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_MATCH); } |
3327 | 196 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3328 | 196 | break; |
3329 | 198 | case 289: /* expr ::= expr NMATCH expr */ |
3330 | 198 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-2].minor.yy194, yymsp[0].minor.yy194, TK_NMATCH); } |
3331 | 198 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3332 | 198 | break; |
3333 | 0 | case 290: /* expr ::= ID CONTAINS STRING */ |
3334 | 0 | { tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_CONTAINS); } |
3335 | 0 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3336 | 0 | break; |
3337 | 0 | case 291: /* expr ::= ID DOT ID CONTAINS STRING */ |
3338 | 0 | { yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_CONTAINS); } |
3339 | 0 | yymsp[-4].minor.yy194 = yylhsminor.yy194; |
3340 | 0 | break; |
3341 | 373 | case 292: /* arrow ::= ID ARROW STRING */ |
3342 | 373 | {tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-2].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_ARROW); } |
3343 | 373 | yymsp[-2].minor.yy194 = yylhsminor.yy194; |
3344 | 373 | break; |
3345 | 194 | case 293: /* arrow ::= ID DOT ID ARROW STRING */ |
3346 | 194 | {yymsp[-4].minor.yy0.n += (1+yymsp[-2].minor.yy0.n); tSqlExpr* S = tSqlExprCreateIdValue(pInfo, &yymsp[-4].minor.yy0, TK_ID); tSqlExpr* M = tSqlExprCreateIdValue(pInfo, &yymsp[0].minor.yy0, TK_STRING); yylhsminor.yy194 = tSqlExprCreate(S, M, TK_ARROW); } |
3347 | 194 | yymsp[-4].minor.yy194 = yylhsminor.yy194; |
3348 | 194 | break; |
3349 | 567 | case 294: /* expr ::= arrow */ |
3350 | 819k | case 298: /* expritem ::= expr */ yytestcase(yyruleno==298); |
3351 | 819k | {yylhsminor.yy194 = yymsp[0].minor.yy194;} |
3352 | 819k | yymsp[0].minor.yy194 = yylhsminor.yy194; |
3353 | 819k | break; |
3354 | 194 | case 295: /* expr ::= expr IN LP exprlist RP */ |
3355 | 194 | {yylhsminor.yy194 = tSqlExprCreate(yymsp[-4].minor.yy194, (tSqlExpr*)yymsp[-1].minor.yy333, TK_IN); } |
3356 | 194 | yymsp[-4].minor.yy194 = yylhsminor.yy194; |
3357 | 194 | break; |
3358 | 821k | case 296: /* exprlist ::= exprlist COMMA expritem */ |
3359 | 821k | {yylhsminor.yy333 = tSqlExprListAppend(yymsp[-2].minor.yy333,yymsp[0].minor.yy194,0, 0);} |
3360 | 821k | yymsp[-2].minor.yy333 = yylhsminor.yy333; |
3361 | 821k | break; |
3362 | 34.8k | case 297: /* exprlist ::= expritem */ |
3363 | 34.8k | {yylhsminor.yy333 = tSqlExprListAppend(0,yymsp[0].minor.yy194,0, 0);} |
3364 | 34.8k | yymsp[0].minor.yy333 = yylhsminor.yy333; |
3365 | 34.8k | break; |
3366 | 0 | case 300: /* cmd ::= RESET QUERY CACHE */ |
3367 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);} |
3368 | 0 | break; |
3369 | 0 | case 301: /* cmd ::= SYNCDB ids REPLICA */ |
3370 | 0 | { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);} |
3371 | 0 | break; |
3372 | 0 | case 302: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */ |
3373 | 0 | { |
3374 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3375 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1); |
3376 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3377 | 0 | } |
3378 | 0 | break; |
3379 | 0 | case 303: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */ |
3380 | 0 | { |
3381 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3382 | |
|
3383 | 0 | toTSDBType(yymsp[0].minor.yy0.type); |
3384 | 0 | SArray* K = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1, false); |
3385 | |
|
3386 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN, -1); |
3387 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3388 | 0 | } |
3389 | 0 | break; |
3390 | 0 | case 304: /* cmd ::= ALTER TABLE ids cpxName MODIFY COLUMN columnlist */ |
3391 | 0 | { |
3392 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3393 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, -1); |
3394 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3395 | 0 | } |
3396 | 0 | break; |
3397 | 0 | case 305: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */ |
3398 | 0 | { |
3399 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3400 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1); |
3401 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3402 | 0 | } |
3403 | 0 | break; |
3404 | 0 | case 306: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */ |
3405 | 0 | { |
3406 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3407 | |
|
3408 | 0 | toTSDBType(yymsp[0].minor.yy0.type); |
3409 | 0 | SArray* A = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1, false); |
3410 | |
|
3411 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, -1); |
3412 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3413 | 0 | } |
3414 | 0 | break; |
3415 | 0 | case 307: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */ |
3416 | 0 | { |
3417 | 0 | yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; |
3418 | |
|
3419 | 0 | toTSDBType(yymsp[-1].minor.yy0.type); |
3420 | 0 | SArray* A = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, false); |
3421 | |
|
3422 | 0 | toTSDBType(yymsp[0].minor.yy0.type); |
3423 | 0 | A = tVariantListAppendToken(A, &yymsp[0].minor.yy0, -1, false); |
3424 | |
|
3425 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-5].minor.yy0, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN, -1); |
3426 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3427 | 0 | } |
3428 | 0 | break; |
3429 | 0 | case 308: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */ |
3430 | 0 | { |
3431 | 0 | yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; |
3432 | |
|
3433 | 0 | toTSDBType(yymsp[-2].minor.yy0.type); |
3434 | 0 | SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false); |
3435 | 0 | A = tVariantListAppend(A, &yymsp[0].minor.yy42, -1); |
3436 | |
|
3437 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1); |
3438 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3439 | 0 | } |
3440 | 0 | break; |
3441 | 0 | case 309: /* cmd ::= ALTER TABLE ids cpxName MODIFY TAG columnlist */ |
3442 | 0 | { |
3443 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3444 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, -1); |
3445 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3446 | 0 | } |
3447 | 0 | break; |
3448 | 0 | case 310: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */ |
3449 | 0 | { |
3450 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3451 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE); |
3452 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3453 | 0 | } |
3454 | 0 | break; |
3455 | 0 | case 311: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */ |
3456 | 0 | { |
3457 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3458 | |
|
3459 | 0 | toTSDBType(yymsp[0].minor.yy0.type); |
3460 | 0 | SArray* K = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1, false); |
3461 | |
|
3462 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, K, TSDB_ALTER_TABLE_DROP_COLUMN, TSDB_SUPER_TABLE); |
3463 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3464 | 0 | } |
3465 | 0 | break; |
3466 | 0 | case 312: /* cmd ::= ALTER STABLE ids cpxName MODIFY COLUMN columnlist */ |
3467 | 0 | { |
3468 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3469 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_CHANGE_COLUMN, TSDB_SUPER_TABLE); |
3470 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3471 | 0 | } |
3472 | 0 | break; |
3473 | 0 | case 313: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */ |
3474 | 0 | { |
3475 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3476 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE); |
3477 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3478 | 0 | } |
3479 | 0 | break; |
3480 | 0 | case 314: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */ |
3481 | 0 | { |
3482 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3483 | |
|
3484 | 0 | toTSDBType(yymsp[0].minor.yy0.type); |
3485 | 0 | SArray* A = tVariantListAppendToken(NULL, &yymsp[0].minor.yy0, -1, false); |
3486 | |
|
3487 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, NULL, A, TSDB_ALTER_TABLE_DROP_TAG_COLUMN, TSDB_SUPER_TABLE); |
3488 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3489 | 0 | } |
3490 | 0 | break; |
3491 | 0 | case 315: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */ |
3492 | 0 | { |
3493 | 0 | yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n; |
3494 | |
|
3495 | 0 | toTSDBType(yymsp[-1].minor.yy0.type); |
3496 | 0 | SArray* A = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1, false); |
3497 | |
|
3498 | 0 | toTSDBType(yymsp[0].minor.yy0.type); |
3499 | 0 | A = tVariantListAppendToken(A, &yymsp[0].minor.yy0, -1, false); |
3500 | |
|
3501 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-5].minor.yy0, NULL, A, TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN, TSDB_SUPER_TABLE); |
3502 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3503 | 0 | } |
3504 | 0 | break; |
3505 | 0 | case 316: /* cmd ::= ALTER STABLE ids cpxName SET TAG ids EQ tagitem */ |
3506 | 0 | { |
3507 | 0 | yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n; |
3508 | |
|
3509 | 0 | toTSDBType(yymsp[-2].minor.yy0.type); |
3510 | 0 | SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1, false); |
3511 | 0 | A = tVariantListAppend(A, &yymsp[0].minor.yy42, -1); |
3512 | |
|
3513 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, TSDB_SUPER_TABLE); |
3514 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3515 | 0 | } |
3516 | 0 | break; |
3517 | 0 | case 317: /* cmd ::= ALTER STABLE ids cpxName MODIFY TAG columnlist */ |
3518 | 0 | { |
3519 | 0 | yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n; |
3520 | 0 | SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy333, NULL, TSDB_ALTER_TABLE_MODIFY_TAG_COLUMN, TSDB_SUPER_TABLE); |
3521 | 0 | setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE); |
3522 | 0 | } |
3523 | 0 | break; |
3524 | 0 | case 318: /* cmd ::= KILL CONNECTION INTEGER */ |
3525 | 0 | {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);} |
3526 | 0 | break; |
3527 | 0 | case 319: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */ |
3528 | 0 | {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);} |
3529 | 0 | break; |
3530 | 0 | case 320: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */ |
3531 | 0 | {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);} |
3532 | 0 | break; |
3533 | 0 | case 321: /* cmd ::= DELETE FROM ifexists ids cpxName where_opt */ |
3534 | 0 | { |
3535 | 0 | yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n; |
3536 | 0 | SDelData * pDelData = tGetDelData(&yymsp[-2].minor.yy0, &yymsp[-3].minor.yy0, yymsp[0].minor.yy194); |
3537 | 0 | setSqlInfo(pInfo, pDelData, NULL, TSDB_SQL_DELETE_DATA); |
3538 | 0 | } |
3539 | 0 | break; |
3540 | 0 | default: |
3541 | 0 | break; |
3542 | | /********** End reduce actions ************************************************/ |
3543 | 6.08M | }; |
3544 | 6.08M | assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) ); |
3545 | 6.08M | yygoto = yyRuleInfo[yyruleno].lhs; |
3546 | 6.08M | yysize = yyRuleInfo[yyruleno].nrhs; |
3547 | 6.08M | yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto); |
3548 | | |
3549 | | /* There are no SHIFTREDUCE actions on nonterminals because the table |
3550 | | ** generator has simplified them to pure REDUCE actions. */ |
3551 | 6.08M | assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) ); |
3552 | | |
3553 | | /* It is not possible for a REDUCE to be followed by an error */ |
3554 | 6.08M | assert( yyact!=YY_ERROR_ACTION ); |
3555 | | |
3556 | 6.08M | yymsp += yysize+1; |
3557 | 6.08M | yypParser->yytos = yymsp; |
3558 | 6.08M | yymsp->stateno = (YYACTIONTYPE)yyact; |
3559 | 6.08M | yymsp->major = (YYCODETYPE)yygoto; |
3560 | 6.08M | yyTraceShift(yypParser, yyact, "... then shift"); |
3561 | 6.08M | } |
3562 | | |
3563 | | /* |
3564 | | ** The following code executes when the parse fails |
3565 | | */ |
3566 | | #ifndef YYNOERRORRECOVERY |
3567 | | static void yy_parse_failed( |
3568 | | yyParser *yypParser /* The parser */ |
3569 | 1.66k | ){ |
3570 | 1.66k | ParseARG_FETCH; |
3571 | 1.66k | #ifndef NDEBUG |
3572 | 1.66k | if( yyTraceFILE ){ |
3573 | 0 | fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); |
3574 | 0 | } |
3575 | 1.66k | #endif |
3576 | 14.7k | while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser); |
3577 | | /* Here code is inserted which will be executed whenever the |
3578 | | ** parser fails */ |
3579 | | /************ Begin %parse_failure code ***************************************/ |
3580 | | /************ End %parse_failure code *****************************************/ |
3581 | 1.66k | ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ |
3582 | 1.66k | } |
3583 | | #endif /* YYNOERRORRECOVERY */ |
3584 | | |
3585 | | /* |
3586 | | ** The following code executes when a syntax error first occurs. |
3587 | | */ |
3588 | | static void yy_syntax_error( |
3589 | | yyParser *yypParser, /* The parser */ |
3590 | | int yymajor, /* The major type of the error token */ |
3591 | | ParseTOKENTYPE yyminor /* The minor type of the error token */ |
3592 | 2.82k | ){ |
3593 | 2.82k | ParseARG_FETCH; |
3594 | 5.13k | #define TOKEN yyminor |
3595 | | /************ Begin %syntax_error code ****************************************/ |
3596 | | |
3597 | 2.82k | pInfo->valid = false; |
3598 | 2.82k | int32_t outputBufLen = tListLen(pInfo->msg); |
3599 | 2.82k | int32_t len = 0; |
3600 | | |
3601 | 2.82k | if(TOKEN.z) { |
3602 | 1.15k | char msg[] = "syntax error near \"%s\""; |
3603 | 1.15k | int32_t sqlLen = strlen(&TOKEN.z[0]); |
3604 | | |
3605 | 1.15k | if (sqlLen + sizeof(msg)/sizeof(msg[0]) + 1 > outputBufLen) { |
3606 | 76 | char tmpstr[128] = {0}; |
3607 | 76 | memcpy(tmpstr, &TOKEN.z[0], sizeof(tmpstr)/sizeof(tmpstr[0]) - 1); |
3608 | 76 | len = sprintf(pInfo->msg, msg, tmpstr); |
3609 | 1.08k | } else { |
3610 | 1.08k | len = sprintf(pInfo->msg, msg, &TOKEN.z[0]); |
3611 | 1.08k | } |
3612 | | |
3613 | 1.66k | } else { |
3614 | 1.66k | len = sprintf(pInfo->msg, "Incomplete SQL statement"); |
3615 | 1.66k | } |
3616 | | |
3617 | 2.82k | assert(len <= outputBufLen); |
3618 | | /************ End %syntax_error code ******************************************/ |
3619 | 2.82k | ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ |
3620 | 2.82k | } |
3621 | | |
3622 | | /* |
3623 | | ** The following is executed when the parser accepts |
3624 | | */ |
3625 | | static void yy_accept( |
3626 | | yyParser *yypParser /* The parser */ |
3627 | 2.37k | ){ |
3628 | 2.37k | ParseARG_FETCH; |
3629 | 2.37k | #ifndef NDEBUG |
3630 | 2.37k | if( yyTraceFILE ){ |
3631 | 0 | fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); |
3632 | 0 | } |
3633 | 2.37k | #endif |
3634 | 2.37k | #ifndef YYNOERRORRECOVERY |
3635 | 2.37k | yypParser->yyerrcnt = -1; |
3636 | 2.37k | #endif |
3637 | 2.37k | assert( yypParser->yytos==yypParser->yystack ); |
3638 | | /* Here code is inserted which will be executed whenever the |
3639 | | ** parser accepts */ |
3640 | | /*********** Begin %parse_accept code *****************************************/ |
3641 | | |
3642 | | /*********** End %parse_accept code *******************************************/ |
3643 | 2.37k | ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ |
3644 | 2.37k | } |
3645 | | |
3646 | | /* The main parser program. |
3647 | | ** The first argument is a pointer to a structure obtained from |
3648 | | ** "ParseAlloc" which describes the current state of the parser. |
3649 | | ** The second argument is the major token number. The third is |
3650 | | ** the minor token. The fourth optional argument is whatever the |
3651 | | ** user wants (and specified in the grammar) and is available for |
3652 | | ** use by the action routines. |
3653 | | ** |
3654 | | ** Inputs: |
3655 | | ** <ul> |
3656 | | ** <li> A pointer to the parser (an opaque structure.) |
3657 | | ** <li> The major token number. |
3658 | | ** <li> The minor token number. |
3659 | | ** <li> An option argument of a grammar-specified type. |
3660 | | ** </ul> |
3661 | | ** |
3662 | | ** Outputs: |
3663 | | ** None. |
3664 | | */ |
3665 | | void Parse( |
3666 | | void *yyp, /* The parser */ |
3667 | | int yymajor, /* The major token code number */ |
3668 | | ParseTOKENTYPE yyminor /* The value for the token */ |
3669 | | ParseARG_PDECL /* Optional %extra_argument parameter */ |
3670 | 6.14M | ){ |
3671 | 6.14M | YYMINORTYPE yyminorunion; |
3672 | 6.14M | unsigned int yyact; /* The parser action. */ |
3673 | 6.14M | #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) |
3674 | 6.14M | int yyendofinput; /* True if we are at the end of input */ |
3675 | 6.14M | #endif |
3676 | | #ifdef YYERRORSYMBOL |
3677 | | int yyerrorhit = 0; /* True if yymajor has invoked an error */ |
3678 | | #endif |
3679 | 6.14M | yyParser *yypParser; /* The parser */ |
3680 | | |
3681 | 6.14M | yypParser = (yyParser*)yyp; |
3682 | 6.14M | assert( yypParser->yytos!=0 ); |
3683 | 6.14M | #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY) |
3684 | 6.14M | yyendofinput = (yymajor==0); |
3685 | 6.14M | #endif |
3686 | 6.14M | ParseARG_STORE; |
3687 | | |
3688 | 6.14M | #ifndef NDEBUG |
3689 | 6.14M | if( yyTraceFILE ){ |
3690 | 0 | int stateno = yypParser->yytos->stateno; |
3691 | 0 | if( stateno < YY_MIN_REDUCE ){ |
3692 | 0 | fprintf(yyTraceFILE,"%sInput '%s' in state %d\n", |
3693 | 0 | yyTracePrompt,yyTokenName[yymajor],stateno); |
3694 | 0 | }else{ |
3695 | 0 | fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n", |
3696 | 0 | yyTracePrompt,yyTokenName[yymajor],stateno-YY_MIN_REDUCE); |
3697 | 0 | } |
3698 | 0 | } |
3699 | 6.14M | #endif |
3700 | | |
3701 | 12.2M | do{ |
3702 | 12.2M | yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); |
3703 | 12.2M | if( yyact >= YY_MIN_REDUCE ){ |
3704 | 6.09M | yy_reduce(yypParser,yyact-YY_MIN_REDUCE,yymajor,yyminor); |
3705 | 6.14M | }else if( yyact <= YY_MAX_SHIFTREDUCE ){ |
3706 | 6.13M | yy_shift(yypParser,yyact,yymajor,yyminor); |
3707 | 6.13M | #ifndef YYNOERRORRECOVERY |
3708 | 6.13M | yypParser->yyerrcnt--; |
3709 | 6.13M | #endif |
3710 | 6.13M | yymajor = YYNOCODE; |
3711 | 6.13M | }else if( yyact==YY_ACCEPT_ACTION ){ |
3712 | 2.37k | yypParser->yytos--; |
3713 | 2.37k | yy_accept(yypParser); |
3714 | 2.37k | return; |
3715 | 2.82k | }else{ |
3716 | 2.82k | assert( yyact == YY_ERROR_ACTION ); |
3717 | 2.82k | yyminorunion.yy0 = yyminor; |
3718 | | #ifdef YYERRORSYMBOL |
3719 | | int yymx; |
3720 | | #endif |
3721 | 2.82k | #ifndef NDEBUG |
3722 | 2.82k | if( yyTraceFILE ){ |
3723 | 0 | fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); |
3724 | 0 | } |
3725 | 2.82k | #endif |
3726 | | #ifdef YYERRORSYMBOL |
3727 | | /* A syntax error has occurred. |
3728 | | ** The response to an error depends upon whether or not the |
3729 | | ** grammar defines an error token "ERROR". |
3730 | | ** |
3731 | | ** This is what we do if the grammar does define ERROR: |
3732 | | ** |
3733 | | ** * Call the %syntax_error function. |
3734 | | ** |
3735 | | ** * Begin popping the stack until we enter a state where |
3736 | | ** it is legal to shift the error symbol, then shift |
3737 | | ** the error symbol. |
3738 | | ** |
3739 | | ** * Set the error count to three. |
3740 | | ** |
3741 | | ** * Begin accepting and shifting new tokens. No new error |
3742 | | ** processing will occur until three tokens have been |
3743 | | ** shifted successfully. |
3744 | | ** |
3745 | | */ |
3746 | | if( yypParser->yyerrcnt<0 ){ |
3747 | | yy_syntax_error(yypParser,yymajor,yyminor); |
3748 | | } |
3749 | | yymx = yypParser->yytos->major; |
3750 | | if( yymx==YYERRORSYMBOL || yyerrorhit ){ |
3751 | | #ifndef NDEBUG |
3752 | | if( yyTraceFILE ){ |
3753 | | fprintf(yyTraceFILE,"%sDiscard input token %s\n", |
3754 | | yyTracePrompt,yyTokenName[yymajor]); |
3755 | | } |
3756 | | #endif |
3757 | | yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion); |
3758 | | yymajor = YYNOCODE; |
3759 | | }else{ |
3760 | | while( yypParser->yytos >= yypParser->yystack |
3761 | | && yymx != YYERRORSYMBOL |
3762 | | && (yyact = yy_find_reduce_action( |
3763 | | yypParser->yytos->stateno, |
3764 | | YYERRORSYMBOL)) >= YY_MIN_REDUCE |
3765 | | ){ |
3766 | | yy_pop_parser_stack(yypParser); |
3767 | | } |
3768 | | if( yypParser->yytos < yypParser->yystack || yymajor==0 ){ |
3769 | | yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); |
3770 | | yy_parse_failed(yypParser); |
3771 | | #ifndef YYNOERRORRECOVERY |
3772 | | yypParser->yyerrcnt = -1; |
3773 | | #endif |
3774 | | yymajor = YYNOCODE; |
3775 | | }else if( yymx!=YYERRORSYMBOL ){ |
3776 | | yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor); |
3777 | | } |
3778 | | } |
3779 | | yypParser->yyerrcnt = 3; |
3780 | | yyerrorhit = 1; |
3781 | | #elif defined(YYNOERRORRECOVERY) |
3782 | | /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to |
3783 | | ** do any kind of error recovery. Instead, simply invoke the syntax |
3784 | | ** error routine and continue going as if nothing had happened. |
3785 | | ** |
3786 | | ** Applications can set this macro (for example inside %include) if |
3787 | | ** they intend to abandon the parse upon the first syntax error seen. |
3788 | | */ |
3789 | | yy_syntax_error(yypParser,yymajor, yyminor); |
3790 | | yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); |
3791 | | yymajor = YYNOCODE; |
3792 | | |
3793 | | #else /* YYERRORSYMBOL is not defined */ |
3794 | | /* This is what we do if the grammar does not define ERROR: |
3795 | | ** |
3796 | | ** * Report an error message, and throw away the input token. |
3797 | | ** |
3798 | | ** * If the input token is $, then fail the parse. |
3799 | | ** |
3800 | | ** As before, subsequent error messages are suppressed until |
3801 | | ** three input tokens have been successfully shifted. |
3802 | | */ |
3803 | 2.82k | if( yypParser->yyerrcnt<=0 ){ |
3804 | 2.82k | yy_syntax_error(yypParser,yymajor, yyminor); |
3805 | 2.82k | } |
3806 | 2.82k | yypParser->yyerrcnt = 3; |
3807 | 2.82k | yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); |
3808 | 2.82k | if( yyendofinput ){ |
3809 | 1.66k | yy_parse_failed(yypParser); |
3810 | 1.66k | #ifndef YYNOERRORRECOVERY |
3811 | 1.66k | yypParser->yyerrcnt = -1; |
3812 | 1.66k | #endif |
3813 | 1.66k | } |
3814 | 2.82k | yymajor = YYNOCODE; |
3815 | 2.82k | #endif |
3816 | 2.82k | } |
3817 | 12.2M | }while( yymajor!=YYNOCODE && yypParser->yytos>yypParser->yystack ); |
3818 | 6.14M | #ifndef NDEBUG |
3819 | 6.14M | if( yyTraceFILE ){ |
3820 | 0 | yyStackEntry *i; |
3821 | 0 | char cDiv = '['; |
3822 | 0 | fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt); |
3823 | 0 | for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){ |
3824 | 0 | fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]); |
3825 | 0 | cDiv = ' '; |
3826 | 0 | } |
3827 | 0 | fprintf(yyTraceFILE,"]\n"); |
3828 | 0 | } |
3829 | 6.14M | #endif |
3830 | 6.14M | return; |
3831 | 6.14M | } |