eqlparsergenericimpl.java

CRM源码This file describes some issues that should be implemented in future and how it should be imple

/*
 * Copyright 2006-2007 Queplix Corp.
 *
 * Licensed under the Queplix Public License, Version 1.1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.queplix.com/solutions/commercial-open-source/queplix-public-license/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

/* Generated By:JavaCC: Do not edit this line. EQLParserGenericImpl.java */
package com.queplix.core.modules.eql.parser.generic.jj;

import com.queplix.core.modules.eql.EQLObject;
import com.queplix.core.modules.eql.EQLReqOp;
import com.queplix.core.modules.eql.EQLReqSubOpMember;
import com.queplix.core.modules.eql.EQLReqSubOpMemberEnum;
import com.queplix.core.modules.eql.EQLReqSubOpMemberFunc;
import com.queplix.core.modules.eql.EQLReqSubOrder;
import com.queplix.core.modules.eql.EQLReqSubWhere;
import com.queplix.core.modules.eql.EQLReqSubWhereCond;
import com.queplix.core.modules.eql.EQLReqWhere;
import com.queplix.core.modules.eql.conds.EqCond;
import com.queplix.core.modules.eql.conds.GtCond;
import com.queplix.core.modules.eql.conds.GtEqCond;
import com.queplix.core.modules.eql.conds.InCond;
import com.queplix.core.modules.eql.conds.IsNotNullCond;
import com.queplix.core.modules.eql.conds.IsNullCond;
import com.queplix.core.modules.eql.conds.LikeCond;
import com.queplix.core.modules.eql.conds.LtCond;
import com.queplix.core.modules.eql.conds.LtEqCond;
import com.queplix.core.modules.eql.conds.NoneCond;
import com.queplix.core.modules.eql.conds.NotEqCond;
import com.queplix.core.modules.eql.conds.NotInCond;
import com.queplix.core.modules.eql.conds.NotLikeCond;
import com.queplix.core.modules.eql.error.EQLException;
import com.queplix.core.modules.eql.error.EQLParseException;
import com.queplix.core.modules.eql.ops.DivOp;
import com.queplix.core.modules.eql.ops.MinusOp;
import com.queplix.core.modules.eql.ops.MultOp;
import com.queplix.core.modules.eql.ops.NoneOp;
import com.queplix.core.modules.eql.ops.PlusOp;
import com.queplix.core.modules.eql.parser.generic.AbstractEQLParser;
import com.queplix.core.modules.eql.parser.generic.EQLIntMediator;
import com.queplix.core.modules.eql.utils.EQLUtils;

import java.io.CharArrayReader;

public class EQLParserGenericImpl extends AbstractEQLParser implements EQLParserGenericImplConstants {

  private EQLIntMediator mediator;
  private String eql;

  public EQLParserGenericImpl( EQLIntMediator mediator, String eql ) {
    this( new CharArrayReader(eql.toCharArray()) );
    this.mediator = mediator;
    this.eql = eql;
  }

  public void parse()
    throws EQLException {

    try {
      process( mediator );
    } catch (ParseException ex) {
      printError( ex.getMessage() );
      throw new EQLParseException( eql );
    }
  }

  public EQLReqOp parseSrc()
    throws EQLException {

    try {
      return op_attr( mediator );
    } catch (ParseException ex) {
      printError( ex.getMessage() );
      throw new EQLParseException( eql );
    }
  }

  public void parseWhere()
    throws EQLException {

    try {
      where_attr( mediator );
    } catch (ParseException ex) {
      printError( ex.getMessage() );
      throw new EQLParseException( eql );
    }
  }

  public void parseOrder()
    throws EQLException {

    try {
      order_attr( mediator, false );
    } catch (ParseException ex) {
      printError( ex.getMessage() );
      throw new EQLParseException( eql );
    }
  }

  public EQLIntMediator getMediator() {
    return mediator;
  }

//
// main process
//
  final public void process(EQLIntMediator mediator) throws ParseException, EQLException {
        Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SELECT:
      jj_consume_token(SELECT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 41:
        jj_consume_token(41);
        meta_attr(mediator);
        jj_consume_token(42);
        break;
      default:
        jj_la1[0] = jj_gen;
        ;
      }
      select_attr(mediator);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        where_attr(mediator);
        break;
      default:
        jj_la1[1] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ORDER:
        jj_consume_token(ORDER);
        jj_consume_token(BY);
        order_attr(mediator,true);
        break;
      default:
        jj_la1[2] = jj_gen;
        ;
      }
      break;
    case AGGREGATE:
      jj_consume_token(AGGREGATE);
      aggregate_func(mediator);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        where_attr(mediator);
        break;
      default:
        jj_la1[3] = jj_gen;
        ;
      }
      break;
    case NEW:
      jj_consume_token(NEW);
      t = jj_consume_token(ID);
      // select field default value
      mediator.addSelectColumnAsDefault( getReqFieldByFieldId(t.image) );
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 43:
        jj_consume_token(43);
        break;
      default:
        jj_la1[4] = jj_gen;
        ;
      }
      break;
    default:
      jj_la1[5] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

//
// begin parse query meta information
//
  final public void meta_attr(EQLIntMediator mediator) throws ParseException, EQLException {
        Token t1;
        Token t2;
    t1 = jj_consume_token(ID);
    jj_consume_token(EQ);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case TRUE:
      t2 = jj_consume_token(TRUE);
                  mediator.addMetaInfoAsBoolean(t1.image, Boolean.TRUE);
      break;
    case FALSE:
      t2 = jj_consume_token(FALSE);
                   mediator.addMetaInfoAsBoolean(t1.image, Boolean.FALSE);
      break;
    case NUMBER:
      t2 = jj_consume_token(NUMBER);
                    mediator.addMetaInfoAsNumber(t1.image, t2.image);
      break;
    case LIST:
      t2 = jj_consume_token(LIST);
                  mediator.addMetaInfoAsList(t1.image, t2.image);
      break;
    default:
      jj_la1[6] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 44:
      jj_consume_token(44);
      break;
    default:
      jj_la1[7] = jj_gen;
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ID:
      meta_attr(mediator);
      break;
    default:
      jj_la1[8] = jj_gen;
      ;
    }
  }

//
// begin parse select_clause
//
  final public void select_attr(EQLIntMediator mediator) throws ParseException, EQLException {
        Token t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SELECT_ALL_COLUMNS:
      t = jj_consume_token(SELECT_ALL_COLUMNS);
    // select all columns: "select entity.*"
    mediator.addSelectAllColumns( getTopLevelEntity(t.image) );
      break;
    case ID:
      t = jj_consume_token(ID);
    // select one column: "select entity.field"
    mediator.addSelectColumn( getReqFieldByFieldId(t.image) );
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 44:
        jj_consume_token(44);
        select_attr(mediator);
        break;
      default:
        jj_la1[9] = jj_gen;
        ;
      }
      break;
    default:
      jj_la1[10] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

//
// begin parse where_clause
//
  final public void where_attr(EQLIntMediator mediator) throws ParseException, EQLException {
    where_attr1(mediator, mediator.getEQLReq().getWhere(), EQLReqSubWhere.NONE_OP);
  }

//
// [(] where_clause [)]
//
  final public void where_attr1(EQLIntMediator mediator, EQLReqWhere parent, int where_op) throws ParseException, EQLException {
    if (jj_2_1(2147483647)) {
      where_attr2(mediator, parent, where_op);
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NULL:
      case PARAM:
      case NUMBER:
      case STRING:
      case ID:
      case LISTID:
      case FUNCTION:
      case 45:
        where_attr3(mediator, parent, where_op);
        break;
      default:
        jj_la1[11] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AND:
    case OR:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AND:
        jj_consume_token(AND);
              where_op = EQLReqSubWhere.AND_OP;
        break;
      case OR:
        jj_consume_token(OR);
             where_op = EQLReqSubWhere.OR_OP;
        break;
      default:
        jj_la1[12] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      where_attr1(mediator, parent, where_op);
      break;
    default:
      jj_la1[13] = jj_gen;
      ;
    }
  }

//
// ( where_clause )
//
  final public void where_attr2(EQLIntMediator mediator, EQLReqWhere parent, int where_op) throws ParseException, EQLException {
  EQLReqWhere next;
    jj_consume_token(45);
      next = mediator.addSubWhere( parent, where_op );
    where_attr1(mediator, next, EQLReqSubWhere.NONE_OP);
    jj_consume_token(46);
  }

//
// where_clause
//
  final public void where_attr3(EQLIntMediator mediator, EQLReqWhere parent, int where_op) throws ParseException, EQLException {
  EQLReqSubWhereCond subWhereCond = null;
  EQLReqOp leftMember;
  EQLReqOp rightMember;
    leftMember = op_attr(mediator);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IS:
    case IN:
    case NOT:
    case EQ:
    case NE:
    case GT:
    case LT:
    case GTEQ:
    case LTEQ:
    case LIKE:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IN:
      case NOT:
      case EQ:
      case NE:
      case GT:
      case LT:
      case GTEQ:
      case LTEQ:
      case LIKE:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case GTEQ:
          jj_consume_token(GTEQ);
          rightMember = op_attr(mediator);
          subWhereCond = new GtEqCond(leftMember,rightMember);
          break;
        case LTEQ:
          jj_consume_token(LTEQ);
          rightMember = op_attr(mediator);
          subWhereCond = new LtEqCond(leftMember,rightMember);
          break;
        case NE:
          jj_consume_token(NE);
          rightMember = op_attr(mediator);
          subWhereCond = new NotEqCond(leftMember,rightMember);
          break;
        case EQ:
          jj_consume_token(EQ);
          rightMember = op_attr(mediator);
          subWhereCond = new EqCond(leftMember,rightMember);
          break;
        case GT:
          jj_consume_token(GT);
          rightMember = op_attr(mediator);
          subWhereCond = new GtCond(leftMember,rightMember);
          break;
        case LT:
          jj_consume_token(LT);
          rightMember = op_attr(mediator);
          subWhereCond = new LtCond(leftMember,rightMember);
          break;
        case LIKE:
          jj_consume_token(LIKE);
          rightMember = op_attr(mediator);
          subWhereCond = new LikeCond(leftMember,rightMember);
          break;
        case IN:
          jj_consume_token(IN);
          rightMember = in_op_attr(mediator);
          subWhereCond = new InCond(leftMember,rightMember);
          break;
        case NOT:
          if (jj_2_2(2)) {
            jj_consume_token(NOT);
            jj_consume_token(LIKE);
            rightMember = op_attr(mediator);
            subWhereCond = new NotLikeCond(leftMember,rightMember);
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case NOT:
              jj_consume_token(NOT);
              jj_consume_token(IN);
              rightMember = in_op_attr(mediator);
            subWhereCond = new NotInCond(leftMember,rightMember);
              break;
            default:
              jj_la1[14] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
          break;
        default:
          jj_la1[15] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case IS:
        if (jj_2_3(2)) {
          jj_consume_token(IS);
          jj_consume_token(NULL);
        subWhereCond = new IsNullCond(leftMember);
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case IS:
            jj_consume_token(IS);
            jj_consume_token(NOT);
            jj_consume_token(NULL);
        subWhereCond = new IsNotNullCond(leftMember);
            break;
          default:
            jj_la1[16] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        break;
      default:
        jj_la1[17] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      jj_la1[18] = jj_gen;
      ;
    }
    mediator.addSubWhereCondition( parent, where_op, (subWhereCond == null) ? new NoneCond(leftMember) : subWhereCond );
  }

//
// order_clause
//
  final public void order_attr(EQLIntMediator mediator, boolean mandatory) throws ParseException, EQLException {
  Token t;
  int order_op = EQLReqSubOrder.ASC_OP;
    t = jj_consume_token(ID);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ASC:
    case DESC:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASC:
        jj_consume_token(ASC);
            order_op = EQLReqSubOrder.ASC_OP;
        break;
      case DESC:
        jj_consume_token(DESC);
             order_op = EQLReqSubOrder.DESC_OP;
        break;
      default:
        jj_la1[19] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      jj_la1[20] = jj_gen;
      ;
    }
    mediator.addSubOrder( getReqFieldByFieldId(t.image), order_op, mandatory );
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 44:
      jj_consume_token(44);
      order_attr(mediator,mandatory);
      break;
    default:
      jj_la1[21] = jj_gen;
      ;
    }
  }

//***********
// OPERATION
//***********

//
// begin operation
//
  final public EQLReqOp op_attr(EQLIntMediator mediator) throws ParseException, EQLException {
  EQLReqOp parent = new EQLReqOp();
  EQLReqSubOpMember subOpMember;
    subOpMember = op_attr1(mediator, parent);
    mediator.addSubOp( new NoneOp(subOpMember), parent );
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
    case MINUS:
    case DIV:
    case MULT:
      op_attr2(mediator,parent);
      break;
    default:
      jj_la1[22] = jj_gen;
      ;
    }
    {if (true) return parent;}
    throw new Error("Missing return statement in function");
  }

//
// [(] operation [)]
//
  final public EQLReqSubOpMember op_attr1(EQLIntMediator mediator, EQLReqOp parent) throws ParseException, EQLException {
  EQLReqSubOpMember subOpMember;
    if (jj_2_4(2)) {
      subOpMember = op_attr3(mediator);
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 45:
        subOpMember = op_attr4(mediator);
        break;
      default:
        jj_la1[23] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
    {if (true) return subOpMember;}
    throw new Error("Missing return statement in function");
  }

//
// {+|-|...) operation
//
  final public void op_attr2(EQLIntMediator mediator, EQLReqOp parent) throws ParseException, EQLException {
  EQLReqSubOpMember subOpMember;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
      jj_consume_token(PLUS);
      subOpMember = op_attr1(mediator,parent);
      mediator.addSubOp(new PlusOp(subOpMember),parent);
      break;
    case MINUS:
      jj_consume_token(MINUS);
      subOpMember = op_attr1(mediator,parent);
      mediator.addSubOp(new MinusOp(subOpMember),parent);
      break;
    case DIV:
      jj_consume_token(DIV);
      subOpMember = op_attr1(mediator,parent);
      mediator.addSubOp(new DivOp(subOpMember),parent);
      break;
    case MULT:
      jj_consume_token(MULT);
      subOpMember = op_attr1(mediator,parent);
      mediator.addSubOp(new MultOp(subOpMember),parent);
      break;
    default:
      jj_la1[24] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PLUS:
    case MINUS:
    case DIV:
    case MULT: