forked from StarRocks/starrocks
-
Notifications
You must be signed in to change notification settings - Fork 0
/
sql_parser.cup
5209 lines (4865 loc) · 137 KB
/
sql_parser.cup
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package com.starrocks.analysis;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.starrocks.analysis.AlterDatabaseQuotaStmt.QuotaType;
import com.starrocks.analysis.SetOperationStmt.Qualifier;
import com.starrocks.analysis.SetOperationStmt.Operation;
import com.starrocks.analysis.SetOperationStmt.SetOperand;
import com.starrocks.sql.ast.CreateResourceGroupStmt;
import com.starrocks.sql.ast.AlterResourceGroupStmt;
import com.starrocks.sql.ast.DropResourceGroupStmt;
import com.starrocks.sql.ast.ShowResourceGroupStmt;
import com.starrocks.catalog.AccessPrivilege;
import com.starrocks.catalog.AggregateType;
import com.starrocks.catalog.ArrayType;
import com.starrocks.catalog.KeysType;
import com.starrocks.catalog.PrimitiveType;
import com.starrocks.catalog.ScalarType;
import com.starrocks.catalog.Type;
import com.starrocks.catalog.View;
import com.starrocks.common.AnalysisException;
import com.starrocks.common.Version;
import com.starrocks.mysql.MysqlPassword;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import java_cup.runtime.Symbol;
// Commented by Zhao Chun
// Now we have 2 shift/reduce conflict
// between TIMESTAMP "20100101" and TIMESTAMP "alias"
// between DATE "20100101" and DATE "alias"
parser code {:
private Symbol errorToken;
public boolean isVerbose = false;
public String wild;
public Expr where;
// List of expected tokens ids from current parsing state for generating syntax error message
private final List<Integer> expectedTokenIds = Lists.newArrayList();
// To avoid reporting trivial tokens as expected tokens in error messages
private boolean reportExpectedToken(Integer tokenId) {
if (SqlScanner.isKeyword(tokenId) ||
tokenId.intValue() == SqlParserSymbols.COMMA ||
tokenId.intValue() == SqlParserSymbols.IDENT) {
return true;
} else {
return false;
}
}
private String getErrorTypeMessage(int lastTokenId) {
String msg = null;
switch(lastTokenId) {
case SqlParserSymbols.UNMATCHED_STRING_LITERAL:
msg = "Unmatched string literal";
break;
case SqlParserSymbols.NUMERIC_OVERFLOW:
msg = "Numeric overflow";
break;
default:
msg = "Syntax error";
break;
}
return msg;
}
// Override to save error token, just update error information.
@Override
public void syntax_error(Symbol token) {
errorToken = token;
// derive expected tokens from current parsing state
expectedTokenIds.clear();
int state = ((Symbol)stack.peek()).parse_state;
// get row of actions table corresponding to current parsing state
// the row consists of pairs of <tokenId, actionId>
// a pair is stored as row[i] (tokenId) and row[i+1] (actionId)
// the last pair is a special error action
short[] row = action_tab[state];
short tokenId;
// the expected tokens are all the symbols with a
// corresponding action from the current parsing state
for (int i = 0; i < row.length-2; ++i) {
// Get tokenId and skip actionId
tokenId = row[i++];
expectedTokenIds.add(Integer.valueOf(tokenId));
}
}
// Override to keep it from calling report_fatal_error()
// This exception is not AnalysisException because we don't want this report to client.
@Override
public void unrecovered_syntax_error(Symbol cur_token) throws AnalysisException {
throw new AnalysisException(getErrorTypeMessage(cur_token.sym));
}
// Manually throw a parse error on a given symbol for special circumstances.
public void parseError(String symbolName, int symbolId) throws AnalysisException {
Symbol errorToken = getSymbolFactory().newSymbol(symbolName, symbolId,
((Symbol) stack.peek()), ((Symbol) stack.peek()), null);
// Call syntax error to gather information about expected tokens, etc.
// syntax_error does not throw an exception
syntax_error(errorToken);
unrecovered_syntax_error(errorToken);
}
// Returns error string, consisting of the original
// stmt with a '^' under the offending token. Assumes
// that parse() has been called and threw an exception
public String getErrorMsg(String stmt) {
if (errorToken == null || stmt == null) {
return null;
}
String[] lines = stmt.split("\n", -1);
StringBuffer result = new StringBuffer();
result.append(getErrorTypeMessage(errorToken.sym) + " in line ");
result.append(errorToken.left);
result.append(":\n");
// errorToken_.left is the line number of error.
// errorToken_.right is the column number of the error.
// index is start from 0, so "minus 1" is the real error line idx
String errorLine = lines[errorToken.left - 1];
// If the error is that additional tokens are expected past the end,
// errorToken_.right will be past the end of the string.
int lastCharIndex = Math.min(errorLine.length(), errorToken.right);
int maxPrintLength = 60;
int errorLoc = 0;
if (errorLine.length() <= maxPrintLength) {
// The line is short. Print the entire line.
result.append(errorLine);
result.append('\n');
errorLoc = errorToken.right;
} else {
// The line is too long. Print maxPrintLength/2 characters before the error and
// after the error.
int contextLength = maxPrintLength / 2 - 3;
String leftSubStr;
if (errorToken.right > maxPrintLength / 2) {
leftSubStr = "..." + errorLine.substring(errorToken.right - contextLength,
lastCharIndex);
} else {
leftSubStr = errorLine.substring(0, errorToken.right);
}
errorLoc = leftSubStr.length();
result.append(leftSubStr);
if (errorLine.length() - errorToken.right > maxPrintLength / 2) {
result.append(errorLine.substring(errorToken.right,
errorToken.right + contextLength) + "...");
} else {
result.append(errorLine.substring(lastCharIndex));
}
result.append("\n");
}
// print error indicator
for (int i = 0; i < errorLoc - 1; ++i) {
result.append(' ');
}
result.append("^\n");
// only report encountered and expected tokens for syntax errors
if (errorToken.sym == SqlParserSymbols.UNMATCHED_STRING_LITERAL ||
errorToken.sym == SqlParserSymbols.NUMERIC_OVERFLOW) {
return result.toString();
}
// append last encountered token
result.append("Encountered: ");
String lastToken = SqlScanner.tokenIdMap.get(Integer.valueOf(errorToken.sym));
if (lastToken != null) {
result.append(lastToken);
} else if (SqlScanner.isKeyword((String) errorToken.value)) {
result.append("A reserved word cannot be used as an identifier: ").append((String) errorToken.value);
} else {
result.append("Unknown last token with id: " + errorToken.sym);
}
// Append expected tokens
result.append('\n');
result.append("Expected: ");
String expectedToken = null;
Integer tokenId = null;
for (int i = 0; i < expectedTokenIds.size(); ++i) {
tokenId = expectedTokenIds.get(i);
// keywords hints
if (SqlScanner.isKeyword(lastToken) && tokenId.intValue() == SqlParserSymbols.IDENT) {
result.append(String.format("%s is keyword, maybe `%s`", lastToken, lastToken) + ", ");
continue;
}
if (reportExpectedToken(tokenId)) {
expectedToken = SqlScanner.tokenIdMap.get(tokenId);
result.append(expectedToken + ", ");
}
}
// remove trailing ", "
result.delete(result.length() - 2, result.length());
result.append('\n');
return result.toString();
}
:};
// Total keywords of starrocks
terminal String KW_ADD, KW_ADMIN, KW_AFTER, KW_AGGREGATE, KW_ALL, KW_ALTER, KW_AND, KW_ANTI, KW_ARRAY, KW_AS, KW_ASC, KW_AUTHORS,
KW_BACKEND, KW_BACKUP, KW_BETWEEN, KW_BEGIN, KW_BIGINT, KW_BITMAP, KW_BITMAP_UNION, KW_BOOLEAN, KW_BROKER, KW_BACKENDS, KW_BY, KW_BUILTIN,
KW_CANCEL, KW_CASE, KW_CAST, KW_CHAIN, KW_CHAR, KW_CHARSET, KW_CHECK, KW_CLUSTER, KW_CLUSTERS,
KW_COLLATE, KW_COLLATION, KW_COLUMN, KW_COLUMNS, KW_COMMENT, KW_COMMIT, KW_COMMITTED,
KW_CONFIG, KW_CONNECTION, KW_CONNECTION_ID, KW_CONSISTENT, KW_COSTS, KW_COUNT, KW_CREATE, KW_CROSS, KW_CUBE, KW_CURRENT, KW_CURRENT_TIMESTAMP, KW_CURRENT_USER,
KW_DATA, KW_DATABASE, KW_DATABASES, KW_DATE, KW_DATETIME, KW_DAY, KW_DECIMAL, KW_DECIMALV2, KW_DECIMAL32, KW_DECIMAL64, KW_DECIMAL128, KW_DECOMMISSION, KW_DEFAULT, KW_DESC, KW_DESCRIBE,
KW_DELETE, KW_DISTINCT, KW_DISTINCTPC, KW_DISTINCTPCSA, KW_DISTRIBUTED, KW_DISTRIBUTION, KW_DYNAMIC, KW_BUCKETS, KW_DIV, KW_DOUBLE, KW_DROP, KW_DROPP, KW_DUAL, KW_DUPLICATE,
KW_ELSE, KW_END, KW_ENGINE, KW_ENGINES, KW_ERRORS, KW_EVENTS, KW_EXCEPT, KW_EXISTS, KW_EXPORT,
KW_EXTERNAL, KW_EXTRACT,
KW_FALSE, KW_FOLLOWER, KW_FOLLOWING, KW_FREE, KW_FROM, KW_FILE, KW_FIRST, KW_FLOAT, KW_FOR, KW_FORCE, KW_FORMAT, KW_FRONTEND, KW_FRONTENDS, KW_FULL, KW_FN, KW_FUNCTION, KW_FUNCTIONS,
KW_GLOBAL, KW_GRANT, KW_GRANTS, KW_GROUP, KW_GROUPS, KW_GROUPING,
KW_HASH, KW_HAVING, KW_HELP,KW_HLL, KW_HLL_UNION, KW_HOUR, KW_HUB,
KW_IDENTIFIED, KW_IF, KW_IN, KW_INDEX, KW_INDEXES, KW_INFILE, KW_INSTALL,
KW_INNER, KW_INSERT, KW_INT, KW_SIGNED, KW_INTERMEDIATE, KW_INTERSECT, KW_INTERVAL, KW_INTO, KW_IGNORE, KW_IS, KW_ISNULL, KW_ISOLATION,
KW_JOIN, KW_JSON,
KW_KEY, KW_KEYS, KW_KILL,
KW_LABEL, KW_LARGEINT, KW_LAST, KW_LEFT, KW_LESS, KW_LEVEL, KW_LIKE, KW_LIMIT, KW_LINK, KW_LIST, KW_LOAD,
KW_LOCAL, KW_LOCATION, KW_LATERAL, KW_LOGICAL,
KW_MATERIALIZED, KW_MAX, KW_MAX_VALUE, KW_MERGE, KW_MIN, KW_MINUTE, KW_MINUS, KW_MODIFY, KW_MONTH,
KW_NAME, KW_NAMES, KW_NEGATIVE, KW_NO, KW_NOT, KW_NULL, KW_NULLS,
KW_OBSERVER, KW_OFFSET, KW_ON, KW_ONLY, KW_OPEN, KW_OR, KW_ORDER, KW_OUTER, KW_OUTFILE, KW_OVER,
KW_PARTITION, KW_PARTITIONS, KW_PASSWORD, KW_PATH, KW_PAUSE, KW_PIPE, KW_PRECEDING,
KW_PLUGIN, KW_PLUGINS,
KW_PRIMARY,
KW_PROC, KW_PROCEDURE, KW_PROCESSLIST, KW_PROPERTIES, KW_PROPERTY, KW_PERCENTILE, KW_PERCENTILE_UNION,
KW_QUERY, KW_QUOTA,
KW_RANDOM, KW_RANGE, KW_READ, KW_RECOVER, KW_REGEXP, KW_RELEASE, KW_RENAME,
KW_REPAIR, KW_REPEATABLE, KW_REPOSITORY, KW_REPOSITORIES, KW_REPLACE, KW_REPLACE_IF_NOT_NULL, KW_REPLICA, KW_RESOURCE, KW_RESOURCES, KW_RESTORE, KW_RETURNS, KW_RESUME, KW_REVOKE,
KW_RIGHT, KW_ROLE, KW_ROLES, KW_ROLLBACK, KW_ROLLUP, KW_ROUTINE, KW_ROW, KW_ROWS,
KW_SCHEMA, KW_SCHEMAS, KW_SECOND, KW_SELECT, KW_SEMI, KW_SERIALIZABLE, KW_SESSION, KW_SET, KW_SETS, KW_SET_VAR, KW_SHOW,
KW_SMALLINT, KW_SNAPSHOT, KW_SONAME, KW_SPLIT, KW_START, KW_STATUS, KW_STOP, KW_STORAGE, KW_STRING,
KW_SUM, KW_SUPERUSER, KW_SYNC, KW_SYSTEM, KW_SWAP,
KW_TABLE, KW_TABLES, KW_TABLET, KW_TASK, KW_TEMPORARY, KW_TERMINATED, KW_THAN, KW_TIME, KW_THEN, KW_TIMESTAMP, KW_TINYINT,
KW_TO, KW_TRANSACTION, KW_TRIGGERS, KW_TRIM, KW_TRUE, KW_TRUNCATE, KW_TYPE, KW_TYPES,
KW_UNCOMMITTED, KW_UNBOUNDED, KW_UNION, KW_UNIQUE, KW_UNSIGNED, KW_USE, KW_USER, KW_USING, KW_UNINSTALL,
KW_VALUE, KW_VALUES, KW_VARCHAR, KW_VARIABLES, KW_VERBOSE, KW_VIEW,
KW_WARNINGS, KW_WEEK, KW_WHEN, KW_SQLBLACKLIST, KW_WHITELIST, KW_WHERE, KW_WITH, KW_WORK, KW_WRITE,
KW_YEAR, KW_EVERY;
terminal COMMA, DOT, DOTDOTDOT, AT, STAR, LPAREN, RPAREN, COLON, SEMICOLON, LBRACE, RBRACE, LBRACKET, RBRACKET, DIVIDE, MOD, ADD, SUBTRACT;
terminal BITAND, BITOR, BITXOR, BITNOT;
terminal EQUAL, NOT, LESSTHAN, GREATERTHAN, SET_VAR;
terminal COMMENTED_PLAN_HINT_START, COMMENTED_PLAN_HINT_END;
terminal ARROW;
terminal String IDENT;
terminal String NUMERIC_OVERFLOW;
terminal Long INTEGER_LITERAL;
terminal String LARGE_INTEGER_LITERAL;
terminal Double FLOATINGPOINT_LITERAL;
terminal BigDecimal DECIMAL_LITERAL;
terminal String STRING_LITERAL;
terminal String UNMATCHED_STRING_LITERAL;
terminal String COMMENTED_PLAN_HINTS;
// Statement that the result of this parser.
nonterminal List<StatementBase> stmts;
nonterminal StatementBase stmt, show_stmt, show_param, help_stmt, load_stmt,
create_routine_load_stmt, pause_routine_load_stmt, resume_routine_load_stmt, stop_routine_load_stmt,
show_routine_load_stmt, show_routine_load_task_stmt,
describe_stmt, alter_stmt,
kill_stmt, drop_stmt, recover_stmt, grant_stmt, revoke_stmt, create_stmt, set_stmt, sync_stmt, cancel_stmt, cancel_param, delete_stmt,
unsupported_stmt, export_stmt, admin_stmt, truncate_stmt,
import_columns_stmt, import_where_stmt, install_plugin_stmt, uninstall_plugin_stmt, analyze_stmt, create_analyze_stmt,
alter_resource_group_stmt;
nonterminal ImportColumnDesc import_column_desc;
nonterminal List<ImportColumnDesc> import_column_descs;
// unsupported statement
nonterminal opt_with_consistent_snapshot, opt_work, opt_chain, opt_release;
// Single select statement.
nonterminal SelectStmt select_stmt;
nonterminal ValueList value_clause;
// No return.
nonterminal opt_full, opt_inner, opt_outer, from_or_in, keys_or_index, opt_storage, opt_wild_where,
charset, equal, transaction_characteristics, isolation_level,
transaction_access_mode, isolation_types, insert_ignore;
// String
nonterminal String user, opt_user, opt_charset_name, opt_character_name, opt_equal_or_not;
nonterminal UserIdentity user_identity;
nonterminal String quantity;
// Description of user
nonterminal UserDesc grant_user;
// Select or set operation(union/intersect/except) statement.
nonterminal QueryStmt query_stmt;
// Single select_stmt or parenthesized query_stmt.
nonterminal QueryStmt set_operand;
// List of select or set operation(union/intersect/except) blocks connected by set operators or a single select block.
nonterminal List<SetOperand> set_operand_list;
// List of select blocks connected by set operators, with order by or limit.
nonterminal QueryStmt set_operation_with_order_by_or_limit;
nonterminal InsertStmt insert_stmt;
nonterminal InsertTarget insert_target;
nonterminal InsertSource insert_source;
nonterminal BackupStmt backup_stmt;
nonterminal RestoreStmt restore_stmt;
nonterminal SelectList select_clause, select_list, select_sublist;
nonterminal SelectListItem select_list_item, star_expr;
nonterminal Expr expr, non_pred_expr, arithmetic_expr, timestamp_arithmetic_expr, expr_or_default;
nonterminal Expr array_expr, array_subscript, array_slice;
nonterminal Expr set_expr_or_default;
nonterminal Expr arrow_expr;
nonterminal ArrayList<Expr> expr_list, values, row_value, opt_values;
nonterminal ArrayList<Expr> func_arg_list;
nonterminal ArrayList<Expr> expr_pipe_list;
nonterminal String select_alias, opt_table_alias;
nonterminal ArrayList<String> ident_list;
nonterminal PartitionNames opt_partition_names, partition_names;
nonterminal ArrayList<Long> opt_tablet_list, tablet_list;
nonterminal TableName table_name, opt_table_name;
nonterminal FunctionName function_name;
nonterminal Expr where_clause;
nonterminal Predicate predicate, between_predicate, comparison_predicate,
compound_predicate, in_predicate, like_predicate, exists_predicate;
nonterminal List<List<Predicate>> classifier_list;
nonterminal List<Predicate> classifier, predicate_list;
nonterminal ArrayList<Expr> opt_partition_by_clause;
nonterminal Expr having_clause;
nonterminal ArrayList<OrderByElement> order_by_elements, order_by_clause;
nonterminal OrderByElement order_by_element;
nonterminal Boolean opt_order_param;
nonterminal Boolean opt_nulls_order_param;
nonterminal LimitElement limit_clause;
nonterminal TypeDef type_def, opt_intermediate_type;
nonterminal List<TypeDef> type_def_list;
nonterminal FunctionArgsDef func_args_def;
nonterminal Type type, array_def;
nonterminal Expr cast_expr, case_else_clause, analytic_expr;
nonterminal LiteralExpr literal;
nonterminal CaseExpr case_expr;
nonterminal ArrayList<CaseWhenClause> case_when_clause_list;
nonterminal FunctionParams function_params;
nonterminal Expr function_call_expr;
nonterminal AnalyticWindow opt_window_clause;
nonterminal AnalyticWindow.Type window_type;
nonterminal AnalyticWindow.Boundary window_boundary;
nonterminal SlotRef column_ref;
nonterminal ArrayList<TableRef> table_ref_list, base_table_ref_list;
nonterminal FromClause from_clause;
nonterminal TableRef table_ref;
nonterminal TableRef base_table_ref;
nonterminal WithClause opt_with_clause;
nonterminal ArrayList<View> with_view_def_list;
nonterminal View with_view_def;
nonterminal Subquery subquery;
nonterminal InlineViewRef inline_view_ref;
nonterminal FunctionTableRef function_table_ref;
nonterminal JoinOperator join_operator;
nonterminal Boolean opt_lateral;
nonterminal ArrayList<String> opt_plan_hints;
nonterminal ArrayList<String> opt_sort_hints;
nonterminal Map<String, String> opt_select_hints, select_hint, select_hint_list, hint_map;
nonterminal Expr sign_chain_expr;
nonterminal Qualifier opt_set_qualifier;
nonterminal Operation set_op;
nonterminal ArrayList<String> opt_common_hints;
// Set type
nonterminal SetType option_type, opt_var_type, var_ident_type;
// Set variable
nonterminal SetVar option_value, option_value_follow_option_type, option_value_no_option_type,
user_property;
// List of set variable
nonterminal List<SetVar> option_value_list, option_value_list_continued, start_option_value_list,
start_option_value_list_following_option_type, user_property_list;
nonterminal Map<String, String> key_value_map, opt_key_value_map, opt_properties, opt_ext_properties;
nonterminal ColumnDef column_definition;
nonterminal IndexDef index_definition;
nonterminal ArrayList<ColumnDef> column_definition_list;
nonterminal ArrayList<IndexDef> index_definition_list;
nonterminal AggregateType opt_agg_type;
nonterminal PartitionDesc opt_partition;
nonterminal DistributionDesc opt_distribution;
nonterminal Integer opt_distribution_number;
nonterminal Long opt_field_length;
nonterminal KeysDesc opt_keys;
nonterminal PartitionKeyDesc partition_key_desc;
nonterminal PartitionKeyDesc fixed_partition_key_desc;
nonterminal List<PartitionValue> partition_key_list;
nonterminal PartitionDesc range_partition_desc;
nonterminal SingleRangePartitionDesc single_range_partition_desc;
nonterminal MultiRangePartitionDesc multi_range_partition_desc;
nonterminal List<PartitionDesc> opt_range_partition_desc_list;
nonterminal List<PartitionDesc> range_partition_desc_list;
nonterminal List<PartitionDesc> opt_list_partition_desc_list;
nonterminal List<PartitionDesc> list_partition_desc_list;
nonterminal PartitionDesc list_partition_desc;
nonterminal List<List<String>> list_partition_multi_item_list;
nonterminal List<String> list_partition_multi_item;
nonterminal List<AccessPrivilege> privilege_list;
nonterminal List<String> string_list;
nonterminal List<Long> integer_list, cancel_rollup_job_id_list;
nonterminal AccessPrivilege privilege_type;
nonterminal DataDescription data_desc;
nonterminal List<DataDescription> data_desc_list;
nonterminal LabelName job_label;
nonterminal String opt_with_label;
nonterminal String opt_system;
nonterminal BrokerDesc opt_broker;
nonterminal ResourceDesc resource_desc;
nonterminal List<String> opt_col_list, opt_dup_keys, opt_columns_from_path;
nonterminal List<ColWithComment> opt_col_with_comment_list, col_with_comment_list;
nonterminal ColWithComment col_with_comment;
nonterminal List<Expr> opt_col_mapping_list;
nonterminal ColumnSeparator opt_field_term, column_separator;
nonterminal RowDelimiter row_delimiter;
nonterminal String opt_user_role;
nonterminal TablePattern tbl_pattern;
nonterminal ResourcePattern resource_pattern;
nonterminal String ident_or_star;
// Routine load
nonterminal ParseNode load_property;
nonterminal List<ParseNode> opt_load_property_list;
// Boolean
nonterminal Boolean opt_negative, opt_is_allow_null, opt_is_key, opt_read_only;
nonterminal String opt_from_rollup, opt_to_rollup, function_type;
nonterminal ColumnPosition opt_col_pos;
// Alter statement
nonterminal AlterClause alter_system_clause, alter_table_clause;
nonterminal List<AlterClause> alter_table_clause_list, opt_rollup, add_rollup_clause_list, drop_rollup_clause_list;
nonterminal AddRollupClause add_rollup_clause;
nonterminal DropRollupClause drop_rollup_clause;
// grouping sets
nonterminal List<ArrayList<Expr>> grouping_set_list;
nonterminal ArrayList<Expr> grouping_set;
nonterminal GroupByClause group_by_clause, grouping_elements;
//
nonterminal String keyword, ident, ident_or_text, variable_name, text_or_password,
charset_name_or_default, old_or_new_charset_name_or_default, opt_collate,
collation_name_or_default, type_func_name_keyword, type_function_name, opt_file_format, time_unit;
nonterminal String opt_db, procedure_or_function, opt_comment, opt_engine;
nonterminal ColumnDef.DefaultValueDef opt_default_value;
nonterminal Boolean opt_if_exists, opt_if_not_exists, opt_or_replace;
nonterminal Boolean externalable_table, externalable_resource;
nonterminal Boolean opt_force;
nonterminal IndexDef.IndexType opt_index_type;
nonterminal ShowAlterStmt.AlterType opt_alter_type;
nonterminal Boolean opt_builtin;
nonterminal StatementBase.ExplainLevel opt_explain_level;
nonterminal Boolean opt_tmp;
nonterminal OutFileClause opt_outfile;
nonterminal RoutineLoadDataSourceProperties opt_datasource_properties;
nonterminal Boolean opt_all;
precedence nonassoc COMMA;
precedence nonassoc STRING_LITERAL;
precedence nonassoc KW_COLUMNS;
precedence nonassoc KW_WITH;
precedence left KW_FULL, KW_MERGE;
precedence left DOT;
precedence left SET_VAR;
precedence left KW_OR;
precedence left KW_AND;
precedence left KW_NOT, NOT;
precedence left KW_BETWEEN, KW_IN, KW_IS, KW_EXISTS;
precedence left KW_LIKE, KW_REGEXP;
precedence left EQUAL, LESSTHAN, GREATERTHAN;
precedence left ADD, SUBTRACT;
precedence left AT, STAR, DIVIDE, MOD, KW_DIV;
precedence left BITAND, BITOR, BITXOR;
precedence left KW_PIPE;
precedence left BITNOT;
precedence left KW_ORDER, KW_BY, KW_LIMIT;
precedence left ARROW;
precedence right KW_PROPERTIES;
precedence left LPAREN, RPAREN;
// Support chaining of timestamp arithmetic exprs.
precedence left KW_INTERVAL;
precedence left KW_OVER;
precedence left KW_COLLATE;
precedence left KW_PARTITION;
precedence left KW_PARTITIONS;
precedence right KW_TEMPORARY;
precedence right LBRACKET;
// fix conflict in create table function
// http://tryitnw.blogspot.com/2012/02/tip-avoiding-shiftreduce-conflict.html
precedence left KW_FUNCTION;
start with stmts;
stmts ::=
stmt:stmt
{:
RESULT = Lists.newArrayList(stmt);
:}
| stmts:stmts SEMICOLON stmt:stmt
{:
stmts.add(stmt);
RESULT = stmts;
:}
| import_columns_stmt:stmt
{:
RESULT = Lists.newArrayList(stmt);
:}
| import_where_stmt:stmt
{:
RESULT = Lists.newArrayList(stmt);
:}
;
import_columns_stmt ::=
KW_COLUMNS LPAREN import_column_descs:columns RPAREN
{:
RESULT = new ImportColumnsStmt(columns);
:}
;
import_column_descs ::=
import_column_desc:column
{:
RESULT = Lists.newArrayList(column);
:}
| import_column_descs:columns COMMA import_column_desc:column
{:
columns.add(column);
RESULT = columns;
:}
;
import_column_desc ::=
ident:name
{:
RESULT = new ImportColumnDesc(name, null);
:}
| ident:name EQUAL expr:expr
{:
RESULT = new ImportColumnDesc(name, expr);
:}
;
import_where_stmt ::=
KW_WHERE expr:expr
{:
RESULT = new ImportWhereStmt(expr);
:}
;
stmt ::=
alter_stmt:stmt
{: RESULT = stmt; :}
| create_stmt:query
{: RESULT = query; :}
| query_stmt:query
{: RESULT = query; :}
| drop_stmt:stmt
{: RESULT = stmt; :}
| recover_stmt:stmt
{: RESULT = stmt; :}
| set_stmt:set
{: RESULT = set; :}
| kill_stmt:kill
{: RESULT = kill; :}
| describe_stmt:describe
{: RESULT = describe; :}
| KW_ADD KW_SQLBLACKLIST STRING_LITERAL:sql
{: RESULT = new AddSqlBlackListStmt(sql); :}
| show_stmt:show
{: RESULT = show; :}
| grant_stmt:grant
{: RESULT = grant; :}
| revoke_stmt:revoke
{: RESULT = revoke; :}
| help_stmt : stmt
{: RESULT = stmt; :}
| load_stmt : stmt
{: RESULT = stmt; :}
| create_routine_load_stmt : stmt
{: RESULT = stmt; :}
| pause_routine_load_stmt : stmt
{: RESULT = stmt; :}
| resume_routine_load_stmt : stmt
{: RESULT = stmt; :}
| stop_routine_load_stmt : stmt
{: RESULT = stmt; :}
| show_routine_load_stmt : stmt
{: RESULT = stmt; :}
| show_routine_load_task_stmt : stmt
{: RESULT = stmt; :}
| cancel_stmt : stmt
{: RESULT = stmt; :}
| delete_stmt : stmt
{: RESULT = stmt; :}
| sync_stmt : stmt
{: RESULT = stmt; :}
| insert_stmt : stmt
{: RESULT = stmt; :}
| backup_stmt : stmt
{: RESULT = stmt; :}
| restore_stmt : stmt
{: RESULT = stmt; :}
| unsupported_stmt : stmt
{: RESULT = stmt; :}
| export_stmt : stmt
{: RESULT = stmt; :}
| admin_stmt : stmt
{: RESULT = stmt; :}
| truncate_stmt : stmt
{: RESULT = stmt; :}
| install_plugin_stmt : stmt
{: RESULT = stmt; :}
| uninstall_plugin_stmt : stmt
{: RESULT = stmt; :}
| analyze_stmt : stmt
{: RESULT = stmt; :}
| /* empty: query only has comments */
{:
RESULT = new EmptyStmt();
:}
;
// plugin statement
install_plugin_stmt ::=
KW_INSTALL KW_PLUGIN KW_FROM ident_or_text:source opt_properties:properties
{:
RESULT = new InstallPluginStmt(source, properties);
:}
;
uninstall_plugin_stmt ::=
KW_UNINSTALL KW_PLUGIN ident_or_text:name
{:
RESULT = new UninstallPluginStmt(name);
:}
;
classifier_list ::=
classifier:classifier
{:
List<List<Predicate>> list = new ArrayList<>();
list.add(classifier);
RESULT = list;
:}
| classifier_list:list COMMA classifier:classifier
{:
list.add(classifier);
RESULT = list;
:}
;
classifier ::= LPAREN predicate_list:list RPAREN
{:
RESULT = list;
:}
;
predicate_list ::= predicate:item
{:
List<Predicate> list = new ArrayList<>();
list.add(item);
RESULT = list;
:}
| predicate_list:list COMMA predicate:item
{:
list.add(item);
RESULT = list;
:}
;
// Alter Statement
alter_stmt ::=
KW_ALTER KW_TABLE table_name:tbl
alter_table_clause_list:clauses
{:
RESULT = new AlterTableStmt(tbl, clauses);
:}
| KW_ALTER KW_TABLE table_name:tbl KW_ADD KW_ROLLUP add_rollup_clause_list:clauses
{:
RESULT = new AlterTableStmt(tbl, clauses);
:}
| KW_ALTER KW_TABLE table_name:tbl KW_DROP KW_ROLLUP drop_rollup_clause_list:clauses
{:
RESULT = new AlterTableStmt(tbl, clauses);
:}
| KW_ALTER KW_VIEW table_name:tbl
opt_col_with_comment_list:columns KW_AS query_stmt:view_def
{:
RESULT = new AlterViewStmt(tbl, columns, view_def);
:}
| KW_ALTER KW_SYSTEM alter_system_clause:clause
{:
RESULT = new AlterSystemStmt(clause);
:}
| KW_ALTER KW_DATABASE ident:dbName KW_SET KW_DATA KW_QUOTA quantity:quota_quantity
{:
RESULT = new AlterDatabaseQuotaStmt(dbName, QuotaType.DATA, quota_quantity);
:}
| KW_ALTER KW_DATABASE ident:dbName KW_SET KW_REPLICA KW_QUOTA INTEGER_LITERAL:number
{:
RESULT = new AlterDatabaseQuotaStmt(dbName, QuotaType.REPLICA, String.valueOf(number));
:}
| KW_ALTER KW_DATABASE ident:dbName KW_RENAME ident:newDbName
{:
RESULT = new AlterDatabaseRename(dbName, newDbName);
:}
| KW_ALTER KW_USER grant_user:user
{:
RESULT = new AlterUserStmt(user);
:}
| KW_ALTER KW_ROUTINE KW_LOAD KW_FOR job_label:jobLabel
opt_load_property_list:loadPropertyList
opt_properties:jobProperties
opt_datasource_properties:datasourceProperties
{:
RESULT = new AlterRoutineLoadStmt(jobLabel, loadPropertyList, jobProperties, datasourceProperties);
:}
/* resource */
| KW_ALTER KW_RESOURCE ident_or_text:resourceName KW_SET opt_properties:properties
{:
RESULT = new AlterResourceStmt(resourceName, properties);
:}
| alter_resource_group_stmt:stmt
{:
RESULT = stmt;
:}
;
alter_resource_group_stmt ::=
KW_ALTER KW_RESOURCE KW_GROUP ident:name KW_ADD classifier_list:list
{:
RESULT = new AlterResourceGroupStmt(name, new AlterResourceGroupStmt.AddClassifiers(list));
:}
|KW_ALTER KW_RESOURCE KW_GROUP ident:name KW_DROP LPAREN integer_list:list RPAREN
{:
RESULT = new AlterResourceGroupStmt(name, new AlterResourceGroupStmt.DropClassifiers(list));
:}
|KW_ALTER KW_RESOURCE KW_GROUP ident:name KW_DROP KW_ALL
{:
RESULT = new AlterResourceGroupStmt(name, new AlterResourceGroupStmt.DropAllClassifiers());
:}
|KW_ALTER KW_RESOURCE KW_GROUP ident:name KW_WITH LPAREN key_value_map:properties RPAREN
{:
RESULT = new AlterResourceGroupStmt(name, new AlterResourceGroupStmt.AlterProperties(properties));
:}
;
opt_datasource_properties ::=
// empty
{:
RESULT = new RoutineLoadDataSourceProperties();
:}
| KW_FROM ident:type LPAREN key_value_map:customProperties RPAREN
{:
RESULT = new RoutineLoadDataSourceProperties(type, customProperties);
:}
;
quantity ::=
INTEGER_LITERAL:number
{:
RESULT = number.toString();
:}
| ident:number_unit
{:
RESULT = number_unit;
:}
;
opt_user ::=
/* empty */
| KW_FOR user:user
{:
RESULT = user;
:}
;
add_rollup_clause ::=
ident:rollupName LPAREN ident_list:cols RPAREN opt_dup_keys:dup_keys opt_from_rollup:baseRollup opt_properties:properties
{:
RESULT = new AddRollupClause(rollupName, cols, dup_keys, baseRollup, properties);
:}
;
add_rollup_clause_list ::=
add_rollup_clause:clause
{:
RESULT = Lists.newArrayList(clause);
:}
| add_rollup_clause_list:list COMMA add_rollup_clause:clause
{:
list.add(clause);
RESULT = list;
:}
;
drop_rollup_clause ::=
ident:rollupName opt_properties:properties
{:
RESULT = new DropRollupClause(rollupName, properties);
:}
;
drop_rollup_clause_list ::=
drop_rollup_clause:clause
{:
RESULT = Lists.newArrayList(clause);
:}
| drop_rollup_clause_list:list COMMA drop_rollup_clause:clause
{:
list.add(clause);
RESULT = list;
:}
;
alter_table_clause_list ::=
alter_table_clause:clause
{:
RESULT = Lists.newArrayList(clause);
:}
| alter_table_clause_list:list COMMA alter_table_clause:clause
{:
list.add(clause);
RESULT = list;
:}
;
opt_to_rollup ::=
{:
RESULT = null;
:}
| KW_TO ident:rollup
{:
RESULT = rollup;
:}
| KW_IN ident:rollup
{:
RESULT = rollup;
:}
;
opt_from_rollup ::=
{:
RESULT = null;
:}
| KW_FROM ident:rollup
{:
RESULT = rollup;
:}
;
opt_col_pos ::=
{:
RESULT = null;
:}
| KW_FIRST
{:
RESULT = ColumnPosition.FIRST;
:}
| KW_AFTER ident:col
{:
RESULT = new ColumnPosition(col);
:}
;
opt_dup_keys ::=
{:
RESULT = null;
:}
| KW_DUPLICATE KW_KEY LPAREN ident_list:cols RPAREN
{:
RESULT = cols;
:}
;
alter_table_clause ::=
KW_ADD KW_COLUMN column_definition:col opt_col_pos:col_pos opt_to_rollup:rollup opt_properties:properties
{:
RESULT = new AddColumnClause(col, col_pos, rollup, properties);
:}
| KW_ADD KW_COLUMN LPAREN column_definition_list:cols RPAREN opt_to_rollup:rollup opt_properties:properties
{:
RESULT = new AddColumnsClause(cols, rollup, properties);
:}
| KW_DROP KW_COLUMN ident:col opt_from_rollup:rollup opt_properties:properties
{:
RESULT = new DropColumnClause(col, rollup, properties);
:}
| KW_MODIFY KW_COLUMN column_definition:col opt_col_pos:col_pos opt_from_rollup:rollup opt_properties:properties
{:
RESULT = new ModifyColumnClause(col, col_pos, rollup, properties);
:}
| KW_ORDER KW_BY LPAREN ident_list:cols RPAREN opt_from_rollup:rollup opt_properties:properties
{:
RESULT = new ReorderColumnsClause(cols, rollup, properties);
:}
| KW_ADD opt_tmp:isTempPartition single_range_partition_desc:desc opt_distribution:distribution opt_properties:properties
{:
RESULT = new AddPartitionClause(desc, distribution, properties, isTempPartition);
:}
| KW_ADD opt_tmp:isTempPartition KW_PARTITIONS multi_range_partition_desc:desc opt_distribution:distribution opt_properties:properties
{:
RESULT = new AddPartitionClause(desc, distribution, properties, isTempPartition);
:}
| KW_DROP opt_tmp:isTempPartition KW_PARTITION opt_if_exists:ifExists ident:partitionName opt_force:force
{:
RESULT = new DropPartitionClause(ifExists, partitionName, isTempPartition, force ? force : isTempPartition);
:}
| KW_MODIFY KW_PARTITION ident:partitionName KW_SET LPAREN key_value_map:properties RPAREN
{:
ArrayList<String> partitions = new ArrayList<String>();
partitions.add(partitionName);
RESULT = new ModifyPartitionClause(partitions, properties);
:}
| KW_MODIFY KW_PARTITION LPAREN ident_list:partitions RPAREN KW_SET LPAREN key_value_map:properties RPAREN
{:
RESULT = new ModifyPartitionClause(partitions, properties);
:}
| KW_MODIFY KW_PARTITION LPAREN STAR RPAREN KW_SET LPAREN key_value_map:properties RPAREN
{:
RESULT = ModifyPartitionClause.createStarClause(properties);
:}
| KW_REPLACE opt_partition_names:partitions KW_WITH opt_partition_names:tempPartitions opt_properties:properties
{:
RESULT = new ReplacePartitionClause(partitions, tempPartitions, properties);
:}
| KW_RENAME KW_ROLLUP ident:rollupName ident:newRollupName
{:
RESULT = new RollupRenameClause(rollupName, newRollupName);
:}
| KW_RENAME KW_PARTITION ident:partitionName ident:newPartitionName
{:
RESULT = new PartitionRenameClause(partitionName, newPartitionName);
:}
| KW_RENAME KW_COLUMN ident:colName ident:newColName
{:
RESULT = new ColumnRenameClause(colName, newColName);
:}
| KW_ADD index_definition:indexDef
{:
RESULT = new CreateIndexClause(null, indexDef, true);
:}
| KW_DROP KW_INDEX ident:indexName
{:
RESULT = new DropIndexClause(indexName, null, true);
:}
;
alter_system_clause ::=
KW_ADD KW_BACKEND string_list:hostPorts
{:
RESULT = new AddBackendClause(hostPorts);
:}