psql.jj

High performance DB query

options {
        LOOKAHEAD = 1;
        CHOICE_AMBIGUITY_CHECK = 2;
        OTHER_AMBIGUITY_CHECK = 1;
        STATIC = false;
        DEBUG_PARSER = false;
        DEBUG_LOOKAHEAD = false;
        DEBUG_TOKEN_MANAGER = false;
        OPTIMIZE_TOKEN_MANAGER = true;
        ERROR_REPORTING = true;
        JAVA_UNICODE_ESCAPE = false;
        UNICODE_INPUT = false;
        IGNORE_CASE = true;
        USER_TOKEN_MANAGER = false;
        USER_CHAR_STREAM = false;
        BUILD_PARSER = true;
        BUILD_TOKEN_MANAGER = true;
        SANITY_CHECK = true;
        FORCE_LA_CHECK = true;
        COMMON_TOKEN_ACTION = false;
        CACHE_TOKENS = false;
}

PARSER_BEGIN(PSQL)
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 {
    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;
    }

}

PARSER_END(PSQL)

TOKEN :
{
    <SELECT:        "SELECT">
|   <FROM:          "FROM">
|   <WHERE:         "WHERE">
|   <GROUP:         "GROUP">
|   <BY:            "BY">
|   <HAVING:        "HAVING">
|   <AS:            "AS">
|   <AND:           "AND">
|   <OR:            "OR">
|   <SEND:          "SEND">
|   <TO:            "TO">
|   <DISTINCT:      "DISTINCT">
|	<COUNT:         "COUNT">
|	<SUM:           "SUM">
|   <MIN:           "MIN">
|	<MAX:           "MAX">
|	<AVG:           "AVG">
|   <CAST:          "::">
|   <CSVPARSER:     "CSVParser(">
|	<STAR:          "*">
|   <WORD:          ["a"-"z","A"-"Z"](["a"-"z","A"-"Z","_","0"-"9"])*>
|   <QUOTEDWORD:    "\"" (["#"-"[", "]"-"~", "!", " "])* "\"">
|   <NUMBER:        ((["0"-"9"])* ".")? (["0"-"9"])+>
|   <IPADDRESS:     (["0"-"9"])+ "." (["0"-"9"])+ "." (["0"-"9"])+ "." (["0"-"9"])+>
|   <COMPAREOP:         "=" | "!=" | "<>" | ">=" | ">" | "<=" | "<">
}

SKIP :
{
    <" " | "\t" | "\n" | "\r">
}

QueryBlock doInput() :
{
	QueryBlock qblock;
}
{
    qblock=doSelectQuery() <SEND><TO> doSendTo(qblock) { return qblock; }
}

QueryBlock doSelectQuery() :
{
	QueryBlock qblock = new QueryBlock();
}
{
    <SELECT> doSelectList(qblock)
    <FROM> doFromList(qblock)
    (<WHERE> doWhereList(qblock))?
    (<GROUP><BY> doGroupByList(qblock)
        (<HAVING> doHavingList(qblock))?)?
    { return qblock; }
}

void doSelectList(QueryBlock qblock) :
{}
{
    (doSelectionItem(qblock) ("," doSelectionItem(qblock))*)
}

void doFromList(QueryBlock qblock) :
{}
{
    doFromItem(qblock) ("," doFromItem(qblock))*
}

void doWhereList(QueryBlock qblock) :
{
	Set logicalClause;
}
{
	logicalClause=doLogicalClause() {
		qblock.whereDef(logicalClause);
	}
}

void doGroupByList(QueryBlock qblock) :
{
	Field attribute;
}
{
    attribute=doField() ("," doGroupByList(qblock))? {
    		qblock.groupByDef(attribute);
    }
}

void doHavingList(QueryBlock qblock) :
{
	Set logicalClause;
}
{
	logicalClause=doLogicalClause() {
		qblock.havingDef(logicalClause);
	}
}

void doSendTo(QueryBlock qblock) :
{
    Token text;
    String host = "";
}
{
    ((text=<IPADDRESS> {host=text.image;})
       | (text=<WORD> { host += text.image; }
            ("." text=<WORD> { host += "." + text.image; })*))
    ":"
    text=<NUMBER>
    {
        int port = Integer.parseInt(text.image);
        qblock.sendToAddress(new InetSocketAddress(host, port));
    }
}

Field doField() :
{
    Token source, attribute;
}
{
	<STAR> 	{ return Field.STAR; 	}
	|
	source=<WORD> "." (
		(<STAR> { return new Field(source.image); })
		|
		(attribute=<WORD> { return new Field(source.image, attribute.image); })
	)
}

Aggregation doAgg() :
{
    Field field;
}
{
	(<COUNT> "(" field=doField() ")")	{ return new Aggregation(Aggregation.COUNT, field); }
	|
	(<SUM>   "(" field=doField() ")") { return new Aggregation(Aggregation.SUM, field); }
	|
	(<MAX>   "(" field=doField() ")") { return new Aggregation(Aggregation.MAX, field); }
	|
	(<MIN>   "(" field=doField() ")") { return new Aggregation(Aggregation.MIN, field); }
	|
	(<AVG>   "(" field=doField() ")") { return new Aggregation(Aggregation.AVG, field); }
}


void doSelectionItem(QueryBlock qblock) :
{
    Token rename=null, distinct=null;
    Field field;
    Aggregation agg;
}
{
    (distinct=<DISTINCT>)? field=doField() (<AS> rename=<WORD>)? {
		qblock.selectDef(new Projection(field, ((rename == null) ? null : rename.image), distinct!=null));
    }
    |
    agg=doAgg() {
    		qblock.selectDef(agg);
    	}
}


void doFromItem(QueryBlock qblock) :
{
    Token text, as = null, url, format;
    Source source;
    QueryBlock subQuery;
}
{
	text=<WORD> {
		source = new Source(text.image);
		qblock.fromDef(source);
	}
    |
    "(" subQuery=doSelectQuery() ")" <AS> as=<WORD> {
    		subQuery.queryBlockName(as.image);
    		qblock.fromDef(subQuery);
    }
    |
	text=<CSVPARSER> url=<QUOTEDWORD> "," format=<QUOTEDWORD> ")" <AS> as=<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);
	}
}

Set doLogicalClause() :
{
	Set predSet=null;
}
{
	(predSet=doLogicalDisjunction()) {return predSet; }
}


Set doLogicalSubClause() :
{
	Set predSet;
}
{
	"(" predSet=doLogicalClause() ")" { return predSet; }
}

Set doLogicalConjunction() :
{
	Predicate p1=null, p2=null;
	Set predSet=null, lpredSet=null;
}
{
	(
		(predSet=doLogicalSubClause()
		|
	 	p1=doPredicate() {
				predSet = new HashSet();
				predSet.add(p1);
	 		}
	 	)
		(<AND>
			(lpredSet=doLogicalSubClause() {
				if (lpredSet instanceof DisjunctiveSet) {
					predSet.add(lpredSet);
				} else predSet.addAll(lpredSet);
			}
			|
			p2=doPredicate() {
				if (predSet instanceof ConjunctiveSet) {
					predSet.add(p2);
				}
				else {
					ConjunctiveSet cs = new ConjunctiveSet();

					if (predSet instanceof DisjunctiveSet) cs.add(predSet);
					else cs.addAll(predSet);

					cs.add(p2);
					predSet = cs;
				}
			})
		)*
	) { return predSet; }
}

Set doLogicalDisjunction() :
{
	Set lhs=null, rhs=null;
}
{
	lhs=doLogicalConjunction() (<OR> rhs=doLogicalConjunction())* {
		if (rhs == null) {
			return lhs;
		}
		else {
			if (lhs instanceof DisjunctiveSet || lhs instanceof ConjunctiveSet) {
				// HACK: Ensure that rhs holds a Set type, unless both lhs and rhs are predicates.
				Set tmp = rhs;
				rhs = lhs;
				lhs = tmp;
			}

			if (rhs instanceof DisjunctiveSet) {
				if (lhs instanceof ConjunctiveSet) {
					ConjunctiveSet pushedConjunction = new ConjunctiveSet();
					for (Iterator iter = lhs.iterator(); iter.hasNext(); ) {
						Object element = iter.next();
						if (element instanceof Predicate) {
							DisjunctiveSet ds = new DisjunctiveSet();
							ds.addAll(rhs);
							ds.add(element);
							pushedConjunction.add(ds);
						}
						else if (element instanceof DisjunctiveSet) {
							((DisjunctiveSet)element).addAll(rhs);
							pushedConjunction.add(element);
						}
					}
					return pushedConjunction;
				}
				else if (lhs instanceof DisjunctiveSet) {
					lhs.addAll(rhs);
					return lhs;
				}
				else {
					rhs.addAll(lhs);
					return rhs;
				}
			}
			else if (rhs instanceof ConjunctiveSet) {
				ConjunctiveSet pushedConjunction = new ConjunctiveSet();
				if (!(lhs instanceof ConjunctiveSet)) {
					for (Iterator iter = rhs.iterator(); iter.hasNext(); ) {
						Object element = iter.next();
						if (element instanceof Predicate) {
							DisjunctiveSet ds = new DisjunctiveSet();
							ds.add(element);
							ds.addAll(lhs);
							pushedConjunction.add(ds);
						}
						else if (element instanceof DisjunctiveSet) {
							((DisjunctiveSet)element).addAll(lhs);
							pushedConjunction.add(element);
						}
						else {
							throw new ParseException("doLogicalDisjunction: Bad left hand side element.");
						}
					}
				}
				else {
					for (Iterator riter = rhs.iterator(); riter.hasNext(); ) {
						Object relement = riter.next();
						assert(!(relement instanceof ConjunctiveSet));
						for (Iterator liter = lhs.iterator(); liter.hasNext(); ) {
							Object    lelement = liter.next();
							DisjunctiveSet ds = new DisjunctiveSet();

							assert(!(lelement instanceof ConjunctiveSet));

							if (relement instanceof DisjunctiveSet) ds.addAll((Set)relement);
							else ds.add(relement);
							if (lelement instanceof DisjunctiveSet) ds.addAll((Set)lelement);
							else ds.add(lelement);

							pushedConjunction.add(ds);
						}
					}
				}
				return pushedConjunction;
			}
			else {
				// Case: Both lhs and rhs are singleton predicates, create disjunction.
				DisjunctiveSet disjunction = new DisjunctiveSet();
				disjunction.addAll(lhs);
				disjunction.addAll(rhs);
				return disjunction;
			}
		}
	}
}


Predicate doPredicate() :
{
    Token text, op;
    Object LHS;
    Object RHS;
    byte opInt;
    String cast = null;
}
{
    (LHS=doField() | LHS=doAgg())
    op=<COMPAREOP>
    (
		RHS=doField()
     	|
     	RHS=doAgg()
     	|
     	text=<NUMBER> ("::" cast=doJavaClass())? {
			if (cast == null) { //use a default cast of Integer or Double
				if (text.image.indexOf(".") == -1) {
					cast = "java.lang.Integer";
				} else {
					cast = "java.lang.Double";
				}
			}

			try {
				Class parameterTypes[] = new Class[] { String.class };
				Constructor valueConstructor = Class.forName(cast).getConstructor(parameterTypes);
				Object parameterValues[] = new Object[] { text.image };
				RHS = valueConstructor.newInstance(parameterValues);
			} catch (Exception e) {
				throw new ParseException("Unable to cast " + text.image + " to " + cast);
			}
		}
		|
		text=<QUOTEDWORD> {
			RHS=text.image.substring(1, text.image.length() - 1);
		}
	) {
        if (op.image.equals("=")) {
            opInt = Predicate.EQUAL;
        } else if (op.image.equals("!=") || op.image.equals("<>")) {
            opInt = Predicate.NOTEQUAL;
        } else if (op.image.equals(">=")) {
            opInt = Predicate.GREATERTHANEQUAL;
        } else if (op.image.equals(">")) {
            opInt = Predicate.GREATERTHAN;
        } else if (op.image.equals("<=")) {
            opInt = Predicate.LESSTHANEQUAL;
        } else if (op.image.equals("<")) {
            opInt = Predicate.LESSTHAN;
        } else {
            throw new ParseException("Illegal predicate operation: " + op.image);
        }

        return new Predicate(LHS, opInt, RHS); }
}

String doJavaClass() :
{
    String result;
    Token text;
}
{
    text=<WORD> { result = text.image; }
    ("." text=<WORD> { result += "." + text.image; })*
    { return result; }
}