00001 // $ANTLR 2.7.2a2 (20020112-1): "sql.g" -> "SQLParser.java"$ 00002 00003 package com.quadcap.sql; 00004 00005 import antlr.TokenBuffer; 00006 import antlr.TokenStreamException; 00007 import antlr.TokenStreamIOException; 00008 import antlr.ANTLRException; 00009 import antlr.LLkParser; 00010 import antlr.Token; 00011 import antlr.TokenStream; 00012 import antlr.RecognitionException; 00013 import antlr.NoViableAltException; 00014 import antlr.MismatchedTokenException; 00015 import antlr.SemanticException; 00016 import antlr.ParserSharedInputState; 00017 import antlr.collections.impl.BitSet; 00018 00019 import java.io.*; 00020 import java.sql.ResultSet; 00021 import java.sql.SQLException; 00022 import java.sql.Types; 00023 import java.util.Vector; 00024 import com.quadcap.sql.types.Type; 00025 import com.quadcap.sql.types.TypeReal; 00026 import com.quadcap.sql.types.*; 00027 00028 public class SQLParser extends antlr.LLkParser 00029 implements SQLTokenTypes 00030 { 00031 00032 Vector parameters = new Vector(); 00033 Session session = null; 00034 Connection qConn = null; 00035 void addParameter(ParameterExpression e) { 00036 parameters.addElement(e); 00037 } 00038 public Vector getParameters() { 00039 return parameters; 00040 } 00041 public SQLParser(Session session, String cmd, boolean esc) { 00042 super((esc 00043 ? (TokenStream)(new JdbcEscapeTokenStream( 00044 new SQLLexer(new StringReader(cmd)))) 00045 : (TokenStream)(new SQLLexer(new StringReader(cmd)))), 2); 00046 this.session = session; 00047 this.qConn = session.getConnection(); 00048 tokenNames = _tokenNames; 00049 } 00050 00051 String fixIdTerm(String s) { 00052 if (s.charAt(0) == '"') { 00053 boolean bad = false; 00054 for (int i = 1; !bad && i < s.length() - 1; i++) { 00055 char c = s.charAt(i); 00056 if (Character.isUpperCase(c) || (i > 1 && Character.isDigit(c) || c == '_')) { 00057 } else { 00058 bad = true; 00059 } 00060 } 00061 if (bad) { 00062 return s; 00063 } else { 00064 return s.substring(1, s.length()-1).toUpperCase(); 00065 } 00066 } else { 00067 return s.toUpperCase(); 00068 } 00069 } 00070 00071 protected SQLParser(TokenBuffer tokenBuf, int k) { 00072 super(tokenBuf,k); 00073 tokenNames = _tokenNames; 00074 } 00075 00076 public SQLParser(TokenBuffer tokenBuf) { 00077 this(tokenBuf,2); 00078 } 00079 00080 protected SQLParser(TokenStream lexer, int k) { 00081 super(lexer,k); 00082 tokenNames = _tokenNames; 00083 } 00084 00085 public SQLParser(TokenStream lexer) { 00086 this(lexer,2); 00087 } 00088 00089 public SQLParser(ParserSharedInputState state) { 00090 super(state,2); 00091 tokenNames = _tokenNames; 00092 } 00093 00094 public final Stmt statement() throws RecognitionException, TokenStreamException { 00095 Stmt s; 00096 00097 00098 s = null; 00099 parameters.clear(); 00100 00101 00102 switch ( LA(1)) { 00103 case LITERAL_alter: 00104 { 00105 s=alterTableStmt(); 00106 break; 00107 } 00108 case LITERAL_delete: 00109 { 00110 s=deleteStmt(); 00111 break; 00112 } 00113 case LITERAL_grant: 00114 { 00115 s=grantStmt(); 00116 break; 00117 } 00118 case LITERAL_insert: 00119 { 00120 s=insertStmt(); 00121 break; 00122 } 00123 case LITERAL_table: 00124 case LPAREN: 00125 case LITERAL_select: 00126 case LITERAL_values: 00127 case ID: 00128 { 00129 s=selectStmt(); 00130 break; 00131 } 00132 case LITERAL_update: 00133 { 00134 s=updateStmt(); 00135 break; 00136 } 00137 case LITERAL_commit: 00138 { 00139 s=commitStmt(); 00140 break; 00141 } 00142 case LITERAL_rollback: 00143 { 00144 s=rollbackStmt(); 00145 break; 00146 } 00147 default: 00148 boolean synPredMatched4 = false; 00149 if (((LA(1)==LITERAL_create) && (LA(2)==LITERAL_unique||LA(2)==LITERAL_index))) { 00150 int _m4 = mark(); 00151 synPredMatched4 = true; 00152 inputState.guessing++; 00153 try { 00154 { 00155 match(LITERAL_create); 00156 { 00157 switch ( LA(1)) { 00158 case LITERAL_unique: 00159 { 00160 match(LITERAL_unique); 00161 break; 00162 } 00163 case LITERAL_index: 00164 { 00165 break; 00166 } 00167 default: 00168 { 00169 throw new NoViableAltException(LT(1), getFilename()); 00170 } 00171 } 00172 } 00173 match(LITERAL_index); 00174 } 00175 } 00176 catch (RecognitionException pe) { 00177 synPredMatched4 = false; 00178 } 00179 rewind(_m4); 00180 inputState.guessing--; 00181 } 00182 if ( synPredMatched4 ) { 00183 s=createIndexStmt(); 00184 } 00185 else { 00186 boolean synPredMatched6 = false; 00187 if (((LA(1)==LITERAL_create) && (LA(2)==LITERAL_schema))) { 00188 int _m6 = mark(); 00189 synPredMatched6 = true; 00190 inputState.guessing++; 00191 try { 00192 { 00193 match(LITERAL_create); 00194 match(LITERAL_schema); 00195 } 00196 } 00197 catch (RecognitionException pe) { 00198 synPredMatched6 = false; 00199 } 00200 rewind(_m6); 00201 inputState.guessing--; 00202 } 00203 if ( synPredMatched6 ) { 00204 s=createSchemaStmt(); 00205 } 00206 else { 00207 boolean synPredMatched9 = false; 00208 if (((LA(1)==LITERAL_create) && (LA(2)==LITERAL_temporary||LA(2)==LITERAL_table||LA(2)==LITERAL_global||LA(2)==LITERAL_local))) { 00209 int _m9 = mark(); 00210 synPredMatched9 = true; 00211 inputState.guessing++; 00212 try { 00213 { 00214 match(LITERAL_create); 00215 { 00216 switch ( LA(1)) { 00217 case LITERAL_temporary: 00218 { 00219 match(LITERAL_temporary); 00220 break; 00221 } 00222 case LITERAL_table: 00223 { 00224 break; 00225 } 00226 default: 00227 { 00228 throw new NoViableAltException(LT(1), getFilename()); 00229 } 00230 } 00231 } 00232 match(LITERAL_table); 00233 } 00234 } 00235 catch (RecognitionException pe) { 00236 synPredMatched9 = false; 00237 } 00238 rewind(_m9); 00239 inputState.guessing--; 00240 } 00241 if ( synPredMatched9 ) { 00242 s=createTableStmt(); 00243 } 00244 else { 00245 boolean synPredMatched11 = false; 00246 if (((LA(1)==LITERAL_create) && (LA(2)==LITERAL_view))) { 00247 int _m11 = mark(); 00248 synPredMatched11 = true; 00249 inputState.guessing++; 00250 try { 00251 { 00252 match(LITERAL_create); 00253 match(LITERAL_view); 00254 } 00255 } 00256 catch (RecognitionException pe) { 00257 synPredMatched11 = false; 00258 } 00259 rewind(_m11); 00260 inputState.guessing--; 00261 } 00262 if ( synPredMatched11 ) { 00263 s=createViewStmt(); 00264 } 00265 else { 00266 boolean synPredMatched14 = false; 00267 if (((LA(1)==LITERAL_drop) && (LA(2)==LITERAL_table||LA(2)==LITERAL_view))) { 00268 int _m14 = mark(); 00269 synPredMatched14 = true; 00270 inputState.guessing++; 00271 try { 00272 { 00273 match(LITERAL_drop); 00274 { 00275 switch ( LA(1)) { 00276 case LITERAL_table: 00277 { 00278 match(LITERAL_table); 00279 break; 00280 } 00281 case LITERAL_view: 00282 { 00283 match(LITERAL_view); 00284 break; 00285 } 00286 default: 00287 { 00288 throw new NoViableAltException(LT(1), getFilename()); 00289 } 00290 } 00291 } 00292 } 00293 } 00294 catch (RecognitionException pe) { 00295 synPredMatched14 = false; 00296 } 00297 rewind(_m14); 00298 inputState.guessing--; 00299 } 00300 if ( synPredMatched14 ) { 00301 s=dropTableStmt(); 00302 } 00303 else { 00304 boolean synPredMatched16 = false; 00305 if (((LA(1)==LITERAL_drop) && (LA(2)==LITERAL_index))) { 00306 int _m16 = mark(); 00307 synPredMatched16 = true; 00308 inputState.guessing++; 00309 try { 00310 { 00311 match(LITERAL_drop); 00312 match(LITERAL_index); 00313 } 00314 } 00315 catch (RecognitionException pe) { 00316 synPredMatched16 = false; 00317 } 00318 rewind(_m16); 00319 inputState.guessing--; 00320 } 00321 if ( synPredMatched16 ) { 00322 s=dropIndexStmt(); 00323 } 00324 else { 00325 throw new NoViableAltException(LT(1), getFilename()); 00326 } 00327 }}}}}} 00328 return s; 00329 } 00330 00331 public final Stmt alterTableStmt() throws RecognitionException, TokenStreamException { 00332 Stmt s; 00333 00334 00335 s = null; 00336 String id = null; 00337 00338 00339 match(LITERAL_alter); 00340 match(LITERAL_table); 00341 id=sqlId(); 00342 if ( inputState.guessing==0 ) { 00343 id = qConn.resolveName(id); 00344 } 00345 { 00346 switch ( LA(1)) { 00347 case LITERAL_alter: 00348 { 00349 s=alterColumn(id); 00350 break; 00351 } 00352 case LITERAL_rename: 00353 { 00354 s=renameTable(id); 00355 break; 00356 } 00357 default: 00358 boolean synPredMatched28 = false; 00359 if (((LA(1)==LITERAL_add) && (LA(2)==LITERAL_unique||LA(2)==LITERAL_constraint||LA(2)==LITERAL_primary||LA(2)==LITERAL_foreign||LA(2)==LITERAL_check))) { 00360 int _m28 = mark(); 00361 synPredMatched28 = true; 00362 inputState.guessing++; 00363 try { 00364 { 00365 match(LITERAL_add); 00366 { 00367 switch ( LA(1)) { 00368 case LITERAL_constraint: 00369 { 00370 match(LITERAL_constraint); 00371 break; 00372 } 00373 case LITERAL_primary: 00374 { 00375 match(LITERAL_primary); 00376 break; 00377 } 00378 case LITERAL_unique: 00379 { 00380 match(LITERAL_unique); 00381 break; 00382 } 00383 case LITERAL_foreign: 00384 { 00385 match(LITERAL_foreign); 00386 break; 00387 } 00388 case LITERAL_check: 00389 { 00390 match(LITERAL_check); 00391 break; 00392 } 00393 default: 00394 { 00395 throw new NoViableAltException(LT(1), getFilename()); 00396 } 00397 } 00398 } 00399 } 00400 } 00401 catch (RecognitionException pe) { 00402 synPredMatched28 = false; 00403 } 00404 rewind(_m28); 00405 inputState.guessing--; 00406 } 00407 if ( synPredMatched28 ) { 00408 s=addConstraint(id); 00409 } 00410 else { 00411 boolean synPredMatched30 = false; 00412 if (((LA(1)==LITERAL_add) && (LA(2)==LITERAL_column||LA(2)==ID))) { 00413 int _m30 = mark(); 00414 synPredMatched30 = true; 00415 inputState.guessing++; 00416 try { 00417 { 00418 match(LITERAL_add); 00419 } 00420 } 00421 catch (RecognitionException pe) { 00422 synPredMatched30 = false; 00423 } 00424 rewind(_m30); 00425 inputState.guessing--; 00426 } 00427 if ( synPredMatched30 ) { 00428 s=addColumn(id); 00429 } 00430 else { 00431 boolean synPredMatched32 = false; 00432 if (((LA(1)==LITERAL_drop) && (LA(2)==LITERAL_constraint))) { 00433 int _m32 = mark(); 00434 synPredMatched32 = true; 00435 inputState.guessing++; 00436 try { 00437 { 00438 match(LITERAL_drop); 00439 match(LITERAL_constraint); 00440 } 00441 } 00442 catch (RecognitionException pe) { 00443 synPredMatched32 = false; 00444 } 00445 rewind(_m32); 00446 inputState.guessing--; 00447 } 00448 if ( synPredMatched32 ) { 00449 s=dropConstraint(id); 00450 } 00451 else { 00452 boolean synPredMatched34 = false; 00453 if (((LA(1)==LITERAL_drop) && (LA(2)==LITERAL_column||LA(2)==ID))) { 00454 int _m34 = mark(); 00455 synPredMatched34 = true; 00456 inputState.guessing++; 00457 try { 00458 { 00459 match(LITERAL_drop); 00460 } 00461 } 00462 catch (RecognitionException pe) { 00463 synPredMatched34 = false; 00464 } 00465 rewind(_m34); 00466 inputState.guessing--; 00467 } 00468 if ( synPredMatched34 ) { 00469 s=dropColumn(id); 00470 } 00471 else { 00472 throw new NoViableAltException(LT(1), getFilename()); 00473 } 00474 }}}} 00475 } 00476 return s; 00477 } 00478 00479 public final Stmt createIndexStmt() throws RecognitionException, TokenStreamException { 00480 Stmt s; 00481 00482 00483 s = null; 00484 String indexName = null; 00485 String tableName = null; 00486 Vector columns; 00487 boolean unique = false; 00488 boolean text = false; 00489 00490 00491 match(LITERAL_create); 00492 { 00493 switch ( LA(1)) { 00494 case LITERAL_unique: 00495 { 00496 match(LITERAL_unique); 00497 if ( inputState.guessing==0 ) { 00498 unique = true; 00499 } 00500 break; 00501 } 00502 case LITERAL_index: 00503 { 00504 break; 00505 } 00506 default: 00507 { 00508 throw new NoViableAltException(LT(1), getFilename()); 00509 } 00510 } 00511 } 00512 match(LITERAL_index); 00513 indexName=sqlId(); 00514 match(LITERAL_on); 00515 tableName=sqlId(); 00516 match(LPAREN); 00517 columns=idList(); 00518 match(RPAREN); 00519 if ( inputState.guessing==0 ) { 00520 00521 tableName = qConn.resolveName(tableName); 00522 indexName = qConn.resolveName(indexName); 00523 s = new StmtCreateIndex(indexName, tableName, 00524 columns, unique, text); 00525 00526 } 00527 return s; 00528 } 00529 00530 public final StmtCreateSchema createSchemaStmt() throws RecognitionException, TokenStreamException { 00531 StmtCreateSchema s; 00532 00533 00534 s = null; 00535 String name = null; 00536 String auth = null; 00537 Stmt s1 = null; 00538 00539 00540 match(LITERAL_create); 00541 match(LITERAL_schema); 00542 { 00543 switch ( LA(1)) { 00544 case ID: 00545 { 00546 name=sqlId(); 00547 { 00548 switch ( LA(1)) { 00549 case LITERAL_authorization: 00550 { 00551 match(LITERAL_authorization); 00552 auth=sqlId(); 00553 break; 00554 } 00555 case EOF: 00556 case LITERAL_create: 00557 case LITERAL_grant: 00558 { 00559 break; 00560 } 00561 default: 00562 { 00563 throw new NoViableAltException(LT(1), getFilename()); 00564 } 00565 } 00566 } 00567 break; 00568 } 00569 case LITERAL_authorization: 00570 { 00571 match(LITERAL_authorization); 00572 name=sqlId(); 00573 if ( inputState.guessing==0 ) { 00574 auth = name; 00575 } 00576 break; 00577 } 00578 default: 00579 { 00580 throw new NoViableAltException(LT(1), getFilename()); 00581 } 00582 } 00583 } 00584 if ( inputState.guessing==0 ) { 00585 00586 try { 00587 s = new StmtCreateSchema(name, auth); 00588 qConn.setAuth(name, null); 00589 } catch (SQLException ex) { 00590 throw new RecognitionException("Bad auth"); 00591 } 00592 00593 } 00594 { 00595 _loop71: 00596 do { 00597 if ((LA(1)==LITERAL_create||LA(1)==LITERAL_grant)) { 00598 s1=schemaStatement(); 00599 if ( inputState.guessing==0 ) { 00600 s.addStatement(s1); 00601 } 00602 } 00603 else { 00604 break _loop71; 00605 } 00606 00607 } while (true); 00608 } 00609 return s; 00610 } 00611 00612 public final Stmt createTableStmt() throws RecognitionException, TokenStreamException { 00613 Stmt s; 00614 00615 00616 s = null; 00617 Column col = null; 00618 Constraint con = null; 00619 Vector constraints = new Vector(); 00620 Table t = null; 00621 String id = null; 00622 int modifiers = 0; 00623 00624 00625 match(LITERAL_create); 00626 { 00627 switch ( LA(1)) { 00628 case LITERAL_global: 00629 { 00630 match(LITERAL_global); 00631 if ( inputState.guessing==0 ) { 00632 modifiers |= Table.GLOBAL; 00633 } 00634 break; 00635 } 00636 case LITERAL_local: 00637 { 00638 match(LITERAL_local); 00639 if ( inputState.guessing==0 ) { 00640 modifiers |= Table.LOCAL; 00641 } 00642 break; 00643 } 00644 case LITERAL_temporary: 00645 case LITERAL_table: 00646 { 00647 break; 00648 } 00649 default: 00650 { 00651 throw new NoViableAltException(LT(1), getFilename()); 00652 } 00653 } 00654 } 00655 { 00656 switch ( LA(1)) { 00657 case LITERAL_temporary: 00658 { 00659 match(LITERAL_temporary); 00660 if ( inputState.guessing==0 ) { 00661 modifiers |= Table.TEMPORARY; 00662 } 00663 break; 00664 } 00665 case LITERAL_table: 00666 { 00667 break; 00668 } 00669 default: 00670 { 00671 throw new NoViableAltException(LT(1), getFilename()); 00672 } 00673 } 00674 } 00675 match(LITERAL_table); 00676 id=sqlId(); 00677 match(LPAREN); 00678 if ( inputState.guessing==0 ) { 00679 00680 t = new Table(qConn.resolveName(id), modifiers); 00681 00682 } 00683 { 00684 switch ( LA(1)) { 00685 case ID: 00686 { 00687 col=columnDefinition(); 00688 if ( inputState.guessing==0 ) { 00689 00690 try { 00691 t.addColumn(col); 00692 } catch (SQLException e) { 00693 throw new DbException(e); 00694 } 00695 00696 } 00697 break; 00698 } 00699 case LITERAL_unique: 00700 case LITERAL_constraint: 00701 case LITERAL_primary: 00702 case LITERAL_foreign: 00703 case LITERAL_check: 00704 { 00705 con=tableConstraint(); 00706 if ( inputState.guessing==0 ) { 00707 00708 constraints.addElement(con); 00709 00710 } 00711 break; 00712 } 00713 case RPAREN: 00714 case COMMA: 00715 { 00716 break; 00717 } 00718 default: 00719 { 00720 throw new NoViableAltException(LT(1), getFilename()); 00721 } 00722 } 00723 } 00724 { 00725 _loop87: 00726 do { 00727 if ((LA(1)==COMMA)) { 00728 match(COMMA); 00729 { 00730 switch ( LA(1)) { 00731 case ID: 00732 { 00733 col=columnDefinition(); 00734 if ( inputState.guessing==0 ) { 00735 00736 try { 00737 t.addColumn(col); 00738 } catch (SQLException e) { 00739 throw new DbException(e); 00740 } 00741 00742 } 00743 break; 00744 } 00745 case LITERAL_unique: 00746 case LITERAL_constraint: 00747 case LITERAL_primary: 00748 case LITERAL_foreign: 00749 case LITERAL_check: 00750 { 00751 con=tableConstraint(); 00752 if ( inputState.guessing==0 ) { 00753 00754 constraints.addElement(con); 00755 00756 } 00757 break; 00758 } 00759 default: 00760 { 00761 throw new NoViableAltException(LT(1), getFilename()); 00762 } 00763 } 00764 } 00765 } 00766 else { 00767 break _loop87; 00768 } 00769 00770 } while (true); 00771 } 00772 match(RPAREN); 00773 if ( inputState.guessing==0 ) { 00774 00775 s = new StmtCreateTable(t, constraints); 00776 00777 } 00778 return s; 00779 } 00780 00781 public final StmtCreateView createViewStmt() throws RecognitionException, TokenStreamException { 00782 StmtCreateView s; 00783 00784 00785 s = null; 00786 Vector columns = null; 00787 TableExpression te = null; 00788 int check = View.NOCHECK; 00789 String id = null; 00790 00791 00792 match(LITERAL_create); 00793 match(LITERAL_view); 00794 id=sqlId(); 00795 { 00796 switch ( LA(1)) { 00797 case LPAREN: 00798 { 00799 match(LPAREN); 00800 columns=idList(); 00801 match(RPAREN); 00802 break; 00803 } 00804 case LITERAL_as: 00805 { 00806 break; 00807 } 00808 default: 00809 { 00810 throw new NoViableAltException(LT(1), getFilename()); 00811 } 00812 } 00813 } 00814 match(LITERAL_as); 00815 te=queryExpression(); 00816 { 00817 switch ( LA(1)) { 00818 case LITERAL_with: 00819 { 00820 match(LITERAL_with); 00821 if ( inputState.guessing==0 ) { 00822 check = View.CASCADED; 00823 } 00824 { 00825 switch ( LA(1)) { 00826 case LITERAL_cascaded: 00827 { 00828 match(LITERAL_cascaded); 00829 break; 00830 } 00831 case LITERAL_check: 00832 { 00833 break; 00834 } 00835 default: 00836 { 00837 throw new NoViableAltException(LT(1), getFilename()); 00838 } 00839 } 00840 } 00841 match(LITERAL_check); 00842 match(LITERAL_option); 00843 break; 00844 } 00845 case EOF: 00846 case LITERAL_create: 00847 case LITERAL_grant: 00848 { 00849 break; 00850 } 00851 default: 00852 { 00853 throw new NoViableAltException(LT(1), getFilename()); 00854 } 00855 } 00856 } 00857 if ( inputState.guessing==0 ) { 00858 00859 String name = qConn.resolveName(id); 00860 View view = new View(name, columns, te, check); 00861 s = new StmtCreateView(session, view); 00862 00863 } 00864 return s; 00865 } 00866 00867 public final Stmt deleteStmt() throws RecognitionException, TokenStreamException { 00868 Stmt s; 00869 00870 00871 s = null; 00872 Expression e = null; 00873 String id = null; 00874 00875 00876 match(LITERAL_delete); 00877 match(LITERAL_from); 00878 id=sqlId(); 00879 e=whereExpression(); 00880 if ( inputState.guessing==0 ) { 00881 00882 String n = qConn.resolveName(id); 00883 s = new StmtDelete(n, e); 00884 00885 } 00886 return s; 00887 } 00888 00889 public final Stmt dropTableStmt() throws RecognitionException, TokenStreamException { 00890 Stmt s; 00891 00892 00893 s = null; 00894 boolean restrict = true; 00895 boolean view = false; 00896 String id; 00897 String n; 00898 00899 00900 match(LITERAL_drop); 00901 { 00902 switch ( LA(1)) { 00903 case LITERAL_table: 00904 { 00905 match(LITERAL_table); 00906 break; 00907 } 00908 case LITERAL_view: 00909 { 00910 match(LITERAL_view); 00911 if ( inputState.guessing==0 ) { 00912 view = true; 00913 } 00914 break; 00915 } 00916 default: 00917 { 00918 throw new NoViableAltException(LT(1), getFilename()); 00919 } 00920 } 00921 } 00922 id=sqlId(); 00923 { 00924 switch ( LA(1)) { 00925 case LITERAL_cascade: 00926 { 00927 match(LITERAL_cascade); 00928 if ( inputState.guessing==0 ) { 00929 restrict = false; 00930 } 00931 break; 00932 } 00933 case LITERAL_restrict: 00934 { 00935 match(LITERAL_restrict); 00936 if ( inputState.guessing==0 ) { 00937 restrict = true; 00938 } 00939 break; 00940 } 00941 case EOF: 00942 { 00943 break; 00944 } 00945 default: 00946 { 00947 throw new NoViableAltException(LT(1), getFilename()); 00948 } 00949 } 00950 } 00951 if ( inputState.guessing==0 ) { 00952 00953 n = qConn.resolveName(id); 00954 s = new StmtDropTable(n, view, restrict); 00955 00956 } 00957 return s; 00958 } 00959 00960 public final Stmt dropIndexStmt() throws RecognitionException, TokenStreamException { 00961 Stmt s; 00962 00963 00964 s = null; 00965 String indexName = null; 00966 00967 00968 match(LITERAL_drop); 00969 match(LITERAL_index); 00970 indexName=sqlId(); 00971 if ( inputState.guessing==0 ) { 00972 00973 indexName = qConn.resolveName(indexName); 00974 s = new StmtDropIndex(indexName); 00975 00976 } 00977 return s; 00978 } 00979 00980 public final Stmt grantStmt() throws RecognitionException, TokenStreamException { 00981 Stmt s; 00982 00983 00984 s = null; 00985 String id = null; 00986 00987 00988 match(LITERAL_grant); 00989 privilege(); 00990 { 00991 _loop90: 00992 do { 00993 if ((LA(1)==COMMA)) { 00994 match(COMMA); 00995 privilege(); 00996 } 00997 else { 00998 break _loop90; 00999 } 01000 01001 } while (true); 01002 } 01003 match(LITERAL_on); 01004 { 01005 switch ( LA(1)) { 01006 case LITERAL_table: 01007 { 01008 match(LITERAL_table); 01009 break; 01010 } 01011 case ID: 01012 { 01013 break; 01014 } 01015 default: 01016 { 01017 throw new NoViableAltException(LT(1), getFilename()); 01018 } 01019 } 01020 } 01021 id=sqlId(); 01022 match(LITERAL_to); 01023 { 01024 switch ( LA(1)) { 01025 case ID: 01026 { 01027 id=sqlId(); 01028 { 01029 _loop94: 01030 do { 01031 if ((LA(1)==COMMA)) { 01032 match(COMMA); 01033 id=sqlId(); 01034 } 01035 else { 01036 break _loop94; 01037 } 01038 01039 } while (true); 01040 } 01041 break; 01042 } 01043 case LITERAL_public: 01044 { 01045 match(LITERAL_public); 01046 break; 01047 } 01048 default: 01049 { 01050 throw new NoViableAltException(LT(1), getFilename()); 01051 } 01052 } 01053 } 01054 { 01055 switch ( LA(1)) { 01056 case LITERAL_with: 01057 { 01058 match(LITERAL_with); 01059 match(LITERAL_grant); 01060 match(LITERAL_option); 01061 break; 01062 } 01063 case EOF: 01064 case LITERAL_create: 01065 case LITERAL_grant: 01066 { 01067 break; 01068 } 01069 default: 01070 { 01071 throw new NoViableAltException(LT(1), getFilename()); 01072 } 01073 } 01074 } 01075 if ( inputState.guessing==0 ) { 01076 s = new StmtNull(); 01077 } 01078 return s; 01079 } 01080 01081 public final StmtInsert insertStmt() throws RecognitionException, TokenStreamException { 01082 StmtInsert s; 01083 01084 01085 s = null; 01086 ResultSet rs = null; 01087 Vector columns = null; 01088 Expression query = null; 01089 String n = null; 01090 String id = null; 01091 01092 01093 match(LITERAL_insert); 01094 match(LITERAL_into); 01095 id=sqlId(); 01096 if ( inputState.guessing==0 ) { 01097 01098 n = qConn.resolveName(id); 01099 s = new StmtInsert(n); 01100 01101 } 01102 { 01103 if ((LA(1)==LPAREN) && (LA(2)==ID)) { 01104 match(LPAREN); 01105 columns=idList(); 01106 if ( inputState.guessing==0 ) { 01107 s.setColumns(columns); 01108 } 01109 match(RPAREN); 01110 } 01111 else if ((LA(1)==LITERAL_table||LA(1)==LPAREN||LA(1)==LITERAL_default||LA(1)==LITERAL_select||LA(1)==LITERAL_values||LA(1)==ID) && (LA(2)==EOF||LA(2)==LITERAL_unique||LA(2)==LITERAL_table||LA(2)==LPAREN||LA(2)==LITERAL_default||LA(2)==LITERAL_as||LA(2)==LITERAL_all||LA(2)==LITERAL_select||LA(2)==LITERAL_insert||LA(2)==LITERAL_not||LA(2)==LITERAL_null||LA(2)==LITERAL_full||LA(2)==LITERAL_char||LA(2)==LITERAL_date||LA(2)==LITERAL_time||LA(2)==LITERAL_timestamp||LA(2)==LITERAL_interval||LA(2)==LITERAL_distinct||LA(2)==STAR||LA(2)==LITERAL_values||LA(2)==LITERAL_exists||LA(2)==PLUS||LA(2)==MINUS||LA(2)==STRING_LITERAL||LA(2)==QUESTION||LA(2)==INT||LA(2)==REAL||LA(2)==BINSTR||LA(2)==HEXSTR||LA(2)==LITERAL_case||LA(2)==LITERAL_hour||LA(2)==LITERAL_left||LA(2)==LITERAL_minute||LA(2)==LITERAL_month||LA(2)==LITERAL_right||LA(2)==LITERAL_second||LA(2)==LITERAL_year||LA(2)==LITERAL_user||LA(2)==LITERAL_current_user||LA(2)==LITERAL_session_user||LA(2)==LITERAL_system_user||LA(2)==LITERAL_current_date||LA(2)==LITERAL_current_time||LA(2)==LITERAL_current_timestamp||LA(2)==LITERAL_sql_tsi_frac_second||LA(2)==LITERAL_sql_tsi_second||LA(2)==LITERAL_sql_tsi_minute||LA(2)==LITERAL_sql_tsi_hour||LA(2)==LITERAL_sql_tsi_day||LA(2)==LITERAL_sql_tsi_week||LA(2)==LITERAL_sql_tsi_month||LA(2)==LITERAL_sql_tsi_quarter||LA(2)==LITERAL_sql_tsi_year||LA(2)==LITERAL_cast||LA(2)==LITERAL_true||LA(2)==LITERAL_false||LA(2)==LITERAL_avg||LA(2)==LITERAL_min||LA(2)==LITERAL_max||LA(2)==LITERAL_sum||LA(2)==LITERAL_count||LA(2)==LITERAL_cross||LA(2)==LITERAL_join||LA(2)==LITERAL_natural||LA(2)==LITERAL_union||LA(2)==LITERAL_inner||LA(2)==LITERAL_intersect||LA(2)==LITERAL_except||LA(2)==ID)) { 01112 } 01113 else { 01114 throw new NoViableAltException(LT(1), getFilename()); 01115 } 01116 01117 } 01118 { 01119 switch ( LA(1)) { 01120 case LITERAL_table: 01121 case LPAREN: 01122 case LITERAL_select: 01123 case LITERAL_values: 01124 case ID: 01125 { 01126 query=queryExpression(); 01127 if ( inputState.guessing==0 ) { 01128 s.setValues(query); 01129 } 01130 break; 01131 } 01132 case LITERAL_default: 01133 { 01134 match(LITERAL_default); 01135 match(LITERAL_values); 01136 if ( inputState.guessing==0 ) { 01137 s.setDefaultValue(); 01138 } 01139 break; 01140 } 01141 default: 01142 { 01143 throw new NoViableAltException(LT(1), getFilename()); 01144 } 01145 } 01146 } 01147 return s; 01148 } 01149 01150 public final SelectStmt selectStmt() throws RecognitionException, TokenStreamException { 01151 SelectStmt s; 01152 01153 01154 s = null; 01155 TableExpression te = null; 01156 Vector ob = null; 01157 01158 01159 te=queryExpression(); 01160 if ( inputState.guessing==0 ) { 01161 s = new SelectStmt(te); 01162 } 01163 { 01164 switch ( LA(1)) { 01165 case LITERAL_order: 01166 { 01167 ob=orderBy(); 01168 if ( inputState.guessing==0 ) { 01169 s.setOrder(ob); 01170 } 01171 break; 01172 } 01173 case LITERAL_for: 01174 { 01175 match(LITERAL_for); 01176 { 01177 switch ( LA(1)) { 01178 case LITERAL_update: 01179 { 01180 match(LITERAL_update); 01181 break; 01182 } 01183 case LITERAL_read: 01184 { 01185 match(LITERAL_read); 01186 match(LITERAL_only); 01187 break; 01188 } 01189 default: 01190 { 01191 throw new NoViableAltException(LT(1), getFilename()); 01192 } 01193 } 01194 } 01195 break; 01196 } 01197 case EOF: 01198 { 01199 break; 01200 } 01201 default: 01202 { 01203 throw new NoViableAltException(LT(1), getFilename()); 01204 } 01205 } 01206 } 01207 return s; 01208 } 01209 01210 public final StmtUpdate updateStmt() throws RecognitionException, TokenStreamException { 01211 StmtUpdate s; 01212 01213 01214 s = null; 01215 String n = null; 01216 UpdateItem item = null; 01217 Expression we = null; 01218 String id = null; 01219 01220 01221 match(LITERAL_update); 01222 id=sqlId(); 01223 if ( inputState.guessing==0 ) { 01224 01225 n = qConn.resolveName(id); 01226 s = new StmtUpdate(n); 01227 01228 } 01229 match(LITERAL_set); 01230 { 01231 switch ( LA(1)) { 01232 case ID: 01233 { 01234 item=updateItem(); 01235 if ( inputState.guessing==0 ) { 01236 01237 s.addItem(item); 01238 01239 } 01240 { 01241 _loop62: 01242 do { 01243 if ((LA(1)==COMMA)) { 01244 match(COMMA); 01245 item=updateItem(); 01246 if ( inputState.guessing==0 ) { 01247 01248 s.addItem(item); 01249 01250 } 01251 } 01252 else { 01253 break _loop62; 01254 } 01255 01256 } while (true); 01257 } 01258 break; 01259 } 01260 case EOF: 01261 case LITERAL_where: 01262 { 01263 break; 01264 } 01265 default: 01266 { 01267 throw new NoViableAltException(LT(1), getFilename()); 01268 } 01269 } 01270 } 01271 we=whereExpression(); 01272 if ( inputState.guessing==0 ) { 01273 s.addWhere(we); 01274 } 01275 return s; 01276 } 01277 01278 public final Stmt commitStmt() throws RecognitionException, TokenStreamException { 01279 Stmt s; 01280 01281 01282 s = null; 01283 01284 01285 match(LITERAL_commit); 01286 { 01287 switch ( LA(1)) { 01288 case LITERAL_work: 01289 { 01290 match(LITERAL_work); 01291 break; 01292 } 01293 case EOF: 01294 { 01295 break; 01296 } 01297 default: 01298 { 01299 throw new NoViableAltException(LT(1), getFilename()); 01300 } 01301 } 01302 } 01303 if ( inputState.guessing==0 ) { 01304 s = new StmtCommit(); 01305 } 01306 return s; 01307 } 01308 01309 public final Stmt rollbackStmt() throws RecognitionException, TokenStreamException { 01310 Stmt s; 01311 01312 01313 s = null; 01314 01315 01316 match(LITERAL_rollback); 01317 { 01318 switch ( LA(1)) { 01319 case LITERAL_transaction: 01320 { 01321 match(LITERAL_transaction); 01322 break; 01323 } 01324 case EOF: 01325 { 01326 break; 01327 } 01328 default: 01329 { 01330 throw new NoViableAltException(LT(1), getFilename()); 01331 } 01332 } 01333 } 01334 if ( inputState.guessing==0 ) { 01335 s = new StmtRollback(); 01336 } 01337 return s; 01338 } 01339 01340 public final String sqlId() throws RecognitionException, TokenStreamException { 01341 String s; 01342 01343 Token id = null; 01344 01345 s = null; 01346 StringBuffer sb = new StringBuffer(); 01347 01348 01349 id = LT(1); 01350 match(ID); 01351 if ( inputState.guessing==0 ) { 01352 01353 String n = id.getText(); 01354 int idx = TupleImpl.nextUnquotedPeriod(n); 01355 if (idx > 0) { 01356 sb.append(fixIdTerm(n.substring(0, idx))); 01357 sb.append('.'); 01358 n = n.substring(idx+1); 01359 idx = TupleImpl.nextUnquotedPeriod(n); 01360 if (idx > 0) { 01361 sb.append(fixIdTerm(n.substring(0, idx))); 01362 sb.append('.'); 01363 n = n.substring(idx+1); 01364 } 01365 } 01366 sb.append(fixIdTerm(n)); 01367 s = sb.toString(); 01368 01369 } 01370 return s; 01371 } 01372 01373 public final Vector idList() throws RecognitionException, TokenStreamException { 01374 Vector v ; 01375 01376 01377 v = new Vector(); 01378 String id = null; 01379 01380 01381 id=sqlId(); 01382 if ( inputState.guessing==0 ) { 01383 v.addElement(id); 01384 } 01385 { 01386 _loop332: 01387 do { 01388 if ((LA(1)==COMMA) && (LA(2)==ID)) { 01389 match(COMMA); 01390 id=sqlId(); 01391 if ( inputState.guessing==0 ) { 01392 v.addElement(id); 01393 } 01394 } 01395 else { 01396 break _loop332; 01397 } 01398 01399 } while (true); 01400 } 01401 return v ; 01402 } 01403 01404 public final Stmt addConstraint( 01405 String id 01406 ) throws RecognitionException, TokenStreamException { 01407 Stmt s; 01408 01409 01410 s = null; 01411 Constraint con = null; 01412 01413 01414 match(LITERAL_add); 01415 con=tableConstraint(); 01416 if ( inputState.guessing==0 ) { 01417 s = new StmtAddConstraint(id, con); 01418 } 01419 return s; 01420 } 01421 01422 public final Stmt addColumn( 01423 String id 01424 ) throws RecognitionException, TokenStreamException { 01425 Stmt s; 01426 01427 01428 s = null; 01429 Column col = null; 01430 String aname = null; 01431 01432 01433 match(LITERAL_add); 01434 { 01435 switch ( LA(1)) { 01436 case LITERAL_column: 01437 { 01438 match(LITERAL_column); 01439 break; 01440 } 01441 case ID: 01442 { 01443 break; 01444 } 01445 default: 01446 { 01447 throw new NoViableAltException(LT(1), getFilename()); 01448 } 01449 } 01450 } 01451 col=columnDefinition(); 01452 { 01453 switch ( LA(1)) { 01454 case LITERAL_first: 01455 { 01456 match(LITERAL_first); 01457 if ( inputState.guessing==0 ) { 01458 aname = ""; 01459 } 01460 break; 01461 } 01462 case LITERAL_after: 01463 { 01464 match(LITERAL_after); 01465 aname=sqlId(); 01466 break; 01467 } 01468 case EOF: 01469 { 01470 break; 01471 } 01472 default: 01473 { 01474 throw new NoViableAltException(LT(1), getFilename()); 01475 } 01476 } 01477 } 01478 if ( inputState.guessing==0 ) { 01479 s = new StmtAddColumn(id, col, aname); 01480 } 01481 return s; 01482 } 01483 01484 public final Stmt dropConstraint( 01485 String id 01486 ) throws RecognitionException, TokenStreamException { 01487 Stmt s; 01488 01489 01490 s = null; 01491 String conName = null; 01492 boolean restrict = true; 01493 01494 01495 match(LITERAL_drop); 01496 match(LITERAL_constraint); 01497 conName=sqlId(); 01498 { 01499 switch ( LA(1)) { 01500 case LITERAL_restrict: 01501 { 01502 match(LITERAL_restrict); 01503 break; 01504 } 01505 case LITERAL_cascade: 01506 { 01507 match(LITERAL_cascade); 01508 if ( inputState.guessing==0 ) { 01509 restrict = false; 01510 } 01511 break; 01512 } 01513 case EOF: 01514 { 01515 break; 01516 } 01517 default: 01518 { 01519 throw new NoViableAltException(LT(1), getFilename()); 01520 } 01521 } 01522 } 01523 if ( inputState.guessing==0 ) { 01524 s = new StmtDropConstraint(id, conName, restrict); 01525 } 01526 return s; 01527 } 01528 01529 public final Stmt dropColumn( 01530 String id 01531 ) throws RecognitionException, TokenStreamException { 01532 Stmt s; 01533 01534 01535 s = null; 01536 String colName = null; 01537 01538 01539 match(LITERAL_drop); 01540 { 01541 switch ( LA(1)) { 01542 case LITERAL_column: 01543 { 01544 match(LITERAL_column); 01545 break; 01546 } 01547 case ID: 01548 { 01549 break; 01550 } 01551 default: 01552 { 01553 throw new NoViableAltException(LT(1), getFilename()); 01554 } 01555 } 01556 } 01557 colName=sqlId(); 01558 { 01559 switch ( LA(1)) { 01560 case LITERAL_restrict: 01561 { 01562 match(LITERAL_restrict); 01563 break; 01564 } 01565 case LITERAL_cascade: 01566 { 01567 match(LITERAL_cascade); 01568 break; 01569 } 01570 case EOF: 01571 { 01572 break; 01573 } 01574 default: 01575 { 01576 throw new NoViableAltException(LT(1), getFilename()); 01577 } 01578 } 01579 } 01580 if ( inputState.guessing==0 ) { 01581 s = new StmtDropColumn(id, colName); 01582 } 01583 return s; 01584 } 01585 01586 public final Stmt alterColumn( 01587 String id 01588 ) throws RecognitionException, TokenStreamException { 01589 Stmt s; 01590 01591 01592 s = null; 01593 String colName = null; 01594 Expression def = null; 01595 01596 01597 match(LITERAL_alter); 01598 { 01599 switch ( LA(1)) { 01600 case LITERAL_column: 01601 { 01602 match(LITERAL_column); 01603 break; 01604 } 01605 case ID: 01606 { 01607 break; 01608 } 01609 default: 01610 { 01611 throw new NoViableAltException(LT(1), getFilename()); 01612 } 01613 } 01614 } 01615 colName=sqlId(); 01616 { 01617 switch ( LA(1)) { 01618 case LITERAL_set: 01619 { 01620 match(LITERAL_set); 01621 match(LITERAL_default); 01622 def=expression(); 01623 break; 01624 } 01625 case LITERAL_drop: 01626 { 01627 match(LITERAL_drop); 01628 match(LITERAL_default); 01629 break; 01630 } 01631 default: 01632 { 01633 throw new NoViableAltException(LT(1), getFilename()); 01634 } 01635 } 01636 } 01637 if ( inputState.guessing==0 ) { 01638 s = new StmtAlterColumn(id, colName, def); 01639 } 01640 return s; 01641 } 01642 01643 public final Stmt renameTable( 01644 String id 01645 ) throws RecognitionException, TokenStreamException { 01646 Stmt s; 01647 01648 01649 s = null; 01650 Constraint con = null; 01651 String id2 = null; 01652 01653 01654 match(LITERAL_rename); 01655 match(LITERAL_to); 01656 id2=sqlId(); 01657 if ( inputState.guessing==0 ) { 01658 01659 id2 = qConn.resolveName(id2); 01660 s = new StmtRenameTable(id, id2); 01661 01662 } 01663 return s; 01664 } 01665 01666 public final Constraint tableConstraint() throws RecognitionException, TokenStreamException { 01667 Constraint con; 01668 01669 01670 con = null; 01671 String name = null; 01672 Vector v = null; 01673 Vector v2 = null; 01674 int ref = 0; 01675 String n = null; 01676 String id = null; 01677 Expression predicate = null; 01678 01679 01680 { 01681 switch ( LA(1)) { 01682 case LITERAL_constraint: 01683 { 01684 match(LITERAL_constraint); 01685 name=sqlId(); 01686 break; 01687 } 01688 case LITERAL_unique: 01689 case LITERAL_primary: 01690 case LITERAL_foreign: 01691 case LITERAL_check: 01692 { 01693 break; 01694 } 01695 default: 01696 { 01697 throw new NoViableAltException(LT(1), getFilename()); 01698 } 01699 } 01700 } 01701 { 01702 switch ( LA(1)) { 01703 case LITERAL_primary: 01704 { 01705 match(LITERAL_primary); 01706 match(LITERAL_key); 01707 match(LPAREN); 01708 v=idList(); 01709 match(RPAREN); 01710 if ( inputState.guessing==0 ) { 01711 con = new PrimaryKeyConstraint(name, v); 01712 } 01713 break; 01714 } 01715 case LITERAL_unique: 01716 { 01717 match(LITERAL_unique); 01718 match(LPAREN); 01719 v=idList(); 01720 match(RPAREN); 01721 if ( inputState.guessing==0 ) { 01722 con = new UniqueConstraint(name, v); 01723 } 01724 break; 01725 } 01726 case LITERAL_foreign: 01727 { 01728 match(LITERAL_foreign); 01729 match(LITERAL_key); 01730 match(LPAREN); 01731 v=idList(); 01732 match(RPAREN); 01733 match(LITERAL_references); 01734 id=sqlId(); 01735 { 01736 switch ( LA(1)) { 01737 case LPAREN: 01738 { 01739 match(LPAREN); 01740 v2=idList(); 01741 match(RPAREN); 01742 break; 01743 } 01744 case EOF: 01745 case LITERAL_on: 01746 case RPAREN: 01747 case COMMA: 01748 case LITERAL_match: 01749 { 01750 break; 01751

com/quadcap/sql/SQLParser.java