axionsqlparser.java

开源的axion的数据库代码

    case RIGHT:
      jj_consume_token(RIGHT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OUTER:
        jj_consume_token(OUTER);
        break;
      default:
        ;
      }
      jj_consume_token(JOIN);
         type = FromNode.TYPE_RIGHT;
      break;
    case INNER:
    case JOIN:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INNER:
        jj_consume_token(INNER);
        break;
      default:
        ;
      }
      jj_consume_token(JOIN);
         type = FromNode.TYPE_INNER;
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return (type);}
    throw new Error("Missing return statement in function");
  }

// ----------------------------------------------------------------------------
// GROUP BY CLAUSE
// ----------------------------------------------------------------------------
  final public void SqlGroupBy() throws ParseException {
    jj_consume_token(GROUP);
    if(_log.isDebugEnabled()) { _log.debug("SqlGroupBy: consumed \"" + token + "\""); }
    jj_consume_token(BY);
    if(_log.isDebugEnabled()) { _log.debug("SqlGroupBy: consumed \"" + token + "\""); }
    SqlOrderByList();
  }

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

  final public Selectable SqlWhereOr() throws ParseException {
   BinaryBranchWhereNode parent = null;
   Selectable left = null;
   Selectable right = null;
   Selectable result = null;
    left = SqlWhereAnd();
      result = left;
    label_17:
    while (true) {
      if (jj_2_9(2)) {
        ;
      } else {
        break label_17;
      }
      jj_consume_token(OR);
       if(_log.isDebugEnabled()) { _log.debug("SqlWhereOr: consumed \"" + token + "\""); }
      right = SqlWhereAnd();
         parent = new BinaryBranchWhereNode();
         parent.setLeft((WhereNode)left);
         parent.setRight((WhereNode)right);
         parent.setIsOr(true);
         left = (Selectable) parent;
         result = (Selectable) parent;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlWhereAnd() throws ParseException {
   BinaryBranchWhereNode parent = null;
   Selectable left = null;
   Selectable right = null;
   Selectable result = null;
    left = SqlWhereNot();
      result = left;
    label_18:
    while (true) {
      if (jj_2_10(2)) {
        ;
      } else {
        break label_18;
      }
      jj_consume_token(AND);
       if(_log.isDebugEnabled()) { _log.debug("SqlWhereAnd: consumed \"" + token + "\""); }
      right = SqlWhereNot();
         parent = new BinaryBranchWhereNode();
         parent.setLeft((WhereNode)left);
         parent.setRight((WhereNode)right);
         parent.setIsAnd(true);
         left = (Selectable) parent;
         result = (Selectable) parent;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlWhereNot() throws ParseException {
   Selectable child = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NOT:
      jj_consume_token(NOT);
         if(_log.isDebugEnabled()) { _log.debug("SqlWhereNot: consumed \"" + token + "\""); }
      child = SqlWhereElt();
         {if (true) return ((Selectable)new NotWhereNode((WhereNode)child));}
      break;
    case CASE:
    case FALSE:
    case NULL:
    case SYSDATE:
    case TRUE:
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
    case STRING_LITERAL:
    case ID:
    case OPENPAREN:
    case ASTERISK:
    case PLUS:
    case MINUS:
    case QUESTIONMARK:
      child = SqlWhereElt();
     {if (true) return child;}
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlWhereElt() throws ParseException {
   Selectable result = null;
    if (jj_2_11(6)) {
      result = SqlCompareExpr();
         {if (true) return result;}
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OPENPAREN:
        jj_consume_token(OPENPAREN);
        result = SqlWhereOr();
        jj_consume_token(CLOSEPAREN);
         {if (true) return result;}
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public Selectable SqlCompareExpr() throws ParseException {
   Selectable left = null;
   Selectable right = null;
   ComparisonOperator op = null;
   Selectable[] endpts = null;
   List elements = null;
   Selectable result = null;
    left = SqlSumExprSelectable();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case BETWEEN:
    case IN:
    case IS:
    case LIKE:
    case LESS:
    case LESSEQUAL:
    case GREATER:
    case GREATEREQUAL:
    case EQUAL:
    case NOTEQUAL:
    case NOTEQUAL2:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IS:
        op = SqlIsClause();
        result = new LeafWhereNode(left, op, null);
        break;
      case BETWEEN:
        endpts = SqlBetweenClause();
        BinaryBranchWhereNode between = new BinaryBranchWhereNode();
        between.setIsAnd(true);
        between.setLeft(new LeafWhereNode(left, ComparisonOperator.GREATER_THAN_OR_EQUAL, endpts[0]));
        between.setRight(new LeafWhereNode(left, ComparisonOperator.LESS_THAN_OR_EQUAL, endpts[1]));
        result = between;
        break;
      case LESS:
      case LESSEQUAL:
      case GREATER:
      case GREATEREQUAL:
      case EQUAL:
      case NOTEQUAL:
      case NOTEQUAL2:
        op = SqlCompareOp();
        right = SqlSumExprSelectable();
        result = new LeafWhereNode(left, op, right);
        break;
      case IN:
        jj_consume_token(IN);
        jj_consume_token(OPENPAREN);
        elements = SqlLiteralList();
        jj_consume_token(CLOSEPAREN);
         result = new InWhereNode(left, elements);
        break;
      case LIKE:
        jj_consume_token(LIKE);
        right = SqlSumExprSelectable();
         List likeArgs = new ArrayList();
         likeArgs.add(right);
         FunctionIdentifier like = new FunctionIdentifier("like2regexp", likeArgs);

         List matchArgs = new ArrayList();
         matchArgs.add(left);
         matchArgs.add(like);
         FunctionIdentifier matches = new FunctionIdentifier("matches", matchArgs);

         Literal troo = new Literal(Boolean.TRUE, new BooleanType());
         result = new LeafWhereNode(matches, ComparisonOperator.EQUAL, troo);
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      ;
    }
        if (result == null) {
            result = left;
        }
        {if (true) return (result);}
    throw new Error("Missing return statement in function");
  }

  final public ComparisonOperator SqlCompareOp() throws ParseException {
   ComparisonOperator result = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case EQUAL:
      jj_consume_token(EQUAL);
         if(_log.isDebugEnabled()) { _log.debug("SqlCompareOp: consumed \"" + token + "\""); }
         result = ComparisonOperator.EQUAL;
      break;
    case NOTEQUAL:
      jj_consume_token(NOTEQUAL);
         if(_log.isDebugEnabled()) { _log.debug("SqlCompareOp: consumed \"" + token + "\""); }
         result = ComparisonOperator.NOT_EQUAL;
      break;
    case NOTEQUAL2:
      jj_consume_token(NOTEQUAL2);
         if(_log.isDebugEnabled()) { _log.debug("SqlCompareOp: consumed \"" + token + "\""); }
         result = ComparisonOperator.NOT_EQUAL;
      break;
    case GREATER:
      jj_consume_token(GREATER);
         if(_log.isDebugEnabled()) { _log.debug("SqlCompareOp: consumed \"" + token + "\""); }
         result = ComparisonOperator.GREATER_THAN;
      break;
    case GREATEREQUAL:
      jj_consume_token(GREATEREQUAL);
         if(_log.isDebugEnabled()) { _log.debug("SqlCompareOp: consumed \"" + token + "\""); }
         result = ComparisonOperator.GREATER_THAN_OR_EQUAL;
      break;
    case LESS:
      jj_consume_token(LESS);
         if(_log.isDebugEnabled()) { _log.debug("SqlCompareOp: consumed \"" + token + "\""); }
         result = ComparisonOperator.LESS_THAN;
      break;
    case LESSEQUAL:
      jj_consume_token(LESSEQUAL);
         if(_log.isDebugEnabled()) { _log.debug("SqlCompareOp: consumed \"" + token + "\""); }
         result = ComparisonOperator.LESS_THAN_OR_EQUAL;
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public ComparisonOperator SqlIsClause() throws ParseException {
   boolean foundnot = false;
    jj_consume_token(IS);
    if(_log.isDebugEnabled()) { _log.debug("SqlIsClause: consumed \"" + token + "\""); }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case NOT:
      jj_consume_token(NOT);
     if(_log.isDebugEnabled()) { _log.debug("SqlIsClause: consumed \"" + token + "\""); }
     foundnot = true;
      break;
    default:
      ;
    }
    jj_consume_token(NULL);
     if(_log.isDebugEnabled()) { _log.debug("SqlIsClause: consumed \"" + token + "\""); }
     {if (true) return (foundnot ? ComparisonOperator.IS_NOT_NULL : ComparisonOperator.IS_NULL);}
    throw new Error("Missing return statement in function");
  }

  final public Selectable[] SqlBetweenClause() throws ParseException {
   Selectable[] pair = new Selectable[2];
    jj_consume_token(BETWEEN);
    if(_log.isDebugEnabled()) { _log.debug("SqlBetweenClause: consumed \"" + token + "\""); }
    pair[0] = SqlSumExprSelectable();
    jj_consume_token(AND);
    if(_log.isDebugEnabled()) { _log.debug("SqlBetweenClause: consumed \"" + token + "\""); }
    pair[1] = SqlSumExprSelectable();
    {if (true) return pair;}
    throw new Error("Missing return statement in function");
  }

  final private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_1();
  }

  final private boolean jj_2_2(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_2();
  }

  final private boolean jj_2_3(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_3();
  }

  final private boolean jj_2_4(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_4();
  }

  final private boolean jj_2_5(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_5();
  }

  final private boolean jj_2_6(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_6();
  }

  final private boolean jj_2_7(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_7();
  }

  final private boolean jj_2_8(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_8();
  }

  final private boolean jj_2_9(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_9();
  }

  final private boolean jj_2_10(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_10();
  }

  final private boolean jj_2_11(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    return !jj_3_11();
  }

  final private boolean jj_3R_35() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3_5()) {
    jj_scanpos = xsp;
    if (jj_3R_41()) {
    jj_scanpos = xsp;
    if (jj_3R_42()) {
    jj_scanpos = xsp;
    if (jj_3R_43()) {
    jj_scanpos = xsp;
    if (jj_3R_44()) {
    jj_scanpos = xsp;
    if (jj_3R_45()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_1() {
    if (jj_3R_19()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_8() {
    if (jj_scan_token(COMMA)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_28()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_27() {
    Token xsp;
    if (jj_3_8()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3_8()) { jj_scanpos = xsp; break; }
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    }
    return false;
  }

  final private boolean jj_3R_62() {
    if (jj_scan_token(BETWEEN)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_24()) return true;
    if (jj_la == 0 && jj_scanpos == jj_la