}    public List query(WorkflowExpressionQuery query) throws StoreException {        com.opensymphony.workflow.query.Expression expression = query.getExpression();        Criterion expr;        Class entityClass = getQueryClass(expression, null);        if (expression.isNested()) {            expr = buildNested((NestedExpression) expression);        } else {            expr = queryComparison((FieldExpression) expression);        }        //get results and send them back        Criteria criteria = session.createCriteria(entityClass);        criteria.add(expr);        try {            Set results = new HashSet();            Iterator iter = criteria.list().iterator();            while (iter.hasNext()) {                Object next = iter.next();                Object item;                if (next instanceof HibernateStep) {                    HibernateStep step = (HibernateStep) next;                    item = new Long(step.getEntryId());                } else {                    WorkflowEntry entry = (WorkflowEntry) next;                    item = new Long(entry.getId());                }                results.add(item);            }            return new ArrayList(results);        } catch (HibernateException e) {            throw new StoreException("Error executing query " + expression, e);        }    }    public List query(WorkflowQuery query) throws StoreException {        Class entityClass;        int qtype = query.getType();        if (qtype == 0) { // then not set, so look in sub queries            if (query.getLeft() != null) {                qtype = query.getLeft().getType();            }        }        if (qtype == WorkflowQuery.CURRENT) {            entityClass = HibernateCurrentStep.class;        } else {            entityClass = HibernateHistoryStep.class;        }        Criteria criteria = session.createCriteria(entityClass);        Criterion expression = buildExpression(query);        criteria.add(expression);        //get results and send them back        try {            Set results = new HashSet();            Iterator iter = criteria.list().iterator();            while (iter.hasNext()) {                HibernateStep step = (HibernateStep) iter.next();                results.add(new Long(step.getEntryId()));            }            return new ArrayList(results);        } catch (HibernateException e) {            throw new StoreException("Error executing query " + expression, e);        }    }    /**     * Returns an expression generated from this query     */    private Criterion getExpression(WorkflowQuery query) {        int operator = query.getOperator();        switch (operator) {        case WorkflowQuery.EQUALS:            return Expression.eq(getFieldName(query.getField()), query.getValue());        case WorkflowQuery.NOT_EQUALS:            return Expression.not(Expression.like(getFieldName(query.getField()), query.getValue()));        case WorkflowQuery.GT:            return Expression.gt(getFieldName(query.getField()), query.getValue());        case WorkflowQuery.LT:            return Expression.lt(getFieldName(query.getField()), query.getValue());        default:            return Expression.eq(getFieldName(query.getField()), query.getValue());        }    }    /**     * returns the correct name of the field given or "1" if none is found     * which matches the input.     * @param field     * @return     */    private String getFieldName(int field) {        switch (field) {        case FieldExpression.ACTION: // actionId            return "actionId";        case FieldExpression.CALLER:            return "caller";        case FieldExpression.FINISH_DATE:            return "finishDate";        case FieldExpression.OWNER:            return "owner";        case FieldExpression.START_DATE:            return "startDate";        case FieldExpression.STEP: // stepId            return "stepId";        case FieldExpression.STATUS:            return "status";        case FieldExpression.STATE:            return "state";        case FieldExpression.NAME:            return "workflowName";        case FieldExpression.DUE_DATE:            return "dueDate";        default:            return "1";        }    }    private Class getQueryClass(com.opensymphony.workflow.query.Expression expr, Collection classesCache) throws StoreException {        if (classesCache == null) {            classesCache = new HashSet();        }        if (expr instanceof FieldExpression) {            FieldExpression fieldExpression = (FieldExpression) expr;            switch (fieldExpression.getContext()) {            case FieldExpression.CURRENT_STEPS:                classesCache.add(HibernateCurrentStep.class);                break;            case FieldExpression.HISTORY_STEPS:                classesCache.add(HibernateHistoryStep.class);                break;            case FieldExpression.ENTRY:                classesCache.add(HibernateWorkflowEntry.class);                break;            default:                throw new QueryNotSupportedException("Query for unsupported context " + fieldExpression.getContext());            }        } else {            NestedExpression nestedExpression = (NestedExpression) expr;            for (int i = 0; i < nestedExpression.getExpressionCount(); i++) {                com.opensymphony.workflow.query.Expression expression = nestedExpression.getExpression(i);                if (expression.isNested()) {                    classesCache.add(getQueryClass(nestedExpression.getExpression(i), classesCache));                } else {                    classesCache.add(getQueryClass(expression, classesCache));                }            }        }        if (classesCache.size() > 1) {            throw new QueryNotSupportedException("Store does not support nested queries of different types (types found:" + classesCache + ")");        }        return (Class) classesCache.iterator().next();    }    /**     *  Recursive method for building Expressions using Query objects.     */    private Criterion buildExpression(WorkflowQuery query) throws StoreException {        if (query.getLeft() == null) {            if (query.getRight() == null) {                return getExpression(query); //leaf node            } else {                throw new StoreException("Invalid WorkflowQuery object.  QueryLeft is null but QueryRight is not.");            }        } else {            if (query.getRight() == null) {                throw new StoreException("Invalid WorkflowQuery object.  QueryLeft is not null but QueryRight is.");            }            int operator = query.getOperator();            WorkflowQuery left = query.getLeft();            WorkflowQuery right = query.getRight();            switch (operator) {            case WorkflowQuery.AND:                return Expression.and(buildExpression(left), buildExpression(right));            case WorkflowQuery.OR:                return Expression.or(buildExpression(left), buildExpression(right));            case WorkflowQuery.XOR:                throw new StoreException("XOR Operator in Queries not supported by " + this.getClass().getName());            default:                throw new StoreException("Operator '" + operator + "' is not supported by " + this.getClass().getName());            }        }    }    private Criterion buildNested(NestedExpression nestedExpression) throws StoreException {        Criterion full = null;        for (int i = 0; i < nestedExpression.getExpressionCount(); i++) {            Criterion expr;            com.opensymphony.workflow.query.Expression expression = nestedExpression.getExpression(i);            if (expression.isNested()) {                expr = buildNested((NestedExpression) nestedExpression.getExpression(i));            } else {                FieldExpression sub = (FieldExpression) nestedExpression.getExpression(i);                expr = queryComparison(sub);                if (sub.isNegate()) {                    expr = Expression.not(expr);                }            }            if (full == null) {                full = expr;            } else {                switch (nestedExpression.getExpressionOperator()) {                case NestedExpression.AND:                    full = Expression.and(full, expr);                    break;                case NestedExpression.OR:                    full = Expression.or(full, expr);                }            }        }        return full;    }    private Criterion queryComparison(FieldExpression expression) {        int operator = expression.getOperator();        switch (operator) {        case FieldExpression.EQUALS:            return Expression.eq(getFieldName(expression.getField()), expression.getValue());        case FieldExpression.NOT_EQUALS:            return Expression.not(Expression.like(getFieldName(expression.getField()), expression.getValue()));        case FieldExpression.GT:            return Expression.gt(getFieldName(expression.getField()), expression.getValue());        case FieldExpression.LT:            return Expression.lt(getFieldName(expression.getField()), expression.getValue());        default:            return Expression.eq(getFieldName(expression.getField()), expression.getValue());        }    }}