1 /*
2 * Copyright 2015-2018 HuntLabs.cn
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 module hunt.sql.parser.SQLExprParser;
17
18 import hunt.collection;
19
20 import hunt.sql.SQLUtils;
21 import hunt.sql.ast;
22 import hunt.sql.ast.expr;
23 import hunt.sql.ast.statement;
24 // import hunt.sql.dialect.oracle.ast.expr.OracleArgumentExpr;
25 import hunt.sql.dialect.postgresql.ast.expr.PGTypeCastExpr;
26 import hunt.sql.util.FnvHash;
27 import hunt.sql.util.DBType;
28 import hunt.sql.parser.SQLParser;
29 import hunt.sql.parser.Lexer;
30 import hunt.sql.parser.SQLSelectParser;
31 import hunt.sql.parser.Token;
32 import hunt.sql.ast.SQLObject;
33 import hunt.sql.util.Utils;
34 import hunt.Number;
35 import hunt.Integer;
36 import hunt.text;
37 import hunt.Boolean;
38 import hunt.Long;
39 import hunt.sql.parser.ParserException;
40 import hunt.String;
41 import std.algorithm.searching;
42 import hunt.sql.parser.SQLParserFeature;
43 import hunt.Exceptions;
44 import hunt.math;
45
46 import hunt.logging;
47
48 import std.concurrency : initOnce;
49
50 public class SQLExprParser : SQLParser {
51
52 private enum string[] strings = [ "AVG", "COUNT", "MAX", "MIN", "STDDEV", "SUM" ];
53
54 static string[] AGGREGATE_FUNCTIONS() {
55 __gshared string[] inst;
56 return initOnce!inst({
57 long[] codes = AGGREGATE_FUNCTIONS_CODES();
58 string[] r = new string[codes.length];
59
60 foreach(string str ; strings) {
61 long hash = FnvHash.fnv1a_64_lower(str);
62 int index = search(codes, hash);
63 r[index] = str;
64 }
65 return r;
66 }());
67 }
68
69 static long[] AGGREGATE_FUNCTIONS_CODES() {
70 __gshared long[] inst;
71 return initOnce!inst({
72 return FnvHash.fnv1a_64_lower(strings, true);
73 }());
74 }
75
76
77 // public static string[] AGGREGATE_FUNCTIONS =[];
78
79 // public static long[] AGGREGATE_FUNCTIONS_CODES = [];
80
81 // static this(){
82 // string[] strings = [ "AVG", "COUNT", "MAX", "MIN", "STDDEV", "SUM" ];
83 // AGGREGATE_FUNCTIONS_CODES = FnvHash.fnv1a_64_lower(strings, true);
84 // AGGREGATE_FUNCTIONS = new string[AGGREGATE_FUNCTIONS_CODES.length];
85 // foreach(string str ; strings) {
86 // long hash = FnvHash.fnv1a_64_lower(str);
87 // int index = search(AGGREGATE_FUNCTIONS_CODES, hash);
88 // AGGREGATE_FUNCTIONS[index] = str;
89 // }
90 // }
91
92 protected string[] aggregateFunctions;
93
94 protected long[] aggregateFunctionHashCodes;
95
96 public this(string sql){
97 import std.stdio;
98 aggregateFunctions = AGGREGATE_FUNCTIONS;
99 aggregateFunctionHashCodes = AGGREGATE_FUNCTIONS_CODES;
100 super(sql);
101 }
102
103 public this(string sql, string dbType){
104 aggregateFunctions = AGGREGATE_FUNCTIONS;
105 aggregateFunctionHashCodes = AGGREGATE_FUNCTIONS_CODES;
106 super(sql, dbType);
107 }
108
109 public this(Lexer lexer){
110 aggregateFunctions = AGGREGATE_FUNCTIONS;
111 aggregateFunctionHashCodes = AGGREGATE_FUNCTIONS_CODES;
112 super(lexer);
113 }
114
115 public this(Lexer lexer, string dbType){
116 aggregateFunctions = AGGREGATE_FUNCTIONS;
117 aggregateFunctionHashCodes = AGGREGATE_FUNCTIONS_CODES;
118 super(lexer, dbType);
119 }
120
121 public SQLExpr expr() {
122 if (lexer.token == Token.STAR) {
123 lexer.nextToken();
124
125 SQLExpr expr = new SQLAllColumnExpr();
126
127 if (lexer.token == Token.DOT) {
128 lexer.nextToken();
129 accept(Token.STAR);
130 return new SQLPropertyExpr(expr, "*");
131 }
132
133 return expr;
134 }
135
136 SQLExpr expr = primary();
137
138 Token token = lexer.token;
139 if (token == Token.COMMA) {
140 return expr;
141 } else if (token == Token.EQ) {
142 expr = relationalRest(expr);
143 expr = andRest(expr);
144 expr = xorRest(expr);
145 expr = orRest(expr);
146 return expr;
147 } else {
148 return exprRest(expr);
149 }
150 }
151
152 public SQLExpr exprRest(SQLExpr expr) {
153 expr = bitXorRest(expr);
154 expr = multiplicativeRest(expr);
155 expr = additiveRest(expr);
156 expr = shiftRest(expr);
157 expr = bitAndRest(expr);
158 expr = bitOrRest(expr);
159 expr = inRest(expr);
160 expr = relationalRest(expr);
161 // expr = equalityRest(expr);
162 expr = andRest(expr);
163 expr = xorRest(expr);
164 expr = orRest(expr);
165
166 return expr;
167 }
168
169 public SQLExpr bitXor() {
170 SQLExpr expr = primary();
171 return bitXorRest(expr);
172 }
173
174 public SQLExpr bitXorRest(SQLExpr expr) {
175 Token token = lexer.token;
176 switch (token) {
177 case Token.CARET: {
178 lexer.nextToken();
179 SQLBinaryOperator op;
180 if (lexer.token == Token.EQ) {
181 lexer.nextToken();
182 op = SQLBinaryOperator.BitwiseXorEQ;
183 } else {
184 op = SQLBinaryOperator.BitwiseXor;
185 }
186 SQLExpr rightExp = primary();
187 expr = new SQLBinaryOpExpr(expr, op, rightExp, dbType);
188 expr = bitXorRest(expr);
189 break;
190 }
191 case Token.SUBGT:{
192 lexer.nextToken();
193 SQLExpr rightExp = primary();
194 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SubGt, rightExp, dbType);
195 expr = bitXorRest(expr);
196 break;
197 }
198 case Token.LT_SUB_GT: {
199 lexer.nextToken();
200 SQLExpr rightExp = primary();
201 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.PG_ST_DISTANCE, rightExp, dbType);
202 expr = bitXorRest(expr);
203 break;
204 }
205 case Token.SUBGTGT:{
206 lexer.nextToken();
207 SQLExpr rightExp = primary();
208 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SubGtGt, rightExp, dbType);
209 expr = bitXorRest(expr);
210 break;
211 }
212 case Token.POUNDGT: {
213 lexer.nextToken();
214 SQLExpr rightExp = primary();
215 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.PoundGt, rightExp, dbType);
216 expr = bitXorRest(expr);
217 break;
218 }
219 case Token.POUNDGTGT: {
220 lexer.nextToken();
221 SQLExpr rightExp = primary();
222 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.PoundGtGt, rightExp, dbType);
223 expr = bitXorRest(expr);
224 break;
225 }
226 case Token.QUESQUES: {
227 lexer.nextToken();
228 SQLExpr rightExp = primary();
229 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.QuesQues, rightExp, dbType);
230 expr = bitXorRest(expr);
231 break;
232 }
233 case Token.QUESBAR: {
234 lexer.nextToken();
235 SQLExpr rightExp = primary();
236 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.QuesBar, rightExp, dbType);
237 expr = bitXorRest(expr);
238 break;
239 }
240 case Token.QUESAMP: {
241 lexer.nextToken();
242 SQLExpr rightExp = primary();
243 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.QuesAmp, rightExp, dbType);
244 expr = bitXorRest(expr);
245 break;
246 }
247
248 default:
249 break;
250 }
251
252
253 return expr;
254 }
255
256 public SQLExpr multiplicative() {
257 SQLExpr expr = bitXor();
258 return multiplicativeRest(expr);
259 }
260
261 public SQLExpr multiplicativeRest(SQLExpr expr) {
262 Token token = lexer.token;
263 if (token == Token.STAR) {
264 lexer.nextToken();
265 SQLExpr rightExp = bitXor();
266 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Multiply, rightExp, getDbType());
267 expr = multiplicativeRest(expr);
268 } else if (token == Token.SLASH) {
269 lexer.nextToken();
270 SQLExpr rightExp = bitXor();
271 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Divide, rightExp, getDbType());
272 expr = multiplicativeRest(expr);
273 } else if (token == Token.PERCENT) {
274 lexer.nextToken();
275 SQLExpr rightExp = bitXor();
276 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Modulus, rightExp, getDbType());
277 expr = multiplicativeRest(expr);
278 } else if (token == Token.DIV) {
279 lexer.nextToken();
280 SQLExpr rightExp = bitXor();
281 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.DIV, rightExp, getDbType());
282 expr = multiplicativeRest(expr);
283 } else if (lexer.identifierEquals(FnvHash.Constants.MOD) || lexer.token == Token.MOD) {
284 Lexer.SavePoint savePoint = lexer.mark();
285 lexer.nextToken();
286
287 if (lexer.token == Token.COMMA || lexer.token == Token.EOF) {
288 lexer.reset(savePoint);
289 return expr;
290 }
291
292 SQLExpr rightExp = bitXor();
293
294 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Modulus, rightExp, dbType);
295
296 expr = multiplicativeRest(expr);
297 }
298 return expr;
299 }
300
301 public SQLIntegerExpr integerExpr() {
302 SQLIntegerExpr intExpr = new SQLIntegerExpr(lexer.integerValue());
303 accept(Token.LITERAL_INT);
304 return intExpr;
305 }
306
307 public int parseIntValue() {
308 if (lexer.token == Token.LITERAL_INT) {
309 Number number = this.lexer.integerValue();
310 int intVal = (cast(Integer) number).intValue();
311 lexer.nextToken();
312 return intVal;
313 } else {
314 throw new ParserException("not int. " ~ lexer.info());
315 }
316 }
317
318 public SQLExpr primary() {
319 List!(string) beforeComments = null;
320 if (lexer.isKeepComments() && lexer.hasComment()) {
321 beforeComments = lexer.readAndResetComments();
322 }
323
324 SQLExpr sqlExpr = null;
325
326 Token tok = lexer.token;
327
328 switch (tok) {
329 case Token.LPAREN:
330 lexer.nextToken();
331
332 sqlExpr = this.expr();
333 if (lexer.token == Token.COMMA) {
334 SQLListExpr listExpr = new SQLListExpr();
335 listExpr.addItem(sqlExpr);
336 do {
337 lexer.nextToken();
338 listExpr.addItem(this.expr());
339 } while (lexer.token == Token.COMMA);
340
341 sqlExpr = listExpr;
342 }
343
344 if (cast(SQLBinaryOpExpr)(sqlExpr) !is null) {
345 (cast(SQLBinaryOpExpr) sqlExpr).setBracket(true);
346 }
347
348 accept(Token.RPAREN);
349
350 if (lexer.token == Token.UNION && cast(SQLQueryExpr)(sqlExpr) !is null) {
351 SQLQueryExpr queryExpr = cast(SQLQueryExpr) sqlExpr;
352
353 SQLSelectQuery query = this.createSelectParser().queryRest(queryExpr.getSubQuery().getQuery());
354 queryExpr.getSubQuery().setQuery(query);
355 }
356 break;
357 case Token.INSERT:
358 lexer.nextToken();
359 if (lexer.token != Token.LPAREN) {
360 throw new ParserException("syntax error. " ~ lexer.info());
361 }
362 sqlExpr = new SQLIdentifierExpr("INSERT");
363 break;
364 case Token.IDENTIFIER:
365 string ident = lexer.stringVal();
366 long hash_lower = lexer.hash_lower;
367 lexer.nextToken();
368
369 if (hash_lower == FnvHash.Constants.DATE
370 && (lexer.token == Token.LITERAL_CHARS || lexer.token == Token.VARIANT)
371 && (DBType.ORACLE.name == (dbType)
372 || DBType.POSTGRESQL.name == (dbType)
373 || DBType.MYSQL.name == (dbType))) {
374 SQLExpr literal = this.primary();
375 SQLDateExpr dateExpr = new SQLDateExpr();
376 dateExpr.setLiteral(literal);
377 sqlExpr = dateExpr;
378 } else if (hash_lower == FnvHash.Constants.TIMESTAMP
379 && (lexer.token == Token.LITERAL_CHARS || lexer.token == Token.VARIANT)
380 && !(DBType.ORACLE.name == (dbType))) {
381 SQLTimestampExpr dateExpr = new SQLTimestampExpr(lexer.stringVal());
382 lexer.nextToken();
383 sqlExpr = dateExpr;
384 } else if (equalsIgnoreCase(DBType.MYSQL.name, dbType) && ident.startsWith("0x") && (ident.length % 2) == 0) {
385 sqlExpr = new SQLHexExpr(ident.substring(2));
386 } else {
387 sqlExpr = new SQLIdentifierExpr(ident, hash_lower);
388 }
389 break;
390 case Token.NEW:
391 throw new ParserException("TODO " ~ lexer.info());
392 case Token.LITERAL_INT:
393 sqlExpr = new SQLIntegerExpr(lexer.integerValue());
394 lexer.nextToken();
395 break;
396 case Token.LITERAL_FLOAT:
397 sqlExpr = lexer.numberExpr();
398 lexer.nextToken();
399 break;
400 case Token.LITERAL_CHARS: {
401 sqlExpr = new SQLCharExpr(lexer.stringVal());
402
403 if (DBType.MYSQL.name == (dbType)) {
404 lexer.nextTokenValue();
405
406 for (; ; ) {
407 if (lexer.token == Token.LITERAL_ALIAS) {
408 string concat = (cast(SQLCharExpr) sqlExpr).getText().value();
409 concat ~= lexer.stringVal();
410 lexer.nextTokenValue();
411 sqlExpr = new SQLCharExpr(concat);
412 } else if (lexer.token == Token.LITERAL_CHARS || lexer.token == Token.LITERAL_NCHARS) {
413 string concat = (cast(SQLCharExpr) sqlExpr).getText().value();
414 concat ~= lexer.stringVal();
415 lexer.nextTokenValue();
416 sqlExpr = new SQLCharExpr(concat);
417 } else {
418 break;
419 }
420 }
421 } else {
422 lexer.nextToken();
423 }
424 break;
425 } case Token.LITERAL_NCHARS:
426 sqlExpr = new SQLNCharExpr(lexer.stringVal());
427 lexer.nextToken();
428
429 if (DBType.MYSQL.name == (dbType)) {
430 SQLMethodInvokeExpr concat = null;
431 for (; ; ) {
432 if (lexer.token == Token.LITERAL_ALIAS) {
433 if (concat is null) {
434 concat = new SQLMethodInvokeExpr("CONCAT");
435 concat.addParameter(sqlExpr);
436 sqlExpr = concat;
437 }
438 string _alias = lexer.stringVal();
439 lexer.nextToken();
440 SQLCharExpr concat_right = new SQLCharExpr(_alias.substring(1, cast(int)(_alias.length - 1)));
441 concat.addParameter(concat_right);
442 } else if (lexer.token == Token.LITERAL_CHARS || lexer.token == Token.LITERAL_NCHARS) {
443 if (concat is null) {
444 concat = new SQLMethodInvokeExpr("CONCAT");
445 concat.addParameter(sqlExpr);
446 sqlExpr = concat;
447 }
448
449 string chars = lexer.stringVal();
450 lexer.nextToken();
451 SQLCharExpr concat_right = new SQLCharExpr(chars);
452 concat.addParameter(concat_right);
453 } else {
454 break;
455 }
456 }
457 }
458 break;
459 case Token.VARIANT: {
460 string varName = lexer.stringVal();
461 lexer.nextToken();
462
463 if (varName == (":") && lexer.token == Token.IDENTIFIER && DBType.ORACLE.name == (dbType)) {
464 string part2 = lexer.stringVal();
465 lexer.nextToken();
466 varName ~= part2;
467 }
468
469 SQLVariantRefExpr varRefExpr = new SQLVariantRefExpr(varName);
470 if (varName.startsWith(":")) {
471 varRefExpr.setIndex(lexer.nextVarIndex());
472 }
473 if (varRefExpr.getName() == ("@") && lexer.token == Token.LITERAL_CHARS) {
474 varRefExpr.setName("@'" ~ lexer.stringVal() ~ "'");
475 lexer.nextToken();
476 } else if (varRefExpr.getName() == ("@@") && lexer.token == Token.LITERAL_CHARS) {
477 varRefExpr.setName("@@'" ~ lexer.stringVal() ~ "'");
478 lexer.nextToken();
479 }
480 sqlExpr = varRefExpr;
481 }
482 break;
483 case Token.DEFAULT:
484 sqlExpr = new SQLDefaultExpr();
485 lexer.nextToken();
486 break;
487 case Token.DUAL:
488 case Token.KEY:
489 case Token.DISTINCT:
490 case Token.LIMIT:
491 case Token.SCHEMA:
492 case Token.COLUMN:
493 case Token.IF:
494 case Token.END:
495 case Token.COMMENT:
496 case Token.COMPUTE:
497 case Token.ENABLE:
498 case Token.DISABLE:
499 case Token.INITIALLY:
500 case Token.SEQUENCE:
501 case Token.USER:
502 case Token.EXPLAIN:
503 case Token.WITH:
504 case Token.GRANT:
505 case Token.REPLACE:
506 case Token.INDEX:
507 case Token.MODEL:
508 case Token.PCTFREE:
509 case Token.INITRANS:
510 case Token.MAXTRANS:
511 case Token.SEGMENT:
512 case Token.CREATION:
513 case Token.IMMEDIATE:
514 case Token.DEFERRED:
515 case Token.STORAGE:
516 case Token.NEXT:
517 case Token.MINEXTENTS:
518 case Token.MAXEXTENTS:
519 case Token.MAXSIZE:
520 case Token.PCTINCREASE:
521 case Token.FLASH_CACHE:
522 case Token.CELL_FLASH_CACHE:
523 case Token.NONE:
524 case Token.LOB:
525 case Token.STORE:
526 case Token.ROW:
527 case Token.CHUNK:
528 case Token.CACHE:
529 case Token.NOCACHE:
530 case Token.LOGGING:
531 case Token.NOCOMPRESS:
532 case Token.KEEP_DUPLICATES:
533 case Token.EXCEPTIONS:
534 case Token.PURGE:
535 case Token.FULL:
536 case Token.TO:
537 case Token.IDENTIFIED:
538 case Token.PASSWORD:
539 case Token.BINARY:
540 case Token.WINDOW:
541 case Token.OFFSET:
542 case Token.SHARE:
543 case Token.START:
544 case Token.CONNECT:
545 case Token.MATCHED:
546 case Token.ERRORS:
547 case Token.REJECT:
548 case Token.UNLIMITED:
549 case Token.BEGIN:
550 case Token.EXCLUSIVE:
551 case Token.MODE:
552 case Token.ADVISE:
553 case Token.VIEW:
554 case Token.ESCAPE:
555 case Token.OVER:
556 case Token.ORDER:
557 case Token.CONSTRAINT:
558 case Token.TYPE:
559 case Token.OPEN:
560 case Token.REPEAT:
561 case Token.TABLE:
562 case Token.TRUNCATE:
563 case Token.EXCEPTION:
564 case Token.FUNCTION:
565 case Token.IDENTITY:
566 case Token.EXTRACT:
567 case Token.DESC:
568 case Token.DO:
569 case Token.GROUP:
570 case Token.MOD:
571 case Token.CONCAT:
572 sqlExpr = new SQLIdentifierExpr(lexer.stringVal());
573 lexer.nextToken();
574 break;
575 case Token.CASE:
576 SQLCaseExpr caseExpr = new SQLCaseExpr();
577 lexer.nextToken();
578 if (lexer.token != Token.WHEN) {
579 caseExpr.setValueExpr(this.expr());
580 }
581
582 accept(Token.WHEN);
583 SQLExpr testExpr = this.expr();
584 accept(Token.THEN);
585 SQLExpr valueExpr = this.expr();
586 SQLCaseExpr.Item caseItem = new SQLCaseExpr.Item(testExpr, valueExpr);
587 caseExpr.addItem(caseItem);
588
589 while (lexer.token == Token.WHEN) {
590 lexer.nextToken();
591 testExpr = this.expr();
592 accept(Token.THEN);
593 valueExpr = this.expr();
594 caseItem = new SQLCaseExpr.Item(testExpr, valueExpr);
595 caseExpr.addItem(caseItem);
596 }
597
598 if (lexer.token == Token.ELSE) {
599 lexer.nextToken();
600 caseExpr.setElseExpr(this.expr());
601 }
602
603 accept(Token.END);
604
605 sqlExpr = caseExpr;
606 break;
607 case Token.EXISTS:
608 lexer.nextToken();
609 accept(Token.LPAREN);
610 sqlExpr = new SQLExistsExpr(createSelectParser().select());
611 accept(Token.RPAREN);
612 break;
613 case Token.NOT:
614 lexer.nextToken();
615 if (lexer.token == Token.EXISTS) {
616 lexer.nextToken();
617 accept(Token.LPAREN);
618 sqlExpr = new SQLExistsExpr(createSelectParser().select(), true);
619 accept(Token.RPAREN);
620 } else if (lexer.token == Token.LPAREN) {
621 lexer.nextToken();
622
623 SQLExpr notTarget = this.expr();
624
625 accept(Token.RPAREN);
626 notTarget = relationalRest(notTarget);
627 sqlExpr = new SQLNotExpr(notTarget);
628
629 return primaryRest(sqlExpr);
630 } else {
631 SQLExpr restExpr = relational();
632 sqlExpr = new SQLNotExpr(restExpr);
633 }
634 break;
635 case Token.SELECT:
636 SQLQueryExpr queryExpr = new SQLQueryExpr(
637 createSelectParser()
638 .select());
639 sqlExpr = queryExpr;
640 break;
641 case Token.CAST:
642 lexer.nextToken();
643 accept(Token.LPAREN);
644 SQLCastExpr _cast = new SQLCastExpr();
645 _cast.setExpr(this.expr());
646 accept(Token.AS);
647 _cast.setDataType(parseDataType(false));
648 accept(Token.RPAREN);
649
650 sqlExpr = _cast;
651 break;
652 case Token.SUB:
653 lexer.nextToken();
654 switch (lexer.token) {
655 case Token.LITERAL_INT:
656 Number integerValue = lexer.integerValue();
657 if (cast(Integer)(integerValue) !is null) {
658 int intVal = (cast(Integer) integerValue).intValue();
659 if (intVal == Integer.MIN_VALUE) {
660 integerValue = Long.valueOf((cast(long) intVal) * -1);
661 } else {
662 integerValue = Integer.valueOf(intVal * -1);
663 }
664 } else if (cast(Long)(integerValue) !is null) {
665 long longVal = (cast(Long) integerValue).longValue();
666 if (longVal == 2147483648L) {
667 integerValue = Integer.valueOf(cast(int) ((cast(long) longVal) * -1));
668 } else {
669 integerValue = Long.valueOf(longVal * -1);
670 }
671 } else {
672 integerValue = (cast(BigInteger) integerValue).negate();
673 }
674 sqlExpr = new SQLIntegerExpr(integerValue);
675 lexer.nextToken();
676 break;
677 case Token.LITERAL_FLOAT:
678 sqlExpr = lexer.numberExpr(true);
679 lexer.nextToken();
680 break;
681 case Token.IDENTIFIER: // 当负号后面为字段的情况
682 sqlExpr = new SQLIdentifierExpr(lexer.stringVal());
683 lexer.nextToken();
684
685 if (lexer.token == Token.LPAREN || lexer.token == Token.LBRACKET) {
686 sqlExpr = primaryRest(sqlExpr);
687 }
688 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Negative, sqlExpr);
689
690 break;
691 case Token.QUES: {
692 SQLVariantRefExpr variantRefExpr = new SQLVariantRefExpr("?");
693 variantRefExpr.setIndex(lexer.nextVarIndex());
694 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Negative, variantRefExpr);
695 lexer.nextToken();
696 break;
697 }
698 case Token.LPAREN:
699 lexer.nextToken();
700 sqlExpr = this.expr();
701 accept(Token.RPAREN);
702 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Negative, sqlExpr);
703 break;
704 case Token.BANG:
705 sqlExpr = this.expr();
706 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Negative, sqlExpr);
707 break;
708 default:
709 throw new ParserException("TODO : " ~ lexer.info());
710 }
711 break;
712 case Token.PLUS:
713 lexer.nextToken();
714 switch (lexer.token) {
715 case Token.LITERAL_INT:
716 sqlExpr = new SQLIntegerExpr(lexer.integerValue());
717 lexer.nextToken();
718 break;
719 case Token.LITERAL_FLOAT:
720 sqlExpr = lexer.numberExpr();
721 lexer.nextToken();
722 break;
723 case Token.IDENTIFIER: // 当~号后面为字段的情况
724 sqlExpr = new SQLIdentifierExpr(lexer.stringVal());
725 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Plus, sqlExpr);
726 lexer.nextToken();
727 break;
728 case Token.LPAREN:
729 lexer.nextToken();
730 sqlExpr = this.expr();
731 accept(Token.RPAREN);
732 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Plus, sqlExpr);
733 break;
734 case Token.SUB:
735 sqlExpr = this.expr();
736 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Plus, sqlExpr);
737 break;
738 default:
739 throw new ParserException("TODO " ~ lexer.info());
740 }
741 break;
742 case Token.TILDE:
743 lexer.nextToken();
744 SQLExpr unaryValueExpr = primary();
745 SQLUnaryExpr unary = new SQLUnaryExpr(SQLUnaryOperator.Compl, unaryValueExpr);
746 sqlExpr = unary;
747 break;
748 case Token.QUES:
749 if (DBType.MYSQL.name == (dbType)) {
750 lexer.nextTokenValue();
751 } else {
752 lexer.nextToken();
753 }
754 SQLVariantRefExpr quesVarRefExpr = new SQLVariantRefExpr("?");
755 quesVarRefExpr.setIndex(lexer.nextVarIndex());
756 sqlExpr = quesVarRefExpr;
757 break;
758 case Token.LEFT:
759 sqlExpr = new SQLIdentifierExpr("LEFT");
760 lexer.nextToken();
761 break;
762 case Token.RIGHT:
763 sqlExpr = new SQLIdentifierExpr("RIGHT");
764 lexer.nextToken();
765 break;
766 case Token.DATABASE:
767 sqlExpr = new SQLIdentifierExpr("DATABASE");
768 lexer.nextToken();
769 break;
770 case Token.LOCK:
771 sqlExpr = new SQLIdentifierExpr("LOCK");
772 lexer.nextToken();
773 break;
774 case Token.NULL:
775 sqlExpr = new SQLNullExpr();
776 lexer.nextToken();
777 break;
778 case Token.BANG:
779 lexer.nextToken();
780 SQLExpr bangExpr = primary();
781 sqlExpr = new SQLUnaryExpr(SQLUnaryOperator.Not, bangExpr);
782 break;
783 case Token.LITERAL_HEX:
784 string hex = lexer.hexString();
785 sqlExpr = new SQLHexExpr(hex);
786 lexer.nextToken();
787 break;
788 case Token.INTERVAL:
789 sqlExpr = parseInterval();
790 break;
791 case Token.COLON:
792 lexer.nextToken();
793 if (lexer.token == Token.LITERAL_ALIAS) {
794 sqlExpr = new SQLVariantRefExpr(":\"" ~ lexer.stringVal() ~ "\"");
795 lexer.nextToken();
796 }
797 break;
798 case Token.ANY:
799 sqlExpr = parseAny();
800 break;
801 case Token.SOME:
802 sqlExpr = parseSome();
803 break;
804 case Token.ALL:
805 sqlExpr = parseAll();
806 break;
807 case Token.LITERAL_ALIAS:
808 sqlExpr = parseAliasExpr(lexer.stringVal());
809 lexer.nextToken();
810 break;
811 case Token.EOF:
812 throw new ParserException("EOF");
813 case Token.TRUE:
814 lexer.nextToken();
815 sqlExpr = new SQLBooleanExpr(true);
816 break;
817 case Token.FALSE:
818 lexer.nextToken();
819 sqlExpr = new SQLBooleanExpr(false);
820 break;
821 case Token.BITS: {
822 string strVal = lexer.stringVal();
823 lexer.nextToken();
824 sqlExpr = new SQLBinaryExpr(strVal);
825 break;
826 }
827 case Token.CONTAINS:
828 sqlExpr = inRest(null);
829 break;
830 case Token.SET: {
831 Lexer.SavePoint savePoint = lexer.mark();
832 lexer.nextToken();
833 if (lexer.token() == Token.LPAREN) {
834 sqlExpr = new SQLIdentifierExpr("SET");
835 } else {
836 lexer.reset(savePoint);
837 throw new ParserException("ERROR. " ~ lexer.info());
838 }
839 break;
840 }
841
842 default:
843 throw new ParserException("ERROR. " ~ lexer.info());
844 }
845
846 SQLExpr expr = primaryRest(sqlExpr);
847
848 if (beforeComments !is null) {
849 expr.addBeforeComment(beforeComments);
850 }
851
852 return expr;
853 }
854
855 protected SQLExpr parseAll() {
856 SQLExpr sqlExpr;
857 lexer.nextToken();
858 SQLAllExpr allExpr = new SQLAllExpr();
859
860 accept(Token.LPAREN);
861 SQLSelect allSubQuery = createSelectParser().select();
862 allExpr.setSubQuery(allSubQuery);
863 accept(Token.RPAREN);
864
865 allSubQuery.setParent(allExpr);
866
867 sqlExpr = allExpr;
868 return sqlExpr;
869 }
870
871 protected SQLExpr parseSome() {
872 SQLExpr sqlExpr;
873 lexer.nextToken();
874 SQLSomeExpr someExpr = new SQLSomeExpr();
875
876 accept(Token.LPAREN);
877 SQLSelect someSubQuery = createSelectParser().select();
878 someExpr.setSubQuery(someSubQuery);
879 accept(Token.RPAREN);
880
881 someSubQuery.setParent(someExpr);
882
883 sqlExpr = someExpr;
884 return sqlExpr;
885 }
886
887 protected SQLExpr parseAny() {
888 SQLExpr sqlExpr;
889 lexer.nextToken();
890 if (lexer.token == Token.LPAREN) {
891 accept(Token.LPAREN);
892
893 if (lexer.token == Token.ARRAY || lexer.token == Token.IDENTIFIER) {
894 SQLExpr expr = this.expr();
895 SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr("ANY");
896 methodInvokeExpr.addParameter(expr);
897 accept(Token.RPAREN);
898 return methodInvokeExpr;
899 }
900
901 SQLSelect anySubQuery = createSelectParser().select();
902 SQLAnyExpr anyExpr = new SQLAnyExpr(anySubQuery);
903 accept(Token.RPAREN);
904
905 sqlExpr = anyExpr;
906 } else {
907 sqlExpr = new SQLIdentifierExpr("ANY");
908 }
909 return sqlExpr;
910 }
911
912 protected SQLExpr parseAliasExpr(string _alias) {
913 return new SQLIdentifierExpr(_alias);
914 }
915
916 protected SQLExpr parseInterval() {
917 throw new ParserException("TODO. " ~ lexer.info());
918 }
919
920 public SQLSelectParser createSelectParser() {
921 return new SQLSelectParser(this);
922 }
923
924 public SQLExpr primaryRest(SQLExpr expr) {
925 if (expr is null) {
926 throw new Exception("expr");
927 }
928
929 Token token = lexer.token;
930 if (token == Token.OF) {
931 if (cast(SQLIdentifierExpr)(expr) !is null) {
932 long hashCode64 = (cast(SQLIdentifierExpr) expr).hashCode64();
933 if (hashCode64 == FnvHash.Constants.CURRENT) {
934 lexer.nextToken();
935 SQLName cursorName = this.name();
936 return new SQLCurrentOfCursorExpr(cursorName);
937 }
938 }
939 } else if (token == Token.FOR) {
940 if (cast(SQLIdentifierExpr)(expr) !is null) {
941 SQLIdentifierExpr idenExpr = cast(SQLIdentifierExpr) expr;
942 if (idenExpr.hashCode64() == FnvHash.Constants.NEXTVAL) {
943 lexer.nextToken();
944 SQLName seqName = this.name();
945 SQLSequenceExpr seqExpr = new SQLSequenceExpr(seqName, SQLSequenceExpr.Function.NextVal);
946 return seqExpr;
947 } else if (idenExpr.hashCode64() == FnvHash.Constants.CURRVAL) {
948 lexer.nextToken();
949 SQLName seqName = this.name();
950 SQLSequenceExpr seqExpr = new SQLSequenceExpr(seqName, SQLSequenceExpr.Function.CurrVal);
951 return seqExpr;
952 } else if (idenExpr.hashCode64() == FnvHash.Constants.PREVVAL) {
953 lexer.nextToken();
954 SQLName seqName = this.name();
955 SQLSequenceExpr seqExpr = new SQLSequenceExpr(seqName, SQLSequenceExpr.Function.PrevVal);
956 return seqExpr;
957 }
958 }
959 }
960
961 if (token == Token.DOT) {
962 lexer.nextToken();
963
964 if (cast(SQLCharExpr)(expr) !is null) {
965 string text = (cast(SQLCharExpr) expr).getText().value();
966 expr = new SQLIdentifierExpr(text);
967 }
968
969 expr = dotRest(expr);
970 return primaryRest(expr);
971 } else if (lexer.identifierEquals(FnvHash.Constants.SETS) //
972 && typeid(expr) == typeid(SQLIdentifierExpr) //
973 && "GROUPING".equalsIgnoreCase((cast(SQLIdentifierExpr) expr).getName())) {
974 SQLGroupingSetExpr groupingSets = new SQLGroupingSetExpr();
975 lexer.nextToken();
976
977 accept(Token.LPAREN);
978
979 for (; ; ) {
980 SQLExpr item;
981 if (lexer.token == Token.LPAREN) {
982 lexer.nextToken();
983
984 SQLListExpr listExpr = new SQLListExpr();
985 this.exprList(listExpr.getItems(), listExpr);
986 item = listExpr;
987
988 accept(Token.RPAREN);
989 } else {
990 item = this.expr();
991 }
992
993 item.setParent(groupingSets);
994 groupingSets.addParameter(item);
995
996 if (lexer.token == Token.RPAREN) {
997 break;
998 }
999
1000 accept(Token.COMMA);
1001 }
1002
1003 this.exprList(groupingSets.getParameters(), groupingSets);
1004
1005 accept(Token.RPAREN);
1006
1007 return groupingSets;
1008 } else {
1009 if (lexer.token == Token.LPAREN) {
1010 return methodRest(expr, true);
1011 }
1012 }
1013
1014 return expr;
1015 }
1016
1017 protected SQLExpr parseExtract() {
1018 throw new ParserException("not supported.");
1019 }
1020
1021 protected SQLExpr parsePosition() {
1022 throw new ParserException("not supported.");
1023 }
1024
1025 protected SQLExpr parseMatch() {
1026 throw new ParserException("not supported.");
1027 }
1028
1029 protected SQLExpr methodRest(SQLExpr expr, bool acceptLPAREN) {
1030 if (acceptLPAREN) {
1031 accept(Token.LPAREN);
1032 }
1033
1034 bool distinct = false;
1035 if (lexer.token == Token.DISTINCT) {
1036 lexer.nextToken();
1037 distinct = true;
1038 }
1039
1040 string methodName = null;
1041 string aggMethodName = null;
1042 SQLMethodInvokeExpr methodInvokeExpr;
1043 SQLExpr owner = null;
1044 string trimOption = null;
1045
1046 long hash_lower = 0L;
1047 if (cast(SQLIdentifierExpr)(expr) !is null) {
1048 SQLIdentifierExpr identifierExpr = cast(SQLIdentifierExpr) expr;
1049 methodName = identifierExpr.getName();
1050 hash_lower = identifierExpr.nameHashCode64();
1051
1052 if (hash_lower == FnvHash.Constants.TRIM) {
1053 if (lexer.identifierEquals(FnvHash.Constants.LEADING)) {
1054 trimOption = lexer.stringVal();
1055 lexer.nextToken();
1056 } else if (lexer.identifierEquals(FnvHash.Constants.BOTH)) {
1057 trimOption = lexer.stringVal();
1058 lexer.nextToken();
1059 } else if (lexer.identifierEquals(FnvHash.Constants.TRAILING)) {
1060 trimOption = lexer.stringVal();
1061 lexer.nextToken();
1062 }
1063 } else if (hash_lower == FnvHash.Constants.MATCH
1064 && DBType.MYSQL.name == (dbType)) {
1065 return parseMatch();
1066 } else if (hash_lower == FnvHash.Constants.EXTRACT
1067 && DBType.MYSQL.name == (dbType)) {
1068 return parseExtract();
1069 } else if (hash_lower == FnvHash.Constants.POSITION
1070 && DBType.MYSQL.name == (dbType)) {
1071 return parsePosition();
1072 } else if (hash_lower == FnvHash.Constants.INT4 && DBType.POSTGRESQL.name == (dbType)) {
1073 PGTypeCastExpr castExpr = new PGTypeCastExpr();
1074 castExpr.setExpr(this.expr());
1075 castExpr.setDataType(new SQLDataTypeImpl(methodName));
1076 accept(Token.RPAREN);
1077 return castExpr;
1078 } else if (hash_lower == FnvHash.Constants.VARBIT && DBType.POSTGRESQL.name == (dbType)) {
1079 PGTypeCastExpr castExpr = new PGTypeCastExpr();
1080 SQLExpr len = this.primary();
1081 castExpr.setDataType(new SQLDataTypeImpl(methodName, len));
1082 accept(Token.RPAREN);
1083 castExpr.setExpr(this.expr());
1084 return castExpr;
1085 }
1086 aggMethodName = getAggreateFunction(hash_lower);
1087 } else if (cast(SQLPropertyExpr)(expr) !is null) {
1088 methodName = (cast(Object)(expr)).toString();
1089 aggMethodName = SQLUtils.normalize(methodName);
1090 hash_lower = FnvHash.fnv1a_64_lower(aggMethodName);
1091 aggMethodName = getAggreateFunction(hash_lower);
1092
1093 owner = (cast(SQLPropertyExpr) expr).getOwner();
1094 } else if (cast(SQLDefaultExpr)(expr) !is null) {
1095 methodName = "DEFAULT";
1096 } else if (cast(SQLCharExpr)(expr) !is null) {
1097 methodName = (cast(SQLCharExpr) expr).getText().value();
1098 }
1099
1100 if (aggMethodName !is null) {
1101 SQLAggregateExpr aggregateExpr = parseAggregateExpr(aggMethodName);
1102 if (distinct) {
1103 aggregateExpr.setOption(SQLAggregateOption.DISTINCT);
1104 }
1105
1106
1107 return aggregateExpr;
1108 }
1109
1110 methodInvokeExpr = new SQLMethodInvokeExpr(methodName, hash_lower);
1111 if (owner !is null) {
1112 methodInvokeExpr.setOwner(owner);
1113 }
1114 if (trimOption !is null) {
1115 methodInvokeExpr.setTrimOption(trimOption);
1116 }
1117
1118 Token token = lexer.token;
1119 if (token != Token.RPAREN && token != Token.FROM) {
1120 exprList(methodInvokeExpr.getParameters(), methodInvokeExpr);
1121 }
1122
1123 if (hash_lower == FnvHash.Constants.EXIST
1124 && methodInvokeExpr.getParameters().size() == 1
1125 && methodInvokeExpr.getParameters().get(0) !is null) {
1126 throw new ParserException("exists syntax error.");
1127 }
1128
1129 if (lexer.token == Token.FROM) {
1130 lexer.nextToken();
1131 SQLExpr from = this.expr();
1132 methodInvokeExpr.setFrom(from);
1133
1134 if (lexer.token == Token.FOR) {
1135 lexer.nextToken();
1136 SQLExpr forExpr = this.expr();
1137 methodInvokeExpr.setFor(forExpr);
1138 }
1139 }
1140
1141 if (lexer.token == Token.USING || lexer.identifierEquals(FnvHash.Constants.USING)) {
1142 lexer.nextToken();
1143 SQLExpr using;
1144 if (lexer.token == Token.STAR) {
1145 lexer.nextToken();
1146 using = new SQLAllColumnExpr();
1147 } else if (lexer.token == Token.BINARY) {
1148 using = new SQLIdentifierExpr(lexer.stringVal());
1149 lexer.nextToken();
1150 } else {
1151 using = this.primary();
1152 }
1153 methodInvokeExpr.setUsing(using);
1154 }
1155
1156 SQLAggregateExpr aggregateExpr = null;
1157 if (lexer.token == Token.ORDER) {
1158 lexer.nextToken();
1159 accept(Token.BY);
1160
1161 aggregateExpr = new SQLAggregateExpr(methodName);
1162 aggregateExpr.getArguments().addAll(methodInvokeExpr.getParameters());
1163
1164 SQLOrderBy orderBy = new SQLOrderBy();
1165 this.orderBy(orderBy.getItems(), orderBy);
1166 aggregateExpr.setWithinGroup(orderBy);
1167 }
1168
1169 accept(Token.RPAREN);
1170
1171 if (lexer.token == Token.OVER) {
1172 if (aggregateExpr is null) {
1173 aggregateExpr = new SQLAggregateExpr(methodName);
1174 aggregateExpr.getArguments().addAll(methodInvokeExpr.getParameters());
1175 }
1176 over(aggregateExpr);
1177 }
1178
1179 if (aggregateExpr !is null) {
1180 return primaryRest(aggregateExpr);
1181 }
1182
1183 return primaryRest(methodInvokeExpr);
1184
1185 //throw new ParserException("not support token:" ~ lexer.token ~ ", " ~ lexer.info());
1186 }
1187
1188 protected SQLExpr dotRest(SQLExpr expr) {
1189 if (lexer.token == Token.STAR) {
1190 lexer.nextToken();
1191 expr = new SQLPropertyExpr(expr, "*");
1192 } else {
1193 string name;
1194 long hash_lower = 0L;
1195
1196 if (lexer.token == Token.IDENTIFIER) {
1197 name = lexer.stringVal();
1198 hash_lower = lexer.hash_lower;
1199 lexer.nextToken();
1200 } else if (lexer.token == Token.LITERAL_CHARS
1201 || lexer.token == Token.LITERAL_ALIAS) {
1202 name = lexer.stringVal();
1203 lexer.nextToken();
1204 } else if (lexer.getKeywods().containsValue(lexer.token)) {
1205 name = lexer.stringVal();
1206 lexer.nextToken();
1207 } else {
1208 throw new ParserException("error : " ~ lexer.info());
1209 }
1210
1211 if (lexer.token == Token.LPAREN) {
1212 bool aggregate = hash_lower == FnvHash.Constants.WM_CONCAT
1213 && cast(SQLIdentifierExpr)(expr) !is null
1214 && (cast(SQLIdentifierExpr) expr).nameHashCode64() == FnvHash.Constants.WMSYS;
1215 expr = methodRest(expr, name, aggregate);
1216 } else {
1217 expr = new SQLPropertyExpr(expr, name, hash_lower);
1218 }
1219 }
1220
1221 expr = primaryRest(expr);
1222 return expr;
1223 }
1224
1225 private SQLExpr methodRest(SQLExpr expr, string name, bool aggregate) {
1226 lexer.nextToken();
1227
1228 if (lexer.token == Token.DISTINCT) {
1229 lexer.nextToken();
1230
1231 string aggreateMethodName = (cast(Object)(expr)).toString() ~ "." ~ name;
1232 SQLAggregateExpr aggregateExpr = new SQLAggregateExpr(aggreateMethodName, SQLAggregateOption.DISTINCT);
1233
1234 if (lexer.token == Token.RPAREN) {
1235 lexer.nextToken();
1236 } else {
1237 if (lexer.token == Token.PLUS) {
1238 aggregateExpr.getArguments().add(new SQLIdentifierExpr("~"));
1239 lexer.nextToken();
1240 } else {
1241 exprList(aggregateExpr.getArguments(), aggregateExpr);
1242 }
1243 accept(Token.RPAREN);
1244 }
1245 expr = aggregateExpr;
1246 } else if (aggregate) {
1247 SQLAggregateExpr methodInvokeExpr = new SQLAggregateExpr(name);
1248 methodInvokeExpr.setMethodName((cast(Object)(expr)).toString() ~ "." ~ name);
1249 if (lexer.token == Token.RPAREN) {
1250 lexer.nextToken();
1251 } else {
1252 if (lexer.token == Token.PLUS) {
1253 methodInvokeExpr.addArgument(new SQLIdentifierExpr("~"));
1254 lexer.nextToken();
1255 } else {
1256 exprList(methodInvokeExpr.getArguments(), methodInvokeExpr);
1257 }
1258 accept(Token.RPAREN);
1259 }
1260
1261 if (lexer.token == Token.OVER) {
1262 over(methodInvokeExpr);
1263 }
1264
1265 expr = methodInvokeExpr;
1266 } else {
1267 SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(name);
1268 methodInvokeExpr.setOwner(expr);
1269 if (lexer.token == Token.RPAREN) {
1270 lexer.nextToken();
1271 } else {
1272 if (lexer.token == Token.PLUS) {
1273 methodInvokeExpr.addParameter(new SQLIdentifierExpr("~"));
1274 lexer.nextToken();
1275 } else {
1276 exprList(methodInvokeExpr.getParameters(), methodInvokeExpr);
1277 }
1278 accept(Token.RPAREN);
1279 }
1280 expr = methodInvokeExpr;
1281 }
1282 return expr;
1283 }
1284
1285 public SQLExpr groupComparisionRest(SQLExpr expr) {
1286 return expr;
1287 }
1288
1289 public void names(Collection!(SQLName) exprCol) {
1290 names(exprCol, null);
1291 }
1292
1293 public void names(Collection!(SQLName) exprCol, SQLObject parent) {
1294 if (lexer.token == Token.RBRACE) {
1295 return;
1296 }
1297
1298 if (lexer.token == Token.EOF) {
1299 return;
1300 }
1301
1302 SQLName name = name();
1303 name.setParent(parent);
1304 exprCol.add(name);
1305
1306 while (lexer.token == Token.COMMA) {
1307 lexer.nextToken();
1308
1309 name = this.name();
1310 name.setParent(parent);
1311 exprCol.add(name);
1312 }
1313 }
1314
1315 //@Deprecated
1316 public void exprList(Collection!(SQLExpr) exprCol) {
1317 exprList(exprCol, null);
1318 }
1319
1320 public void exprList(Collection!(SQLExpr) exprCol, SQLObject parent) {
1321 if (lexer.token == Token.RPAREN || lexer.token == Token.RBRACKET) {
1322 return;
1323 }
1324
1325 if (lexer.token == Token.EOF) {
1326 return;
1327 }
1328
1329 SQLExpr expr = expr();
1330 expr.setParent(parent);
1331 exprCol.add(expr);
1332
1333 while (lexer.token == Token.COMMA) {
1334 lexer.nextToken();
1335 expr = this.expr();
1336 expr.setParent(parent);
1337 exprCol.add(expr);
1338 }
1339 }
1340
1341 public SQLName name() {
1342 string identName;
1343 long hash = 0;
1344 if (lexer.token == Token.LITERAL_ALIAS) {
1345 identName = lexer.stringVal();
1346 lexer.nextToken();
1347 } else if (lexer.token == Token.IDENTIFIER) {
1348 identName = lexer.stringVal();
1349
1350 char c0 = charAt(identName, 0);
1351 if (c0 != '[') {
1352 hash = lexer.hash_lower();
1353 }
1354 lexer.nextToken();
1355 } else if (lexer.token == Token.LITERAL_CHARS) {
1356 identName = '\'' ~ lexer.stringVal() ~ '\'';
1357 lexer.nextToken();
1358 } else if (lexer.token == Token.VARIANT) {
1359 identName = lexer.stringVal();
1360 lexer.nextToken();
1361 } else {
1362 switch (lexer.token) {
1363 case Token.MODEL:
1364 case Token.PCTFREE:
1365 case Token.INITRANS:
1366 case Token.MAXTRANS:
1367 case Token.SEGMENT:
1368 case Token.CREATION:
1369 case Token.IMMEDIATE:
1370 case Token.DEFERRED:
1371 case Token.STORAGE:
1372 case Token.NEXT:
1373 case Token.MINEXTENTS:
1374 case Token.MAXEXTENTS:
1375 case Token.MAXSIZE:
1376 case Token.PCTINCREASE:
1377 case Token.FLASH_CACHE:
1378 case Token.CELL_FLASH_CACHE:
1379 case Token.NONE:
1380 case Token.LOB:
1381 case Token.STORE:
1382 case Token.ROW:
1383 case Token.CHUNK:
1384 case Token.CACHE:
1385 case Token.NOCACHE:
1386 case Token.LOGGING:
1387 case Token.NOCOMPRESS:
1388 case Token.KEEP_DUPLICATES:
1389 case Token.EXCEPTIONS:
1390 case Token.PURGE:
1391 case Token.INITIALLY:
1392 case Token.END:
1393 case Token.COMMENT:
1394 case Token.ENABLE:
1395 case Token.DISABLE:
1396 case Token.SEQUENCE:
1397 case Token.USER:
1398 case Token.ANALYZE:
1399 case Token.OPTIMIZE:
1400 case Token.GRANT:
1401 case Token.REVOKE:
1402 // binary有很多含义，lexer识别了这个token，实际上应该当做普通IDENTIFIER
1403 case Token.BINARY:
1404 case Token.OVER:
1405 case Token.ORDER:
1406 case Token.DO:
1407 case Token.JOIN:
1408 case Token.TYPE:
1409 case Token.FUNCTION:
1410 case Token.KEY:
1411 case Token.SCHEMA:
1412 case Token.INTERVAL:
1413 case Token.EXPLAIN:
1414 case Token.PARTITION:
1415 case Token.SET:
1416 identName = lexer.stringVal();
1417 lexer.nextToken();
1418 break;
1419 default:
1420 throw new ParserException("error " ~ lexer.info());
1421 }
1422 }
1423
1424 SQLName name = new SQLIdentifierExpr(identName, hash);
1425
1426 name = nameRest(name);
1427
1428 return name;
1429 }
1430
1431 public SQLName nameRest(SQLName name) {
1432 if (lexer.token == Token.DOT) {
1433 lexer.nextToken();
1434
1435 if (lexer.token == Token.KEY) {
1436 name = new SQLPropertyExpr(name, "KEY");
1437 lexer.nextToken();
1438 return name;
1439 }
1440
1441 if (lexer.token != Token.LITERAL_ALIAS && lexer.token != Token.IDENTIFIER
1442 && (!lexer.getKeywods().containsValue(lexer.token))) {
1443 throw new ParserException("error, " ~ lexer.info());
1444 }
1445
1446 if (lexer.token == Token.LITERAL_ALIAS) {
1447 name = new SQLPropertyExpr(name, lexer.stringVal());
1448 } else {
1449 name = new SQLPropertyExpr(name, lexer.stringVal());
1450 }
1451 lexer.nextToken();
1452 name = nameRest(name);
1453 }
1454
1455 return name;
1456 }
1457
1458 public bool isAggreateFunction(string word) {
1459 long hash_lower = FnvHash.fnv1a_64_lower(word);
1460 return isAggreateFunction(hash_lower);
1461 }
1462
1463 protected bool isAggreateFunction(long hash_lower) {
1464 return search(aggregateFunctionHashCodes, hash_lower) >= 0;
1465 }
1466
1467 protected string getAggreateFunction(long hash_lower) {
1468 int index = search(aggregateFunctionHashCodes, hash_lower);
1469 if (index < 0) {
1470 return null;
1471 }
1472 return aggregateFunctions[index];
1473 }
1474
1475 protected SQLAggregateExpr parseAggregateExpr(string methodName) {
1476 SQLAggregateExpr aggregateExpr;
1477 if (lexer.token == Token.ALL) {
1478 aggregateExpr = new SQLAggregateExpr(methodName, SQLAggregateOption.ALL);
1479 lexer.nextToken();
1480 } else if (lexer.token == Token.DISTINCT) {
1481 aggregateExpr = new SQLAggregateExpr(methodName, SQLAggregateOption.DISTINCT);
1482 lexer.nextToken();
1483 } else if (lexer.identifierEquals(FnvHash.Constants.DEDUPLICATION)) { // just for nut
1484 aggregateExpr = new SQLAggregateExpr(methodName, SQLAggregateOption.DEDUPLICATION);
1485 lexer.nextToken();
1486 } else {
1487 aggregateExpr = new SQLAggregateExpr(methodName);
1488 }
1489
1490 exprList(aggregateExpr.getArguments(), aggregateExpr);
1491
1492 if (lexer.token != Token.RPAREN) {
1493 parseAggregateExprRest(aggregateExpr);
1494 }
1495
1496 accept(Token.RPAREN);
1497
1498 if (lexer.identifierEquals(FnvHash.Constants.FILTER)) {
1499 filter(aggregateExpr);
1500 }
1501
1502 if (lexer.token == Token.OVER) {
1503 over(aggregateExpr);
1504 }
1505
1506 return aggregateExpr;
1507 }
1508
1509 protected void filter(SQLAggregateExpr aggregateExpr) {
1510
1511 }
1512
1513 public void over(SQLAggregateExpr aggregateExpr) {
1514 lexer.nextToken();
1515
1516 if (lexer.token != Token.LPAREN) {
1517 SQLName overRef = this.name();
1518 aggregateExpr.setOverRef(overRef);
1519 return;
1520 }
1521
1522 SQLOver Sover = new SQLOver();
1523 over(Sover);
1524 aggregateExpr.setOver(Sover);
1525 }
1526
1527 public void over(SQLOver over) {
1528 lexer.nextToken();
1529
1530 if (lexer.token == Token.PARTITION || lexer.identifierEquals("PARTITION")) {
1531 lexer.nextToken();
1532 accept(Token.BY);
1533
1534 if (lexer.token == (Token.LPAREN)) {
1535 lexer.nextToken();
1536 exprList(over.getPartitionBy(), over);
1537 accept(Token.RPAREN);
1538 } else {
1539 exprList(over.getPartitionBy(), over);
1540 }
1541 }
1542
1543 over.setOrderBy(parseOrderBy());
1544
1545 if (lexer.token == Token.OF) {
1546 lexer.nextToken();
1547 SQLName of = this.name();
1548 over.setOf(of);
1549 }
1550
1551 SQLOver.WindowingType windowingType;
1552 bool is_set =false;
1553 if (lexer.identifierEquals(FnvHash.Constants.ROWS) || lexer.token == Token.ROWS) {
1554 windowingType = SQLOver.WindowingType.ROWS;
1555 is_set =true;
1556
1557 } else if (lexer.identifierEquals(FnvHash.Constants.RANGE)) {
1558 windowingType = SQLOver.WindowingType.RANGE;
1559 is_set =true;
1560 }
1561
1562 if (is_set) {
1563 over.setWindowingType(windowingType);
1564 lexer.nextToken();
1565
1566 if (lexer.token == Token.BETWEEN) {
1567 lexer.nextToken();
1568 SQLExpr rowsBegin = this.primary();
1569 over.setWindowingBetweenBegin(rowsBegin);
1570
1571 if (lexer.identifierEquals(FnvHash.Constants.PRECEDING)) {
1572 over.setWindowingBetweenBeginPreceding(true);
1573 lexer.nextToken();
1574 } else if (lexer.identifierEquals(FnvHash.Constants.FOLLOWING)) {
1575 over.setWindowingBetweenBeginFollowing(true);
1576 lexer.nextToken();
1577 }
1578
1579 accept(Token.AND);
1580
1581 SQLExpr betweenEnd;
1582 if (lexer.identifierEquals(FnvHash.Constants.CURRENT) || lexer.token == Token.CURRENT) {
1583 lexer.nextToken();
1584 if (lexer.identifierEquals(FnvHash.Constants.ROW)) {
1585 lexer.nextToken();
1586 } else {
1587 accept(Token.ROW);
1588 }
1589 betweenEnd = new SQLIdentifierExpr("CURRENT ROW");
1590 } else {
1591 betweenEnd = this.primary();
1592 }
1593 over.setWindowingBetweenEnd(betweenEnd);
1594
1595 if (lexer.identifierEquals(FnvHash.Constants.PRECEDING)) {
1596 over.setWindowingBetweenEndPreceding(true);
1597 lexer.nextToken();
1598 } else if (lexer.identifierEquals(FnvHash.Constants.FOLLOWING)) {
1599 over.setWindowingBetweenEndFollowing(true);
1600 lexer.nextToken();
1601 }
1602
1603 } else {
1604
1605 if (lexer.identifierEquals(FnvHash.Constants.CURRENT)) {
1606 lexer.nextToken();
1607 if (lexer.identifierEquals(FnvHash.Constants.ROW)) {
1608 lexer.nextToken();
1609 } else {
1610 accept(Token.ROW);
1611 }
1612 over.setWindowing(new SQLIdentifierExpr("CURRENT ROW"));
1613 } else if (lexer.identifierEquals(FnvHash.Constants.UNBOUNDED)) {
1614 lexer.nextToken();
1615 over.setWindowing(new SQLIdentifierExpr("UNBOUNDED"));
1616
1617 if (lexer.identifierEquals(FnvHash.Constants.PRECEDING)) {
1618 over.setWindowingPreceding(true);
1619 lexer.nextToken();
1620 } else if (lexer.identifierEquals("FOLLOWING")) {
1621 over.setWindowingFollowing(true);
1622 lexer.nextToken();
1623 }
1624 } else {
1625 SQLIntegerExpr rowsExpr = cast(SQLIntegerExpr) this.primary();
1626 over.setWindowing(rowsExpr);
1627
1628 if (lexer.identifierEquals(FnvHash.Constants.PRECEDING)) {
1629 over.setWindowingPreceding(true);
1630 lexer.nextToken();
1631 } else if (lexer.identifierEquals(FnvHash.Constants.FOLLOWING)) {
1632 over.setWindowingFollowing(true);
1633 lexer.nextToken();
1634 }
1635 }
1636 }
1637 }
1638
1639 accept(Token.RPAREN);
1640 }
1641
1642 protected SQLAggregateExpr parseAggregateExprRest(SQLAggregateExpr aggregateExpr) {
1643 return aggregateExpr;
1644 }
1645
1646 public SQLOrderBy parseOrderBy() {
1647 if (lexer.token == Token.ORDER) {
1648 SQLOrderBy SorderBy = new SQLOrderBy();
1649
1650 lexer.nextToken();
1651
1652 if (lexer.identifierEquals(FnvHash.Constants.SIBLINGS)) {
1653 lexer.nextToken();
1654 SorderBy.setSibings(true);
1655 }
1656
1657 accept(Token.BY);
1658
1659 orderBy(SorderBy.getItems(), SorderBy);
1660
1661 return SorderBy;
1662 }
1663
1664 return null;
1665 }
1666
1667 public void orderBy(List!(SQLSelectOrderByItem) items, SQLObject parent) {
1668 SQLSelectOrderByItem item = parseSelectOrderByItem();
1669 item.setParent(parent);
1670 items.add(item);
1671 while (lexer.token == Token.COMMA) {
1672 lexer.nextToken();
1673 item = parseSelectOrderByItem();
1674 item.setParent(parent);
1675 items.add(item);
1676 }
1677 }
1678
1679 public SQLSelectOrderByItem parseSelectOrderByItem() {
1680 SQLSelectOrderByItem item = new SQLSelectOrderByItem();
1681
1682 item.setExpr(this.expr());
1683
1684 if (lexer.token == Token.ASC) {
1685 lexer.nextToken();
1686 item.setType(SQLOrderingSpecification.ASC);
1687 } else if (lexer.token == Token.DESC) {
1688 lexer.nextToken();
1689 item.setType(SQLOrderingSpecification.DESC);
1690 }
1691
1692 if (lexer.identifierEquals(FnvHash.Constants.NULLS)) {
1693 lexer.nextToken();
1694 if (lexer.identifierEquals(FnvHash.Constants.FIRST)) {
1695 lexer.nextToken();
1696 item.setNullsOrderType(SQLSelectOrderByItem.NullsOrderType.NullsFirst);
1697 } else if (lexer.identifierEquals(FnvHash.Constants.LAST)) {
1698 lexer.nextToken();
1699 item.setNullsOrderType(SQLSelectOrderByItem.NullsOrderType.NullsLast);
1700 } else {
1701 throw new ParserException("TODO " ~ lexer.info());
1702 }
1703 }
1704
1705 return item;
1706 }
1707
1708 public SQLUpdateSetItem parseUpdateSetItem() {
1709 SQLUpdateSetItem item = new SQLUpdateSetItem();
1710
1711 if (lexer.token == (Token.LPAREN)) {
1712 lexer.nextToken();
1713 SQLListExpr list = new SQLListExpr();
1714 this.exprList(list.getItems(), list);
1715 accept(Token.RPAREN);
1716 item.setColumn(list);
1717 } else {
1718 string identName;
1719 long hash;
1720
1721 Token token = lexer.token();
1722 if (token == Token.IDENTIFIER) {
1723 identName = lexer.stringVal();
1724 hash = lexer.hash_lower();
1725 } else if (token == Token.LITERAL_CHARS) {
1726 identName = '\'' ~ lexer.stringVal() ~ '\'';
1727 hash = 0;
1728 } else {
1729 identName = lexer.stringVal();
1730 hash = 0;
1731 }
1732 lexer.nextTokenEq();
1733 SQLExpr expr = new SQLIdentifierExpr(identName, hash);
1734 while (lexer.token() == Token.DOT) {
1735 lexer.nextToken();
1736 string propertyName = lexer.stringVal();
1737 lexer.nextTokenEq();
1738 expr = new SQLPropertyExpr(expr, propertyName);
1739 }
1740
1741 item.setColumn(expr);
1742 }
1743 if (lexer.token == Token.COLONEQ) {
1744 lexer.nextTokenValue();
1745 } else if (lexer.token == Token.EQ) {
1746 lexer.nextTokenValue();
1747 } else {
1748 throw new ParserException("syntax error, expect EQ, actual " ~ lexer.token ~ " "
1749 ~ lexer.info());
1750 }
1751
1752 item.setValue(this.expr());
1753 return item;
1754 }
1755
1756 public SQLExpr bitAnd() {
1757 SQLExpr expr = shift();
1758 return bitAndRest(expr);
1759 }
1760
1761 public SQLExpr bitAndRest(SQLExpr expr) {
1762 while (lexer.token == Token.AMP) {
1763 lexer.nextToken();
1764 SQLExpr rightExp = shift();
1765 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.BitwiseAnd, rightExp, getDbType());
1766 }
1767 return expr;
1768 }
1769
1770 public SQLExpr bitOr() {
1771 SQLExpr expr = bitAnd();
1772 return bitOrRest(expr);
1773 }
1774
1775 public SQLExpr bitOrRest(SQLExpr expr) {
1776 while (lexer.token == Token.BAR) {
1777 lexer.nextToken();
1778 SQLBinaryOperator op = SQLBinaryOperator.BitwiseOr;
1779 if (lexer.token == Token.BAR) {
1780 lexer.nextToken();
1781 op = SQLBinaryOperator.Concat;
1782 }
1783 SQLExpr rightExp = bitAnd();
1784 expr = new SQLBinaryOpExpr(expr, op, rightExp, getDbType());
1785 expr = bitAndRest(expr);
1786 }
1787 return expr;
1788 }
1789
1790 public SQLExpr inRest(SQLExpr expr) {
1791 if (lexer.token == Token.IN) {
1792 lexer.nextTokenLParen();
1793
1794 SQLInListExpr inListExpr = new SQLInListExpr(expr);
1795 List!(SQLExpr) targetList = inListExpr.getTargetList();
1796 if (lexer.token == Token.LPAREN) {
1797 lexer.nextTokenValue();
1798
1799 if (lexer.token == Token.WITH) {
1800 SQLSelect select = this.createSelectParser().select();
1801 SQLInSubQueryExpr queryExpr = new SQLInSubQueryExpr(select);
1802 queryExpr.setExpr(expr);
1803 accept(Token.RPAREN);
1804 return queryExpr;
1805 }
1806
1807 for (;;) {
1808 SQLExpr item;
1809 if (lexer.token == Token.LITERAL_INT) {
1810 item = new SQLIntegerExpr(lexer.integerValue());
1811 lexer.nextToken();
1812 if (lexer.token != Token.COMMA && lexer.token != Token.RPAREN) {
1813 item = this.primaryRest(item);
1814 item = this.exprRest(item);
1815 }
1816 } else {
1817 item = this.expr();
1818 }
1819
1820 item.setParent(inListExpr);
1821 targetList.add(item);
1822 if (lexer.token == Token.COMMA) {
1823 lexer.nextTokenValue();
1824 continue;
1825 }
1826 break;
1827 }
1828
1829 accept(Token.RPAREN);
1830 } else {
1831 SQLExpr itemExpr = primary();
1832 itemExpr.setParent(inListExpr);
1833 targetList.add(itemExpr);
1834 }
1835
1836 expr = inListExpr;
1837
1838 if (targetList.size() == 1) {
1839 SQLExpr targetExpr = targetList.get(0);
1840 if (cast(SQLQueryExpr)(targetExpr) !is null) {
1841 SQLInSubQueryExpr inSubQueryExpr = new SQLInSubQueryExpr();
1842 inSubQueryExpr.setExpr(inListExpr.getExpr());
1843 inSubQueryExpr.setSubQuery((cast(SQLQueryExpr) targetExpr).getSubQuery());
1844 expr = inSubQueryExpr;
1845 }
1846 }
1847 } else if (lexer.token == Token.CONTAINS) {
1848 lexer.nextTokenLParen();
1849
1850 SQLContainsExpr containsExpr = new SQLContainsExpr(expr);
1851 List!(SQLExpr) targetList = containsExpr.getTargetList();
1852 if (lexer.token == Token.LPAREN) {
1853 lexer.nextTokenValue();
1854
1855 if (lexer.token == Token.WITH) {
1856 SQLSelect select = this.createSelectParser().select();
1857 SQLInSubQueryExpr queryExpr = new SQLInSubQueryExpr(select);
1858 queryExpr.setExpr(expr);
1859 accept(Token.RPAREN);
1860 return queryExpr;
1861 }
1862
1863 for (;;) {
1864 SQLExpr item;
1865 if (lexer.token == Token.LITERAL_INT) {
1866 item = new SQLIntegerExpr(lexer.integerValue());
1867 lexer.nextToken();
1868 if (lexer.token != Token.COMMA && lexer.token != Token.RPAREN) {
1869 item = this.primaryRest(item);
1870 item = this.exprRest(item);
1871 }
1872 } else {
1873 item = this.expr();
1874 }
1875
1876 item.setParent(containsExpr);
1877 targetList.add(item);
1878 if (lexer.token == Token.COMMA) {
1879 lexer.nextTokenValue();
1880 continue;
1881 }
1882 break;
1883 }
1884
1885 accept(Token.RPAREN);
1886 } else {
1887 SQLExpr itemExpr = primary();
1888 itemExpr.setParent(containsExpr);
1889 targetList.add(itemExpr);
1890 }
1891
1892 expr = containsExpr;
1893 }
1894
1895 return expr;
1896 }
1897
1898 public SQLExpr additive() {
1899 SQLExpr expr = multiplicative();
1900
1901 if (lexer.token == Token.PLUS
1902 || lexer.token == Token.BARBAR
1903 || lexer.token == Token.CONCAT
1904 || lexer.token == Token.SUB) {
1905 expr = additiveRest(expr);
1906 }
1907
1908 return expr;
1909 }
1910
1911 public SQLExpr additiveRest(SQLExpr expr) {
1912 Token token = lexer.token;
1913 if (token == Token.PLUS) {
1914 lexer.nextToken();
1915 SQLExpr rightExp = multiplicative();
1916
1917 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Add, rightExp, dbType);
1918 expr = additiveRest(expr);
1919 } else if ((token == Token.BARBAR || token == Token.CONCAT)
1920 && (isEnabled(SQLParserFeature.PipesAsConcat) || !(DBType.MYSQL.name == (dbType)))) {
1921 lexer.nextToken();
1922 SQLExpr rightExp = multiplicative();
1923 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Concat, rightExp, dbType);
1924 expr = additiveRest(expr);
1925 } else if (token == Token.SUB) {
1926 lexer.nextToken();
1927 SQLExpr rightExp = multiplicative();
1928
1929 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Subtract, rightExp, dbType);
1930 expr = additiveRest(expr);
1931 }
1932
1933 return expr;
1934 }
1935
1936 public SQLExpr shift() {
1937 SQLExpr expr = additive();
1938 return shiftRest(expr);
1939 }
1940
1941 public SQLExpr shiftRest(SQLExpr expr) {
1942 if (lexer.token == Token.LTLT) {
1943 lexer.nextToken();
1944 SQLExpr rightExp = additive();
1945
1946 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LeftShift, rightExp, dbType);
1947 expr = shiftRest(expr);
1948 } else if (lexer.token == Token.GTGT) {
1949 lexer.nextToken();
1950 SQLExpr rightExp = additive();
1951
1952 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.RightShift, rightExp, dbType);
1953 expr = shiftRest(expr);
1954 }
1955
1956 return expr;
1957 }
1958
1959 public SQLExpr and() {
1960 SQLExpr expr = relational();
1961 if (lexer.token == Token.AND || lexer.token == Token.AMPAMP) {
1962 expr = andRest(expr);
1963 }
1964 return expr;
1965 }
1966
1967 public SQLExpr andRest(SQLExpr expr) {
1968 for (;;) {
1969 Token token = lexer.token;
1970 if (token == Token.AND) {
1971 if (lexer.isKeepComments() && lexer.hasComment()) {
1972 expr.addAfterComment(lexer.readAndResetComments());
1973 }
1974
1975 lexer.nextToken();
1976
1977 SQLExpr rightExp = relational();
1978
1979 if (lexer.token == Token.AND
1980 && lexer.isEnabled(SQLParserFeature.EnableSQLBinaryOpExprGroup)) {
1981
1982 SQLBinaryOpExprGroup group = new SQLBinaryOpExprGroup(SQLBinaryOperator.BooleanAnd, dbType);
1983 group.add(expr);
1984 group.add(rightExp);
1985
1986 if (lexer.isKeepComments() && lexer.hasComment()) {
1987 rightExp.addAfterComment(lexer.readAndResetComments());
1988 }
1989
1990 for (;;) {
1991 lexer.nextToken();
1992 SQLExpr more = relational();
1993 group.add(more);
1994
1995 if (lexer.token == Token.AND) {
1996 if (lexer.isKeepComments() && lexer.hasComment()) {
1997 more.addAfterComment(lexer.readAndResetComments());
1998 }
1999
2000 continue;
2001 }
2002 break;
2003 }
2004
2005 expr = group;
2006 } else {
2007 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.BooleanAnd, rightExp, dbType);
2008 }
2009 } else if (token == Token.AMPAMP) {
2010 if (lexer.isKeepComments() && lexer.hasComment()) {
2011 expr.addAfterComment(lexer.readAndResetComments());
2012 }
2013
2014 lexer.nextToken();
2015
2016 SQLExpr rightExp = relational();
2017
2018 SQLBinaryOperator operator = DBType.POSTGRESQL.name == (dbType)
2019 ? SQLBinaryOperator.PG_And
2020 : SQLBinaryOperator.BooleanAnd;
2021
2022 expr = new SQLBinaryOpExpr(expr, operator, rightExp, dbType);
2023 } else {
2024 break;
2025 }
2026 }
2027
2028 return expr;
2029 }
2030
2031
2032 public SQLExpr xor() {
2033 SQLExpr expr = and();
2034 if (lexer.token == Token.XOR) {
2035 expr = xorRest(expr);
2036 }
2037 return expr;
2038 }
2039
2040 public SQLExpr xorRest(SQLExpr expr) {
2041 for (;;) {
2042 if (lexer.token == Token.XOR) {
2043 lexer.nextToken();
2044 SQLExpr rightExp = and();
2045
2046 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.BooleanXor, rightExp, dbType);
2047 } else {
2048 break;
2049 }
2050 }
2051
2052 return expr;
2053 }
2054
2055 public SQLExpr or() {
2056 SQLExpr expr = xor();
2057 if (lexer.token == Token.OR || lexer.token == Token.BARBAR) {
2058 expr = orRest(expr);
2059 }
2060 return expr;
2061 }
2062
2063 public SQLExpr orRest(SQLExpr expr) {
2064 for (;;) {
2065 if (lexer.token == Token.OR) {
2066 lexer.nextToken();
2067 SQLExpr rightExp = xor();
2068
2069 if (lexer.token == Token.OR
2070 && lexer.isEnabled(SQLParserFeature.EnableSQLBinaryOpExprGroup)) {
2071
2072 SQLBinaryOpExprGroup group = new SQLBinaryOpExprGroup(SQLBinaryOperator.BooleanOr, dbType);
2073 group.add(expr);
2074 group.add(rightExp);
2075
2076 if (lexer.isKeepComments() && lexer.hasComment()) {
2077 rightExp.addAfterComment(lexer.readAndResetComments());
2078 }
2079
2080 for (;;) {
2081 lexer.nextToken();
2082 SQLExpr more = xor();
2083 group.add(more);
2084 if (lexer.token == Token.OR) {
2085 if (lexer.isKeepComments() && lexer.hasComment()) {
2086 more.addAfterComment(lexer.readAndResetComments());
2087 }
2088
2089 continue;
2090 }
2091 break;
2092 }
2093
2094 expr = group;
2095 } else {
2096 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.BooleanOr, rightExp, dbType);
2097 }
2098 } else if (lexer.token == Token.BARBAR) {
2099 lexer.nextToken();
2100 SQLExpr rightExp = xor();
2101
2102 SQLBinaryOperator op = DBType.MYSQL.name == (dbType) && !isEnabled(SQLParserFeature.PipesAsConcat)
2103 ? SQLBinaryOperator.BooleanOr
2104 : SQLBinaryOperator.Concat;
2105
2106 expr = new SQLBinaryOpExpr(expr, op, rightExp, dbType);
2107 } else {
2108 break;
2109 }
2110 }
2111
2112 return expr;
2113 }
2114
2115 public SQLExpr relational() {
2116 SQLExpr expr = bitOr();
2117
2118 return relationalRest(expr);
2119 }
2120
2121 public SQLExpr relationalRest(SQLExpr expr) {
2122 SQLExpr rightExp;
2123
2124 Token token = lexer.token;
2125
2126 switch (token) {
2127 case Token.EQ:{
2128 lexer.nextToken();
2129 try {
2130 rightExp = bitOr();
2131 } catch (ParserException e) {
2132 throw new ParserException("EOF, " ~ expr.stringof ~ "=", e);
2133 }
2134
2135 if (lexer.token == Token.COLONEQ) {
2136 lexer.nextToken();
2137 SQLExpr colonExpr = this.expr();
2138 rightExp = new SQLBinaryOpExpr(rightExp, SQLBinaryOperator.Assignment, colonExpr, dbType);
2139 }
2140
2141 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Equality, rightExp, dbType);
2142 }
2143 break;
2144 case Token.IS: {
2145 lexer.nextTokenNotOrNull();
2146
2147 SQLBinaryOperator op;
2148 if (lexer.token == Token.NOT) {
2149 op = SQLBinaryOperator.IsNot;
2150 lexer.nextTokenNotOrNull();
2151 } else {
2152 op = SQLBinaryOperator.Is;
2153 }
2154 rightExp = primary();
2155 expr = new SQLBinaryOpExpr(expr, op, rightExp, dbType);
2156 }
2157 break;
2158 case Token.EQGT: {
2159 lexer.nextToken();
2160 rightExp = this.expr();
2161 string argumentName = (cast(SQLIdentifierExpr) expr).getName();
2162 // expr = new OracleArgumentExpr(argumentName, rightExp);
2163 implementationMissing(false);
2164 }
2165 break;
2166 case Token.BANGEQ:
2167 case Token.CARETEQ: {
2168 lexer.nextToken();
2169 rightExp = bitOr();
2170 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotEqual, rightExp, dbType);
2171 }
2172 break;
2173 case Token.COLONEQ:{
2174 lexer.nextToken();
2175 rightExp = this.expr();
2176 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Assignment, rightExp, dbType);
2177 }
2178 break;
2179 case Token.LT:{
2180 SQLBinaryOperator op = SQLBinaryOperator.LessThan;
2181
2182 lexer.nextToken();
2183 if (lexer.token == Token.EQ) {
2184 lexer.nextToken();
2185 op = SQLBinaryOperator.LessThanOrEqual;
2186 }
2187
2188 rightExp = bitOr();
2189 expr = new SQLBinaryOpExpr(expr, op, rightExp, getDbType());
2190 }
2191 break;
2192 case Token.LTEQ: {
2193 lexer.nextToken();
2194 rightExp = bitOr();
2195
2196 // rightExp = relationalRest(rightExp);
2197
2198 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrEqual, rightExp, getDbType());
2199 }
2200 break;
2201 case Token.LTEQGT: {
2202 lexer.nextToken();
2203 rightExp = bitOr();
2204
2205 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrEqualOrGreaterThan, rightExp, getDbType());
2206 }
2207 break;
2208 case Token.GT: {
2209 SQLBinaryOperator op = SQLBinaryOperator.GreaterThan;
2210
2211 lexer.nextToken();
2212
2213 if (lexer.token == Token.EQ) {
2214 lexer.nextToken();
2215 op = SQLBinaryOperator.GreaterThanOrEqual;
2216 }
2217
2218 rightExp = bitOr();
2219
2220 expr = new SQLBinaryOpExpr(expr, op, rightExp, getDbType());
2221 }
2222 break;
2223 case Token.GTEQ:{
2224 lexer.nextToken();
2225 rightExp = bitOr();
2226
2227 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.GreaterThanOrEqual, rightExp, getDbType());
2228 }
2229 break;
2230 case Token.BANGLT:{
2231 lexer.nextToken();
2232 rightExp = bitOr();
2233
2234 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotLessThan, rightExp, getDbType());
2235 }
2236 break;
2237 case Token.BANGGT:
2238 lexer.nextToken();
2239 rightExp = bitOr();
2240
2241 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotGreaterThan, rightExp, getDbType());
2242 break;
2243 case Token.LTGT:
2244 lexer.nextToken();
2245 rightExp = bitOr();
2246 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.LessThanOrGreater, rightExp, getDbType());
2247 break;
2248 case Token.LIKE:
2249 lexer.nextTokenValue();
2250 rightExp = bitOr();
2251
2252 if (typeid(rightExp) == typeid(SQLIdentifierExpr)) {
2253 string name = (cast(SQLIdentifierExpr) rightExp).getName();
2254 int length = cast(int)(name.length);
2255 if(length > 1 && charAt(name, 0) == charAt(name, length -1 )) {
2256 rightExp = new SQLCharExpr(name.substring(1, length - 1));
2257 }
2258 }
2259
2260 // rightExp = relationalRest(rightExp);
2261
2262 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Like, rightExp, getDbType());
2263
2264 if (lexer.token == Token.ESCAPE) {
2265 lexer.nextToken();
2266 rightExp = primary();
2267 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Escape, rightExp, getDbType());
2268 }
2269 break;
2270 case Token.ILIKE:
2271 lexer.nextToken();
2272 rightExp = bitOr();
2273
2274 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.ILike, rightExp, getDbType());
2275 break;
2276 case Token.MONKEYS_AT_AT:
2277 lexer.nextToken();
2278 rightExp = bitOr();
2279
2280 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.AT_AT, rightExp, getDbType());
2281 break;
2282 case Token.MONKEYS_AT_GT:
2283 lexer.nextToken();
2284 rightExp = bitOr();
2285
2286 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Array_Contains, rightExp, getDbType());
2287 break;
2288 case Token.LT_MONKEYS_AT:
2289 lexer.nextToken();
2290 rightExp = bitOr();
2291
2292 rightExp = relationalRest(rightExp);
2293
2294 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Array_ContainedBy, rightExp, getDbType());
2295 break;
2296 case Token.NOT:
2297 lexer.nextToken();
2298 expr = notRationalRest(expr);
2299 break;
2300 case Token.BETWEEN:
2301 lexer.nextToken();
2302 SQLExpr beginExpr = relational();
2303 accept(Token.AND);
2304 SQLExpr endExpr = relational();
2305 expr = new SQLBetweenExpr(expr, beginExpr, endExpr);
2306 break;
2307 case Token.IN:
2308 case Token.CONTAINS:
2309 expr = inRest(expr);
2310 break;
2311 case Token.EQEQ:
2312 /* if (DBType.ODPS.name == (dbType)) {
2313 lexer.nextToken();
2314 try {
2315 rightExp = bitOr();
2316 } catch (ParserException e) {
2317 throw new ParserException("EOF, " ~ expr.stringof ~ "=", e);
2318 }
2319
2320 if (lexer.token == Token.COLONEQ) {
2321 lexer.nextToken();
2322 SQLExpr colonExpr = this.expr();
2323 rightExp = new SQLBinaryOpExpr(rightExp, SQLBinaryOperator.Assignment, colonExpr, dbType);
2324 }
2325
2326 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Equality, rightExp, dbType);
2327 } else */ {
2328 return expr;
2329 }
2330 case Token.TILDE:
2331 if (DBType.POSTGRESQL == (lexer.dbType)) {
2332 lexer.nextToken();
2333
2334 rightExp = relational();
2335
2336 rightExp = relationalRest(rightExp);
2337
2338 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Match, rightExp, getDbType());
2339 } else {
2340 return expr;
2341 }
2342 break;
2343 case Token.TILDE_STAR:
2344 if (DBType.POSTGRESQL.name == (lexer.dbType)) {
2345 lexer.nextToken();
2346 rightExp = relational();
2347 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Match_Insensitive, rightExp, getDbType());
2348 } else {
2349 return expr;
2350 }
2351 break;
2352 case Token.BANG_TILDE:
2353 if (DBType.POSTGRESQL.name == (lexer.dbType)) {
2354 lexer.nextToken();
2355 rightExp = relational();
2356 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Not_Match, rightExp, getDbType());
2357 } else {
2358 return expr;
2359 }
2360 break;
2361 case Token.BANG_TILDE_STAR:
2362 if (DBType.POSTGRESQL.name == (lexer.dbType)) {
2363 lexer.nextToken();
2364 rightExp = relational();
2365 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.POSIX_Regular_Not_Match_POSIX_Regular_Match_Insensitive, rightExp, getDbType());
2366 } else {
2367 return expr;
2368 }
2369 break;
2370 case Token.TILDE_EQ:
2371 if (DBType.POSTGRESQL.name == (lexer.dbType)) {
2372 lexer.nextToken();
2373 rightExp = relational();
2374 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SAME_AS, rightExp, getDbType());
2375 } else {
2376 return expr;
2377 }
2378 break;
2379 case Token.RLIKE:
2380 lexer.nextToken();
2381 rightExp = relational();
2382 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.RLike, rightExp, getDbType());
2383 break;
2384 case Token.IDENTIFIER:
2385 long hash = lexer.hash_lower;
2386 if (hash == FnvHash.Constants.SOUNDS) {
2387 lexer.nextToken();
2388 accept(Token.LIKE);
2389
2390 rightExp = relational();
2391
2392 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SoudsLike, rightExp, getDbType());
2393 } else if (hash == FnvHash.Constants.REGEXP) {
2394 lexer.nextToken();
2395 rightExp = relational();
2396
2397 return new SQLBinaryOpExpr(expr, SQLBinaryOperator.RegExp, rightExp, DBType.MYSQL.name);
2398
2399 } else if (hash == FnvHash.Constants.SIMILAR && DBType.POSTGRESQL.name == (lexer.dbType)) {
2400 lexer.nextToken();
2401 accept(Token.TO);
2402
2403 rightExp = relational();
2404
2405 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.SIMILAR_TO, rightExp, getDbType());
2406 } else {
2407 return expr;
2408 }
2409 break;
2410 default:
2411 break;
2412 }
2413
2414 switch (lexer.token) {
2415 case Token.BETWEEN:
2416 case Token.IS:
2417 case Token.EQ:
2418 case Token.IN:
2419 case Token.CONTAINS:
2420 case Token.BANG_TILDE_STAR:
2421 case Token.TILDE_EQ:
2422 case Token.LT:
2423 case Token.LTEQ:
2424 case Token.LTEQGT:
2425 case Token.GT:
2426 case Token.GTEQ:
2427 case Token.LTGT:
2428 case Token.BANGEQ:
2429 case Token.LIKE:
2430 case Token.NOT:
2431 expr = relationalRest(expr);
2432 break;
2433 default:
2434 break;
2435 }
2436
2437 return expr;
2438 }
2439
2440 public SQLExpr notRationalRest(SQLExpr expr) {
2441 SQLExpr rightExp;
2442 switch (lexer.token) {
2443 case Token.LIKE:
2444 lexer.nextTokenValue();
2445 rightExp = bitOr();
2446
2447 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotLike, rightExp, getDbType());
2448
2449 if (lexer.token == Token.ESCAPE) {
2450 lexer.nextToken();
2451 rightExp = bitOr();
2452 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.Escape, rightExp, getDbType());
2453 }
2454 break;
2455 case Token.IN:
2456 lexer.nextToken();
2457
2458 SQLInListExpr inListExpr = new SQLInListExpr(expr, true);
2459 if (lexer.token == Token.LPAREN) {
2460 lexer.nextToken();
2461
2462 exprList(inListExpr.getTargetList(), inListExpr);
2463 expr = inListExpr;
2464
2465 accept(Token.RPAREN);
2466 } else {
2467 SQLExpr valueExpr = this.primary();
2468 valueExpr.setParent(inListExpr);
2469 inListExpr.getTargetList().add(valueExpr);
2470 expr = inListExpr;
2471 }
2472
2473 if (inListExpr.getTargetList().size() == 1) {
2474 SQLExpr targetExpr = inListExpr.getTargetList().get(0);
2475 if (cast(SQLQueryExpr)(targetExpr) !is null) {
2476 SQLInSubQueryExpr inSubQueryExpr = new SQLInSubQueryExpr();
2477 inSubQueryExpr.setNot(true);
2478 inSubQueryExpr.setExpr(inListExpr.getExpr());
2479 inSubQueryExpr.setSubQuery((cast(SQLQueryExpr) targetExpr).getSubQuery());
2480 expr = inSubQueryExpr;
2481 }
2482 }
2483
2484 break;
2485 case Token.CONTAINS:
2486 lexer.nextToken();
2487
2488 SQLContainsExpr containsExpr = new SQLContainsExpr(expr, true);
2489 if (lexer.token == Token.LPAREN) {
2490 lexer.nextToken();
2491
2492 exprList(containsExpr.getTargetList(), containsExpr);
2493 expr = containsExpr;
2494
2495 accept(Token.RPAREN);
2496 } else {
2497 SQLExpr valueExpr = this.primary();
2498 valueExpr.setParent(containsExpr);
2499 containsExpr.getTargetList().add(valueExpr);
2500 expr = containsExpr;
2501 }
2502
2503 if (containsExpr.getTargetList().size() == 1) {
2504 SQLExpr targetExpr = containsExpr.getTargetList().get(0);
2505 if (cast(SQLQueryExpr)(targetExpr) !is null) {
2506 SQLInSubQueryExpr inSubQueryExpr = new SQLInSubQueryExpr();
2507 inSubQueryExpr.setNot(true);
2508 inSubQueryExpr.setExpr(containsExpr.getExpr());
2509 inSubQueryExpr.setSubQuery((cast(SQLQueryExpr) targetExpr).getSubQuery());
2510 expr = inSubQueryExpr;
2511 }
2512 }
2513
2514 break;
2515 case Token.BETWEEN:
2516 lexer.nextToken();
2517 SQLExpr beginExpr = relational();
2518 accept(Token.AND);
2519 SQLExpr endExpr = relational();
2520
2521 expr = new SQLBetweenExpr(expr, true, beginExpr, endExpr);
2522 break;
2523 case Token.ILIKE:
2524 lexer.nextToken();
2525 rightExp = bitOr();
2526
2527 return new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotILike, rightExp, getDbType());
2528 case Token.LPAREN:
2529 expr = this.primary();
2530 break;
2531 case Token.RLIKE:
2532 lexer.nextToken();
2533 rightExp = bitOr();
2534 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotRLike, rightExp, getDbType());
2535 break;
2536 case Token.IDENTIFIER:
2537 long hash = lexer.hash_lower;
2538 if (hash == FnvHash.Constants.REGEXP) {
2539 lexer.nextToken();
2540 rightExp = bitOr();
2541 expr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.NotRegExp, rightExp, getDbType());
2542 }
2543 break;
2544 default:
2545 throw new ParserException("TODO " ~ lexer.info());
2546 }
2547
2548 return expr;
2549 }
2550
2551 public SQLDataType parseDataType() {
2552 return parseDataType(true);
2553 }
2554
2555 public SQLDataType parseDataType(bool restrict) {
2556 Token token = lexer.token;
2557 if (token == Token.DEFAULT || token == Token.NOT || token == Token.NULL) {
2558 return null;
2559 }
2560
2561 SQLName typeExpr = name();
2562 string typeName = (cast(Object)(typeExpr)).toString();
2563
2564 version(HUNT_SQL_PARSER_DEBUG) warningf("typename: %s", typeName);
2565
2566 if ("long".equalsIgnoreCase(typeName) //
2567 && lexer.identifierEquals("byte") //
2568 && DBType.MYSQL.name == (getDbType()) //
2569 ) {
2570 typeName ~= (' ' ~ lexer.stringVal());
2571 lexer.nextToken();
2572 } else if ("double".equalsIgnoreCase(typeName)
2573 && DBType.POSTGRESQL.name == (getDbType()) //
2574 ) {
2575 typeName ~= (' ' ~ lexer.stringVal());
2576 lexer.nextToken();
2577 }
2578
2579 if (isCharType(typeName)) {
2580 SQLCharacterDataType charType = new SQLCharacterDataType(typeName);
2581
2582 if (lexer.token == Token.LPAREN) {
2583 lexer.nextToken();
2584 SQLExpr arg = this.expr();
2585 arg.setParent(charType);
2586 charType.addArgument(arg);
2587 accept(Token.RPAREN);
2588 }
2589
2590 charType = cast(SQLCharacterDataType) parseCharTypeRest(charType);
2591
2592 if (lexer.token == Token.HINT) {
2593 List!(SQLCommentHint) hints = this.parseHints();
2594 charType.setHints(hints);
2595 }
2596
2597 return charType;
2598 }
2599
2600 if ("character".equalsIgnoreCase(typeName) && "varying".equalsIgnoreCase(lexer.stringVal())) {
2601 typeName ~= ' ' ~ lexer.stringVal();
2602 lexer.nextToken();
2603 }
2604
2605 SQLDataTypeImpl dataType = new SQLDataTypeImpl(typeName);
2606 dataType.setDbType(dbType);
2607
2608 version(HUNT_SQL_PARSER_DEBUG) infof("token: %s, value: %s", lexer.token, cast(string)lexer.token);
2609
2610 // FIXME: Needing refactor or cleanup -@zhangxueping at 2020-08-05T18:03:58+08:00
2611 //
2612 // if (lexer.token == Token.LPAREN) {
2613 // lexer.nextToken();
2614 // SQLExpr arg = this.expr();
2615 // arg.setParent(dataType);
2616 // dataType.addArgument(arg);
2617 // accept(Token.RPAREN);
2618 // }
2619
2620 return parseDataTypeRest(dataType);
2621 }
2622
2623 protected SQLDataType parseDataTypeRest(SQLDataType dataType) {
2624 if (lexer.token == Token.LPAREN) {
2625 lexer.nextToken();
2626 exprList(dataType.getArguments(), dataType);
2627 accept(Token.RPAREN);
2628 }
2629
2630 if (lexer.identifierEquals(FnvHash.Constants.PRECISION)
2631 && dataType.nameHashCode64() == FnvHash.Constants.DOUBLE) {
2632 lexer.nextToken();
2633 dataType.setName("DOUBLE PRECISION");
2634 }
2635
2636 if (FnvHash.Constants.TIMESTAMP == dataType.nameHashCode64()) {
2637 if (lexer.identifierEquals(FnvHash.Constants.WITHOUT)) {
2638 lexer.nextToken();
2639 acceptIdentifier("TIME");
2640 acceptIdentifier("ZONE");
2641 dataType.setWithTimeZone(Boolean.FALSE);
2642 } else if (lexer.token == Token.WITH) {
2643 lexer.nextToken();
2644 acceptIdentifier("TIME");
2645 acceptIdentifier("ZONE");
2646 dataType.setWithTimeZone(Boolean.TRUE);
2647 }
2648 }
2649
2650 return dataType;
2651 }
2652
2653 protected bool isCharType(string dataTypeName) {
2654 long hash = FnvHash.hashCode64(dataTypeName);
2655 return isCharType(hash);
2656 }
2657
2658
2659 protected bool isCharType(long hash) {
2660 return hash == FnvHash.Constants.CHAR
2661 || hash == FnvHash.Constants.VARCHAR
2662 || hash == FnvHash.Constants.NCHAR
2663 || hash == FnvHash.Constants.NVARCHAR
2664 || hash == FnvHash.Constants.TINYTEXT
2665 || hash == FnvHash.Constants.TEXT
2666 || hash == FnvHash.Constants.MEDIUMTEXT
2667 || hash == FnvHash.Constants.LONGTEXT
2668 ;
2669 }
2670
2671 protected SQLDataType parseCharTypeRest(SQLCharacterDataType charType) {
2672 if (lexer.token == Token.BINARY) {
2673 charType.setHasBinary(true);
2674 lexer.nextToken();
2675 }
2676
2677 if (lexer.identifierEquals(FnvHash.Constants.CHARACTER)) {
2678 lexer.nextToken();
2679
2680 accept(Token.SET);
2681
2682 if (lexer.token != Token.IDENTIFIER
2683 && lexer.token != Token.LITERAL_CHARS
2684 && lexer.token != Token.BINARY) {
2685 throw new ParserException(lexer.info());
2686 }
2687 charType.setCharSetName(lexer.stringVal());
2688 lexer.nextToken();
2689 } else if (lexer.identifierEquals(FnvHash.Constants.CHARSET)) {
2690 lexer.nextToken();
2691
2692 if (lexer.token != Token.IDENTIFIER
2693 && lexer.token != Token.LITERAL_CHARS
2694 && lexer.token != Token.BINARY) {
2695 throw new ParserException(lexer.info());
2696 }
2697 charType.setCharSetName(lexer.stringVal());
2698 lexer.nextToken();
2699 }
2700
2701 if (lexer.token == Token.BINARY) {
2702 charType.setHasBinary(true);
2703 lexer.nextToken();
2704 }
2705
2706 if (lexer.identifierEquals(FnvHash.Constants.COLLATE)) {
2707 lexer.nextToken();
2708
2709 if (lexer.token == Token.LITERAL_ALIAS) {
2710 charType.setCollate(lexer.stringVal());
2711 } else if (lexer.token == Token.IDENTIFIER) {
2712 charType.setCollate(lexer.stringVal());
2713 } else {
2714 throw new ParserException();
2715 }
2716
2717 lexer.nextToken();
2718 }
2719
2720 return charType;
2721 }
2722
2723 override public void accept(Token token) {
2724 if (lexer.token == token) {
2725 lexer.nextToken();
2726 } else {
2727 throw new ParserException("syntax error, expect:{" ~ token ~ "}, actual:{" ~ lexer.token ~ "}, "
2728 ~ lexer.info());
2729 }
2730 }
2731
2732 public SQLColumnDefinition parseColumn() {
2733 SQLColumnDefinition column = createColumnDefinition();
2734 column.setName(name());
2735
2736 Token token = lexer.token;
2737 if (token != Token.SET //
2738 && token != Token.DROP
2739 && token != Token.PRIMARY
2740 && token != Token.RPAREN) {
2741 column.setDataType(parseDataType());
2742 }
2743 return parseColumnRest(column);
2744 }
2745
2746 public SQLColumnDefinition createColumnDefinition() {
2747 SQLColumnDefinition column = new SQLColumnDefinition();
2748 column.setDbType(dbType);
2749 return column;
2750 }
2751
2752 public SQLColumnDefinition parseColumnRest(SQLColumnDefinition column) {
2753 if (lexer.token == Token.DEFAULT) {
2754 lexer.nextToken();
2755 column.setDefaultExpr(bitOr());
2756 return parseColumnRest(column);
2757 }
2758
2759 if (lexer.token == Token.NOT) {
2760 lexer.nextToken();
2761 accept(Token.NULL);
2762 SQLNotNullConstraint notNull = new SQLNotNullConstraint();
2763 if (lexer.token == Token.HINT) {
2764 List!(SQLCommentHint) hints = this.parseHints();
2765 notNull.setHints(hints);
2766 }
2767 column.addConstraint(notNull);
2768 return parseColumnRest(column);
2769 }
2770
2771 if (lexer.token == Token.NULL) {
2772 lexer.nextToken();
2773 column.getConstraints().add(new SQLNullConstraint());
2774 return parseColumnRest(column);
2775 }
2776
2777 if (lexer.token == Token.PRIMARY) {
2778 lexer.nextToken();
2779 accept(Token.KEY);
2780 column.addConstraint(new SQLColumnPrimaryKey());
2781 return parseColumnRest(column);
2782 }
2783
2784 if (lexer.token == Token.UNIQUE) {
2785 lexer.nextToken();
2786 if (lexer.token == Token.KEY) {
2787 lexer.nextToken();
2788 }
2789 column.addConstraint(new SQLColumnUniqueKey());
2790 return parseColumnRest(column);
2791 }
2792
2793 if (lexer.token == Token.KEY) {
2794 lexer.nextToken();
2795 column.addConstraint(new SQLColumnUniqueKey());
2796 return parseColumnRest(column);
2797 }
2798
2799 if (lexer.token == Token.REFERENCES) {
2800 SQLColumnReference _ref = parseReference();
2801 column.addConstraint(_ref);
2802 return parseColumnRest(column);
2803 }
2804
2805 if (lexer.token == Token.CONSTRAINT) {
2806 lexer.nextToken();
2807
2808 SQLName name = this.name();
2809
2810 if (lexer.token == Token.PRIMARY) {
2811 lexer.nextToken();
2812 accept(Token.KEY);
2813 SQLColumnPrimaryKey pk = new SQLColumnPrimaryKey();
2814 pk.setName(name);
2815 column.addConstraint(pk);
2816 return parseColumnRest(column);
2817 }
2818
2819 if (lexer.token == Token.UNIQUE) {
2820 lexer.nextToken();
2821 SQLColumnUniqueKey uk = new SQLColumnUniqueKey();
2822 uk.setName(name);
2823
2824 column.addConstraint(uk);
2825 return parseColumnRest(column);
2826 }
2827
2828 if (lexer.token == Token.REFERENCES) {
2829 SQLColumnReference _ref = parseReference();
2830 _ref.setName(name);
2831 column.addConstraint(_ref);
2832 return parseColumnRest(column);
2833 }
2834
2835 if (lexer.token == Token.NOT) {
2836 lexer.nextToken();
2837 accept(Token.NULL);
2838 SQLNotNullConstraint notNull = new SQLNotNullConstraint();
2839 notNull.setName(name);
2840 column.addConstraint(notNull);
2841 return parseColumnRest(column);
2842 }
2843
2844 if (lexer.token == Token.CHECK) {
2845 SQLColumnCheck check = parseColumnCheck();
2846 check.setName(name);
2847 check.setParent(column);
2848 column.addConstraint(check);
2849 return parseColumnRest(column);
2850 }
2851
2852 if (lexer.token == Token.DEFAULT) {
2853 lexer.nextToken();
2854 SQLExpr expr = this.expr();
2855 column.setDefaultExpr(expr);
2856 return parseColumnRest(column);
2857 }
2858
2859 throw new ParserException("TODO : " ~ lexer.info());
2860 }
2861
2862 if (lexer.token == Token.CHECK) {
2863 SQLColumnCheck check = parseColumnCheck();
2864 column.addConstraint(check);
2865 return parseColumnRest(column);
2866 }
2867
2868 if (lexer.token == Token.COMMENT) {
2869 lexer.nextToken();
2870
2871 if (lexer.token == Token.LITERAL_ALIAS) {
2872 string _alias = lexer.stringVal();
2873 if (_alias.length > 2 && charAt(_alias, 0) == '"' && charAt(_alias, _alias.length - 1) == '"') {
2874 _alias = _alias.substring(1, cast(int)(_alias.length - 1));
2875 }
2876 column.setComment(_alias);
2877 lexer.nextToken();
2878 } else {
2879 column.setComment(primary());
2880 }
2881 return parseColumnRest(column);
2882 }
2883
2884 if (lexer.identifierEquals(FnvHash.Constants.AUTO_INCREMENT)) {
2885 lexer.nextToken();
2886 column.setAutoIncrement(true);
2887 return parseColumnRest(column);
2888 }
2889
2890 return column;
2891 }
2892
2893 private SQLColumnReference parseReference() {
2894 SQLColumnReference fk = new SQLColumnReference();
2895
2896 lexer.nextToken();
2897 fk.setTable(this.name());
2898 accept(Token.LPAREN);
2899 this.names(fk.getColumns(), fk);
2900 accept(Token.RPAREN);
2901
2902 if (lexer.identifierEquals(FnvHash.Constants.MATCH)) {
2903 lexer.nextToken();
2904 if (lexer.identifierEquals("FULL") || lexer.token() == Token.FULL) {
2905 fk.setReferenceMatch(SQLForeignKeyImpl.Match.FULL);
2906 lexer.nextToken();
2907 } else if (lexer.identifierEquals(FnvHash.Constants.PARTIAL)) {
2908 fk.setReferenceMatch(SQLForeignKeyImpl.Match.PARTIAL);
2909 lexer.nextToken();
2910 } else if (lexer.identifierEquals(FnvHash.Constants.SIMPLE)) {
2911 fk.setReferenceMatch(SQLForeignKeyImpl.Match.SIMPLE);
2912 lexer.nextToken();
2913 } else {
2914 throw new ParserException("TODO : " ~ lexer.info());
2915 }
2916 }
2917
2918 while (lexer.token() == Token.ON) {
2919 lexer.nextToken();
2920
2921 if (lexer.token() == Token.DELETE) {
2922 lexer.nextToken();
2923
2924 SQLForeignKeyImpl.Option option = parseReferenceOption();
2925 fk.setOnDelete(option);
2926 } else if (lexer.token() == Token.UPDATE) {
2927 lexer.nextToken();
2928
2929 SQLForeignKeyImpl.Option option = parseReferenceOption();
2930 fk.setOnUpdate(option);
2931 } else {
2932 throw new ParserException("syntax error, expect DELETE or UPDATE, actual " ~ lexer.token() ~ " "
2933 ~ lexer.info());
2934 }
2935 }
2936
2937 return fk;
2938 }
2939
2940 protected SQLForeignKeyImpl.Option parseReferenceOption() {
2941 SQLForeignKeyImpl.Option option;
2942 if (lexer.token() == Token.RESTRICT || lexer.identifierEquals(FnvHash.Constants.RESTRICT)) {
2943 option = SQLForeignKeyImpl.Option.RESTRICT;
2944 lexer.nextToken();
2945 } else if (lexer.identifierEquals(FnvHash.Constants.CASCADE)) {
2946 option = SQLForeignKeyImpl.Option.CASCADE;
2947 lexer.nextToken();
2948 } else if (lexer.token() == Token.SET) {
2949 lexer.nextToken();
2950 accept(Token.NULL);
2951 option = SQLForeignKeyImpl.Option.SET_NULL;
2952 } else if (lexer.identifierEquals(FnvHash.Constants.NO)) {
2953 lexer.nextToken();
2954 if (lexer.identifierEquals(FnvHash.Constants.ACTION)) {
2955 option = SQLForeignKeyImpl.Option.NO_ACTION;
2956 lexer.nextToken();
2957 } else {
2958 throw new ParserException("syntax error, expect ACTION, actual " ~ lexer.token() ~ " "
2959 ~ lexer.info());
2960 }
2961 } else {
2962 throw new ParserException("syntax error, expect ACTION, actual " ~ lexer.token() ~ " "
2963 ~ lexer.info());
2964 }
2965
2966 return option;
2967 }
2968
2969 protected SQLColumnCheck parseColumnCheck() {
2970 lexer.nextToken();
2971 SQLExpr expr = this.expr();
2972 SQLColumnCheck check = new SQLColumnCheck(expr);
2973
2974 if (lexer.token == Token.DISABLE) {
2975 lexer.nextToken();
2976 check.setEnable(Boolean.FALSE);
2977 } else if (lexer.token == Token.ENABLE) {
2978 lexer.nextToken();
2979 check.setEnable(Boolean.TRUE);
2980 } else if (lexer.identifierEquals(FnvHash.Constants.VALIDATE)) {
2981 lexer.nextToken();
2982 check.setValidate(Boolean.TRUE);
2983 } else if (lexer.identifierEquals(FnvHash.Constants.NOVALIDATE)) {
2984 lexer.nextToken();
2985 check.setValidate(Boolean.FALSE);
2986 } else if (lexer.identifierEquals(FnvHash.Constants.RELY)) {
2987 lexer.nextToken();
2988 check.setRely(Boolean.TRUE);
2989 } else if (lexer.identifierEquals(FnvHash.Constants.NORELY)) {
2990 lexer.nextToken();
2991 check.setRely(Boolean.FALSE);
2992 }
2993 return check;
2994 }
2995
2996 public SQLPrimaryKey parsePrimaryKey() {
2997 accept(Token.PRIMARY);
2998 accept(Token.KEY);
2999
3000 SQLPrimaryKeyImpl pk = new SQLPrimaryKeyImpl();
3001
3002 if (lexer.identifierEquals(FnvHash.Constants.CLUSTERED)) {
3003 lexer.nextToken();
3004 pk.setClustered(true);
3005 }
3006
3007 accept(Token.LPAREN);
3008 orderBy(pk.getColumns(), pk);
3009 accept(Token.RPAREN);
3010
3011 return pk;
3012 }
3013
3014 public SQLUnique parseUnique() {
3015 accept(Token.UNIQUE);
3016
3017 SQLUnique unique = new SQLUnique();
3018 accept(Token.LPAREN);
3019 orderBy(unique.getColumns(), unique);
3020 accept(Token.RPAREN);
3021
3022 if (lexer.token == Token.DISABLE) {
3023 lexer.nextToken();
3024 unique.setEnable(Boolean.FALSE);
3025 } else if (lexer.token == Token.ENABLE) {
3026 lexer.nextToken();
3027 unique.setEnable(Boolean.TRUE);
3028 } else if (lexer.identifierEquals(FnvHash.Constants.VALIDATE)) {
3029 lexer.nextToken();
3030 unique.setValidate(Boolean.TRUE);
3031 } else if (lexer.identifierEquals(FnvHash.Constants.NOVALIDATE)) {
3032 lexer.nextToken();
3033 unique.setValidate(Boolean.FALSE);
3034 } else if (lexer.identifierEquals(FnvHash.Constants.RELY)) {
3035 lexer.nextToken();
3036 unique.setRely(Boolean.TRUE);
3037 } else if (lexer.identifierEquals(FnvHash.Constants.NORELY)) {
3038 lexer.nextToken();
3039 unique.setRely(Boolean.FALSE);
3040 }
3041
3042 return unique;
3043 }
3044
3045 public SQLAssignItem parseAssignItem() {
3046 SQLAssignItem item = new SQLAssignItem();
3047
3048 SQLExpr var = primary();
3049
3050 if (cast(SQLIdentifierExpr)(var) !is null) {
3051 var = new SQLVariantRefExpr((cast(SQLIdentifierExpr) var).getName());
3052 }
3053 item.setTarget(var);
3054 if (lexer.token == Token.COLONEQ) {
3055 lexer.nextToken();
3056 } else if (lexer.token == Token.TRUE || lexer.identifierEquals(FnvHash.Constants.TRUE)) {
3057 lexer.nextToken();
3058 item.setValue(new SQLBooleanExpr(true));
3059 return item;
3060 } else if (lexer.token == Token.ON) {
3061 lexer.nextToken();
3062 item.setValue(new SQLIdentifierExpr("ON"));
3063 return item;
3064 } else {
3065 if (lexer.token == Token.EQ) {
3066 lexer.nextToken();
3067 } else {
3068 accept(Token.EQ);
3069 }
3070 }
3071
3072 if (lexer.token == Token.ON) {
3073 item.setValue(new SQLIdentifierExpr(lexer.stringVal()));
3074 lexer.nextToken();
3075 } else {
3076 if (lexer.token == Token.ALL) {
3077 item.setValue(new SQLIdentifierExpr(lexer.stringVal()));
3078 lexer.nextToken();
3079 } else {
3080 SQLExpr expr = this.expr();
3081
3082 if (lexer.token == Token.COMMA && DBType.POSTGRESQL.name == (dbType)) {
3083 SQLListExpr listExpr = new SQLListExpr();
3084 listExpr.addItem(expr);
3085 expr.setParent(listExpr);
3086 do {
3087 lexer.nextToken();
3088 SQLExpr listItem = this.expr();
3089 listItem.setParent(listExpr);
3090 listExpr.addItem(listItem);
3091 } while (lexer.token == Token.COMMA);
3092 item.setValue(listExpr);
3093 } else {
3094 item.setValue(expr);
3095 }
3096 }
3097 }
3098
3099 return item;
3100 }
3101
3102 public List!(SQLCommentHint) parseHints() {
3103 List!(SQLCommentHint) hints = new ArrayList!(SQLCommentHint)();
3104 parseHints!(SQLCommentHint)((hints));
3105 return hints;
3106 }
3107
3108 //@SuppressWarnings({ "unchecked", "rawtypes" })
3109 public void parseHints(T)(List!(T) hints) {
3110 if (lexer.token == Token.HINT) {
3111 SQLCommentHint hint = new SQLCommentHint(lexer.stringVal());
3112
3113 if (lexer.commentCount > 0) {
3114 hint.addBeforeComment(lexer.comments);
3115 }
3116
3117 hints.add(hint);
3118 lexer.nextToken();
3119 }
3120 }
3121
3122 public SQLConstraint parseConstaint() {
3123 SQLName name = null;
3124
3125 if (lexer.token == Token.CONSTRAINT) {
3126 lexer.nextToken();
3127 name = this.name();
3128 }
3129
3130 SQLConstraint constraint;
3131 if (lexer.token == Token.PRIMARY) {
3132 constraint = parsePrimaryKey();
3133 } else if (lexer.token == Token.UNIQUE) {
3134 constraint = parseUnique();
3135 } else if (lexer.token == Token.KEY) {
3136 constraint = parseUnique();
3137 } else if (lexer.token == Token.FOREIGN) {
3138 constraint = parseForeignKey();
3139 } else if (lexer.token == Token.CHECK) {
3140 constraint = parseCheck();
3141 } else {
3142 throw new ParserException("TODO : " ~ lexer.info());
3143 }
3144
3145 constraint.setName(name);
3146
3147 return constraint;
3148 }
3149
3150 public SQLCheck parseCheck() {
3151 accept(Token.CHECK);
3152 SQLCheck check = createCheck();
3153 accept(Token.LPAREN);
3154 check.setExpr(this.expr());
3155 accept(Token.RPAREN);
3156 return check;
3157 }
3158
3159 protected SQLCheck createCheck() {
3160 return new SQLCheck();
3161 }
3162
3163 public SQLForeignKeyConstraint parseForeignKey() {
3164 accept(Token.FOREIGN);
3165 accept(Token.KEY);
3166
3167 SQLForeignKeyImpl fk = createForeignKey();
3168
3169 accept(Token.LPAREN);
3170 this.names(fk.getReferencingColumns(), fk);
3171 accept(Token.RPAREN);
3172
3173 accept(Token.REFERENCES);
3174
3175 fk.setReferencedTableName(this.name());
3176
3177 if (lexer.token == Token.LPAREN) {
3178 lexer.nextToken();
3179 this.names(fk.getReferencedColumns(), fk);
3180 accept(Token.RPAREN);
3181 }
3182
3183 if (lexer.token == Token.ON) {
3184 lexer.nextToken();
3185 accept(Token.DELETE);
3186 if (lexer.identifierEquals(FnvHash.Constants.CASCADE)) {
3187 lexer.nextToken();
3188 fk.setOnDeleteCascade(true);
3189 } else {
3190 accept(Token.SET);
3191 accept(Token.NULL);
3192 fk.setOnDeleteSetNull(true);
3193 }
3194 }
3195
3196 return fk;
3197 }
3198
3199 protected SQLForeignKeyImpl createForeignKey() {
3200 return new SQLForeignKeyImpl();
3201 }
3202
3203 public SQLSelectItem parseSelectItem() {
3204 SQLExpr expr;
3205 bool connectByRoot = false;
3206 Token token = lexer.token;
3207 if (token == Token.IDENTIFIER) {
3208 string ident = lexer.stringVal();
3209 long hash_lower = lexer.hash_lower();
3210 lexer.nextTokenComma();
3211
3212 if (hash_lower == FnvHash.Constants.CONNECT_BY_ROOT) {
3213 connectByRoot = lexer.token != Token.LPAREN;
3214 if (connectByRoot) {
3215 expr = new SQLIdentifierExpr(lexer.stringVal());
3216 lexer.nextToken();
3217 } else {
3218 expr = new SQLIdentifierExpr(ident);
3219 }
3220 } else if (FnvHash.Constants.DATE == hash_lower
3221 && lexer.token == Token.LITERAL_CHARS
3222 && (DBType.ORACLE.name == (getDbType())
3223 || DBType.POSTGRESQL.name == (getDbType()))) {
3224 string literal = lexer.stringVal();
3225 lexer.nextToken();
3226
3227 SQLDateExpr dateExpr = new SQLDateExpr();
3228 dateExpr.setLiteral(new String(literal));
3229
3230 expr = dateExpr;
3231 } else {
3232 expr = new SQLIdentifierExpr(ident, hash_lower);
3233 }
3234
3235 token = lexer.token;
3236
3237 if (token == Token.DOT) {
3238 lexer.nextTokenIdent();
3239 string name;
3240 long name_hash_lower;
3241
3242 if (lexer.token == Token.STAR) {
3243 name = "*";
3244 name_hash_lower = FnvHash.Constants.STAR;
3245 } else {
3246 name = lexer.stringVal();
3247 name_hash_lower = lexer.hash_lower();
3248 }
3249
3250 lexer.nextTokenComma();
3251
3252 token = lexer.token;
3253 if (token == Token.LPAREN) {
3254 bool aggregate = hash_lower == FnvHash.Constants.WMSYS && name_hash_lower == FnvHash.Constants.WM_CONCAT;
3255 expr = methodRest(expr, name, aggregate);
3256 token = lexer.token;
3257 } else {
3258 if (name_hash_lower == FnvHash.Constants.NEXTVAL) {
3259 expr = new SQLSequenceExpr(cast(SQLIdentifierExpr) expr, SQLSequenceExpr.Function.NextVal);
3260 } else if (name_hash_lower == FnvHash.Constants.CURRVAL) {
3261 expr = new SQLSequenceExpr(cast(SQLIdentifierExpr) expr, SQLSequenceExpr.Function.CurrVal);
3262 } else if (name_hash_lower == FnvHash.Constants.PREVVAL) {
3263 expr = new SQLSequenceExpr(cast(SQLIdentifierExpr) expr, SQLSequenceExpr.Function.PrevVal);
3264 } else {
3265 expr = new SQLPropertyExpr(expr, name, name_hash_lower);
3266 }
3267 }
3268 }
3269
3270 if (token == Token.COMMA) {
3271 return new SQLSelectItem(expr, null, connectByRoot);
3272 }
3273
3274 if (token == Token.AS) {
3275 lexer.nextToken();
3276 string as = null;
3277 if (lexer.token != Token.COMMA && lexer.token != Token.FROM) {
3278 as = lexer.stringVal();
3279
3280 lexer.nextTokenComma();
3281
3282 if (lexer.token == Token.DOT) {
3283 lexer.nextToken();
3284 as ~= '.' ~ lexer.stringVal();
3285 lexer.nextToken();
3286 }
3287 }
3288
3289 return new SQLSelectItem(expr, as, connectByRoot);
3290 }
3291
3292 if (token == Token.LITERAL_ALIAS) {
3293 string as = lexer.stringVal();
3294 lexer.nextTokenComma();
3295 return new SQLSelectItem(expr, as, connectByRoot);
3296 }
3297
3298 if ((token == Token.IDENTIFIER && hash_lower != FnvHash.Constants.CURRENT)
3299 || token == Token.MODEL) {
3300 string as;
3301 if (lexer.hash_lower == FnvHash.Constants.FORCE && DBType.MYSQL.name == (dbType)) {
3302 string force = lexer.stringVal();
3303
3304 Lexer.SavePoint savePoint = lexer.mark();
3305 lexer.nextToken();
3306
3307 if (lexer.token == Token.PARTITION) {
3308 lexer.reset(savePoint);
3309 as = null;
3310 } else {
3311 as = force;
3312 lexer.nextTokenComma();
3313 }
3314 } else {
3315 as = lexer.stringVal();
3316 lexer.nextTokenComma();
3317 }
3318 return new SQLSelectItem(expr, as, connectByRoot);
3319 }
3320
3321 if (token == Token.LPAREN) {
3322 lexer.nextToken();
3323 expr = this.methodRest(expr, false);
3324 } else {
3325 expr = this.primaryRest(expr);
3326 }
3327 expr = this.exprRest(expr);
3328 } else if (token == Token.STAR) {
3329 expr = new SQLAllColumnExpr();
3330 lexer.nextToken();
3331 return new SQLSelectItem(expr, null, connectByRoot);
3332 } else if (token == Token.DO || token == Token.JOIN) {
3333 expr = this.name();
3334 expr = this.exprRest(expr);
3335 } else {
3336 expr = this.expr();
3337 }
3338
3339 string _alias;
3340 switch (lexer.token) {
3341 case Token.FULL:
3342 case Token.MODEL:
3343 case Token.TABLESPACE:
3344 _alias = lexer.stringVal();
3345 lexer.nextToken();
3346 break;
3347 default:
3348 _alias = as();
3349 break;
3350 }
3351
3352 SQLSelectItem selectItem = new SQLSelectItem(expr, _alias, connectByRoot);
3353 if (lexer.token == Token.HINT && !lexer.isEnabled(SQLParserFeature.StrictForWall)) {
3354 string comment = "/*" ~ lexer.stringVal() ~ "*/";
3355 selectItem.addAfterComment(comment);
3356 lexer.nextToken();
3357 }
3358
3359 return selectItem;
3360 }
3361
3362 public SQLExpr parseGroupingSet() {
3363 string tmp = lexer.stringVal();
3364 acceptIdentifier("GROUPING");
3365
3366 SQLGroupingSetExpr expr = new SQLGroupingSetExpr();
3367
3368 if (lexer.token == Token.SET || lexer.identifierEquals(FnvHash.Constants.SET)) {
3369 lexer.nextToken();
3370 } else {
3371 return new SQLIdentifierExpr(tmp);
3372 }
3373
3374 accept(Token.LPAREN);
3375
3376 this.exprList(expr.getParameters(), expr);
3377
3378 accept(Token.RPAREN);
3379
3380 return expr;
3381 }
3382
3383 protected SQLPartition parsePartition() {
3384 throw new ParserException("TODO");
3385 }
3386
3387 public SQLPartitionBy parsePartitionBy() {
3388 throw new ParserException("TODO");
3389 }
3390
3391 public SQLPartitionValue parsePartitionValues() {
3392 if (lexer.token != Token.VALUES) {
3393 return null;
3394 }
3395 lexer.nextToken();
3396
3397 SQLPartitionValue values = null;
3398
3399 if (lexer.token == Token.IN) {
3400 lexer.nextToken();
3401 values = new SQLPartitionValue(SQLPartitionValue.Operator.In);
3402
3403 accept(Token.LPAREN);
3404 this.exprList(values.getItems(), values);
3405 accept(Token.RPAREN);
3406 } else if (lexer.identifierEquals(FnvHash.Constants.LESS)) {
3407 lexer.nextToken();
3408 acceptIdentifier("THAN");
3409
3410 values = new SQLPartitionValue(SQLPartitionValue.Operator.LessThan);
3411
3412 if (lexer.identifierEquals(FnvHash.Constants.MAXVALUE)) {
3413 SQLIdentifierExpr maxValue = new SQLIdentifierExpr(lexer.stringVal());
3414 lexer.nextToken();
3415 maxValue.setParent(values);
3416 values.addItem(maxValue);
3417 } else {
3418 accept(Token.LPAREN);
3419 this.exprList(values.getItems(), values);
3420 accept(Token.RPAREN);
3421 }
3422 } else if (lexer.token == Token.LPAREN) {
3423 values = new SQLPartitionValue(SQLPartitionValue.Operator.List);
3424 lexer.nextToken();
3425 this.exprList(values.getItems(), values);
3426 accept(Token.RPAREN);
3427 }
3428
3429 return values;
3430 }
3431
3432 protected static bool isIdent(SQLExpr expr, string name) {
3433 if (cast(SQLIdentifierExpr)(expr) !is null) {
3434 SQLIdentifierExpr identExpr = cast(SQLIdentifierExpr) expr;
3435 return identExpr.getName().equalsIgnoreCase(name);
3436 }
3437 return false;
3438 }
3439
3440 public SQLLimit parseLimit() {
3441 if (lexer.token == Token.LIMIT) {
3442 lexer.nextTokenValue();
3443
3444 SQLLimit limit = new SQLLimit();
3445
3446 SQLExpr temp;
3447 if (lexer.token == Token.LITERAL_INT) {
3448 temp = new SQLIntegerExpr(lexer.integerValue());
3449 lexer.nextTokenComma();
3450 if (lexer.token != Token.COMMA && lexer.token != Token.EOF && lexer.token != Token.IDENTIFIER) {
3451 temp = this.primaryRest(temp);
3452 temp = this.exprRest(temp);
3453 }
3454 } else {
3455 temp = this.expr();
3456 }
3457
3458 if (lexer.token == (Token.COMMA)) {
3459 limit.setOffset(temp);
3460 lexer.nextTokenValue();
3461
3462 SQLExpr rowCount;
3463 if (lexer.token == Token.LITERAL_INT) {
3464 rowCount = new SQLIntegerExpr(lexer.integerValue());
3465 lexer.nextToken();
3466 if (lexer.token != Token.EOF && lexer.token != Token.IDENTIFIER) {
3467 rowCount = this.primaryRest(rowCount);
3468 rowCount = this.exprRest(rowCount);
3469 }
3470 } else {
3471 rowCount = this.expr();
3472 }
3473
3474 limit.setRowCount(rowCount);
3475 } else if (lexer.identifierEquals(FnvHash.Constants.OFFSET)) {
3476 limit.setRowCount(temp);
3477 lexer.nextToken();
3478 limit.setOffset(this.expr());
3479 } else {
3480 limit.setRowCount(temp);
3481 }
3482 return limit;
3483 }
3484
3485 return null;
3486 }
3487 }