/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.ode.daohib.bpel.ql;
import org.apache.commons.lang.StringUtils;
import org.apache.ode.bpel.common.ProcessState;
import org.apache.ode.daohib.bpel.hobj.HProcessInstance;
import org.apache.ode.ql.Compiler;
import org.apache.ode.ql.eval.skel.AbstractConjunction;
import org.apache.ode.ql.eval.skel.AbstractDisjunction;
import org.apache.ode.ql.eval.skel.AbstractEqualityEvaluator;
import org.apache.ode.ql.eval.skel.CommandEvaluator;
import org.apache.ode.ql.eval.skel.ConjunctionEvaluator;
import org.apache.ode.ql.eval.skel.DisjunctionEvaluator;
import org.apache.ode.ql.eval.skel.EqualityEvaluator;
import org.apache.ode.ql.eval.skel.GEEvaluator;
import org.apache.ode.ql.eval.skel.GreaterEvaluator;
import org.apache.ode.ql.eval.skel.INEvaluator;
import org.apache.ode.ql.eval.skel.LEEvaluator;
import org.apache.ode.ql.eval.skel.LessEvaluator;
import org.apache.ode.ql.eval.skel.LikeEvaluator;
import org.apache.ode.ql.eval.skel.OrderByEvaluator;
import org.apache.ode.ql.tree.Builder;
import org.apache.ode.ql.tree.BuilderFactory;
import org.apache.ode.ql.tree.nodes.*;
import org.apache.ode.utils.ISO8601DateParser;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Conjunction;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
public class HibernateInstancesQueryCompiler extends Compiler<List, Session> {
private static class DBFieldValueEq extends FieldValueEquality {
protected final Object fieldValue;
/**
* @param identifier
*/
public DBFieldValueEq(String identifier, Object fieldValue) {
super(identifier);
this.fieldValue = fieldValue;
}
/**
* @see org.apache.ode.ql.eval.skel.CommandEvaluator#evaluate(java.lang.Object)
*/
public Criterion evaluate(Object paramValue) {
return Restrictions.eq(identifier, fieldValue);
}
}
private abstract static class FieldValueEquality extends AbstractEqualityEvaluator<String, Criterion, Object> {
/**
* @param identifier
*/
public FieldValueEquality(String identifier) {
super(identifier);
}
}
//
private final static String INSTANCE_ID_FIELD = "iid";
private final static String PROCESS_ID_FIELD = "pid";
private final static String PROCESS_NAME_FIELD = "name";
private final static String PROCESS_NAMESPACE_FIELD = "namespace";
private final static String INSTANCE_STATUS_FIELD = "status";
private final static String INSTANCE_STARTED_FIELD = "started";
private final static String INSTANCE_LAST_ACTIVE_FIELD = "last-active";
/*
* private final static String CORRELATION_NAME_FIELD = "name"; private final static String
* CORRELATION_NAMESPACE_FIELD = "namespace"; private final static String CORRELATION_NAMESPACE_FIELD = "namespace";
*/
// DB fields
private final static String INSTANCE_ID_DB_FIELD = "id";
private final static String PROCESS_ID_DB_FIELD = "process.processId";
private final static String PROCESS_NAME_DB_FIELD = "process.typeName";
private final static String PROCESS_NAMESPACE_DB_FIELD = "process.typeNamespace";
private final static String INSTANCE_STATUS_DB_FIELD = "state";
private final static String PROPERTY_NS_DB_FIELD = "process.typeNamespace";
private final static String PROPERTY_NAME_DB_FIELD = "property.name";
private final static String PROPERTY_VALUE_DB_FIELD = "property.value";
private final static String INSTANCE_STARTED_DB_FIELD = "created";
private final static String INSTANCE_LAST_ACTIVE_DB_FIELD = "lastActiveTime";
// status fields
private final static String STATUS_ACTIVE = "active";
private final static String STATUS_SUSPENDED = "suspended";
private final static String STATUS_ERROR = "error";
private final static String STATUS_COMPLETED = "completed";
private final static String STATUS_TERMINATED = "terminated";
private final static String STATUS_FAULTED = "failed";
private final static Map<String, String> nodeIdentifierToDBField = new HashMap<String, String>(20);
//Whether property is used in query
private boolean propertyInQuery;
//Whether ordering by status used
private boolean orderByStatus;
private boolean orderByStatusDesc;
static {
nodeIdentifierToDBField.put(INSTANCE_ID_FIELD, INSTANCE_ID_DB_FIELD);
nodeIdentifierToDBField.put(INSTANCE_ID_FIELD, INSTANCE_ID_DB_FIELD);
nodeIdentifierToDBField.put(PROCESS_ID_FIELD, PROCESS_ID_DB_FIELD);
nodeIdentifierToDBField.put(PROCESS_NAME_FIELD, PROCESS_NAME_DB_FIELD);
nodeIdentifierToDBField.put(PROCESS_NAMESPACE_FIELD, PROCESS_NAMESPACE_DB_FIELD);
nodeIdentifierToDBField.put(INSTANCE_STARTED_FIELD, INSTANCE_STARTED_DB_FIELD);
nodeIdentifierToDBField.put(INSTANCE_LAST_ACTIVE_FIELD, INSTANCE_LAST_ACTIVE_DB_FIELD);
nodeIdentifierToDBField.put(INSTANCE_STATUS_FIELD, INSTANCE_STATUS_DB_FIELD);
}
private static String getDBField(String name) {
String dbField = nodeIdentifierToDBField.get(name);
if (dbField == null) {
throw new IllegalArgumentException("Unsupported field " + name);
}
return dbField;
}
private void init() {
propertyInQuery = false;
orderByStatus = false;
orderByStatusDesc = false;
}
@Override
public CommandEvaluator<List, Session> compile(final Query node) {
init();
final OrderByEvaluator<Collection<Order>, Object> orderEvaluator = (node.getOrder() != null) ? compileOrderBy(node
.getOrder()) : null;
final CommandEvaluator<Criterion, Object> selectionEvaluator = node.getChilds().size() == 0 ? null
: compileEvaluator(node.getChilds().iterator().next());
final boolean joinCorrelationSet = propertyInQuery;
final boolean sortByStatus = orderByStatus;
final boolean sortByStatusDesc = orderByStatusDesc;
final Limit limit = node.getLimit();
return new CommandEvaluator<List, Session>() {
public List evaluate(Session session) {
Criteria criteria = session.createCriteria(HProcessInstance.class).createAlias("process", "process");
if(joinCorrelationSet) {
criteria = criteria.createAlias("correlationSets", "property");
}
if(selectionEvaluator!=null) {
criteria.add(selectionEvaluator.evaluate(null));
}
if (orderEvaluator != null) {
Collection<Order> orders = orderEvaluator.evaluate(null);
for (Order order : orders) {
criteria.addOrder(order);
}
}
// setting limit
if (limit != null) {
criteria.setMaxResults(limit.getNumber());
}
List result = criteria.list();
//check whether ordering by status
if(sortByStatus) {
Collections.sort(result, sortByStatusDesc?StateComparator.DESC:StateComparator.ASC);
}
return result;
};
};
}
protected ConjunctionEvaluator<Criterion, Object> compileConjunction(Collection<CommandEvaluator> childs) {
return new AbstractConjunction<Criterion, Object>(childs) {
public Criterion evaluate(Object arg) {
Conjunction conj = Restrictions.conjunction();
for (CommandEvaluator eval : childs) {
conj.add((Criterion) eval.evaluate(null));
}
return conj;
}
};
}
protected DisjunctionEvaluator<Criterion, Object> compileDisjunction(Collection<CommandEvaluator> childs) {
return new AbstractDisjunction<Criterion, Object>(childs) {
public Criterion evaluate(Object arg) {
Disjunction conj = Restrictions.disjunction();
for (CommandEvaluator eval : childs) {
conj.add((Criterion) eval.evaluate(null));
}
return conj;
};
};
}
protected EqualityEvaluator<String, Criterion, Object> compileEqual(final Equality eq) {
if (eq.getIdentifier() instanceof Property) {
propertyInQuery = true;
final Property property = (Property) eq.getIdentifier();
return new EqualityEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.eq(PROPERTY_NS_DB_FIELD, property.getNamespace()));
}
conj.add(Restrictions.eq(PROPERTY_NAME_DB_FIELD, property.getName()));
conj.add(Restrictions.eq(PROPERTY_VALUE_DB_FIELD, eq.getValue().getValue()));
return conj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = eq.getIdentifier().getName();
final Object value = eq.getValue().getValue();
final String dbField = getDBField(fieldName);
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
return new FieldValueEquality(INSTANCE_STATUS_FIELD) {
/**
* @see org.apache.ode.ql.eval.skel.CommandEvaluator#evaluate(java.lang.Object)
*/
public Criterion evaluate(Object paramValue) {
short noState = 200; // TODO move to constants
Disjunction disj = Restrictions.disjunction();
if (STATUS_ACTIVE.equals(paramValue)) {
disj.add(Restrictions.eq(dbField, ProcessState.STATE_NEW));
disj.add(Restrictions.eq(dbField, ProcessState.STATE_ACTIVE));
disj.add(Restrictions.eq(dbField, ProcessState.STATE_READY));
} else if (STATUS_SUSPENDED.equals(paramValue)) {
disj.add(Restrictions.eq(dbField, ProcessState.STATE_SUSPENDED));
} else if (STATUS_ERROR.equals(value)) {
disj.add(Restrictions.eq(dbField, noState)); // Error instance state doesn't exist yet
} else if (STATUS_COMPLETED.equals(paramValue)) {
disj.add(Restrictions.eq(dbField, ProcessState.STATE_COMPLETED_OK));
} else if (STATUS_TERMINATED.equals(paramValue)) {
disj.add(Restrictions.eq(dbField, ProcessState.STATE_TERMINATED));
} else if (STATUS_FAULTED.equals(paramValue)) {
disj.add(Restrictions.eq(dbField, ProcessState.STATE_COMPLETED_WITH_FAULT));
} else {
disj.add(Restrictions.eq(dbField, noState)); // Non existent state
}
return disj;
}
};
}
return new DBFieldValueEq(dbField, value);
}
}
public CommandEvaluator compileEvaluator(Object node) {
/*
*
*/
if (node instanceof In) {
return compileIn((In) node);
} else if (node instanceof org.apache.ode.ql.tree.nodes.Conjunction) {
return compileConjunction(evaluate((LogicExprNode) node));
} else if (node instanceof org.apache.ode.ql.tree.nodes.Disjunction) {
return compileDisjunction(evaluate((LogicExprNode) node));
} else if (node instanceof IdentifierToValueCMP) {
return compileIdentifierToValueCMP((IdentifierToValueCMP) node);
}
throw new IllegalArgumentException("Unsupported node " + node.getClass());
}
protected CommandEvaluator<Criterion, Object> compileIdentifierToValueCMP(IdentifierToValueCMP node) {
Identifier id = node.getIdentifier();
if (id instanceof Field) {
String name = id.getName();
Value value = node.getValue();
if (INSTANCE_ID_FIELD.equals(name)) {
value.setValue(Long.valueOf((String) value.getValue()));
} else if (INSTANCE_STARTED_FIELD.equals(name) || INSTANCE_LAST_ACTIVE_FIELD.equals(name)) {
try {
value.setValue(ISO8601DateParser.parse((String) value.getValue()));
} catch (ParseException ex) {
// TODO
throw new RuntimeException(ex);
}
}
}
if (node instanceof Equality) {
return compileEqual((Equality) node);
} else if (node instanceof Less) {
return compileLess((Less) node);
} else if (node instanceof Greater) {
return compileGreater((Greater) node);
} else if (node instanceof GE) {
return compileGE((GE) node);
} else if (node instanceof LE) {
return compileLE((LE) node);
} else if (node instanceof Like) {
return compileLike((Like) node);
} else {
throw new IllegalArgumentException("Unsupported node " + node.getClass());
}
}
protected GEEvaluator<String, Criterion, Object> compileGE(final GE ge) {
if (ge.getIdentifier() instanceof Property) {
propertyInQuery = true;
final Property property = (Property) ge.getIdentifier();
return new GEEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.ge(PROPERTY_NS_DB_FIELD, property.getNamespace()));
}
conj.add(Restrictions.ge(PROPERTY_NAME_DB_FIELD, property.getName()));
conj.add(Restrictions.ge(PROPERTY_VALUE_DB_FIELD, ge.getValue().getValue()));
return conj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = ge.getIdentifier().getName();
final Object objValue = ge.getValue().getValue();
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
throw new IllegalArgumentException("Field " + INSTANCE_STATUS_FIELD + " is not supported.");
}
final String dbField = getDBField(fieldName);
return new GEEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
return Restrictions.ge(dbField, objValue);
}
public String getIdentifier() {
return fieldName;
}
};
}
}
protected GreaterEvaluator<String, Criterion, Object> compileGreater(final Greater gt) {
if (gt.getIdentifier() instanceof Property) {
propertyInQuery = true;
final Property property = (Property) gt.getIdentifier();
return new GreaterEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.gt(PROPERTY_NS_DB_FIELD, property.getNamespace()));
}
conj.add(Restrictions.gt(PROPERTY_NAME_DB_FIELD, property.getName()));
conj.add(Restrictions.gt(PROPERTY_VALUE_DB_FIELD, gt.getValue().getValue()));
return conj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = gt.getIdentifier().getName();
final Object value = gt.getValue().getValue();
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
throw new IllegalArgumentException("Field " + INSTANCE_STATUS_FIELD + " is not supported.");
}
final String dbField = getDBField(fieldName);
return new GreaterEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
return Restrictions.gt(dbField, value);
}
public String getIdentifier() {
return fieldName;
}
};
}
}
protected INEvaluator<String, Criterion, Object> compileIn(final In in) {
if (in.getIdentifier() instanceof Property) {
propertyInQuery = true;
final Property property = (Property) in.getIdentifier();
return new INEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Disjunction disj = Restrictions.disjunction();
String propertyNS = property.getNamespace();
String propertyName = property.getName();
for (Value value : in.getValues()) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.gt(PROPERTY_NS_DB_FIELD, propertyNS));
}
conj.add(Restrictions.gt(PROPERTY_NAME_DB_FIELD, propertyName));
conj.add(Restrictions.gt(PROPERTY_VALUE_DB_FIELD, value.getValue()));
disj.add(conj);
}
return disj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = in.getIdentifier().getName();
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
short noState = 200; // TODO move to constants
final Disjunction disj = Restrictions.disjunction();
final Collection values = ValuesHelper.extract((Collection<Value>) in.getValues());
if (values.contains(STATUS_ACTIVE)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_NEW));
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_ACTIVE));
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_READY));
}
if (values.contains(STATUS_SUSPENDED)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_SUSPENDED));
}
if (values.contains(STATUS_ERROR)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, noState)); // Error instance state doesn't exist yet
}
if (values.contains(STATUS_COMPLETED)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_COMPLETED_OK));
}
if (values.contains(STATUS_TERMINATED)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_TERMINATED));
}
if (values.contains(STATUS_FAULTED)) {
disj.add(Restrictions.eq(INSTANCE_STATUS_DB_FIELD, ProcessState.STATE_COMPLETED_WITH_FAULT));
}
return new INEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
return disj;
};
public String getIdentifier() {
return INSTANCE_STATUS_DB_FIELD;
};
};
} else {
final Collection objValues;
final Collection<Value> values = in.getValues();
if (INSTANCE_ID_FIELD.equals(fieldName)) {
objValues = new ArrayList<Long>(values.size());
for (Value value : values) {
objValues.add(Long.valueOf((String) value.getValue()));
}
} else if (INSTANCE_STARTED_FIELD.equals(fieldName) || INSTANCE_LAST_ACTIVE_FIELD.equals(fieldName)) {
objValues = new ArrayList<Date>(values.size());
try {
for (Value value : values) {
objValues.add(ISO8601DateParser.parse((String) value.getValue()));
}
} catch (ParseException ex) {
// TODO
throw new RuntimeException(ex);
}
} else {
objValues = ValuesHelper.extract((Collection<Value>) values);
}
final String dbField = getDBField(fieldName);
return new INEvaluator<String, Criterion, Object>() {
/**
* @see org.apache.ode.ql.eval.skel.CommandEvaluator#evaluate(java.lang.Object)
*/
public Criterion evaluate(Object paramValue) {
return Restrictions.in(dbField, objValues);
}
/**
* @see org.apache.ode.ql.eval.skel.Identified#getIdentifier()
*/
public String getIdentifier() {
return dbField;
}
};
}
}
}
protected LEEvaluator<String, Criterion, Object> compileLE(final LE le) {
if (le.getIdentifier() instanceof Property) {
final Property property = (Property) le.getIdentifier();
return new LEEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.le(PROPERTY_NS_DB_FIELD, property.getNamespace()));
}
conj.add(Restrictions.le(PROPERTY_NAME_DB_FIELD, property.getName()));
conj.add(Restrictions.le(PROPERTY_VALUE_DB_FIELD, le.getValue().getValue()));
return conj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = le.getIdentifier().getName();
final Object value = le.getValue().getValue();
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
throw new IllegalArgumentException("Field " + INSTANCE_STATUS_FIELD + " is not supported.");
}
final String dbField = getDBField(fieldName);
return new LEEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
return Restrictions.le(dbField, value);
}
public String getIdentifier() {
return fieldName;
}
};
}
}
protected LessEvaluator<String, Criterion, Object> compileLess(final Less less) {
if (less.getIdentifier() instanceof Property) {
propertyInQuery = true;
final Property property = (Property) less.getIdentifier();
return new LessEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.lt(PROPERTY_NS_DB_FIELD, property.getNamespace()));
}
conj.add(Restrictions.lt(PROPERTY_NAME_DB_FIELD, property.getName()));
conj.add(Restrictions.lt(PROPERTY_VALUE_DB_FIELD, less.getValue().getValue()));
return conj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = less.getIdentifier().getName();
final Object value = less.getValue().getValue();
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
throw new IllegalArgumentException("Field " + INSTANCE_STATUS_FIELD + " is not supported.");
}
final String dbField = getDBField(fieldName);
return new LessEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
return Restrictions.lt(dbField, value);
}
public String getIdentifier() {
return fieldName;
}
};
}
}
protected LikeEvaluator<String, Criterion, Object> compileLike(final Like like) {
if (like.getIdentifier() instanceof Property) {
propertyInQuery = true;
final Property property = (Property) like.getIdentifier();
return new LikeEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
Conjunction conj = Restrictions.conjunction();
if (!StringUtils.isEmpty(property.getNamespace())) {
conj.add(Restrictions.like(PROPERTY_NS_DB_FIELD, property.getNamespace()));
}
conj.add(Restrictions.like(PROPERTY_NAME_DB_FIELD, property.getName()));
conj.add(Restrictions.like(PROPERTY_VALUE_DB_FIELD, like.getValue().getValue()));
return conj;
};
public String getIdentifier() {
return property.toString();
};
};
} else {
final String fieldName = like.getIdentifier().getName();
if (INSTANCE_STATUS_FIELD.equals(fieldName)) {
throw new IllegalArgumentException("Field " + INSTANCE_STATUS_FIELD + " is not supported by like operation.");
}
if (INSTANCE_ID_FIELD.equals(fieldName)) {
throw new IllegalArgumentException("Field " + INSTANCE_ID_FIELD + " is not supported by like operation.");
}
final Object value = like.getValue().getValue();
final String dbField = getDBField(fieldName);
return new LikeEvaluator<String, Criterion, Object>() {
public Criterion evaluate(Object paramValue) {
return Restrictions.like(dbField, value);
};
public String getIdentifier() {
return dbField;
}
};
}
}
protected OrderByEvaluator<Collection<Order>, Object> compileOrderBy(OrderBy orderBy) {
final LinkedHashMap<String, Boolean> orders = new LinkedHashMap<String, Boolean>();
for (OrderByElement idOrder : orderBy.getOrders()) {
if (!(idOrder.getIdentifier() instanceof Field)) {
throw new IllegalArgumentException("Only field identifier supported by order by operator.");
}
String idName = idOrder.getIdentifier().getName();
if(INSTANCE_STATUS_FIELD.equals(idName)) {
if(orderBy.getOrders().size()>1) {
//TODO throw appropriate exception
throw new RuntimeException("Status field should be used alone in <order by> construction.");
}
orderByStatus = true;
orderByStatusDesc = idOrder.getType()==OrderByType.DESC;
return null;
}
String dbField = getDBField(idName);
orders.put(dbField, idOrder.getType() == null || idOrder.getType() == OrderByType.ASC);
}
return new OrderByEvaluator<Collection<Order>, Object>() {
public Collection<Order> evaluate(Object paramValue) {
Collection<Order> hibernateOrders = new ArrayList<Order>(orders.size());
for (Map.Entry<String, Boolean> order : orders.entrySet()) {
hibernateOrders.add(order.getValue() ? Order.asc(order.getKey()) : Order.desc(order.getKey()));
}
return hibernateOrders;
}
};
}
protected List<CommandEvaluator> evaluate(LogicExprNode exprNode) {
ArrayList<CommandEvaluator> commandsEv = new ArrayList<CommandEvaluator>(exprNode.getChilds().size());
for (LogicNode node : exprNode.getChilds()) {
commandsEv.add(compileEvaluator(node));
}
return commandsEv;
}
public static void main(String[] args) {
String queryString = "order by last-active desc limit 1000";
Builder<String> builder = BuilderFactory.getInstance().createBuilder();
Node queryNode = builder.build(queryString);
HibernateInstancesQueryCompiler compiler = new HibernateInstancesQueryCompiler();
compiler.compile((Query) queryNode);
}
}