MedorFactory.java

package org.objectweb.jonas_ejb.container.jorm;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import javax.ejb.EJBException;

import org.objectweb.jonas_ejb.container.JContainer;
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.EntityDesc;
import org.objectweb.jonas_ejb.deployment.api.MethodCmp2Desc;
import org.objectweb.jonas_ejb.lib.EjbqlLimiterRange;
import org.objectweb.jonas_ejb.lib.EjbqlQueryTreeHolder;
import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jorm.metainfo.api.Manager;
import org.objectweb.medor.api.EvaluationException;
import org.objectweb.medor.api.MedorException;
import org.objectweb.medor.eval.api.ConnectionResources;
import org.objectweb.medor.eval.api.QueryEvaluator;
import org.objectweb.medor.eval.lib.BasicEvaluationMetaData;
import org.objectweb.medor.eval.prefetch.api.PrefetchBuffer;
import org.objectweb.medor.eval.prefetch.lib.PrefetchBufferFactoryImpl;
import org.objectweb.medor.expression.api.ParameterOperand;
import org.objectweb.medor.expression.api.TypingException;
import org.objectweb.medor.lib.Log;
import org.objectweb.medor.optim.api.ExecPlanGenerator;
import org.objectweb.medor.optim.api.QueryTransformer;
import org.objectweb.medor.optim.jorm.Jorm2Rdb;
import org.objectweb.medor.optim.lib.BasicQueryRewriter;
import org.objectweb.medor.optim.lib.FlattenQueryTreeRule;
import org.objectweb.medor.optim.lib.IndexesGenerator;
import org.objectweb.medor.query.api.QueryLeaf;
import org.objectweb.medor.query.api.QueryTree;
import org.objectweb.medor.tuple.api.TupleCollection;
import org.objectweb.util.monolog.api.BasicLevel;

public abstract class MedorFactory extends JormFactory {

    protected QueryTransformer queryTransformer = null;

    protected Manager miManager = null;

    protected ExecPlanGenerator indexesGenerator;

    protected boolean optimizeAtInit = false;

    private int prefetchIndex;

    private EjbqlLimiterRange[] limiterRanges = null;

    public MedorFactory() {
        super();
        if (Log.loggerFactory != TraceEjb.loggerFactory) {
            Log.loggerFactory = TraceEjb.loggerFactory;
        }
    }

    public synchronized QueryEvaluator getOptimizedRequest(MethodCmp2Desc methodDesc) throws MedorException {
        TraceEjb.logger.log(BasicLevel.DEBUG, "getOptimizedRequest(method name: " + methodDesc.getMethod().getName()
                + ")");
        try {
            EjbqlQueryTreeHolder qth = methodDesc.getQueryTreeHolder(mapper);
            // set the prefetch index for this method
            setPrefetchIndex(qth.getPrefetchIndex());
            // set the optimizer if not set yet
            if (qth.getQueryOptimizer() == null) {
                if (queryTransformer == null) {
                    ArrayList rules = new ArrayList(2);
                    rules.add(new FlattenQueryTreeRule());
                    rules.add(new Jorm2Rdb());
                    queryTransformer = new BasicQueryRewriter(rules);
                }
                qth.setQueryOptimizer(new QueryTransformer() {

                    public QueryTree transform(QueryTree qt) throws MedorException {
                        QueryTree qt1 = queryTransformer.transform(qt);
                        //TraceEjb.query.log(BasicLevel.DEBUG, "Transformed
                        // QueryTree: ");
                        //QueryTreePrinter.printQueryTree(qt1, TraceEjb.query,
                        // BasicLevel.DEBUG);
                        if (indexesGenerator == null) {
                            throw new Error("getOptimizedRequest: indexesGenerator == null");
                        }
                        return indexesGenerator.transform(qt1);
                    }
                });
            }
            limiterRanges = qth.getLimiterRanges();
            return qth.getOptimizedQueryTree();
        } catch (Exception e) {
            throw new MedorException("Impossible to optimize the query " + methodDesc.getQuery(), e);
        }
    }

    /*
     * NO MORE USED ??? public void optimizeAll() throws MedorException { for
     * (Iterator it = dd.getMethodDescIterator(); it.hasNext();) {
     * MethodCmp2Desc mcd = (MethodCmp2Desc) it.next(); if
     * (!mcd.isFindByPrimaryKey() && (mcd.isFinder() || mcd.isEjbSelect())) {
     * getOptimizedRequest(mcd.getIndex()); } } }
     */

    public TupleCollection evaluate(Object conn, int methodIndex, ParameterOperand[] parameters) throws MedorException {

        MethodCmp2Desc mcd = (MethodCmp2Desc) dd.getMethodDesc(methodIndex);
        QueryEvaluator evaluator = getOptimizedRequest(mcd);

        // Calculates and gets the required connection resources for this query
        ConnectionResources cr = evaluator.getRequiredConnectionResources();

        // Gets the QueryLeafs that requierd connections
        QueryLeaf[] leaves = cr.getRequiredQueryLeafConnection();

        // Setting QueryLeaf's appropriated connection Object
        // TODO : All jorm classes are not mapped on the same mapper
        // than the current class - should use connections from different
        // datasources.
        if (conn == null) {
            throw new MedorException("invalid connection handle [null]");
        }
        for (int i = 0; (i < leaves.length); i++) {
            cr.setConnection(leaves[i], conn);
        }
        // PrefetchBuffer initialization if prefetch tag setting
        PrefetchBuffer prefetchBuffer = null;
        if (mcd.getPrefetch()) {
            Object tx = null;
            try {
                tx = this.getTransactionManager().getTransaction();
                if (tx != null) {
                    prefetchBuffer = mapper.getPrefetchCache().createPrefetchBuffer(new PrefetchBufferFactoryImpl(),
                            this, tx, getPrefetchIndex());
                }
            } catch (javax.transaction.SystemException e) {
                // TODO : Que fait-on ???
                TraceEjb.logger.log(BasicLevel.ERROR,
                        "Cannot get the current transaction to create the Prefetch buffer:", e);
            }
        }
        // Map of EvaluationMetaData initialization needed for LIMIT clause
        Map evalMDMap = null;
        if (limiterRanges.length > 0) {
            try {
                // There is a LIMIT clause, init the Map of EvaluationMetaData
                evalMDMap = new HashMap();
                BasicEvaluationMetaData evalMD = new BasicEvaluationMetaData();
                EjbqlLimiterRange range = limiterRanges[0];
                if (range.getKind() == EjbqlLimiterRange.KIND_PARAMETER) {
                    evalMD.setLimitedRangeStartAt(parameters[range.getValue()].getInt());
                } else {
                    evalMD.setLimitedRangeStartAt(range.getValue());
                }
                if (TraceEjb.isDebugQuery()) {
                    TraceEjb.query.log(BasicLevel.LEVEL_DEBUG, "Query with LIMITer Range Start At = "
                            + evalMD.getLimitedRangeStartAt() + " for method name " + mcd.getMethod().getName());
                }
                if (limiterRanges.length > 1) {
                    range = limiterRanges[1];
                    if (range.getKind() == EjbqlLimiterRange.KIND_PARAMETER) {
                        System.out.println("parameters[range.getValue()].getInt() = "
                                + parameters[range.getValue()].getInt());
                        evalMD.setLimitedRangeSize(parameters[range.getValue()].getInt());
                    } else {
                        evalMD.setLimitedRangeSize(range.getValue());
                    }
                    if (TraceEjb.isDebugQuery()) {
                        TraceEjb.query.log(BasicLevel.LEVEL_DEBUG, "Query with LIMITer Range Size = "
                                + evalMD.getLimitedRangeSize() + " for method name " + mcd.getMethod().getName());
                    }
                }
                evalMDMap.put(leaves[0], evalMD);
            } catch (TypingException te) {
                throw new MedorException("Invalid parameter for a LIMIT range", te);
            }
        }
        try {
            return evaluator.evaluate(parameters, cr, prefetchBuffer, evalMDMap);
        } catch (EvaluationException e) {
            throw e;
        }
    }

    public void init(EntityDesc ed, JContainer c, String mapperName) {
        super.init(ed, c, mapperName);

        ecd = (EntityCmp2Desc) ed;

        //------------------- JORM META INFORMATION BUILDING ----------------//
        TraceEjb.logger.log(BasicLevel.DEBUG, "Jorm Meta information building");
        DeploymentDescEjb2 dd = ecd.getDeploymentDescEjb2();
        try {
            miManager = dd.getJormManager();
        } catch (DeploymentDescException e) {
            TraceEjb.logger.log(BasicLevel.ERROR, "impossible to load the jorm meta information into the manager", e);
            throw new EJBException("impossible to load the jorm meta information into the manager", e);
        }

        //---------------------- MEDOR INITIALIZATION -----------------------//
        TraceEjb.logger.log(BasicLevel.DEBUG, "Medor initialisation");
        indexesGenerator = new IndexesGenerator();

    }

    private void setPrefetchIndex(int i) {
        prefetchIndex = i;
    }

    private int getPrefetchIndex() {
        return prefetchIndex;
    }

}

---