EjbqlVariableVisitor.java

package org.objectweb.jonas_ejb.lib;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Stack;

import org.objectweb.jonas_ejb.container.TraceEjb;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDescEjb2;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTAbstractSchemaName;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCollectionMemberDeclaration;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCollectionValuedPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTEJBQL;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTFromClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTIdentifier;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTPath;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTRangeVariableDeclaration;
import org.objectweb.jonas_ejb.deployment.ejbql.ParseException;
import org.objectweb.jonas_ejb.deployment.ejbql.SimpleNode;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSelectClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSelectExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTAggregateSelectExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTIdentificationVariable;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCmpPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSingleValuedCmrPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTSingleValuedPathExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTWhereClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTConditionalExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTConditionalTerm;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTConditionalFactor;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTBetweenExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTInExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTLikeExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTNullComparisonExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTEmptyCollectionComparisonExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTCollectionMemberExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTComparisonExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTArithmeticExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTArithmeticTerm;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTArithmeticFactor;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTStringExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTDatetimeExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTBooleanExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTEntityBeanExpression;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTFunctionsReturningStrings;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTFunctionsReturningNumerics;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTOrderByClause;
import org.objectweb.jonas_ejb.deployment.ejbql.ASTOrderByItem;
import org.objectweb.jorm.metainfo.api.Class;
import org.objectweb.jorm.metainfo.api.Manager;
import org.objectweb.medor.api.Field;
import org.objectweb.medor.api.MedorException;
import org.objectweb.medor.query.api.QueryTree;
import org.objectweb.medor.query.api.QueryTreeField;
import org.objectweb.medor.query.jorm.lib.ClassExtent;
import org.objectweb.medor.query.jorm.lib.PNameField;
import org.objectweb.medor.query.jorm.lib.QueryBuilder;
import org.objectweb.medor.query.lib.QueryTreePrinter;
import org.objectweb.medor.filter.lib.BasicFieldOperand;
import org.objectweb.util.monolog.api.BasicLevel;

public class EjbqlVariableVisitor extends EjbqlAbstractVisitor {

    private Manager manager;

    private DeploymentDescEjb2 dd;

    private HashMap ids = new HashMap();

    private HashMap fields = new HashMap();

    private QueryBuilder qb = new QueryBuilder();

    private HashSet collections = new HashSet();

    public EjbqlVariableVisitor(ASTEJBQL ejbql, DeploymentDescEjb2 dd, QueryBuilder qb) throws Exception {
        this.dd = dd;
        this.qb = qb;
        manager = dd.getJormManager();

        // parse the ejbql and build the ids structure
        visit(ejbql);

        for (Iterator it = ids.keySet().iterator(); it.hasNext(); ) {
            String id = (String) it.next();
            IdValue idv = (IdValue) ids.get(id);
            fields.put(id + "." + Field.PNAMENAME, qb.project(define(id)));
            for (int i = 0; i < idv.getDeclaredPathLength(); i++) {
                String path = idv.getMergedPath(i);
                if (!collections.contains(path)) {
                    fields.put(path, qb.project(define(path)));
                }
            }
        }
    }

    private QueryTreeField define(String id) throws ParseException, MedorException {
        String[] path = splitPath(id);

        if (!qb.contains(path[0])) {
            IdValue idv = (IdValue) ids.get(path[0]);
            String[] name = idv.getName();

            PNameField pnf;
            if (name.length == 1) {
                pnf = extent(name[0], path[0]);
            } else {
                pnf = (PNameField) define(mergePath(name));
            }
            qb.define(path[0], pnf);
        }

        return qb.navigate(path);
    }

    private PNameField extent(String schema, String alias) throws ParseException, MedorException {
        if (schema == null) { throw new NullPointerException("schema"); }
        String cn = dd.asn2BeanDesc(schema).getJormClassName();
        Class theClass = manager.getClass(cn);
        if (theClass == null) {
            throw new ParseException
                ("Abstract schema name \"" + schema +
                 "\" has not been declared in the jorm meta information");
        }
        ClassExtent ext = new ClassExtent(theClass, alias, Field.PNAMENAME, false);
        return (PNameField) ext.getField(ext.getPNameFieldName());
    }

    public Map getFields() {
        return fields;
    }

    public void traceIds(HashMap idsM) {
        if (TraceEjb.isDebugQuery()) {
            TraceEjb.query.log(BasicLevel.DEBUG, "Begin of IDS structure:");
            // trace the ids structure
            for (Iterator i = idsM.keySet().iterator(); i.hasNext();) {
                String id = (String) i.next();
                IdValue idv = (IdValue) idsM.get(id);
                TraceEjb.query.log(BasicLevel.DEBUG, "ids[" + id + "]=" + idv);
                if (idv.getQueryTree() != null) {
                    QueryTreePrinter.printQueryTree(idv.getQueryTree(), TraceEjb.query, BasicLevel.DEBUG);
                }
            }
            TraceEjb.query.log(BasicLevel.DEBUG, "End of IDS structure:");
        }
    }

    public Object visit(ASTFromClause node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTCollectionMemberDeclaration node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTRangeVariableDeclaration node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTCollectionValuedPathExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTAbstractSchemaName node, Object data) {
        ((Stack) data).push(node.value);
        return null;
    }

    public Object visit(ASTIdentifier node, Object data) {
        String id = (String) node.value;
        String name = (String) ((Stack) data).pop();
        IdValue iv = (IdValue) ids.get(id);
        if (iv == null) {
            iv = new IdValue(name);
            ids.put(id, iv);
        } else {
            iv.setName(splitPath(name));
        }
        return null;
    }

    public Object visit(ASTPath node, Object data) {
        ((Stack) data).push(node.value);
        return null;
    }

    private void processVariable(String path) {
        // Common to select, where and orderby clauses
        String id = splitPath(path)[0];
        IdValue iv = (IdValue) ids.get(id);
        if (iv == null) {
            iv = new IdValue();
            ids.put(id, iv);
        }
        iv.addPath(path);
    }

    // -------------- select ---------------//
    public Object visit(ASTSelectClause node, Object data) {
        visit((SimpleNode) node, data);
        Stack st = (Stack) data;
        if (!st.empty()) {
            processVariable((String) st.pop());
        }
        return null;
    }

    public Object visit(ASTSelectExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTAggregateSelectExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTIdentificationVariable node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTSingleValuedPathExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTSingleValuedCmrPathExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTCmpPathExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    // ----------- Where -----------------//
    public Object visit(ASTWhereClause node, Object data) {
        visit((SimpleNode) node, data);
        Stack st = (Stack) data;
        while (!st.empty()) {
            processVariable((String) st.pop());
        }
        return null;
    }

    public Object visit(ASTConditionalExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTConditionalTerm node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTConditionalFactor node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTBetweenExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTInExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTLikeExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTNullComparisonExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTEmptyCollectionComparisonExpression node, Object data) {
        visit((SimpleNode) node, data);
        Stack st = (Stack) data;
        String path = (String) st.peek();
        collections.add(path);
        return null;
    }

    public Object visit(ASTCollectionMemberExpression node, Object data) {
        visit((SimpleNode) node, data);
        Stack st = (Stack) data;
        String path = (String) st.peek();
        collections.add(path);
        return null;
    }

    public Object visit(ASTComparisonExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTArithmeticExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTArithmeticTerm node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTArithmeticFactor node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTStringExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTDatetimeExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTBooleanExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTEntityBeanExpression node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTFunctionsReturningStrings node, Object data) {
        return visit((SimpleNode) node, data);
    }

    public Object visit(ASTFunctionsReturningNumerics node, Object data) {
        return visit((SimpleNode) node, data);
    }

    // ----------- Order by -----------------//
    public Object visit(ASTOrderByClause node, Object data) {
        visit((SimpleNode) node, data);
        Stack st = (Stack) data;
        while (!st.empty()) {
            processVariable((String) st.pop());
        }
        return null;
    }

    public Object visit(ASTOrderByItem node, Object data) {
        return visit((SimpleNode) node, data);
    }

}

---