Example usage for org.hibernate.criterion Restrictions lt

List of usage examples for org.hibernate.criterion Restrictions lt

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.criterion.*
  5. Restrictions
  6. lt

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions lt.

Prototype

public static SimpleExpression lt(String propertyName, Object value)

Source Link

Document

Apply a "less than" constraint to the named property

Usage

From source file:com.inkubator.hrm.dao.impl.UnregSalaryDaoImpl.java

@Override
public List<UnregSalary> getByParamBySalaryPayroll(UnregSalarySearchParameter searchParameter,
        Date fromPeriodPayrollType, int firstResult, int maxResults, Order order) {
    Criteria criteria = getCurrentSession().createCriteria(getEntityClass());
    criteria.createAlias("wtPeriode", "wtPeriode", JoinType.INNER_JOIN);
    criteria.add(Restrictions.lt("wtPeriode.fromPeriode", fromPeriodPayrollType));
    doSearchByParam(searchParameter, criteria);
    criteria.addOrder(order);/*from  w w  w . j  av  a2  s . co  m*/
    criteria.setFirstResult(firstResult);
    criteria.setMaxResults(maxResults);
    return criteria.list();

}

From source file:com.inkubator.hrm.dao.impl.UnregSalaryDaoImpl.java

@Override
public Long getTotalByParamBySalaryPayroll(UnregSalarySearchParameter searchParameter,
        Date fromPeriodPayrollType) {
    Criteria criteria = getCurrentSession().createCriteria(getEntityClass());
    criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
    criteria.createAlias("wtPeriode", "wtPeriode", JoinType.INNER_JOIN);
    criteria.add(Restrictions.lt("wtPeriode.fromPeriode", fromPeriodPayrollType));
    doSearchByParam(searchParameter, criteria);
    return (Long) criteria.setProjection(Projections.rowCount()).uniqueResult();
}

From source file:com.inkubator.hrm.dao.impl.WtHolidayDaoImpl.java

@Override
public List<WtHoliday> getByYearDif(int value) {
    Date now = new Date();
    Date parameter = DateTimeUtil.getDateFrom(now, -value, CommonUtilConstant.DATE_FORMAT_YEAR);

    Criteria criteria = getCurrentSession().createCriteria(getEntityClass());
    criteria.add(Restrictions.lt("holidayDate", parameter));
    criteria.add(Restrictions.eq("isEveryYear", 1));
    return criteria.list();
}

From source file:com.jaspersoft.jasperserver.api.metadata.common.service.impl.hibernate.HibernateFilter.java

License:Open Source License

public void applyPropertyFilter(PropertyFilter filter) {
    Criterion propCriterion;/*from   www  .j  a  v a 2  s  .c  o  m*/
    switch (filter.getOp()) {
    case PropertyFilter.EQ:
        propCriterion = Restrictions.eq(filter.getProperty(), filter.getValue());
        break;
    case PropertyFilter.LIKE:
        propCriterion = Restrictions.like(filter.getProperty(), filter.getValue());
        break;
    case PropertyFilter.GT:
        propCriterion = Restrictions.gt(filter.getProperty(), filter.getValue());
        break;
    case PropertyFilter.LT:
        propCriterion = Restrictions.lt(filter.getProperty(), filter.getValue());
        break;
    case PropertyFilter.BETWEEN:
        propCriterion = Restrictions.between(filter.getProperty(), filter.getLowValue(), filter.getHighValue());
        break;
    case PropertyFilter.IN:
        propCriterion = Restrictions.in(filter.getProperty(), filter.getValues());
        break;
    default:
        throw new JSException("jsexception.hibernate.unknown.property.filter.operation",
                new Object[] { new Byte(filter.getOp()) });
    }
    add(propCriterion);
}

From source file:com.jeroensteenbeeke.hyperion.data.Expression.java

License:Open Source License

public static <T extends Comparable<T> & Serializable> Expression<T> lessThan(final String property, T value) {
    return new Expression<T>(value) {
        private static final long serialVersionUID = 1L;

        @Override//w  ww.  j  a  v  a2  s  .c om
        public void decorateCriteria(Criteria criteria) {
            criteria.add(Restrictions.lt(property, getValue()));
        }

        @SuppressWarnings("unchecked")
        @Override
        public boolean retain(Object object) {
            T objectValue = (T) Reflector.invokeGetter(object, property);

            return objectValue.compareTo(getValue()) < 0;
        }

    };
}

From source file:com.jeysan.modules.orm.hibernate.HibernateDao.java

License:Apache License

/**
 * ??Criterion,./*from   w  w  w. j av a  2s  .  com*/
 */
protected Criterion buildCriterion(final String propertyName, final Object propertyValue,
        final MatchType matchType) {
    Assert.hasText(propertyName, "propertyName?");
    Criterion criterion = null;
    //?MatchTypecriterion
    switch (matchType) {
    case EQ:
        criterion = Restrictions.eq(propertyName, propertyValue);
        break;
    case NEQ:
        if (propertyValue == null)
            criterion = Restrictions.isNotNull(propertyName);
        else
            criterion = Restrictions.not(Restrictions.eq(propertyName, propertyValue));
        break;
    case NULL:
        criterion = Restrictions.isNull(propertyName);
        break;
    case LIKE:
        criterion = Restrictions.like(propertyName, (String) propertyValue, MatchMode.ANYWHERE);
        break;

    case LE:
        criterion = Restrictions.le(propertyName, propertyValue);
        break;
    case LT:
        criterion = Restrictions.lt(propertyName, propertyValue);
        break;
    case GE:
        criterion = Restrictions.ge(propertyName, propertyValue);
        break;
    case GT:
        criterion = Restrictions.gt(propertyName, propertyValue);
    }
    return criterion;
}

From source file:com.jgeppert.struts2.jquery.grid.showcase.action.JsonOrdersAction.java

License:Apache License

public String execute() {
    log.debug("Page " + getPage() + " Rows " + getRows() + " Sorting Order " + getSord() + " Index Row :"
            + getSidx());/*from w w  w .  j a v a2s.  c  om*/
    log.debug("Search :" + searchField + " " + searchOper + " " + searchString);

    // Calcalate until rows ware selected
    int to = (rows * page);

    // Calculate the first row to read
    int from = to - rows;

    // Criteria to Build SQL
    DetachedCriteria criteria = DetachedCriteria.forClass(Orders.class);

    if (id != null) {
        criteria.createAlias("customer", "c");
        criteria.add(Restrictions.eq("c.customernumber", id));
    }

    // Handle Search
    if (searchField != null) {
        if (searchField.equals("customernumber")) {
            Integer searchValue = Integer.parseInt(searchString);
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("ordernumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("ordernumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("ordernumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("ordernumber", searchValue));
        } else if (searchField.equals("status") || searchField.equals("comments")) {
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq(searchField, searchString));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne(searchField, searchString));
            else if (searchOper.equals("bw"))
                criteria.add(Restrictions.like(searchField, searchString + "%"));
            else if (searchOper.equals("cn"))
                criteria.add(Restrictions.like(searchField, "%" + searchString + "%"));
        }
        if (searchField.equals("customer")) {
            Integer searchValue = Integer.parseInt(searchString);
            criteria.createAlias("customer", "c");

            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("c.customernumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("c.customernumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("c.customernumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("c.customernumber", searchValue));
        }
    }

    // Count Orders
    records = ordersDao.countByCriteria(criteria);

    // Reset count Projection
    criteria.setProjection(null);
    criteria.setResultTransformer(Criteria.ROOT_ENTITY);

    // Handle Order By
    if (sidx != null && !sidx.equals("")) {
        if (!sidx.equals("customer")) {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc(sidx));
            else
                criteria.addOrder(Order.desc(sidx));
        } else {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc("customer.customernumber"));
            else
                criteria.addOrder(Order.desc("customer.customernumber"));
        }
    }

    // Get Customers by Criteria
    gridModel = ordersDao.findByCriteria(criteria, from, rows);

    // Set to = max rows
    if (to > records)
        to = records;

    // Calculate total Pages
    total = (int) Math.ceil((double) records / (double) rows);

    return SUCCESS;
}

From source file:com.jgeppert.struts2.jquery.grid.showcase.action.JsonTableAction.java

License:Apache License

public String execute() {
    log.debug("Page " + getPage() + " Rows " + getRows() + " Sorting Order " + getSord() + " Index Row :"
            + getSidx());//from  ww w.j a  va 2s. c  o  m
    log.debug("Search :" + searchField + " " + searchOper + " " + searchString);

    // Calcalate until rows ware selected
    int to = (rows * page);

    // Calculate the first row to read
    int from = to - rows;

    // Criteria to Build SQL
    DetachedCriteria criteria = DetachedCriteria.forClass(Customers.class);

    // Handle Search
    if (searchField != null) {
        if (searchField.equals("customernumber")) {
            Integer searchValue = Integer.parseInt(searchString);
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("customernumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("customernumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("customernumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("customernumber", searchValue));
        } else if (searchField.equals("country") || searchField.equals("city")
                || searchField.equals("addressLine1") || searchField.equals("contactfirstname")
                || searchField.equals("contactlastname") || searchField.equals("customername")) {
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq(searchField, searchString));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne(searchField, searchString));
            else if (searchOper.equals("bw"))
                criteria.add(Restrictions.like(searchField, searchString + "%"));
            else if (searchOper.equals("cn"))
                criteria.add(Restrictions.like(searchField, "%" + searchString + "%"));
        } else if (searchField.equals("creditlimit")) {
            Double searchValue = Double.parseDouble(searchString);
            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("creditlimit", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("creditlimit", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("creditlimit", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("creditlimit", searchValue));
        }
        if (searchField.equals("employeenumber")) {
            Integer searchValue = Integer.parseInt(searchString);
            criteria.createAlias("salesemployee", "se");

            if (searchOper.equals("eq"))
                criteria.add(Restrictions.eq("se.employeenumber", searchValue));
            else if (searchOper.equals("ne"))
                criteria.add(Restrictions.ne("se.employeenumber", searchValue));
            else if (searchOper.equals("lt"))
                criteria.add(Restrictions.lt("se.employeenumber", searchValue));
            else if (searchOper.equals("gt"))
                criteria.add(Restrictions.gt("se.employeenumber", searchValue));
        }
    }

    // Count Customers
    records = customersDao.countByCriteria(criteria);

    // Reset count Projection
    criteria.setProjection(null);
    criteria.setResultTransformer(Criteria.ROOT_ENTITY);

    // Handle Order By
    if (sidx != null && !sidx.equals("")) {
        if (!sidx.equals("employeenumber")) {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc(sidx));
            else
                criteria.addOrder(Order.desc(sidx));
        } else {
            if (sord.equals("asc"))
                criteria.addOrder(Order.asc("salesemployee.employeenumber"));
            else
                criteria.addOrder(Order.desc("salesemployee.employeenumber"));
        }
    }

    // Get Customers by Criteria
    gridModel = customersDao.findByCriteria(criteria, from, rows);

    // Set to = max rows
    if (to > records)
        to = records;

    // Calculate total Pages
    total = (int) Math.ceil((double) records / (double) rows);

    return SUCCESS;
}

From source file:com.jubination.model.dao.ClientDAOImpl.java

@Transactional(propagation = Propagation.REQUIRED, readOnly = true)
public List fetchEntities(String paramVal) {
    List list = null;/* w  ww . ja  va  2  s. c  om*/

    switch (paramVal) {

    case "PendingMinusOne":
        session = getSessionFactory().getCurrentSession();
        Criteria criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.and(Restrictions.lt("l.count", 0), Restrictions.isNull("l.followUpDate"),
                Restrictions.gt("l.leadId", "50000")));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();

        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "PendingInProgress":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.createAlias("l.call", "call");
        criteria.add(Restrictions.and(Restrictions.le("l.count", 0), Restrictions.gt("l.leadId", "50000"),
                Restrictions.eq("call.Status", "in-progress")));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();

        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "PendingAndNotified":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.or(Restrictions.and(

                Restrictions.ge("l.count", 1), Restrictions.eq("l.followUpDate", ""),
                Restrictions.isNull("l.followUpDate")),

                Restrictions.and(Restrictions.ge("l.count", 1), Restrictions.ne("l.followUpDate", ""),
                        Restrictions.isNotNull("l.followUpDate"),
                        Restrictions.le("l.followUpDate",
                                new SimpleDateFormat("yyyy-MM-dd").format(new Date()))),
                Restrictions.eq("l.followUpDate", new SimpleDateFormat("yyyy-MM-dd").format(new Date())))

        );
        criteria.addOrder(Order.desc("l.followUpDate"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();

        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;

    case "Pending":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.and(Restrictions.and(Restrictions.ge("l.count", 1),
                Restrictions.isNull("l.missedAppointment"), Restrictions.isNull("l.followUpDate"))));

        criteria.addOrder(Order.asc("l.count"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();

            }
        }
        break;
    case "Notified":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(
                Restrictions.or(
                        Restrictions.and(
                                Restrictions
                                        .and(Restrictions.ge("l.count", 1),
                                                Restrictions.and(
                                                        Restrictions.le("l.followUpDate",
                                                                new SimpleDateFormat("yyyy-MM-dd")
                                                                        .format(new Date())),
                                                        Restrictions.gt("l.followUpDate", "2016-01-01"))),
                                Restrictions.isNull("l.missedAppointment")),
                        Restrictions.and(
                                Restrictions.eq("l.followUpDate",
                                        new SimpleDateFormat("yyyy-MM-dd").format(new Date())),
                                Restrictions.eq("l.leadStatus", "Follow up/Call back"))));
        criteria.addOrder(Order.asc("l.followUpDate"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "PendingMA":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class, "c");
        criteria.createAlias("c.lead", "l");
        criteria.add(Restrictions.and(Restrictions.ge("l.count", 1),
                Restrictions.eq("l.missedAppointment", true), Restrictions.isNull("l.followUpDate")));

        criteria.addOrder(Order.desc("l.count"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;
    case "NotifiedMA":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class);
        criteria.createAlias("lead", "l");
        criteria.add(Restrictions.and(
                Restrictions.and(Restrictions.ge("l.count", 1),
                        Restrictions.and(
                                Restrictions.le("l.followUpDate",
                                        new SimpleDateFormat("yyyy-MM-dd").format(new Date())),
                                Restrictions.gt("l.followUpDate", "2016-01-01"))),
                Restrictions.eq("l.missedAppointment", true)));
        criteria.addOrder(Order.asc("l.followUpDate"));
        criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            client.getLead().size();
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
        }
        break;

    case "Overnight":
        session = getSessionFactory().getCurrentSession();
        criteria = session.createCriteria(Client.class);
        criteria.add(Restrictions.eq("overnight", true));
        list = criteria.list();
        for (Client client : (List<Client>) list) {
            for (Lead lead : client.getLead()) {
                if (lead.getBeneficiaries() != null) {
                    lead.getBeneficiaries().size();
                }
                lead.getCall().size();
            }
            client.getLead().size();
        }
        break;

    default:

        break;
    }
    if (list != null) {
        System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" + list.size() + "$$$" + paramVal);
    }

    System.out.println(
            "READ CLIENT WITH INNER ELEMENTS WITH STATUS :::::::::::::::::::::::::::::::::::::::::::::::CHECK");
    return list;

}

From source file:com.klistret.cmdb.utility.hibernate.XPathCriteria.java

License:Open Source License

/**
 * /*  w ww .  j av a2 s .c  om*/
 * @param predicate
 * @return
 */
protected Criterion getRestriction(Expr predicate, HibernateStep context) {
    logger.debug("Adding restrictions by predicate to context [{}]", context);

    switch (predicate.getType()) {
    case Or:
        /**
         * Recursively breaks down the OrExpr by translating on the first
         * and second operands
         */
        if (((OrExpr) predicate).getOperands().size() != 2)
            throw new ApplicationException(
                    String.format("OrExpr expression [%s] expects 2 operands", predicate));

        return Restrictions.or(getRestriction(((OrExpr) predicate).getOperands().get(0), context),
                getRestriction(((OrExpr) predicate).getOperands().get(1), context));
    case And:
        /**
         * Recursively breaks down the AndExpr by translating on the first
         * and second operands
         */
        if (((AndExpr) predicate).getOperands().size() != 2)
            throw new ApplicationException(
                    String.format("AndExpr expression [%s] expects 2 operands", predicate));

        return Restrictions.and(getRestriction(((AndExpr) predicate).getOperands().get(0), context),
                getRestriction(((AndExpr) predicate).getOperands().get(1), context));
    case Comparison:
        /**
         * Find the literal
         */
        LiteralExpr literal = getLiteralOperand(((ComparisonExpr) predicate).getOperands());

        /**
         * Find the relative path making a Hibernate relative path
         */
        RelativePathExpr rpe = getRelativePathOperand(((ComparisonExpr) predicate).getOperands());
        HibernateRelativePath hRPath = process(rpe, context);
        build(hRPath);

        HibernateStep last = hRPath.getLastHibernateStep();

        /**
         * Property name with alias prefix
         */
        String alias = last.getPrevious() == null ? aliasCache.get(context.getPath())
                : aliasCache.get(last.getPrevious().getPath());
        String propertyName = alias == null ? last.getName() : String.format("%s.%s", alias, last.getName());

        /**
         * Paths with XML properties (always the last step if present)
         * return a XPath restriction.
         */
        if (hRPath.hasXML()) {
            if (!hRPath.isTruncated())
                throw new ApplicationException(String.format(
                        "Predicate relative path ending in an XML property [%s] must be truncated", last));

            /**
             * Last Hibernate step of the Hibernate path marks the property
             * which the restriction acts on.
             */
            StepExpr step = (StepExpr) last.getStep();

            /**
             * A new XPath is created from the last step downwards till the
             * step prior to the ending step.
             */
            String xpath = null;
            for (int depth = step.getDepth(); depth < step.getRelativePath().getDepth() - 1; depth++) {
                Expr expr = step.getRelativePath().getExpr(depth);
                xpath = xpath == null ? expr.getXPath() : String.format("%s/%s", xpath, expr.getXPath());
            }

            Step ending = (Step) step.getRelativePath().getLastExpr();

            /**
             * A new comparison is generated
             */
            List<Expr> operands = new ArrayList<Expr>();
            operands.add(ending);
            operands.add(literal);

            xpath = String.format("%s[%s]", xpath,
                    ComparisonExpr.getXPath(((ComparisonExpr) predicate).getOperator(), operands, false));
            xpath = String.format("%s%s", context.getBaseExpression().getProlog(), xpath);

            PathExpression other = new PathExpression(xpath);
            return new XPathRestriction(propertyName, (Step) other.getRelativePath().getFirstExpr());
        }

        if (((StepExpr) last.getStep()).hasPredicates())
            throw new ApplicationException(String.format(
                    "Comparisons against Hibernate properties may not have an underlying step [] with predicates",
                    last.getStep()));

        logger.debug("Predicate is comparison [{}] against property [{}]",
                ((ComparisonExpr) predicate).getOperator().name(), propertyName);

        switch (((ComparisonExpr) predicate).getOperator()) {
        case ValueEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.eq(propertyName, literal.getValue().getJavaValue());
        case ValueGreaterThan:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.gt(propertyName, literal.getValue().getJavaValue());
        case ValueGreaterThanOrEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.ge(propertyName, literal.getValue().getJavaValue());
        case ValueLessThan:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.lt(propertyName, literal.getValue().getJavaValue());
        case ValueLessThanOrEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.le(propertyName, literal.getValue().getJavaValue());
        case ValueNotEquals:
            logger.debug("Value: {}", literal.getValue().getJavaValue());
            return Restrictions.ne(propertyName, literal.getValue().getJavaValue());
        case GeneralEquals:
            /**
             * If atomic (not a sequence) then the 'in' restriction is not
             * usable (defaults to 'eq' restriction) since the argument is
             * an array of objects.
             */
            if (literal.isAtomic()) {
                logger.debug("Value: {}", literal.getValue().getJavaValue());
                return Restrictions.eq(propertyName, literal.getValue().getJavaValue());
            }

            logger.debug("Values: {}", literal.getValues());

            Object[] javaValues = new Object[literal.getValues().length];
            for (int index = 0; index < literal.getValues().length; index++)
                javaValues[index] = ((com.klistret.cmdb.utility.saxon.Value) literal.getValues()[index])
                        .getJavaValue();

            return Restrictions.in(propertyName, javaValues);
        case Matches:
            if (((ComparisonExpr) predicate).getOperands().size() != 2)
                throw new ApplicationException(
                        String.format("Matches function [%s] expects 2 operands", predicate));

            logger.debug("Value: {}", literal.getValue().getText());
            return Restrictions.ilike(propertyName, literal.getValue().getText(), MatchMode.EXACT);
        case Exists:
            if (((ComparisonExpr) predicate).getOperands().size() != 1)
                throw new ApplicationException(
                        String.format("Exists function [%s] expects only 1 operand", predicate));

            return Restrictions.isNotNull(propertyName);
        case Empty:
            if (((ComparisonExpr) predicate).getOperands().size() != 1)
                throw new ApplicationException(
                        String.format("Empty function [%s] expects only 1 operand", predicate));

            return Restrictions.isNull(propertyName);
        default:
            throw new ApplicationException(
                    String.format("Unexpected comparison operator [%s] handling predicates",
                            ((ComparisonExpr) predicate).getOperator()));
        }

    default:
        throw new ApplicationException(String.format("Unexpected expr [%s] type for predicate", predicate));
    }
}