pierosl.jj

High performance DB query

options {
    LOOKAHEAD = 1;
    CHOICE_AMBIGUITY_CHECK = 1;
    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 = false;
    USER_TOKEN_MANAGER = false;
    USER_CHAR_STREAM = false;
    BUILD_PARSER = true;
    BUILD_TOKEN_MANAGER = true;
    SANITY_CHECK = true;
    FORCE_LA_CHECK = false;
    COMMON_TOKEN_ACTION = false;
    CACHE_TOKENS = true;
}

PARSER_BEGIN(PierOSL)

/*
 * @(#)$Id: PierOSL.jj,v 1.39 2005/07/18 04:03:36 huebsch Exp $
 *
 * Copyright (c) 2001-2003 Regents of the University of California.
 * All rights reserved.
 *
 * This file is distributed under the terms in the attached BERKELEY-LICENSE
 * file. If you do not find these files, copies can be found by writing to:
 * Computer Science Division, Database Group, Universite of California,
 * 617 Soda Hall #1776, Berkeley, CA 94720-1776. Attention: Berkeley License
 *
 * Copyright (c) 2003 Intel Corporation. All rights reserved.
 *
 * This file is distributed under the terms in the attached INTEL-LICENSE file.
 * If you do not find these files, copies can be found by writing to:
 * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300,
 * Berkeley, CA, 94704.  Attention:  Intel License Inquiry.
 */


package pier.parsers.PierOSL;

import java.lang.reflect.Constructor;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.HashMap;
import org.apache.log4j.Logger;
import pier.expressions.Expression;
import pier.expressions.ExpressionField;
import pier.expressions.ExpressionFunction;
import pier.expressions.ExpressionConstant;
import pier.operators.Bloom;
import pier.operators.Cache;
import pier.operators.DupElim;
import pier.operators.Eddy;
import pier.operators.FlowControl;
import pier.operators.Get;
import pier.operators.GroupBy;
import pier.operators.Join;
import pier.operators.Null;
import pier.operators.Operator;
import pier.operators.Projection;
import pier.operators.Put;
import pier.operators.Queue;
import pier.operators.Result;
import pier.operators.Scan;
import pier.operators.Selection;
import pier.operators.Tee;
import pier.operators.Union;
import pier.parsers.ParseException;
import pier.parsers.Parser;
import pier.parsers.SimpleCharStream;
import pier.parsers.Token;
import pier.parsers.TokenMgrError;
import pier.predicate.ConjunctivePredicateSet;
import pier.predicate.DisjunctivePredicateSet;
import pier.predicate.SimplePredicate;
import pier.predicate.SimplePredicateAtomic;
import pier.predicate.SimplePredicateSet;
import pier.query.OperatorGraph;
import pier.query.OperatorGraphEntry;
import pier.query.QueryPlan;
import pier.query.QueryTag;
import pier.query.PhysicalQueryPlan;
import services.Output;
import util.logging.LogMessage;

/**
 * Class PierOSL
 *
 */
public class PierOSL implements Parser {

    private static Logger logger = Logger.getLogger(PierOSL.class);
    private static final double OSLVersion = 1.19;
    private static final double minCompatibleOSLVersion = 1.14;
    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 PhysicalQueryPlan thePlan;
    private InetSocketAddress sourceSocketAddress;
    private int sourceID;
    private String queryNS;
    private int errorCode = 0;
    private int opGraphNum = 0;
    private int opNum;
    private int graphNum = 0;
    private OperatorGraph curGraph;
    private Operator curOp;
    private HashMap opLookup;
    private ArrayList children;
    private ArrayList parents;

    /**
     * Method parse
     *
     * @param language
     * @param version
     * @param sourceSocketAddress
     * @param sourceID
     * @return
     * @throws ParseException
     */
    public QueryPlan parse(
        String language, double version, InetSocketAddress sourceSocketAddress, int sourceID)
        throws ParseException {
	    if (Output.debuggingEnabled) {
		logger.debug(new LogMessage(
                           new Object[]{"Pier OSL 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;
        }

        this.sourceSocketAddress = sourceSocketAddress;
        this.sourceID = sourceID;
        thePlan = new PhysicalQueryPlan();

        doInput();

        return thePlan;
    }

    /**
     * Method makeTypedObject
     *
     * @param type
     * @param value
     * @return
     */
    Object makeTypedObject(String type, String value) {
        try {
            Class parameterTypes[] = new Class[1];

            parameterTypes[0] = Class.forName("java.lang.String");

            Class valueClass = Class.forName(type);
            Constructor valueConstructor =
            valueClass.getConstructor(parameterTypes);
            Object parameterValues[] = new Object[1];

            parameterValues[0] = value;

            return valueConstructor.newInstance(parameterValues);
        } catch (Exception e) {
	    if (Output.debuggingEnabled) {
		logger.debug(new LogMessage(new Object[]{
                       "Unable to create literal object"}));
            }

            errorCode = ERROR_LITERAL_CREATION;

            throw new RuntimeException(e.getClass() + " " + e.getMessage());
        }
    }

    /**
     * Method fixOpGraphLinks
     *
     * @param theGraph
     */
    public void fixOpGraphLinks(OperatorGraph theGraph) {
        fixOpGraphLinks(theGraph, true);
        fixOpGraphLinks(theGraph, false);
    }

    /**
     * Method fixOpGraphLinks
     *
     * @param theGraph
     * @param doChildren
     */
    public void fixOpGraphLinks(OperatorGraph theGraph, boolean doChildren) {
        ArrayList theLinks = doChildren
                     ? children
                     : parents;

        for (int i = 0; i < theGraph.numOperators(); i++) {
            OperatorGraphEntry entry = theGraph.getOperator(i);
            ArrayList opLinks = (ArrayList) theLinks.get(i);

            if (opLinks != null) {
                for (int j = 0; j < opLinks.size(); j++) {
                    String link = (String) opLinks.get(j);

                    if (link != null) {
                        Object lookupVal = opLookup.get(link);

                        if (lookupVal != null) {
                            int opNum = ((Integer) lookupVal).intValue();

                            if (doChildren) {
                                entry.setChild(j, opNum);
                            } else {
                                entry.setParent(j, opNum);
                            }
                        } else {
                            throw new RuntimeException(
                                "Invalid child/parent specification on operator "
                                + i + " and source " + link);
                        }
                    }
                }
            }
        }
    }
 }

PARSER_END(PierOSL)

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

<DEFAULT> TOKEN :
{
    <OPGRAPHSTART:"["                    > : OPGRAPHDEF
|    <END:        "#"                           >
}

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

<OPGRAPHDEF> TOKEN :
{
    <GRAPHSEP:    "#"                        >
|    <OPGRAPHEND:"]"                        > : DEFAULT
|    <OPSTART:    "["                        > : OPDEF
}

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

<OPDEF> TOKEN :
{
    <OPEND:        "]"                        > : OPGRAPHDEF
|    <OPSEP:        "#"                        >
}

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

<OPNAME> TOKEN:
{
    <BLOOM:        "B"    | "BLOOM"            > : OPDEF
|    <CACHE:        "C"    | "CACHE"            > : OPDEF
|    <DUPELIM:    "E"    | "DUPELIM"            > : OPDEF
|    <EDDY:        "Y"    | "EDDY"            > : OPDEF
|    <FLOW:        "O"    | "FLOW" | "FLOWCONTROL"> : OPDEF
|    <GET:        "F"    | "GET" | "FETCH"    > : OPDEF
|    <GROUPBY:    "G"    | "GROUPBY" | "GROUP"    > : OPDEF
|    <JOIN:        "J"    | "JOIN"            > : OPDEF
|    <NULL:        "N"    | "NULL"            > : OPDEF
|    <PROJECTION:    "P"    | "PROJECTION" | "SELECT"> : OPDEF
|    <QUEUE:        "Q"    | "QUEUE"            > : OPDEF
|    <PUT:        "R"    | "REHASH" | "PUT"    > : OPDEF
|    <RESULT:    "D"    | "RESULT" | "DELIVER"    > : OPDEF
|    <SCAN:        "S"    | "SCAN" | "FROM"    > : OPDEF
|    <SELECTION:    "W"    | "SELECTION" | "WHERE"    > : OPDEF
|    <TEE:        "T"    | "TEE"            > : OPDEF
|    <UNION:        "U"    | "UNION"            > : OPDEF
}

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

<PREDICATE> TOKEN :
{
    <PREDICATESTART:"{"                    >
|    <PREDICATEEND:    "}"                    >
|    <PREDICATESEP:    ","                    >
|   <PREDICATETYPEAND:  "AND"                   >
|   <PREDICATETYPEOR:   "OR"                    >
|   <PREDICATETYPEATOMIC: "ATOMIC"               >
}

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

<PREDICATEATOMIC> TOKEN :
{
    <COMPAREOP:    "=" | "!=" | "<>" | ">=" | ">" | "<=" | "<">
}

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

<EXPRESSION> TOKEN:
{
    <EXPRESSIONSTART:   "{"             >
|   <EXPRESSIONEND:     "}"             >
|   <EXPRESSIONSEP:     ","             >
|   <EXPRESSIONCONSTANT: "C" | "CONSTANT" >
|   <EXPRESSIONFIELD:   "F" | "FIELD"   >
|   <EXPRESSIONFUNCTION: "U" | "FUNCTION">
|   <EXPRESSIONCAST:    "::"            >
}

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

<HASHMAP> TOKEN:
{
    <HASHMAPEQ:    "="                        >
|    <HASHMAPSEP:","                        >
|    <HASHMAPEND:"#"                        >
}

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

<INETSOCKET> TOKEN:
{
    <PORTSEP:    ":"                        >
}

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

<ARRAYLIST> TOKEN:
{
    <ARRAYSTART:    "["                    >
|   <ARRAYEXPSTART: "{"                    >
|   <ARRAYSEP:      "|"                    >
|   <ARRAYEND:      "]"                    >
}



<LITERALS> TOKEN:
{
    <LITERALTEXT:    ( ~["\"", "\\"] )+        >
|    <LITERALESCAPE:    "\\"                > : LITERALESCAPES
|    <LITERALEND:    ~["\\"]                >
}

<LITERALESCAPES> TOKEN:
{
    <ESCAPEUNICODE:    "u" ["0"-"9","A"-"F","a"-"f"]
                ["0"-"9","A"-"F","a"-"f"]
                ["0"-"9","A"-"F","a"-"f"]
                ["0"-"9","A"-"F","a"-"f"]
                ("$")?                    > : LITERALS
|    <ESCAPEQID:    "qi" ("$")?                > : LITERALS
|    <ESCAPEQTAG:    "qt" ("$")?            > : LITERALS
|    <ESCAPEQADDR:    "qa" ("$")?            > : LITERALS
|    <ESCAPESLASH:    "\\" ("$")?            > : LITERALS
|    <ESCAPEQUOTE:    "\"$"                 > : LITERALS
|    <ESCAPENEWLINE:  "n" ("$")?                        > : LITERALS
}

<*>    TOKEN :
{
    <BASICTEXTCHARS: ( ["a"-"z", "A"-"Z"] |
                ["0"-"9", "."] |
                ["*", "-", "_", "/"] )+    >
|    <LITERALSTART:    "\""                >
|    <UNKNOWN:    ~[" "]                       >
}

void doInput() :
{
    QueryTag queryTag;
}
{
    { queryTag = new QueryTag(sourceSocketAddress, sourceID, (byte) 0); }
    { this.queryNS = queryTag.getQueryNS(); }
    (
    { graphNum++; }
    doOpGraph() )+ <END>
}

void doOpGraph() :
{
    String optionalRID = null;
    String ns = null, rid = null, graphName, duration;

    QueryTag queryTag;
}
{
    { opNum = 0; }
    { opLookup = new HashMap(); }
    { children = new ArrayList(); }
    { parents = new ArrayList(); }
    <OPGRAPHSTART> ( ns=doLiteralTextString() )? <GRAPHSEP> ( rid=doLiteralTextString() )? <GRAPHSEP> duration=doTextString() <GRAPHSEP> graphName=doLiteralTextString()
    { if (rid != null) optionalRID = rid; }
    { queryTag = new QueryTag(sourceSocketAddress, sourceID, (byte) graphNum); }
    { this.queryNS = queryTag.getQueryNS(); }
    { curGraph = new OperatorGraph(ns, optionalRID, Long.parseLong(duration), queryTag); }
    ( <OPSTART> doOperator() )* <OPGRAPHEND>
    { fixOpGraphLinks(curGraph); }
    { if (Output.debuggingEnabled) {logger.debug(new LogMessage(new Object[] {"Processed OpGraph: #", String.valueOf(opGraphNum), "\n", curGraph}));}}
    { thePlan.addOpGraph(curGraph); }
    { opGraphNum++; }
}

void doOperator() :
{
    String opname;
    HashMap opOptions = null;
    ArrayList opChildren = null;
    ArrayList opParents = null;
}
{
    opname=doTextString() <OPSEP>
    { token_source.SwitchTo(PierOSLConstants.OPNAME); }

    (( <BLOOM> <OPSEP> doOpBloom() ) |
    ( <CACHE> <OPSEP> doOpCache() ) |
    ( <DUPELIM> <OPSEP> doOpDupElim() ) |
    ( <EDDY> <OPSEP> doOpEddy() ) |
    ( <FLOW> <OPSEP> doOpFlowControl() ) |
    ( <GET> <OPSEP> doOpGet() ) |
    ( <GROUPBY> <OPSEP> doOpGroupBy() ) |
    ( <JOIN> <OPSEP> doOpJoin() ) |
    ( <NULL> <OPSEP> doOpNull() ) |
    ( <PROJECTION> <OPSEP> doOpProjection() ) |
    ( <PUT> <OPSEP> doOpPut() ) |
    ( <QUEUE> <OPSEP> doOpQueue() ) |
    ( <RESULT> <OPSEP> doOpResult() ) |
    ( <SCAN> <OPSEP> doOpScan() ) |
    ( <SELECTION> <OPSEP> doOpSelection() ) |
    ( <TEE> <OPSEP> doOpTee() ) |
    ( <UNION> <OPSEP> doOpUnion() ))

    <OPSEP> opOptions=doHashMap() opChildren = doStringArrayList()
        ( <OPSEP> opParents = doStringArrayList() )?