axionsqlparser.java

开源的axion的数据库代码

      throw new ParseException();
    }
    if (jj_2_2(2)) {
      SqlDeferrable(constraint);
    } else {
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INITIALLY:
      SqlInitiallyDeferredOrImmediate(constraint);
      break;
    default:
      ;
    }
        {if (true) return constraint;}
    throw new Error("Missing return statement in function");
  }

  final public SelectableBasedConstraint SqlSelectableBasedConstraintType(String constraintname) throws ParseException {
    SelectableBasedConstraint constraint = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PRIMARY:
      jj_consume_token(PRIMARY);
      jj_consume_token(KEY);
                constraint = new PrimaryKeyConstraint(constraintname);
      break;
    case NULL:
      jj_consume_token(NULL);
                constraint = new NullConstraint(constraintname);
      break;
    case NOT:
      jj_consume_token(NOT);
      jj_consume_token(NULL);
                constraint = new NotNullConstraint(constraintname);
      break;
    case UNIQUE:
      jj_consume_token(UNIQUE);
                constraint = new UniqueConstraint(constraintname);
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return constraint;}
    throw new Error("Missing return statement in function");
  }

  final public CheckConstraint SqlCheckConstraintType(String constraintname) throws ParseException {
    CheckConstraint constraint = null;
    Selectable where = null;
    jj_consume_token(CHECK);
            constraint = new CheckConstraint(constraintname);
    jj_consume_token(OPENPAREN);
    where = SqlWhereOr();
    jj_consume_token(CLOSEPAREN);
            constraint.setCondition((WhereNode)where);
        {if (true) return constraint;}
    throw new Error("Missing return statement in function");
  }

  final public void SqlSelectableBasedConstraintArgs(SelectableBasedConstraint constraint) throws ParseException {
    Selectable selectable = null;
    jj_consume_token(OPENPAREN);
    selectable = SqlSelectableElements();
      constraint.addSelectable(selectable);
    label_5:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_5;
      }
      jj_consume_token(COMMA);
      selectable = SqlSelectableElements();
        constraint.addSelectable(selectable);
    }
    jj_consume_token(CLOSEPAREN);
  }

  final public void SqlDeferrable(Constraint constraint) throws ParseException {
    boolean deferrable = true;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NOT:
      jj_consume_token(NOT);
            deferrable = false;
      break;
    default:
      ;
    }
    jj_consume_token(DEFERRABLE);
        constraint.setDeferrable(deferrable);
  }

  final public void SqlInitiallyDeferredOrImmediate(Constraint constraint) throws ParseException {
    jj_consume_token(INITIALLY);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case DEFERRED:
      jj_consume_token(DEFERRED);
                try {
                    constraint.setDeferred(true);
                } catch(AxionException e) {
                    {if (true) throw new ParseException("Constraint not deferrable (use DEFERRABLE before INITIALLY DEFERRED)");}
                }
      break;
    case IMMEDIATE:
      jj_consume_token(IMMEDIATE);
                try {
                    constraint.setDeferred(false);
                } catch(AxionException e) {
                    {if (true) throw new ParseException("Constraint not deferrable (use DEFERRABLE)");}
                }
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

// ----------------------------------------------------------------------------
// GENERIC STUFF (IDENTIFIERS, LITERALS, ETC.)
// ----------------------------------------------------------------------------
  final public String SqlIdentifier() throws ParseException {
   Token t = null;
    t = jj_consume_token(ID);
      {if (true) return t.image;}
    throw new Error("Missing return statement in function");
  }

  final public List SqlIdentifierList() throws ParseException {
   List result = new ArrayList();
   String curIdent = null;
    curIdent = SqlIdentifier();
      result.add(curIdent);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case COMMA:
      jj_consume_token(COMMA);
      curIdent = SqlIdentifier();
         result.add(curIdent);
      break;
    default:
      ;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public BindVariable SqlBindVar() throws ParseException {
    jj_consume_token(QUESTIONMARK);
      {if (true) return new BindVariable();}
    throw new Error("Missing return statement in function");
  }

  final public String[] SqlColumnDef() throws ParseException {
    String[] pair = new String[2];
    pair[0] = SqlLValueTerm();
    pair[1] = SqlLValueTerm();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case OPENPAREN:
      jj_consume_token(OPENPAREN);
      jj_consume_token(INTEGER_LITERAL);
      label_6:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          break label_6;
        }
        jj_consume_token(COMMA);
        jj_consume_token(INTEGER_LITERAL);
      }
      jj_consume_token(CLOSEPAREN);
      break;
    default:
      ;
    }
        {if (true) return pair;}
    throw new Error("Missing return statement in function");
  }

  final public ColumnIdentifier SqlColumnRef() throws ParseException {
   String column = null;
    column = SqlLValueTerm();
      {if (true) return new ColumnIdentifier(column);}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlCase() throws ParseException {
    List   caseargs = new ArrayList();
    List   whenargs = null;
    //
    Selectable condition = null;
    Selectable thenArg = null;
    Selectable elseArg = null;
    //
    FunctionIdentifier whenFn = null;
    FunctionIdentifier caseFn = null;
    jj_consume_token(CASE);
    label_7:
    while (true) {
      jj_consume_token(WHEN);
      condition = SqlWhereOr();
                whenargs = new ArrayList();
                whenargs.add((WhereNode)condition);
      jj_consume_token(THEN);
      thenArg = SqlSelectable();
                whenargs.add(thenArg);
                whenFn = new FunctionIdentifier("IFTHEN", whenargs);
                caseargs.add(whenFn);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHEN:
        ;
        break;
      default:
        break label_7;
      }
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ELSE:
      jj_consume_token(ELSE);
      elseArg = SqlSelectable();
            caseargs.add(elseArg);
      break;
    default:
      ;
    }
    jj_consume_token(END);
        caseFn = new FunctionIdentifier("COALESCE", caseargs);
        {if (true) return (caseFn);}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlPseudoColumn() throws ParseException {
    Selectable sel = null;
    jj_consume_token(SYSDATE);
        if(_log.isDebugEnabled()) { _log.debug("SqlPseudoColumn: consumed \"" + token + "\""); }
        sel = new FunctionIdentifier("now",Collections.EMPTY_LIST);
    {if (true) return sel;}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlFunction() throws ParseException {
  String name = null;
  List fnargs = null;
    jj_consume_token(ID);
        if(_log.isDebugEnabled()) { _log.debug("SqlFunction: consumed \"" + token + "\""); }
        name = token.image;
    fnargs = SqlFunctionArgs();
    {if (true) return new FunctionIdentifier(name,fnargs);}
    throw new Error("Missing return statement in function");
  }

  final public List SqlFunctionArgs() throws ParseException {
    List args = new ArrayList();
    jj_consume_token(OPENPAREN);
    args = SqlSelectCols();
    jj_consume_token(CLOSEPAREN);
    {if (true) return args;}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlSumExprSelectable() throws ParseException {
        Selectable sel = null;
        Selectable temp = null;
        short operation = -1;
        Selectable prv = null;
    sel = SqlProductExprSelectable();
    label_8:
    while (true) {
      if (jj_2_3(2)) {
        ;
      } else {
        break label_8;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
        jj_consume_token(PLUS);
                                  operation = ExpressionIdentifier.PLUS_OPERATION;
        break;
      case MINUS:
        jj_consume_token(MINUS);
                                    operation = ExpressionIdentifier.MINUS_OPERATION;
        break;
      case CONCAT:
        jj_consume_token(CONCAT);
                                     operation = ExpressionIdentifier.CONCAT_OPERATION;
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
      temp = SqlProductExprSelectable();
                           ExpressionIdentifier expr = new ExpressionIdentifier("Sum");
                           if(prv == null){
                                prv = sel;
                           }
                           expr.setLeftSelectable(prv);
                           expr.setRightSelectable(temp);
                           expr.setOperationType(operation);
                           prv = expr;
    }
        if(null==prv){
                 {if (true) return sel;}
        }
        else{
                {if (true) return  prv;}
        }
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlProductExprSelectable() throws ParseException {
        Selectable sel = null;
        Selectable temp = null;
        short operation = -1;
    Selectable prv = null;
    sel = SqlParenthExprSelectable();
    label_9:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASTERISK:
      case SLASH:
        ;
        break;
      default:
        break label_9;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASTERISK:
        jj_consume_token(ASTERISK);
                    operation = ExpressionIdentifier.MULT_OPERATION;
        break;
      case SLASH:
        jj_consume_token(SLASH);
                     operation = ExpressionIdentifier.DIV_OPERATION;
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
      temp = SqlParenthExprSelectable();
            ExpressionIdentifier expr = new ExpressionIdentifier("Product");
            if(prv == null){
                prv = sel;
            }
            expr.setLeftSelectable(prv);
            expr.setRightSelectable(temp);
            expr.setOperationType(operation);
            prv = expr;
    }
         if(null==prv){
                 {if (true) return sel;}
        }
        else{
                {if (true) return  prv;}
        }
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlParenthExprSelectable() throws ParseException {
        Selectable sel = null;
    if (jj_2_4(3)) {
      jj_consume_token(OPENPAREN);
      sel = SqlSumExprSelectable();
      jj_consume_token(CLOSEPAREN);
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CASE:
      case FALSE:
      case NULL:
      case SYSDATE:
      case TRUE:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case STRING_LITERAL:
      case ID:
      case ASTERISK:
      case PLUS:
      case MINUS:
      case QUESTIONMARK:
        sel = SqlUnaryExprSelectable();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }

  {if (true) return sel;}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlUnaryExprSelectable() throws ParseException {
        //UnaryExpression unary = null;
        Selectable sel = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
    case MINUS:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
        jj_consume_token(PLUS);

        break;
      case MINUS:
        jj_consume_token(MINUS);

        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      ;
    }
    sel = SqlSelectableElements();

  {if (true) return sel;}
    throw new Error("Missing return statement in function");
  }

  final public List SqlLiteralList() throws ParseException {
   List result = new ArrayList();
   Object cur = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case FALSE:
    case NULL:
    case TRUE:
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
    case STRING_LITERAL:
    case ASTERISK: