| /* |
| * 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); |
| } |
| } |
