EjbqlQueryTreeHolder.java

package org.objectweb.jonas_ejb.lib;

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

import org.objectweb.jonas_ejb.container.TraceEjb;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDescEjb2;
import org.objectweb.jonas_ejb.deployment.api.EntityCmp2Desc;
import org.objectweb.jonas_ejb.deployment.api.MethodCmp2Desc;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTEJBQL;
import org.objectweb.jorm.api.PMapper;
import org.objectweb.jorm.metainfo.api.Manager;
import org.objectweb.medor.api.Field;
import org.objectweb.medor.eval.api.QueryEvaluator;
import org.objectweb.medor.eval.lib.MedorEvaluator;
import org.objectweb.medor.expression.api.Expression;
import org.objectweb.medor.optim.api.QueryTransformer;
import org.objectweb.medor.query.api.OrderField;
import org.objectweb.medor.query.api.QueryTree;
import org.objectweb.medor.query.api.QueryTreeField;
import org.objectweb.medor.query.jorm.api.JormExtent;
import org.objectweb.medor.query.jorm.lib.ClassExtent;
import org.objectweb.medor.query.jorm.lib.JormQueryTreeHelper;
import org.objectweb.medor.query.jorm.lib.QueryBuilder;
import org.objectweb.medor.query.lib.QueryTreePrinter;
import org.objectweb.medor.query.lib.SelectProject;
import org.objectweb.util.monolog.api.BasicLevel;


public class EjbqlQueryTreeHolder {

    QueryTree queryTree = null;
    QueryTransformer queryOptimizer = null;
    QueryEvaluator optimizedQuery = null;
    Field resField = null;
    EjbqlLimiterRange[] limiterRanges = null;

    private String beanName;
    private String methodName;

    private int prefetchIdentifierIndex;


    public EjbqlQueryTreeHolder(MethodCmp2Desc mDesc, ASTEJBQL ejbql, PMapper mapper)
            throws Exception {

        EntityCmp2Desc eDesc = (EntityCmp2Desc) mDesc.getBeanDesc();
        DeploymentDescEjb2 dd = (DeploymentDescEjb2) eDesc.getDeploymentDesc();
        Manager jormManager = dd.getJormManager();

        // create identifiers Map (visit ALL the query)
        QueryBuilder qb = new QueryBuilder();
        Map fields = (new EjbqlVariableVisitor(ejbql, dd, qb)).getFields();

        // Begin PREFETCHING CODE (by Seb)
        SelectProject sp = new SelectProject("");
        if (mDesc.getPrefetch() && (mapper != null)) {
            // Find the QueryTree of the ClassExtend of the bean of the current finder method
            // WARNING: This only works for finder methods, and not for ejbSelect methods!!!
            //          (Indeed the result type of the query must be the bean type in which
            //           the method is defined)
            ClassExtent ce = null;
            QueryTree qt = null;
            String jormClassName = ((EntityCmp2Desc) mDesc.getBeanDesc()).getJormClassName();
            Iterator itFields = fields.values().iterator();
            boolean found = false;
            while (itFields.hasNext() && !found) {
                QueryTree cqt = ((QueryTreeField) itFields.next()).getQueryTree();
                Collection extents = JormQueryTreeHelper.getJormExtents(cqt);
                for (Iterator it = extents.iterator(); it.hasNext() && !found;) {
                    JormExtent je = (JormExtent) it.next();
                    if (jormClassName.equals(je.getJormName())) {
                        found = true;
                        ce = (ClassExtent) je;
                        qt = cqt;
                    }
                }
            }
            if ((ce == null) && (qt == null)) {
                throw new Error("EjbqlQueryTreeHolder: cannot do the prefetch !!!");
            }
            setMapper(qt, mapper);
            // Add fields of the class which the values must be prefetched, at
            // the begin of the the TupleCollection
            JormQueryTreeHelper.addPrefetchFields(ce, qt, sp);
            prefetchIdentifierIndex = sp.getTupleStructure().getSize() + 1;
        }
        // End PREFETCHING CODE

        // create SelectProject (visit the SELECT clause)
        EjbqlSelectVisitor selectVisitor = new EjbqlSelectVisitor(ejbql, fields, sp);

        // create the Filter's expression (visit the WHERE clause)
        Expression qf = new EjbqlQueryFilterVisitor
            (mapper, fields, mDesc.getMethod().getParameterTypes(), ejbql, qb).getQueryFilter();
        sp.setQueryFilter(qf);

        // create the OrderField list (visit the ORDER BY clause)
        OrderField[] ofs = new EjbqlOrderByVisitor(ejbql, fields).getOrderFields();
        if (ofs.length > 0) {
            sp.setOrderBy(ofs);
        }

        // create the EjbqlLimiterRange list (visit the LIMIT clause)
        limiterRanges = new EjbqlLimitVisitor(ejbql, mDesc.getMethod().getParameterTypes()).getLimiterRanges();

        queryTree = selectVisitor.getQueryTree();

        setMapper(queryTree, mapper);

        // Get the field description of the result of the query
        // Nota Bene: TupleStructures of queries non optimized and optimized are differents.
        resField = queryTree.getTupleStructure().getField(queryTree.getTupleStructure().getSize());

        // Just needed later for debug trace
        beanName = eDesc.getJormClassName();
        methodName = mDesc.getMethod().getName();
    }

    private void setMapper(QueryTree tree, PMapper mapper) {
        // set the mapper of each leaves of the QueryTree
        if (mapper != null) {
            Collection extents = JormQueryTreeHelper.getJormExtents(tree);
            for (Iterator it = extents.iterator(); it.hasNext();) {
                JormExtent je = (JormExtent) it.next();
                je.setPMapper(mapper, RdbMappingBuilder.getProjectName());
            }
        }
    }

    public int getPrefetchIndex() {
        return prefetchIdentifierIndex;
    }

    public QueryTree getQueryTree() {
        return queryTree;
    }

    public void setQueryOptimizer(QueryTransformer qtf) {
        optimizedQuery = null;
        queryOptimizer = qtf;
    }

    public QueryTransformer getQueryOptimizer() {
        return queryOptimizer;
    }

    public Field getResField() {
        return resField;
    }
    public EjbqlLimiterRange[] getLimiterRanges() {
        return limiterRanges;
    }

    public QueryEvaluator getOptimizedQueryTree() throws Exception {
        if (optimizedQuery == null) {
            if (TraceEjb.isDebugQuery()) {
                TraceEjb.query.log(BasicLevel.DEBUG,
                                   "Initial QueryTree of the method " + methodName
                                   + " of the bean " + beanName);
                QueryTreePrinter.printQueryTree(queryTree, TraceEjb.query, BasicLevel.DEBUG);
            }
            QueryTree qt = queryOptimizer.transform(queryTree);
            if (TraceEjb.isDebugQuery()) {
                TraceEjb.query.log(BasicLevel.DEBUG,
                                   "Optimized QueryTree of the method " + methodName
                                   + " of the bean " + beanName);
                QueryTreePrinter.printQueryTree(qt, TraceEjb.query, BasicLevel.DEBUG);
            }
            optimizedQuery = new MedorEvaluator(qt, 0);
        }
        return optimizedQuery;
    }

}

---