aladdinparser.java

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

        valueToken = jj_consume_token(K_TRUE);
                                                value = Boolean.TRUE;
        break;
      case K_FALSE:
        valueToken = jj_consume_token(K_FALSE);
                                                 value = Boolean.FALSE;
        break;
      case IDENTIFIER:
        valueToken = jj_consume_token(IDENTIFIER);
                                                     value = valueToken.image;
        break;
      case INTEGER_LITERAL:
        valueToken = jj_consume_token(INTEGER_LITERAL);
                                                         value = Long.valueOf(valueToken.image);
        break;
      case STRING_LITERAL:
        valueToken = jj_consume_token(STRING_LITERAL);
                                                        value = valueToken.image;
        break;
      case S_QUOTED_IDENTIFIER:
        valueToken = jj_consume_token(S_QUOTED_IDENTIFIER);
                                                             value = valueToken.image;
        break;
      default:
        jj_la1[10] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      jj_la1[11] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 131:
      jj_consume_token(131);
      PropertySetQuery(statment);
      break;
    default:
      jj_la1[12] = jj_gen;
      ;
    }
                if(value != null){
                        ConstantExpression consExp= new ConstantExpression(value);
                        statment.addProperty(propertyName,consExp);
                }
                {if (true) return statment;}
    throw new Error("Missing return statement in function");
  }

  final public Statment UpdateQuery() throws ParseException {
        Expression expression = null;
        Table table = null;
        DMLStatment statment = null;
    table = UpdateStatement();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_WHERE:
      expression = WhereClause();
      break;
    default:
      jj_la1[13] = jj_gen;
      ;
    }
        statment = new UpdateStatment();
        if(expression != null){
                if(expression instanceof BaseExpressionList){
                        if(((BaseExpressionList)expression).getSize()>0){
                                statment.setExpression(expression);
                        }
                }else{
                        statment.setExpression(expression);
                }
        }
        {if (true) return statment;}
    throw new Error("Missing return statement in function");
  }

  final public Table UpdateStatement() throws ParseException {
        Table table = null;
    jj_consume_token(K_UPDATE);
    table = TableReference();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 131:
      jj_consume_token(131);
      TableReference();
      break;
    default:
      jj_la1[14] = jj_gen;
      ;
    }
    jj_consume_token(K_SET);
    AssignmentClause();
        {if (true) return table;}
    throw new Error("Missing return statement in function");
  }

  final public Expression AssignmentClause() throws ParseException {
        Expression expression = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IDENTIFIER:
    case S_QUOTED_IDENTIFIER:
    case S_COMMA_IDENTIFIER:
      expression = ColumnValues();

      break;
    case 132:
      jj_consume_token(132);
      UpdateColumn();
      label_1:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 131:
          ;
          break;
        default:
          jj_la1[15] = jj_gen;
          break label_1;
        }
        jj_consume_token(131);
        UpdateColumn();
      }
      jj_consume_token(133);
      jj_consume_token(130);
      jj_consume_token(132);
      if (jj_2_1(2)) {
        UpdateValues();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case K_SELECT:
        case 132:
          FullSelectStatement();
          break;
        default:
          jj_la1[16] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jj_consume_token(133);
      break;
    default:
      jj_la1[17] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
                {if (true) return expression;}
    throw new Error("Missing return statement in function");
  }

  final public void UpdateColumn() throws ParseException {
    ColumnName();
  }

  final public List<Expression> UpdateValues() throws ParseException {
        Expression expression = null;
        List<Expression> list = new ArrayList<Expression>();
    expression = UpdateValue();
                                 list.add(expression);
    label_2:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 131:
        ;
        break;
      default:
        jj_la1[18] = jj_gen;
        break label_2;
      }
      jj_consume_token(131);
      expression = UpdateValue();
                                                                                      list.add(expression);
    }
        {if (true) return list;}
    throw new Error("Missing return statement in function");
  }

  final public Expression UpdateValue() throws ParseException {
Expression expression = null;
    expression = SQLSimpleExpression();
       {if (true) return   expression;}
    throw new Error("Missing return statement in function");
  }

  final public Statment DeleteQuery() throws ParseException {
        Expression expression = null;
        Table table = null;
        DMLStatment statment = null;
    table = DeleteStatement();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_WHERE:
      expression = WhereClause();
      break;
    default:
      jj_la1[19] = jj_gen;
      ;
    }
        statment = new DeleteStatment();
        if(expression != null){
                if(expression instanceof BaseExpressionList){
                        if(((BaseExpressionList)expression).getSize()>0){
                                statment.setExpression(expression);
                        }
                }else{
                        statment.setExpression(expression);
                }
        }
        {if (true) return  statment;}
    throw new Error("Missing return statement in function");
  }

  final public Table DeleteStatement() throws ParseException {
        Table table = null;
    jj_consume_token(K_DELETE);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_FROM:
      jj_consume_token(K_FROM);
      break;
    default:
      jj_la1[20] = jj_gen;
      ;
    }
    table = TableReference();
        {if (true) return table;}
    throw new Error("Missing return statement in function");
  }

  final public Statment InsertQuery() throws ParseException {
        Table table = null;
        DMLStatment statment = new InsertStatment();
        Expression expression = null;
        List<Column> insertColumns = null;
        List<Expression> insertValues = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_INSERT:
      jj_consume_token(K_INSERT);
      break;
    case K_REPLACE:
      jj_consume_token(K_REPLACE);
      break;
    default:
      jj_la1[21] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_INTO:
      jj_consume_token(K_INTO);
      break;
    default:
      jj_la1[22] = jj_gen;
      ;
    }
    table = TableName();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case K_SELECT:
    case K_VALUES:
    case 132:
      if (jj_2_2(4)) {
        jj_consume_token(132);
        insertColumns = InsertColumns();
        jj_consume_token(133);
      } else {
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case K_VALUES:
        insertValues = InsertValues();
        break;
      case K_SELECT:
      case 132:
        expression = FullSelectStatement();
        break;
      default:
        jj_la1[23] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
        if(insertValues == null){
                if(expression != null){
                                if(expression instanceof BaseExpressionList){
                                        if(((BaseExpressionList)expression).getSize()>0){
                                                statment.setExpression(expression);
                                        }
                                }else{
                                        statment.setExpression(expression);
                                }
                        }
        }else{
                if(insertColumns != null){
                        AndExpression andExpression = new AndExpression();
                        int index = 0;
                        for(Column column:insertColumns){
                                ColumnExpression colExpression = new ColumnExpression();
                                colExpression.setColumn(column);
                                ComparisonExpression compExp = new ComparisonExpression();
                                compExp.setComparison(Comparative.Equivalent);
                                compExp.setExpression(insertValues.get(index));
                                colExpression.setExpression(compExp);
                                andExpression.addExpression(colExpression);
                                index ++;
                        }

                        if(andExpression.getSize()>0){
                                statment.setExpression(andExpression);
                        }
                }
        }
      break;
    case K_SET:
      jj_consume_token(K_SET);
      expression = AssignmentClause();
                if(expression != null){
                        if(expression instanceof BaseExpressionList){
                                if(((BaseExpressionList)expression).getSize()>0){
                                        statment.setExpression(expression);
                                }
                        }else{
                                statment.setExpression(expression);
                        }
                }
      break;
    default:
      jj_la1[24] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return statment;}
    throw new Error("Missing return statement in function");
  }

  final public List<Column> InsertColumns() throws ParseException {
        List<Column> insertColumns = new ArrayList<Column>();
        Column column = null;
    column = InsertColumn();
                                 insertColumns.add(column);
    label_3:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 131:
        ;
        break;
      default:
        jj_la1[25] = jj_gen;
        break label_3;
      }
      jj_consume_token(131);
      column = InsertColumn();
                                                                                          insertColumns.add(column);
    }
                {if (true) return insertColumns;}
    throw new Error("Missing return statement in function");
  }

//This is just a wrapper to provide different formatting in case of Insert
  final public Column InsertColumn() throws ParseException {
        Column column = null;
    column = ColumnName();
                {if (true) return column;}
    throw new Error("Missing return statement in function");
  }

  final public List<Expression> InsertValues() throws ParseException {
        List<Expression> insertValues = new ArrayList<Expression>();
        Expression expression = null;
    jj_consume_token(K_VALUES);
    jj_consume_token(132);
    expression = InsertValue();
                                                 insertValues.add(expression);
    label_4:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 131:
        ;
        break;
      default:
        jj_la1[26] = jj_gen;
        break label_4;
      }
      jj_consume_token(131);
      expression = InsertValue();
                                                                                                                insertValues.add(expression);
    }
    jj_consume_token(133);
        {if (true) return insertValues;}
    throw new Error("Missing return statement in function");
  }

//This is just a wrapper to provide different formatting in case of Insert
  final public Expression InsertValue() throws ParseException {
        Expression expression = null;
    expression = SQLSimpleExpression();
                {if (true) return expression;}
    throw new Error("Missing return statement in function");
  }

  final public Statment SelectQuery() throws ParseException {
        Expression expression = null;
        DMLStatment statment = null;
    expression = FullSelectStatement();
    label_5:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case K_FETCH:
      case K_FOR:
      case K_QUERYNO:
      case K_OPTIMIZE:
      case K_WITH:
        ;
        break;
      default:
        jj_la1[27] = jj_gen;
        break label_5;
      }
      ExtraClauses();
    }
        statment = new SelectStatment();
        if(expression != null){
                if(expression instanceof BaseExpressionList){
                        if(((BaseExpressionList)expression).getSize()>0){
                                statment.setExpression(expression);
                        }
                }else{