axionsqlparser.java

开源的axion的数据库代码

      cur = SqlLiteral();
      break;
    case QUESTIONMARK:
      cur = SqlBindVar();
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
      result.add(cur);
    label_10:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_10;
      }
      jj_consume_token(COMMA);
      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:
        cur = SqlLiteral();
        break;
      case QUESTIONMARK:
        cur = SqlBindVar();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
         result.add(cur);
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

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

  final public Literal SqlLiteral() throws ParseException {
   Literal literal = null;
   Token t = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STRING_LITERAL:
      t = jj_consume_token(STRING_LITERAL);
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: consumed \"" + token + "\""); }
      // trim off the open and close quotes
      String trimmed = t.image.substring(1, t.image.length() - 1);
      // replace all '' with '
      String result = replace(trimmed,"''","'");
      literal = new Literal(result,new StringType());
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: result \"" + result + "\""); }
      break;
    case INTEGER_LITERAL:
      t = jj_consume_token(INTEGER_LITERAL);
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: consumed \"" + token + "\""); }
      literal = new Literal(new Long(t.image), new LongType());
      break;
    case FLOATING_POINT_LITERAL:
      t = jj_consume_token(FLOATING_POINT_LITERAL);
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: consumed \"" + token + "\""); }
      literal = new Literal(new Float(t.image),new FloatType());
      break;
    case NULL:
      jj_consume_token(NULL);
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: consumed \"" + token + "\""); }
      literal = new Literal(null);
      break;
    case TRUE:
      jj_consume_token(TRUE);
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: consumed \"" + token + "\""); }
      literal = new Literal(Boolean.TRUE,new BooleanType());
      break;
    case FALSE:
      jj_consume_token(FALSE);
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: consumed \"" + token + "\""); }
      literal = new Literal(Boolean.FALSE,new BooleanType());
      break;
    case ASTERISK:
      jj_consume_token(ASTERISK);
      if(_log.isDebugEnabled()) { _log.debug("SqlLiteral: consumed \"" + token + "\""); }
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return literal;}
    throw new Error("Missing return statement in function");
  }

  final public String SqlLValueTerm() throws ParseException {
  StringBuffer buffer = new StringBuffer();
  Token t = null;
    t = jj_consume_token(ID);
    buffer.append(t.image);
    if(_log.isDebugEnabled()) { _log.debug("SqlLValueTerm: consumed \"" + token + "\""); }
    label_11:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DOT:
        ;
        break;
      default:
        break label_11;
      }
      t = jj_consume_token(DOT);
      buffer.append(t.image);
      if(_log.isDebugEnabled()) { _log.debug("SqlLValueTerm: consumed \"" + token + "\""); }
      t = jj_consume_token(ID);
      buffer.append(t.image);
      if(_log.isDebugEnabled()) { _log.debug("SqlLValueTerm: consumed \"" + token + "\""); }
    }
    {if (true) return buffer.toString();}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlSelectable() throws ParseException {
        Selectable sel = null;
    sel = SqlWhereOr();
                {if (true) return sel;}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlSelectableElements() throws ParseException {
   Selectable sel = null;
    if (jj_2_5(2)) {
      sel = SqlFunction();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ID:
        sel = SqlColumnRef();
        break;
      case FALSE:
      case NULL:
      case TRUE:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case STRING_LITERAL:
      case ASTERISK:
        sel = SqlLiteral();
        break;
      case QUESTIONMARK:
        sel = SqlBindVar();
        break;
      case CASE:
        sel = SqlCase();
        break;
      case SYSDATE:
        sel = SqlPseudoColumn();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
      {if (true) return sel;}
    throw new Error("Missing return statement in function");
  }

  final public List SqlSelectList() throws ParseException {
  List list = new ArrayList();
  Selectable curCol = null;
    curCol = SqlSelectable();
      list.add(curCol);
    label_12:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_12;
      }
      jj_consume_token(COMMA);
      if(_log.isDebugEnabled()) { _log.debug("SqlSelectList: consumed \"" + token + "\""); }
      curCol = SqlSelectable();
      list.add(curCol);
    }
    {if (true) return list;}
    throw new Error("Missing return statement in function");
  }

  final public TableIdentifier SqlTableRef() throws ParseException {
  Token t = null;
  String name = null;
  String alias = null;
    t = jj_consume_token(ID);
    name = t.image;
    if(_log.isDebugEnabled()) { _log.debug("SqlTableRef: consumed \"" + token + "\""); }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ID:
      t = jj_consume_token(ID);
      alias = t.image;
      if(_log.isDebugEnabled()) { _log.debug("SqlTableRef: consumed \"" + token + "\""); }
      break;
    default:
      ;
    }
    {if (true) return new TableIdentifier(name, alias);}
    throw new Error("Missing return statement in function");
  }

  final public void SqlLValueList() throws ParseException {
    SqlLValueElement();
    label_13:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_13;
      }
      jj_consume_token(COMMA);
     if(_log.isDebugEnabled()) { _log.debug("SqlValueList: consumed \"" + token + "\""); }
      SqlLValueElement();
    }
  }

  final public void SqlLValueElement() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NULL:
      jj_consume_token(NULL);
    if(_log.isDebugEnabled()) { _log.debug("SqlValueElement: consumed \"" + token + "\""); }
      break;
    case SELECT:
      SqlSelect();
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

// ----------------------------------------------------------------------------
// ORDER BY CLAUSE
// ----------------------------------------------------------------------------
  final public List SqlOrderBy() throws ParseException {
   List result = null;
    jj_consume_token(ORDER);
     if(_log.isDebugEnabled()) { _log.debug("SqlOrderBy: consumed \"" + token + "\""); }
    jj_consume_token(BY);
     if(_log.isDebugEnabled()) { _log.debug("SqlOrderBy: consumed \"" + token + "\""); }
    result = SqlOrderByList();
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public OrderNode SqlOrderByElem() throws ParseException {
   Selectable sel = null;
   boolean ascending = true;
    sel = SqlSelectableElements();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ASC:
    case DESC:
      ascending = SqlOrderDirection();
      break;
    default:
      ;
    }
      {if (true) return new OrderNode(sel, !ascending);}
    throw new Error("Missing return statement in function");
  }

  final public List SqlOrderByList() throws ParseException {
   List result = new ArrayList();
   OrderNode cur = null;
    cur = SqlOrderByElem();
      result.add(cur);
    label_14:
    while (true) {
      if (jj_2_6(2)) {
        ;
      } else {
        break label_14;
      }
      jj_consume_token(COMMA);
        if(_log.isDebugEnabled()) { _log.debug("SqlOrderByList: consumed \"" + token + "\""); }
      cur = SqlOrderByElem();
         result.add(cur);
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public boolean SqlOrderDirection() throws ParseException {
   boolean ascending = true;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ASC:
      jj_consume_token(ASC);
      if(_log.isDebugEnabled()) { _log.debug("SqlOrderDirection: consumed \"" + token + "\""); }
      break;
    case DESC:
      jj_consume_token(DESC);
      if(_log.isDebugEnabled()) { _log.debug("SqlOrderDirection: consumed \"" + token + "\""); }
      ascending = false;
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
   {if (true) return ascending;}
    throw new Error("Missing return statement in function");
  }

// ----------------------------------------------------------------------------
// FROM CLAUSE
// ----------------------------------------------------------------------------
  final public FromNode SqlFrom() throws ParseException {
    FromNode node = new FromNode();
    TableIdentifier curTable = null;
    curTable = SqlTableRef();
        node.setLeft(curTable);
        node.setType(FromNode.TYPE_SINGLE);
        node.setCondition(null);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INNER:
    case JOIN:
    case LEFT:
    case RIGHT:
    case COMMA:
      if (jj_2_7(2)) {
        node = SqlTableList(node);
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INNER:
        case JOIN:
        case LEFT:
        case RIGHT:
          node = SqlJoin(node);
          break;
        default:
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      break;
    default:
      ;
    }
        {if (true) return (node);}
    throw new Error("Missing return statement in function");
  }

  final public FromNode SqlTableList(FromNode node) throws ParseException {
    FromNode temp = null;
    TableIdentifier curTable = null;
    label_15:
    while (true) {
      jj_consume_token(COMMA);
     if (temp != null) {
       temp.setLeft(node);
       node = temp;
       temp = null;
     }

     node.setCondition(null);
     node.setType(FromNode.TYPE_INNER);
      curTable = SqlTableRef();
     node.setRight(curTable);
     temp = new FromNode();
      if (jj_2_8(2)) {
        ;
      } else {
        break label_15;
      }
    }
    {if (true) return node;}
    throw new Error("Missing return statement in function");
  }

  final public FromNode SqlJoin(FromNode node) throws ParseException {
    FromNode temp = null;
    Selectable condition = null;
    TableIdentifier curTable = null;
    int curType = -1;
    label_16:
    while (true) {
      curType = SqlJoinType();
          if (temp != null) {
            temp.setLeft(node);
            node = temp;
            temp = null;
          }
          node.setType(curType);
      curTable = SqlTableRef();
          node.setRight(curTable);
      jj_consume_token(ON);
      jj_consume_token(OPENPAREN);
      condition = SqlWhereOr();
          node.setCondition((WhereNode)condition);
      jj_consume_token(CLOSEPAREN);
          temp = new FromNode();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INNER:
      case JOIN:
      case LEFT:
      case RIGHT:
        ;
        break;
      default:
        break label_16;
      }
    }
      {if (true) return (node);}
    throw new Error("Missing return statement in function");
  }

  final public int SqlJoinType() throws ParseException {
    int type = FromNode.TYPE_UNDEFINED;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LEFT:
      jj_consume_token(LEFT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OUTER:
        jj_consume_token(OUTER);
        break;
      default:
        ;
      }
      jj_consume_token(JOIN);
         type = FromNode.TYPE_LEFT;
      break;