psql.java

High performance DB query

/* Generated By:JavaCC: Do not edit this line. PSQL.java */
package pier.parsers.PSQL;

import org.apache.log4j.Logger;
import pier.logical.*;
import pier.parsers.ParseException;
import pier.parsers.Parser;
import pier.parsers.SimpleCharStream;
import pier.parsers.Token;
import pier.parsers.TokenMgrError;
import services.Output;
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
import java.lang.reflect.Constructor;
import java.net.InetSocketAddress;
import util.logging.LogMessage;
import pier.query.QueryPlan;


public class PSQL implements Parser, PSQLConstants {
    private static Logger logger = Logger.getLogger(PSQL.class);
    private static final double OSLVersion = 1.01;
    private static final double minCompatibleOSLVersion = 1.00;
    private static final int ERROR_VERSION_OLD = 1;
    private static final int ERROR_VERSION_NEW = 2;
    private static final int ERROR_LITERAL_CREATION = 3;

    private int errorCode = 0;

    public QueryPlan parse(
            String language, double version, InetSocketAddress sourceSocketAddress, int sourceID)
            throws ParseException {
            if (Output.debuggingEnabled) {
                logger.debug(new LogMessage(
                                       new Object[]{"PSQL Version: ",
                                                    String.valueOf(OSLVersion),
                                                    " (Requested: ",
                                                    String.valueOf(version),
                                                    ")"}));
        }

        if (version < minCompatibleOSLVersion) {
            if (Output.debuggingEnabled) {
                logger.debug(new LogMessage(new Object[]{
                                           "Unable to parse old version"}));
            }

            errorCode = ERROR_VERSION_OLD;

            return null;
        }

        if (version > OSLVersion) {
            if (Output.debuggingEnabled) {
                logger.debug(new LogMessage(new Object[]{
                                           "Unable to parse new version"}));
            }

            errorCode = ERROR_VERSION_NEW;

            return null;
        }

        QueryBlock queryBlock = doInput();


        if (Output.debuggingEnabled) {
            logger.debug(new LogMessage(new Object[] {queryBlock}));
        }

        return null;
    }

    public int getErrorCode() {
        return errorCode;
    }

  final public QueryBlock doInput() throws ParseException {
        QueryBlock qblock;
    qblock = doSelectQuery();
    jj_consume_token(SEND);
    jj_consume_token(TO);
    doSendTo(qblock);
                                                         {if (true) return qblock;}
    throw new Error("Missing return statement in function");
  }

  final public QueryBlock doSelectQuery() throws ParseException {
        QueryBlock qblock = new QueryBlock();
    jj_consume_token(SELECT);
    doSelectList(qblock);
    jj_consume_token(FROM);
    doFromList(qblock);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case WHERE:
      jj_consume_token(WHERE);
      doWhereList(qblock);
      break;
    default:
      jj_la1[0] = jj_gen;
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case GROUP:
      jj_consume_token(GROUP);
      jj_consume_token(BY);
      doGroupByList(qblock);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case HAVING:
        jj_consume_token(HAVING);
        doHavingList(qblock);
        break;
      default:
        jj_la1[1] = jj_gen;
        ;
      }
      break;
    default:
      jj_la1[2] = jj_gen;
      ;
    }
      {if (true) return qblock;}
    throw new Error("Missing return statement in function");
  }

  final public void doSelectList(QueryBlock qblock) throws ParseException {
    doSelectionItem(qblock);
    label_1:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 27:
        ;
        break;
      default:
        jj_la1[3] = jj_gen;
        break label_1;
      }
      jj_consume_token(27);
      doSelectionItem(qblock);
    }
  }

  final public void doFromList(QueryBlock qblock) throws ParseException {
    doFromItem(qblock);
    label_2:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 27:
        ;
        break;
      default:
        jj_la1[4] = jj_gen;
        break label_2;
      }
      jj_consume_token(27);
      doFromItem(qblock);
    }
  }

  final public void doWhereList(QueryBlock qblock) throws ParseException {
        Set logicalClause;
    logicalClause = doLogicalClause();
                qblock.whereDef(logicalClause);
  }

  final public void doGroupByList(QueryBlock qblock) throws ParseException {
        Field attribute;
    attribute = doField();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 27:
      jj_consume_token(27);
      doGroupByList(qblock);
      break;
    default:
      jj_la1[5] = jj_gen;
      ;
    }
                qblock.groupByDef(attribute);
  }

  final public void doHavingList(QueryBlock qblock) throws ParseException {
        Set logicalClause;
    logicalClause = doLogicalClause();
                qblock.havingDef(logicalClause);
  }

  final public void doSendTo(QueryBlock qblock) throws ParseException {
    Token text;
    String host = "";
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IPADDRESS:
      text = jj_consume_token(IPADDRESS);
                        host=text.image;
      break;
    case WORD:
      text = jj_consume_token(WORD);
                        host += text.image;
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 28:
          ;
          break;
        default:
          jj_la1[6] = jj_gen;
          break label_3;
        }
        jj_consume_token(28);
        text = jj_consume_token(WORD);
                               host += "." + text.image;
      }
      break;
    default:
      jj_la1[7] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(29);
    text = jj_consume_token(NUMBER);
        int port = Integer.parseInt(text.image);
        qblock.sendToAddress(new InetSocketAddress(host, port));
  }

  final public Field doField() throws ParseException {
    Token source, attribute;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STAR:
      jj_consume_token(STAR);
                  {if (true) return Field.STAR;}
      break;
    case WORD:
      source = jj_consume_token(WORD);
      jj_consume_token(28);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
        jj_consume_token(STAR);
                          {if (true) return new Field(source.image);}
        break;
      case WORD:
        attribute = jj_consume_token(WORD);
                                    {if (true) return new Field(source.image, attribute.image);}
        break;
      default:
        jj_la1[8] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      jj_la1[9] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public Aggregation doAgg() throws ParseException {
    Field field;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case COUNT:
      jj_consume_token(COUNT);
      jj_consume_token(30);
      field = doField();
      jj_consume_token(31);
                                                  {if (true) return new Aggregation(Aggregation.COUNT, field);}
      break;
    case SUM:
      jj_consume_token(SUM);
      jj_consume_token(30);
      field = doField();
      jj_consume_token(31);
                                            {if (true) return new Aggregation(Aggregation.SUM, field);}
      break;
    case MAX:
      jj_consume_token(MAX);
      jj_consume_token(30);
      field = doField();
      jj_consume_token(31);
                                            {if (true) return new Aggregation(Aggregation.MAX, field);}
      break;
    case MIN:
      jj_consume_token(MIN);
      jj_consume_token(30);
      field = doField();
      jj_consume_token(31);
                                            {if (true) return new Aggregation(Aggregation.MIN, field);}
      break;
    case AVG:
      jj_consume_token(AVG);
      jj_consume_token(30);
      field = doField();
      jj_consume_token(31);
                                            {if (true) return new Aggregation(Aggregation.AVG, field);}
      break;
    default:
      jj_la1[10] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public void doSelectionItem(QueryBlock qblock) throws ParseException {
    Token rename=null, distinct=null;
    Field field;
    Aggregation agg;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case DISTINCT:
    case STAR:
    case WORD:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DISTINCT:
        distinct = jj_consume_token(DISTINCT);
        break;
      default:
        jj_la1[11] = jj_gen;
        ;
      }
      field = doField();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AS:
        jj_consume_token(AS);
        rename = jj_consume_token(WORD);
        break;
      default:
        jj_la1[12] = jj_gen;
        ;
      }
                qblock.selectDef(new Projection(field, ((rename == null) ? null : rename.image), distinct!=null));
      break;
    case COUNT:
    case SUM:
    case MIN:
    case MAX:
    case AVG:
      agg = doAgg();
                qblock.selectDef(agg);
      break;
    default:
      jj_la1[13] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void doFromItem(QueryBlock qblock) throws ParseException {
    Token text, as = null, url, format;
    Source source;
    QueryBlock subQuery;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case WORD:
      text = jj_consume_token(WORD);
                source = new Source(text.image);
                qblock.fromDef(source);
      break;
    case 30:
      jj_consume_token(30);
      subQuery = doSelectQuery();
      jj_consume_token(31);
      jj_consume_token(AS);
      as = jj_consume_token(WORD);
                subQuery.queryBlockName(as.image);
                qblock.fromDef(subQuery);
      break;
    case CSVPARSER:
      text = jj_consume_token(CSVPARSER);
      url = jj_consume_token(QUOTEDWORD);
      jj_consume_token(27);
      format = jj_consume_token(QUOTEDWORD);
      jj_consume_token(31);
      jj_consume_token(AS);
      as = jj_consume_token(WORD);
                source = new CSVSource(as.image, url.image.substring(1, url.image.length() - 1), format.image.substring(1, format.image.length() - 1));
                qblock.fromDef(source);
      break;
    default:
      jj_la1[14] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public Set doLogicalClause() throws ParseException {
        Set predSet=null;
    predSet = doLogicalDisjunction();
                                          {if (true) return predSet;}
    throw new Error("Missing return statement in function");
  }

  final public Set doLogicalSubClause() throws ParseException {
        Set predSet;
    jj_consume_token(30);
    predSet = doLogicalClause();
    jj_consume_token(31);
                                            {if (true) return predSet;}
    throw new Error("Missing return statement in function");
  }

  final public Set doLogicalConjunction() throws ParseException {
        Predicate p1=null, p2=null;
        Set predSet=null, lpredSet=null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 30:
      predSet = doLogicalSubClause();
      break;
    case COUNT:
    case SUM:
    case MIN:
    case MAX:
    case AVG:
    case STAR:
    case WORD:
      p1 = doPredicate();
                                predSet = new HashSet();
                                predSet.add(p1);
      break;
    default:
      jj_la1[15] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();