This project has retired. For details please refer to its
Attic page.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 package org.apache.chemistry.opencmis.server.support.query;
29
30 import java.math.BigDecimal;
31 import org.apache.commons.logging.Log;
32 import org.apache.commons.logging.LogFactory;
33
34
35 import org.antlr.runtime.*;
36 import org.antlr.runtime.tree.*;import java.util.Stack;
37 import java.util.List;
38 import java.util.ArrayList;
39
40
41
42
43
44
45
46 public class CmisQueryWalker extends TreeParser {
47 public static final String[] tokenNames = new String[] {
48 "<invalid>", "<EOR>", "<DOWN>", "<UP>", "TABLE", "COL", "SEL_LIST", "IN_LIST", "IN_ANY", "NOT_IN_ANY", "EQ_ANY", "NOT_IN", "NOT_LIKE", "IS_NULL", "IS_NOT_NULL", "ORDER_BY", "SELECT", "FROM", "AS", "JOIN", "INNER", "OUTER", "LEFT", "RIGHT", "ON", "WHERE", "ORDER", "BY", "ASC", "DESC", "IS", "NULL", "AND", "OR", "NOT", "IN", "LIKE", "ANY", "CONTAINS", "SCORE", "IN_FOLDER", "IN_TREE", "TIMESTAMP", "STAR", "LPAR", "RPAR", "COMMA", "DOT", "EQ", "NEQ", "LT", "GT", "LTEQ", "GTEQ", "BOOL_LIT", "Sign", "Digits", "ExactNumLit", "ApproxNumLit", "NUM_LIT", "QUOTE", "BACKSL", "UNDERSCORE", "PERCENT", "ESC", "STRING_LIT", "WS", "TIME_LIT", "ID"
49 };
50 public static final int EOF=-1;
51 public static final int TABLE=4;
52 public static final int COL=5;
53 public static final int SEL_LIST=6;
54 public static final int IN_LIST=7;
55 public static final int IN_ANY=8;
56 public static final int NOT_IN_ANY=9;
57 public static final int EQ_ANY=10;
58 public static final int NOT_IN=11;
59 public static final int NOT_LIKE=12;
60 public static final int IS_NULL=13;
61 public static final int IS_NOT_NULL=14;
62 public static final int ORDER_BY=15;
63 public static final int SELECT=16;
64 public static final int FROM=17;
65 public static final int AS=18;
66 public static final int JOIN=19;
67 public static final int INNER=20;
68 public static final int OUTER=21;
69 public static final int LEFT=22;
70 public static final int RIGHT=23;
71 public static final int ON=24;
72 public static final int WHERE=25;
73 public static final int ORDER=26;
74 public static final int BY=27;
75 public static final int ASC=28;
76 public static final int DESC=29;
77 public static final int IS=30;
78 public static final int NULL=31;
79 public static final int AND=32;
80 public static final int OR=33;
81 public static final int NOT=34;
82 public static final int IN=35;
83 public static final int LIKE=36;
84 public static final int ANY=37;
85 public static final int CONTAINS=38;
86 public static final int SCORE=39;
87 public static final int IN_FOLDER=40;
88 public static final int IN_TREE=41;
89 public static final int TIMESTAMP=42;
90 public static final int STAR=43;
91 public static final int LPAR=44;
92 public static final int RPAR=45;
93 public static final int COMMA=46;
94 public static final int DOT=47;
95 public static final int EQ=48;
96 public static final int NEQ=49;
97 public static final int LT=50;
98 public static final int GT=51;
99 public static final int LTEQ=52;
100 public static final int GTEQ=53;
101 public static final int BOOL_LIT=54;
102 public static final int Sign=55;
103 public static final int Digits=56;
104 public static final int ExactNumLit=57;
105 public static final int ApproxNumLit=58;
106 public static final int NUM_LIT=59;
107 public static final int QUOTE=60;
108 public static final int BACKSL=61;
109 public static final int UNDERSCORE=62;
110 public static final int PERCENT=63;
111 public static final int ESC=64;
112 public static final int STRING_LIT=65;
113 public static final int WS=66;
114 public static final int TIME_LIT=67;
115 public static final int ID=68;
116
117
118
119
120
121 public CmisQueryWalker(TreeNodeStream input) {
122 this(input, new RecognizerSharedState());
123 }
124 public CmisQueryWalker(TreeNodeStream input, RecognizerSharedState state) {
125 super(input, state);
126
127 }
128
129 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
130
131 public void setTreeAdaptor(TreeAdaptor adaptor) {
132 this.adaptor = adaptor;
133 }
134 public TreeAdaptor getTreeAdaptor() {
135 return adaptor;
136 }
137
138 public String[] getTokenNames() { return CmisQueryWalker.tokenNames; }
139 public String getGrammarFileName() { return "org/apache/chemistry/opencmis/server/support/query/CmisQueryWalker.g"; }
140
141
142 private static Log LOG = LogFactory.getLog(CmisQueryWalker.class);
143
144 private QueryObject queryObj;
145 private Tree wherePredicateTree;
146 private boolean doFullTextParse = true;
147
148 public Tree getWherePredicateTree() {
149 return wherePredicateTree;
150 }
151
152 protected void mismatch(IntStream input, int ttype, BitSet follow)
153 throws RecognitionException
154 {
155 throw new MismatchedTokenException(ttype, input);
156 }
157
158 public void recoverFromMismatchedSet(IntStream input, RecognitionException e, antlr.collections.impl.BitSet follow)
159 throws RecognitionException
160 {
161 throw e;
162 }
163
164 public void setDoFullTextParse(boolean value) {
165 doFullTextParse = value;
166 }
167
168 public boolean getDoFullTextParse() {
169 return doFullTextParse;
170 }
171
172 private static CommonTree parseTextSearchPredicate(String expr) throws RecognitionException {
173 String unescapedExpr = StringUtil.unescape(expr.substring(1, expr.length()-1), null);
174 CharStream input = new ANTLRStringStream(unescapedExpr);
175 TokenSource lexer = new TextSearchLexer(input);
176 TokenStream tokens = new CommonTokenStream(lexer);
177 TextSearchParser parser = new TextSearchParser(tokens);
178
179 TextSearchParser.text_search_expression_return parsedStatement = parser.text_search_expression();
180 return (CommonTree) parsedStatement.getTree();
181 }
182
183
184
185 public static class query_return extends TreeRuleReturnScope {
186 CommonTree tree;
187 public Object getTree() { return tree; }
188 };
189
190
191
192 public final CmisQueryWalker.query_return query(QueryObject qo, PredicateWalkerBase pw) throws RecognitionException {
193 CmisQueryWalker.query_return retval = new CmisQueryWalker.query_return();
194 retval.start = input.LT(1);
195
196 CommonTree root_0 = null;
197
198 CommonTree _first_0 = null;
199 CommonTree _last = null;
200
201 CommonTree SELECT1=null;
202 CmisQueryWalker.select_list_return select_list2 = null;
203
204 CmisQueryWalker.from_clause_return from_clause3 = null;
205
206 CmisQueryWalker.order_by_clause_return order_by_clause4 = null;
207
208 CmisQueryWalker.where_clause_return where_clause5 = null;
209
210
211 CommonTree SELECT1_tree=null;
212
213
214 queryObj = qo;
215
216 try {
217
218
219 {
220 root_0 = (CommonTree)adaptor.nil();
221
222 _last = (CommonTree)input.LT(1);
223 {
224 CommonTree _save_last_1 = _last;
225 CommonTree _first_1 = null;
226 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
227 SELECT1=(CommonTree)match(input,SELECT,FOLLOW_SELECT_in_query93);
228 SELECT1_tree = (CommonTree)adaptor.dupNode(SELECT1);
229
230 root_1 = (CommonTree)adaptor.becomeRoot(SELECT1_tree, root_1);
231
232
233
234 match(input, Token.DOWN, null);
235 _last = (CommonTree)input.LT(1);
236 pushFollow(FOLLOW_select_list_in_query95);
237 select_list2=select_list();
238
239 state._fsp--;
240
241 adaptor.addChild(root_1, select_list2.getTree());
242 _last = (CommonTree)input.LT(1);
243 pushFollow(FOLLOW_from_clause_in_query97);
244 from_clause3=from_clause();
245
246 state._fsp--;
247
248 adaptor.addChild(root_1, from_clause3.getTree());
249
250 int alt1=2;
251 switch ( input.LA(1) ) {
252 case ORDER_BY:
253 {
254 alt1=1;
255 }
256 break;
257 }
258
259 switch (alt1) {
260 case 1 :
261
262 {
263 _last = (CommonTree)input.LT(1);
264 pushFollow(FOLLOW_order_by_clause_in_query99);
265 order_by_clause4=order_by_clause();
266
267 state._fsp--;
268
269 adaptor.addChild(root_1, order_by_clause4.getTree());
270
271 }
272 break;
273
274 }
275
276 _last = (CommonTree)input.LT(1);
277 pushFollow(FOLLOW_where_clause_in_query102);
278 where_clause5=where_clause();
279
280 state._fsp--;
281
282 adaptor.addChild(root_1, where_clause5.getTree());
283
284 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
285 }
286
287
288 wherePredicateTree = (where_clause5!=null?((CommonTree)where_clause5.tree):null)==null ? null : (where_clause5!=null?((CommonTree)where_clause5.tree):null).getChild(0);
289 boolean resolved = queryObj.resolveTypes();
290 if (null != pw && null != (where_clause5!=null?((CommonTree)where_clause5.tree):null))
291 pw.walkPredicate(wherePredicateTree);
292
293 if ( !((
294 resolved
295 )) ) {
296 throw new FailedPredicateException(input, "query", "\n resolved\n ");
297 }
298
299 }
300
301 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
302
303 }
304 catch (FailedPredicateException e) {
305
306
307 e.predicateText = queryObj.getErrorMessage();
308 throw e;
309
310 }
311 finally {
312 }
313 return retval;
314 }
315
316
317 public static class select_list_return extends TreeRuleReturnScope {
318 CommonTree tree;
319 public Object getTree() { return tree; }
320 };
321
322
323
324 public final CmisQueryWalker.select_list_return select_list() throws RecognitionException {
325 CmisQueryWalker.select_list_return retval = new CmisQueryWalker.select_list_return();
326 retval.start = input.LT(1);
327
328 CommonTree root_0 = null;
329
330 CommonTree _first_0 = null;
331 CommonTree _last = null;
332
333 CommonTree STAR6=null;
334 CommonTree SEL_LIST7=null;
335 CmisQueryWalker.select_sublist_return select_sublist8 = null;
336
337
338 CommonTree STAR6_tree=null;
339 CommonTree SEL_LIST7_tree=null;
340
341 try {
342
343 int alt3=2;
344 switch ( input.LA(1) ) {
345 case STAR:
346 {
347 alt3=1;
348 }
349 break;
350 case SEL_LIST:
351 {
352 alt3=2;
353 }
354 break;
355 default:
356 NoViableAltException nvae =
357 new NoViableAltException("", 3, 0, input);
358
359 throw nvae;
360 }
361
362 switch (alt3) {
363 case 1 :
364
365 {
366 root_0 = (CommonTree)adaptor.nil();
367
368 _last = (CommonTree)input.LT(1);
369 STAR6=(CommonTree)match(input,STAR,FOLLOW_STAR_in_select_list146);
370 STAR6_tree = (CommonTree)adaptor.dupNode(STAR6);
371
372 adaptor.addChild(root_0, STAR6_tree);
373
374
375 queryObj.addSelectReference(STAR6, new ColumnReference((STAR6!=null?STAR6.getText():null)));
376
377
378 }
379 break;
380 case 2 :
381
382 {
383 root_0 = (CommonTree)adaptor.nil();
384
385 _last = (CommonTree)input.LT(1);
386 {
387 CommonTree _save_last_1 = _last;
388 CommonTree _first_1 = null;
389 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
390 SEL_LIST7=(CommonTree)match(input,SEL_LIST,FOLLOW_SEL_LIST_in_select_list163);
391 SEL_LIST7_tree = (CommonTree)adaptor.dupNode(SEL_LIST7);
392
393 root_1 = (CommonTree)adaptor.becomeRoot(SEL_LIST7_tree, root_1);
394
395
396
397 match(input, Token.DOWN, null);
398
399 int cnt2=0;
400 loop2:
401 do {
402 int alt2=2;
403 switch ( input.LA(1) ) {
404 case COL:
405 case SCORE:
406 case ID:
407 {
408 alt2=1;
409 }
410 break;
411
412 }
413
414 switch (alt2) {
415 case 1 :
416
417 {
418 _last = (CommonTree)input.LT(1);
419 pushFollow(FOLLOW_select_sublist_in_select_list165);
420 select_sublist8=select_sublist();
421
422 state._fsp--;
423
424 adaptor.addChild(root_1, select_sublist8.getTree());
425
426 }
427 break;
428
429 default :
430 if ( cnt2 >= 1 ) break loop2;
431 EarlyExitException eee =
432 new EarlyExitException(2, input);
433 throw eee;
434 }
435 cnt2++;
436 } while (true);
437
438
439 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
440 }
441
442
443 }
444 break;
445
446 }
447 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
448
449 }
450
451 catch (RecognitionException e) {
452 throw e;
453 }
454 finally {
455 }
456 return retval;
457 }
458
459
460 protected static class select_sublist_scope {
461 String current;
462 }
463 protected Stack select_sublist_stack = new Stack();
464
465 public static class select_sublist_return extends TreeRuleReturnScope {
466 CommonTree tree;
467 public Object getTree() { return tree; }
468 };
469
470
471
472 public final CmisQueryWalker.select_sublist_return select_sublist() throws RecognitionException {
473 select_sublist_stack.push(new select_sublist_scope());
474 CmisQueryWalker.select_sublist_return retval = new CmisQueryWalker.select_sublist_return();
475 retval.start = input.LT(1);
476
477 CommonTree root_0 = null;
478
479 CommonTree _first_0 = null;
480 CommonTree _last = null;
481
482 CommonTree DOT11=null;
483 CommonTree STAR12=null;
484 CmisQueryWalker.qualifier_return s = null;
485
486 CmisQueryWalker.value_expression_return value_expression9 = null;
487
488 CmisQueryWalker.column_name_return column_name10 = null;
489
490
491 CommonTree DOT11_tree=null;
492 CommonTree STAR12_tree=null;
493
494 try {
495
496 int alt5=2;
497 switch ( input.LA(1) ) {
498 case COL:
499 case SCORE:
500 {
501 alt5=1;
502 }
503 break;
504 case ID:
505 {
506 alt5=2;
507 }
508 break;
509 default:
510 NoViableAltException nvae =
511 new NoViableAltException("", 5, 0, input);
512
513 throw nvae;
514 }
515
516 switch (alt5) {
517 case 1 :
518
519 {
520 root_0 = (CommonTree)adaptor.nil();
521
522 _last = (CommonTree)input.LT(1);
523 pushFollow(FOLLOW_value_expression_in_select_sublist198);
524 value_expression9=value_expression();
525
526 state._fsp--;
527
528 adaptor.addChild(root_0, value_expression9.getTree());
529
530 int alt4=2;
531 switch ( input.LA(1) ) {
532 case ID:
533 {
534 switch ( input.LA(2) ) {
535 case UP:
536 case COL:
537 case SCORE:
538 case ID:
539 {
540 alt4=1;
541 }
542 break;
543 }
544
545 }
546 break;
547 }
548
549 switch (alt4) {
550 case 1 :
551
552 {
553 _last = (CommonTree)input.LT(1);
554 pushFollow(FOLLOW_column_name_in_select_sublist200);
555 column_name10=column_name();
556
557 state._fsp--;
558
559 adaptor.addChild(root_0, column_name10.getTree());
560
561 }
562 break;
563
564 }
565
566
567
568 queryObj.addSelectReference((value_expression9!=null?((CommonTree)value_expression9.start):null), (value_expression9!=null?value_expression9.result:null));
569
570 if ((column_name10!=null?(input.getTokenStream().toString(
571 input.getTreeAdaptor().getTokenStartIndex(column_name10.start),
572 input.getTreeAdaptor().getTokenStopIndex(column_name10.start))):null) != null) {
573 queryObj.addAlias((column_name10!=null?(input.getTokenStream().toString(
574 input.getTreeAdaptor().getTokenStartIndex(column_name10.start),
575 input.getTreeAdaptor().getTokenStopIndex(column_name10.start))):null), (value_expression9!=null?value_expression9.result:null));
576 }
577
578
579 }
580 break;
581 case 2 :
582
583 {
584 root_0 = (CommonTree)adaptor.nil();
585
586 _last = (CommonTree)input.LT(1);
587 pushFollow(FOLLOW_qualifier_in_select_sublist219);
588 s=qualifier();
589
590 state._fsp--;
591
592 adaptor.addChild(root_0, s.getTree());
593 _last = (CommonTree)input.LT(1);
594 DOT11=(CommonTree)match(input,DOT,FOLLOW_DOT_in_select_sublist221);
595 DOT11_tree = (CommonTree)adaptor.dupNode(DOT11);
596
597 adaptor.addChild(root_0, DOT11_tree);
598
599 _last = (CommonTree)input.LT(1);
600 STAR12=(CommonTree)match(input,STAR,FOLLOW_STAR_in_select_sublist223);
601 STAR12_tree = (CommonTree)adaptor.dupNode(STAR12);
602
603 adaptor.addChild(root_0, STAR12_tree);
604
605
606 queryObj.addSelectReference((s!=null?((CommonTree)s.start):null), new ColumnReference((s!=null?s.value:null), (STAR12!=null?STAR12.getText():null)));
607
608
609 }
610 break;
611
612 }
613 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
614
615 }
616
617 catch (RecognitionException e) {
618 throw e;
619 }
620 finally {
621 select_sublist_stack.pop();
622 }
623 return retval;
624 }
625
626
627 public static class value_expression_return extends TreeRuleReturnScope {
628 public CmisSelector result;
629 CommonTree tree;
630 public Object getTree() { return tree; }
631 };
632
633
634
635 public final CmisQueryWalker.value_expression_return value_expression() throws RecognitionException {
636 CmisQueryWalker.value_expression_return retval = new CmisQueryWalker.value_expression_return();
637 retval.start = input.LT(1);
638
639 CommonTree root_0 = null;
640
641 CommonTree _first_0 = null;
642 CommonTree _last = null;
643
644 CommonTree SCORE14=null;
645 CmisQueryWalker.column_reference_return column_reference13 = null;
646
647
648 CommonTree SCORE14_tree=null;
649
650 try {
651
652 int alt6=2;
653 switch ( input.LA(1) ) {
654 case COL:
655 {
656 alt6=1;
657 }
658 break;
659 case SCORE:
660 {
661 alt6=2;
662 }
663 break;
664 default:
665 NoViableAltException nvae =
666 new NoViableAltException("", 6, 0, input);
667
668 throw nvae;
669 }
670
671 switch (alt6) {
672 case 1 :
673
674 {
675 root_0 = (CommonTree)adaptor.nil();
676
677 _last = (CommonTree)input.LT(1);
678 pushFollow(FOLLOW_column_reference_in_value_expression254);
679 column_reference13=column_reference();
680
681 state._fsp--;
682
683 adaptor.addChild(root_0, column_reference13.getTree());
684
685 retval.result = (column_reference13!=null?column_reference13.result:null);
686
687
688 }
689 break;
690 case 2 :
691
692 {
693 root_0 = (CommonTree)adaptor.nil();
694
695 _last = (CommonTree)input.LT(1);
696 SCORE14=(CommonTree)match(input,SCORE,FOLLOW_SCORE_in_value_expression270);
697 SCORE14_tree = (CommonTree)adaptor.dupNode(SCORE14);
698
699 root_0 = (CommonTree)adaptor.becomeRoot(SCORE14_tree, root_0);
700
701
702 retval.result = new FunctionReference(FunctionReference.CmisQlFunction.SCORE);
703
704
705 }
706 break;
707
708 }
709 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
710
711 }
712
713 catch (RecognitionException e) {
714 throw e;
715 }
716 finally {
717 }
718 return retval;
719 }
720
721
722 public static class column_reference_return extends TreeRuleReturnScope {
723 public ColumnReference result;
724 CommonTree tree;
725 public Object getTree() { return tree; }
726 };
727
728
729
730 public final CmisQueryWalker.column_reference_return column_reference() throws RecognitionException {
731 CmisQueryWalker.column_reference_return retval = new CmisQueryWalker.column_reference_return();
732 retval.start = input.LT(1);
733
734 CommonTree root_0 = null;
735
736 CommonTree _first_0 = null;
737 CommonTree _last = null;
738
739 CommonTree COL15=null;
740 CmisQueryWalker.qualifier_return qualifier16 = null;
741
742 CmisQueryWalker.column_name_return column_name17 = null;
743
744
745 CommonTree COL15_tree=null;
746
747 try {
748
749
750 {
751 root_0 = (CommonTree)adaptor.nil();
752
753 _last = (CommonTree)input.LT(1);
754 {
755 CommonTree _save_last_1 = _last;
756 CommonTree _first_1 = null;
757 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
758 COL15=(CommonTree)match(input,COL,FOLLOW_COL_in_column_reference302);
759 COL15_tree = (CommonTree)adaptor.dupNode(COL15);
760
761 root_1 = (CommonTree)adaptor.becomeRoot(COL15_tree, root_1);
762
763
764
765 match(input, Token.DOWN, null);
766
767 int alt7=2;
768 switch ( input.LA(1) ) {
769 case ID:
770 {
771 switch ( input.LA(2) ) {
772 case ID:
773 {
774 alt7=1;
775 }
776 break;
777 }
778
779 }
780 break;
781 }
782
783 switch (alt7) {
784 case 1 :
785
786 {
787 _last = (CommonTree)input.LT(1);
788 pushFollow(FOLLOW_qualifier_in_column_reference304);
789 qualifier16=qualifier();
790
791 state._fsp--;
792
793 adaptor.addChild(root_1, qualifier16.getTree());
794
795 }
796 break;
797
798 }
799
800 _last = (CommonTree)input.LT(1);
801 pushFollow(FOLLOW_column_name_in_column_reference307);
802 column_name17=column_name();
803
804 state._fsp--;
805
806 adaptor.addChild(root_1, column_name17.getTree());
807
808 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
809 }
810
811
812 retval.result = new ColumnReference((qualifier16!=null?qualifier16.value:null), (column_name17!=null?(input.getTokenStream().toString(
813 input.getTreeAdaptor().getTokenStartIndex(column_name17.start),
814 input.getTreeAdaptor().getTokenStopIndex(column_name17.start))):null));
815
816
817 }
818
819 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
820
821 }
822
823 catch (RecognitionException e) {
824 throw e;
825 }
826 finally {
827 }
828 return retval;
829 }
830
831
832 public static class multi_valued_column_reference_return extends TreeRuleReturnScope {
833 public ColumnReference result;
834 CommonTree tree;
835 public Object getTree() { return tree; }
836 };
837
838
839
840 public final CmisQueryWalker.multi_valued_column_reference_return multi_valued_column_reference() throws RecognitionException {
841 CmisQueryWalker.multi_valued_column_reference_return retval = new CmisQueryWalker.multi_valued_column_reference_return();
842 retval.start = input.LT(1);
843
844 CommonTree root_0 = null;
845
846 CommonTree _first_0 = null;
847 CommonTree _last = null;
848
849 CommonTree COL18=null;
850 CmisQueryWalker.qualifier_return qualifier19 = null;
851
852 CmisQueryWalker.column_name_return column_name20 = null;
853
854
855 CommonTree COL18_tree=null;
856
857 try {
858
859
860 {
861 root_0 = (CommonTree)adaptor.nil();
862
863 _last = (CommonTree)input.LT(1);
864 {
865 CommonTree _save_last_1 = _last;
866 CommonTree _first_1 = null;
867 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
868 COL18=(CommonTree)match(input,COL,FOLLOW_COL_in_multi_valued_column_reference337);
869 COL18_tree = (CommonTree)adaptor.dupNode(COL18);
870
871 root_1 = (CommonTree)adaptor.becomeRoot(COL18_tree, root_1);
872
873
874
875 match(input, Token.DOWN, null);
876
877 int alt8=2;
878 switch ( input.LA(1) ) {
879 case ID:
880 {
881 switch ( input.LA(2) ) {
882 case ID:
883 {
884 alt8=1;
885 }
886 break;
887 }
888
889 }
890 break;
891 }
892
893 switch (alt8) {
894 case 1 :
895
896 {
897 _last = (CommonTree)input.LT(1);
898 pushFollow(FOLLOW_qualifier_in_multi_valued_column_reference339);
899 qualifier19=qualifier();
900
901 state._fsp--;
902
903 adaptor.addChild(root_1, qualifier19.getTree());
904
905 }
906 break;
907
908 }
909
910 _last = (CommonTree)input.LT(1);
911 pushFollow(FOLLOW_column_name_in_multi_valued_column_reference342);
912 column_name20=column_name();
913
914 state._fsp--;
915
916 adaptor.addChild(root_1, column_name20.getTree());
917
918 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
919 }
920
921
922 retval.result = new ColumnReference((qualifier19!=null?qualifier19.value:null), (column_name20!=null?(input.getTokenStream().toString(
923 input.getTreeAdaptor().getTokenStartIndex(column_name20.start),
924 input.getTreeAdaptor().getTokenStopIndex(column_name20.start))):null));
925
926
927 }
928
929 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
930
931 }
932
933 catch (RecognitionException e) {
934 throw e;
935 }
936 finally {
937 }
938 return retval;
939 }
940
941
942 public static class qualifier_return extends TreeRuleReturnScope {
943 public String value;
944 CommonTree tree;
945 public Object getTree() { return tree; }
946 };
947
948
949
950 public final CmisQueryWalker.qualifier_return qualifier() throws RecognitionException {
951 CmisQueryWalker.qualifier_return retval = new CmisQueryWalker.qualifier_return();
952 retval.start = input.LT(1);
953
954 CommonTree root_0 = null;
955
956 CommonTree _first_0 = null;
957 CommonTree _last = null;
958
959 CmisQueryWalker.table_name_return table_name21 = null;
960
961
962
963 try {
964
965
966 {
967 root_0 = (CommonTree)adaptor.nil();
968
969 _last = (CommonTree)input.LT(1);
970 pushFollow(FOLLOW_table_name_in_qualifier373);
971 table_name21=table_name();
972
973 state._fsp--;
974
975 adaptor.addChild(root_0, table_name21.getTree());
976
977 retval.value = (table_name21!=null?(input.getTokenStream().toString(
978 input.getTreeAdaptor().getTokenStartIndex(table_name21.start),
979 input.getTreeAdaptor().getTokenStopIndex(table_name21.start))):null);
980
981
982 }
983
984 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
985
986 }
987
988 catch (RecognitionException e) {
989 throw e;
990 }
991 finally {
992 }
993 return retval;
994 }
995
996
997 public static class from_clause_return extends TreeRuleReturnScope {
998 CommonTree tree;
999 public Object getTree() { return tree; }
1000 };
1001
1002
1003
1004 public final CmisQueryWalker.from_clause_return from_clause() throws RecognitionException {
1005 CmisQueryWalker.from_clause_return retval = new CmisQueryWalker.from_clause_return();
1006 retval.start = input.LT(1);
1007
1008 CommonTree root_0 = null;
1009
1010 CommonTree _first_0 = null;
1011 CommonTree _last = null;
1012
1013 CommonTree FROM22=null;
1014 CmisQueryWalker.table_reference_return table_reference23 = null;
1015
1016
1017 CommonTree FROM22_tree=null;
1018
1019 try {
1020
1021
1022 {
1023 root_0 = (CommonTree)adaptor.nil();
1024
1025 _last = (CommonTree)input.LT(1);
1026 {
1027 CommonTree _save_last_1 = _last;
1028 CommonTree _first_1 = null;
1029 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
1030 FROM22=(CommonTree)match(input,FROM,FOLLOW_FROM_in_from_clause397);
1031 FROM22_tree = (CommonTree)adaptor.dupNode(FROM22);
1032
1033 root_1 = (CommonTree)adaptor.becomeRoot(FROM22_tree, root_1);
1034
1035
1036
1037 match(input, Token.DOWN, null);
1038 _last = (CommonTree)input.LT(1);
1039 pushFollow(FOLLOW_table_reference_in_from_clause399);
1040 table_reference23=table_reference();
1041
1042 state._fsp--;
1043
1044 adaptor.addChild(root_1, table_reference23.getTree());
1045
1046 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
1047 }
1048
1049
1050 }
1051
1052 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1053
1054 }
1055
1056 catch (RecognitionException e) {
1057 throw e;
1058 }
1059 finally {
1060 }
1061 return retval;
1062 }
1063
1064
1065 public static class table_reference_return extends TreeRuleReturnScope {
1066 CommonTree tree;
1067 public Object getTree() { return tree; }
1068 };
1069
1070
1071
1072 public final CmisQueryWalker.table_reference_return table_reference() throws RecognitionException {
1073 CmisQueryWalker.table_reference_return retval = new CmisQueryWalker.table_reference_return();
1074 retval.start = input.LT(1);
1075
1076 CommonTree root_0 = null;
1077
1078 CommonTree _first_0 = null;
1079 CommonTree _last = null;
1080
1081 CmisQueryWalker.one_table_return one_table24 = null;
1082
1083 CmisQueryWalker.table_join_return table_join25 = null;
1084
1085
1086
1087 try {
1088
1089
1090 {
1091 root_0 = (CommonTree)adaptor.nil();
1092
1093 _last = (CommonTree)input.LT(1);
1094 pushFollow(FOLLOW_one_table_in_table_reference416);
1095 one_table24=one_table();
1096
1097 state._fsp--;
1098
1099 adaptor.addChild(root_0, one_table24.getTree());
1100
1101 loop9:
1102 do {
1103 int alt9=2;
1104 switch ( input.LA(1) ) {
1105 case JOIN:
1106 {
1107 alt9=1;
1108 }
1109 break;
1110
1111 }
1112
1113 switch (alt9) {
1114 case 1 :
1115
1116 {
1117 _last = (CommonTree)input.LT(1);
1118 pushFollow(FOLLOW_table_join_in_table_reference418);
1119 table_join25=table_join();
1120
1121 state._fsp--;
1122
1123 adaptor.addChild(root_0, table_join25.getTree());
1124
1125 }
1126 break;
1127
1128 default :
1129 break loop9;
1130 }
1131 } while (true);
1132
1133
1134 }
1135
1136 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1137
1138 }
1139
1140 catch (RecognitionException e) {
1141 throw e;
1142 }
1143 finally {
1144 }
1145 return retval;
1146 }
1147
1148
1149 public static class table_join_return extends TreeRuleReturnScope {
1150 CommonTree tree;
1151 public Object getTree() { return tree; }
1152 };
1153
1154
1155
1156 public final CmisQueryWalker.table_join_return table_join() throws RecognitionException {
1157 CmisQueryWalker.table_join_return retval = new CmisQueryWalker.table_join_return();
1158 retval.start = input.LT(1);
1159
1160 CommonTree root_0 = null;
1161
1162 CommonTree _first_0 = null;
1163 CommonTree _last = null;
1164
1165 CommonTree JOIN26=null;
1166 CmisQueryWalker.join_kind_return join_kind27 = null;
1167
1168 CmisQueryWalker.one_table_return one_table28 = null;
1169
1170 CmisQueryWalker.join_specification_return join_specification29 = null;
1171
1172
1173 CommonTree JOIN26_tree=null;
1174
1175 try {
1176
1177
1178 {
1179 root_0 = (CommonTree)adaptor.nil();
1180
1181 _last = (CommonTree)input.LT(1);
1182 {
1183 CommonTree _save_last_1 = _last;
1184 CommonTree _first_1 = null;
1185 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
1186 JOIN26=(CommonTree)match(input,JOIN,FOLLOW_JOIN_in_table_join436);
1187 JOIN26_tree = (CommonTree)adaptor.dupNode(JOIN26);
1188
1189 root_1 = (CommonTree)adaptor.becomeRoot(JOIN26_tree, root_1);
1190
1191
1192
1193 match(input, Token.DOWN, null);
1194 _last = (CommonTree)input.LT(1);
1195 pushFollow(FOLLOW_join_kind_in_table_join438);
1196 join_kind27=join_kind();
1197
1198 state._fsp--;
1199
1200 adaptor.addChild(root_1, join_kind27.getTree());
1201 _last = (CommonTree)input.LT(1);
1202 pushFollow(FOLLOW_one_table_in_table_join440);
1203 one_table28=one_table();
1204
1205 state._fsp--;
1206
1207 adaptor.addChild(root_1, one_table28.getTree());
1208
1209 int alt10=2;
1210 switch ( input.LA(1) ) {
1211 case ON:
1212 {
1213 alt10=1;
1214 }
1215 break;
1216 }
1217
1218 switch (alt10) {
1219 case 1 :
1220
1221 {
1222 _last = (CommonTree)input.LT(1);
1223 pushFollow(FOLLOW_join_specification_in_table_join442);
1224 join_specification29=join_specification();
1225
1226 state._fsp--;
1227
1228 adaptor.addChild(root_1, join_specification29.getTree());
1229
1230 }
1231 break;
1232
1233 }
1234
1235
1236 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
1237 }
1238
1239
1240 boolean hasSpec = (join_specification29!=null?((CommonTree)join_specification29.tree):null) != null;
1241 queryObj.addJoin((join_kind27!=null?join_kind27.kind:null), (one_table28!=null?one_table28.alias:null), hasSpec);
1242
1243
1244 }
1245
1246 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1247
1248 }
1249
1250 catch (RecognitionException e) {
1251 throw e;
1252 }
1253 finally {
1254 }
1255 return retval;
1256 }
1257
1258
1259 public static class one_table_return extends TreeRuleReturnScope {
1260 public String alias;
1261 CommonTree tree;
1262 public Object getTree() { return tree; }
1263 };
1264
1265
1266
1267 public final CmisQueryWalker.one_table_return one_table() throws RecognitionException {
1268 CmisQueryWalker.one_table_return retval = new CmisQueryWalker.one_table_return();
1269 retval.start = input.LT(1);
1270
1271 CommonTree root_0 = null;
1272
1273 CommonTree _first_0 = null;
1274 CommonTree _last = null;
1275
1276 CommonTree TABLE30=null;
1277 CmisQueryWalker.table_name_return table_name31 = null;
1278
1279 CmisQueryWalker.correlation_name_return correlation_name32 = null;
1280
1281
1282 CommonTree TABLE30_tree=null;
1283
1284 try {
1285
1286
1287 {
1288 root_0 = (CommonTree)adaptor.nil();
1289
1290 _last = (CommonTree)input.LT(1);
1291 {
1292 CommonTree _save_last_1 = _last;
1293 CommonTree _first_1 = null;
1294 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
1295 TABLE30=(CommonTree)match(input,TABLE,FOLLOW_TABLE_in_one_table471);
1296 TABLE30_tree = (CommonTree)adaptor.dupNode(TABLE30);
1297
1298 root_1 = (CommonTree)adaptor.becomeRoot(TABLE30_tree, root_1);
1299
1300
1301
1302 match(input, Token.DOWN, null);
1303 _last = (CommonTree)input.LT(1);
1304 pushFollow(FOLLOW_table_name_in_one_table473);
1305 table_name31=table_name();
1306
1307 state._fsp--;
1308
1309 adaptor.addChild(root_1, table_name31.getTree());
1310
1311 int alt11=2;
1312 switch ( input.LA(1) ) {
1313 case ID:
1314 {
1315 alt11=1;
1316 }
1317 break;
1318 }
1319
1320 switch (alt11) {
1321 case 1 :
1322
1323 {
1324 _last = (CommonTree)input.LT(1);
1325 pushFollow(FOLLOW_correlation_name_in_one_table475);
1326 correlation_name32=correlation_name();
1327
1328 state._fsp--;
1329
1330 adaptor.addChild(root_1, correlation_name32.getTree());
1331
1332 }
1333 break;
1334
1335 }
1336
1337
1338 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
1339 }
1340
1341 if ( !((
1342 (retval.alias = queryObj.addType((correlation_name32!=null?(input.getTokenStream().toString(
1343 input.getTreeAdaptor().getTokenStartIndex(correlation_name32.start),
1344 input.getTreeAdaptor().getTokenStopIndex(correlation_name32.start))):null), (table_name31!=null?(input.getTokenStream().toString(
1345 input.getTreeAdaptor().getTokenStartIndex(table_name31.start),
1346 input.getTreeAdaptor().getTokenStopIndex(table_name31.start))):null))) != null
1347 )) ) {
1348 throw new FailedPredicateException(input, "one_table", "\n ($alias = queryObj.addType($correlation_name.text, $table_name.text)) != null\n ");
1349 }
1350
1351 }
1352
1353 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1354
1355 }
1356 catch (FailedPredicateException e) {
1357
1358
1359 e.predicateText = queryObj.getErrorMessage();
1360 throw e;
1361
1362 }
1363 finally {
1364 }
1365 return retval;
1366 }
1367
1368
1369 public static class join_kind_return extends TreeRuleReturnScope {
1370 public String kind;
1371 CommonTree tree;
1372 public Object getTree() { return tree; }
1373 };
1374
1375
1376
1377 public final CmisQueryWalker.join_kind_return join_kind() throws RecognitionException {
1378 CmisQueryWalker.join_kind_return retval = new CmisQueryWalker.join_kind_return();
1379 retval.start = input.LT(1);
1380
1381 CommonTree root_0 = null;
1382
1383 CommonTree _first_0 = null;
1384 CommonTree _last = null;
1385
1386 CommonTree INNER33=null;
1387 CommonTree LEFT34=null;
1388 CommonTree RIGHT35=null;
1389
1390 CommonTree INNER33_tree=null;
1391 CommonTree LEFT34_tree=null;
1392 CommonTree RIGHT35_tree=null;
1393
1394 try {
1395
1396 int alt12=3;
1397 switch ( input.LA(1) ) {
1398 case INNER:
1399 {
1400 alt12=1;
1401 }
1402 break;
1403 case LEFT:
1404 {
1405 alt12=2;
1406 }
1407 break;
1408 case RIGHT:
1409 {
1410 alt12=3;
1411 }
1412 break;
1413 default:
1414 NoViableAltException nvae =
1415 new NoViableAltException("", 12, 0, input);
1416
1417 throw nvae;
1418 }
1419
1420 switch (alt12) {
1421 case 1 :
1422
1423 {
1424 root_0 = (CommonTree)adaptor.nil();
1425
1426 _last = (CommonTree)input.LT(1);
1427 INNER33=(CommonTree)match(input,INNER,FOLLOW_INNER_in_join_kind520);
1428 INNER33_tree = (CommonTree)adaptor.dupNode(INNER33);
1429
1430 adaptor.addChild(root_0, INNER33_tree);
1431
1432 retval.kind = "INNER";
1433
1434 }
1435 break;
1436 case 2 :
1437
1438 {
1439 root_0 = (CommonTree)adaptor.nil();
1440
1441 _last = (CommonTree)input.LT(1);
1442 LEFT34=(CommonTree)match(input,LEFT,FOLLOW_LEFT_in_join_kind530);
1443 LEFT34_tree = (CommonTree)adaptor.dupNode(LEFT34);
1444
1445 adaptor.addChild(root_0, LEFT34_tree);
1446
1447 retval.kind = "LEFT";
1448
1449 }
1450 break;
1451 case 3 :
1452
1453 {
1454 root_0 = (CommonTree)adaptor.nil();
1455
1456 _last = (CommonTree)input.LT(1);
1457 RIGHT35=(CommonTree)match(input,RIGHT,FOLLOW_RIGHT_in_join_kind541);
1458 RIGHT35_tree = (CommonTree)adaptor.dupNode(RIGHT35);
1459
1460 adaptor.addChild(root_0, RIGHT35_tree);
1461
1462 retval.kind = "RIGHT";
1463
1464 }
1465 break;
1466
1467 }
1468 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1469
1470 }
1471
1472 catch (RecognitionException e) {
1473 throw e;
1474 }
1475 finally {
1476 }
1477 return retval;
1478 }
1479
1480
1481 public static class join_specification_return extends TreeRuleReturnScope {
1482 CommonTree tree;
1483 public Object getTree() { return tree; }
1484 };
1485
1486
1487
1488 public final CmisQueryWalker.join_specification_return join_specification() throws RecognitionException {
1489 CmisQueryWalker.join_specification_return retval = new CmisQueryWalker.join_specification_return();
1490 retval.start = input.LT(1);
1491
1492 CommonTree root_0 = null;
1493
1494 CommonTree _first_0 = null;
1495 CommonTree _last = null;
1496
1497 CommonTree ON36=null;
1498 CommonTree EQ37=null;
1499 CmisQueryWalker.column_reference_return cr1 = null;
1500
1501 CmisQueryWalker.column_reference_return cr2 = null;
1502
1503
1504 CommonTree ON36_tree=null;
1505 CommonTree EQ37_tree=null;
1506
1507 try {
1508
1509
1510 {
1511 root_0 = (CommonTree)adaptor.nil();
1512
1513 _last = (CommonTree)input.LT(1);
1514 {
1515 CommonTree _save_last_1 = _last;
1516 CommonTree _first_1 = null;
1517 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
1518 ON36=(CommonTree)match(input,ON,FOLLOW_ON_in_join_specification560);
1519 ON36_tree = (CommonTree)adaptor.dupNode(ON36);
1520
1521 root_1 = (CommonTree)adaptor.becomeRoot(ON36_tree, root_1);
1522
1523
1524
1525 match(input, Token.DOWN, null);
1526 _last = (CommonTree)input.LT(1);
1527 pushFollow(FOLLOW_column_reference_in_join_specification564);
1528 cr1=column_reference();
1529
1530 state._fsp--;
1531
1532 adaptor.addChild(root_1, cr1.getTree());
1533 _last = (CommonTree)input.LT(1);
1534 EQ37=(CommonTree)match(input,EQ,FOLLOW_EQ_in_join_specification566);
1535 EQ37_tree = (CommonTree)adaptor.dupNode(EQ37);
1536
1537 adaptor.addChild(root_1, EQ37_tree);
1538
1539 _last = (CommonTree)input.LT(1);
1540 pushFollow(FOLLOW_column_reference_in_join_specification570);
1541 cr2=column_reference();
1542
1543 state._fsp--;
1544
1545 adaptor.addChild(root_1, cr2.getTree());
1546
1547 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
1548 }
1549
1550
1551 queryObj.addJoinReference((cr1!=null?((CommonTree)cr1.start):null), (cr1!=null?cr1.result:null));
1552 queryObj.addJoinReference((cr2!=null?((CommonTree)cr2.start):null), (cr2!=null?cr2.result:null));
1553
1554
1555 }
1556
1557 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1558
1559 }
1560
1561 catch (RecognitionException e) {
1562 throw e;
1563 }
1564 finally {
1565 }
1566 return retval;
1567 }
1568
1569
1570 public static class where_clause_return extends TreeRuleReturnScope {
1571 CommonTree tree;
1572 public Object getTree() { return tree; }
1573 };
1574
1575
1576
1577 public final CmisQueryWalker.where_clause_return where_clause() throws RecognitionException {
1578 CmisQueryWalker.where_clause_return retval = new CmisQueryWalker.where_clause_return();
1579 retval.start = input.LT(1);
1580
1581 CommonTree root_0 = null;
1582
1583 CommonTree _first_0 = null;
1584 CommonTree _last = null;
1585
1586 CommonTree WHERE38=null;
1587 CmisQueryWalker.search_condition_return search_condition39 = null;
1588
1589
1590 CommonTree WHERE38_tree=null;
1591
1592 try {
1593
1594 int alt13=2;
1595 switch ( input.LA(1) ) {
1596 case WHERE:
1597 {
1598 alt13=1;
1599 }
1600 break;
1601 case UP:
1602 {
1603 alt13=2;
1604 }
1605 break;
1606 default:
1607 NoViableAltException nvae =
1608 new NoViableAltException("", 13, 0, input);
1609
1610 throw nvae;
1611 }
1612
1613 switch (alt13) {
1614 case 1 :
1615
1616 {
1617 root_0 = (CommonTree)adaptor.nil();
1618
1619 _last = (CommonTree)input.LT(1);
1620 {
1621 CommonTree _save_last_1 = _last;
1622 CommonTree _first_1 = null;
1623 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
1624 WHERE38=(CommonTree)match(input,WHERE,FOLLOW_WHERE_in_where_clause596);
1625 WHERE38_tree = (CommonTree)adaptor.dupNode(WHERE38);
1626
1627 root_1 = (CommonTree)adaptor.becomeRoot(WHERE38_tree, root_1);
1628
1629
1630
1631 match(input, Token.DOWN, null);
1632 _last = (CommonTree)input.LT(1);
1633 pushFollow(FOLLOW_search_condition_in_where_clause598);
1634 search_condition39=search_condition();
1635
1636 state._fsp--;
1637
1638 adaptor.addChild(root_1, search_condition39.getTree());
1639
1640 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
1641 }
1642
1643
1644 }
1645 break;
1646 case 2 :
1647
1648 {
1649 root_0 = (CommonTree)adaptor.nil();
1650
1651 }
1652 break;
1653
1654 }
1655 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
1656
1657 }
1658
1659 catch (RecognitionException e) {
1660 throw e;
1661 }
1662 finally {
1663 }
1664 return retval;
1665 }
1666
1667
1668 public static class search_condition_return extends TreeRuleReturnScope {
1669 CommonTree tree;
1670 public Object getTree() { return tree; }
1671 };
1672
1673
1674
1675 public final CmisQueryWalker.search_condition_return search_condition() throws RecognitionException {
1676 CmisQueryWalker.search_condition_return retval = new CmisQueryWalker.search_condition_return();
1677 retval.start = input.LT(1);
1678
1679 CommonTree root_0 = null;
1680
1681 CommonTree _first_0 = null;
1682 CommonTree _last = null;
1683
1684 CommonTree OR40=null;
1685 CommonTree AND41=null;
1686 CommonTree NOT42=null;
1687 CommonTree EQ44=null;
1688 CommonTree NEQ47=null;
1689 CommonTree LT50=null;
1690 CommonTree GT53=null;
1691 CommonTree GTEQ56=null;
1692 CommonTree LTEQ59=null;
1693 CommonTree LIKE62=null;
1694 CommonTree NOT_LIKE65=null;
1695 CommonTree IS_NULL68=null;
1696 CommonTree IS_NOT_NULL70=null;
1697 CommonTree EQ_ANY72=null;
1698 CommonTree IN_ANY74=null;
1699 CommonTree NOT_IN_ANY76=null;
1700 CommonTree CONTAINS78=null;
1701 CommonTree IN_FOLDER81=null;
1702 CommonTree IN_TREE84=null;
1703 CommonTree IN87=null;
1704 CommonTree NOT_IN90=null;
1705 CmisQueryWalker.search_condition_return s1 = null;
1706
1707 CmisQueryWalker.search_condition_return s2 = null;
1708
1709 CmisQueryWalker.multi_valued_column_reference_return mvcr = null;
1710
1711 CmisQueryWalker.search_condition_return search_condition43 = null;
1712
1713 CmisQueryWalker.search_condition_return search_condition45 = null;
1714
1715 CmisQueryWalker.search_condition_return search_condition46 = null;
1716
1717 CmisQueryWalker.search_condition_return search_condition48 = null;
1718
1719 CmisQueryWalker.search_condition_return search_condition49 = null;
1720
1721 CmisQueryWalker.search_condition_return search_condition51 = null;
1722
1723 CmisQueryWalker.search_condition_return search_condition52 = null;
1724
1725 CmisQueryWalker.search_condition_return search_condition54 = null;
1726
1727 CmisQueryWalker.search_condition_return search_condition55 = null;
1728
1729 CmisQueryWalker.search_condition_return search_condition57 = null;
1730
1731 CmisQueryWalker.search_condition_return search_condition58 = null;
1732
1733 CmisQueryWalker.search_condition_return search_condition60 = null;
1734
1735 CmisQueryWalker.search_condition_return search_condition61 = null;
1736
1737 CmisQueryWalker.search_condition_return search_condition63 = null;
1738
1739 CmisQueryWalker.search_condition_return search_condition64 = null;
1740
1741 CmisQueryWalker.search_condition_return search_condition66 = null;
1742
1743 CmisQueryWalker.search_condition_return search_condition67 = null;
1744
1745 CmisQueryWalker.search_condition_return search_condition69 = null;
1746
1747 CmisQueryWalker.search_condition_return search_condition71 = null;
1748
1749 CmisQueryWalker.literal_return literal73 = null;
1750
1751 CmisQueryWalker.in_value_list_return in_value_list75 = null;
1752
1753 CmisQueryWalker.in_value_list_return in_value_list77 = null;
1754
1755 CmisQueryWalker.qualifier_return qualifier79 = null;
1756
1757 CmisQueryWalker.text_search_expression_return text_search_expression80 = null;
1758
1759 CmisQueryWalker.qualifier_return qualifier82 = null;
1760
1761 CmisQueryWalker.search_condition_return search_condition83 = null;
1762
1763 CmisQueryWalker.qualifier_return qualifier85 = null;
1764
1765 CmisQueryWalker.search_condition_return search_condition86 = null;
1766
1767 CmisQueryWalker.column_reference_return column_reference88 = null;
1768
1769 CmisQueryWalker.in_value_list_return in_value_list89 = null;
1770
1771 CmisQueryWalker.column_reference_return column_reference91 = null;
1772
1773 CmisQueryWalker.in_value_list_return in_value_list92 = null;
1774
1775 CmisQueryWalker.value_expression_return value_expression93 = null;
1776
1777 CmisQueryWalker.literal_return literal94 = null;
1778
1779
1780 CommonTree OR40_tree=null;
1781 CommonTree AND41_tree=null;
1782 CommonTree NOT42_tree=null;
1783 CommonTree EQ44_tree=null;
1784 CommonTree NEQ47_tree=null;
1785 CommonTree LT50_tree=null;
1786 CommonTree GT53_tree=null;
1787 CommonTree GTEQ56_tree=null;
1788 CommonTree LTEQ59_tree=null;
1789 CommonTree LIKE62_tree=null;
1790 CommonTree NOT_LIKE65_tree=null;
1791 CommonTree IS_NULL68_tree=null;
1792 CommonTree IS_NOT_NULL70_tree=null;
1793 CommonTree EQ_ANY72_tree=null;
1794 CommonTree IN_ANY74_tree=null;
1795 CommonTree NOT_IN_ANY76_tree=null;
1796 CommonTree CONTAINS78_tree=null;
1797 CommonTree IN_FOLDER81_tree=null;
1798 CommonTree IN_TREE84_tree=null;
1799 CommonTree IN87_tree=null;
1800 CommonTree NOT_IN90_tree=null;
1801
1802
1803 List<Object> listLiterals;
1804
1805 try {
1806
1807 int alt17=23;
1808 switch ( input.LA(1) ) {
1809 case OR:
1810 {
1811 alt17=1;
1812 }
1813 break;
1814 case AND:
1815 {
1816 alt17=2;
1817 }
1818 break;
1819 case NOT:
1820 {
1821 alt17=3;
1822 }
1823 break;
1824 case EQ:
1825 {
1826 alt17=4;
1827 }
1828 break;
1829 case NEQ:
1830 {
1831 alt17=5;
1832 }
1833 break;
1834 case LT:
1835 {
1836 alt17=6;
1837 }
1838 break;
1839 case GT:
1840 {
1841 alt17=7;
1842 }
1843 break;
1844 case GTEQ:
1845 {
1846 alt17=8;
1847 }
1848 break;
1849 case LTEQ:
1850 {
1851 alt17=9;
1852 }
1853 break;
1854 case LIKE:
1855 {
1856 alt17=10;
1857 }
1858 break;
1859 case NOT_LIKE:
1860 {
1861 alt17=11;
1862 }
1863 break;
1864 case IS_NULL:
1865 {
1866 alt17=12;
1867 }
1868 break;
1869 case IS_NOT_NULL:
1870 {
1871 alt17=13;
1872 }
1873 break;
1874 case EQ_ANY:
1875 {
1876 alt17=14;
1877 }
1878 break;
1879 case IN_ANY:
1880 {
1881 alt17=15;
1882 }
1883 break;
1884 case NOT_IN_ANY:
1885 {
1886 alt17=16;
1887 }
1888 break;
1889 case CONTAINS:
1890 {
1891 alt17=17;
1892 }
1893 break;
1894 case IN_FOLDER:
1895 {
1896 alt17=18;
1897 }
1898 break;
1899 case IN_TREE:
1900 {
1901 alt17=19;
1902 }
1903 break;
1904 case IN:
1905 {
1906 alt17=20;
1907 }
1908 break;
1909 case NOT_IN:
1910 {
1911 alt17=21;
1912 }
1913 break;
1914 case COL:
1915 case SCORE:
1916 {
1917 alt17=22;
1918 }
1919 break;
1920 case BOOL_LIT:
1921 case NUM_LIT:
1922 case STRING_LIT:
1923 case TIME_LIT:
1924 {
1925 alt17=23;
1926 }
1927 break;
1928 default:
1929 NoViableAltException nvae =
1930 new NoViableAltException("", 17, 0, input);
1931
1932 throw nvae;
1933 }
1934
1935 switch (alt17) {
1936 case 1 :
1937
1938 {
1939 root_0 = (CommonTree)adaptor.nil();
1940
1941 _last = (CommonTree)input.LT(1);
1942 {
1943 CommonTree _save_last_1 = _last;
1944 CommonTree _first_1 = null;
1945 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
1946 OR40=(CommonTree)match(input,OR,FOLLOW_OR_in_search_condition629);
1947 OR40_tree = (CommonTree)adaptor.dupNode(OR40);
1948
1949 root_1 = (CommonTree)adaptor.becomeRoot(OR40_tree, root_1);
1950
1951
1952
1953 match(input, Token.DOWN, null);
1954 _last = (CommonTree)input.LT(1);
1955 pushFollow(FOLLOW_search_condition_in_search_condition633);
1956 s1=search_condition();
1957
1958 state._fsp--;
1959
1960 adaptor.addChild(root_1, s1.getTree());
1961 _last = (CommonTree)input.LT(1);
1962 pushFollow(FOLLOW_search_condition_in_search_condition637);
1963 s2=search_condition();
1964
1965 state._fsp--;
1966
1967 adaptor.addChild(root_1, s2.getTree());
1968
1969 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
1970 }
1971
1972
1973 }
1974 break;
1975 case 2 :
1976
1977 {
1978 root_0 = (CommonTree)adaptor.nil();
1979
1980 _last = (CommonTree)input.LT(1);
1981 {
1982 CommonTree _save_last_1 = _last;
1983 CommonTree _first_1 = null;
1984 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
1985 AND41=(CommonTree)match(input,AND,FOLLOW_AND_in_search_condition647);
1986 AND41_tree = (CommonTree)adaptor.dupNode(AND41);
1987
1988 root_1 = (CommonTree)adaptor.becomeRoot(AND41_tree, root_1);
1989
1990
1991
1992 match(input, Token.DOWN, null);
1993 _last = (CommonTree)input.LT(1);
1994 pushFollow(FOLLOW_search_condition_in_search_condition651);
1995 s1=search_condition();
1996
1997 state._fsp--;
1998
1999 adaptor.addChild(root_1, s1.getTree());
2000 _last = (CommonTree)input.LT(1);
2001 pushFollow(FOLLOW_search_condition_in_search_condition655);
2002 s2=search_condition();
2003
2004 state._fsp--;
2005
2006 adaptor.addChild(root_1, s2.getTree());
2007
2008 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2009 }
2010
2011
2012 }
2013 break;
2014 case 3 :
2015
2016 {
2017 root_0 = (CommonTree)adaptor.nil();
2018
2019 _last = (CommonTree)input.LT(1);
2020 {
2021 CommonTree _save_last_1 = _last;
2022 CommonTree _first_1 = null;
2023 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2024 NOT42=(CommonTree)match(input,NOT,FOLLOW_NOT_in_search_condition665);
2025 NOT42_tree = (CommonTree)adaptor.dupNode(NOT42);
2026
2027 root_1 = (CommonTree)adaptor.becomeRoot(NOT42_tree, root_1);
2028
2029
2030
2031 match(input, Token.DOWN, null);
2032 _last = (CommonTree)input.LT(1);
2033 pushFollow(FOLLOW_search_condition_in_search_condition667);
2034 search_condition43=search_condition();
2035
2036 state._fsp--;
2037
2038 adaptor.addChild(root_1, search_condition43.getTree());
2039
2040 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2041 }
2042
2043
2044 }
2045 break;
2046 case 4 :
2047
2048 {
2049 root_0 = (CommonTree)adaptor.nil();
2050
2051 _last = (CommonTree)input.LT(1);
2052 {
2053 CommonTree _save_last_1 = _last;
2054 CommonTree _first_1 = null;
2055 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2056 EQ44=(CommonTree)match(input,EQ,FOLLOW_EQ_in_search_condition677);
2057 EQ44_tree = (CommonTree)adaptor.dupNode(EQ44);
2058
2059 root_1 = (CommonTree)adaptor.becomeRoot(EQ44_tree, root_1);
2060
2061
2062
2063 match(input, Token.DOWN, null);
2064 _last = (CommonTree)input.LT(1);
2065 pushFollow(FOLLOW_search_condition_in_search_condition679);
2066 search_condition45=search_condition();
2067
2068 state._fsp--;
2069
2070 adaptor.addChild(root_1, search_condition45.getTree());
2071 _last = (CommonTree)input.LT(1);
2072 pushFollow(FOLLOW_search_condition_in_search_condition681);
2073 search_condition46=search_condition();
2074
2075 state._fsp--;
2076
2077 adaptor.addChild(root_1, search_condition46.getTree());
2078
2079 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2080 }
2081
2082
2083 }
2084 break;
2085 case 5 :
2086
2087 {
2088 root_0 = (CommonTree)adaptor.nil();
2089
2090 _last = (CommonTree)input.LT(1);
2091 {
2092 CommonTree _save_last_1 = _last;
2093 CommonTree _first_1 = null;
2094 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2095 NEQ47=(CommonTree)match(input,NEQ,FOLLOW_NEQ_in_search_condition691);
2096 NEQ47_tree = (CommonTree)adaptor.dupNode(NEQ47);
2097
2098 root_1 = (CommonTree)adaptor.becomeRoot(NEQ47_tree, root_1);
2099
2100
2101
2102 match(input, Token.DOWN, null);
2103 _last = (CommonTree)input.LT(1);
2104 pushFollow(FOLLOW_search_condition_in_search_condition693);
2105 search_condition48=search_condition();
2106
2107 state._fsp--;
2108
2109 adaptor.addChild(root_1, search_condition48.getTree());
2110 _last = (CommonTree)input.LT(1);
2111 pushFollow(FOLLOW_search_condition_in_search_condition695);
2112 search_condition49=search_condition();
2113
2114 state._fsp--;
2115
2116 adaptor.addChild(root_1, search_condition49.getTree());
2117
2118 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2119 }
2120
2121
2122 }
2123 break;
2124 case 6 :
2125
2126 {
2127 root_0 = (CommonTree)adaptor.nil();
2128
2129 _last = (CommonTree)input.LT(1);
2130 {
2131 CommonTree _save_last_1 = _last;
2132 CommonTree _first_1 = null;
2133 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2134 LT50=(CommonTree)match(input,LT,FOLLOW_LT_in_search_condition705);
2135 LT50_tree = (CommonTree)adaptor.dupNode(LT50);
2136
2137 root_1 = (CommonTree)adaptor.becomeRoot(LT50_tree, root_1);
2138
2139
2140
2141 match(input, Token.DOWN, null);
2142 _last = (CommonTree)input.LT(1);
2143 pushFollow(FOLLOW_search_condition_in_search_condition707);
2144 search_condition51=search_condition();
2145
2146 state._fsp--;
2147
2148 adaptor.addChild(root_1, search_condition51.getTree());
2149 _last = (CommonTree)input.LT(1);
2150 pushFollow(FOLLOW_search_condition_in_search_condition709);
2151 search_condition52=search_condition();
2152
2153 state._fsp--;
2154
2155 adaptor.addChild(root_1, search_condition52.getTree());
2156
2157 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2158 }
2159
2160
2161 }
2162 break;
2163 case 7 :
2164
2165 {
2166 root_0 = (CommonTree)adaptor.nil();
2167
2168 _last = (CommonTree)input.LT(1);
2169 {
2170 CommonTree _save_last_1 = _last;
2171 CommonTree _first_1 = null;
2172 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2173 GT53=(CommonTree)match(input,GT,FOLLOW_GT_in_search_condition719);
2174 GT53_tree = (CommonTree)adaptor.dupNode(GT53);
2175
2176 root_1 = (CommonTree)adaptor.becomeRoot(GT53_tree, root_1);
2177
2178
2179
2180 match(input, Token.DOWN, null);
2181 _last = (CommonTree)input.LT(1);
2182 pushFollow(FOLLOW_search_condition_in_search_condition721);
2183 search_condition54=search_condition();
2184
2185 state._fsp--;
2186
2187 adaptor.addChild(root_1, search_condition54.getTree());
2188 _last = (CommonTree)input.LT(1);
2189 pushFollow(FOLLOW_search_condition_in_search_condition723);
2190 search_condition55=search_condition();
2191
2192 state._fsp--;
2193
2194 adaptor.addChild(root_1, search_condition55.getTree());
2195
2196 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2197 }
2198
2199
2200 }
2201 break;
2202 case 8 :
2203
2204 {
2205 root_0 = (CommonTree)adaptor.nil();
2206
2207 _last = (CommonTree)input.LT(1);
2208 {
2209 CommonTree _save_last_1 = _last;
2210 CommonTree _first_1 = null;
2211 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2212 GTEQ56=(CommonTree)match(input,GTEQ,FOLLOW_GTEQ_in_search_condition733);
2213 GTEQ56_tree = (CommonTree)adaptor.dupNode(GTEQ56);
2214
2215 root_1 = (CommonTree)adaptor.becomeRoot(GTEQ56_tree, root_1);
2216
2217
2218
2219 match(input, Token.DOWN, null);
2220 _last = (CommonTree)input.LT(1);
2221 pushFollow(FOLLOW_search_condition_in_search_condition735);
2222 search_condition57=search_condition();
2223
2224 state._fsp--;
2225
2226 adaptor.addChild(root_1, search_condition57.getTree());
2227 _last = (CommonTree)input.LT(1);
2228 pushFollow(FOLLOW_search_condition_in_search_condition737);
2229 search_condition58=search_condition();
2230
2231 state._fsp--;
2232
2233 adaptor.addChild(root_1, search_condition58.getTree());
2234
2235 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2236 }
2237
2238
2239 }
2240 break;
2241 case 9 :
2242
2243 {
2244 root_0 = (CommonTree)adaptor.nil();
2245
2246 _last = (CommonTree)input.LT(1);
2247 {
2248 CommonTree _save_last_1 = _last;
2249 CommonTree _first_1 = null;
2250 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2251 LTEQ59=(CommonTree)match(input,LTEQ,FOLLOW_LTEQ_in_search_condition747);
2252 LTEQ59_tree = (CommonTree)adaptor.dupNode(LTEQ59);
2253
2254 root_1 = (CommonTree)adaptor.becomeRoot(LTEQ59_tree, root_1);
2255
2256
2257
2258 match(input, Token.DOWN, null);
2259 _last = (CommonTree)input.LT(1);
2260 pushFollow(FOLLOW_search_condition_in_search_condition749);
2261 search_condition60=search_condition();
2262
2263 state._fsp--;
2264
2265 adaptor.addChild(root_1, search_condition60.getTree());
2266 _last = (CommonTree)input.LT(1);
2267 pushFollow(FOLLOW_search_condition_in_search_condition751);
2268 search_condition61=search_condition();
2269
2270 state._fsp--;
2271
2272 adaptor.addChild(root_1, search_condition61.getTree());
2273
2274 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2275 }
2276
2277
2278 }
2279 break;
2280 case 10 :
2281
2282 {
2283 root_0 = (CommonTree)adaptor.nil();
2284
2285 _last = (CommonTree)input.LT(1);
2286 {
2287 CommonTree _save_last_1 = _last;
2288 CommonTree _first_1 = null;
2289 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2290 LIKE62=(CommonTree)match(input,LIKE,FOLLOW_LIKE_in_search_condition761);
2291 LIKE62_tree = (CommonTree)adaptor.dupNode(LIKE62);
2292
2293 root_1 = (CommonTree)adaptor.becomeRoot(LIKE62_tree, root_1);
2294
2295
2296
2297 match(input, Token.DOWN, null);
2298 _last = (CommonTree)input.LT(1);
2299 pushFollow(FOLLOW_search_condition_in_search_condition763);
2300 search_condition63=search_condition();
2301
2302 state._fsp--;
2303
2304 adaptor.addChild(root_1, search_condition63.getTree());
2305 _last = (CommonTree)input.LT(1);
2306 pushFollow(FOLLOW_search_condition_in_search_condition765);
2307 search_condition64=search_condition();
2308
2309 state._fsp--;
2310
2311 adaptor.addChild(root_1, search_condition64.getTree());
2312
2313 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2314 }
2315
2316
2317 }
2318 break;
2319 case 11 :
2320
2321 {
2322 root_0 = (CommonTree)adaptor.nil();
2323
2324 _last = (CommonTree)input.LT(1);
2325 {
2326 CommonTree _save_last_1 = _last;
2327 CommonTree _first_1 = null;
2328 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2329 NOT_LIKE65=(CommonTree)match(input,NOT_LIKE,FOLLOW_NOT_LIKE_in_search_condition775);
2330 NOT_LIKE65_tree = (CommonTree)adaptor.dupNode(NOT_LIKE65);
2331
2332 root_1 = (CommonTree)adaptor.becomeRoot(NOT_LIKE65_tree, root_1);
2333
2334
2335
2336 match(input, Token.DOWN, null);
2337 _last = (CommonTree)input.LT(1);
2338 pushFollow(FOLLOW_search_condition_in_search_condition777);
2339 search_condition66=search_condition();
2340
2341 state._fsp--;
2342
2343 adaptor.addChild(root_1, search_condition66.getTree());
2344 _last = (CommonTree)input.LT(1);
2345 pushFollow(FOLLOW_search_condition_in_search_condition779);
2346 search_condition67=search_condition();
2347
2348 state._fsp--;
2349
2350 adaptor.addChild(root_1, search_condition67.getTree());
2351
2352 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2353 }
2354
2355
2356 }
2357 break;
2358 case 12 :
2359
2360 {
2361 root_0 = (CommonTree)adaptor.nil();
2362
2363 _last = (CommonTree)input.LT(1);
2364 {
2365 CommonTree _save_last_1 = _last;
2366 CommonTree _first_1 = null;
2367 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2368 IS_NULL68=(CommonTree)match(input,IS_NULL,FOLLOW_IS_NULL_in_search_condition789);
2369 IS_NULL68_tree = (CommonTree)adaptor.dupNode(IS_NULL68);
2370
2371 root_1 = (CommonTree)adaptor.becomeRoot(IS_NULL68_tree, root_1);
2372
2373
2374
2375 match(input, Token.DOWN, null);
2376 _last = (CommonTree)input.LT(1);
2377 pushFollow(FOLLOW_search_condition_in_search_condition791);
2378 search_condition69=search_condition();
2379
2380 state._fsp--;
2381
2382 adaptor.addChild(root_1, search_condition69.getTree());
2383
2384 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2385 }
2386
2387
2388 }
2389 break;
2390 case 13 :
2391
2392 {
2393 root_0 = (CommonTree)adaptor.nil();
2394
2395 _last = (CommonTree)input.LT(1);
2396 {
2397 CommonTree _save_last_1 = _last;
2398 CommonTree _first_1 = null;
2399 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2400 IS_NOT_NULL70=(CommonTree)match(input,IS_NOT_NULL,FOLLOW_IS_NOT_NULL_in_search_condition801);
2401 IS_NOT_NULL70_tree = (CommonTree)adaptor.dupNode(IS_NOT_NULL70);
2402
2403 root_1 = (CommonTree)adaptor.becomeRoot(IS_NOT_NULL70_tree, root_1);
2404
2405
2406
2407 match(input, Token.DOWN, null);
2408 _last = (CommonTree)input.LT(1);
2409 pushFollow(FOLLOW_search_condition_in_search_condition803);
2410 search_condition71=search_condition();
2411
2412 state._fsp--;
2413
2414 adaptor.addChild(root_1, search_condition71.getTree());
2415
2416 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2417 }
2418
2419
2420 }
2421 break;
2422 case 14 :
2423
2424 {
2425 root_0 = (CommonTree)adaptor.nil();
2426
2427 _last = (CommonTree)input.LT(1);
2428 {
2429 CommonTree _save_last_1 = _last;
2430 CommonTree _first_1 = null;
2431 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2432 EQ_ANY72=(CommonTree)match(input,EQ_ANY,FOLLOW_EQ_ANY_in_search_condition813);
2433 EQ_ANY72_tree = (CommonTree)adaptor.dupNode(EQ_ANY72);
2434
2435 root_1 = (CommonTree)adaptor.becomeRoot(EQ_ANY72_tree, root_1);
2436
2437
2438
2439 match(input, Token.DOWN, null);
2440 _last = (CommonTree)input.LT(1);
2441 pushFollow(FOLLOW_literal_in_search_condition815);
2442 literal73=literal();
2443
2444 state._fsp--;
2445
2446 adaptor.addChild(root_1, literal73.getTree());
2447 _last = (CommonTree)input.LT(1);
2448 pushFollow(FOLLOW_multi_valued_column_reference_in_search_condition819);
2449 mvcr=multi_valued_column_reference();
2450
2451 state._fsp--;
2452
2453 adaptor.addChild(root_1, mvcr.getTree());
2454
2455 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2456 }
2457
2458
2459 queryObj.addWhereReference((mvcr!=null?((CommonTree)mvcr.start):null), (mvcr!=null?mvcr.result:null));
2460
2461
2462 }
2463 break;
2464 case 15 :
2465
2466 {
2467 root_0 = (CommonTree)adaptor.nil();
2468
2469 _last = (CommonTree)input.LT(1);
2470 {
2471 CommonTree _save_last_1 = _last;
2472 CommonTree _first_1 = null;
2473 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2474 IN_ANY74=(CommonTree)match(input,IN_ANY,FOLLOW_IN_ANY_in_search_condition837);
2475 IN_ANY74_tree = (CommonTree)adaptor.dupNode(IN_ANY74);
2476
2477 root_1 = (CommonTree)adaptor.becomeRoot(IN_ANY74_tree, root_1);
2478
2479
2480
2481 match(input, Token.DOWN, null);
2482 _last = (CommonTree)input.LT(1);
2483 pushFollow(FOLLOW_multi_valued_column_reference_in_search_condition841);
2484 mvcr=multi_valued_column_reference();
2485
2486 state._fsp--;
2487
2488 adaptor.addChild(root_1, mvcr.getTree());
2489 _last = (CommonTree)input.LT(1);
2490 pushFollow(FOLLOW_in_value_list_in_search_condition843);
2491 in_value_list75=in_value_list();
2492
2493 state._fsp--;
2494
2495 adaptor.addChild(root_1, in_value_list75.getTree());
2496
2497 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2498 }
2499
2500
2501 queryObj.addWhereReference((mvcr!=null?((CommonTree)mvcr.start):null), (mvcr!=null?mvcr.result:null));
2502
2503
2504 }
2505 break;
2506 case 16 :
2507
2508 {
2509 root_0 = (CommonTree)adaptor.nil();
2510
2511 _last = (CommonTree)input.LT(1);
2512 {
2513 CommonTree _save_last_1 = _last;
2514 CommonTree _first_1 = null;
2515 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2516 NOT_IN_ANY76=(CommonTree)match(input,NOT_IN_ANY,FOLLOW_NOT_IN_ANY_in_search_condition862);
2517 NOT_IN_ANY76_tree = (CommonTree)adaptor.dupNode(NOT_IN_ANY76);
2518
2519 root_1 = (CommonTree)adaptor.becomeRoot(NOT_IN_ANY76_tree, root_1);
2520
2521
2522
2523 match(input, Token.DOWN, null);
2524 _last = (CommonTree)input.LT(1);
2525 pushFollow(FOLLOW_multi_valued_column_reference_in_search_condition866);
2526 mvcr=multi_valued_column_reference();
2527
2528 state._fsp--;
2529
2530 adaptor.addChild(root_1, mvcr.getTree());
2531 _last = (CommonTree)input.LT(1);
2532 pushFollow(FOLLOW_in_value_list_in_search_condition868);
2533 in_value_list77=in_value_list();
2534
2535 state._fsp--;
2536
2537 adaptor.addChild(root_1, in_value_list77.getTree());
2538
2539 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2540 }
2541
2542
2543 queryObj.addWhereReference((mvcr!=null?((CommonTree)mvcr.start):null), (mvcr!=null?mvcr.result:null));
2544
2545
2546 }
2547 break;
2548 case 17 :
2549
2550 {
2551 root_0 = (CommonTree)adaptor.nil();
2552
2553 _last = (CommonTree)input.LT(1);
2554 {
2555 CommonTree _save_last_1 = _last;
2556 CommonTree _first_1 = null;
2557 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2558 CONTAINS78=(CommonTree)match(input,CONTAINS,FOLLOW_CONTAINS_in_search_condition886);
2559 CONTAINS78_tree = (CommonTree)adaptor.dupNode(CONTAINS78);
2560
2561 root_1 = (CommonTree)adaptor.becomeRoot(CONTAINS78_tree, root_1);
2562
2563
2564
2565 match(input, Token.DOWN, null);
2566
2567 int alt14=2;
2568 switch ( input.LA(1) ) {
2569 case ID:
2570 {
2571 alt14=1;
2572 }
2573 break;
2574 }
2575
2576 switch (alt14) {
2577 case 1 :
2578
2579 {
2580 _last = (CommonTree)input.LT(1);
2581 pushFollow(FOLLOW_qualifier_in_search_condition888);
2582 qualifier79=qualifier();
2583
2584 state._fsp--;
2585
2586 adaptor.addChild(root_1, qualifier79.getTree());
2587
2588 }
2589 break;
2590
2591 }
2592
2593 _last = (CommonTree)input.LT(1);
2594 pushFollow(FOLLOW_text_search_expression_in_search_condition891);
2595 text_search_expression80=text_search_expression();
2596
2597 state._fsp--;
2598
2599 adaptor.addChild(root_1, text_search_expression80.getTree());
2600
2601 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2602 }
2603
2604
2605 queryObj.addWhereTypeReference((qualifier79!=null?((CommonTree)qualifier79.start):null), (qualifier79!=null?qualifier79.value:null));
2606
2607
2608 }
2609 break;
2610 case 18 :
2611
2612 {
2613 root_0 = (CommonTree)adaptor.nil();
2614
2615 _last = (CommonTree)input.LT(1);
2616 {
2617 CommonTree _save_last_1 = _last;
2618 CommonTree _first_1 = null;
2619 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2620 IN_FOLDER81=(CommonTree)match(input,IN_FOLDER,FOLLOW_IN_FOLDER_in_search_condition909);
2621 IN_FOLDER81_tree = (CommonTree)adaptor.dupNode(IN_FOLDER81);
2622
2623 root_1 = (CommonTree)adaptor.becomeRoot(IN_FOLDER81_tree, root_1);
2624
2625
2626
2627 match(input, Token.DOWN, null);
2628
2629 int alt15=2;
2630 switch ( input.LA(1) ) {
2631 case ID:
2632 {
2633 alt15=1;
2634 }
2635 break;
2636 }
2637
2638 switch (alt15) {
2639 case 1 :
2640
2641 {
2642 _last = (CommonTree)input.LT(1);
2643 pushFollow(FOLLOW_qualifier_in_search_condition911);
2644 qualifier82=qualifier();
2645
2646 state._fsp--;
2647
2648 adaptor.addChild(root_1, qualifier82.getTree());
2649
2650 }
2651 break;
2652
2653 }
2654
2655 _last = (CommonTree)input.LT(1);
2656 pushFollow(FOLLOW_search_condition_in_search_condition914);
2657 search_condition83=search_condition();
2658
2659 state._fsp--;
2660
2661 adaptor.addChild(root_1, search_condition83.getTree());
2662
2663 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2664 }
2665
2666
2667 queryObj.addWhereTypeReference((qualifier82!=null?((CommonTree)qualifier82.start):null), (qualifier82!=null?qualifier82.value:null));
2668
2669
2670 }
2671 break;
2672 case 19 :
2673
2674 {
2675 root_0 = (CommonTree)adaptor.nil();
2676
2677 _last = (CommonTree)input.LT(1);
2678 {
2679 CommonTree _save_last_1 = _last;
2680 CommonTree _first_1 = null;
2681 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2682 IN_TREE84=(CommonTree)match(input,IN_TREE,FOLLOW_IN_TREE_in_search_condition932);
2683 IN_TREE84_tree = (CommonTree)adaptor.dupNode(IN_TREE84);
2684
2685 root_1 = (CommonTree)adaptor.becomeRoot(IN_TREE84_tree, root_1);
2686
2687
2688
2689 match(input, Token.DOWN, null);
2690
2691 int alt16=2;
2692 switch ( input.LA(1) ) {
2693 case ID:
2694 {
2695 alt16=1;
2696 }
2697 break;
2698 }
2699
2700 switch (alt16) {
2701 case 1 :
2702
2703 {
2704 _last = (CommonTree)input.LT(1);
2705 pushFollow(FOLLOW_qualifier_in_search_condition934);
2706 qualifier85=qualifier();
2707
2708 state._fsp--;
2709
2710 adaptor.addChild(root_1, qualifier85.getTree());
2711
2712 }
2713 break;
2714
2715 }
2716
2717 _last = (CommonTree)input.LT(1);
2718 pushFollow(FOLLOW_search_condition_in_search_condition937);
2719 search_condition86=search_condition();
2720
2721 state._fsp--;
2722
2723 adaptor.addChild(root_1, search_condition86.getTree());
2724
2725 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2726 }
2727
2728
2729 queryObj.addWhereTypeReference((qualifier85!=null?((CommonTree)qualifier85.start):null), (qualifier85!=null?qualifier85.value:null));
2730
2731
2732 }
2733 break;
2734 case 20 :
2735
2736 {
2737 root_0 = (CommonTree)adaptor.nil();
2738
2739 _last = (CommonTree)input.LT(1);
2740 {
2741 CommonTree _save_last_1 = _last;
2742 CommonTree _first_1 = null;
2743 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2744 IN87=(CommonTree)match(input,IN,FOLLOW_IN_in_search_condition955);
2745 IN87_tree = (CommonTree)adaptor.dupNode(IN87);
2746
2747 root_1 = (CommonTree)adaptor.becomeRoot(IN87_tree, root_1);
2748
2749
2750
2751 match(input, Token.DOWN, null);
2752 _last = (CommonTree)input.LT(1);
2753 pushFollow(FOLLOW_column_reference_in_search_condition957);
2754 column_reference88=column_reference();
2755
2756 state._fsp--;
2757
2758 adaptor.addChild(root_1, column_reference88.getTree());
2759 _last = (CommonTree)input.LT(1);
2760 pushFollow(FOLLOW_in_value_list_in_search_condition959);
2761 in_value_list89=in_value_list();
2762
2763 state._fsp--;
2764
2765 adaptor.addChild(root_1, in_value_list89.getTree());
2766
2767 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2768 }
2769
2770
2771 queryObj.addWhereReference((column_reference88!=null?((CommonTree)column_reference88.start):null), (column_reference88!=null?column_reference88.result:null));
2772
2773
2774 }
2775 break;
2776 case 21 :
2777
2778 {
2779 root_0 = (CommonTree)adaptor.nil();
2780
2781 _last = (CommonTree)input.LT(1);
2782 {
2783 CommonTree _save_last_1 = _last;
2784 CommonTree _first_1 = null;
2785 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2786 NOT_IN90=(CommonTree)match(input,NOT_IN,FOLLOW_NOT_IN_in_search_condition977);
2787 NOT_IN90_tree = (CommonTree)adaptor.dupNode(NOT_IN90);
2788
2789 root_1 = (CommonTree)adaptor.becomeRoot(NOT_IN90_tree, root_1);
2790
2791
2792
2793 match(input, Token.DOWN, null);
2794 _last = (CommonTree)input.LT(1);
2795 pushFollow(FOLLOW_column_reference_in_search_condition979);
2796 column_reference91=column_reference();
2797
2798 state._fsp--;
2799
2800 adaptor.addChild(root_1, column_reference91.getTree());
2801 _last = (CommonTree)input.LT(1);
2802 pushFollow(FOLLOW_in_value_list_in_search_condition981);
2803 in_value_list92=in_value_list();
2804
2805 state._fsp--;
2806
2807 adaptor.addChild(root_1, in_value_list92.getTree());
2808
2809 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2810 }
2811
2812
2813 queryObj.addWhereReference((column_reference91!=null?((CommonTree)column_reference91.start):null), (column_reference91!=null?column_reference91.result:null));
2814
2815
2816 }
2817 break;
2818 case 22 :
2819
2820 {
2821 root_0 = (CommonTree)adaptor.nil();
2822
2823 _last = (CommonTree)input.LT(1);
2824 pushFollow(FOLLOW_value_expression_in_search_condition998);
2825 value_expression93=value_expression();
2826
2827 state._fsp--;
2828
2829 adaptor.addChild(root_0, value_expression93.getTree());
2830
2831 LOG.debug(" add node to where: " + (value_expression93!=null?((CommonTree)value_expression93.start):null) + " id: " + System.identityHashCode((value_expression93!=null?((CommonTree)value_expression93.start):null)));
2832 queryObj.addWhereReference((value_expression93!=null?((CommonTree)value_expression93.start):null), (value_expression93!=null?value_expression93.result:null));
2833
2834
2835 }
2836 break;
2837 case 23 :
2838
2839 {
2840 root_0 = (CommonTree)adaptor.nil();
2841
2842 _last = (CommonTree)input.LT(1);
2843 pushFollow(FOLLOW_literal_in_search_condition1014);
2844 literal94=literal();
2845
2846 state._fsp--;
2847
2848 adaptor.addChild(root_0, literal94.getTree());
2849
2850 }
2851 break;
2852
2853 }
2854 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2855
2856 }
2857
2858 catch (RecognitionException e) {
2859 throw e;
2860 }
2861 finally {
2862 }
2863 return retval;
2864 }
2865
2866
2867 public static class in_value_list_return extends TreeRuleReturnScope {
2868 public Object inList;
2869 CommonTree tree;
2870 public Object getTree() { return tree; }
2871 };
2872
2873
2874
2875 public final CmisQueryWalker.in_value_list_return in_value_list() throws RecognitionException {
2876 CmisQueryWalker.in_value_list_return retval = new CmisQueryWalker.in_value_list_return();
2877 retval.start = input.LT(1);
2878
2879 CommonTree root_0 = null;
2880
2881 CommonTree _first_0 = null;
2882 CommonTree _last = null;
2883
2884 CommonTree IN_LIST95=null;
2885 CmisQueryWalker.literal_return l = null;
2886
2887
2888 CommonTree IN_LIST95_tree=null;
2889
2890
2891 List<Object> inLiterals = new ArrayList<Object>();
2892
2893 try {
2894
2895
2896 {
2897 root_0 = (CommonTree)adaptor.nil();
2898
2899 _last = (CommonTree)input.LT(1);
2900 {
2901 CommonTree _save_last_1 = _last;
2902 CommonTree _first_1 = null;
2903 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
2904 IN_LIST95=(CommonTree)match(input,IN_LIST,FOLLOW_IN_LIST_in_in_value_list1040);
2905 IN_LIST95_tree = (CommonTree)adaptor.dupNode(IN_LIST95);
2906
2907 root_1 = (CommonTree)adaptor.becomeRoot(IN_LIST95_tree, root_1);
2908
2909
2910
2911 match(input, Token.DOWN, null);
2912
2913 int cnt18=0;
2914 loop18:
2915 do {
2916 int alt18=2;
2917 switch ( input.LA(1) ) {
2918 case BOOL_LIT:
2919 case NUM_LIT:
2920 case STRING_LIT:
2921 case TIME_LIT:
2922 {
2923 alt18=1;
2924 }
2925 break;
2926
2927 }
2928
2929 switch (alt18) {
2930 case 1 :
2931
2932 {
2933 _last = (CommonTree)input.LT(1);
2934 pushFollow(FOLLOW_literal_in_in_value_list1045);
2935 l=literal();
2936
2937 state._fsp--;
2938
2939 adaptor.addChild(root_1, l.getTree());
2940 inLiterals.add((l!=null?l.value:null));
2941
2942 }
2943 break;
2944
2945 default :
2946 if ( cnt18 >= 1 ) break loop18;
2947 EarlyExitException eee =
2948 new EarlyExitException(18, input);
2949 throw eee;
2950 }
2951 cnt18++;
2952 } while (true);
2953
2954
2955 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
2956 }
2957
2958
2959 retval.inList = inLiterals;
2960
2961
2962 }
2963
2964 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
2965
2966 }
2967
2968 catch (RecognitionException e) {
2969 throw e;
2970 }
2971 finally {
2972 }
2973 return retval;
2974 }
2975
2976
2977 public static class text_search_expression_return extends TreeRuleReturnScope {
2978 CommonTree tree;
2979 public Object getTree() { return tree; }
2980 };
2981
2982
2983
2984 public final CmisQueryWalker.text_search_expression_return text_search_expression() throws RecognitionException {
2985 CmisQueryWalker.text_search_expression_return retval = new CmisQueryWalker.text_search_expression_return();
2986 retval.start = input.LT(1);
2987
2988 CommonTree root_0 = null;
2989
2990 CommonTree _first_0 = null;
2991 CommonTree _last = null;
2992
2993 CommonTree STRING_LIT96=null;
2994
2995 CommonTree STRING_LIT96_tree=null;
2996
2997
2998 CommonTree tse = null;
2999
3000 try {
3001
3002
3003 {
3004 root_0 = (CommonTree)adaptor.nil();
3005
3006 _last = (CommonTree)input.LT(1);
3007 STRING_LIT96=(CommonTree)match(input,STRING_LIT,FOLLOW_STRING_LIT_in_text_search_expression1084);
3008 STRING_LIT96_tree = (CommonTree)adaptor.dupNode(STRING_LIT96);
3009
3010 adaptor.addChild(root_0, STRING_LIT96_tree);
3011
3012
3013 if (doFullTextParse) {
3014 tse = parseTextSearchPredicate((STRING_LIT96!=null?STRING_LIT96.getText():null));
3015 }
3016
3017
3018 }
3019
3020 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3021
3022
3023 if (doFullTextParse) {
3024 retval.tree = tse;
3025 }
3026
3027 }
3028
3029 catch (RecognitionException e) {
3030 throw e;
3031 }
3032 finally {
3033 }
3034 return retval;
3035 }
3036
3037
3038 public static class literal_return extends TreeRuleReturnScope {
3039 public Object value;
3040 CommonTree tree;
3041 public Object getTree() { return tree; }
3042 };
3043
3044
3045
3046 public final CmisQueryWalker.literal_return literal() throws RecognitionException {
3047 CmisQueryWalker.literal_return retval = new CmisQueryWalker.literal_return();
3048 retval.start = input.LT(1);
3049
3050 CommonTree root_0 = null;
3051
3052 CommonTree _first_0 = null;
3053 CommonTree _last = null;
3054
3055 CommonTree NUM_LIT97=null;
3056 CommonTree STRING_LIT98=null;
3057 CommonTree TIME_LIT99=null;
3058 CommonTree BOOL_LIT100=null;
3059
3060 CommonTree NUM_LIT97_tree=null;
3061 CommonTree STRING_LIT98_tree=null;
3062 CommonTree TIME_LIT99_tree=null;
3063 CommonTree BOOL_LIT100_tree=null;
3064
3065 try {
3066
3067 int alt19=4;
3068 switch ( input.LA(1) ) {
3069 case NUM_LIT:
3070 {
3071 alt19=1;
3072 }
3073 break;
3074 case STRING_LIT:
3075 {
3076 alt19=2;
3077 }
3078 break;
3079 case TIME_LIT:
3080 {
3081 alt19=3;
3082 }
3083 break;
3084 case BOOL_LIT:
3085 {
3086 alt19=4;
3087 }
3088 break;
3089 default:
3090 NoViableAltException nvae =
3091 new NoViableAltException("", 19, 0, input);
3092
3093 throw nvae;
3094 }
3095
3096 switch (alt19) {
3097 case 1 :
3098
3099 {
3100 root_0 = (CommonTree)adaptor.nil();
3101
3102 _last = (CommonTree)input.LT(1);
3103 NUM_LIT97=(CommonTree)match(input,NUM_LIT,FOLLOW_NUM_LIT_in_literal1113);
3104 NUM_LIT97_tree = (CommonTree)adaptor.dupNode(NUM_LIT97);
3105
3106 adaptor.addChild(root_0, NUM_LIT97_tree);
3107
3108
3109 try {
3110 retval.value = Long.valueOf((NUM_LIT97!=null?NUM_LIT97.getText():null));
3111 } catch (NumberFormatException e) {
3112 retval.value = new BigDecimal((NUM_LIT97!=null?NUM_LIT97.getText():null));
3113 }
3114
3115
3116 }
3117 break;
3118 case 2 :
3119
3120 {
3121 root_0 = (CommonTree)adaptor.nil();
3122
3123 _last = (CommonTree)input.LT(1);
3124 STRING_LIT98=(CommonTree)match(input,STRING_LIT,FOLLOW_STRING_LIT_in_literal1131);
3125 STRING_LIT98_tree = (CommonTree)adaptor.dupNode(STRING_LIT98);
3126
3127 adaptor.addChild(root_0, STRING_LIT98_tree);
3128
3129
3130 String s = (STRING_LIT98!=null?STRING_LIT98.getText():null);
3131 retval.value = s!= null ? s.substring(1, s.length() - 1) : null;
3132
3133
3134 }
3135 break;
3136 case 3 :
3137
3138 {
3139 root_0 = (CommonTree)adaptor.nil();
3140
3141 _last = (CommonTree)input.LT(1);
3142 TIME_LIT99=(CommonTree)match(input,TIME_LIT,FOLLOW_TIME_LIT_in_literal1149);
3143 TIME_LIT99_tree = (CommonTree)adaptor.dupNode(TIME_LIT99);
3144
3145 adaptor.addChild(root_0, TIME_LIT99_tree);
3146
3147
3148 String s = (TIME_LIT99!=null?TIME_LIT99.getText():null);
3149 s = s!= null ? s.substring(s.indexOf('\'') + 1, s.length() - 1) : null;
3150 try {
3151
3152 } catch (IllegalArgumentException e) {
3153 throw new UnwantedTokenException(Token.INVALID_TOKEN_TYPE, input);
3154 }
3155
3156
3157 }
3158 break;
3159 case 4 :
3160
3161 {
3162 root_0 = (CommonTree)adaptor.nil();
3163
3164 _last = (CommonTree)input.LT(1);
3165 BOOL_LIT100=(CommonTree)match(input,BOOL_LIT,FOLLOW_BOOL_LIT_in_literal1167);
3166 BOOL_LIT100_tree = (CommonTree)adaptor.dupNode(BOOL_LIT100);
3167
3168 adaptor.addChild(root_0, BOOL_LIT100_tree);
3169
3170
3171 retval.value = Boolean.valueOf((BOOL_LIT100!=null?BOOL_LIT100.getText():null));
3172
3173
3174 }
3175 break;
3176
3177 }
3178 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3179
3180 }
3181
3182 catch (RecognitionException e) {
3183 throw e;
3184 }
3185 finally {
3186 }
3187 return retval;
3188 }
3189
3190
3191 public static class order_by_clause_return extends TreeRuleReturnScope {
3192 CommonTree tree;
3193 public Object getTree() { return tree; }
3194 };
3195
3196
3197
3198 public final CmisQueryWalker.order_by_clause_return order_by_clause() throws RecognitionException {
3199 CmisQueryWalker.order_by_clause_return retval = new CmisQueryWalker.order_by_clause_return();
3200 retval.start = input.LT(1);
3201
3202 CommonTree root_0 = null;
3203
3204 CommonTree _first_0 = null;
3205 CommonTree _last = null;
3206
3207 CommonTree ORDER_BY101=null;
3208 CmisQueryWalker.sort_specification_return sort_specification102 = null;
3209
3210
3211 CommonTree ORDER_BY101_tree=null;
3212
3213 try {
3214
3215
3216 {
3217 root_0 = (CommonTree)adaptor.nil();
3218
3219 _last = (CommonTree)input.LT(1);
3220 {
3221 CommonTree _save_last_1 = _last;
3222 CommonTree _first_1 = null;
3223 CommonTree root_1 = (CommonTree)adaptor.nil();_last = (CommonTree)input.LT(1);
3224 ORDER_BY101=(CommonTree)match(input,ORDER_BY,FOLLOW_ORDER_BY_in_order_by_clause1194);
3225 ORDER_BY101_tree = (CommonTree)adaptor.dupNode(ORDER_BY101);
3226
3227 root_1 = (CommonTree)adaptor.becomeRoot(ORDER_BY101_tree, root_1);
3228
3229
3230
3231 match(input, Token.DOWN, null);
3232
3233 int cnt20=0;
3234 loop20:
3235 do {
3236 int alt20=2;
3237 switch ( input.LA(1) ) {
3238 case COL:
3239 {
3240 alt20=1;
3241 }
3242 break;
3243
3244 }
3245
3246 switch (alt20) {
3247 case 1 :
3248
3249 {
3250 _last = (CommonTree)input.LT(1);
3251 pushFollow(FOLLOW_sort_specification_in_order_by_clause1196);
3252 sort_specification102=sort_specification();
3253
3254 state._fsp--;
3255
3256 adaptor.addChild(root_1, sort_specification102.getTree());
3257
3258 }
3259 break;
3260
3261 default :
3262 if ( cnt20 >= 1 ) break loop20;
3263 EarlyExitException eee =
3264 new EarlyExitException(20, input);
3265 throw eee;
3266 }
3267 cnt20++;
3268 } while (true);
3269
3270
3271 match(input, Token.UP, null); adaptor.addChild(root_0, root_1);_last = _save_last_1;
3272 }
3273
3274
3275 }
3276
3277 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3278
3279 }
3280
3281 catch (RecognitionException e) {
3282 throw e;
3283 }
3284 finally {
3285 }
3286 return retval;
3287 }
3288
3289
3290 public static class sort_specification_return extends TreeRuleReturnScope {
3291 CommonTree tree;
3292 public Object getTree() { return tree; }
3293 };
3294
3295
3296
3297 public final CmisQueryWalker.sort_specification_return sort_specification() throws RecognitionException {
3298 CmisQueryWalker.sort_specification_return retval = new CmisQueryWalker.sort_specification_return();
3299 retval.start = input.LT(1);
3300
3301 CommonTree root_0 = null;
3302
3303 CommonTree _first_0 = null;
3304 CommonTree _last = null;
3305
3306 CommonTree ASC104=null;
3307 CommonTree DESC106=null;
3308 CmisQueryWalker.column_reference_return column_reference103 = null;
3309
3310 CmisQueryWalker.column_reference_return column_reference105 = null;
3311
3312
3313 CommonTree ASC104_tree=null;
3314 CommonTree DESC106_tree=null;
3315
3316 try {
3317
3318 int alt21=2;
3319 switch ( input.LA(1) ) {
3320 case COL:
3321 {
3322 switch ( input.LA(2) ) {
3323 case DOWN:
3324 {
3325 switch ( input.LA(3) ) {
3326 case ID:
3327 {
3328 switch ( input.LA(4) ) {
3329 case ID:
3330 {
3331 switch ( input.LA(5) ) {
3332 case UP:
3333 {
3334 switch ( input.LA(6) ) {
3335 case ASC:
3336 {
3337 alt21=1;
3338 }
3339 break;
3340 case DESC:
3341 {
3342 alt21=2;
3343 }
3344 break;
3345 default:
3346 NoViableAltException nvae =
3347 new NoViableAltException("", 21, 5, input);
3348
3349 throw nvae;
3350 }
3351
3352 }
3353 break;
3354 default:
3355 NoViableAltException nvae =
3356 new NoViableAltException("", 21, 4, input);
3357
3358 throw nvae;
3359 }
3360
3361 }
3362 break;
3363 case UP:
3364 {
3365 switch ( input.LA(5) ) {
3366 case ASC:
3367 {
3368 alt21=1;
3369 }
3370 break;
3371 case DESC:
3372 {
3373 alt21=2;
3374 }
3375 break;
3376 default:
3377 NoViableAltException nvae =
3378 new NoViableAltException("", 21, 5, input);
3379
3380 throw nvae;
3381 }
3382
3383 }
3384 break;
3385 default:
3386 NoViableAltException nvae =
3387 new NoViableAltException("", 21, 3, input);
3388
3389 throw nvae;
3390 }
3391
3392 }
3393 break;
3394 default:
3395 NoViableAltException nvae =
3396 new NoViableAltException("", 21, 2, input);
3397
3398 throw nvae;
3399 }
3400
3401 }
3402 break;
3403 default:
3404 NoViableAltException nvae =
3405 new NoViableAltException("", 21, 1, input);
3406
3407 throw nvae;
3408 }
3409
3410 }
3411 break;
3412 default:
3413 NoViableAltException nvae =
3414 new NoViableAltException("", 21, 0, input);
3415
3416 throw nvae;
3417 }
3418
3419 switch (alt21) {
3420 case 1 :
3421
3422 {
3423 root_0 = (CommonTree)adaptor.nil();
3424
3425 _last = (CommonTree)input.LT(1);
3426 pushFollow(FOLLOW_column_reference_in_sort_specification1214);
3427 column_reference103=column_reference();
3428
3429 state._fsp--;
3430
3431 adaptor.addChild(root_0, column_reference103.getTree());
3432 _last = (CommonTree)input.LT(1);
3433 ASC104=(CommonTree)match(input,ASC,FOLLOW_ASC_in_sort_specification1216);
3434 ASC104_tree = (CommonTree)adaptor.dupNode(ASC104);
3435
3436 adaptor.addChild(root_0, ASC104_tree);
3437
3438
3439 queryObj.addSortCriterium((column_reference103!=null?((CommonTree)column_reference103.start):null), (column_reference103!=null?column_reference103.result:null), true);
3440
3441
3442 }
3443 break;
3444 case 2 :
3445
3446 {
3447 root_0 = (CommonTree)adaptor.nil();
3448
3449 _last = (CommonTree)input.LT(1);
3450 pushFollow(FOLLOW_column_reference_in_sort_specification1230);
3451 column_reference105=column_reference();
3452
3453 state._fsp--;
3454
3455 adaptor.addChild(root_0, column_reference105.getTree());
3456 _last = (CommonTree)input.LT(1);
3457 DESC106=(CommonTree)match(input,DESC,FOLLOW_DESC_in_sort_specification1232);
3458 DESC106_tree = (CommonTree)adaptor.dupNode(DESC106);
3459
3460 adaptor.addChild(root_0, DESC106_tree);
3461
3462
3463 queryObj.addSortCriterium((column_reference105!=null?((CommonTree)column_reference105.start):null), (column_reference105!=null?column_reference105.result:null), false);
3464
3465
3466 }
3467 break;
3468
3469 }
3470 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3471
3472 }
3473
3474 catch (RecognitionException e) {
3475 throw e;
3476 }
3477 finally {
3478 }
3479 return retval;
3480 }
3481
3482
3483 public static class correlation_name_return extends TreeRuleReturnScope {
3484 CommonTree tree;
3485 public Object getTree() { return tree; }
3486 };
3487
3488
3489
3490 public final CmisQueryWalker.correlation_name_return correlation_name() throws RecognitionException {
3491 CmisQueryWalker.correlation_name_return retval = new CmisQueryWalker.correlation_name_return();
3492 retval.start = input.LT(1);
3493
3494 CommonTree root_0 = null;
3495
3496 CommonTree _first_0 = null;
3497 CommonTree _last = null;
3498
3499 CommonTree ID107=null;
3500
3501 CommonTree ID107_tree=null;
3502
3503 try {
3504
3505
3506 {
3507 root_0 = (CommonTree)adaptor.nil();
3508
3509 _last = (CommonTree)input.LT(1);
3510 ID107=(CommonTree)match(input,ID,FOLLOW_ID_in_correlation_name1254);
3511 ID107_tree = (CommonTree)adaptor.dupNode(ID107);
3512
3513 adaptor.addChild(root_0, ID107_tree);
3514
3515
3516 }
3517
3518 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3519
3520 }
3521
3522 catch (RecognitionException e) {
3523 throw e;
3524 }
3525 finally {
3526 }
3527 return retval;
3528 }
3529
3530
3531 public static class table_name_return extends TreeRuleReturnScope {
3532 CommonTree tree;
3533 public Object getTree() { return tree; }
3534 };
3535
3536
3537
3538 public final CmisQueryWalker.table_name_return table_name() throws RecognitionException {
3539 CmisQueryWalker.table_name_return retval = new CmisQueryWalker.table_name_return();
3540 retval.start = input.LT(1);
3541
3542 CommonTree root_0 = null;
3543
3544 CommonTree _first_0 = null;
3545 CommonTree _last = null;
3546
3547 CommonTree ID108=null;
3548
3549 CommonTree ID108_tree=null;
3550
3551 try {
3552
3553
3554 {
3555 root_0 = (CommonTree)adaptor.nil();
3556
3557 _last = (CommonTree)input.LT(1);
3558 ID108=(CommonTree)match(input,ID,FOLLOW_ID_in_table_name1265);
3559 ID108_tree = (CommonTree)adaptor.dupNode(ID108);
3560
3561 adaptor.addChild(root_0, ID108_tree);
3562
3563
3564 }
3565
3566 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3567
3568 }
3569
3570 catch (RecognitionException e) {
3571 throw e;
3572 }
3573 finally {
3574 }
3575 return retval;
3576 }
3577
3578
3579 public static class column_name_return extends TreeRuleReturnScope {
3580 CommonTree tree;
3581 public Object getTree() { return tree; }
3582 };
3583
3584
3585
3586 public final CmisQueryWalker.column_name_return column_name() throws RecognitionException {
3587 CmisQueryWalker.column_name_return retval = new CmisQueryWalker.column_name_return();
3588 retval.start = input.LT(1);
3589
3590 CommonTree root_0 = null;
3591
3592 CommonTree _first_0 = null;
3593 CommonTree _last = null;
3594
3595 CommonTree ID109=null;
3596
3597 CommonTree ID109_tree=null;
3598
3599 try {
3600
3601
3602 {
3603 root_0 = (CommonTree)adaptor.nil();
3604
3605 _last = (CommonTree)input.LT(1);
3606 ID109=(CommonTree)match(input,ID,FOLLOW_ID_in_column_name1276);
3607 ID109_tree = (CommonTree)adaptor.dupNode(ID109);
3608
3609 adaptor.addChild(root_0, ID109_tree);
3610
3611
3612 }
3613
3614 retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
3615
3616 }
3617
3618 catch (RecognitionException e) {
3619 throw e;
3620 }
3621 finally {
3622 }
3623 return retval;
3624 }
3625
3626
3627
3628
3629
3630
3631
3632 public static final BitSet FOLLOW_SELECT_in_query93 = new BitSet(new long[]{0x0000000000000004L});
3633 public static final BitSet FOLLOW_select_list_in_query95 = new BitSet(new long[]{0x0000000000020000L});
3634 public static final BitSet FOLLOW_from_clause_in_query97 = new BitSet(new long[]{0x0000000002008008L});
3635 public static final BitSet FOLLOW_order_by_clause_in_query99 = new BitSet(new long[]{0x0000000002000008L});
3636 public static final BitSet FOLLOW_where_clause_in_query102 = new BitSet(new long[]{0x0000000000000008L});
3637 public static final BitSet FOLLOW_STAR_in_select_list146 = new BitSet(new long[]{0x0000000000000002L});
3638 public static final BitSet FOLLOW_SEL_LIST_in_select_list163 = new BitSet(new long[]{0x0000000000000004L});
3639 public static final BitSet FOLLOW_select_sublist_in_select_list165 = new BitSet(new long[]{0x0000008000000028L,0x0000000000000010L});
3640 public static final BitSet FOLLOW_value_expression_in_select_sublist198 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000010L});
3641 public static final BitSet FOLLOW_column_name_in_select_sublist200 = new BitSet(new long[]{0x0000000000000002L});
3642 public static final BitSet FOLLOW_qualifier_in_select_sublist219 = new BitSet(new long[]{0x0000800000000000L});
3643 public static final BitSet FOLLOW_DOT_in_select_sublist221 = new BitSet(new long[]{0x0000080000000000L});
3644 public static final BitSet FOLLOW_STAR_in_select_sublist223 = new BitSet(new long[]{0x0000000000000002L});
3645 public static final BitSet FOLLOW_column_reference_in_value_expression254 = new BitSet(new long[]{0x0000000000000002L});
3646 public static final BitSet FOLLOW_SCORE_in_value_expression270 = new BitSet(new long[]{0x0000000000000002L});
3647 public static final BitSet FOLLOW_COL_in_column_reference302 = new BitSet(new long[]{0x0000000000000004L});
3648 public static final BitSet FOLLOW_qualifier_in_column_reference304 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
3649 public static final BitSet FOLLOW_column_name_in_column_reference307 = new BitSet(new long[]{0x0000000000000008L});
3650 public static final BitSet FOLLOW_COL_in_multi_valued_column_reference337 = new BitSet(new long[]{0x0000000000000004L});
3651 public static final BitSet FOLLOW_qualifier_in_multi_valued_column_reference339 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
3652 public static final BitSet FOLLOW_column_name_in_multi_valued_column_reference342 = new BitSet(new long[]{0x0000000000000008L});
3653 public static final BitSet FOLLOW_table_name_in_qualifier373 = new BitSet(new long[]{0x0000000000000002L});
3654 public static final BitSet FOLLOW_FROM_in_from_clause397 = new BitSet(new long[]{0x0000000000000004L});
3655 public static final BitSet FOLLOW_table_reference_in_from_clause399 = new BitSet(new long[]{0x0000000000000008L});
3656 public static final BitSet FOLLOW_one_table_in_table_reference416 = new BitSet(new long[]{0x0000000000080002L});
3657 public static final BitSet FOLLOW_table_join_in_table_reference418 = new BitSet(new long[]{0x0000000000080002L});
3658 public static final BitSet FOLLOW_JOIN_in_table_join436 = new BitSet(new long[]{0x0000000000000004L});
3659 public static final BitSet FOLLOW_join_kind_in_table_join438 = new BitSet(new long[]{0x0000000000000010L});
3660 public static final BitSet FOLLOW_one_table_in_table_join440 = new BitSet(new long[]{0x0000000001000008L});
3661 public static final BitSet FOLLOW_join_specification_in_table_join442 = new BitSet(new long[]{0x0000000000000008L});
3662 public static final BitSet FOLLOW_TABLE_in_one_table471 = new BitSet(new long[]{0x0000000000000004L});
3663 public static final BitSet FOLLOW_table_name_in_one_table473 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000010L});
3664 public static final BitSet FOLLOW_correlation_name_in_one_table475 = new BitSet(new long[]{0x0000000000000008L});
3665 public static final BitSet FOLLOW_INNER_in_join_kind520 = new BitSet(new long[]{0x0000000000000002L});
3666 public static final BitSet FOLLOW_LEFT_in_join_kind530 = new BitSet(new long[]{0x0000000000000002L});
3667 public static final BitSet FOLLOW_RIGHT_in_join_kind541 = new BitSet(new long[]{0x0000000000000002L});
3668 public static final BitSet FOLLOW_ON_in_join_specification560 = new BitSet(new long[]{0x0000000000000004L});
3669 public static final BitSet FOLLOW_column_reference_in_join_specification564 = new BitSet(new long[]{0x0001000000000000L});
3670 public static final BitSet FOLLOW_EQ_in_join_specification566 = new BitSet(new long[]{0x0000000000000020L});
3671 public static final BitSet FOLLOW_column_reference_in_join_specification570 = new BitSet(new long[]{0x0000000000000008L});
3672 public static final BitSet FOLLOW_WHERE_in_where_clause596 = new BitSet(new long[]{0x0000000000000004L});
3673 public static final BitSet FOLLOW_search_condition_in_where_clause598 = new BitSet(new long[]{0x0000000000000008L});
3674 public static final BitSet FOLLOW_OR_in_search_condition629 = new BitSet(new long[]{0x0000000000000004L});
3675 public static final BitSet FOLLOW_search_condition_in_search_condition633 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3676 public static final BitSet FOLLOW_search_condition_in_search_condition637 = new BitSet(new long[]{0x0000000000000008L});
3677 public static final BitSet FOLLOW_AND_in_search_condition647 = new BitSet(new long[]{0x0000000000000004L});
3678 public static final BitSet FOLLOW_search_condition_in_search_condition651 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3679 public static final BitSet FOLLOW_search_condition_in_search_condition655 = new BitSet(new long[]{0x0000000000000008L});
3680 public static final BitSet FOLLOW_NOT_in_search_condition665 = new BitSet(new long[]{0x0000000000000004L});
3681 public static final BitSet FOLLOW_search_condition_in_search_condition667 = new BitSet(new long[]{0x0000000000000008L});
3682 public static final BitSet FOLLOW_EQ_in_search_condition677 = new BitSet(new long[]{0x0000000000000004L});
3683 public static final BitSet FOLLOW_search_condition_in_search_condition679 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3684 public static final BitSet FOLLOW_search_condition_in_search_condition681 = new BitSet(new long[]{0x0000000000000008L});
3685 public static final BitSet FOLLOW_NEQ_in_search_condition691 = new BitSet(new long[]{0x0000000000000004L});
3686 public static final BitSet FOLLOW_search_condition_in_search_condition693 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3687 public static final BitSet FOLLOW_search_condition_in_search_condition695 = new BitSet(new long[]{0x0000000000000008L});
3688 public static final BitSet FOLLOW_LT_in_search_condition705 = new BitSet(new long[]{0x0000000000000004L});
3689 public static final BitSet FOLLOW_search_condition_in_search_condition707 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3690 public static final BitSet FOLLOW_search_condition_in_search_condition709 = new BitSet(new long[]{0x0000000000000008L});
3691 public static final BitSet FOLLOW_GT_in_search_condition719 = new BitSet(new long[]{0x0000000000000004L});
3692 public static final BitSet FOLLOW_search_condition_in_search_condition721 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3693 public static final BitSet FOLLOW_search_condition_in_search_condition723 = new BitSet(new long[]{0x0000000000000008L});
3694 public static final BitSet FOLLOW_GTEQ_in_search_condition733 = new BitSet(new long[]{0x0000000000000004L});
3695 public static final BitSet FOLLOW_search_condition_in_search_condition735 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3696 public static final BitSet FOLLOW_search_condition_in_search_condition737 = new BitSet(new long[]{0x0000000000000008L});
3697 public static final BitSet FOLLOW_LTEQ_in_search_condition747 = new BitSet(new long[]{0x0000000000000004L});
3698 public static final BitSet FOLLOW_search_condition_in_search_condition749 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3699 public static final BitSet FOLLOW_search_condition_in_search_condition751 = new BitSet(new long[]{0x0000000000000008L});
3700 public static final BitSet FOLLOW_LIKE_in_search_condition761 = new BitSet(new long[]{0x0000000000000004L});
3701 public static final BitSet FOLLOW_search_condition_in_search_condition763 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3702 public static final BitSet FOLLOW_search_condition_in_search_condition765 = new BitSet(new long[]{0x0000000000000008L});
3703 public static final BitSet FOLLOW_NOT_LIKE_in_search_condition775 = new BitSet(new long[]{0x0000000000000004L});
3704 public static final BitSet FOLLOW_search_condition_in_search_condition777 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3705 public static final BitSet FOLLOW_search_condition_in_search_condition779 = new BitSet(new long[]{0x0000000000000008L});
3706 public static final BitSet FOLLOW_IS_NULL_in_search_condition789 = new BitSet(new long[]{0x0000000000000004L});
3707 public static final BitSet FOLLOW_search_condition_in_search_condition791 = new BitSet(new long[]{0x0000000000000008L});
3708 public static final BitSet FOLLOW_IS_NOT_NULL_in_search_condition801 = new BitSet(new long[]{0x0000000000000004L});
3709 public static final BitSet FOLLOW_search_condition_in_search_condition803 = new BitSet(new long[]{0x0000000000000008L});
3710 public static final BitSet FOLLOW_EQ_ANY_in_search_condition813 = new BitSet(new long[]{0x0000000000000004L});
3711 public static final BitSet FOLLOW_literal_in_search_condition815 = new BitSet(new long[]{0x0000000000000020L});
3712 public static final BitSet FOLLOW_multi_valued_column_reference_in_search_condition819 = new BitSet(new long[]{0x0000000000000008L});
3713 public static final BitSet FOLLOW_IN_ANY_in_search_condition837 = new BitSet(new long[]{0x0000000000000004L});
3714 public static final BitSet FOLLOW_multi_valued_column_reference_in_search_condition841 = new BitSet(new long[]{0x0000000000000080L});
3715 public static final BitSet FOLLOW_in_value_list_in_search_condition843 = new BitSet(new long[]{0x0000000000000008L});
3716 public static final BitSet FOLLOW_NOT_IN_ANY_in_search_condition862 = new BitSet(new long[]{0x0000000000000004L});
3717 public static final BitSet FOLLOW_multi_valued_column_reference_in_search_condition866 = new BitSet(new long[]{0x0000000000000080L});
3718 public static final BitSet FOLLOW_in_value_list_in_search_condition868 = new BitSet(new long[]{0x0000000000000008L});
3719 public static final BitSet FOLLOW_CONTAINS_in_search_condition886 = new BitSet(new long[]{0x0000000000000004L});
3720 public static final BitSet FOLLOW_qualifier_in_search_condition888 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
3721 public static final BitSet FOLLOW_text_search_expression_in_search_condition891 = new BitSet(new long[]{0x0000000000000008L});
3722 public static final BitSet FOLLOW_IN_FOLDER_in_search_condition909 = new BitSet(new long[]{0x0000000000000004L});
3723 public static final BitSet FOLLOW_qualifier_in_search_condition911 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3724 public static final BitSet FOLLOW_search_condition_in_search_condition914 = new BitSet(new long[]{0x0000000000000008L});
3725 public static final BitSet FOLLOW_IN_TREE_in_search_condition932 = new BitSet(new long[]{0x0000000000000004L});
3726 public static final BitSet FOLLOW_qualifier_in_search_condition934 = new BitSet(new long[]{0x087F03DF00007F20L,0x000000000000000AL});
3727 public static final BitSet FOLLOW_search_condition_in_search_condition937 = new BitSet(new long[]{0x0000000000000008L});
3728 public static final BitSet FOLLOW_IN_in_search_condition955 = new BitSet(new long[]{0x0000000000000004L});
3729 public static final BitSet FOLLOW_column_reference_in_search_condition957 = new BitSet(new long[]{0x0000000000000080L});
3730 public static final BitSet FOLLOW_in_value_list_in_search_condition959 = new BitSet(new long[]{0x0000000000000008L});
3731 public static final BitSet FOLLOW_NOT_IN_in_search_condition977 = new BitSet(new long[]{0x0000000000000004L});
3732 public static final BitSet FOLLOW_column_reference_in_search_condition979 = new BitSet(new long[]{0x0000000000000080L});
3733 public static final BitSet FOLLOW_in_value_list_in_search_condition981 = new BitSet(new long[]{0x0000000000000008L});
3734 public static final BitSet FOLLOW_value_expression_in_search_condition998 = new BitSet(new long[]{0x0000000000000002L});
3735 public static final BitSet FOLLOW_literal_in_search_condition1014 = new BitSet(new long[]{0x0000000000000002L});
3736 public static final BitSet FOLLOW_IN_LIST_in_in_value_list1040 = new BitSet(new long[]{0x0000000000000004L});
3737 public static final BitSet FOLLOW_literal_in_in_value_list1045 = new BitSet(new long[]{0x087F03DF00007F28L,0x000000000000000AL});
3738 public static final BitSet FOLLOW_STRING_LIT_in_text_search_expression1084 = new BitSet(new long[]{0x0000000000000002L});
3739 public static final BitSet FOLLOW_NUM_LIT_in_literal1113 = new BitSet(new long[]{0x0000000000000002L});
3740 public static final BitSet FOLLOW_STRING_LIT_in_literal1131 = new BitSet(new long[]{0x0000000000000002L});
3741 public static final BitSet FOLLOW_TIME_LIT_in_literal1149 = new BitSet(new long[]{0x0000000000000002L});
3742 public static final BitSet FOLLOW_BOOL_LIT_in_literal1167 = new BitSet(new long[]{0x0000000000000002L});
3743 public static final BitSet FOLLOW_ORDER_BY_in_order_by_clause1194 = new BitSet(new long[]{0x0000000000000004L});
3744 public static final BitSet FOLLOW_sort_specification_in_order_by_clause1196 = new BitSet(new long[]{0x0000000000000028L});
3745 public static final BitSet FOLLOW_column_reference_in_sort_specification1214 = new BitSet(new long[]{0x0000000010000000L});
3746 public static final BitSet FOLLOW_ASC_in_sort_specification1216 = new BitSet(new long[]{0x0000000000000002L});
3747 public static final BitSet FOLLOW_column_reference_in_sort_specification1230 = new BitSet(new long[]{0x0000000020000000L});
3748 public static final BitSet FOLLOW_DESC_in_sort_specification1232 = new BitSet(new long[]{0x0000000000000002L});
3749 public static final BitSet FOLLOW_ID_in_correlation_name1254 = new BitSet(new long[]{0x0000000000000002L});
3750 public static final BitSet FOLLOW_ID_in_table_name1265 = new BitSet(new long[]{0x0000000000000002L});
3751 public static final BitSet FOLLOW_ID_in_column_name1276 = new BitSet(new long[]{0x0000000000000002L});
3752
3753 }