pierosl.java

High performance DB query

    opChildren = doStringArrayList();
    switch (jj_nt.kind) {
    case OPSEP:
      jj_consume_token(OPSEP);
      opParents = doStringArrayList();
      break;
    default:
      jj_la1[5] = jj_gen;
      ;
    }
          opLookup.put(opname, new Integer(opNum++));
          curOp.setQueryOptions(opOptions);
          children.add(opChildren);
          parents.add(opParents);
      curGraph.addOperator(curOp);
    jj_consume_token(OPEND);
  }

  final public void doOpBloom() throws ParseException {
    String type, sendNS, deliverNS, filterName;
    String sendRID = null;
    int executorNum = 0;
    type = doTextString();
    jj_consume_token(OPSEP);
    sendNS = doLiteralTextString();
    jj_consume_token(OPSEP);
    switch (jj_nt.kind) {
    case BASICTEXTCHARS:
    case LITERALSTART:
      sendRID = doLiteralTextString();
      break;
    default:
      jj_la1[6] = jj_gen;
      ;
    }
    jj_consume_token(OPSEP);
    deliverNS = doLiteralTextString();
    jj_consume_token(OPSEP);
    filterName = doLiteralTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BLOOMCOLLECTOR")) executorNum = Operator.SPEC_BLOOMCOLLECTOR;
      curOp = new Bloom(executorNum, sendNS, sendRID, deliverNS, filterName);
  }

  final public void doOpCache() throws ParseException {
    String type;
    int executorNum = 0;
    type = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("MEMCACHE")) executorNum = Operator.SPEC_MEMCACHE;
      if (type.equals("MEMUPDATECACHE")) executorNum = Operator.SPEC_MEMUPDATECACHE;
      curOp = new Cache(executorNum);
  }

  final public void doOpDupElim() throws ParseException {
    String type;
    int executorNum = 0;
    type = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.DUPELIM_BASIC;
      curOp = new DupElim(executorNum);
  }

  final public void doOpEddy() throws ParseException {
    String type, policy, pullSet, pullStream;;
    HashMap sourceMap, doneMap;
    int executorNum = 0;
    int routingPolicy = 0;
    type = doTextString();
    jj_consume_token(OPSEP);
    sourceMap = doHashMap();
    doneMap = doHashMap();
    policy = doTextString();
    jj_consume_token(OPSEP);
    pullSet = doTextString();
    jj_consume_token(OPSEP);
    pullStream = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.EDDY_BASIC;
      if (policy.equals("BASIC")) routingPolicy = Eddy.BASIC_ROUTING;
      if (policy.equals("RANDOM")) routingPolicy = Eddy.RANDOM_ROUTING;
      curOp = new Eddy(executorNum, sourceMap, doneMap, routingPolicy, Boolean.valueOf(pullSet).booleanValue(), Boolean.valueOf(pullStream).booleanValue());
  }

  final public void doOpFlowControl() throws ParseException {
    String type, pullSet, pullStream;
    int executorNum = 0;
    type = doTextString();
    jj_consume_token(OPSEP);
    pullSet = doTextString();
    jj_consume_token(OPSEP);
    pullStream = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.FLOWCONTROL_BASIC;
      curOp = new FlowControl(executorNum, Boolean.valueOf(pullSet).booleanValue(), Boolean.valueOf(pullStream).booleanValue());
  }

  final public void doOpGet() throws ParseException {
    String type, getNS;
    int executorNum = 0;
    type = doTextString();
    jj_consume_token(OPSEP);
    getNS = doLiteralTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.GET_BASIC;
      curOp = new Get(executorNum, getNS);
  }

  final public void doOpGroupBy() throws ParseException {
    String type, tableName, last;
    int executorNum = 0;
    ArrayList groupByExpressions, aggregateExpressions, aggregateOperations;
    type = doTextString();
    jj_consume_token(OPSEP);
    groupByExpressions = doExpressionArrayList();
    jj_consume_token(OPSEP);
    aggregateExpressions = doExpressionArrayList();
    jj_consume_token(OPSEP);
    aggregateOperations = convertAggOperators(doStringArrayList());
    jj_consume_token(OPSEP);
    tableName = doLiteralTextString();
    jj_consume_token(OPSEP);
    last = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.GROUPBY_BASIC;
      if (type.equals("DUAL")) executorNum = Operator.GROUPBY_DUAL;
      if (type.equals("LEARNED")) executorNum = Operator.GROUPBY_LEARNED;
      if (type.equals("TREE")) executorNum = Operator.GROUPBY_TREE;
      curOp = new GroupBy(executorNum, groupByExpressions, aggregateExpressions, aggregateOperations, tableName, Boolean.valueOf(last).booleanValue());
  }

  final public ArrayList convertAggOperators(ArrayList raw) throws ParseException {
    ArrayList converted = new ArrayList();
    for (int i=0; i<raw.size(); i++) {
        String curItem = (String) raw.get(i);
        if (curItem.compareToIgnoreCase("COUNT") == 0) converted.add(new Integer(GroupBy.AGG_COUNT));
        if (curItem.compareToIgnoreCase("SUM") == 0) converted.add(new Integer(GroupBy.AGG_SUM));
        if (curItem.compareToIgnoreCase("MAX") == 0) converted.add(new Integer(GroupBy.AGG_MAX));
        if (curItem.compareToIgnoreCase("MIN") == 0) converted.add(new Integer(GroupBy.AGG_MIN));
        if (curItem.compareToIgnoreCase("AVG") == 0) converted.add(new Integer(GroupBy.AGG_AVG));
        if (curItem.compareToIgnoreCase("CONCAT") == 0) converted.add(new Integer(GroupBy.AGG_CONCAT));
    }
      {if (true) return converted;}
    throw new Error("Missing return statement in function");
  }

  final public void doOpJoin() throws ParseException {
    String type, resultTableName;
    int executorNum = 0;
    SimplePredicateAtomic joinPredicate;
    type = doTextString();
    jj_consume_token(OPSEP);
    joinPredicate = doSimplePredicateAtomic();
    jj_consume_token(OPSEP);
    resultTableName = doLiteralTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("SYMMETRICHASH")) executorNum = Operator.JOIN_SYMMETRICHASH;
      if (type.equals("INDEX")) executorNum = Operator.JOIN_INDEX;
      curOp = new Join(executorNum, joinPredicate, resultTableName);
  }

  final public void doOpNull() throws ParseException {
    String type;
    int executorNum = 0;
    type = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      curOp = new Null(executorNum);
  }

  final public void doOpProjection() throws ParseException {
    String type, tableName;
    int executorNum = 0;
    ArrayList expressionList, renameList = null;
    type = doTextString();
    jj_consume_token(OPSEP);
    expressionList = doExpressionArrayList();
    jj_consume_token(OPSEP);
    renameList = doStringArrayList();
    jj_consume_token(OPSEP);
    tableName = doLiteralTextString();
    jj_consume_token(OPSEP);
    switch (jj_nt.kind) {
    case BASICTEXTCHARS:
    case LITERALSTART:
      doLiteralTextString();
      break;
    default:
      jj_la1[7] = jj_gen;
      ;
    }
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.PROJECT_BASIC;
      if (type.equals("NEW")) executorNum = Operator.PROJECT_NEW;
      if ((renameList != null) && (renameList.size() != expressionList.size())) renameList = null;
      curOp = new Projection(executorNum, expressionList, renameList, tableName);
  }

  final public void doOpPut() throws ParseException {
    String type, putNS;
    int executorNum = 0;
    ArrayList expressionList;
    type = doTextString();
    jj_consume_token(OPSEP);
    putNS = doLiteralTextString();
    jj_consume_token(OPSEP);
    expressionList = doExpressionArrayList();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.PUT_BASIC;
      if (type.equals("DHT")) executorNum = Operator.PUT_DHT;
      if (type.equals("EDDY")) executorNum = Operator.PUT_EDDY;
      if (type.equals("BLOOM")) executorNum = Operator.PUT_BLOOM;
      if (type.equals("DHTMESSAGE")) executorNum = Operator.PUT_DHTMESSAGE;
      if (type.equals("IP")) executorNum = Operator.PUT_IP;
      if (type.equals("TREE")) executorNum = Operator.PUT_TREE;
      curOp = new Put(executorNum, putNS, expressionList);
  }

  final public void doOpQueue() throws ParseException {
    String type;
    int executorNum = 0;
    type = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.QUEUE_BASIC;
      curOp = new Queue(executorNum);
  }

  final public void doOpResult() throws ParseException {
    String type, batching, queryID;
    int executorNum = 0;
    InetSocketAddress destination;
    type = doTextString();
    jj_consume_token(OPSEP);
    destination = doInetSocketAddress();
    jj_consume_token(OPSEP);
    batching = doTextString();
    jj_consume_token(OPSEP);
    queryID = doLiteralTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("NETSEND")) executorNum = Operator.RESULT_NETSEND;
      curOp = new Result(executorNum, destination, Integer.parseInt(batching), Integer.parseInt(queryID));
  }

  final public void doOpScan() throws ParseException {
    String type, sourceTable;
    int executorNum = 0;
    type = doTextString();
    jj_consume_token(OPSEP);
    sourceTable = doLiteralTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("DHT")) executorNum = Operator.SCAN_DHT;
      if (type.equals("JDBC")) executorNum = Operator.SCAN_JDBC;
      if (type.equals("GANGLIA")) executorNum = Operator.SCAN_GANGLIA;
      if (type.equals("DHTMESSAGE")) executorNum = Operator.SCAN_DHTMESSAGE;
      if (type.equals("CSV")) executorNum = Operator.SCAN_CSV;
      if (type.equals("PLSENSOR")) executorNum = Operator.SCAN_CSV;
      if (type.equals("IP")) executorNum = Operator.SCAN_IP;
      if (type.equals("TREE")) executorNum = Operator.SCAN_TREE;
      curOp = new Scan(executorNum, sourceTable);
  }

  final public void doOpSelection() throws ParseException {
    String type;
    int executorNum = 0;
    SimplePredicate predicate;
    type = doTextString();
    jj_consume_token(OPSEP);
    predicate = doSimplePredicate();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.SELECT_BASIC;
      curOp = new Selection(executorNum, predicate);
  }

  final public void doOpTee() throws ParseException {
    String type;
    int executorNum = 0;
    type = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.TEE_BASIC;
      curOp = new Tee(executorNum);
  }

  final public void doOpUnion() throws ParseException {
    String type;
    int executorNum = 0;
    type = doTextString();
      if (type.equals("DYNAMIC")) executorNum = Operator.DYNAMIC_LOADER;
      if (type.equals("BASIC")) executorNum = Operator.UNION_BASIC;
      curOp = new Union(executorNum);
  }

  final public HashMap doHashMap() throws ParseException {
    String option;
    Expression value;
    int curState;
    HashMap theHashMap;
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.HASHMAP);
      theHashMap = new HashMap();
    switch (jj_nt.kind) {
    case BASICTEXTCHARS:
    case LITERALSTART:
      option = doLiteralTextString();
      jj_consume_token(HASHMAPEQ);
      value = doExpression(false);
      theHashMap.put(option, value);
      label_3:
      while (true) {
        switch (jj_nt.kind) {
        case HASHMAPSEP:
          ;
          break;
        default:
          jj_la1[8] = jj_gen;
          break label_3;
        }
        jj_consume_token(HASHMAPSEP);
        option = doLiteralTextString();
        jj_consume_token(HASHMAPEQ);
        value = doExpression(false);
      theHashMap.put(option, value);
      }
      break;
    default:
      jj_la1[9] = jj_gen;
      ;
    }
    jj_consume_token(HASHMAPEND);
      token_source.SwitchTo(curState);
      {if (true) return theHashMap;}
    throw new Error("Missing return statement in function");
  }

  final public SimplePredicate doSimplePredicate() throws ParseException {
    SimplePredicate predicate;
    int curState;
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.PREDICATE);
    jj_consume_token(PREDICATESTART);
    switch (jj_nt.kind) {
    case PREDICATETYPEAND:
      jj_consume_token(PREDICATETYPEAND);
      predicate = doSimplePredicates(new ConjunctivePredicateSet());
      break;
    case PREDICATETYPEOR:
      jj_consume_token(PREDICATETYPEOR);
      predicate = doSimplePredicates(new DisjunctivePredicateSet());
      break;
    case PREDICATETYPEATOMIC:
      jj_consume_token(PREDICATETYPEATOMIC);
      jj_consume_token(PREDICATESEP);
      predicate = doSimplePredicateAtomic();
      break;
    default:
      jj_la1[10] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(PREDICATEEND);
      token_source.SwitchTo(curState);
      {if (true) return predicate;}
    throw new Error("Missing return statement in function");
  }

  final public SimplePredicate doSimplePredicates(SimplePredicateSet predicateSet) throws ParseException {
    SimplePredicate predicate;
    label_4:
    while (true) {
      jj_consume_token(PREDICATESEP);
      predicate = doSimplePredicate();
      predicateSet.addPredicate(predicate);
      switch (jj_nt.kind) {
      case PREDICATESEP:
        ;
        break;
      default:
        jj_la1[11] = jj_gen;
        break label_4;
      }
    }
      {if (true) return predicateSet;}
    throw new Error("Missing return statement in function");
  }

  final public SimplePredicateAtomic doSimplePredicateAtomic() throws ParseException {
    Expression leftExpression, rightExpression;
    SimplePredicateAtomic predicate;
    byte op;
    int curState;
      curState = token_source.curLexState;
      token_source.SwitchTo(PierOSLConstants.PREDICATEATOMIC);
    leftExpression = doExpression(false);
    op = doPredicateOp();
    rightExpression = doExpression(false);
      predicate = new SimplePredicateAtomic(leftExpression, rightExpression, op);
      token_source.SwitchTo(curState);
      {if (true) return predicate;}
    throw new Error("Missing return statement in function");
  }

  final public byte doPredicateOp() throws ParseException {
    Token op;
    op = jj_consume_token(COMPAREOP);
      if (op.image.equals("=")) {if (true) return 1;}
      if (op.image.equals("!=")) {if (true) return -1;}
      if (op.image.equals("<>")) {if (true) return -1;}
      if (op.image.equals(">")) {if (true) return -3;}
      if (op.image.equals(">=")) {if (true) return -2;}
      if (op.image.equals("<")) {if (true) return 2;}
      if (op.image.equals("<=")) {if (true) return 3;}