0001: /* Generated By:JavaCC: Do not edit this line. SQL.java */
0002: package com.mckoi.database.sql;
0003:
0004: import com.mckoi.database.TType;
0005: import com.mckoi.database.Assignment;
0006: import com.mckoi.database.JoiningSet;
0007: import com.mckoi.database.Expression;
0008: import com.mckoi.database.Variable;
0009: import com.mckoi.database.FunctionDef;
0010: import com.mckoi.database.FunctionFactory;
0011: import com.mckoi.database.Operator;
0012: import com.mckoi.database.StatementTree;
0013: import com.mckoi.database.ParameterSubstitution;
0014: import com.mckoi.database.global.*;
0015: import com.mckoi.database.interpret.*;
0016: import com.mckoi.database.TObject;
0017: import java.util.ArrayList;
0018: import java.util.Stack;
0019:
0020: public class SQL implements SQLConstants {
0021:
0022: // State variables for the parser,
0023:
0024: /**
0025: * Set to true if the SQL identifiers are converted to upper case.
0026: * NOTE: Purely experimental feature!
0027: */
0028: private boolean case_insensitive_identifiers = false;
0029:
0030: /**
0031: * The parameter id.
0032: */
0033: private int parameter_id = 0;
0034:
0035: /**
0036: * Resets the parameter id. This MUST be called before a parser is used
0037: * to parse a statement.
0038: */
0039: public void reset() {
0040: parameter_id = 0;
0041: }
0042:
0043: /**
0044: * Creates and returns a parameter substitution. This is called when the
0045: * parser comes across a '?' style object. This object is used to mark an
0046: * expression with a place mark that can be substituted for a value later.
0047: */
0048: public ParameterSubstitution createSubstitution(String image) {
0049: ParameterSubstitution ps = new ParameterSubstitution(
0050: parameter_id);
0051: ++parameter_id;
0052: return ps;
0053: }
0054:
0055: /**
0056: * If the parser has been defined as case insensitive then this
0057: * returns the uppercase version of the given string.
0058: *
0059: * NOTE: This actually doesn't do anything because the case is now resolved
0060: * outside the parser.
0061: */
0062: public String caseCheck(String identif) {
0063: // if (case_insensitive_identifiers) {
0064: // return identif.toUpperCase();
0065: // }
0066: return identif;
0067: }
0068:
0069: /**
0070: * Helper for expression parsing.
0071: * Called when an end parenthese has been found.
0072: */
0073: public void expEndParen(Expression exp, Stack stack) {
0074: Operator op = (Operator) stack.pop();
0075: while (!op.is("(")) {
0076: addOperatorToExpression(exp, op);
0077: op = (Operator) stack.pop();
0078: }
0079: }
0080:
0081: /**
0082: * Helper for expression parsing.
0083: * Called when an operator has been read in. This needs to check precedence
0084: * and add the operator to the expression as appropriate.
0085: */
0086: public void expOperator(Expression exp, Stack stack, Operator op) {
0087: int precedence = op.precedence();
0088: flushOperatorStack(exp, stack, precedence);
0089: stack.push(op);
0090: }
0091:
0092: /**
0093: * Flush the operator stack until the stack is either empty or the top
0094: * element is either a "(" or of a precedence lower than the given
0095: * precedence.
0096: */
0097: public void flushOperatorStack(Expression exp, Stack stack,
0098: int precedence) {
0099: if (!stack.empty()) {
0100: Operator top_op = (Operator) stack.pop();
0101: while (!top_op.is("(") && top_op.precedence() >= precedence) {
0102: addOperatorToExpression(exp, top_op);
0103: if (stack.empty()) {
0104: return;
0105: }
0106: top_op = (Operator) stack.pop();
0107: }
0108: stack.push(top_op);
0109: }
0110: }
0111:
0112: /**
0113: * Helper for expression parsing.
0114: * Called when an entire expression has been read in. We need to empty
0115: * the stack.
0116: */
0117: public void expEnd(Expression exp, Stack stack) {
0118: while (!stack.empty()) {
0119: Operator op = (Operator) stack.pop();
0120: addOperatorToExpression(exp, op);
0121: }
0122: }
0123:
0124: /**
0125: * Helper for expression parsing.
0126: * Adds an operator to the given expression.
0127: */
0128: public void addOperatorToExpression(Expression exp, Operator op) {
0129: if (op.is("not")) {
0130: exp.addElement(null);
0131: }
0132: exp.addOperator(op);
0133: }
0134:
0135: public static void main(String args[]) throws ParseException {
0136: SQL parser = new SQL(System.in);
0137: parser.Test();
0138: }
0139:
0140: final public void Test() throws ParseException {
0141: parseExpression();
0142: jj_consume_token(207);
0143:
0144: }
0145:
0146: // Parses a single expression. Useed in 'com.mckoi.database.Expression.parse' method.
0147: final public Expression parseExpression() throws ParseException {
0148: Expression exp;
0149: exp = DoExpression();
0150: jj_consume_token(0);
0151: {
0152: if (true)
0153: return exp;
0154: }
0155: throw new Error("Missing return statement in function");
0156: }
0157:
0158: // Statement that ends with a ';'
0159: final public StatementTree Statement() throws ParseException {
0160: StatementTree ob;
0161: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0162: case SELECT:
0163: ob = Select();
0164: break;
0165: case UPDATE:
0166: ob = Update();
0167: break;
0168: case ALTER:
0169: ob = Alter();
0170: break;
0171: case COMPACT:
0172: ob = Compact();
0173: break;
0174: case CREATE:
0175: ob = Create();
0176: break;
0177: case DROP:
0178: ob = Drop();
0179: break;
0180: case DELETE:
0181: ob = Delete();
0182: break;
0183: case INSERT:
0184: ob = Insert();
0185: break;
0186: case DESCRIBE:
0187: ob = Describe();
0188: break;
0189: case SHOW:
0190: ob = Show();
0191: break;
0192: case CALL:
0193: ob = Call();
0194: break;
0195: case GRANT:
0196: ob = Grant();
0197: break;
0198: case REVOKE:
0199: ob = Revoke();
0200: break;
0201: case COMMIT:
0202: case ROLLBACK:
0203: ob = CompleteTransaction();
0204: break;
0205: case SET:
0206: ob = Set();
0207: break;
0208: case SHUTDOWN:
0209: ob = ShutDown();
0210: break;
0211: default:
0212: jj_la1[0] = jj_gen;
0213: jj_consume_token(-1);
0214: throw new ParseException();
0215: }
0216: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0217: case 207:
0218: jj_consume_token(207);
0219: break;
0220: case 0:
0221: jj_consume_token(0);
0222: break;
0223: default:
0224: jj_la1[1] = jj_gen;
0225: jj_consume_token(-1);
0226: throw new ParseException();
0227: }
0228: {
0229: if (true)
0230: return ob;
0231: }
0232: throw new Error("Missing return statement in function");
0233: }
0234:
0235: // All statements that start with <CREATE>
0236: final public StatementTree Create() throws ParseException {
0237: StatementTree ob;
0238: jj_consume_token(CREATE);
0239: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0240: case TABLE:
0241: case TEMPORARY:
0242: ob = CreateTable();
0243: break;
0244: case TRIGGER:
0245: case CALLBACK:
0246: ob = CreateTrigger();
0247: break;
0248: case FUNCTION:
0249: ob = CreateFunction();
0250: break;
0251: case INDEX:
0252: case UNIQUE:
0253: ob = CreateIndex();
0254: break;
0255: case SCHEMA:
0256: ob = CreateSchema();
0257: break;
0258: case SEQUENCE:
0259: ob = CreateSequence();
0260: break;
0261: case USER:
0262: ob = CreateUser();
0263: break;
0264: case VIEW:
0265: ob = CreateView();
0266: break;
0267: default:
0268: jj_la1[2] = jj_gen;
0269: jj_consume_token(-1);
0270: throw new ParseException();
0271: }
0272: {
0273: if (true)
0274: return ob;
0275: }
0276: throw new Error("Missing return statement in function");
0277: }
0278:
0279: // All statements that start with <DROP>
0280: final public StatementTree Drop() throws ParseException {
0281: StatementTree ob;
0282: jj_consume_token(DROP);
0283: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0284: case TABLE:
0285: ob = DropTable();
0286: break;
0287: case TRIGGER:
0288: case CALLBACK:
0289: ob = DropTrigger();
0290: break;
0291: case FUNCTION:
0292: ob = DropFunction();
0293: break;
0294: case INDEX:
0295: ob = DropIndex();
0296: break;
0297: case SCHEMA:
0298: ob = DropSchema();
0299: break;
0300: case SEQUENCE:
0301: ob = DropSequence();
0302: break;
0303: case USER:
0304: ob = DropUser();
0305: break;
0306: case VIEW:
0307: ob = DropView();
0308: break;
0309: default:
0310: jj_la1[3] = jj_gen;
0311: jj_consume_token(-1);
0312: throw new ParseException();
0313: }
0314: {
0315: if (true)
0316: return ob;
0317: }
0318: throw new Error("Missing return statement in function");
0319: }
0320:
0321: final public StatementTree Select() throws ParseException {
0322: StatementTree cmd = new StatementTree(
0323: "com.mckoi.database.interpret.Select");
0324: TableSelectExpression table_expr;
0325: ArrayList order_by = new ArrayList();
0326: table_expr = GetTableSelectExpression();
0327: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0328: case ORDERBY:
0329: jj_consume_token(ORDERBY);
0330: SelectOrderByList(order_by);
0331: break;
0332: default:
0333: jj_la1[4] = jj_gen;
0334: ;
0335: }
0336: cmd.putObject("table_expression", table_expr);
0337: cmd.putObject("order_by", order_by);
0338: {
0339: if (true)
0340: return cmd;
0341: }
0342: throw new Error("Missing return statement in function");
0343: }
0344:
0345: final public StatementTree Update() throws ParseException {
0346: StatementTree cmd = new StatementTree(
0347: "com.mckoi.database.interpret.UpdateTable");
0348: String table_name;
0349: ArrayList assignments = new ArrayList();
0350: SearchExpression where_clause = new SearchExpression();
0351: int limit = -1;
0352: jj_consume_token(UPDATE);
0353: table_name = TableName();
0354: jj_consume_token(SET);
0355: AssignmentList(assignments);
0356: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0357: case WHERE:
0358: jj_consume_token(WHERE);
0359: ConditionsExpression(where_clause);
0360: break;
0361: default:
0362: jj_la1[5] = jj_gen;
0363: ;
0364: }
0365: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0366: case LIMIT:
0367: jj_consume_token(LIMIT);
0368: limit = PositiveIntegerConstant();
0369: break;
0370: default:
0371: jj_la1[6] = jj_gen;
0372: ;
0373: }
0374: cmd.putObject("table_name", table_name);
0375: cmd.putObject("assignments", assignments);
0376: cmd.putObject("where_clause", where_clause);
0377: cmd.putInt("limit", limit);
0378: {
0379: if (true)
0380: return cmd;
0381: }
0382: throw new Error("Missing return statement in function");
0383: }
0384:
0385: final public StatementTree Alter() throws ParseException {
0386: StatementTree cmd;
0387: jj_consume_token(ALTER);
0388: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0389: case CREATE:
0390: case TABLE:
0391: cmd = AlterTable();
0392: break;
0393: case USER:
0394: cmd = AlterUser();
0395: break;
0396: default:
0397: jj_la1[7] = jj_gen;
0398: jj_consume_token(-1);
0399: throw new ParseException();
0400: }
0401: {
0402: if (true)
0403: return cmd;
0404: }
0405: throw new Error("Missing return statement in function");
0406: }
0407:
0408: final public StatementTree AlterTable() throws ParseException {
0409: StatementTree cmd = new StatementTree(
0410: "com.mckoi.database.interpret.AlterTable");
0411: String table_name;
0412: AlterTableAction action;
0413: StatementTree create_statement;
0414: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0415: case TABLE:
0416: jj_consume_token(TABLE);
0417: table_name = TableName();
0418: action = GetAlterTableAction();
0419: cmd.putObject("table_name", table_name);
0420: cmd.putObject("alter_action", action);
0421: break;
0422: case CREATE:
0423: jj_consume_token(CREATE);
0424: create_statement = CreateTable();
0425: cmd.putObject("create_statement", create_statement);
0426: break;
0427: default:
0428: jj_la1[8] = jj_gen;
0429: jj_consume_token(-1);
0430: throw new ParseException();
0431: }
0432: {
0433: if (true)
0434: return cmd;
0435: }
0436: throw new Error("Missing return statement in function");
0437: }
0438:
0439: final public StatementTree Compact() throws ParseException {
0440: StatementTree cmd = new StatementTree(
0441: "com.mckoi.database.interpret.Compact");
0442: String table_name;
0443: jj_consume_token(COMPACT);
0444: jj_consume_token(TABLE);
0445: table_name = TableName();
0446: cmd.putObject("table_name", table_name);
0447: {
0448: if (true)
0449: return cmd;
0450: }
0451: throw new Error("Missing return statement in function");
0452: }
0453:
0454: final public StatementTree CreateTable() throws ParseException {
0455: StatementTree cmd = new StatementTree(
0456: "com.mckoi.database.interpret.CreateTable");
0457: boolean temporary = false;
0458: boolean only_if_not_exists = false;
0459: String table_name;
0460: ArrayList column_list = new ArrayList();
0461: ArrayList constraint_list = new ArrayList();
0462: Expression check_expression;
0463: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0464: case TEMPORARY:
0465: jj_consume_token(TEMPORARY);
0466: temporary = true;
0467: break;
0468: default:
0469: jj_la1[9] = jj_gen;
0470: ;
0471: }
0472: jj_consume_token(TABLE);
0473: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0474: case IF:
0475: jj_consume_token(IF);
0476: jj_consume_token(NOT);
0477: jj_consume_token(EXISTS);
0478: only_if_not_exists = true;
0479: break;
0480: default:
0481: jj_la1[10] = jj_gen;
0482: ;
0483: }
0484: table_name = TableName();
0485: ColumnDeclarationList(column_list, constraint_list);
0486: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0487: case CHECK:
0488: jj_consume_token(CHECK);
0489: check_expression = DoExpression();
0490: ConstraintDef check_constraint = new ConstraintDef();
0491: check_constraint.setCheck(check_expression);
0492: constraint_list.add(check_constraint);
0493: break;
0494: default:
0495: jj_la1[11] = jj_gen;
0496: ;
0497: }
0498: cmd.putBoolean("temporary", temporary);
0499: cmd.putBoolean("only_if_not_exists", only_if_not_exists);
0500: cmd.putObject("table_name", table_name);
0501: cmd.putObject("column_list", column_list);
0502: cmd.putObject("constraint_list", constraint_list);
0503: {
0504: if (true)
0505: return cmd;
0506: }
0507: throw new Error("Missing return statement in function");
0508: }
0509:
0510: final public StatementTree CreateTrigger() throws ParseException {
0511: StatementTree cmd = new StatementTree(
0512: "com.mckoi.database.interpret.CreateTrigger");
0513: boolean callback;
0514: String trigger_name;
0515: ArrayList trigger_types = new ArrayList();
0516: String table_name;
0517: String before_after;
0518: String procedure_name;
0519: Expression[] procedure_args;
0520: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0521: case CALLBACK:
0522: jj_consume_token(CALLBACK);
0523: jj_consume_token(TRIGGER);
0524: trigger_name = TriggerName();
0525: TriggerTypes(trigger_types);
0526: jj_consume_token(ON);
0527: table_name = TableName();
0528: cmd.putObject("type", "callback_trigger");
0529: break;
0530: case TRIGGER:
0531: jj_consume_token(TRIGGER);
0532: trigger_name = TriggerName();
0533: before_after = BeforeOrAfter();
0534: TriggerTypes(trigger_types);
0535: jj_consume_token(ON);
0536: table_name = TableName();
0537: jj_consume_token(FOR);
0538: jj_consume_token(EACH);
0539: jj_consume_token(ROW);
0540: jj_consume_token(EXECUTE);
0541: jj_consume_token(PROCEDURE);
0542: procedure_name = FunctionName();
0543: jj_consume_token(208);
0544: procedure_args = ExpressionList();
0545: jj_consume_token(209);
0546: cmd.putObject("type", "procedure_trigger");
0547: cmd.putObject("before_after", before_after);
0548: cmd.putObject("procedure_name", procedure_name);
0549: cmd.putObject("procedure_args", procedure_args);
0550: break;
0551: default:
0552: jj_la1[12] = jj_gen;
0553: jj_consume_token(-1);
0554: throw new ParseException();
0555: }
0556: cmd.putObject("trigger_name", trigger_name);
0557: cmd.putObject("trigger_types", trigger_types);
0558: cmd.putObject("table_name", table_name);
0559: {
0560: if (true)
0561: return cmd;
0562: }
0563: throw new Error("Missing return statement in function");
0564: }
0565:
0566: final public StatementTree DropTrigger() throws ParseException {
0567: StatementTree cmd = new StatementTree(
0568: "com.mckoi.database.interpret.DropTrigger");
0569: String trigger_name;
0570: String type = null;
0571: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0572: case CALLBACK:
0573: jj_consume_token(CALLBACK);
0574: jj_consume_token(TRIGGER);
0575: trigger_name = TriggerName();
0576: type = "callback_trigger";
0577: break;
0578: case TRIGGER:
0579: jj_consume_token(TRIGGER);
0580: trigger_name = TriggerName();
0581: type = "procedure_trigger";
0582: cmd.putObject("trigger_name", trigger_name);
0583: cmd.putObject("type", type);
0584: {
0585: if (true)
0586: return cmd;
0587: }
0588: break;
0589: default:
0590: jj_la1[13] = jj_gen;
0591: jj_consume_token(-1);
0592: throw new ParseException();
0593: }
0594: throw new Error("Missing return statement in function");
0595: }
0596:
0597: final public StatementTree CreateFunction() throws ParseException {
0598: StatementTree cmd = new StatementTree(
0599: "com.mckoi.database.interpret.Function");
0600: cmd.putObject("type", "create");
0601: String function_name;
0602: ArrayList arg_names = new ArrayList();
0603: ArrayList arg_types = new ArrayList();
0604: Token loc_name;
0605: TType return_type = null;
0606: jj_consume_token(FUNCTION);
0607: function_name = FunctionName();
0608: jj_consume_token(208);
0609: ProcParameterList(arg_names, arg_types);
0610: jj_consume_token(209);
0611: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0612: case RETURNS:
0613: jj_consume_token(RETURNS);
0614: return_type = GetTType();
0615: break;
0616: default:
0617: jj_la1[14] = jj_gen;
0618: ;
0619: }
0620: jj_consume_token(LANGUAGE);
0621: jj_consume_token(JAVA);
0622: jj_consume_token(NAME);
0623: loc_name = jj_consume_token(STRING_LITERAL);
0624: cmd.putObject("function_name", function_name);
0625: cmd.putObject("arg_names", arg_names);
0626: cmd.putObject("arg_types", arg_types);
0627: // Note that 'location_name' will be a TObject
0628: cmd.putObject("location_name", Util.toParamObject(loc_name,
0629: case_insensitive_identifiers));
0630: cmd.putObject("return_type", return_type);
0631: {
0632: if (true)
0633: return cmd;
0634: }
0635: throw new Error("Missing return statement in function");
0636: }
0637:
0638: final public StatementTree DropFunction() throws ParseException {
0639: StatementTree cmd = new StatementTree(
0640: "com.mckoi.database.interpret.Function");
0641: cmd.putObject("type", "drop");
0642: String function_name;
0643: jj_consume_token(FUNCTION);
0644: function_name = FunctionName();
0645: cmd.putObject("function_name", function_name);
0646: {
0647: if (true)
0648: return cmd;
0649: }
0650: throw new Error("Missing return statement in function");
0651: }
0652:
0653: final public StatementTree CreateSchema() throws ParseException {
0654: StatementTree cmd = new StatementTree(
0655: "com.mckoi.database.interpret.Schema");
0656: cmd.putObject("type", "create");
0657: String schema_name;
0658: jj_consume_token(SCHEMA);
0659: schema_name = SchemaName();
0660: cmd.putObject("schema_name", schema_name);
0661: {
0662: if (true)
0663: return cmd;
0664: }
0665: throw new Error("Missing return statement in function");
0666: }
0667:
0668: final public StatementTree DropSchema() throws ParseException {
0669: StatementTree cmd = new StatementTree(
0670: "com.mckoi.database.interpret.Schema");
0671: cmd.putObject("type", "drop");
0672: String schema_name;
0673: jj_consume_token(SCHEMA);
0674: schema_name = SchemaName();
0675: cmd.putObject("schema_name", schema_name);
0676: {
0677: if (true)
0678: return cmd;
0679: }
0680: throw new Error("Missing return statement in function");
0681: }
0682:
0683: final public StatementTree CreateView() throws ParseException {
0684: StatementTree cmd = new StatementTree(
0685: "com.mckoi.database.interpret.ViewManager");
0686: String view_name;
0687: TableSelectExpression select_cmd;
0688: ArrayList col_list = new ArrayList();
0689: jj_consume_token(VIEW);
0690: view_name = TableName();
0691: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0692: case 208:
0693: jj_consume_token(208);
0694: BasicColumnList(col_list);
0695: jj_consume_token(209);
0696: break;
0697: default:
0698: jj_la1[15] = jj_gen;
0699: ;
0700: }
0701: jj_consume_token(AS);
0702: select_cmd = GetTableSelectExpression();
0703: cmd.putObject("type", "create");
0704: cmd.putObject("view_name", view_name);
0705: cmd.putObject("column_list", col_list);
0706: cmd.putObject("select_expression", select_cmd);
0707: {
0708: if (true)
0709: return cmd;
0710: }
0711: throw new Error("Missing return statement in function");
0712: }
0713:
0714: final public StatementTree DropView() throws ParseException {
0715: StatementTree cmd = new StatementTree(
0716: "com.mckoi.database.interpret.ViewManager");
0717: String view_name;
0718: jj_consume_token(VIEW);
0719: view_name = TableName();
0720: cmd.putObject("type", "drop");
0721: cmd.putObject("view_name", view_name);
0722: {
0723: if (true)
0724: return cmd;
0725: }
0726: throw new Error("Missing return statement in function");
0727: }
0728:
0729: final public StatementTree CreateIndex() throws ParseException {
0730: StatementTree cmd = new StatementTree(
0731: "com.mckoi.database.interpret.NoOp");
0732: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0733: case UNIQUE:
0734: jj_consume_token(UNIQUE);
0735: break;
0736: default:
0737: jj_la1[16] = jj_gen;
0738: ;
0739: }
0740: jj_consume_token(INDEX);
0741: IndexName();
0742: jj_consume_token(ON);
0743: TableName();
0744: jj_consume_token(208);
0745: BasicColumnList(new ArrayList());
0746: jj_consume_token(209);
0747: {
0748: if (true)
0749: return cmd;
0750: }
0751: throw new Error("Missing return statement in function");
0752: }
0753:
0754: final public StatementTree DropTable() throws ParseException {
0755: StatementTree cmd = new StatementTree(
0756: "com.mckoi.database.interpret.DropTable");
0757: boolean only_if_exists = false;
0758: String table_name;
0759: ArrayList table_list = new ArrayList();
0760: jj_consume_token(TABLE);
0761: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0762: case IF:
0763: jj_consume_token(IF);
0764: jj_consume_token(EXISTS);
0765: only_if_exists = true;
0766: break;
0767: default:
0768: jj_la1[17] = jj_gen;
0769: ;
0770: }
0771: table_name = TableName();
0772: table_list.add(table_name);
0773: label_1: while (true) {
0774: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0775: case 210:
0776: ;
0777: break;
0778: default:
0779: jj_la1[18] = jj_gen;
0780: break label_1;
0781: }
0782: jj_consume_token(210);
0783: table_name = TableName();
0784: table_list.add(table_name);
0785: }
0786: cmd.putBoolean("only_if_exists", only_if_exists);
0787: cmd.putObject("table_list", table_list);
0788: {
0789: if (true)
0790: return cmd;
0791: }
0792: throw new Error("Missing return statement in function");
0793: }
0794:
0795: final public StatementTree DropIndex() throws ParseException {
0796: StatementTree cmd = new StatementTree(
0797: "com.mckoi.database.interpret.NoOp");
0798: jj_consume_token(INDEX);
0799: IndexName();
0800: jj_consume_token(ON);
0801: TableName();
0802: {
0803: if (true)
0804: return cmd;
0805: }
0806: throw new Error("Missing return statement in function");
0807: }
0808:
0809: final public StatementTree Call() throws ParseException {
0810: StatementTree cmd = new StatementTree(
0811: "com.mckoi.database.interpret.Call");
0812: String proc_name;
0813: Expression[] args = null;
0814: jj_consume_token(CALL);
0815: proc_name = ProcedureName();
0816: jj_consume_token(208);
0817: args = ExpressionList();
0818: jj_consume_token(209);
0819: cmd.putObject("proc_name", proc_name);
0820: cmd.putObject("args", args);
0821: {
0822: if (true)
0823: return cmd;
0824: }
0825: throw new Error("Missing return statement in function");
0826: }
0827:
0828: final public StatementTree CreateSequence() throws ParseException {
0829: StatementTree cmd = new StatementTree(
0830: "com.mckoi.database.interpret.Sequence");
0831: cmd.putObject("type", "create");
0832: String seq_name;
0833: Expression v;
0834: jj_consume_token(SEQUENCE);
0835: seq_name = SequenceName();
0836: cmd.putObject("seq_name", seq_name);
0837: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0838: case INCREMENT:
0839: jj_consume_token(INCREMENT);
0840: v = DoExpression();
0841: cmd.putObject("increment", v);
0842: break;
0843: default:
0844: jj_la1[19] = jj_gen;
0845: ;
0846: }
0847: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0848: case MINVALUE:
0849: jj_consume_token(MINVALUE);
0850: v = DoExpression();
0851: cmd.putObject("min_value", v);
0852: break;
0853: default:
0854: jj_la1[20] = jj_gen;
0855: ;
0856: }
0857: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0858: case MAXVALUE:
0859: jj_consume_token(MAXVALUE);
0860: v = DoExpression();
0861: cmd.putObject("max_value", v);
0862: break;
0863: default:
0864: jj_la1[21] = jj_gen;
0865: ;
0866: }
0867: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0868: case START:
0869: jj_consume_token(START);
0870: v = DoExpression();
0871: cmd.putObject("start", v);
0872: break;
0873: default:
0874: jj_la1[22] = jj_gen;
0875: ;
0876: }
0877: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0878: case CACHE:
0879: jj_consume_token(CACHE);
0880: v = DoExpression();
0881: cmd.putObject("cache", v);
0882: break;
0883: default:
0884: jj_la1[23] = jj_gen;
0885: ;
0886: }
0887: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0888: case CYCLE:
0889: jj_consume_token(CYCLE);
0890: cmd.putObject("cycle", "yes");
0891: break;
0892: default:
0893: jj_la1[24] = jj_gen;
0894: ;
0895: }
0896: {
0897: if (true)
0898: return cmd;
0899: }
0900: throw new Error("Missing return statement in function");
0901: }
0902:
0903: final public StatementTree DropSequence() throws ParseException {
0904: StatementTree cmd = new StatementTree(
0905: "com.mckoi.database.interpret.Sequence");
0906: cmd.putObject("type", "drop");
0907: String seq_name;
0908: jj_consume_token(SEQUENCE);
0909: seq_name = SequenceName();
0910: cmd.putObject("seq_name", seq_name);
0911: {
0912: if (true)
0913: return cmd;
0914: }
0915: throw new Error("Missing return statement in function");
0916: }
0917:
0918: final public StatementTree CreateUser() throws ParseException {
0919: StatementTree cmd = new StatementTree(
0920: "com.mckoi.database.interpret.UserManager");
0921: cmd.putObject("type", "CREATE USER");
0922: jj_consume_token(USER);
0923: UserManagerCommand(cmd);
0924: {
0925: if (true)
0926: return cmd;
0927: }
0928: throw new Error("Missing return statement in function");
0929: }
0930:
0931: final public StatementTree AlterUser() throws ParseException {
0932: StatementTree cmd = new StatementTree(
0933: "com.mckoi.database.interpret.UserManager");
0934: cmd.putObject("type", "ALTER USER");
0935: jj_consume_token(USER);
0936: UserManagerCommand(cmd);
0937: {
0938: if (true)
0939: return cmd;
0940: }
0941: throw new Error("Missing return statement in function");
0942: }
0943:
0944: final public StatementTree DropUser() throws ParseException {
0945: StatementTree cmd = new StatementTree(
0946: "com.mckoi.database.interpret.UserManager");
0947: cmd.putObject("type", "DROP USER");
0948: String username;
0949: jj_consume_token(USER);
0950: username = UserName();
0951: cmd.putObject("username", username);
0952: {
0953: if (true)
0954: return cmd;
0955: }
0956: throw new Error("Missing return statement in function");
0957: }
0958:
0959: final public void UserManagerCommand(StatementTree cmd)
0960: throws ParseException {
0961: String username;
0962: Expression password_exp;
0963: Expression[] groups_list = null;
0964: String lock_status = null;
0965: username = UserName();
0966: jj_consume_token(SET);
0967: jj_consume_token(PASSWORD);
0968: password_exp = DoExpression();
0969: if (jj_2_1(2)) {
0970: jj_consume_token(SET);
0971: jj_consume_token(GROUPS);
0972: groups_list = ExpressionList();
0973: } else {
0974: ;
0975: }
0976: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0977: case SET:
0978: jj_consume_token(SET);
0979: jj_consume_token(ACCOUNT);
0980: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0981: case LOCK:
0982: jj_consume_token(LOCK);
0983: lock_status = "LOCK";
0984: break;
0985: case UNLOCK:
0986: jj_consume_token(UNLOCK);
0987: lock_status = "UNLOCK";
0988: break;
0989: default:
0990: jj_la1[25] = jj_gen;
0991: jj_consume_token(-1);
0992: throw new ParseException();
0993: }
0994: break;
0995: default:
0996: jj_la1[26] = jj_gen;
0997: ;
0998: }
0999: cmd.putObject("username", username);
1000: cmd.putObject("password_expression", password_exp);
1001: cmd.putObject("groups_list", groups_list);
1002: cmd.putObject("lock_status", lock_status);
1003: }
1004:
1005: final public StatementTree Delete() throws ParseException {
1006: StatementTree cmd = new StatementTree(
1007: "com.mckoi.database.interpret.Delete");
1008: String table_name;
1009: SearchExpression where_clause = new SearchExpression();
1010: int limit = -1;
1011: jj_consume_token(DELETE);
1012: jj_consume_token(FROM);
1013: table_name = TableName();
1014: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1015: case WHERE:
1016: jj_consume_token(WHERE);
1017: ConditionsExpression(where_clause);
1018: break;
1019: default:
1020: jj_la1[27] = jj_gen;
1021: ;
1022: }
1023: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1024: case LIMIT:
1025: jj_consume_token(LIMIT);
1026: limit = PositiveIntegerConstant();
1027: break;
1028: default:
1029: jj_la1[28] = jj_gen;
1030: ;
1031: }
1032: cmd.putObject("table_name", table_name);
1033: cmd.putObject("where_clause", where_clause);
1034: cmd.putInt("limit", limit);
1035: {
1036: if (true)
1037: return cmd;
1038: }
1039: throw new Error("Missing return statement in function");
1040: }
1041:
1042: final public StatementTree Insert() throws ParseException {
1043: StatementTree cmd = new StatementTree(
1044: "com.mckoi.database.interpret.Insert");
1045: String table_name;
1046: ArrayList col_list = new ArrayList();
1047: ArrayList data_list = new ArrayList(); // ( Array of Expression[] )
1048: StatementTree select = null;
1049: ArrayList assignments = new ArrayList();
1050: String type;
1051: jj_consume_token(INSERT);
1052: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1053: case INTO:
1054: jj_consume_token(INTO);
1055: break;
1056: default:
1057: jj_la1[29] = jj_gen;
1058: ;
1059: }
1060: table_name = TableName();
1061: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1062: case SELECT:
1063: case VALUES:
1064: case 208:
1065: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1066: case 208:
1067: jj_consume_token(208);
1068: BasicColumnList(col_list);
1069: jj_consume_token(209);
1070: break;
1071: default:
1072: jj_la1[30] = jj_gen;
1073: ;
1074: }
1075: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1076: case VALUES:
1077: jj_consume_token(VALUES);
1078: InsertDataList(data_list);
1079: type = "from_values";
1080: break;
1081: case SELECT:
1082: select = Select();
1083: type = "from_select";
1084: break;
1085: default:
1086: jj_la1[31] = jj_gen;
1087: jj_consume_token(-1);
1088: throw new ParseException();
1089: }
1090: break;
1091: case SET:
1092: jj_consume_token(SET);
1093: AssignmentList(assignments);
1094: type = "from_set";
1095: break;
1096: default:
1097: jj_la1[32] = jj_gen;
1098: jj_consume_token(-1);
1099: throw new ParseException();
1100: }
1101: cmd.putObject("table_name", table_name);
1102: cmd.putObject("col_list", col_list);
1103: cmd.putObject("data_list", data_list);
1104: cmd.putObject("select", select);
1105: cmd.putObject("assignments", assignments);
1106: cmd.putObject("type", type);
1107: {
1108: if (true)
1109: return cmd;
1110: }
1111: throw new Error("Missing return statement in function");
1112: }
1113:
1114: final public StatementTree Describe() throws ParseException {
1115: StatementTree cmd = new StatementTree(
1116: "com.mckoi.database.interpret.Show");
1117: cmd.putObject("show", "describe_table");
1118: String table_name;
1119: jj_consume_token(DESCRIBE);
1120: table_name = TableName();
1121: cmd.putObject("table_name", table_name);
1122: cmd.putObject("where_clause", new SearchExpression());
1123: {
1124: if (true)
1125: return cmd;
1126: }
1127: throw new Error("Missing return statement in function");
1128: }
1129:
1130: final public StatementTree Show() throws ParseException {
1131: StatementTree cmd = new StatementTree(
1132: "com.mckoi.database.interpret.Show");
1133: Expression[] args = null;
1134: SearchExpression where_clause = new SearchExpression();
1135: Token t;
1136: jj_consume_token(SHOW);
1137: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1138: case IDENTIFIER:
1139: t = jj_consume_token(IDENTIFIER);
1140: break;
1141: case SCHEMA:
1142: t = jj_consume_token(SCHEMA);
1143: break;
1144: default:
1145: jj_la1[33] = jj_gen;
1146: jj_consume_token(-1);
1147: throw new ParseException();
1148: }
1149: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1150: case 208:
1151: jj_consume_token(208);
1152: args = ExpressionList();
1153: jj_consume_token(209);
1154: break;
1155: default:
1156: jj_la1[34] = jj_gen;
1157: ;
1158: }
1159: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1160: case WHERE:
1161: jj_consume_token(WHERE);
1162: ConditionsExpression(where_clause);
1163: break;
1164: default:
1165: jj_la1[35] = jj_gen;
1166: ;
1167: }
1168: cmd.putObject("show", t.image);
1169: cmd.putObject("args", args);
1170: cmd.putObject("where_clause", where_clause);
1171: {
1172: if (true)
1173: return cmd;
1174: }
1175: throw new Error("Missing return statement in function");
1176: }
1177:
1178: final public StatementTree Grant() throws ParseException {
1179: StatementTree cmd = new StatementTree(
1180: "com.mckoi.database.interpret.PrivManager");
1181: ArrayList priv_list = new ArrayList();
1182: String priv_object;
1183: ArrayList grant_to;
1184: boolean grant_option = false;
1185: jj_consume_token(GRANT);
1186: PrivList(priv_list);
1187: jj_consume_token(ON);
1188: priv_object = PrivObject();
1189: jj_consume_token(TO);
1190: grant_to = UserNameList(new ArrayList());
1191: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1192: case WITH:
1193: jj_consume_token(WITH);
1194: jj_consume_token(GRANT);
1195: jj_consume_token(OPTION);
1196: grant_option = true;
1197: break;
1198: default:
1199: jj_la1[36] = jj_gen;
1200: ;
1201: }
1202: cmd.putObject("command", "GRANT");
1203: cmd.putObject("priv_list", priv_list);
1204: cmd.putObject("priv_object", priv_object);
1205: cmd.putObject("grant_to", grant_to);
1206: cmd.putBoolean("grant_option", grant_option);
1207: {
1208: if (true)
1209: return cmd;
1210: }
1211: throw new Error("Missing return statement in function");
1212: }
1213:
1214: final public StatementTree Revoke() throws ParseException {
1215: StatementTree cmd = new StatementTree(
1216: "com.mckoi.database.interpret.PrivManager");
1217: ArrayList priv_list = new ArrayList();
1218: String priv_object;
1219: ArrayList revoke_from;
1220: boolean revoke_grant_option = false;
1221: jj_consume_token(REVOKE);
1222: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1223: case GRANT:
1224: jj_consume_token(GRANT);
1225: jj_consume_token(OPTION);
1226: jj_consume_token(FOR);
1227: revoke_grant_option = true;
1228: break;
1229: default:
1230: jj_la1[37] = jj_gen;
1231: ;
1232: }
1233: PrivList(priv_list);
1234: jj_consume_token(ON);
1235: priv_object = PrivObject();
1236: jj_consume_token(FROM);
1237: revoke_from = UserNameList(new ArrayList());
1238: cmd.putObject("command", "REVOKE");
1239: cmd.putObject("priv_list", priv_list);
1240: cmd.putObject("priv_object", priv_object);
1241: cmd.putObject("revoke_from", revoke_from);
1242: cmd.putBoolean("revoke_grant_option", revoke_grant_option);
1243: {
1244: if (true)
1245: return cmd;
1246: }
1247: throw new Error("Missing return statement in function");
1248: }
1249:
1250: final public StatementTree CompleteTransaction()
1251: throws ParseException {
1252: StatementTree cmd = new StatementTree(
1253: "com.mckoi.database.interpret.CompleteTransaction");
1254: String command;
1255: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1256: case COMMIT:
1257: jj_consume_token(COMMIT);
1258: command = "commit";
1259: break;
1260: case ROLLBACK:
1261: jj_consume_token(ROLLBACK);
1262: command = "rollback";
1263: break;
1264: default:
1265: jj_la1[38] = jj_gen;
1266: jj_consume_token(-1);
1267: throw new ParseException();
1268: }
1269: cmd.putObject("command", command);
1270: {
1271: if (true)
1272: return cmd;
1273: }
1274: throw new Error("Missing return statement in function");
1275: }
1276:
1277: final public StatementTree Set() throws ParseException {
1278: StatementTree cmd = new StatementTree(
1279: "com.mckoi.database.interpret.Set");
1280: Token t1;
1281: String value;
1282: Expression exp;
1283: String name;
1284: jj_consume_token(SET);
1285: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1286: case IDENTIFIER:
1287: t1 = jj_consume_token(IDENTIFIER);
1288: jj_consume_token(ASSIGNMENT);
1289: exp = DoExpression();
1290: cmd.putObject("type", "VARSET");
1291: cmd.putObject("var_name", t1.image);
1292: cmd.putObject("exp", exp);
1293: break;
1294: case TRANSACTIONISOLATIONLEVEL:
1295: jj_consume_token(TRANSACTIONISOLATIONLEVEL);
1296: t1 = jj_consume_token(SERIALIZABLE);
1297: cmd.putObject("type", "ISOLATIONSET");
1298: cmd.putObject("var_name", "TRANSACTION ISOLATION LEVEL");
1299: cmd.putObject("value", t1.image);
1300: break;
1301: case AUTOCOMMIT:
1302: jj_consume_token(AUTOCOMMIT);
1303: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1304: case ON:
1305: t1 = jj_consume_token(ON);
1306: break;
1307: case IDENTIFIER:
1308: t1 = jj_consume_token(IDENTIFIER);
1309: break;
1310: default:
1311: jj_la1[39] = jj_gen;
1312: jj_consume_token(-1);
1313: throw new ParseException();
1314: }
1315: cmd.putObject("type", "AUTOCOMMIT");
1316: cmd.putObject("value", t1.image);
1317: break;
1318: case SCHEMA:
1319: jj_consume_token(SCHEMA);
1320: name = SchemaName();
1321: cmd.putObject("type", "SCHEMA");
1322: cmd.putObject("value", name);
1323: break;
1324: default:
1325: jj_la1[40] = jj_gen;
1326: jj_consume_token(-1);
1327: throw new ParseException();
1328: }
1329: {
1330: if (true)
1331: return cmd;
1332: }
1333: throw new Error("Missing return statement in function");
1334: }
1335:
1336: final public StatementTree ShutDown() throws ParseException {
1337: StatementTree cmd = new StatementTree(
1338: "com.mckoi.database.interpret.Misc");
1339: jj_consume_token(SHUTDOWN);
1340: cmd.putObject("command", "shutdown");
1341: {
1342: if (true)
1343: return cmd;
1344: }
1345: throw new Error("Missing return statement in function");
1346: }
1347:
1348: // ----------
1349: final public String TriggerType() throws ParseException {
1350: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1351: case INSERT:
1352: jj_consume_token(INSERT);
1353: {
1354: if (true)
1355: return "insert";
1356: }
1357: break;
1358: case DELETE:
1359: jj_consume_token(DELETE);
1360: {
1361: if (true)
1362: return "delete";
1363: }
1364: break;
1365: case UPDATE:
1366: jj_consume_token(UPDATE);
1367: {
1368: if (true)
1369: return "update";
1370: }
1371: break;
1372: default:
1373: jj_la1[41] = jj_gen;
1374: jj_consume_token(-1);
1375: throw new ParseException();
1376: }
1377: throw new Error("Missing return statement in function");
1378: }
1379:
1380: final public String BeforeOrAfter() throws ParseException {
1381: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1382: case BEFORE:
1383: jj_consume_token(BEFORE);
1384: {
1385: if (true)
1386: return "before";
1387: }
1388: break;
1389: case AFTER:
1390: jj_consume_token(AFTER);
1391: {
1392: if (true)
1393: return "after";
1394: }
1395: break;
1396: default:
1397: jj_la1[42] = jj_gen;
1398: jj_consume_token(-1);
1399: throw new ParseException();
1400: }
1401: throw new Error("Missing return statement in function");
1402: }
1403:
1404: // A list of triggered actions separated by 'OR' delimination, for example,
1405: // INSERT OR DELETE OR UPDATE
1406: final public void TriggerTypes(ArrayList list)
1407: throws ParseException {
1408: String trig_type;
1409: trig_type = TriggerType();
1410: list.add(trig_type);
1411: label_2: while (true) {
1412: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1413: case OR:
1414: ;
1415: break;
1416: default:
1417: jj_la1[43] = jj_gen;
1418: break label_2;
1419: }
1420: jj_consume_token(OR);
1421: trig_type = TriggerType();
1422: list.add(trig_type);
1423: }
1424: }
1425:
1426: // A priv object
1427: // Note we add a 2 character prefix to the priv object for future enhancements.
1428: // In the future an object may be something other than a table.
1429: final public String PrivObject() throws ParseException {
1430: String table_name;
1431: String schema_name;
1432: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1433: case OLD:
1434: case NEW:
1435: case NAME:
1436: case JAVA:
1437: case TABLE:
1438: case ACTION:
1439: case GROUPS:
1440: case OPTION:
1441: case ACCOUNT:
1442: case PASSWORD:
1443: case LANGUAGE:
1444: case PRIVILEGES:
1445: case QUOTED_VARIABLE:
1446: case IDENTIFIER:
1447: case DOT_DELIMINATED_REF:
1448: case QUOTED_DELIMINATED_REF:
1449: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1450: case TABLE:
1451: jj_consume_token(TABLE);
1452: break;
1453: default:
1454: jj_la1[44] = jj_gen;
1455: ;
1456: }
1457: table_name = TableName();
1458: {
1459: if (true)
1460: return "T:" + table_name;
1461: }
1462: break;
1463: case SCHEMA:
1464: jj_consume_token(SCHEMA);
1465: schema_name = SchemaName();
1466: {
1467: if (true)
1468: return "S:" + schema_name;
1469: }
1470: break;
1471: default:
1472: jj_la1[45] = jj_gen;
1473: jj_consume_token(-1);
1474: throw new ParseException();
1475: }
1476: throw new Error("Missing return statement in function");
1477: }
1478:
1479: // A list of privs
1480: final public ArrayList PrivList(ArrayList list)
1481: throws ParseException {
1482: PrivListItem(list);
1483: label_3: while (true) {
1484: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1485: case 210:
1486: ;
1487: break;
1488: default:
1489: jj_la1[46] = jj_gen;
1490: break label_3;
1491: }
1492: jj_consume_token(210);
1493: PrivListItem(list);
1494: }
1495: {
1496: if (true)
1497: return list;
1498: }
1499: throw new Error("Missing return statement in function");
1500: }
1501:
1502: // Adds an item in a priv list
1503: final public void PrivListItem(ArrayList list)
1504: throws ParseException {
1505: Token t;
1506: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1507: case SELECT:
1508: t = jj_consume_token(SELECT);
1509: break;
1510: case INSERT:
1511: t = jj_consume_token(INSERT);
1512: break;
1513: case UPDATE:
1514: t = jj_consume_token(UPDATE);
1515: break;
1516: case DELETE:
1517: t = jj_consume_token(DELETE);
1518: break;
1519: case REFERENCES:
1520: t = jj_consume_token(REFERENCES);
1521: break;
1522: case USAGE:
1523: t = jj_consume_token(USAGE);
1524: break;
1525: case ALL:
1526: t = jj_consume_token(ALL);
1527: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1528: case PRIVILEGES:
1529: jj_consume_token(PRIVILEGES);
1530: break;
1531: default:
1532: jj_la1[47] = jj_gen;
1533: ;
1534: }
1535: break;
1536: default:
1537: jj_la1[48] = jj_gen;
1538: jj_consume_token(-1);
1539: throw new ParseException();
1540: }
1541: list.add(t.image);
1542: }
1543:
1544: // A table expression
1545: final public TableSelectExpression GetTableSelectExpression()
1546: throws ParseException {
1547: TableSelectExpression table_expr = new TableSelectExpression();
1548: String composite = "";
1549: boolean is_all = false;
1550: TableSelectExpression next_composite_expression;
1551: jj_consume_token(SELECT);
1552: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1553: case ALL:
1554: case DISTINCT:
1555: table_expr.distinct = SetQuantifier();
1556: break;
1557: default:
1558: jj_la1[49] = jj_gen;
1559: ;
1560: }
1561: SelectColumnList(table_expr.columns);
1562: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1563: case FROM:
1564: jj_consume_token(FROM);
1565: SelectTableList(table_expr.from_clause);
1566: break;
1567: default:
1568: jj_la1[50] = jj_gen;
1569: ;
1570: }
1571: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1572: case WHERE:
1573: jj_consume_token(WHERE);
1574: ConditionsExpression(table_expr.where_clause);
1575: break;
1576: default:
1577: jj_la1[51] = jj_gen;
1578: ;
1579: }
1580: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1581: case GROUPBY:
1582: jj_consume_token(GROUPBY);
1583: SelectGroupByList(table_expr.group_by);
1584: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1585: case GROUPMAX:
1586: jj_consume_token(GROUPMAX);
1587: table_expr.group_max = GroupMaxColumn();
1588: break;
1589: default:
1590: jj_la1[52] = jj_gen;
1591: ;
1592: }
1593: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1594: case HAVING:
1595: jj_consume_token(HAVING);
1596: ConditionsExpression(table_expr.having_clause);
1597: break;
1598: default:
1599: jj_la1[53] = jj_gen;
1600: ;
1601: }
1602: break;
1603: default:
1604: jj_la1[54] = jj_gen;
1605: ;
1606: }
1607: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1608: case UNION:
1609: case EXCEPT:
1610: case INTERSECT:
1611: composite = GetComposite();
1612: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1613: case ALL:
1614: jj_consume_token(ALL);
1615: is_all = true;
1616: break;
1617: default:
1618: jj_la1[55] = jj_gen;
1619: ;
1620: }
1621: next_composite_expression = GetTableSelectExpression();
1622: table_expr.chainComposite(next_composite_expression,
1623: composite, is_all);
1624: break;
1625: default:
1626: jj_la1[56] = jj_gen;
1627: ;
1628: }
1629: {
1630: if (true)
1631: return table_expr;
1632: }
1633: throw new Error("Missing return statement in function");
1634: }
1635:
1636: final public AlterTableAction GetAlterTableAction()
1637: throws ParseException {
1638: String col_name, con_name;
1639: ColumnDef column_def;
1640: ConstraintDef constraint_def;
1641: Expression default_exp;
1642: AlterTableAction action = new AlterTableAction();
1643: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1644: case SQLADD:
1645: jj_consume_token(SQLADD);
1646: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1647: case NAME:
1648: case JAVA:
1649: case ACTION:
1650: case GROUPS:
1651: case OPTION:
1652: case SQLCOLUMN:
1653: case ACCOUNT:
1654: case PASSWORD:
1655: case LANGUAGE:
1656: case PRIVILEGES:
1657: case QUOTED_VARIABLE:
1658: case IDENTIFIER:
1659: case DOT_DELIMINATED_REF:
1660: case QUOTED_DELIMINATED_REF:
1661: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1662: case SQLCOLUMN:
1663: jj_consume_token(SQLCOLUMN);
1664: break;
1665: default:
1666: jj_la1[57] = jj_gen;
1667: ;
1668: }
1669: column_def = ColumnDefinition();
1670: action.setAction("ADD");
1671: action.addElement(column_def);
1672: break;
1673: case CHECK:
1674: case UNIQUE:
1675: case CONSTRAINT:
1676: case PRIMARY:
1677: case FOREIGN:
1678: constraint_def = TableConstraintDefinition();
1679: action.setAction("ADD_CONSTRAINT");
1680: action.addElement(constraint_def);
1681: break;
1682: default:
1683: jj_la1[58] = jj_gen;
1684: jj_consume_token(-1);
1685: throw new ParseException();
1686: }
1687: break;
1688: case ALTER:
1689: jj_consume_token(ALTER);
1690: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1691: case SQLCOLUMN:
1692: jj_consume_token(SQLCOLUMN);
1693: break;
1694: default:
1695: jj_la1[59] = jj_gen;
1696: ;
1697: }
1698: col_name = ColumnName();
1699: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1700: case SET:
1701: jj_consume_token(SET);
1702: default_exp = DoExpression();
1703: action.setAction("ALTERSET");
1704: action.addElement(col_name);
1705: action.addElement(default_exp);
1706: break;
1707: case DROP:
1708: jj_consume_token(DROP);
1709: jj_consume_token(SQLDEFAULT);
1710: action.setAction("DROPDEFAULT");
1711: action.addElement(col_name);
1712: break;
1713: default:
1714: jj_la1[60] = jj_gen;
1715: jj_consume_token(-1);
1716: throw new ParseException();
1717: }
1718: break;
1719: case DROP:
1720: jj_consume_token(DROP);
1721: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1722: case NAME:
1723: case JAVA:
1724: case ACTION:
1725: case GROUPS:
1726: case OPTION:
1727: case SQLCOLUMN:
1728: case ACCOUNT:
1729: case PASSWORD:
1730: case LANGUAGE:
1731: case PRIVILEGES:
1732: case QUOTED_VARIABLE:
1733: case IDENTIFIER:
1734: case DOT_DELIMINATED_REF:
1735: case QUOTED_DELIMINATED_REF:
1736: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1737: case SQLCOLUMN:
1738: jj_consume_token(SQLCOLUMN);
1739: break;
1740: default:
1741: jj_la1[61] = jj_gen;
1742: ;
1743: }
1744: col_name = ColumnName();
1745: action.setAction("DROP");
1746: action.addElement(col_name);
1747: break;
1748: case CONSTRAINT:
1749: jj_consume_token(CONSTRAINT);
1750: con_name = ConstraintName();
1751: action.setAction("DROP_CONSTRAINT");
1752: action.addElement(con_name);
1753: break;
1754: case PRIMARY:
1755: jj_consume_token(PRIMARY);
1756: jj_consume_token(KEY);
1757: action.setAction("DROP_CONSTRAINT_PRIMARY_KEY");
1758: break;
1759: default:
1760: jj_la1[62] = jj_gen;
1761: jj_consume_token(-1);
1762: throw new ParseException();
1763: }
1764: break;
1765: default:
1766: jj_la1[63] = jj_gen;
1767: jj_consume_token(-1);
1768: throw new ParseException();
1769: }
1770: {
1771: if (true)
1772: return action;
1773: }
1774: throw new Error("Missing return statement in function");
1775: }
1776:
1777: // An element to insert, either an expression or DEFAULT for the default
1778: // element.
1779: final public Object InsertElement() throws ParseException {
1780: Expression e;
1781: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1782: case SQLDEFAULT:
1783: jj_consume_token(SQLDEFAULT);
1784: {
1785: if (true)
1786: return "DEFAULT";
1787: }
1788: break;
1789: case ADD:
1790: case SUBTRACT:
1791: case BOOLEAN_LITERAL:
1792: case NULL_LITERAL:
1793: case IF:
1794: case NEW:
1795: case TRIM:
1796: case USER:
1797: case CAST:
1798: case NAME:
1799: case JAVA:
1800: case COUNT:
1801: case ACTION:
1802: case GROUPS:
1803: case OPTION:
1804: case ACCOUNT:
1805: case PASSWORD:
1806: case LANGUAGE:
1807: case PRIVILEGES:
1808: case DATE:
1809: case TIME:
1810: case TIMESTAMP:
1811: case CURRENT_TIME:
1812: case CURRENT_DATE:
1813: case CURRENT_TIMESTAMP:
1814: case NOT:
1815: case NUMBER_LITERAL:
1816: case STRING_LITERAL:
1817: case QUOTED_VARIABLE:
1818: case IDENTIFIER:
1819: case DOT_DELIMINATED_REF:
1820: case QUOTED_DELIMINATED_REF:
1821: case PARAMETER_REF:
1822: case 208:
1823: e = DoExpression();
1824: {
1825: if (true)
1826: return e;
1827: }
1828: break;
1829: default:
1830: jj_la1[64] = jj_gen;
1831: jj_consume_token(-1);
1832: throw new ParseException();
1833: }
1834: throw new Error("Missing return statement in function");
1835: }
1836:
1837: final public ArrayList InsertExpressionList() throws ParseException {
1838: ArrayList list = new ArrayList();
1839: Object elem;
1840: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1841: case ADD:
1842: case SUBTRACT:
1843: case BOOLEAN_LITERAL:
1844: case NULL_LITERAL:
1845: case IF:
1846: case NEW:
1847: case TRIM:
1848: case USER:
1849: case CAST:
1850: case NAME:
1851: case JAVA:
1852: case COUNT:
1853: case ACTION:
1854: case GROUPS:
1855: case OPTION:
1856: case ACCOUNT:
1857: case SQLDEFAULT:
1858: case PASSWORD:
1859: case LANGUAGE:
1860: case PRIVILEGES:
1861: case DATE:
1862: case TIME:
1863: case TIMESTAMP:
1864: case CURRENT_TIME:
1865: case CURRENT_DATE:
1866: case CURRENT_TIMESTAMP:
1867: case NOT:
1868: case NUMBER_LITERAL:
1869: case STRING_LITERAL:
1870: case QUOTED_VARIABLE:
1871: case IDENTIFIER:
1872: case DOT_DELIMINATED_REF:
1873: case QUOTED_DELIMINATED_REF:
1874: case PARAMETER_REF:
1875: case 208:
1876: elem = InsertElement();
1877: list.add(elem);
1878: label_4: while (true) {
1879: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1880: case 210:
1881: ;
1882: break;
1883: default:
1884: jj_la1[65] = jj_gen;
1885: break label_4;
1886: }
1887: jj_consume_token(210);
1888: elem = InsertElement();
1889: list.add(elem);
1890: }
1891: break;
1892: default:
1893: jj_la1[66] = jj_gen;
1894: ;
1895: }
1896: {
1897: if (true)
1898: return list;
1899: }
1900: throw new Error("Missing return statement in function");
1901: }
1902:
1903: // The list of columns to insert formatted as; eg. (9, 4), (3, 2), (9, 9), ....
1904: final public void InsertDataList(ArrayList data_list)
1905: throws ParseException {
1906: ArrayList insert_vals;
1907: jj_consume_token(208);
1908: insert_vals = InsertExpressionList();
1909: jj_consume_token(209);
1910: data_list.add(insert_vals);
1911: label_5: while (true) {
1912: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1913: case 210:
1914: ;
1915: break;
1916: default:
1917: jj_la1[67] = jj_gen;
1918: break label_5;
1919: }
1920: jj_consume_token(210);
1921: jj_consume_token(208);
1922: insert_vals = InsertExpressionList();
1923: jj_consume_token(209);
1924: data_list.add(insert_vals);
1925: }
1926: }
1927:
1928: // Returning true means distinct, false means all.
1929: final public boolean SetQuantifier() throws ParseException {
1930: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1931: case DISTINCT:
1932: jj_consume_token(DISTINCT);
1933: {
1934: if (true)
1935: return true;
1936: }
1937: break;
1938: case ALL:
1939: jj_consume_token(ALL);
1940: {
1941: if (true)
1942: return false;
1943: }
1944: break;
1945: default:
1946: jj_la1[68] = jj_gen;
1947: jj_consume_token(-1);
1948: throw new ParseException();
1949: }
1950: throw new Error("Missing return statement in function");
1951: }
1952:
1953: final public void SelectColumnList(ArrayList list)
1954: throws ParseException {
1955: SelectColumn col;
1956: col = SelectColumn();
1957: list.add(col);
1958: label_6: while (true) {
1959: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1960: case 210:
1961: ;
1962: break;
1963: default:
1964: jj_la1[69] = jj_gen;
1965: break label_6;
1966: }
1967: jj_consume_token(210);
1968: col = SelectColumn();
1969: list.add(col);
1970: }
1971: }
1972:
1973: final public SelectColumn SelectColumn() throws ParseException {
1974: SelectColumn col = new SelectColumn();
1975: String aliased_name;
1976: Token t;
1977: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1978: case ADD:
1979: case SUBTRACT:
1980: case BOOLEAN_LITERAL:
1981: case NULL_LITERAL:
1982: case IF:
1983: case NEW:
1984: case TRIM:
1985: case USER:
1986: case CAST:
1987: case NAME:
1988: case JAVA:
1989: case COUNT:
1990: case ACTION:
1991: case GROUPS:
1992: case OPTION:
1993: case ACCOUNT:
1994: case PASSWORD:
1995: case LANGUAGE:
1996: case PRIVILEGES:
1997: case DATE:
1998: case TIME:
1999: case TIMESTAMP:
2000: case CURRENT_TIME:
2001: case CURRENT_DATE:
2002: case CURRENT_TIMESTAMP:
2003: case NOT:
2004: case NUMBER_LITERAL:
2005: case STRING_LITERAL:
2006: case QUOTED_VARIABLE:
2007: case IDENTIFIER:
2008: case DOT_DELIMINATED_REF:
2009: case QUOTED_DELIMINATED_REF:
2010: case PARAMETER_REF:
2011: case 208:
2012: col.expression = DoExpression();
2013: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2014: case AS:
2015: jj_consume_token(AS);
2016: break;
2017: default:
2018: jj_la1[70] = jj_gen;
2019: ;
2020: }
2021: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2022: case NAME:
2023: case JAVA:
2024: case ACTION:
2025: case GROUPS:
2026: case OPTION:
2027: case ACCOUNT:
2028: case PASSWORD:
2029: case LANGUAGE:
2030: case PRIVILEGES:
2031: case QUOTED_VARIABLE:
2032: case IDENTIFIER:
2033: col.alias = TableAliasName();
2034: break;
2035: default:
2036: jj_la1[71] = jj_gen;
2037: ;
2038: }
2039: break;
2040: case STAR:
2041: jj_consume_token(STAR);
2042: col.glob_name = "*";
2043: break;
2044: case GLOBVARIABLE:
2045: t = jj_consume_token(GLOBVARIABLE);
2046: col.glob_name = caseCheck(t.image);
2047: break;
2048: case QUOTEDGLOBVARIABLE:
2049: t = jj_consume_token(QUOTEDGLOBVARIABLE);
2050: col.glob_name = caseCheck(Util.asNonQuotedRef(t));
2051: break;
2052: default:
2053: jj_la1[72] = jj_gen;
2054: jj_consume_token(-1);
2055: throw new ParseException();
2056: }
2057: {
2058: if (true)
2059: return col;
2060: }
2061: throw new Error("Missing return statement in function");
2062: }
2063:
2064: final public void SelectGroupByList(ArrayList list)
2065: throws ParseException {
2066: ByColumn col;
2067: Expression exp;
2068: exp = DoExpression();
2069: col = new ByColumn();
2070: col.exp = exp;
2071: list.add(col);
2072: label_7: while (true) {
2073: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2074: case 210:
2075: ;
2076: break;
2077: default:
2078: jj_la1[73] = jj_gen;
2079: break label_7;
2080: }
2081: jj_consume_token(210);
2082: exp = DoExpression();
2083: col = new ByColumn();
2084: col.exp = exp;
2085: list.add(col);
2086: }
2087: }
2088:
2089: /**
2090: * NOTE: This is an extension, allows for us to specify a column to return the
2091: * max value for each row representing a group.
2092: */
2093: final public Variable GroupMaxColumn() throws ParseException {
2094: Variable var;
2095: var = ColumnNameVariable();
2096: {
2097: if (true)
2098: return var;
2099: }
2100: throw new Error("Missing return statement in function");
2101: }
2102:
2103: final public void SelectOrderByList(ArrayList list)
2104: throws ParseException {
2105: ByColumn col;
2106: Expression exp;
2107: boolean ascending = true;
2108: exp = DoExpression();
2109: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2110: case ASC:
2111: case DESC:
2112: ascending = OrderingSpec();
2113: break;
2114: default:
2115: jj_la1[74] = jj_gen;
2116: ;
2117: }
2118: col = new ByColumn();
2119: col.exp = exp;
2120: col.ascending = ascending;
2121: list.add(col);
2122: label_8: while (true) {
2123: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2124: case 210:
2125: ;
2126: break;
2127: default:
2128: jj_la1[75] = jj_gen;
2129: break label_8;
2130: }
2131: jj_consume_token(210);
2132: exp = DoExpression();
2133: ascending = true;
2134: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2135: case ASC:
2136: case DESC:
2137: ascending = OrderingSpec();
2138: break;
2139: default:
2140: jj_la1[76] = jj_gen;
2141: ;
2142: }
2143: col = new ByColumn();
2144: col.exp = exp;
2145: col.ascending = ascending;
2146: list.add(col);
2147: }
2148: }
2149:
2150: final public boolean OrderingSpec() throws ParseException {
2151: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2152: case ASC:
2153: jj_consume_token(ASC);
2154: {
2155: if (true)
2156: return true;
2157: }
2158: break;
2159: case DESC:
2160: jj_consume_token(DESC);
2161: {
2162: if (true)
2163: return false;
2164: }
2165: break;
2166: default:
2167: jj_la1[77] = jj_gen;
2168: jj_consume_token(-1);
2169: throw new ParseException();
2170: }
2171: {
2172: if (true)
2173: return true;
2174: }
2175: throw new Error("Missing return statement in function");
2176: }
2177:
2178: final public void TableDeclaration(FromClause from_clause)
2179: throws ParseException {
2180: String table = null, declare_as = null;
2181: TableSelectExpression select_stmt = null;
2182: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2183: case OLD:
2184: case NEW:
2185: case NAME:
2186: case JAVA:
2187: case ACTION:
2188: case GROUPS:
2189: case OPTION:
2190: case ACCOUNT:
2191: case PASSWORD:
2192: case LANGUAGE:
2193: case PRIVILEGES:
2194: case QUOTED_VARIABLE:
2195: case IDENTIFIER:
2196: case DOT_DELIMINATED_REF:
2197: case QUOTED_DELIMINATED_REF:
2198: table = TableName();
2199: break;
2200: case 208:
2201: jj_consume_token(208);
2202: select_stmt = GetTableSelectExpression();
2203: jj_consume_token(209);
2204: break;
2205: default:
2206: jj_la1[78] = jj_gen;
2207: jj_consume_token(-1);
2208: throw new ParseException();
2209: }
2210: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2211: case AS:
2212: case OLD:
2213: case NEW:
2214: case NAME:
2215: case JAVA:
2216: case ACTION:
2217: case GROUPS:
2218: case OPTION:
2219: case ACCOUNT:
2220: case PASSWORD:
2221: case LANGUAGE:
2222: case PRIVILEGES:
2223: case QUOTED_VARIABLE:
2224: case IDENTIFIER:
2225: case DOT_DELIMINATED_REF:
2226: case QUOTED_DELIMINATED_REF:
2227: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2228: case AS:
2229: jj_consume_token(AS);
2230: break;
2231: default:
2232: jj_la1[79] = jj_gen;
2233: ;
2234: }
2235: declare_as = TableName();
2236: break;
2237: default:
2238: jj_la1[80] = jj_gen;
2239: ;
2240: }
2241: from_clause.addTableDeclaration(table, select_stmt, declare_as);
2242: }
2243:
2244: final public void SelectTableList(FromClause from_clause)
2245: throws ParseException {
2246: TableDeclaration(from_clause);
2247: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2248: case LEFT:
2249: case JOIN:
2250: case RIGHT:
2251: case INNER:
2252: case 210:
2253: FromClauseJoin(from_clause);
2254: break;
2255: default:
2256: jj_la1[81] = jj_gen;
2257: ;
2258: }
2259: }
2260:
2261: final public void FromClauseJoin(FromClause from_clause)
2262: throws ParseException {
2263: Expression on_expression;
2264: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2265: case 210:
2266: jj_consume_token(210);
2267: from_clause.addJoin(JoiningSet.INNER_JOIN);
2268: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2269: case OLD:
2270: case NEW:
2271: case NAME:
2272: case JAVA:
2273: case ACTION:
2274: case GROUPS:
2275: case OPTION:
2276: case ACCOUNT:
2277: case PASSWORD:
2278: case LANGUAGE:
2279: case PRIVILEGES:
2280: case QUOTED_VARIABLE:
2281: case IDENTIFIER:
2282: case DOT_DELIMINATED_REF:
2283: case QUOTED_DELIMINATED_REF:
2284: case 208:
2285: SelectTableList(from_clause);
2286: break;
2287: default:
2288: jj_la1[82] = jj_gen;
2289: ;
2290: }
2291: break;
2292: case JOIN:
2293: case INNER:
2294: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2295: case INNER:
2296: jj_consume_token(INNER);
2297: break;
2298: default:
2299: jj_la1[83] = jj_gen;
2300: ;
2301: }
2302: jj_consume_token(JOIN);
2303: TableDeclaration(from_clause);
2304: jj_consume_token(ON);
2305: on_expression = DoExpression();
2306: from_clause.addPreviousJoin(JoiningSet.INNER_JOIN,
2307: on_expression);
2308: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2309: case LEFT:
2310: case JOIN:
2311: case RIGHT:
2312: case INNER:
2313: case 210:
2314: FromClauseJoin(from_clause);
2315: break;
2316: default:
2317: jj_la1[84] = jj_gen;
2318: ;
2319: }
2320: break;
2321: case LEFT:
2322: jj_consume_token(LEFT);
2323: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2324: case OUTER:
2325: jj_consume_token(OUTER);
2326: break;
2327: default:
2328: jj_la1[85] = jj_gen;
2329: ;
2330: }
2331: jj_consume_token(JOIN);
2332: TableDeclaration(from_clause);
2333: jj_consume_token(ON);
2334: on_expression = DoExpression();
2335: from_clause.addPreviousJoin(JoiningSet.LEFT_OUTER_JOIN,
2336: on_expression);
2337: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2338: case LEFT:
2339: case JOIN:
2340: case RIGHT:
2341: case INNER:
2342: case 210:
2343: FromClauseJoin(from_clause);
2344: break;
2345: default:
2346: jj_la1[86] = jj_gen;
2347: ;
2348: }
2349: break;
2350: case RIGHT:
2351: jj_consume_token(RIGHT);
2352: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2353: case OUTER:
2354: jj_consume_token(OUTER);
2355: break;
2356: default:
2357: jj_la1[87] = jj_gen;
2358: ;
2359: }
2360: jj_consume_token(JOIN);
2361: TableDeclaration(from_clause);
2362: jj_consume_token(ON);
2363: on_expression = DoExpression();
2364: from_clause.addPreviousJoin(JoiningSet.RIGHT_OUTER_JOIN,
2365: on_expression);
2366: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2367: case LEFT:
2368: case JOIN:
2369: case RIGHT:
2370: case INNER:
2371: case 210:
2372: FromClauseJoin(from_clause);
2373: break;
2374: default:
2375: jj_la1[88] = jj_gen;
2376: ;
2377: }
2378: break;
2379: default:
2380: jj_la1[89] = jj_gen;
2381: jj_consume_token(-1);
2382: throw new ParseException();
2383: }
2384: }
2385:
2386: // A list of parameters in a function or procedure declaration. For example,
2387: // ' p1 NUMERIC, p2 NUMERIC, s1 CHARACTER VARYING '
2388: // First array contains parameter names, and second contains TType representing
2389: // the type.
2390: final public void ProcParameterList(ArrayList decl_names,
2391: ArrayList decl_types) throws ParseException {
2392: String name;
2393: TType type;
2394: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2395: case LONG:
2396: case NAME:
2397: case JAVA:
2398: case ACTION:
2399: case GROUPS:
2400: case OPTION:
2401: case ACCOUNT:
2402: case PASSWORD:
2403: case LANGUAGE:
2404: case CHARACTER:
2405: case PRIVILEGES:
2406: case BIT:
2407: case INT:
2408: case REAL:
2409: case CLOB:
2410: case BLOB:
2411: case CHAR:
2412: case TEXT:
2413: case DATE:
2414: case TIME:
2415: case FLOAT:
2416: case BIGINT:
2417: case DOUBLE:
2418: case STRING:
2419: case BINARY:
2420: case NUMERIC:
2421: case DECIMAL:
2422: case BOOLEAN:
2423: case TINYINT:
2424: case INTEGER:
2425: case VARCHAR:
2426: case SMALLINT:
2427: case VARBINARY:
2428: case TIMESTAMP:
2429: case JAVA_OBJECT:
2430: case LONGVARCHAR:
2431: case LONGVARBINARY:
2432: case QUOTED_VARIABLE:
2433: case IDENTIFIER:
2434: name = null;
2435: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2436: case NAME:
2437: case JAVA:
2438: case ACTION:
2439: case GROUPS:
2440: case OPTION:
2441: case ACCOUNT:
2442: case PASSWORD:
2443: case LANGUAGE:
2444: case PRIVILEGES:
2445: case QUOTED_VARIABLE:
2446: case IDENTIFIER:
2447: name = ProcArgumentName();
2448: break;
2449: default:
2450: jj_la1[90] = jj_gen;
2451: ;
2452: }
2453: type = GetTType();
2454: decl_names.add(name);
2455: decl_types.add(type);
2456: label_9: while (true) {
2457: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2458: case 210:
2459: ;
2460: break;
2461: default:
2462: jj_la1[91] = jj_gen;
2463: break label_9;
2464: }
2465: jj_consume_token(210);
2466: name = null;
2467: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2468: case NAME:
2469: case JAVA:
2470: case ACTION:
2471: case GROUPS:
2472: case OPTION:
2473: case ACCOUNT:
2474: case PASSWORD:
2475: case LANGUAGE:
2476: case PRIVILEGES:
2477: case QUOTED_VARIABLE:
2478: case IDENTIFIER:
2479: name = ProcArgumentName();
2480: break;
2481: default:
2482: jj_la1[92] = jj_gen;
2483: ;
2484: }
2485: type = GetTType();
2486: decl_names.add(name);
2487: decl_types.add(type);
2488: }
2489: break;
2490: default:
2491: jj_la1[93] = jj_gen;
2492: ;
2493: }
2494: }
2495:
2496: // The ' set a = (a * 9), b = concat(b, "aa") ' part of the 'update', 'insert' statement
2497: final public void AssignmentList(ArrayList assignment_list)
2498: throws ParseException {
2499: String column;
2500: Expression exp;
2501: column = ColumnName();
2502: jj_consume_token(ASSIGNMENT);
2503: exp = DoExpression();
2504: assignment_list.add(new Assignment(Variable.resolve(column),
2505: exp));
2506: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2507: case 210:
2508: jj_consume_token(210);
2509: AssignmentList(assignment_list);
2510: break;
2511: default:
2512: jj_la1[94] = jj_gen;
2513: ;
2514: }
2515: }
2516:
2517: // Parses a list of column declarations. eg. ' id NUMERIC(5, 20), number VARCHAR(90), ... '
2518: // and also any constraints.
2519: final public void ColumnDeclarationList(ArrayList column_list,
2520: ArrayList constraint_list) throws ParseException {
2521: jj_consume_token(208);
2522: ColumnOrConstraintDefinition(column_list, constraint_list);
2523: label_10: while (true) {
2524: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2525: case 210:
2526: ;
2527: break;
2528: default:
2529: jj_la1[95] = jj_gen;
2530: break label_10;
2531: }
2532: jj_consume_token(210);
2533: ColumnOrConstraintDefinition(column_list, constraint_list);
2534: }
2535: jj_consume_token(209);
2536: }
2537:
2538: final public void ColumnOrConstraintDefinition(
2539: ArrayList column_list, ArrayList constraint_list)
2540: throws ParseException {
2541: ColumnDef coldef = null;
2542: ConstraintDef condef = null;
2543: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2544: case NAME:
2545: case JAVA:
2546: case ACTION:
2547: case GROUPS:
2548: case OPTION:
2549: case ACCOUNT:
2550: case PASSWORD:
2551: case LANGUAGE:
2552: case PRIVILEGES:
2553: case QUOTED_VARIABLE:
2554: case IDENTIFIER:
2555: case DOT_DELIMINATED_REF:
2556: case QUOTED_DELIMINATED_REF:
2557: coldef = ColumnDefinition();
2558: column_list.add(coldef);
2559: break;
2560: case CHECK:
2561: case UNIQUE:
2562: case CONSTRAINT:
2563: case PRIMARY:
2564: case FOREIGN:
2565: condef = TableConstraintDefinition();
2566: constraint_list.add(condef);
2567: break;
2568: default:
2569: jj_la1[96] = jj_gen;
2570: jj_consume_token(-1);
2571: throw new ParseException();
2572: }
2573: }
2574:
2575: final public ColumnDef ColumnDefinition() throws ParseException {
2576: ColumnDef column = new ColumnDef();
2577: Token t;
2578: Token col_constraint;
2579: Expression default_exp;
2580: String col_name;
2581: col_name = ColumnName();
2582: column.setName(col_name);
2583: ColumnDataType(column);
2584: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2585: case SQLDEFAULT:
2586: jj_consume_token(SQLDEFAULT);
2587: default_exp = DoExpression();
2588: column.setDefaultExpression(default_exp);
2589: break;
2590: default:
2591: jj_la1[97] = jj_gen;
2592: ;
2593: }
2594: label_11: while (true) {
2595: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2596: case NULL_LITERAL:
2597: case UNIQUE:
2598: case PRIMARY:
2599: case NOT:
2600: ;
2601: break;
2602: default:
2603: jj_la1[98] = jj_gen;
2604: break label_11;
2605: }
2606: ColumnConstraint(column);
2607: }
2608: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2609: case INDEX_NONE:
2610: case INDEX_BLIST:
2611: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2612: case INDEX_BLIST:
2613: t = jj_consume_token(INDEX_BLIST);
2614: break;
2615: case INDEX_NONE:
2616: t = jj_consume_token(INDEX_NONE);
2617: break;
2618: default:
2619: jj_la1[99] = jj_gen;
2620: jj_consume_token(-1);
2621: throw new ParseException();
2622: }
2623: column.setIndex(t);
2624: break;
2625: default:
2626: jj_la1[100] = jj_gen;
2627: ;
2628: }
2629: {
2630: if (true)
2631: return column;
2632: }
2633: throw new Error("Missing return statement in function");
2634: }
2635:
2636: // Constraint on a column, eg. 'NOT NULL', 'NULL', 'PRIMARY KEY', 'UNIQUE', etc.
2637: final public void ColumnConstraint(ColumnDef column)
2638: throws ParseException {
2639: Token t;
2640: String table_name;
2641: ArrayList col_list = new ArrayList();
2642: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2643: case NOT:
2644: jj_consume_token(NOT);
2645: jj_consume_token(NULL_LITERAL);
2646: column.addConstraint("NOT NULL");
2647: break;
2648: case NULL_LITERAL:
2649: jj_consume_token(NULL_LITERAL);
2650: column.addConstraint("NULL");
2651: break;
2652: case PRIMARY:
2653: jj_consume_token(PRIMARY);
2654: jj_consume_token(KEY);
2655: column.addConstraint("PRIMARY");
2656: break;
2657: case UNIQUE:
2658: jj_consume_token(UNIQUE);
2659: column.addConstraint("UNIQUE");
2660: break;
2661: default:
2662: jj_la1[101] = jj_gen;
2663: jj_consume_token(-1);
2664: throw new ParseException();
2665: }
2666: }
2667:
2668: final public int GetCollateStrength() throws ParseException {
2669: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2670: case PRIMARY_STRENGTH:
2671: jj_consume_token(PRIMARY_STRENGTH);
2672: {
2673: if (true)
2674: return java.text.Collator.PRIMARY;
2675: }
2676: break;
2677: case SECONDARY_STRENGTH:
2678: jj_consume_token(SECONDARY_STRENGTH);
2679: {
2680: if (true)
2681: return java.text.Collator.SECONDARY;
2682: }
2683: break;
2684: case TERTIARY_STRENGTH:
2685: jj_consume_token(TERTIARY_STRENGTH);
2686: {
2687: if (true)
2688: return java.text.Collator.TERTIARY;
2689: }
2690: break;
2691: case IDENTICAL_STRENGTH:
2692: jj_consume_token(IDENTICAL_STRENGTH);
2693: {
2694: if (true)
2695: return java.text.Collator.IDENTICAL;
2696: }
2697: break;
2698: default:
2699: jj_la1[102] = jj_gen;
2700: jj_consume_token(-1);
2701: throw new ParseException();
2702: }
2703: throw new Error("Missing return statement in function");
2704: }
2705:
2706: final public int GetCollateDecomposition() throws ParseException {
2707: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2708: case NO_DECOMPOSITION:
2709: jj_consume_token(NO_DECOMPOSITION);
2710: {
2711: if (true)
2712: return java.text.Collator.NO_DECOMPOSITION;
2713: }
2714: break;
2715: case CANONICAL_DECOMPOSITION:
2716: jj_consume_token(CANONICAL_DECOMPOSITION);
2717: {
2718: if (true)
2719: return java.text.Collator.CANONICAL_DECOMPOSITION;
2720: }
2721: break;
2722: case FULL_DECOMPOSITION:
2723: jj_consume_token(FULL_DECOMPOSITION);
2724: {
2725: if (true)
2726: return java.text.Collator.FULL_DECOMPOSITION;
2727: }
2728: break;
2729: default:
2730: jj_la1[103] = jj_gen;
2731: jj_consume_token(-1);
2732: throw new ParseException();
2733: }
2734: throw new Error("Missing return statement in function");
2735: }
2736:
2737: final public int GetStringSQLType() throws ParseException {
2738: if (jj_2_2(2)) {
2739: jj_consume_token(CHARACTER);
2740: jj_consume_token(VARYING);
2741: {
2742: if (true)
2743: return SQLTypes.VARCHAR;
2744: }
2745: } else if (jj_2_3(3)) {
2746: jj_consume_token(LONG);
2747: jj_consume_token(CHARACTER);
2748: jj_consume_token(VARYING);
2749: {
2750: if (true)
2751: return SQLTypes.LONGVARCHAR;
2752: }
2753: } else {
2754: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2755: case TEXT:
2756: case STRING:
2757: case LONGVARCHAR:
2758: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2759: case TEXT:
2760: jj_consume_token(TEXT);
2761: break;
2762: case STRING:
2763: jj_consume_token(STRING);
2764: break;
2765: case LONGVARCHAR:
2766: jj_consume_token(LONGVARCHAR);
2767: break;
2768: default:
2769: jj_la1[104] = jj_gen;
2770: jj_consume_token(-1);
2771: throw new ParseException();
2772: }
2773: {
2774: if (true)
2775: return SQLTypes.LONGVARCHAR;
2776: }
2777: break;
2778: case CHARACTER:
2779: case CHAR:
2780: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2781: case CHAR:
2782: jj_consume_token(CHAR);
2783: break;
2784: case CHARACTER:
2785: jj_consume_token(CHARACTER);
2786: break;
2787: default:
2788: jj_la1[105] = jj_gen;
2789: jj_consume_token(-1);
2790: throw new ParseException();
2791: }
2792: {
2793: if (true)
2794: return SQLTypes.CHAR;
2795: }
2796: break;
2797: case VARCHAR:
2798: jj_consume_token(VARCHAR);
2799: {
2800: if (true)
2801: return SQLTypes.VARCHAR;
2802: }
2803: break;
2804: case CLOB:
2805: jj_consume_token(CLOB);
2806: {
2807: if (true)
2808: return SQLTypes.CLOB;
2809: }
2810: break;
2811: default:
2812: jj_la1[106] = jj_gen;
2813: jj_consume_token(-1);
2814: throw new ParseException();
2815: }
2816: }
2817: throw new Error("Missing return statement in function");
2818: }
2819:
2820: final public int GetNumericSQLType() throws ParseException {
2821: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2822: case INT:
2823: case INTEGER:
2824: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2825: case INT:
2826: jj_consume_token(INT);
2827: break;
2828: case INTEGER:
2829: jj_consume_token(INTEGER);
2830: break;
2831: default:
2832: jj_la1[107] = jj_gen;
2833: jj_consume_token(-1);
2834: throw new ParseException();
2835: }
2836: {
2837: if (true)
2838: return SQLTypes.INTEGER;
2839: }
2840: break;
2841: case TINYINT:
2842: jj_consume_token(TINYINT);
2843: {
2844: if (true)
2845: return SQLTypes.TINYINT;
2846: }
2847: break;
2848: case SMALLINT:
2849: jj_consume_token(SMALLINT);
2850: {
2851: if (true)
2852: return SQLTypes.SMALLINT;
2853: }
2854: break;
2855: case BIGINT:
2856: jj_consume_token(BIGINT);
2857: {
2858: if (true)
2859: return SQLTypes.BIGINT;
2860: }
2861: break;
2862: case FLOAT:
2863: jj_consume_token(FLOAT);
2864: {
2865: if (true)
2866: return SQLTypes.FLOAT;
2867: }
2868: break;
2869: case REAL:
2870: jj_consume_token(REAL);
2871: {
2872: if (true)
2873: return SQLTypes.REAL;
2874: }
2875: break;
2876: case DOUBLE:
2877: jj_consume_token(DOUBLE);
2878: {
2879: if (true)
2880: return SQLTypes.DOUBLE;
2881: }
2882: break;
2883: case NUMERIC:
2884: jj_consume_token(NUMERIC);
2885: {
2886: if (true)
2887: return SQLTypes.NUMERIC;
2888: }
2889: break;
2890: case DECIMAL:
2891: jj_consume_token(DECIMAL);
2892: {
2893: if (true)
2894: return SQLTypes.DECIMAL;
2895: }
2896: break;
2897: default:
2898: jj_la1[108] = jj_gen;
2899: jj_consume_token(-1);
2900: throw new ParseException();
2901: }
2902: throw new Error("Missing return statement in function");
2903: }
2904:
2905: final public int GetBooleanSQLType() throws ParseException {
2906: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2907: case BOOLEAN:
2908: jj_consume_token(BOOLEAN);
2909: break;
2910: case BIT:
2911: jj_consume_token(BIT);
2912: break;
2913: default:
2914: jj_la1[109] = jj_gen;
2915: jj_consume_token(-1);
2916: throw new ParseException();
2917: }
2918: {
2919: if (true)
2920: return SQLTypes.BOOLEAN;
2921: }
2922: throw new Error("Missing return statement in function");
2923: }
2924:
2925: final public int GetDateSQLType() throws ParseException {
2926: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2927: case TIMESTAMP:
2928: jj_consume_token(TIMESTAMP);
2929: {
2930: if (true)
2931: return SQLTypes.TIMESTAMP;
2932: }
2933: break;
2934: case TIME:
2935: jj_consume_token(TIME);
2936: {
2937: if (true)
2938: return SQLTypes.TIME;
2939: }
2940: break;
2941: case DATE:
2942: jj_consume_token(DATE);
2943: {
2944: if (true)
2945: return SQLTypes.DATE;
2946: }
2947: break;
2948: default:
2949: jj_la1[110] = jj_gen;
2950: jj_consume_token(-1);
2951: throw new ParseException();
2952: }
2953: throw new Error("Missing return statement in function");
2954: }
2955:
2956: final public int GetBinarySQLType() throws ParseException {
2957: if (jj_2_4(2)) {
2958: jj_consume_token(BINARY);
2959: jj_consume_token(VARYING);
2960: {
2961: if (true)
2962: return SQLTypes.VARBINARY;
2963: }
2964: } else if (jj_2_5(3)) {
2965: jj_consume_token(LONG);
2966: jj_consume_token(BINARY);
2967: jj_consume_token(VARYING);
2968: {
2969: if (true)
2970: return SQLTypes.LONGVARBINARY;
2971: }
2972: } else {
2973: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2974: case LONGVARBINARY:
2975: jj_consume_token(LONGVARBINARY);
2976: {
2977: if (true)
2978: return SQLTypes.LONGVARBINARY;
2979: }
2980: break;
2981: case VARBINARY:
2982: jj_consume_token(VARBINARY);
2983: {
2984: if (true)
2985: return SQLTypes.VARBINARY;
2986: }
2987: break;
2988: case BINARY:
2989: jj_consume_token(BINARY);
2990: {
2991: if (true)
2992: return SQLTypes.BINARY;
2993: }
2994: break;
2995: case BLOB:
2996: jj_consume_token(BLOB);
2997: {
2998: if (true)
2999: return SQLTypes.BLOB;
3000: }
3001: break;
3002: default:
3003: jj_la1[111] = jj_gen;
3004: jj_consume_token(-1);
3005: throw new ParseException();
3006: }
3007: }
3008: throw new Error("Missing return statement in function");
3009: }
3010:
3011: // Parses an SQL type and forms a TType object. For example, "CHAR(500)" is
3012: // parsed to a TStringType with a maximum size of 500 and lexicographical
3013: // collation.
3014: final public TType GetTType() throws ParseException {
3015: Token t;
3016: int data_type;
3017: int size = -1;
3018: int scale = -1;
3019: Token class_tok = null;
3020: int strength = -1;
3021: int decomposition = -1;
3022: String loc = null;
3023: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3024: case JAVA_OBJECT:
3025: jj_consume_token(JAVA_OBJECT);
3026: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3027: case 208:
3028: jj_consume_token(208);
3029: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3030: case DOT_DELIMINATED_REF:
3031: class_tok = jj_consume_token(DOT_DELIMINATED_REF);
3032: break;
3033: case JAVA_OBJECT_ARRAY_REF:
3034: class_tok = jj_consume_token(JAVA_OBJECT_ARRAY_REF);
3035: break;
3036: default:
3037: jj_la1[112] = jj_gen;
3038: jj_consume_token(-1);
3039: throw new ParseException();
3040: }
3041: jj_consume_token(209);
3042: break;
3043: default:
3044: jj_la1[113] = jj_gen;
3045: ;
3046: }
3047: String class_str = "java.lang.Object";
3048: if (class_tok != null) {
3049: class_str = class_tok.image;
3050: }
3051: {
3052: if (true)
3053: return TType.javaObjectType(class_str);
3054: }
3055: break;
3056: default:
3057: jj_la1[121] = jj_gen;
3058: if (jj_2_6(2147483647)) {
3059: data_type = GetStringSQLType();
3060: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3061: case 208:
3062: jj_consume_token(208);
3063: size = PositiveIntegerConstant();
3064: jj_consume_token(209);
3065: break;
3066: default:
3067: jj_la1[114] = jj_gen;
3068: ;
3069: }
3070: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3071: case COLLATE:
3072: jj_consume_token(COLLATE);
3073: t = jj_consume_token(STRING_LITERAL);
3074: loc = ((TObject) Util.toParamObject(t,
3075: case_insensitive_identifiers)).toString();
3076: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3077: case PRIMARY_STRENGTH:
3078: case SECONDARY_STRENGTH:
3079: case TERTIARY_STRENGTH:
3080: case IDENTICAL_STRENGTH:
3081: strength = GetCollateStrength();
3082: break;
3083: default:
3084: jj_la1[115] = jj_gen;
3085: ;
3086: }
3087: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3088: case NO_DECOMPOSITION:
3089: case CANONICAL_DECOMPOSITION:
3090: case FULL_DECOMPOSITION:
3091: decomposition = GetCollateDecomposition();
3092: break;
3093: default:
3094: jj_la1[116] = jj_gen;
3095: ;
3096: }
3097: break;
3098: default:
3099: jj_la1[117] = jj_gen;
3100: ;
3101: }
3102: {
3103: if (true)
3104: return TType.stringType(data_type, size, loc,
3105: strength, decomposition);
3106: }
3107: } else {
3108: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3109: case INT:
3110: case REAL:
3111: case FLOAT:
3112: case BIGINT:
3113: case DOUBLE:
3114: case NUMERIC:
3115: case DECIMAL:
3116: case TINYINT:
3117: case INTEGER:
3118: case SMALLINT:
3119: data_type = GetNumericSQLType();
3120: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3121: case 208:
3122: jj_consume_token(208);
3123: size = PositiveIntegerConstant();
3124: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3125: case 210:
3126: jj_consume_token(210);
3127: scale = PositiveIntegerConstant();
3128: break;
3129: default:
3130: jj_la1[118] = jj_gen;
3131: ;
3132: }
3133: jj_consume_token(209);
3134: break;
3135: default:
3136: jj_la1[119] = jj_gen;
3137: ;
3138: }
3139: {
3140: if (true)
3141: return TType.numericType(data_type, size,
3142: scale);
3143: }
3144: break;
3145: case BIT:
3146: case BOOLEAN:
3147: data_type = GetBooleanSQLType();
3148: {
3149: if (true)
3150: return TType.booleanType(data_type);
3151: }
3152: break;
3153: case DATE:
3154: case TIME:
3155: case TIMESTAMP:
3156: data_type = GetDateSQLType();
3157: {
3158: if (true)
3159: return TType.dateType(data_type);
3160: }
3161: break;
3162: case LONG:
3163: case BLOB:
3164: case BINARY:
3165: case VARBINARY:
3166: case LONGVARBINARY:
3167: data_type = GetBinarySQLType();
3168: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3169: case 208:
3170: jj_consume_token(208);
3171: size = PositiveIntegerConstant();
3172: jj_consume_token(209);
3173: break;
3174: default:
3175: jj_la1[120] = jj_gen;
3176: ;
3177: }
3178: {
3179: if (true)
3180: return TType.binaryType(data_type, size);
3181: }
3182: break;
3183: default:
3184: jj_la1[122] = jj_gen;
3185: jj_consume_token(-1);
3186: throw new ParseException();
3187: }
3188: }
3189: }
3190: throw new Error("Missing return statement in function");
3191: }
3192:
3193: // Data type of a ColumnDef (eg. "varchar(50)", etc)
3194: final public void ColumnDataType(ColumnDef column)
3195: throws ParseException {
3196: TType type;
3197: type = GetTType();
3198: column.setDataType(type);
3199: }
3200:
3201: final public ConstraintDef TableConstraintDefinition()
3202: throws ParseException {
3203: ConstraintDef constraint = new ConstraintDef();
3204: ArrayList column_list = new ArrayList();
3205: ArrayList column_list2 = new ArrayList();
3206: String constraint_name;
3207: String update_rule = "NO ACTION";
3208: String delete_rule = "NO ACTION";
3209: Expression expression;
3210: String name;
3211: String reference_table;
3212: Token t;
3213: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3214: case CONSTRAINT:
3215: jj_consume_token(CONSTRAINT);
3216: constraint_name = ConstraintName();
3217: constraint.setName(constraint_name);
3218: break;
3219: default:
3220: jj_la1[123] = jj_gen;
3221: ;
3222: }
3223: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3224: case PRIMARY:
3225: jj_consume_token(PRIMARY);
3226: jj_consume_token(KEY);
3227: jj_consume_token(208);
3228: BasicColumnList(column_list);
3229: jj_consume_token(209);
3230: constraint.setPrimaryKey(column_list);
3231: break;
3232: case UNIQUE:
3233: jj_consume_token(UNIQUE);
3234: jj_consume_token(208);
3235: BasicColumnList(column_list);
3236: jj_consume_token(209);
3237: constraint.setUnique(column_list);
3238: break;
3239: case CHECK:
3240: jj_consume_token(CHECK);
3241: jj_consume_token(208);
3242: expression = DoExpression();
3243: jj_consume_token(209);
3244: constraint.setCheck(expression);
3245: break;
3246: case FOREIGN:
3247: jj_consume_token(FOREIGN);
3248: jj_consume_token(KEY);
3249: jj_consume_token(208);
3250: BasicColumnList(column_list);
3251: jj_consume_token(209);
3252: jj_consume_token(REFERENCES);
3253: reference_table = TableName();
3254: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3255: case 208:
3256: jj_consume_token(208);
3257: BasicColumnList(column_list2);
3258: jj_consume_token(209);
3259: break;
3260: default:
3261: jj_la1[124] = jj_gen;
3262: ;
3263: }
3264: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3265: case ON:
3266: if (jj_2_7(2)) {
3267: jj_consume_token(ON);
3268: jj_consume_token(DELETE);
3269: delete_rule = ReferentialTrigger();
3270: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3271: case ON:
3272: jj_consume_token(ON);
3273: jj_consume_token(UPDATE);
3274: update_rule = ReferentialTrigger();
3275: break;
3276: default:
3277: jj_la1[125] = jj_gen;
3278: ;
3279: }
3280: } else {
3281: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3282: case ON:
3283: jj_consume_token(ON);
3284: jj_consume_token(UPDATE);
3285: update_rule = ReferentialTrigger();
3286: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3287: case ON:
3288: jj_consume_token(ON);
3289: jj_consume_token(DELETE);
3290: delete_rule = ReferentialTrigger();
3291: break;
3292: default:
3293: jj_la1[126] = jj_gen;
3294: ;
3295: }
3296: break;
3297: default:
3298: jj_la1[127] = jj_gen;
3299: jj_consume_token(-1);
3300: throw new ParseException();
3301: }
3302: }
3303: break;
3304: default:
3305: jj_la1[128] = jj_gen;
3306: ;
3307: }
3308: constraint.setForeignKey(reference_table, column_list,
3309: column_list2, delete_rule, update_rule);
3310: break;
3311: default:
3312: jj_la1[129] = jj_gen;
3313: jj_consume_token(-1);
3314: throw new ParseException();
3315: }
3316: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3317: case INITIALLY:
3318: case DEFERRABLE:
3319: case NOT:
3320: ConstraintAttributes(constraint);
3321: break;
3322: default:
3323: jj_la1[130] = jj_gen;
3324: ;
3325: }
3326: {
3327: if (true)
3328: return constraint;
3329: }
3330: throw new Error("Missing return statement in function");
3331: }
3332:
3333: final public String ReferentialTrigger() throws ParseException {
3334: Token t;
3335: String trigger_str;
3336: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3337: case NO:
3338: jj_consume_token(NO);
3339: jj_consume_token(ACTION);
3340: trigger_str = "NO ACTION";
3341: break;
3342: case RESTRICT:
3343: jj_consume_token(RESTRICT);
3344: trigger_str = "NO ACTION";
3345: break;
3346: case CASCADE:
3347: jj_consume_token(CASCADE);
3348: trigger_str = "CASCADE";
3349: break;
3350: default:
3351: jj_la1[131] = jj_gen;
3352: if (jj_2_8(2)) {
3353: jj_consume_token(SET);
3354: jj_consume_token(NULL_LITERAL);
3355: trigger_str = "SET NULL";
3356: } else {
3357: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3358: case SET:
3359: jj_consume_token(SET);
3360: jj_consume_token(SQLDEFAULT);
3361: trigger_str = "SET DEFAULT";
3362: break;
3363: default:
3364: jj_la1[132] = jj_gen;
3365: jj_consume_token(-1);
3366: throw new ParseException();
3367: }
3368: }
3369: }
3370: {
3371: if (true)
3372: return trigger_str;
3373: }
3374: throw new Error("Missing return statement in function");
3375: }
3376:
3377: final public void ConstraintAttributes(ConstraintDef constraint)
3378: throws ParseException {
3379: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3380: case INITIALLY:
3381: jj_consume_token(INITIALLY);
3382: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3383: case DEFERRED:
3384: jj_consume_token(DEFERRED);
3385: constraint.setInitiallyDeferred();
3386: break;
3387: case IMMEDIATE:
3388: jj_consume_token(IMMEDIATE);
3389: break;
3390: default:
3391: jj_la1[133] = jj_gen;
3392: jj_consume_token(-1);
3393: throw new ParseException();
3394: }
3395: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3396: case DEFERRABLE:
3397: case NOT:
3398: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3399: case NOT:
3400: jj_consume_token(NOT);
3401: jj_consume_token(DEFERRABLE);
3402: constraint.setNotDeferrable();
3403: break;
3404: case DEFERRABLE:
3405: jj_consume_token(DEFERRABLE);
3406: break;
3407: default:
3408: jj_la1[134] = jj_gen;
3409: jj_consume_token(-1);
3410: throw new ParseException();
3411: }
3412: break;
3413: default:
3414: jj_la1[135] = jj_gen;
3415: ;
3416: }
3417: break;
3418: case DEFERRABLE:
3419: case NOT:
3420: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3421: case NOT:
3422: jj_consume_token(NOT);
3423: jj_consume_token(DEFERRABLE);
3424: constraint.setNotDeferrable();
3425: break;
3426: case DEFERRABLE:
3427: jj_consume_token(DEFERRABLE);
3428: break;
3429: default:
3430: jj_la1[136] = jj_gen;
3431: jj_consume_token(-1);
3432: throw new ParseException();
3433: }
3434: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3435: case INITIALLY:
3436: jj_consume_token(INITIALLY);
3437: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3438: case DEFERRED:
3439: jj_consume_token(DEFERRED);
3440: constraint.setInitiallyDeferred();
3441: break;
3442: case IMMEDIATE:
3443: jj_consume_token(IMMEDIATE);
3444: break;
3445: default:
3446: jj_la1[137] = jj_gen;
3447: jj_consume_token(-1);
3448: throw new ParseException();
3449: }
3450: break;
3451: default:
3452: jj_la1[138] = jj_gen;
3453: ;
3454: }
3455: break;
3456: default:
3457: jj_la1[139] = jj_gen;
3458: jj_consume_token(-1);
3459: throw new ParseException();
3460: }
3461: }
3462:
3463: // A list of column names
3464: final public ArrayList BasicColumnList(ArrayList list)
3465: throws ParseException {
3466: String col_name;
3467: col_name = ColumnName();
3468: list.add(col_name);
3469: label_12: while (true) {
3470: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3471: case 210:
3472: ;
3473: break;
3474: default:
3475: jj_la1[140] = jj_gen;
3476: break label_12;
3477: }
3478: jj_consume_token(210);
3479: col_name = ColumnName();
3480: list.add(col_name);
3481: }
3482: {
3483: if (true)
3484: return list;
3485: }
3486: throw new Error("Missing return statement in function");
3487: }
3488:
3489: // A list of user names
3490: final public ArrayList UserNameList(ArrayList list)
3491: throws ParseException {
3492: String username;
3493: username = UserName();
3494: list.add(username);
3495: label_13: while (true) {
3496: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3497: case 210:
3498: ;
3499: break;
3500: default:
3501: jj_la1[141] = jj_gen;
3502: break label_13;
3503: }
3504: jj_consume_token(210);
3505: username = UserName();
3506: list.add(username);
3507: }
3508: {
3509: if (true)
3510: return list;
3511: }
3512: throw new Error("Missing return statement in function");
3513: }
3514:
3515: final public void ConditionsExpression(SearchExpression se)
3516: throws ParseException {
3517: Expression exp;
3518: exp = DoExpression();
3519: se.setFromExpression(exp);
3520: }
3521:
3522: final public Expression ExpressionTest() throws ParseException {
3523: Expression exp;
3524: exp = DoExpression();
3525: jj_consume_token(207);
3526: {
3527: if (true)
3528: return exp;
3529: }
3530: throw new Error("Missing return statement in function");
3531: }
3532:
3533: final public Expression DoExpression() throws ParseException {
3534: Stack stack = new Stack();
3535: Expression exp = new Expression();
3536: expression(exp, stack);
3537: expEnd(exp, stack);
3538: // Normalize the expression (remove any NOT operators)
3539: Expression normalized_exp = Util.normalize(exp);
3540: normalized_exp.copyTextFrom(exp);
3541: {
3542: if (true)
3543: return normalized_exp;
3544: }
3545: throw new Error("Missing return statement in function");
3546: }
3547:
3548: final public Expression DoNonBooleanExpression()
3549: throws ParseException {
3550: Stack stack = new Stack();
3551: Expression exp = new Expression();
3552: nonBooleanExpression(exp, stack);
3553: expEnd(exp, stack);
3554: {
3555: if (true)
3556: return exp;
3557: }
3558: throw new Error("Missing return statement in function");
3559: }
3560:
3561: /**
3562: * Parse an expression.
3563: */
3564: final public void expression(Expression exp, Stack stack)
3565: throws ParseException {
3566: Operand(exp, stack);
3567: label_14: while (true) {
3568: if (jj_2_9(2)) {
3569: ;
3570: } else {
3571: break label_14;
3572: }
3573: OpPart(exp, stack);
3574: }
3575: }
3576:
3577: /**
3578: * Parses a non-boolean expression.
3579: */
3580: final public void nonBooleanExpression(Expression exp, Stack stack)
3581: throws ParseException {
3582: Operand(exp, stack);
3583: label_15: while (true) {
3584: if (jj_2_10(2)) {
3585: ;
3586: } else {
3587: break label_15;
3588: }
3589: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3590: case CONCAT:
3591: StringOperator(exp, stack);
3592: break;
3593: case STAR:
3594: case DIVIDE:
3595: case ADD:
3596: case SUBTRACT:
3597: NumericOperator(exp, stack);
3598: break;
3599: default:
3600: jj_la1[142] = jj_gen;
3601: jj_consume_token(-1);
3602: throw new ParseException();
3603: }
3604: Operand(exp, stack);
3605: }
3606: }
3607:
3608: final public void OpPart(Expression exp, Stack stack)
3609: throws ParseException {
3610: Token t;
3611: // SelectStatement select;
3612: // Expression[] exp_arr;
3613: Expression regex_expression;
3614: Object regex_ob;
3615: if (jj_2_11(3)) {
3616: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3617: case ASSIGNMENT:
3618: case EQUALS:
3619: case GR:
3620: case LE:
3621: case GREQ:
3622: case LEEQ:
3623: case NOTEQ:
3624: case IS:
3625: case LIKE:
3626: case AND:
3627: case OR:
3628: case NOT:
3629: BooleanOperator(exp, stack);
3630: break;
3631: case STAR:
3632: case DIVIDE:
3633: case ADD:
3634: case SUBTRACT:
3635: NumericOperator(exp, stack);
3636: break;
3637: case CONCAT:
3638: StringOperator(exp, stack);
3639: break;
3640: default:
3641: jj_la1[143] = jj_gen;
3642: jj_consume_token(-1);
3643: throw new ParseException();
3644: }
3645: Operand(exp, stack);
3646: } else {
3647: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3648: case REGEX_LITERAL:
3649: case REGEX:
3650: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3651: case REGEX:
3652: jj_consume_token(REGEX);
3653: exp.text().append(" regex ");
3654: expOperator(exp, stack, Operator.get("regex"));
3655: expression(exp, stack);
3656: break;
3657: case REGEX_LITERAL:
3658: t = jj_consume_token(REGEX_LITERAL);
3659: regex_ob = Util.toParamObject(t,
3660: case_insensitive_identifiers);
3661: exp.text().append(" regex " + regex_ob);
3662: expOperator(exp, stack, Operator.get("regex"));
3663: exp.addElement(regex_ob);
3664: break;
3665: default:
3666: jj_la1[144] = jj_gen;
3667: jj_consume_token(-1);
3668: throw new ParseException();
3669: }
3670: break;
3671: default:
3672: jj_la1[145] = jj_gen;
3673: if (jj_2_12(2)) {
3674: SubQueryOperator(exp, stack);
3675: SubQueryExpression(exp, stack);
3676: } else {
3677: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3678: case BETWEEN:
3679: case NOT:
3680: BetweenPredicate(exp, stack);
3681: break;
3682: default:
3683: jj_la1[146] = jj_gen;
3684: jj_consume_token(-1);
3685: throw new ParseException();
3686: }
3687: }
3688: }
3689: }
3690: }
3691:
3692: final public void Operand(Expression exp, Stack stack)
3693: throws ParseException {
3694: Token t, tt;
3695: FunctionDef f;
3696: Expression[] exp_list;
3697: String time_fname;
3698: boolean negative = false;
3699: Object param_ob;
3700: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3701: case 208:
3702: jj_consume_token(208);
3703: stack.push(Operator.get("("));
3704: exp.text().append("(");
3705: expression(exp, stack);
3706: jj_consume_token(209);
3707: expEndParen(exp, stack);
3708: exp.text().append(")");
3709: break;
3710: case PARAMETER_REF:
3711: t = jj_consume_token(PARAMETER_REF);
3712: Object param_resolve = createSubstitution(t.image);
3713: exp.addElement(param_resolve);
3714: exp.text().append('?');
3715: break;
3716: default:
3717: jj_la1[153] = jj_gen;
3718: if (jj_2_13(2)) {
3719: jj_consume_token(NOT);
3720: expOperator(exp, stack, Operator.get("not"));
3721: exp.text().append(" not ");
3722: Operand(exp, stack);
3723: } else if (jj_2_14(3)) {
3724: f = Function();
3725: exp.addElement(f);
3726: exp.text().append(f);
3727: } else {
3728: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3729: case DATE:
3730: case TIME:
3731: case TIMESTAMP:
3732: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3733: case DATE:
3734: tt = jj_consume_token(DATE);
3735: time_fname = "DATEOB";
3736: break;
3737: case TIME:
3738: tt = jj_consume_token(TIME);
3739: time_fname = "TIMEOB";
3740: break;
3741: case TIMESTAMP:
3742: tt = jj_consume_token(TIMESTAMP);
3743: time_fname = "TIMESTAMPOB";
3744: break;
3745: default:
3746: jj_la1[147] = jj_gen;
3747: jj_consume_token(-1);
3748: throw new ParseException();
3749: }
3750: t = jj_consume_token(STRING_LITERAL);
3751: Object param_ob1 = Util.toParamObject(t,
3752: case_insensitive_identifiers);
3753: exp_list = new Expression[] { new Expression(
3754: param_ob1) };
3755: f = Util.resolveFunctionName(time_fname, exp_list);
3756: exp.addElement(f);
3757: exp.text().append(tt.image).append(" ").append(
3758: t.image);
3759: break;
3760: case CURRENT_TIME:
3761: case CURRENT_DATE:
3762: case CURRENT_TIMESTAMP:
3763: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3764: case CURRENT_TIMESTAMP:
3765: tt = jj_consume_token(CURRENT_TIMESTAMP);
3766: time_fname = "TIMESTAMPOB";
3767: break;
3768: case CURRENT_TIME:
3769: tt = jj_consume_token(CURRENT_TIME);
3770: time_fname = "TIMEOB";
3771: break;
3772: case CURRENT_DATE:
3773: tt = jj_consume_token(CURRENT_DATE);
3774: time_fname = "DATEOB";
3775: break;
3776: default:
3777: jj_la1[148] = jj_gen;
3778: jj_consume_token(-1);
3779: throw new ParseException();
3780: }
3781: exp_list = new Expression[0];
3782: f = Util.resolveFunctionName(time_fname, exp_list);
3783: exp.addElement(f);
3784: exp.text().append(tt.image);
3785: break;
3786: case NEW:
3787: jj_consume_token(NEW);
3788: f = JavaInstantiation();
3789: exp.addElement(f);
3790: exp.text().append(f);
3791: break;
3792: case BOOLEAN_LITERAL:
3793: case NULL_LITERAL:
3794: case STRING_LITERAL:
3795: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3796: case STRING_LITERAL:
3797: t = jj_consume_token(STRING_LITERAL);
3798: break;
3799: case BOOLEAN_LITERAL:
3800: t = jj_consume_token(BOOLEAN_LITERAL);
3801: break;
3802: case NULL_LITERAL:
3803: t = jj_consume_token(NULL_LITERAL);
3804: break;
3805: default:
3806: jj_la1[149] = jj_gen;
3807: jj_consume_token(-1);
3808: throw new ParseException();
3809: }
3810: param_ob = Util.toParamObject(t,
3811: case_insensitive_identifiers);
3812: exp.addElement(param_ob);
3813: exp.text().append(t.image);
3814: break;
3815: case ADD:
3816: case SUBTRACT:
3817: case NAME:
3818: case JAVA:
3819: case ACTION:
3820: case GROUPS:
3821: case OPTION:
3822: case ACCOUNT:
3823: case PASSWORD:
3824: case LANGUAGE:
3825: case PRIVILEGES:
3826: case NUMBER_LITERAL:
3827: case QUOTED_VARIABLE:
3828: case IDENTIFIER:
3829: case DOT_DELIMINATED_REF:
3830: case QUOTED_DELIMINATED_REF:
3831: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3832: case ADD:
3833: case SUBTRACT:
3834: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3835: case ADD:
3836: jj_consume_token(ADD);
3837: break;
3838: case SUBTRACT:
3839: jj_consume_token(SUBTRACT);
3840: negative = true;
3841: break;
3842: default:
3843: jj_la1[150] = jj_gen;
3844: jj_consume_token(-1);
3845: throw new ParseException();
3846: }
3847: break;
3848: default:
3849: jj_la1[151] = jj_gen;
3850: ;
3851: }
3852: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3853: case NUMBER_LITERAL:
3854: t = jj_consume_token(NUMBER_LITERAL);
3855: break;
3856: case QUOTED_VARIABLE:
3857: t = jj_consume_token(QUOTED_VARIABLE);
3858: break;
3859: case DOT_DELIMINATED_REF:
3860: t = jj_consume_token(DOT_DELIMINATED_REF);
3861: break;
3862: case QUOTED_DELIMINATED_REF:
3863: t = jj_consume_token(QUOTED_DELIMINATED_REF);
3864: break;
3865: case NAME:
3866: case JAVA:
3867: case ACTION:
3868: case GROUPS:
3869: case OPTION:
3870: case ACCOUNT:
3871: case PASSWORD:
3872: case LANGUAGE:
3873: case PRIVILEGES:
3874: case IDENTIFIER:
3875: t = SQLIdentifier();
3876: break;
3877: default:
3878: jj_la1[152] = jj_gen;
3879: jj_consume_token(-1);
3880: throw new ParseException();
3881: }
3882: if (t.kind == SQLConstants.NUMBER_LITERAL) {
3883: param_ob = Util.parseNumberToken(t, negative);
3884: exp.addElement(param_ob);
3885: } else {
3886: param_ob = Util.toParamObject(t,
3887: case_insensitive_identifiers);
3888: if (negative) {
3889: exp.addElement(Util.zeroNumber());
3890: exp.addElement(param_ob);
3891: exp.addElement(Operator.get("-"));
3892: } else {
3893: exp.addElement(param_ob);
3894: }
3895: }
3896: if (negative) {
3897: exp.text().append('-');
3898: }
3899: exp.text().append(t.image);
3900: break;
3901: default:
3902: jj_la1[154] = jj_gen;
3903: jj_consume_token(-1);
3904: throw new ParseException();
3905: }
3906: }
3907: }
3908: }
3909:
3910: final public void SubQueryExpression(Expression exp, Stack stack)
3911: throws ParseException {
3912: TableSelectExpression select;
3913: Expression[] exp_arr;
3914: jj_consume_token(208);
3915: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3916: case SELECT:
3917: select = GetTableSelectExpression();
3918: exp.addElement(select);
3919: exp.text().append(" [SELECT]");
3920: break;
3921: default:
3922: jj_la1[155] = jj_gen;
3923: exp_arr = ExpressionList();
3924: exp.addElement(Util.toArrayParamObject(exp_arr));
3925: exp.text().append(
3926: " (" + Util.expressionListToString(exp_arr) + ")");
3927: }
3928: jj_consume_token(209);
3929: }
3930:
3931: // Parses a simple positive integer constant.
3932: final public int PositiveIntegerConstant() throws ParseException {
3933: Token t;
3934: t = jj_consume_token(NUMBER_LITERAL);
3935: int val = Integer.parseInt(t.image);
3936: if (val < 0)
3937: generateParseException();
3938: {
3939: if (true)
3940: return val;
3941: }
3942: throw new Error("Missing return statement in function");
3943: }
3944:
3945: final public void SubQueryOperator(Expression exp, Stack stack)
3946: throws ParseException {
3947: Token t;
3948: String op_string;
3949: String query_type = "SINGLE";
3950: Operator op;
3951: if (jj_2_15(2)) {
3952: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3953: case IN:
3954: jj_consume_token(IN);
3955: op = Operator.get("IN");
3956: break;
3957: case NOT:
3958: jj_consume_token(NOT);
3959: jj_consume_token(IN);
3960: op = Operator.get("NOT IN");
3961: break;
3962: default:
3963: jj_la1[156] = jj_gen;
3964: jj_consume_token(-1);
3965: throw new ParseException();
3966: }
3967: } else {
3968: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3969: case ASSIGNMENT:
3970: case EQUALS:
3971: case GR:
3972: case LE:
3973: case GREQ:
3974: case LEEQ:
3975: case NOTEQ:
3976: op_string = GetSubQueryBooleanOperator();
3977: op = Operator.get(op_string);
3978: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3979: case ALL:
3980: case ANY:
3981: case SOME:
3982: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3983: case ANY:
3984: t = jj_consume_token(ANY);
3985: break;
3986: case ALL:
3987: t = jj_consume_token(ALL);
3988: break;
3989: case SOME:
3990: t = jj_consume_token(SOME);
3991: break;
3992: default:
3993: jj_la1[157] = jj_gen;
3994: jj_consume_token(-1);
3995: throw new ParseException();
3996: }
3997: query_type = t.image;
3998: break;
3999: default:
4000: jj_la1[158] = jj_gen;
4001: ;
4002: }
4003: op = op.getSubQueryForm(query_type);
4004: break;
4005: default:
4006: jj_la1[159] = jj_gen;
4007: jj_consume_token(-1);
4008: throw new ParseException();
4009: }
4010: }
4011: expOperator(exp, stack, op);
4012: exp.text().append(" " + op + " ");
4013: }
4014:
4015: final public void BetweenPredicate(Expression exp, Stack stack)
4016: throws ParseException {
4017: boolean not_s = false;
4018: Expression exp1, exp2;
4019: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4020: case NOT:
4021: jj_consume_token(NOT);
4022: not_s = true;
4023: break;
4024: default:
4025: jj_la1[160] = jj_gen;
4026: ;
4027: }
4028: jj_consume_token(BETWEEN);
4029: exp1 = DoNonBooleanExpression();
4030: jj_consume_token(AND);
4031: exp2 = DoNonBooleanExpression();
4032: // Flush the operator stack to precedence 8
4033: flushOperatorStack(exp, stack, 8);
4034: // Get the end expression
4035: Expression end_exp = exp.getEndExpression();
4036: if (not_s) {
4037: exp.concat(exp1);
4038: exp.addElement(Operator.get("<"));
4039: exp.concat(end_exp);
4040: exp.concat(exp2);
4041: exp.addElement(Operator.get(">"));
4042: exp.addElement(Operator.get("or"));
4043: exp.text().append(" not between ");
4044: } else {
4045: exp.concat(exp1);
4046: exp.addElement(Operator.get(">="));
4047: exp.concat(end_exp);
4048: exp.concat(exp2);
4049: exp.addElement(Operator.get("<="));
4050: exp.addElement(Operator.get("and"));
4051: exp.text().append(" between ");
4052: }
4053: exp.text().append(exp1.text().toString());
4054: exp.text().append(" and ");
4055: exp.text().append(exp2.text().toString());
4056: }
4057:
4058: final public void BooleanOperator(Expression exp, Stack stack)
4059: throws ParseException {
4060: Token t;
4061: String op_string;
4062: Operator op;
4063: op_string = GetBooleanOperator();
4064: op = Operator.get(op_string);
4065: expOperator(exp, stack, op);
4066: exp.text().append(" " + op + " ");
4067: }
4068:
4069: final public void NumericOperator(Expression exp, Stack stack)
4070: throws ParseException {
4071: Token t;
4072: String op_string;
4073: Operator op;
4074: op_string = GetNumericOperator();
4075: op = Operator.get(op_string);
4076: expOperator(exp, stack, op);
4077: exp.text().append(" " + op + " ");
4078: }
4079:
4080: final public void StringOperator(Expression exp, Stack stack)
4081: throws ParseException {
4082: Token t;
4083: String op_string;
4084: Operator op;
4085: op_string = GetStringOperator();
4086: op = Operator.get(op_string);
4087: expOperator(exp, stack, op);
4088: exp.text().append(" " + op + " ");
4089: }
4090:
4091: final public String GetBooleanOperator() throws ParseException {
4092: Token t;
4093: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4094: case ASSIGNMENT:
4095: t = jj_consume_token(ASSIGNMENT);
4096: break;
4097: case EQUALS:
4098: t = jj_consume_token(EQUALS);
4099: break;
4100: case GR:
4101: t = jj_consume_token(GR);
4102: break;
4103: case LE:
4104: t = jj_consume_token(LE);
4105: break;
4106: case GREQ:
4107: t = jj_consume_token(GREQ);
4108: break;
4109: case LEEQ:
4110: t = jj_consume_token(LEEQ);
4111: break;
4112: case NOTEQ:
4113: t = jj_consume_token(NOTEQ);
4114: break;
4115: default:
4116: jj_la1[161] = jj_gen;
4117: if (jj_2_16(2)) {
4118: jj_consume_token(IS);
4119: jj_consume_token(NOT);
4120: {
4121: if (true)
4122: return "IS NOT";
4123: }
4124: } else {
4125: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4126: case IS:
4127: t = jj_consume_token(IS);
4128: break;
4129: case LIKE:
4130: t = jj_consume_token(LIKE);
4131: break;
4132: case NOT:
4133: jj_consume_token(NOT);
4134: jj_consume_token(LIKE);
4135: {
4136: if (true)
4137: return "NOT LIKE";
4138: }
4139: break;
4140: case AND:
4141: t = jj_consume_token(AND);
4142: break;
4143: case OR:
4144: t = jj_consume_token(OR);
4145: break;
4146: default:
4147: jj_la1[162] = jj_gen;
4148: jj_consume_token(-1);
4149: throw new ParseException();
4150: }
4151: }
4152: }
4153: {
4154: if (true)
4155: return t.image;
4156: }
4157: throw new Error("Missing return statement in function");
4158: }
4159:
4160: final public String GetSubQueryBooleanOperator()
4161: throws ParseException {
4162: Token t;
4163: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4164: case ASSIGNMENT:
4165: t = jj_consume_token(ASSIGNMENT);
4166: break;
4167: case EQUALS:
4168: t = jj_consume_token(EQUALS);
4169: break;
4170: case GR:
4171: t = jj_consume_token(GR);
4172: break;
4173: case LE:
4174: t = jj_consume_token(LE);
4175: break;
4176: case GREQ:
4177: t = jj_consume_token(GREQ);
4178: break;
4179: case LEEQ:
4180: t = jj_consume_token(LEEQ);
4181: break;
4182: case NOTEQ:
4183: t = jj_consume_token(NOTEQ);
4184: break;
4185: default:
4186: jj_la1[163] = jj_gen;
4187: jj_consume_token(-1);
4188: throw new ParseException();
4189: }
4190: {
4191: if (true)
4192: return t.image;
4193: }
4194: throw new Error("Missing return statement in function");
4195: }
4196:
4197: final public String GetNumericOperator() throws ParseException {
4198: Token t;
4199: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4200: case DIVIDE:
4201: t = jj_consume_token(DIVIDE);
4202: break;
4203: case ADD:
4204: t = jj_consume_token(ADD);
4205: break;
4206: case SUBTRACT:
4207: t = jj_consume_token(SUBTRACT);
4208: break;
4209: case STAR:
4210: t = jj_consume_token(STAR);
4211: break;
4212: default:
4213: jj_la1[164] = jj_gen;
4214: jj_consume_token(-1);
4215: throw new ParseException();
4216: }
4217: {
4218: if (true)
4219: return t.image;
4220: }
4221: throw new Error("Missing return statement in function");
4222: }
4223:
4224: final public String GetStringOperator() throws ParseException {
4225: Token t;
4226: t = jj_consume_token(CONCAT);
4227: {
4228: if (true)
4229: return t.image;
4230: }
4231: throw new Error("Missing return statement in function");
4232: }
4233:
4234: final public Token FunctionIdentifier() throws ParseException {
4235: Token t;
4236: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4237: case IF:
4238: t = jj_consume_token(IF);
4239: break;
4240: case USER:
4241: t = jj_consume_token(USER);
4242: break;
4243: case IDENTIFIER:
4244: t = jj_consume_token(IDENTIFIER);
4245: break;
4246: default:
4247: jj_la1[165] = jj_gen;
4248: jj_consume_token(-1);
4249: throw new ParseException();
4250: }
4251: {
4252: if (true)
4253: return t;
4254: }
4255: throw new Error("Missing return statement in function");
4256: }
4257:
4258: final public FunctionDef Function() throws ParseException {
4259: Token t, t2 = null, t3 = null;
4260: FunctionDef f;
4261: Expression exp1, exp2;
4262: Expression[] exp_list;
4263: TType cast_type;
4264: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4265: case COUNT:
4266: t = jj_consume_token(COUNT);
4267: jj_consume_token(208);
4268: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4269: case DISTINCT:
4270: jj_consume_token(DISTINCT);
4271: t.image = "distinct_count";
4272: break;
4273: default:
4274: jj_la1[166] = jj_gen;
4275: ;
4276: }
4277: exp_list = FunctionParams();
4278: jj_consume_token(209);
4279: break;
4280: case TRIM:
4281: t = jj_consume_token(TRIM);
4282: jj_consume_token(208);
4283: if (jj_2_17(3)) {
4284: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4285: case BOTH:
4286: case LEADING:
4287: case TRAILING:
4288: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4289: case LEADING:
4290: t2 = jj_consume_token(LEADING);
4291: break;
4292: case BOTH:
4293: t2 = jj_consume_token(BOTH);
4294: break;
4295: case TRAILING:
4296: t2 = jj_consume_token(TRAILING);
4297: break;
4298: default:
4299: jj_la1[167] = jj_gen;
4300: jj_consume_token(-1);
4301: throw new ParseException();
4302: }
4303: break;
4304: default:
4305: jj_la1[168] = jj_gen;
4306: ;
4307: }
4308: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4309: case STRING_LITERAL:
4310: t3 = jj_consume_token(STRING_LITERAL);
4311: break;
4312: default:
4313: jj_la1[169] = jj_gen;
4314: ;
4315: }
4316: jj_consume_token(FROM);
4317: } else {
4318: ;
4319: }
4320: exp1 = DoExpression();
4321: jj_consume_token(209);
4322: exp_list = new Expression[3];
4323: String ttype = t2 == null ? "both" : t2.image.toLowerCase();
4324: Object str_char = t3 == null ? TObject.stringVal(" ")
4325: : Util.toParamObject(t3,
4326: case_insensitive_identifiers);
4327: exp_list[0] = new Expression(TObject.stringVal(ttype));
4328: exp_list[0].text().append("'" + ttype + "'");
4329: exp_list[1] = new Expression(str_char);
4330: exp_list[1].text().append("'" + str_char + "'");
4331: exp_list[2] = exp1;
4332: {
4333: if (true)
4334: return Util.resolveFunctionName("sql_trim",
4335: exp_list);
4336: }
4337: break;
4338: case CAST:
4339: t = jj_consume_token(CAST);
4340: jj_consume_token(208);
4341: exp1 = DoExpression();
4342: jj_consume_token(AS);
4343: cast_type = GetTType();
4344: jj_consume_token(209);
4345: exp_list = new Expression[2];
4346: String enc_form = TType.asEncodedString(cast_type);
4347: exp_list[0] = exp1;
4348: exp_list[1] = new Expression(TObject.stringVal(enc_form));
4349: exp_list[1].text().append("'" + enc_form + "'");
4350: {
4351: if (true)
4352: return Util.resolveFunctionName("sql_cast",
4353: exp_list);
4354: }
4355: break;
4356: case IF:
4357: case USER:
4358: case IDENTIFIER:
4359: t = FunctionIdentifier();
4360: jj_consume_token(208);
4361: exp_list = FunctionParams();
4362: jj_consume_token(209);
4363: break;
4364: default:
4365: jj_la1[170] = jj_gen;
4366: jj_consume_token(-1);
4367: throw new ParseException();
4368: }
4369: {
4370: if (true)
4371: return Util.resolveFunctionName(t.image, exp_list);
4372: }
4373: throw new Error("Missing return statement in function");
4374: }
4375:
4376: // An instantiation of a java object. For example, 'java.awt.Point(40, 30)'
4377: final public FunctionDef JavaInstantiation() throws ParseException {
4378: Token t;
4379: Expression[] args;
4380: // PENDING: Handling arrays (eg. 'java.lang.String[] { 'Tobias', 'Downer' }' or 'double[] { 25, 2, 75, 26 }' )
4381: t = jj_consume_token(DOT_DELIMINATED_REF);
4382: jj_consume_token(208);
4383: args = ExpressionList();
4384: jj_consume_token(209);
4385: Expression[] comp_args = new Expression[args.length + 1];
4386: System.arraycopy(args, 0, comp_args, 1, args.length);
4387: comp_args[0] = new Expression(TObject.stringVal(t.image));
4388: comp_args[0].text().append("'" + t.image + "'");
4389: {
4390: if (true)
4391: return Util.resolveFunctionName("_new_JavaObject",
4392: comp_args);
4393: }
4394: throw new Error("Missing return statement in function");
4395: }
4396:
4397: // Parameters for a function
4398: final public Expression[] FunctionParams() throws ParseException {
4399: Expression[] exp_list;
4400: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4401: case STAR:
4402: jj_consume_token(STAR);
4403: exp_list = FunctionFactory.GLOB_LIST;
4404: break;
4405: default:
4406: jj_la1[171] = jj_gen;
4407: exp_list = ExpressionList();
4408: }
4409: {
4410: if (true)
4411: return exp_list;
4412: }
4413: throw new Error("Missing return statement in function");
4414: }
4415:
4416: final public Expression[] ExpressionList() throws ParseException {
4417: ArrayList list = new ArrayList();
4418: Expression e;
4419: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4420: case ADD:
4421: case SUBTRACT:
4422: case BOOLEAN_LITERAL:
4423: case NULL_LITERAL:
4424: case IF:
4425: case NEW:
4426: case TRIM:
4427: case USER:
4428: case CAST:
4429: case NAME:
4430: case JAVA:
4431: case COUNT:
4432: case ACTION:
4433: case GROUPS:
4434: case OPTION:
4435: case ACCOUNT:
4436: case PASSWORD:
4437: case LANGUAGE:
4438: case PRIVILEGES:
4439: case DATE:
4440: case TIME:
4441: case TIMESTAMP:
4442: case CURRENT_TIME:
4443: case CURRENT_DATE:
4444: case CURRENT_TIMESTAMP:
4445: case NOT:
4446: case NUMBER_LITERAL:
4447: case STRING_LITERAL:
4448: case QUOTED_VARIABLE:
4449: case IDENTIFIER:
4450: case DOT_DELIMINATED_REF:
4451: case QUOTED_DELIMINATED_REF:
4452: case PARAMETER_REF:
4453: case 208:
4454: e = DoExpression();
4455: list.add(e);
4456: label_16: while (true) {
4457: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4458: case 210:
4459: ;
4460: break;
4461: default:
4462: jj_la1[172] = jj_gen;
4463: break label_16;
4464: }
4465: jj_consume_token(210);
4466: e = DoExpression();
4467: list.add(e);
4468: }
4469: break;
4470: default:
4471: jj_la1[173] = jj_gen;
4472: ;
4473: }
4474: {
4475: if (true)
4476: return (Expression[]) list.toArray(new Expression[list
4477: .size()]);
4478: }
4479: throw new Error("Missing return statement in function");
4480: }
4481:
4482: final public String GetComposite() throws ParseException {
4483: Token name;
4484: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4485: case UNION:
4486: name = jj_consume_token(UNION);
4487: break;
4488: case INTERSECT:
4489: name = jj_consume_token(INTERSECT);
4490: break;
4491: case EXCEPT:
4492: name = jj_consume_token(EXCEPT);
4493: break;
4494: default:
4495: jj_la1[174] = jj_gen;
4496: jj_consume_token(-1);
4497: throw new ParseException();
4498: }
4499: {
4500: if (true)
4501: return name.image;
4502: }
4503: throw new Error("Missing return statement in function");
4504: }
4505:
4506: final public String TableName() throws ParseException {
4507: Token name;
4508: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4509: case QUOTED_VARIABLE:
4510: name = jj_consume_token(QUOTED_VARIABLE);
4511: break;
4512: case NAME:
4513: case JAVA:
4514: case ACTION:
4515: case GROUPS:
4516: case OPTION:
4517: case ACCOUNT:
4518: case PASSWORD:
4519: case LANGUAGE:
4520: case PRIVILEGES:
4521: case IDENTIFIER:
4522: name = SQLIdentifier();
4523: break;
4524: case OLD:
4525: name = jj_consume_token(OLD);
4526: break;
4527: case NEW:
4528: name = jj_consume_token(NEW);
4529: break;
4530: case DOT_DELIMINATED_REF:
4531: name = jj_consume_token(DOT_DELIMINATED_REF);
4532: break;
4533: case QUOTED_DELIMINATED_REF:
4534: name = jj_consume_token(QUOTED_DELIMINATED_REF);
4535: break;
4536: default:
4537: jj_la1[175] = jj_gen;
4538: jj_consume_token(-1);
4539: throw new ParseException();
4540: }
4541: {
4542: if (true)
4543: return caseCheck(Util.asNonQuotedRef(name));
4544: }
4545: throw new Error("Missing return statement in function");
4546: }
4547:
4548: final public String SequenceName() throws ParseException {
4549: Token name;
4550: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4551: case QUOTED_VARIABLE:
4552: name = jj_consume_token(QUOTED_VARIABLE);
4553: break;
4554: case NAME:
4555: case JAVA:
4556: case ACTION:
4557: case GROUPS:
4558: case OPTION:
4559: case ACCOUNT:
4560: case PASSWORD:
4561: case LANGUAGE:
4562: case PRIVILEGES:
4563: case IDENTIFIER:
4564: name = SQLIdentifier();
4565: break;
4566: case DOT_DELIMINATED_REF:
4567: name = jj_consume_token(DOT_DELIMINATED_REF);
4568: break;
4569: case QUOTED_DELIMINATED_REF:
4570: name = jj_consume_token(QUOTED_DELIMINATED_REF);
4571: break;
4572: default:
4573: jj_la1[176] = jj_gen;
4574: jj_consume_token(-1);
4575: throw new ParseException();
4576: }
4577: {
4578: if (true)
4579: return caseCheck(Util.asNonQuotedRef(name));
4580: }
4581: throw new Error("Missing return statement in function");
4582: }
4583:
4584: final public String TriggerName() throws ParseException {
4585: Token name;
4586: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4587: case QUOTED_VARIABLE:
4588: name = jj_consume_token(QUOTED_VARIABLE);
4589: break;
4590: case NAME:
4591: case JAVA:
4592: case ACTION:
4593: case GROUPS:
4594: case OPTION:
4595: case ACCOUNT:
4596: case PASSWORD:
4597: case LANGUAGE:
4598: case PRIVILEGES:
4599: case IDENTIFIER:
4600: name = SQLIdentifier();
4601: break;
4602: default:
4603: jj_la1[177] = jj_gen;
4604: jj_consume_token(-1);
4605: throw new ParseException();
4606: }
4607: {
4608: if (true)
4609: return caseCheck(Util.asNonQuotedRef(name));
4610: }
4611: throw new Error("Missing return statement in function");
4612: }
4613:
4614: final public String IndexName() throws ParseException {
4615: Token name;
4616: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4617: case QUOTED_VARIABLE:
4618: name = jj_consume_token(QUOTED_VARIABLE);
4619: break;
4620: case NAME:
4621: case JAVA:
4622: case ACTION:
4623: case GROUPS:
4624: case OPTION:
4625: case ACCOUNT:
4626: case PASSWORD:
4627: case LANGUAGE:
4628: case PRIVILEGES:
4629: case IDENTIFIER:
4630: name = SQLIdentifier();
4631: break;
4632: default:
4633: jj_la1[178] = jj_gen;
4634: jj_consume_token(-1);
4635: throw new ParseException();
4636: }
4637: {
4638: if (true)
4639: return caseCheck(Util.asNonQuotedRef(name));
4640: }
4641: throw new Error("Missing return statement in function");
4642: }
4643:
4644: // A username
4645: final public String UserName() throws ParseException {
4646: Token name;
4647: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4648: case QUOTED_VARIABLE:
4649: name = jj_consume_token(QUOTED_VARIABLE);
4650: break;
4651: case IDENTIFIER:
4652: name = jj_consume_token(IDENTIFIER);
4653: break;
4654: case PUBLIC:
4655: name = jj_consume_token(PUBLIC);
4656: break;
4657: default:
4658: jj_la1[179] = jj_gen;
4659: jj_consume_token(-1);
4660: throw new ParseException();
4661: }
4662: {
4663: if (true)
4664: return caseCheck(Util.asNonQuotedRef(name));
4665: }
4666: throw new Error("Missing return statement in function");
4667: }
4668:
4669: // Name of a schema
4670: final public String SchemaName() throws ParseException {
4671: Token name;
4672: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4673: case QUOTED_VARIABLE:
4674: name = jj_consume_token(QUOTED_VARIABLE);
4675: break;
4676: case NAME:
4677: case JAVA:
4678: case ACTION:
4679: case GROUPS:
4680: case OPTION:
4681: case ACCOUNT:
4682: case PASSWORD:
4683: case LANGUAGE:
4684: case PRIVILEGES:
4685: case IDENTIFIER:
4686: name = SQLIdentifier();
4687: break;
4688: default:
4689: jj_la1[180] = jj_gen;
4690: jj_consume_token(-1);
4691: throw new ParseException();
4692: }
4693: {
4694: if (true)
4695: return caseCheck(Util.asNonQuotedRef(name));
4696: }
4697: throw new Error("Missing return statement in function");
4698: }
4699:
4700: // Name of a constraint name
4701: final public String ConstraintName() throws ParseException {
4702: Token name;
4703: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4704: case QUOTED_VARIABLE:
4705: name = jj_consume_token(QUOTED_VARIABLE);
4706: break;
4707: case NAME:
4708: case JAVA:
4709: case ACTION:
4710: case GROUPS:
4711: case OPTION:
4712: case ACCOUNT:
4713: case PASSWORD:
4714: case LANGUAGE:
4715: case PRIVILEGES:
4716: case IDENTIFIER:
4717: name = SQLIdentifier();
4718: break;
4719: default:
4720: jj_la1[181] = jj_gen;
4721: jj_consume_token(-1);
4722: throw new ParseException();
4723: }
4724: {
4725: if (true)
4726: return caseCheck(Util.asNonQuotedRef(name));
4727: }
4728: throw new Error("Missing return statement in function");
4729: }
4730:
4731: // Parses a column name
4732: final public String ColumnName() throws ParseException {
4733: Token name;
4734: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4735: case QUOTED_VARIABLE:
4736: name = jj_consume_token(QUOTED_VARIABLE);
4737: break;
4738: case NAME:
4739: case JAVA:
4740: case ACTION:
4741: case GROUPS:
4742: case OPTION:
4743: case ACCOUNT:
4744: case PASSWORD:
4745: case LANGUAGE:
4746: case PRIVILEGES:
4747: case IDENTIFIER:
4748: name = SQLIdentifier();
4749: break;
4750: case DOT_DELIMINATED_REF:
4751: name = jj_consume_token(DOT_DELIMINATED_REF);
4752: break;
4753: case QUOTED_DELIMINATED_REF:
4754: name = jj_consume_token(QUOTED_DELIMINATED_REF);
4755: break;
4756: default:
4757: jj_la1[182] = jj_gen;
4758: jj_consume_token(-1);
4759: throw new ParseException();
4760: }
4761: {
4762: if (true)
4763: return caseCheck(Util.asNonQuotedRef(name));
4764: }
4765: throw new Error("Missing return statement in function");
4766: }
4767:
4768: // Parses a column name as a Variable object
4769: final public Variable ColumnNameVariable() throws ParseException {
4770: Token name;
4771: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4772: case QUOTED_VARIABLE:
4773: name = jj_consume_token(QUOTED_VARIABLE);
4774: break;
4775: case NAME:
4776: case JAVA:
4777: case ACTION:
4778: case GROUPS:
4779: case OPTION:
4780: case ACCOUNT:
4781: case PASSWORD:
4782: case LANGUAGE:
4783: case PRIVILEGES:
4784: case IDENTIFIER:
4785: name = SQLIdentifier();
4786: break;
4787: case DOT_DELIMINATED_REF:
4788: name = jj_consume_token(DOT_DELIMINATED_REF);
4789: break;
4790: case QUOTED_DELIMINATED_REF:
4791: name = jj_consume_token(QUOTED_DELIMINATED_REF);
4792: break;
4793: default:
4794: jj_la1[183] = jj_gen;
4795: jj_consume_token(-1);
4796: throw new ParseException();
4797: }
4798: {
4799: if (true)
4800: return (Variable) Util.toParamObject(name,
4801: case_insensitive_identifiers);
4802: }
4803: throw new Error("Missing return statement in function");
4804: }
4805:
4806: // Parses an aliased table name
4807: final public String TableAliasName() throws ParseException {
4808: Token name;
4809: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4810: case QUOTED_VARIABLE:
4811: name = jj_consume_token(QUOTED_VARIABLE);
4812: break;
4813: case NAME:
4814: case JAVA:
4815: case ACTION:
4816: case GROUPS:
4817: case OPTION:
4818: case ACCOUNT:
4819: case PASSWORD:
4820: case LANGUAGE:
4821: case PRIVILEGES:
4822: case IDENTIFIER:
4823: name = SQLIdentifier();
4824: break;
4825: default:
4826: jj_la1[184] = jj_gen;
4827: jj_consume_token(-1);
4828: throw new ParseException();
4829: }
4830: {
4831: if (true)
4832: return caseCheck(Util.asNonQuotedRef(name));
4833: }
4834: throw new Error("Missing return statement in function");
4835: }
4836:
4837: // Parses a procedure name
4838: final public String ProcedureName() throws ParseException {
4839: Token name;
4840: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4841: case QUOTED_VARIABLE:
4842: name = jj_consume_token(QUOTED_VARIABLE);
4843: break;
4844: case NAME:
4845: case JAVA:
4846: case ACTION:
4847: case GROUPS:
4848: case OPTION:
4849: case ACCOUNT:
4850: case PASSWORD:
4851: case LANGUAGE:
4852: case PRIVILEGES:
4853: case IDENTIFIER:
4854: name = SQLIdentifier();
4855: break;
4856: case DOT_DELIMINATED_REF:
4857: name = jj_consume_token(DOT_DELIMINATED_REF);
4858: break;
4859: case QUOTED_DELIMINATED_REF:
4860: name = jj_consume_token(QUOTED_DELIMINATED_REF);
4861: break;
4862: default:
4863: jj_la1[185] = jj_gen;
4864: jj_consume_token(-1);
4865: throw new ParseException();
4866: }
4867: {
4868: if (true)
4869: return caseCheck(Util.asNonQuotedRef(name));
4870: }
4871: throw new Error("Missing return statement in function");
4872: }
4873:
4874: // Parses a function name
4875: final public String FunctionName() throws ParseException {
4876: Token name;
4877: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4878: case QUOTED_VARIABLE:
4879: name = jj_consume_token(QUOTED_VARIABLE);
4880: break;
4881: case NAME:
4882: case JAVA:
4883: case ACTION:
4884: case GROUPS:
4885: case OPTION:
4886: case ACCOUNT:
4887: case PASSWORD:
4888: case LANGUAGE:
4889: case PRIVILEGES:
4890: case IDENTIFIER:
4891: name = SQLIdentifier();
4892: break;
4893: case DOT_DELIMINATED_REF:
4894: name = jj_consume_token(DOT_DELIMINATED_REF);
4895: break;
4896: case QUOTED_DELIMINATED_REF:
4897: name = jj_consume_token(QUOTED_DELIMINATED_REF);
4898: break;
4899: default:
4900: jj_la1[186] = jj_gen;
4901: jj_consume_token(-1);
4902: throw new ParseException();
4903: }
4904: {
4905: if (true)
4906: return caseCheck(Util.asNonQuotedRef(name));
4907: }
4908: throw new Error("Missing return statement in function");
4909: }
4910:
4911: // Parses the name of an argument in a procedure/function declaration
4912: final public String ProcArgumentName() throws ParseException {
4913: Token name;
4914: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4915: case QUOTED_VARIABLE:
4916: name = jj_consume_token(QUOTED_VARIABLE);
4917: break;
4918: case NAME:
4919: case JAVA:
4920: case ACTION:
4921: case GROUPS:
4922: case OPTION:
4923: case ACCOUNT:
4924: case PASSWORD:
4925: case LANGUAGE:
4926: case PRIVILEGES:
4927: case IDENTIFIER:
4928: name = SQLIdentifier();
4929: break;
4930: default:
4931: jj_la1[187] = jj_gen;
4932: jj_consume_token(-1);
4933: throw new ParseException();
4934: }
4935: {
4936: if (true)
4937: return caseCheck(Util.asNonQuotedRef(name));
4938: }
4939: throw new Error("Missing return statement in function");
4940: }
4941:
4942: // Parses an SQL identifier
4943: final public Token SQLIdentifier() throws ParseException {
4944: Token name;
4945: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4946: case IDENTIFIER:
4947: name = jj_consume_token(IDENTIFIER);
4948: break;
4949: case OPTION:
4950: name = jj_consume_token(OPTION);
4951: break;
4952: case ACCOUNT:
4953: name = jj_consume_token(ACCOUNT);
4954: break;
4955: case PASSWORD:
4956: name = jj_consume_token(PASSWORD);
4957: break;
4958: case PRIVILEGES:
4959: name = jj_consume_token(PRIVILEGES);
4960: break;
4961: case GROUPS:
4962: name = jj_consume_token(GROUPS);
4963: break;
4964: case LANGUAGE:
4965: name = jj_consume_token(LANGUAGE);
4966: break;
4967: case NAME:
4968: name = jj_consume_token(NAME);
4969: break;
4970: case JAVA:
4971: name = jj_consume_token(JAVA);
4972: break;
4973: case ACTION:
4974: name = jj_consume_token(ACTION);
4975: break;
4976: default:
4977: jj_la1[188] = jj_gen;
4978: jj_consume_token(-1);
4979: throw new ParseException();
4980: }
4981: {
4982: if (true)
4983: return name;
4984: }
4985: throw new Error("Missing return statement in function");
4986: }
4987:
4988: final private boolean jj_2_1(int xla) {
4989: jj_la = xla;
4990: jj_lastpos = jj_scanpos = token;
4991: boolean retval = !jj_3_1();
4992: jj_save(0, xla);
4993: return retval;
4994: }
4995:
4996: final private boolean jj_2_2(int xla) {
4997: jj_la = xla;
4998: jj_lastpos = jj_scanpos = token;
4999: boolean retval = !jj_3_2();
5000: jj_save(1, xla);
5001: return retval;
5002: }
5003:
5004: final private boolean jj_2_3(int xla) {
5005: jj_la = xla;
5006: jj_lastpos = jj_scanpos = token;
5007: boolean retval = !jj_3_3();
5008: jj_save(2, xla);
5009: return retval;
5010: }
5011:
5012: final private boolean jj_2_4(int xla) {
5013: jj_la = xla;
5014: jj_lastpos = jj_scanpos = token;
5015: boolean retval = !jj_3_4();
5016: jj_save(3, xla);
5017: return retval;
5018: }
5019:
5020: final private boolean jj_2_5(int xla) {
5021: jj_la = xla;
5022: jj_lastpos = jj_scanpos = token;
5023: boolean retval = !jj_3_5();
5024: jj_save(4, xla);
5025: return retval;
5026: }
5027:
5028: final private boolean jj_2_6(int xla) {
5029: jj_la = xla;
5030: jj_lastpos = jj_scanpos = token;
5031: boolean retval = !jj_3_6();
5032: jj_save(5, xla);
5033: return retval;
5034: }
5035:
5036: final private boolean jj_2_7(int xla) {
5037: jj_la = xla;
5038: jj_lastpos = jj_scanpos = token;
5039: boolean retval = !jj_3_7();
5040: jj_save(6, xla);
5041: return retval;
5042: }
5043:
5044: final private boolean jj_2_8(int xla) {
5045: jj_la = xla;
5046: jj_lastpos = jj_scanpos = token;
5047: boolean retval = !jj_3_8();
5048: jj_save(7, xla);
5049: return retval;
5050: }
5051:
5052: final private boolean jj_2_9(int xla) {
5053: jj_la = xla;
5054: jj_lastpos = jj_scanpos = token;
5055: boolean retval = !jj_3_9();
5056: jj_save(8, xla);
5057: return retval;
5058: }
5059:
5060: final private boolean jj_2_10(int xla) {
5061: jj_la = xla;
5062: jj_lastpos = jj_scanpos = token;
5063: boolean retval = !jj_3_10();
5064: jj_save(9, xla);
5065: return retval;
5066: }
5067:
5068: final private boolean jj_2_11(int xla) {
5069: jj_la = xla;
5070: jj_lastpos = jj_scanpos = token;
5071: boolean retval = !jj_3_11();
5072: jj_save(10, xla);
5073: return retval;
5074: }
5075:
5076: final private boolean jj_2_12(int xla) {
5077: jj_la = xla;
5078: jj_lastpos = jj_scanpos = token;
5079: boolean retval = !jj_3_12();
5080: jj_save(11, xla);
5081: return retval;
5082: }
5083:
5084: final private boolean jj_2_13(int xla) {
5085: jj_la = xla;
5086: jj_lastpos = jj_scanpos = token;
5087: boolean retval = !jj_3_13();
5088: jj_save(12, xla);
5089: return retval;
5090: }
5091:
5092: final private boolean jj_2_14(int xla) {
5093: jj_la = xla;
5094: jj_lastpos = jj_scanpos = token;
5095: boolean retval = !jj_3_14();
5096: jj_save(13, xla);
5097: return retval;
5098: }
5099:
5100: final private boolean jj_2_15(int xla) {
5101: jj_la = xla;
5102: jj_lastpos = jj_scanpos = token;
5103: boolean retval = !jj_3_15();
5104: jj_save(14, xla);
5105: return retval;
5106: }
5107:
5108: final private boolean jj_2_16(int xla) {
5109: jj_la = xla;
5110: jj_lastpos = jj_scanpos = token;
5111: boolean retval = !jj_3_16();
5112: jj_save(15, xla);
5113: return retval;
5114: }
5115:
5116: final private boolean jj_2_17(int xla) {
5117: jj_la = xla;
5118: jj_lastpos = jj_scanpos = token;
5119: boolean retval = !jj_3_17();
5120: jj_save(16, xla);
5121: return retval;
5122: }
5123:
5124: final private boolean jj_3R_137() {
5125: Token xsp;
5126: xsp = jj_scanpos;
5127: if (jj_3R_138())
5128: jj_scanpos = xsp;
5129: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5130: return false;
5131: return false;
5132: }
5133:
5134: final private boolean jj_3R_36() {
5135: Token xsp;
5136: xsp = jj_scanpos;
5137: if (jj_3R_61()) {
5138: jj_scanpos = xsp;
5139: if (jj_3R_62())
5140: return true;
5141: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5142: return false;
5143: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5144: return false;
5145: return false;
5146: }
5147:
5148: final private boolean jj_3R_130() {
5149: if (jj_scan_token(PASSWORD))
5150: return true;
5151: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5152: return false;
5153: return false;
5154: }
5155:
5156: final private boolean jj_3R_120() {
5157: if (jj_scan_token(SOME))
5158: return true;
5159: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5160: return false;
5161: return false;
5162: }
5163:
5164: final private boolean jj_3R_55() {
5165: if (jj_scan_token(TRAILING))
5166: return true;
5167: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5168: return false;
5169: return false;
5170: }
5171:
5172: final private boolean jj_3R_20() {
5173: if (jj_3R_39())
5174: return true;
5175: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5176: return false;
5177: return false;
5178: }
5179:
5180: final private boolean jj_3R_136() {
5181: if (jj_scan_token(ACTION))
5182: return true;
5183: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5184: return false;
5185: return false;
5186: }
5187:
5188: final private boolean jj_3R_19() {
5189: if (jj_3R_38())
5190: return true;
5191: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5192: return false;
5193: return false;
5194: }
5195:
5196: final private boolean jj_3_11() {
5197: Token xsp;
5198: xsp = jj_scanpos;
5199: if (jj_3R_22()) {
5200: jj_scanpos = xsp;
5201: if (jj_3R_23()) {
5202: jj_scanpos = xsp;
5203: if (jj_3R_24())
5204: return true;
5205: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5206: return false;
5207: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5208: return false;
5209: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5210: return false;
5211: if (jj_3R_21())
5212: return true;
5213: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5214: return false;
5215: return false;
5216: }
5217:
5218: final private boolean jj_3R_122() {
5219: if (jj_3R_137())
5220: return true;
5221: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5222: return false;
5223: return false;
5224: }
5225:
5226: final private boolean jj_3R_90() {
5227: if (jj_scan_token(NOT))
5228: return true;
5229: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5230: return false;
5231: return false;
5232: }
5233:
5234: final private boolean jj_3R_18() {
5235: Token xsp;
5236: xsp = jj_scanpos;
5237: if (jj_3_11()) {
5238: jj_scanpos = xsp;
5239: if (jj_3R_36()) {
5240: jj_scanpos = xsp;
5241: if (jj_3_12()) {
5242: jj_scanpos = xsp;
5243: if (jj_3R_37())
5244: return true;
5245: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5246: return false;
5247: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5248: return false;
5249: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5250: return false;
5251: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5252: return false;
5253: return false;
5254: }
5255:
5256: final private boolean jj_3R_63() {
5257: Token xsp;
5258: xsp = jj_scanpos;
5259: if (jj_3R_90())
5260: jj_scanpos = xsp;
5261: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5262: return false;
5263: if (jj_scan_token(BETWEEN))
5264: return true;
5265: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5266: return false;
5267: if (jj_3R_91())
5268: return true;
5269: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5270: return false;
5271: return false;
5272: }
5273:
5274: final private boolean jj_3R_121() {
5275: if (jj_scan_token(STAR))
5276: return true;
5277: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5278: return false;
5279: return false;
5280: }
5281:
5282: final private boolean jj_3R_29() {
5283: if (jj_scan_token(NOT))
5284: return true;
5285: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5286: return false;
5287: if (jj_scan_token(IN))
5288: return true;
5289: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5290: return false;
5291: return false;
5292: }
5293:
5294: final private boolean jj_3R_119() {
5295: if (jj_scan_token(ALL))
5296: return true;
5297: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5298: return false;
5299: return false;
5300: }
5301:
5302: final private boolean jj_3R_28() {
5303: if (jj_scan_token(IN))
5304: return true;
5305: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5306: return false;
5307: return false;
5308: }
5309:
5310: final private boolean jj_3R_87() {
5311: Token xsp;
5312: xsp = jj_scanpos;
5313: if (jj_3R_121()) {
5314: jj_scanpos = xsp;
5315: if (jj_3R_122())
5316: return true;
5317: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5318: return false;
5319: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5320: return false;
5321: return false;
5322: }
5323:
5324: final private boolean jj_3R_54() {
5325: if (jj_scan_token(BOTH))
5326: return true;
5327: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5328: return false;
5329: return false;
5330: }
5331:
5332: final private boolean jj_3R_132() {
5333: if (jj_scan_token(GROUPS))
5334: return true;
5335: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5336: return false;
5337: return false;
5338: }
5339:
5340: final private boolean jj_3_9() {
5341: if (jj_3R_18())
5342: return true;
5343: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5344: return false;
5345: return false;
5346: }
5347:
5348: final private boolean jj_3R_135() {
5349: if (jj_scan_token(JAVA))
5350: return true;
5351: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5352: return false;
5353: return false;
5354: }
5355:
5356: final private boolean jj_3R_129() {
5357: if (jj_scan_token(ACCOUNT))
5358: return true;
5359: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5360: return false;
5361: return false;
5362: }
5363:
5364: final private boolean jj_3_10() {
5365: Token xsp;
5366: xsp = jj_scanpos;
5367: if (jj_3R_19()) {
5368: jj_scanpos = xsp;
5369: if (jj_3R_20())
5370: return true;
5371: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5372: return false;
5373: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5374: return false;
5375: if (jj_3R_21())
5376: return true;
5377: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5378: return false;
5379: return false;
5380: }
5381:
5382: final private boolean jj_3R_118() {
5383: if (jj_scan_token(ANY))
5384: return true;
5385: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5386: return false;
5387: return false;
5388: }
5389:
5390: final private boolean jj_3_6() {
5391: if (jj_3R_17())
5392: return true;
5393: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5394: return false;
5395: return false;
5396: }
5397:
5398: final private boolean jj_3R_85() {
5399: Token xsp;
5400: xsp = jj_scanpos;
5401: if (jj_3R_118()) {
5402: jj_scanpos = xsp;
5403: if (jj_3R_119()) {
5404: jj_scanpos = xsp;
5405: if (jj_3R_120())
5406: return true;
5407: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5408: return false;
5409: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5410: return false;
5411: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5412: return false;
5413: return false;
5414: }
5415:
5416: final private boolean jj_3R_48() {
5417: if (jj_3R_84())
5418: return true;
5419: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5420: return false;
5421: Token xsp;
5422: xsp = jj_scanpos;
5423: if (jj_3R_85())
5424: jj_scanpos = xsp;
5425: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5426: return false;
5427: return false;
5428: }
5429:
5430: final private boolean jj_3R_126() {
5431: if (jj_3R_21())
5432: return true;
5433: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5434: return false;
5435: return false;
5436: }
5437:
5438: final private boolean jj_3R_83() {
5439: if (jj_scan_token(DOT_DELIMINATED_REF))
5440: return true;
5441: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5442: return false;
5443: return false;
5444: }
5445:
5446: final private boolean jj_3_15() {
5447: Token xsp;
5448: xsp = jj_scanpos;
5449: if (jj_3R_28()) {
5450: jj_scanpos = xsp;
5451: if (jj_3R_29())
5452: return true;
5453: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5454: return false;
5455: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5456: return false;
5457: return false;
5458: }
5459:
5460: final private boolean jj_3R_30() {
5461: Token xsp;
5462: xsp = jj_scanpos;
5463: if (jj_3R_53()) {
5464: jj_scanpos = xsp;
5465: if (jj_3R_54()) {
5466: jj_scanpos = xsp;
5467: if (jj_3R_55())
5468: return true;
5469: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5470: return false;
5471: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5472: return false;
5473: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5474: return false;
5475: return false;
5476: }
5477:
5478: final private boolean jj_3R_53() {
5479: if (jj_scan_token(LEADING))
5480: return true;
5481: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5482: return false;
5483: return false;
5484: }
5485:
5486: final private boolean jj_3R_25() {
5487: Token xsp;
5488: xsp = jj_scanpos;
5489: if (jj_3_15()) {
5490: jj_scanpos = xsp;
5491: if (jj_3R_48())
5492: return true;
5493: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5494: return false;
5495: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5496: return false;
5497: return false;
5498: }
5499:
5500: final private boolean jj_3R_134() {
5501: if (jj_scan_token(NAME))
5502: return true;
5503: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5504: return false;
5505: return false;
5506: }
5507:
5508: final private boolean jj_3R_131() {
5509: if (jj_scan_token(PRIVILEGES))
5510: return true;
5511: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5512: return false;
5513: return false;
5514: }
5515:
5516: final private boolean jj_3R_117() {
5517: if (jj_scan_token(NOTEQ))
5518: return true;
5519: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5520: return false;
5521: return false;
5522: }
5523:
5524: final private boolean jj_3R_128() {
5525: if (jj_scan_token(OPTION))
5526: return true;
5527: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5528: return false;
5529: return false;
5530: }
5531:
5532: final private boolean jj_3R_82() {
5533: if (jj_3R_21())
5534: return true;
5535: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5536: return false;
5537: return false;
5538: }
5539:
5540: final private boolean jj_3R_127() {
5541: if (jj_scan_token(IDENTIFIER))
5542: return true;
5543: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5544: return false;
5545: return false;
5546: }
5547:
5548: final private boolean jj_3R_52() {
5549: if (jj_3R_89())
5550: return true;
5551: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5552: return false;
5553: if (jj_scan_token(208))
5554: return true;
5555: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5556: return false;
5557: if (jj_3R_87())
5558: return true;
5559: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5560: return false;
5561: if (jj_scan_token(209))
5562: return true;
5563: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5564: return false;
5565: return false;
5566: }
5567:
5568: final private boolean jj_3R_31() {
5569: if (jj_scan_token(STRING_LITERAL))
5570: return true;
5571: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5572: return false;
5573: return false;
5574: }
5575:
5576: final private boolean jj_3R_98() {
5577: Token xsp;
5578: xsp = jj_scanpos;
5579: if (jj_3R_127()) {
5580: jj_scanpos = xsp;
5581: if (jj_3R_128()) {
5582: jj_scanpos = xsp;
5583: if (jj_3R_129()) {
5584: jj_scanpos = xsp;
5585: if (jj_3R_130()) {
5586: jj_scanpos = xsp;
5587: if (jj_3R_131()) {
5588: jj_scanpos = xsp;
5589: if (jj_3R_132()) {
5590: jj_scanpos = xsp;
5591: if (jj_3R_133()) {
5592: jj_scanpos = xsp;
5593: if (jj_3R_134()) {
5594: jj_scanpos = xsp;
5595: if (jj_3R_135()) {
5596: jj_scanpos = xsp;
5597: if (jj_3R_136())
5598: return true;
5599: if (jj_la == 0
5600: && jj_scanpos == jj_lastpos)
5601: return false;
5602: } else if (jj_la == 0
5603: && jj_scanpos == jj_lastpos)
5604: return false;
5605: } else if (jj_la == 0
5606: && jj_scanpos == jj_lastpos)
5607: return false;
5608: } else if (jj_la == 0
5609: && jj_scanpos == jj_lastpos)
5610: return false;
5611: } else if (jj_la == 0
5612: && jj_scanpos == jj_lastpos)
5613: return false;
5614: } else if (jj_la == 0
5615: && jj_scanpos == jj_lastpos)
5616: return false;
5617: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5618: return false;
5619: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5620: return false;
5621: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5622: return false;
5623: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5624: return false;
5625: return false;
5626: }
5627:
5628: final private boolean jj_3_17() {
5629: Token xsp;
5630: xsp = jj_scanpos;
5631: if (jj_3R_30())
5632: jj_scanpos = xsp;
5633: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5634: return false;
5635: xsp = jj_scanpos;
5636: if (jj_3R_31())
5637: jj_scanpos = xsp;
5638: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5639: return false;
5640: if (jj_scan_token(FROM))
5641: return true;
5642: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5643: return false;
5644: return false;
5645: }
5646:
5647: final private boolean jj_3R_86() {
5648: if (jj_scan_token(DISTINCT))
5649: return true;
5650: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5651: return false;
5652: return false;
5653: }
5654:
5655: final private boolean jj_3R_116() {
5656: if (jj_scan_token(LEEQ))
5657: return true;
5658: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5659: return false;
5660: return false;
5661: }
5662:
5663: final private boolean jj_3R_51() {
5664: if (jj_scan_token(CAST))
5665: return true;
5666: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5667: return false;
5668: if (jj_scan_token(208))
5669: return true;
5670: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5671: return false;
5672: if (jj_3R_88())
5673: return true;
5674: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5675: return false;
5676: return false;
5677: }
5678:
5679: final private boolean jj_3R_91() {
5680: if (jj_3R_126())
5681: return true;
5682: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5683: return false;
5684: return false;
5685: }
5686:
5687: final private boolean jj_3R_125() {
5688: if (jj_scan_token(IDENTIFIER))
5689: return true;
5690: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5691: return false;
5692: return false;
5693: }
5694:
5695: final private boolean jj_3R_115() {
5696: if (jj_scan_token(GREQ))
5697: return true;
5698: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5699: return false;
5700: return false;
5701: }
5702:
5703: final private boolean jj_3R_104() {
5704: if (jj_scan_token(LEEQ))
5705: return true;
5706: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5707: return false;
5708: return false;
5709: }
5710:
5711: final private boolean jj_3R_50() {
5712: if (jj_scan_token(TRIM))
5713: return true;
5714: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5715: return false;
5716: if (jj_scan_token(208))
5717: return true;
5718: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5719: return false;
5720: Token xsp;
5721: xsp = jj_scanpos;
5722: if (jj_3_17())
5723: jj_scanpos = xsp;
5724: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5725: return false;
5726: if (jj_3R_88())
5727: return true;
5728: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5729: return false;
5730: return false;
5731: }
5732:
5733: final private boolean jj_3_5() {
5734: if (jj_scan_token(LONG))
5735: return true;
5736: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5737: return false;
5738: if (jj_scan_token(BINARY))
5739: return true;
5740: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5741: return false;
5742: if (jj_scan_token(VARYING))
5743: return true;
5744: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5745: return false;
5746: return false;
5747: }
5748:
5749: final private boolean jj_3_4() {
5750: if (jj_scan_token(BINARY))
5751: return true;
5752: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5753: return false;
5754: if (jj_scan_token(VARYING))
5755: return true;
5756: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5757: return false;
5758: return false;
5759: }
5760:
5761: final private boolean jj_3R_49() {
5762: if (jj_scan_token(COUNT))
5763: return true;
5764: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5765: return false;
5766: if (jj_scan_token(208))
5767: return true;
5768: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5769: return false;
5770: Token xsp;
5771: xsp = jj_scanpos;
5772: if (jj_3R_86())
5773: jj_scanpos = xsp;
5774: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5775: return false;
5776: if (jj_3R_87())
5777: return true;
5778: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5779: return false;
5780: if (jj_scan_token(209))
5781: return true;
5782: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5783: return false;
5784: return false;
5785: }
5786:
5787: final private boolean jj_3R_26() {
5788: if (jj_scan_token(208))
5789: return true;
5790: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5791: return false;
5792: return false;
5793: }
5794:
5795: final private boolean jj_3R_114() {
5796: if (jj_scan_token(LE))
5797: return true;
5798: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5799: return false;
5800: return false;
5801: }
5802:
5803: final private boolean jj_3R_124() {
5804: if (jj_scan_token(USER))
5805: return true;
5806: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5807: return false;
5808: return false;
5809: }
5810:
5811: final private boolean jj_3R_88() {
5812: if (jj_3R_82())
5813: return true;
5814: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5815: return false;
5816: return false;
5817: }
5818:
5819: final private boolean jj_3R_27() {
5820: Token xsp;
5821: xsp = jj_scanpos;
5822: if (jj_3R_49()) {
5823: jj_scanpos = xsp;
5824: if (jj_3R_50()) {
5825: jj_scanpos = xsp;
5826: if (jj_3R_51()) {
5827: jj_scanpos = xsp;
5828: if (jj_3R_52())
5829: return true;
5830: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5831: return false;
5832: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5833: return false;
5834: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5835: return false;
5836: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5837: return false;
5838: return false;
5839: }
5840:
5841: final private boolean jj_3R_106() {
5842: if (jj_scan_token(IS))
5843: return true;
5844: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5845: return false;
5846: return false;
5847: }
5848:
5849: final private boolean jj_3R_103() {
5850: if (jj_scan_token(GREQ))
5851: return true;
5852: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5853: return false;
5854: return false;
5855: }
5856:
5857: final private boolean jj_3R_94() {
5858: if (jj_scan_token(SUBTRACT))
5859: return true;
5860: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5861: return false;
5862: return false;
5863: }
5864:
5865: final private boolean jj_3R_113() {
5866: if (jj_scan_token(GR))
5867: return true;
5868: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5869: return false;
5870: return false;
5871: }
5872:
5873: final private boolean jj_3R_123() {
5874: if (jj_scan_token(IF))
5875: return true;
5876: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5877: return false;
5878: return false;
5879: }
5880:
5881: final private boolean jj_3R_58() {
5882: if (jj_scan_token(LONGVARCHAR))
5883: return true;
5884: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5885: return false;
5886: return false;
5887: }
5888:
5889: final private boolean jj_3R_102() {
5890: if (jj_scan_token(LE))
5891: return true;
5892: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5893: return false;
5894: return false;
5895: }
5896:
5897: final private boolean jj_3R_89() {
5898: Token xsp;
5899: xsp = jj_scanpos;
5900: if (jj_3R_123()) {
5901: jj_scanpos = xsp;
5902: if (jj_3R_124()) {
5903: jj_scanpos = xsp;
5904: if (jj_3R_125())
5905: return true;
5906: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5907: return false;
5908: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5909: return false;
5910: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
5911: return false;
5912: return false;
5913: }
5914:
5915: final private boolean jj_3R_93() {
5916: if (jj_scan_token(ADD))
5917: return true;
5918: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5919: return false;
5920: return false;
5921: }
5922:
5923: final private boolean jj_3R_112() {
5924: if (jj_scan_token(EQUALS))
5925: return true;
5926: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5927: return false;
5928: return false;
5929: }
5930:
5931: final private boolean jj_3R_101() {
5932: if (jj_scan_token(GR))
5933: return true;
5934: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5935: return false;
5936: return false;
5937: }
5938:
5939: final private boolean jj_3R_60() {
5940: if (jj_scan_token(CHARACTER))
5941: return true;
5942: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5943: return false;
5944: return false;
5945: }
5946:
5947: final private boolean jj_3R_97() {
5948: if (jj_scan_token(SUBTRACT))
5949: return true;
5950: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5951: return false;
5952: return false;
5953: }
5954:
5955: final private boolean jj_3R_80() {
5956: if (jj_3R_98())
5957: return true;
5958: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5959: return false;
5960: return false;
5961: }
5962:
5963: final private boolean jj_3R_57() {
5964: if (jj_scan_token(STRING))
5965: return true;
5966: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5967: return false;
5968: return false;
5969: }
5970:
5971: final private boolean jj_3R_64() {
5972: if (jj_scan_token(CONCAT))
5973: return true;
5974: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5975: return false;
5976: return false;
5977: }
5978:
5979: final private boolean jj_3R_79() {
5980: if (jj_scan_token(QUOTED_DELIMINATED_REF))
5981: return true;
5982: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5983: return false;
5984: return false;
5985: }
5986:
5987: final private boolean jj_3R_78() {
5988: if (jj_scan_token(DOT_DELIMINATED_REF))
5989: return true;
5990: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5991: return false;
5992: return false;
5993: }
5994:
5995: final private boolean jj_3R_77() {
5996: if (jj_scan_token(QUOTED_VARIABLE))
5997: return true;
5998: if (jj_la == 0 && jj_scanpos == jj_lastpos)
5999: return false;
6000: return false;
6001: }
6002:
6003: final private boolean jj_3R_76() {
6004: if (jj_scan_token(NUMBER_LITERAL))
6005: return true;
6006: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6007: return false;
6008: return false;
6009: }
6010:
6011: final private boolean jj_3R_95() {
6012: if (jj_scan_token(STAR))
6013: return true;
6014: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6015: return false;
6016: return false;
6017: }
6018:
6019: final private boolean jj_3R_92() {
6020: if (jj_scan_token(DIVIDE))
6021: return true;
6022: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6023: return false;
6024: return false;
6025: }
6026:
6027: final private boolean jj_3R_96() {
6028: if (jj_scan_token(ADD))
6029: return true;
6030: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6031: return false;
6032: return false;
6033: }
6034:
6035: final private boolean jj_3R_75() {
6036: Token xsp;
6037: xsp = jj_scanpos;
6038: if (jj_3R_96()) {
6039: jj_scanpos = xsp;
6040: if (jj_3R_97())
6041: return true;
6042: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6043: return false;
6044: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6045: return false;
6046: return false;
6047: }
6048:
6049: final private boolean jj_3R_35() {
6050: if (jj_scan_token(CLOB))
6051: return true;
6052: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6053: return false;
6054: return false;
6055: }
6056:
6057: final private boolean jj_3R_59() {
6058: if (jj_scan_token(CHAR))
6059: return true;
6060: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6061: return false;
6062: return false;
6063: }
6064:
6065: final private boolean jj_3R_34() {
6066: if (jj_scan_token(VARCHAR))
6067: return true;
6068: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6069: return false;
6070: return false;
6071: }
6072:
6073: final private boolean jj_3R_56() {
6074: if (jj_scan_token(TEXT))
6075: return true;
6076: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6077: return false;
6078: return false;
6079: }
6080:
6081: final private boolean jj_3R_33() {
6082: Token xsp;
6083: xsp = jj_scanpos;
6084: if (jj_3R_59()) {
6085: jj_scanpos = xsp;
6086: if (jj_3R_60())
6087: return true;
6088: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6089: return false;
6090: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6091: return false;
6092: return false;
6093: }
6094:
6095: final private boolean jj_3R_65() {
6096: Token xsp;
6097: xsp = jj_scanpos;
6098: if (jj_3R_92()) {
6099: jj_scanpos = xsp;
6100: if (jj_3R_93()) {
6101: jj_scanpos = xsp;
6102: if (jj_3R_94()) {
6103: jj_scanpos = xsp;
6104: if (jj_3R_95())
6105: return true;
6106: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6107: return false;
6108: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6109: return false;
6110: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6111: return false;
6112: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6113: return false;
6114: return false;
6115: }
6116:
6117: final private boolean jj_3R_32() {
6118: Token xsp;
6119: xsp = jj_scanpos;
6120: if (jj_3R_56()) {
6121: jj_scanpos = xsp;
6122: if (jj_3R_57()) {
6123: jj_scanpos = xsp;
6124: if (jj_3R_58())
6125: return true;
6126: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6127: return false;
6128: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6129: return false;
6130: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6131: return false;
6132: return false;
6133: }
6134:
6135: final private boolean jj_3R_100() {
6136: if (jj_scan_token(EQUALS))
6137: return true;
6138: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6139: return false;
6140: return false;
6141: }
6142:
6143: final private boolean jj_3R_46() {
6144: Token xsp;
6145: xsp = jj_scanpos;
6146: if (jj_3R_75())
6147: jj_scanpos = xsp;
6148: else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6149: return false;
6150: xsp = jj_scanpos;
6151: if (jj_3R_76()) {
6152: jj_scanpos = xsp;
6153: if (jj_3R_77()) {
6154: jj_scanpos = xsp;
6155: if (jj_3R_78()) {
6156: jj_scanpos = xsp;
6157: if (jj_3R_79()) {
6158: jj_scanpos = xsp;
6159: if (jj_3R_80())
6160: return true;
6161: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6162: return false;
6163: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6164: return false;
6165: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6166: return false;
6167: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6168: return false;
6169: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6170: return false;
6171: return false;
6172: }
6173:
6174: final private boolean jj_3_3() {
6175: if (jj_scan_token(LONG))
6176: return true;
6177: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6178: return false;
6179: if (jj_scan_token(CHARACTER))
6180: return true;
6181: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6182: return false;
6183: if (jj_scan_token(VARYING))
6184: return true;
6185: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6186: return false;
6187: return false;
6188: }
6189:
6190: final private boolean jj_3R_17() {
6191: Token xsp;
6192: xsp = jj_scanpos;
6193: if (jj_3_2()) {
6194: jj_scanpos = xsp;
6195: if (jj_3_3()) {
6196: jj_scanpos = xsp;
6197: if (jj_3R_32()) {
6198: jj_scanpos = xsp;
6199: if (jj_3R_33()) {
6200: jj_scanpos = xsp;
6201: if (jj_3R_34()) {
6202: jj_scanpos = xsp;
6203: if (jj_3R_35())
6204: return true;
6205: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6206: return false;
6207: } else if (jj_la == 0
6208: && jj_scanpos == jj_lastpos)
6209: return false;
6210: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6211: return false;
6212: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6213: return false;
6214: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6215: return false;
6216: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6217: return false;
6218: return false;
6219: }
6220:
6221: final private boolean jj_3_2() {
6222: if (jj_scan_token(CHARACTER))
6223: return true;
6224: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6225: return false;
6226: if (jj_scan_token(VARYING))
6227: return true;
6228: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6229: return false;
6230: return false;
6231: }
6232:
6233: final private boolean jj_3R_74() {
6234: if (jj_scan_token(NULL_LITERAL))
6235: return true;
6236: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6237: return false;
6238: return false;
6239: }
6240:
6241: final private boolean jj_3R_110() {
6242: if (jj_scan_token(OR))
6243: return true;
6244: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6245: return false;
6246: return false;
6247: }
6248:
6249: final private boolean jj_3R_108() {
6250: if (jj_scan_token(NOT))
6251: return true;
6252: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6253: return false;
6254: if (jj_scan_token(LIKE))
6255: return true;
6256: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6257: return false;
6258: return false;
6259: }
6260:
6261: final private boolean jj_3R_73() {
6262: if (jj_scan_token(BOOLEAN_LITERAL))
6263: return true;
6264: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6265: return false;
6266: return false;
6267: }
6268:
6269: final private boolean jj_3R_111() {
6270: if (jj_scan_token(ASSIGNMENT))
6271: return true;
6272: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6273: return false;
6274: return false;
6275: }
6276:
6277: final private boolean jj_3R_72() {
6278: if (jj_scan_token(STRING_LITERAL))
6279: return true;
6280: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6281: return false;
6282: return false;
6283: }
6284:
6285: final private boolean jj_3R_84() {
6286: Token xsp;
6287: xsp = jj_scanpos;
6288: if (jj_3R_111()) {
6289: jj_scanpos = xsp;
6290: if (jj_3R_112()) {
6291: jj_scanpos = xsp;
6292: if (jj_3R_113()) {
6293: jj_scanpos = xsp;
6294: if (jj_3R_114()) {
6295: jj_scanpos = xsp;
6296: if (jj_3R_115()) {
6297: jj_scanpos = xsp;
6298: if (jj_3R_116()) {
6299: jj_scanpos = xsp;
6300: if (jj_3R_117())
6301: return true;
6302: if (jj_la == 0
6303: && jj_scanpos == jj_lastpos)
6304: return false;
6305: } else if (jj_la == 0
6306: && jj_scanpos == jj_lastpos)
6307: return false;
6308: } else if (jj_la == 0
6309: && jj_scanpos == jj_lastpos)
6310: return false;
6311: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6312: return false;
6313: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6314: return false;
6315: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6316: return false;
6317: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6318: return false;
6319: return false;
6320: }
6321:
6322: final private boolean jj_3R_45() {
6323: Token xsp;
6324: xsp = jj_scanpos;
6325: if (jj_3R_72()) {
6326: jj_scanpos = xsp;
6327: if (jj_3R_73()) {
6328: jj_scanpos = xsp;
6329: if (jj_3R_74())
6330: return true;
6331: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6332: return false;
6333: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6334: return false;
6335: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6336: return false;
6337: return false;
6338: }
6339:
6340: final private boolean jj_3R_44() {
6341: if (jj_scan_token(NEW))
6342: return true;
6343: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6344: return false;
6345: if (jj_3R_83())
6346: return true;
6347: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6348: return false;
6349: return false;
6350: }
6351:
6352: final private boolean jj_3R_109() {
6353: if (jj_scan_token(AND))
6354: return true;
6355: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6356: return false;
6357: return false;
6358: }
6359:
6360: final private boolean jj_3R_107() {
6361: if (jj_scan_token(LIKE))
6362: return true;
6363: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6364: return false;
6365: return false;
6366: }
6367:
6368: final private boolean jj_3_16() {
6369: if (jj_scan_token(IS))
6370: return true;
6371: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6372: return false;
6373: if (jj_scan_token(NOT))
6374: return true;
6375: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6376: return false;
6377: return false;
6378: }
6379:
6380: final private boolean jj_3R_105() {
6381: if (jj_scan_token(NOTEQ))
6382: return true;
6383: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6384: return false;
6385: return false;
6386: }
6387:
6388: final private boolean jj_3R_99() {
6389: if (jj_scan_token(ASSIGNMENT))
6390: return true;
6391: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6392: return false;
6393: return false;
6394: }
6395:
6396: final private boolean jj_3R_71() {
6397: if (jj_scan_token(CURRENT_DATE))
6398: return true;
6399: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6400: return false;
6401: return false;
6402: }
6403:
6404: final private boolean jj_3R_81() {
6405: Token xsp;
6406: xsp = jj_scanpos;
6407: if (jj_3R_99()) {
6408: jj_scanpos = xsp;
6409: if (jj_3R_100()) {
6410: jj_scanpos = xsp;
6411: if (jj_3R_101()) {
6412: jj_scanpos = xsp;
6413: if (jj_3R_102()) {
6414: jj_scanpos = xsp;
6415: if (jj_3R_103()) {
6416: jj_scanpos = xsp;
6417: if (jj_3R_104()) {
6418: jj_scanpos = xsp;
6419: if (jj_3R_105()) {
6420: jj_scanpos = xsp;
6421: if (jj_3_16()) {
6422: jj_scanpos = xsp;
6423: if (jj_3R_106()) {
6424: jj_scanpos = xsp;
6425: if (jj_3R_107()) {
6426: jj_scanpos = xsp;
6427: if (jj_3R_108()) {
6428: jj_scanpos = xsp;
6429: if (jj_3R_109()) {
6430: jj_scanpos = xsp;
6431: if (jj_3R_110())
6432: return true;
6433: if (jj_la == 0
6434: && jj_scanpos == jj_lastpos)
6435: return false;
6436: } else if (jj_la == 0
6437: && jj_scanpos == jj_lastpos)
6438: return false;
6439: } else if (jj_la == 0
6440: && jj_scanpos == jj_lastpos)
6441: return false;
6442: } else if (jj_la == 0
6443: && jj_scanpos == jj_lastpos)
6444: return false;
6445: } else if (jj_la == 0
6446: && jj_scanpos == jj_lastpos)
6447: return false;
6448: } else if (jj_la == 0
6449: && jj_scanpos == jj_lastpos)
6450: return false;
6451: } else if (jj_la == 0
6452: && jj_scanpos == jj_lastpos)
6453: return false;
6454: } else if (jj_la == 0
6455: && jj_scanpos == jj_lastpos)
6456: return false;
6457: } else if (jj_la == 0
6458: && jj_scanpos == jj_lastpos)
6459: return false;
6460: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6461: return false;
6462: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6463: return false;
6464: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6465: return false;
6466: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6467: return false;
6468: return false;
6469: }
6470:
6471: final private boolean jj_3R_70() {
6472: if (jj_scan_token(CURRENT_TIME))
6473: return true;
6474: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6475: return false;
6476: return false;
6477: }
6478:
6479: final private boolean jj_3R_69() {
6480: if (jj_scan_token(CURRENT_TIMESTAMP))
6481: return true;
6482: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6483: return false;
6484: return false;
6485: }
6486:
6487: final private boolean jj_3R_43() {
6488: Token xsp;
6489: xsp = jj_scanpos;
6490: if (jj_3R_69()) {
6491: jj_scanpos = xsp;
6492: if (jj_3R_70()) {
6493: jj_scanpos = xsp;
6494: if (jj_3R_71())
6495: return true;
6496: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6497: return false;
6498: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6499: return false;
6500: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6501: return false;
6502: return false;
6503: }
6504:
6505: final private boolean jj_3R_38() {
6506: if (jj_3R_64())
6507: return true;
6508: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6509: return false;
6510: return false;
6511: }
6512:
6513: final private boolean jj_3R_68() {
6514: if (jj_scan_token(TIMESTAMP))
6515: return true;
6516: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6517: return false;
6518: return false;
6519: }
6520:
6521: final private boolean jj_3R_67() {
6522: if (jj_scan_token(TIME))
6523: return true;
6524: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6525: return false;
6526: return false;
6527: }
6528:
6529: final private boolean jj_3R_66() {
6530: if (jj_scan_token(DATE))
6531: return true;
6532: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6533: return false;
6534: return false;
6535: }
6536:
6537: final private boolean jj_3R_42() {
6538: Token xsp;
6539: xsp = jj_scanpos;
6540: if (jj_3R_66()) {
6541: jj_scanpos = xsp;
6542: if (jj_3R_67()) {
6543: jj_scanpos = xsp;
6544: if (jj_3R_68())
6545: return true;
6546: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6547: return false;
6548: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6549: return false;
6550: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6551: return false;
6552: if (jj_scan_token(STRING_LITERAL))
6553: return true;
6554: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6555: return false;
6556: return false;
6557: }
6558:
6559: final private boolean jj_3_8() {
6560: if (jj_scan_token(SET))
6561: return true;
6562: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6563: return false;
6564: if (jj_scan_token(NULL_LITERAL))
6565: return true;
6566: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6567: return false;
6568: return false;
6569: }
6570:
6571: final private boolean jj_3_14() {
6572: if (jj_3R_27())
6573: return true;
6574: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6575: return false;
6576: return false;
6577: }
6578:
6579: final private boolean jj_3R_39() {
6580: if (jj_3R_65())
6581: return true;
6582: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6583: return false;
6584: return false;
6585: }
6586:
6587: final private boolean jj_3_13() {
6588: if (jj_scan_token(NOT))
6589: return true;
6590: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6591: return false;
6592: if (jj_3R_21())
6593: return true;
6594: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6595: return false;
6596: return false;
6597: }
6598:
6599: final private boolean jj_3_1() {
6600: if (jj_scan_token(SET))
6601: return true;
6602: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6603: return false;
6604: if (jj_scan_token(GROUPS))
6605: return true;
6606: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6607: return false;
6608: return false;
6609: }
6610:
6611: final private boolean jj_3R_41() {
6612: if (jj_scan_token(PARAMETER_REF))
6613: return true;
6614: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6615: return false;
6616: return false;
6617: }
6618:
6619: final private boolean jj_3R_40() {
6620: if (jj_scan_token(208))
6621: return true;
6622: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6623: return false;
6624: if (jj_3R_82())
6625: return true;
6626: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6627: return false;
6628: return false;
6629: }
6630:
6631: final private boolean jj_3R_21() {
6632: Token xsp;
6633: xsp = jj_scanpos;
6634: if (jj_3R_40()) {
6635: jj_scanpos = xsp;
6636: if (jj_3R_41()) {
6637: jj_scanpos = xsp;
6638: if (jj_3_13()) {
6639: jj_scanpos = xsp;
6640: if (jj_3_14()) {
6641: jj_scanpos = xsp;
6642: if (jj_3R_42()) {
6643: jj_scanpos = xsp;
6644: if (jj_3R_43()) {
6645: jj_scanpos = xsp;
6646: if (jj_3R_44()) {
6647: jj_scanpos = xsp;
6648: if (jj_3R_45()) {
6649: jj_scanpos = xsp;
6650: if (jj_3R_46())
6651: return true;
6652: if (jj_la == 0
6653: && jj_scanpos == jj_lastpos)
6654: return false;
6655: } else if (jj_la == 0
6656: && jj_scanpos == jj_lastpos)
6657: return false;
6658: } else if (jj_la == 0
6659: && jj_scanpos == jj_lastpos)
6660: return false;
6661: } else if (jj_la == 0
6662: && jj_scanpos == jj_lastpos)
6663: return false;
6664: } else if (jj_la == 0
6665: && jj_scanpos == jj_lastpos)
6666: return false;
6667: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6668: return false;
6669: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6670: return false;
6671: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6672: return false;
6673: } else if (jj_la == 0 && jj_scanpos == jj_lastpos)
6674: return false;
6675: return false;
6676: }
6677:
6678: final private boolean jj_3R_47() {
6679: if (jj_3R_81())
6680: return true;
6681: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6682: return false;
6683: return false;
6684: }
6685:
6686: final private boolean jj_3_7() {
6687: if (jj_scan_token(ON))
6688: return true;
6689: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6690: return false;
6691: if (jj_scan_token(DELETE))
6692: return true;
6693: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6694: return false;
6695: return false;
6696: }
6697:
6698: final private boolean jj_3R_62() {
6699: if (jj_scan_token(REGEX_LITERAL))
6700: return true;
6701: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6702: return false;
6703: return false;
6704: }
6705:
6706: final private boolean jj_3R_37() {
6707: if (jj_3R_63())
6708: return true;
6709: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6710: return false;
6711: return false;
6712: }
6713:
6714: final private boolean jj_3R_24() {
6715: if (jj_3R_38())
6716: return true;
6717: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6718: return false;
6719: return false;
6720: }
6721:
6722: final private boolean jj_3_12() {
6723: if (jj_3R_25())
6724: return true;
6725: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6726: return false;
6727: if (jj_3R_26())
6728: return true;
6729: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6730: return false;
6731: return false;
6732: }
6733:
6734: final private boolean jj_3R_23() {
6735: if (jj_3R_39())
6736: return true;
6737: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6738: return false;
6739: return false;
6740: }
6741:
6742: final private boolean jj_3R_22() {
6743: if (jj_3R_47())
6744: return true;
6745: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6746: return false;
6747: return false;
6748: }
6749:
6750: final private boolean jj_3R_61() {
6751: if (jj_scan_token(REGEX))
6752: return true;
6753: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6754: return false;
6755: if (jj_3R_82())
6756: return true;
6757: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6758: return false;
6759: return false;
6760: }
6761:
6762: final private boolean jj_3R_138() {
6763: if (jj_3R_88())
6764: return true;
6765: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6766: return false;
6767: return false;
6768: }
6769:
6770: final private boolean jj_3R_133() {
6771: if (jj_scan_token(LANGUAGE))
6772: return true;
6773: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6774: return false;
6775: return false;
6776: }
6777:
6778: public SQLTokenManager token_source;
6779: SimpleCharStream jj_input_stream;
6780: public Token token, jj_nt;
6781: private int jj_ntk;
6782: private Token jj_scanpos, jj_lastpos;
6783: private int jj_la;
6784: public boolean lookingAhead = false;
6785: private boolean jj_semLA;
6786: private int jj_gen;
6787: final private int[] jj_la1 = new int[189];
6788: final private int[] jj_la1_0 = { 0xffc00000, 0x1, 0x0, 0x0, 0x0,
6789: 0x0, 0x0, 0x8000000, 0x8000000, 0x0, 0x0, 0x0, 0x0, 0x0,
6790: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6791: 0x0, 0x0, 0x0, 0x0, 0x0, 0x2000000, 0x2000000, 0x0, 0x0,
6792: 0x0, 0x0, 0x0, 0x40000000, 0x0, 0x0, 0x34000000, 0x0, 0x0,
6793: 0x0, 0x0, 0x0, 0x0, 0x36000000, 0x0, 0x0, 0x0, 0x0, 0x0,
6794: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x400000, 0x0, 0x0,
6795: 0x1400000, 0x1b0000, 0x0, 0x1b0000, 0x0, 0x0, 0x0, 0x0,
6796: 0x0, 0x1b0080, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6797: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6798: 0x0, 0x0, 0x0, 0x0, 0x100000, 0x0, 0x0, 0x100000, 0x0, 0x0,
6799: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6800: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6801: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6802: 0x0, 0x0, 0x78080, 0x7ff80, 0x200000, 0x200000, 0x0, 0x0,
6803: 0x0, 0x180000, 0x30000, 0x30000, 0x0, 0x0, 0x1b0000,
6804: 0x2000000, 0x0, 0x0, 0x0, 0x7f00, 0x0, 0x7f00, 0x0, 0x7f00,
6805: 0x38080, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x1b0000,
6806: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6807: 0x0, 0x0, 0x0, };
6808: final private int[] jj_la1_1 = { 0x40201a, 0x0, 0x80000000,
6809: 0x80000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100, 0x0, 0x0,
6810: 0x0, 0x0, 0x0, 0x0, 0x100, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6811: 0x0, 0x0, 0x2000, 0x0, 0x0, 0x10000000, 0x0, 0x0, 0x2000,
6812: 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x80, 0x0, 0x0, 0x0, 0x0,
6813: 0x0, 0x30000, 0x0, 0x0, 0x800, 0x800, 0x2000000, 0x0, 0x0,
6814: 0x0, 0x0, 0x800, 0x0, 0x0, 0x0, 0x0, 0x2000, 0x0, 0x0,
6815: 0x40000, 0x40020100, 0x0, 0x40020100, 0x0, 0x800, 0x0,
6816: 0x40, 0x0, 0x40020100, 0x0, 0x8008000, 0x0, 0x8008000,
6817: 0x8008000, 0x30000, 0x40, 0x30040, 0x24000000, 0x30000,
6818: 0x0, 0x24000000, 0x0, 0x24000000, 0x0, 0x24000000,
6819: 0x24000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6820: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6821: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6822: 0x0, 0x0, 0x80, 0x80, 0x80, 0x80, 0x0, 0x0, 0x400, 0x2000,
6823: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20,
6824: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20000,
6825: 0x0, 0x0, 0x1001800, 0x1001800, 0x0, 0x0, 0x0, 0x20, 0x0,
6826: 0x0, 0x100, 0x0, 0x800000, 0x800000, 0x0, 0x40000100, 0x0,
6827: 0x0, 0x40020100, 0x0, 0x30000, 0x0, 0x0, 0x0, 0x0, 0x0,
6828: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
6829: final private int[] jj_la1_2 = { 0x40800000, 0x0, 0x24004, 0x24004,
6830: 0x0, 0x400, 0x8000, 0x4004, 0x4000, 0x0, 0x0, 0x100000,
6831: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x100,
6832: 0x1000, 0x800, 0x8000001, 0x0, 0x400, 0x8000, 0x0, 0x0,
6833: 0x0, 0x0, 0x0, 0x0, 0x400, 0x2, 0x800000, 0x0, 0x0, 0x0,
6834: 0x0, 0x4000080, 0x0, 0x4000, 0xb0004060, 0x0, 0x0,
6835: 0x1000000, 0x0, 0x0, 0x400, 0x0, 0x0, 0x0, 0x0, 0x400000,
6836: 0x0, 0xb0100060, 0x0, 0x0, 0x0, 0xb0000060, 0x0,
6837: 0xb000026c, 0x0, 0xb000026c, 0x0, 0x0, 0x0, 0x0,
6838: 0xb0000060, 0xb000026c, 0x0, 0x0, 0x0, 0x0, 0x0,
6839: 0xb0000060, 0x0, 0xb0000060, 0x12000, 0xb0000060, 0x10000,
6840: 0x12000, 0x80000, 0x12000, 0x80000, 0x12000, 0x12000,
6841: 0xb0000060, 0x0, 0xb0000060, 0xb0000070, 0x0, 0x0,
6842: 0xb0100060, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6843: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6844: 0x0, 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6845: 0x100000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6846: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6847: 0xb0000060, 0x0, 0xb0000060, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6848: 0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0, 0x0, 0x0, 0x20c, 0x0,
6849: 0x0, 0xb000026c, 0x400000, 0xb0000060, 0xb0000060,
6850: 0xb0000060, 0xb0000060, 0x0, 0xb0000060, 0xb0000060,
6851: 0xb0000060, 0xb0000060, 0xb0000060, 0xb0000060, 0xb0000060,
6852: 0xb0000060, 0xb0000060, };
6853: final private int[] jj_la1_3 = { 0x0, 0x0, 0x644088, 0x644008,
6854: 0x8000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x44000,
6855: 0x44000, 0x200, 0x0, 0x80, 0x0, 0x0, 0x80000000, 0x80000,
6856: 0x100000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6857: 0x20, 0x20, 0x8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x0,
6858: 0x0, 0x0, 0x0, 0x41000408, 0x0, 0x0, 0x0, 0x20000000, 0x0,
6859: 0x0, 0x0, 0x40, 0x4000000, 0x0, 0x2, 0x100, 0x41000580,
6860: 0x100, 0x0, 0x100, 0x41000500, 0x0, 0x41008400, 0x0,
6861: 0x41008400, 0x0, 0x20000000, 0x0, 0x0, 0x41000400,
6862: 0x41000400, 0x0, 0x0, 0x0, 0x0, 0x0, 0x41000400, 0x0,
6863: 0x41000400, 0x0, 0x41000400, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6864: 0x0, 0x41000400, 0x0, 0x41000400, 0x41000400, 0x0, 0x0,
6865: 0x41000480, 0x8000, 0x80, 0x0, 0x0, 0x80, 0x0, 0x0, 0x0,
6866: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6867: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6868: 0x80, 0x0, 0x800000, 0x0, 0x10000000, 0x0, 0x0, 0x0,
6869: 0x10000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2000,
6870: 0x0, 0x0, 0x0, 0x0, 0x0, 0x41000400, 0x0, 0x41000400, 0x0,
6871: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6872: 0x20000000, 0x2000800, 0x2000800, 0x0, 0x0, 0x0, 0x0,
6873: 0x41000400, 0x2, 0x41000400, 0x41000400, 0x41000400,
6874: 0x41000400, 0x1, 0x41000400, 0x41000400, 0x41000400,
6875: 0x41000400, 0x41000400, 0x41000400, 0x41000400, 0x41000400,
6876: 0x41000400, };
6877: final private int[] jj_la1_4 = { 0x0, 0x0, 0x10, 0x0, 0x0, 0x0,
6878: 0x0, 0x0, 0x0, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6879: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6880: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6881: 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x40, 0x200, 0x0, 0x0, 0x0,
6882: 0x8000, 0x0, 0x0, 0x0, 0x20, 0x0, 0xcc0, 0x0, 0x0, 0x0,
6883: 0x4c0, 0x0, 0x80000040, 0x0, 0x80000040, 0x0, 0x0, 0x0,
6884: 0x0, 0x40, 0x80000040, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0,
6885: 0x40, 0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40,
6886: 0x0, 0x40, 0xff000042, 0x0, 0x0, 0xcc0, 0x0, 0x400, 0x6000,
6887: 0x6000, 0x400, 0x1e0000, 0xe00000, 0x40000000, 0x20000002,
6888: 0x68000002, 0x2000000, 0x6000000, 0x1000000, 0x80000000,
6889: 0x10000000, 0x0, 0x0, 0x0, 0x1e0000, 0xe00000, 0x10000,
6890: 0x0, 0x0, 0x0, 0x0, 0x97000000, 0x80, 0x0, 0x0, 0x0, 0x0,
6891: 0x0, 0xc00, 0x108, 0x0, 0x0, 0x4, 0x100, 0x100, 0x100, 0x4,
6892: 0x8, 0x108, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80000000,
6893: 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x80000040, 0x0, 0x0, 0x0,
6894: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6895: 0x0, 0x0, 0x0, 0x80000040, 0x20, 0x40, 0x40, 0x40, 0x40,
6896: 0x0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, };
6897: final private int[] jj_la1_5 = { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6898: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6899: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6900: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc0000, 0x0,
6901: 0x0, 0x80000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6902: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6903: 0xe004001, 0x0, 0xe004001, 0x0, 0x0, 0x0, 0x0, 0x0,
6904: 0xe004001, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6905: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6906: 0x3ffff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6907: 0x10010, 0x0, 0x10810, 0x400, 0x16ce, 0x100, 0x4001,
6908: 0x22020, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6909: 0x8000, 0x277ef, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6910: 0x1000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6911: 0x0, 0x0, 0xd0000000, 0x20000000, 0x20000000, 0x0, 0x4001,
6912: 0xe000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe004001, 0x0, 0x0,
6913: 0x0, 0x0, 0x0, 0x0, 0x0, 0xd0000000, 0x0, 0x0, 0x0, 0x0,
6914: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xe004001, 0x0, 0x0, 0x0,
6915: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, };
6916: final private int[] jj_la1_6 = { 0x0, 0x8000, 0x0, 0x0, 0x0, 0x0,
6917: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10000, 0x0,
6918: 0x0, 0x40000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6919: 0x0, 0x0, 0x10000, 0x0, 0x10000, 0x20, 0x10000, 0x0, 0x0,
6920: 0x0, 0x0, 0x20, 0x20, 0x0, 0x0, 0x0, 0x0, 0xf0, 0x40000,
6921: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6922: 0xf0, 0x0, 0x0, 0x0, 0xf0, 0x0, 0x110fe, 0x40000, 0x110fe,
6923: 0x40000, 0x0, 0x40000, 0x0, 0x30, 0x11cfe, 0x40000, 0x0,
6924: 0x40000, 0x0, 0x0, 0x100f0, 0x0, 0xf0, 0x40000, 0x100f0,
6925: 0x0, 0x40000, 0x0, 0x40000, 0x0, 0x40000, 0x40000, 0x30,
6926: 0x40000, 0x30, 0x30, 0x40000, 0x40000, 0xf0, 0x0, 0x2, 0x0,
6927: 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6928: 0x140, 0x10000, 0x10000, 0x0, 0x0, 0x0, 0x40000, 0x10000,
6929: 0x10000, 0x0, 0x0, 0x0, 0x10000, 0x0, 0x0, 0x0, 0x0, 0x0,
6930: 0x2, 0x0, 0x0, 0x0, 0x2, 0x2, 0x2, 0x0, 0x0, 0x2, 0x40000,
6931: 0x40000, 0x0, 0x2, 0x0, 0x0, 0x2, 0x0, 0x0, 0x8, 0x0, 0x0,
6932: 0xf4, 0x11000, 0xfc, 0x0, 0x3, 0x0, 0x0, 0x0, 0x2, 0x0,
6933: 0x2, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x8, 0x20, 0x0,
6934: 0x40000, 0x110fe, 0x0, 0xf0, 0xf0, 0x30, 0x30, 0x30, 0x30,
6935: 0x30, 0xf0, 0xf0, 0x30, 0xf0, 0xf0, 0x30, 0x20, };
6936: final private JJCalls[] jj_2_rtns = new JJCalls[17];
6937: private boolean jj_rescan = false;
6938: private int jj_gc = 0;
6939:
6940: public SQL(java.io.InputStream stream) {
6941: jj_input_stream = new SimpleCharStream(stream, 1, 1);
6942: token_source = new SQLTokenManager(jj_input_stream);
6943: token = new Token();
6944: jj_ntk = -1;
6945: jj_gen = 0;
6946: for (int i = 0; i < 189; i++)
6947: jj_la1[i] = -1;
6948: for (int i = 0; i < jj_2_rtns.length; i++)
6949: jj_2_rtns[i] = new JJCalls();
6950: }
6951:
6952: public void ReInit(java.io.InputStream stream) {
6953: jj_input_stream.ReInit(stream, 1, 1);
6954: token_source.ReInit(jj_input_stream);
6955: token = new Token();
6956: jj_ntk = -1;
6957: jj_gen = 0;
6958: for (int i = 0; i < 189; i++)
6959: jj_la1[i] = -1;
6960: for (int i = 0; i < jj_2_rtns.length; i++)
6961: jj_2_rtns[i] = new JJCalls();
6962: }
6963:
6964: public SQL(java.io.Reader stream) {
6965: jj_input_stream = new SimpleCharStream(stream, 1, 1);
6966: token_source = new SQLTokenManager(jj_input_stream);
6967: token = new Token();
6968: jj_ntk = -1;
6969: jj_gen = 0;
6970: for (int i = 0; i < 189; i++)
6971: jj_la1[i] = -1;
6972: for (int i = 0; i < jj_2_rtns.length; i++)
6973: jj_2_rtns[i] = new JJCalls();
6974: }
6975:
6976: public void ReInit(java.io.Reader stream) {
6977: jj_input_stream.ReInit(stream, 1, 1);
6978: token_source.ReInit(jj_input_stream);
6979: token = new Token();
6980: jj_ntk = -1;
6981: jj_gen = 0;
6982: for (int i = 0; i < 189; i++)
6983: jj_la1[i] = -1;
6984: for (int i = 0; i < jj_2_rtns.length; i++)
6985: jj_2_rtns[i] = new JJCalls();
6986: }
6987:
6988: public SQL(SQLTokenManager tm) {
6989: token_source = tm;
6990: token = new Token();
6991: jj_ntk = -1;
6992: jj_gen = 0;
6993: for (int i = 0; i < 189; i++)
6994: jj_la1[i] = -1;
6995: for (int i = 0; i < jj_2_rtns.length; i++)
6996: jj_2_rtns[i] = new JJCalls();
6997: }
6998:
6999: public void ReInit(SQLTokenManager tm) {
7000: token_source = tm;
7001: token = new Token();
7002: jj_ntk = -1;
7003: jj_gen = 0;
7004: for (int i = 0; i < 189; i++)
7005: jj_la1[i] = -1;
7006: for (int i = 0; i < jj_2_rtns.length; i++)
7007: jj_2_rtns[i] = new JJCalls();
7008: }
7009:
7010: final private Token jj_consume_token(int kind)
7011: throws ParseException {
7012: Token oldToken;
7013: if ((oldToken = token).next != null)
7014: token = token.next;
7015: else
7016: token = token.next = token_source.getNextToken();
7017: jj_ntk = -1;
7018: if (token.kind == kind) {
7019: jj_gen++;
7020: if (++jj_gc > 100) {
7021: jj_gc = 0;
7022: for (int i = 0; i < jj_2_rtns.length; i++) {
7023: JJCalls c = jj_2_rtns[i];
7024: while (c != null) {
7025: if (c.gen < jj_gen)
7026: c.first = null;
7027: c = c.next;
7028: }
7029: }
7030: }
7031: return token;
7032: }
7033: token = oldToken;
7034: jj_kind = kind;
7035: throw generateParseException();
7036: }
7037:
7038: final private boolean jj_scan_token(int kind) {
7039: if (jj_scanpos == jj_lastpos) {
7040: jj_la--;
7041: if (jj_scanpos.next == null) {
7042: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
7043: .getNextToken();
7044: } else {
7045: jj_lastpos = jj_scanpos = jj_scanpos.next;
7046: }
7047: } else {
7048: jj_scanpos = jj_scanpos.next;
7049: }
7050: if (jj_rescan) {
7051: int i = 0;
7052: Token tok = token;
7053: while (tok != null && tok != jj_scanpos) {
7054: i++;
7055: tok = tok.next;
7056: }
7057: if (tok != null)
7058: jj_add_error_token(kind, i);
7059: }
7060: return (jj_scanpos.kind != kind);
7061: }
7062:
7063: final public Token getNextToken() {
7064: if (token.next != null)
7065: token = token.next;
7066: else
7067: token = token.next = token_source.getNextToken();
7068: jj_ntk = -1;
7069: jj_gen++;
7070: return token;
7071: }
7072:
7073: final public Token getToken(int index) {
7074: Token t = lookingAhead ? jj_scanpos : token;
7075: for (int i = 0; i < index; i++) {
7076: if (t.next != null)
7077: t = t.next;
7078: else
7079: t = t.next = token_source.getNextToken();
7080: }
7081: return t;
7082: }
7083:
7084: final private int jj_ntk() {
7085: if ((jj_nt = token.next) == null)
7086: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
7087: else
7088: return (jj_ntk = jj_nt.kind);
7089: }
7090:
7091: private java.util.Vector jj_expentries = new java.util.Vector();
7092: private int[] jj_expentry;
7093: private int jj_kind = -1;
7094: private int[] jj_lasttokens = new int[100];
7095: private int jj_endpos;
7096:
7097: private void jj_add_error_token(int kind, int pos) {
7098: if (pos >= 100) return;
7099: if (pos == jj_endpos + 1) {
7100: jj_lasttokens[jj_endpos++] = kind;
7101: } else if (jj_endpos != 0) {
7102: jj_expentry = new int[jj_endpos];
7103: for (int i = 0; i < jj_endpos; i++) {
7104: jj_expentry[i] = jj_lasttokens[i];
7105: }
7106: boolean exists = false;
7107: for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
7108: int[] oldentry = (int[])(enum.nextElement());
7109: if (oldentry.length == jj_expentry.length) {
7110: exists = true;
7111: for (int i = 0; i < jj_expentry.length; i++) {
7112: if (oldentry[i] != jj_expentry[i]) {
7113: exists = false;
7114: break;
7115: }
7116: }
7117: if (exists) break;
7118: }
7119: }
7120: if (!exists) jj_expentries.addElement(jj_expentry);
7121: if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
7122: }
7123: }
7124:
7125: final public ParseException generateParseException() {
7126: jj_expentries.removeAllElements();
7127: boolean[] la1tokens = new boolean[211];
7128: for (int i = 0; i < 211; i++) {
7129: la1tokens[i] = false;
7130: }
7131: if (jj_kind >= 0) {
7132: la1tokens[jj_kind] = true;
7133: jj_kind = -1;
7134: }
7135: for (int i = 0; i < 189; i++) {
7136: if (jj_la1[i] == jj_gen) {
7137: for (int j = 0; j < 32; j++) {
7138: if ((jj_la1_0[i] & (1 << j)) != 0) {
7139: la1tokens[j] = true;
7140: }
7141: if ((jj_la1_1[i] & (1 << j)) != 0) {
7142: la1tokens[32 + j] = true;
7143: }
7144: if ((jj_la1_2[i] & (1 << j)) != 0) {
7145: la1tokens[64 + j] = true;
7146: }
7147: if ((jj_la1_3[i] & (1 << j)) != 0) {
7148: la1tokens[96 + j] = true;
7149: }
7150: if ((jj_la1_4[i] & (1 << j)) != 0) {
7151: la1tokens[128 + j] = true;
7152: }
7153: if ((jj_la1_5[i] & (1 << j)) != 0) {
7154: la1tokens[160 + j] = true;
7155: }
7156: if ((jj_la1_6[i] & (1 << j)) != 0) {
7157: la1tokens[192 + j] = true;
7158: }
7159: }
7160: }
7161: }
7162: for (int i = 0; i < 211; i++) {
7163: if (la1tokens[i]) {
7164: jj_expentry = new int[1];
7165: jj_expentry[0] = i;
7166: jj_expentries.addElement(jj_expentry);
7167: }
7168: }
7169: jj_endpos = 0;
7170: jj_rescan_token();
7171: jj_add_error_token(0, 0);
7172: int[][] exptokseq = new int[jj_expentries.size()][];
7173: for (int i = 0; i < jj_expentries.size(); i++) {
7174: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
7175: }
7176: return new ParseException(token, exptokseq, tokenImage);
7177: }
7178:
7179: final public void enable_tracing() {
7180: }
7181:
7182: final public void disable_tracing() {
7183: }
7184:
7185: final private void jj_rescan_token() {
7186: jj_rescan = true;
7187: for (int i = 0; i < 17; i++) {
7188: JJCalls p = jj_2_rtns[i];
7189: do {
7190: if (p.gen > jj_gen) {
7191: jj_la = p.arg;
7192: jj_lastpos = jj_scanpos = p.first;
7193: switch (i) {
7194: case 0:
7195: jj_3_1();
7196: break;
7197: case 1:
7198: jj_3_2();
7199: break;
7200: case 2:
7201: jj_3_3();
7202: break;
7203: case 3:
7204: jj_3_4();
7205: break;
7206: case 4:
7207: jj_3_5();
7208: break;
7209: case 5:
7210: jj_3_6();
7211: break;
7212: case 6:
7213: jj_3_7();
7214: break;
7215: case 7:
7216: jj_3_8();
7217: break;
7218: case 8:
7219: jj_3_9();
7220: break;
7221: case 9:
7222: jj_3_10();
7223: break;
7224: case 10:
7225: jj_3_11();
7226: break;
7227: case 11:
7228: jj_3_12();
7229: break;
7230: case 12:
7231: jj_3_13();
7232: break;
7233: case 13:
7234: jj_3_14();
7235: break;
7236: case 14:
7237: jj_3_15();
7238: break;
7239: case 15:
7240: jj_3_16();
7241: break;
7242: case 16:
7243: jj_3_17();
7244: break;
7245: }
7246: }
7247: p = p.next;
7248: } while (p != null);
7249: }
7250: jj_rescan = false;
7251: }
7252:
7253: final private void jj_save(int index, int xla) {
7254: JJCalls p = jj_2_rtns[index];
7255: while (p.gen > jj_gen) {
7256: if (p.next == null) {
7257: p = p.next = new JJCalls();
7258: break;
7259: }
7260: p = p.next;
7261: }
7262: p.gen = jj_gen + xla - jj_la;
7263: p.first = token;
7264: p.arg = xla;
7265: }
7266:
7267: static final class JJCalls {
7268: int gen;
7269: Token first;
7270: int arg;
7271: JJCalls next;
7272: }
7273:
7274: }
|