aladdinparser.java

来自「mysql集群」· Java 代码 · 共 2,114 行 · 第 1/5 页

                        statment.setExpression(expression);
                }
        }
        {if (true) return statment;}
    throw new Error("Missing return statement in function");
  }

  final public Expression ColumnValues() throws ParseException {
        Expression expression = null;
        AndExpression andExpression = new AndExpression();
    expression = ColumnValue();
                            if(expression != null) andExpression.addExpression(expression);
    label_6:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 131:
        ;
        break;
      default:
        jj_la1[28] = jj_gen;
        break label_6;
      }
      jj_consume_token(131);
      expression = ColumnValue();
                                                                                                                             if(expression != null) andExpression.addExpression(expression);
    }
  {if (true) return andExpression;}
    throw new Error("Missing return statement in function");
  }

  final public Expression ColumnValue() throws ParseException {
ColumnExpression colExpression = new ColumnExpression();
Expression expression = null;
Column column = null;
    column = ColumnName();
    jj_consume_token(130);
    expression = UpdatedValue();
        if(expression == null) {if (true) return null;}

        colExpression.setColumn(column);
        ComparisonExpression compExp = new ComparisonExpression();
                compExp.setComparison(Comparative.Equivalent);
                compExp.setExpression(expression);
                colExpression.setExpression(compExp);
        {if (true) return colExpression;}
    throw new Error("Missing return statement in function");
  }

  final public Expression UpdatedValue() throws ParseException {
Expression expression = null;
    if (jj_2_3(2147483647)) {
      jj_consume_token(132);
      expression = SubSelectStatement();
      jj_consume_token(133);
    } else if (jj_2_4(1)) {
      expression = SQLSimpleExpression();
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return expression;}
    throw new Error("Missing return statement in function");
  }

  final public ComparisonExpression IsNullClause() throws ParseException {
        int comparison = Comparative.Equivalent;
    jj_consume_token(K_IS);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_NOT:
      jj_consume_token(K_NOT);
                     comparison = Comparative.NotEquivalent;
      break;
    default:
      jj_la1[29] = jj_gen;
      ;
    }
    jj_consume_token(K_NULL);
        ComparisonExpression comparativeExpression = new ComparisonExpression();
                comparativeExpression.setComparison(comparison);
                comparativeExpression.setExpression(new ConstantExpression(null));
                {if (true) return comparativeExpression;}
    throw new Error("Missing return statement in function");
  }

/*
*	Tabel Column
*/
  final public Column ColumnName() throws ParseException {
        String schemaName = null;
        String tableName = null;
        String columnName = null;
        Column column =  new Column();
        Table table = null;
    // schema.table.column
       schemaName = EntityName();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 129:
      jj_consume_token(129);
      tableName = EntityName();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 129:
        jj_consume_token(129);
        columnName = EntityName();
        break;
      default:
        jj_la1[30] = jj_gen;
        ;
      }
      break;
    default:
      jj_la1[31] = jj_gen;
      ;
    }
                if(tableName == null){
                        columnName = schemaName;
                        schemaName = null;
                        if(tableStack.size()>0){
                                table = tableStack.peek();
                        }
                }else{
                        if(columnName == null){
                                columnName = tableName;
                                tableName = schemaName;
                                schemaName = null;
                                table = tableAliasMap.get(tableName);
                        }
                }
                column.setTable(table);
                column.setName(columnName);
                {if (true) return column;}
    throw new Error("Missing return statement in function");
  }

  final public String EntityName() throws ParseException {
        Token token = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IDENTIFIER:
      token = jj_consume_token(IDENTIFIER);
                {if (true) return token.image;}
      break;
    case S_QUOTED_IDENTIFIER:
      token = jj_consume_token(S_QUOTED_IDENTIFIER);
                {if (true) return token.image.substring(1,token.image.length()-1);}
      break;
    case S_COMMA_IDENTIFIER:
      token = jj_consume_token(S_COMMA_IDENTIFIER);
                {if (true) return token.image.substring(1,token.image.length()-1);}
      break;
    default:
      jj_la1[32] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public String Relop() throws ParseException {
        Token token;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 130:
      token = jj_consume_token(130);
      break;
    case 134:
      token = jj_consume_token(134);
      break;
    case 135:
      token = jj_consume_token(135);
      break;
    case 136:
      token = jj_consume_token(136);
      break;
    case 137:
      token = jj_consume_token(137);
      break;
    case 138:
      token = jj_consume_token(138);
      break;
    case 139:
      token = jj_consume_token(139);
      break;
    default:
      jj_la1[33] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return token.image;}
    throw new Error("Missing return statement in function");
  }

  final public Table TableName() throws ParseException {
        String schemaName = null;
        String tableName = null;
        Table table = null;
        Schema schema = null;
    schemaName = EntityName();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 129:
      jj_consume_token(129);
      tableName = EntityName();
      break;
    default:
      jj_la1[34] = jj_gen;
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_PARTITION:
      jj_consume_token(K_PARTITION);
      jj_consume_token(132);
      EntityName();
      jj_consume_token(133);
      break;
    default:
      jj_la1[35] = jj_gen;
      ;
    }
        if(tableName == null){
                tableName = schemaName;
                schemaName = null;
        }
        table = new Table();
        table.setName(tableName);
        if(schemaName != null){
                schema = new Schema();
                schema.setName(schemaName);
                table.setSchema(schema);
        }else{
                table.setSchema(defaultSchema);
        }
        tableAliasMap.put(table.getName(),table);
        tableStack.push(table);
        {if (true) return table;}
    throw new Error("Missing return statement in function");
  }

  final public Table TableReference() throws ParseException {
        Table table = null;
        Token token = null;
    table = TableName();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_AS:
    case IDENTIFIER:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case K_AS:
        jj_consume_token(K_AS);
        break;
      default:
        jj_la1[36] = jj_gen;
        ;
      }
      token = jj_consume_token(IDENTIFIER);
        table.setAlias(token.image);
      break;
    default:
      jj_la1[37] = jj_gen;
      ;
    }
         if(table.getAlias() != null){
                tableAliasMap.put(table.getAlias(),table);
         }
         {if (true) return table;}
    throw new Error("Missing return statement in function");
  }

  final public void CaseStatement() throws ParseException {
    jj_consume_token(K_CASE);
    if (jj_2_5(1)) {
      SQLSimpleExpression();
    } else {
      ;
    }
    WhenStatement();
    label_7:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case K_WHEN:
        ;
        break;
      default:
        jj_la1[38] = jj_gen;
        break label_7;
      }
      WhenStatement();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_ELSE:
      ElseStatement();
      break;
    default:
      jj_la1[39] = jj_gen;
      ;
    }
    jj_consume_token(K_END);
  }

  final public void WhenStatement() throws ParseException {
    jj_consume_token(K_WHEN);
    SQLExpression();
    jj_consume_token(K_THEN);
    SQLSimpleExpression();
  }

  final public void ElseStatement() throws ParseException {
    jj_consume_token(K_ELSE);
    SQLSimpleExpression();
  }

  final public void ExtraClauses() throws ParseException {
    if (jj_2_6(2)) {
      ForUpdateClause();
    } else if (jj_2_7(2)) {
      ReadOnlyClause();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case K_OPTIMIZE:
        OptimizeForClause();
        break;
      case K_WITH:
        WithClause();
        break;
      case K_QUERYNO:
        QuerynoClause();
        break;
      case K_FETCH:
        FetchFirstClause();
        break;
      default:
        jj_la1[40] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  final public Expression FullSelectStatement() throws ParseException {
        Expression expression = null;
        Expression unionedExpression = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_SELECT:
      expression = SubSelectStatement();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case K_INTERSECT:
      case K_MINUS:
      case K_UNION:
        UnionClause();
        unionedExpression = FullSelectStatement();
        break;
      default:
        jj_la1[41] = jj_gen;
        ;
      }
      break;
    case 132:
      jj_consume_token(132);
      expression = FullSelectStatement();
      jj_consume_token(133);
      break;
    default:
      jj_la1[42] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
                if(unionedExpression != null){
                        if(expression == null){
                                {if (true) return unionedExpression;}
                        }else{
                                expression = new OrExpression(expression);
                                ((OrExpression)expression).addExpression(unionedExpression);
                                {if (true) return expression;}
                        }
                }else{
                        {if (true) return expression;}
                }
    throw new Error("Missing return statement in function");
  }

  final public void UnionClause() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_UNION:
      jj_consume_token(K_UNION);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case K_ALL:
        jj_consume_token(K_ALL);
        break;
      default:
        jj_la1[43] = jj_gen;
        ;
      }
      break;
    case K_INTERSECT:
      jj_consume_token(K_INTERSECT);
      break;
    case K_MINUS:
      jj_consume_token(K_MINUS);
      break;
    default:
      jj_la1[44] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public Expression SubSelectStatement() throws ParseException {
        Expression expression = null;
        AndExpression andExpression = null;
    SelectClause();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_FROM:
      expression = FromClause();
        if(expression != null){
                if(andExpression == null){
                        andExpression = new AndExpression();
                }
                        andExpression.addExpression(expression);
                }else{


        }
      break;
    default:
      jj_la1[45] = jj_gen;
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {