Example usage for org.hibernate.criterion Restrictions between

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

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

Introduction

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

Prototype

public static Criterion between(String propertyName, Object low, Object high)

Source Link

Document

Apply a "between" constraint to the named property

Usage

From source file:org.encuestame.persistence.dao.imp.TweetPollDao.java

License:Apache License

@SuppressWarnings("unchecked")
public List<TweetPoll> retrieveTweetPollByDate(final Account account, final Integer maxResults,
        final Integer start, final Boolean isCompleted, final Boolean isScheduled, final Boolean isFavourite,
        final Boolean isPublished, final String keyword, final String period, final Date initDate) {
    final DetachedCriteria criteria = DetachedCriteria.forClass(TweetPoll.class);
    criteria.createAlias("tweetOwner", "tweetOwner");
    criteria.add(Restrictions.eq("tweetOwner", account));
    criteria.add(Restrictions.between("createDate", initDate, getNextDayMidnightDate()));
    advancedTweetPollSearchOptions(criteria, isCompleted, isScheduled, isFavourite, isPublished, keyword,
            period);/*from w  w w. j  a  v  a 2 s.c o  m*/
    return (List<TweetPoll>) filterByMaxorStart(criteria, maxResults, start);
}

From source file:org.eulerframework.web.core.base.dao.impl.hibernate5.BaseDao.java

License:Apache License

protected Criterion generateRestriction(String property, String value, QueryMode queryMode) {
    Field field;//from  w  w  w  .  j a  v  a2s . c om
    try {
        String fieldName = property;
        if (property.indexOf('.') > 0) {
            fieldName = property.substring(0, property.indexOf('.'));
        }
        field = this.entityClass.getDeclaredField(fieldName);
    } catch (NoSuchFieldException e) {
        throw new IllegalArgumentException("Property '" + property + "' not exist");
    }

    if (BaseEmbeddable.class.isAssignableFrom(field.getType())) {
        try {
            field = field.getType().getDeclaredField(property.substring(property.indexOf('.') + 1));
        } catch (NoSuchFieldException e) {
            throw new IllegalArgumentException("Property '" + property + "' not exist");
        }
    }

    switch (queryMode) {
    case ANYWHERE:
        return RestrictionsX.like(property, value, MatchMode.ANYWHERE);
    case START:
        return RestrictionsX.like(property, value, MatchMode.START);
    case END:
        return RestrictionsX.like(property, value, MatchMode.END);
    case EXACT:
        return RestrictionsX.like(property, value, MatchMode.EXACT);
    case GE:
        return Restrictions.ge(property, JavaObjectUtils.analyzeStringValueToObject(value, field.getType()));
    case GT:
        return Restrictions.gt(property, JavaObjectUtils.analyzeStringValueToObject(value, field.getType()));
    case LE:
        return Restrictions.le(property, JavaObjectUtils.analyzeStringValueToObject(value, field.getType()));
    case LT:
        return Restrictions.lt(property, JavaObjectUtils.analyzeStringValueToObject(value, field.getType()));
    case IN:
        return Restrictions.in(property, this.analyzeInterval(value, field.getType()));
    case NOTIN:
        return Restrictions.not(RestrictionsX.in(property, this.analyzeInterval(value, field.getType())));
    case IS:
        return Restrictions.eq(property, JavaObjectUtils.analyzeStringValueToObject(value, field.getType()));
    case NOT:
        return Restrictions.ne(property, JavaObjectUtils.analyzeStringValueToObject(value, field.getType()));
    case BETWEEN:
        Object[] array1 = this.analyzeInterval(value, field.getType());
        return Restrictions.between(property, array1[0], array1[1]);
    case OUTSIDE:
        Object[] array2 = this.analyzeInterval(value, field.getType());
        return Restrictions.not(Restrictions.between(property, array2[0], array2[1]));
    default:
        throw new IllegalArgumentException("Unknown query mode: " + queryMode);
    }
}

From source file:org.eurocarbdb.action.core.SearchGlycanSequence.java

License:Open Source License

private DetachedCriteria createSerializableCriteria() {
    // create base criteria    
    log.debug("creating GlycanSequence criteria");

    DetachedCriteria criteria;/*from  w  ww .j a  v a  2s .c  o m*/

    criteria = DetachedCriteria.forClass(GlycanSequence.class);

    // create biological contexts criteria
    DetachedCriteria bc_criteria = null;
    DetachedCriteria tax_criteria = null;
    DetachedCriteria tissue_criteria = null;
    DetachedCriteria disease_criteria = null;
    DetachedCriteria perturbation_criteria = null;

    if (taxonomyName != null || tissueName != null || diseaseName != null || perturbationName != null) {
        isNewQuery = true;
        log.debug("creating Biological context criteria");
        bc_criteria = criteria.createCriteria("glycanContexts").createCriteria("biologicalContext", "bc");

        // add taxonomy criteria        
        if (taxonomyName != null) {
            log.debug("adding taxonomy query predicates for input string '" + taxonomyName + "'");
            tax_criteria = bc_criteria.createCriteria("taxonomy", "taxa")
                    .createCriteria("taxonomySupertypes", "supertax")
                    .add(Restrictions.ilike("taxon", taxonomyName, MatchMode.EXACT));
        }

        // add tissue criteria
        if (tissueName != null) {
            log.debug("adding tissue query predicates for input string '" + tissueName + "'");

            tissue_criteria = bc_criteria.createCriteria("tissueTaxonomy", "ttax")
                    .add(Restrictions.ilike("tissueTaxon", tissueName, MatchMode.EXACT));
        }

        // add disease criteria
        if (diseaseName != null) {
            log.debug("adding disease query criteria for input string '" + diseaseName + "'");

            disease_criteria = bc_criteria.createCriteria("diseaseContexts").createCriteria("disease", "dis")
                    .add(Restrictions.ilike("diseaseName", diseaseName, MatchMode.EXACT));
        }

        if (perturbationName != null) {
            log.debug("adding perturbation query criteria for input string '" + perturbationName + "'");

            perturbation_criteria = bc_criteria.createCriteria("perturbationContexts")
                    .createCriteria("perturbation", "per")
                    .add(Restrictions.ilike("perturbationName", perturbationName, MatchMode.EXACT));
        }

    }

    // add mass criteria
    boolean mass_query_is_given = false;
    boolean params_are_ok = false;

    if (exactMass > 0 && exactMassTolerance > 0) {
        isNewQuery = true;
        mass_query_is_given = true;
        lowMass = exactMass - exactMassTolerance;
        highMass = exactMass + exactMassTolerance;
        log.debug("adding predicates for exactMass=" + exactMass + " Da +/- " + exactMassTolerance + " Da (ie: "
                + lowMass + "-" + highMass + " Da)");
        params_are_ok = true;
    } else if (lowMass > 0 && highMass > 0) {
        isNewQuery = true;
        mass_query_is_given = true;
        exactMass = -1;
        exactMassTolerance = -1;
        log.debug("adding predicates for mass range=(" + lowMass + ".." + highMass + " Da)");
        params_are_ok = true;
    }

    if (mass_query_is_given) {
        if (params_are_ok) {
            isNewQuery = true;
            String property = useAvgMass ? "massAverage" : "massMonoisotopic";
            criteria.add(Restrictions.between(property, new BigDecimal(lowMass), new BigDecimal(highMass)));
        } else {
            String msg = "Insufficient mass parameters given, either "
                    + "provide an exactMass + exactMassTolerence + useAvgMass preference, "
                    + "or provide a lowMass + highMass + useAvgMass preference";

            addActionError(msg);
            log.info(msg);
        }
    }

    Glycan glycan = null;

    if (sequenceGWS != null) {
        glycan = Glycan.fromString(sequenceGWS);
        glycan.removeReducingEndModification();
        if (glycan.isEmpty()) {
            glycan = null;
            sequenceGWS = null;
        }
    }

    if (glycan != null) {
        isNewQuery = true;

        // search structure in DB
        String glycoct = glycan.toGlycoCTCondensed();
        SugarSequence seq = new SugarSequence(glycoct);
        SubstructureQuery query = new SubstructureQuery(seq);

        if (sequencePosition != null) {
            if (sequencePosition.equals("Core") || sequencePosition.equals("Core + Terminii"))
                query.setOption(Must_Include_Reducing_Terminus);

            if (sequencePosition.equals("Terminii") || sequencePosition.equals("Core + Terminii"))
                query.setOption(Must_Include_All_Non_Reducing_Terminii);
        }

        criteria.add(query.getQueryCriterion());
    }

    if (this.additionalQueries.size() > 1) {
        isNewQuery = true;
    }

    for (SavedGlycanSequenceSearch oldQuery : this.additionalQueries) {

        DetachedCriteria oldCriteria = oldQuery.getQueryCriteria();

        criteria.add(Subqueries.propertyIn("glycanSequenceId", oldCriteria));

        oldCriteria.setProjection(Projections.distinct(Projections.property("glycanSequenceId")));

        this.currentSearch = oldQuery;
    }

    return criteria;
}

From source file:org.faster.orm.criteria.GenericCriteria.java

License:Open Source License

public DetachedCriteria buildCriteria() {
    beforeBuildCriteria();/*from  w ww  .j a v  a 2  s  .c om*/
    DetachedCriteria dc = DetachedCriteria.forClass(persistClass);
    List<Field> queryFields = QueryHelper.getQueryFields(this.getClass());
    Set<String> aliases = new HashSet<String>(); // ??
    for (Field f : queryFields) {
        try {
            Object obj = f.get(this);
            boolean ignoreNull = QueryHelper.isIgnoreNull(f);
            if (obj == null) {
                if (ignoreNull) {
                    continue;
                }
            }

            String fieldName = QueryHelper.getFieldName(f);
            if (fieldName.contains(".")) {
                String[] subFieldNames = fieldName.split("\\.");
                String fieldPath = subFieldNames[0];
                String alias = subFieldNames[0];
                if (!aliases.contains(alias)) {
                    dc.createAlias(fieldPath, alias);
                    aliases.add(alias);
                }

                // ?alias
                for (int i = 1; i < subFieldNames.length - 1; i++) {
                    fieldPath += "." + subFieldNames[i];
                    alias += "_" + subFieldNames[i];
                    if (!aliases.contains(alias)) {
                        dc.createAlias(fieldPath, alias);
                        aliases.add(alias);
                    }
                }

                if (subFieldNames.length > 2) {
                    fieldName = alias + "." + subFieldNames[subFieldNames.length - 1];
                }
            }

            if (obj == null && !ignoreNull) {
                dc.add(Restrictions.isNull(fieldName));
                continue;
            }

            String stringValue = String.valueOf(obj);
            boolean ignoreEmptyOrZero = QueryHelper.isIgnoreEmptyOrZero(f);
            if (ignoreEmptyOrZero && isBlank(stringValue)) {
                continue;
            }

            if (stringValue.startsWith(NULL)) {
                dc.add(Restrictions.isNull(fieldName));
                continue;
            }

            if (stringValue.startsWith(NOT_NULL)) {
                dc.add(Restrictions.isNotNull(fieldName));
                continue;
            }

            String delimiter = QueryHelper.getDelimiter(f);
            DataType dt = QueryHelper.getDataType(f);
            MatchMode mm = QueryHelper.getMatchMode(f);

            switch (dt) {
            case STRING:
                switch (mm) {
                case EQ:
                    dc.add(Restrictions.eq(fieldName, stringValue));
                    continue;
                case LIKE:
                    dc.add(Restrictions.like(fieldName, stringValue,
                            org.hibernate.criterion.MatchMode.ANYWHERE));
                    continue;
                case LIKE_START:
                    dc.add(Restrictions.like(fieldName, stringValue, org.hibernate.criterion.MatchMode.START));
                    continue;
                case LIKE_END:
                    dc.add(Restrictions.like(fieldName, stringValue, org.hibernate.criterion.MatchMode.END));
                    continue;
                case ILIKE:
                    dc.add(Restrictions.ilike(fieldName, stringValue,
                            org.hibernate.criterion.MatchMode.ANYWHERE));
                    continue;
                case ILIKE_START:
                    dc.add(Restrictions.ilike(fieldName, stringValue, org.hibernate.criterion.MatchMode.START));
                    continue;
                case ILIKE_END:
                    dc.add(Restrictions.ilike(fieldName, stringValue, org.hibernate.criterion.MatchMode.END));
                    continue;
                case IN:
                    CriteriaRender.renderFieldByStringFilterValues(dc, fieldName, stringValue, delimiter);
                    continue;
                default:
                    throw new IllegalArgumentException("Invalid MatchMode for String: " + mm);
                }
            case INTEGER:
                if (ignoreEmptyOrZero && stringValue.equals("0")) {
                    continue;
                }

                Integer intValue = 0;
                if (mm != MatchMode.IN) {
                    try {
                        intValue = Integer.valueOf(stringValue);
                    } catch (Exception e) {
                        throw new IllegalArgumentException(
                                stringValue + " is not valid int value and can't use MatchMode: " + mm);
                    }
                }

                switch (mm) {
                case EQ:
                    dc.add(Restrictions.eq(fieldName, intValue));
                    continue;
                case NE:
                    dc.add(Restrictions.ne(fieldName, intValue));
                    continue;
                case IN:
                    CriteriaRender.renderFieldByIntegerFilterValues(dc, fieldName, stringValue, delimiter);
                    continue;
                case GT:
                    dc.add(Restrictions.gt(fieldName, intValue));
                    continue;
                case GE:
                    dc.add(Restrictions.ge(fieldName, intValue));
                    continue;
                case LT:
                    dc.add(Restrictions.lt(fieldName, intValue));
                    continue;
                case LE:
                    dc.add(Restrictions.le(fieldName, intValue));
                    continue;
                default:
                    throw new IllegalArgumentException("Invalid MatchMode for Long: " + mm);
                }
            case LONG:
                if (ignoreEmptyOrZero && stringValue.equals("0")) {
                    continue;
                }

                Long longValue = 0L;
                if (mm != MatchMode.IN) {
                    try {
                        longValue = Long.valueOf(stringValue);
                    } catch (Exception e) {
                        throw new IllegalArgumentException(
                                stringValue + " is not valid long value and can't use MatchMode: " + mm);
                    }
                }

                switch (mm) {
                case EQ:
                    dc.add(Restrictions.eq(fieldName, longValue));
                    continue;
                case NE:
                    dc.add(Restrictions.ne(fieldName, longValue));
                    continue;
                case IN:
                    CriteriaRender.renderFieldByLongFilterValues(dc, fieldName, stringValue, delimiter);
                    continue;
                case GT:
                    dc.add(Restrictions.gt(fieldName, longValue));
                    continue;
                case GE:
                    dc.add(Restrictions.ge(fieldName, longValue));
                    continue;
                case LT:
                    dc.add(Restrictions.lt(fieldName, longValue));
                    continue;
                case LE:
                    dc.add(Restrictions.le(fieldName, longValue));
                    continue;
                default:
                    throw new IllegalArgumentException("Invalid MatchMode for Long: " + mm);
                }
            case DATE:
                // TODO ??????
                Date date = DateTimes.parseStringToDate(stringValue);
                switch (mm) {
                case EQ:
                    dc.add(Restrictions.eq(fieldName, date));
                    continue;
                case NE:
                    dc.add(Restrictions.ne(fieldName, date));
                    continue;
                case GT:
                    dc.add(Restrictions.gt(fieldName, date));
                    continue;
                case GE:
                    dc.add(Restrictions.ge(fieldName, date));
                    continue;
                case LT:
                    dc.add(Restrictions.lt(fieldName, date));
                    continue;
                case LE:
                    dc.add(Restrictions.le(fieldName, date));
                    continue;
                default:
                    throw new IllegalArgumentException("Invalid MatchMode for Date: " + mm);
                }
            case BOOLEAN:
                Boolean bool = BooleanUtils.toBooleanObject(stringValue);
                switch (mm) {
                case EQ:
                    dc.add(Restrictions.eq(fieldName, bool));
                    continue;
                case NE:
                    dc.add(Restrictions.ne(fieldName, bool));
                    continue;
                default:
                    throw new IllegalArgumentException("Invalid MatchMode for Boolean: " + mm);
                }
            case LatLong:
                LatLngBound b = new LatLngBound(stringValue);
                if (b.isValid()) {
                    String minLatitude = b.getMinLatitude() == null ? "0.0" : b.getMinLatitude().toString();
                    String maxLatitude = b.getMaxLatitude() == null ? "0.0" : b.getMaxLatitude().toString();
                    String minLongitude = b.getMinLongitude() == null ? "0.0" : b.getMinLongitude().toString();
                    String maxLongitude = b.getMaxLongitude() == null ? "0.0" : b.getMaxLongitude().toString();
                    if ("area".equalsIgnoreCase(fieldName)) {
                        dc.add(Restrictions.between("latitude", minLatitude, maxLatitude));
                        dc.add(Restrictions.between("longitude", minLongitude, maxLongitude));
                    } else {
                        if (fieldName.contains(".")) {
                            String alias = fieldName.replace(".", "_");
                            if (!aliases.contains(alias)) {
                                dc.createAlias(fieldName, alias);
                                aliases.add(alias);
                            }
                            fieldName = alias;
                        } else {
                            if (!aliases.contains(fieldName)) {
                                dc.createAlias(fieldName, fieldName);
                                aliases.add(fieldName);
                            }
                        }
                        dc.add(Restrictions.between(fieldName + ".latitude", minLatitude, maxLatitude));
                        dc.add(Restrictions.between(fieldName + ".longitude", minLongitude, maxLongitude));
                    }
                }
                continue;
            default:
                throw new IllegalArgumentException("Unsupported DataType: " + dt);
            }
        } catch (Exception e) {
            throw new IllegalArgumentException(e);
        }
    }

    renderCriteria(dc);

    if (isNotBlank(sort)) {
        String[] fields = sort.split("-");
        if (fields.length < 2 || "desc".equalsIgnoreCase(fields[1])) {
            dc.addOrder(Order.desc(fields[0]));
        } else {
            dc.addOrder(Order.asc(fields[0]));
        }
    }

    return dc;
}

From source file:org.fireflow.engine.modules.persistence.hibernate.PersisterUtils.java

License:Open Source License

public static org.hibernate.criterion.Criterion fireCriterion2HibernateCriterion(
        org.fireflow.client.query.Criterion fireCriterion) {
    String operation = fireCriterion.getOperation().trim();

    if (Criterion.OPERATION_EQ.equals(operation)) {
        return Restrictions.eq(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0]);
    } else if (Criterion.OPERATION_NE.equals(operation)) {
        return Restrictions.ne(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0]);
    } else if (Criterion.OPERATION_LIKE.equals(operation)) {
        return Restrictions.like(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0]);
    } else if (Criterion.OPERATION_GT.equals(operation)) {
        return Restrictions.gt(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0]);
    } else if (Criterion.OPERATION_LT.equals(operation)) {
        return Restrictions.lt(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0]);
    } else if (Criterion.OPERATION_GE.equals(operation)) {
        return Restrictions.ge(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0]);
    } else if (Criterion.OPERATION_LE.equals(operation)) {
        return Restrictions.le(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0]);
    } else if (operation.equals(Criterion.OPERATION_IS_NULL)) {
        return Restrictions.isNull(fireCriterion.getEntityProperty().getPropertyName());
    } else if (operation.equals(Criterion.OPERATION_IS_NOT_NULL)) {
        return Restrictions.isNotNull(fireCriterion.getEntityProperty().getPropertyName());
    } else if (operation.equals(Criterion.OPERATION_IN)) {
        return Restrictions.in(fireCriterion.getEntityProperty().getPropertyName(), fireCriterion.getValues());
    } else if (Criterion.OPERATION_BETWEEN.equals(operation)) {
        return Restrictions.between(fireCriterion.getEntityProperty().getPropertyName(),
                fireCriterion.getValues()[0], fireCriterion.getValues()[1]);
    } else if (Criterion.OPERATION_AND.equals(operation)) {
        org.fireflow.client.query.Criterion left = (org.fireflow.client.query.Criterion) fireCriterion
                .getValues()[0];/*from  w ww.  ja v a2  s.co  m*/
        org.fireflow.client.query.Criterion right = (org.fireflow.client.query.Criterion) fireCriterion
                .getValues()[1];
        org.hibernate.criterion.Criterion hLeft = fireCriterion2HibernateCriterion(left);
        org.hibernate.criterion.Criterion hRight = fireCriterion2HibernateCriterion(right);
        return Restrictions.and(hLeft, hRight);

    } else if (Criterion.OPERATION_OR.equals(operation)) {
        org.fireflow.client.query.Criterion left = (org.fireflow.client.query.Criterion) fireCriterion
                .getValues()[0];
        org.fireflow.client.query.Criterion right = (org.fireflow.client.query.Criterion) fireCriterion
                .getValues()[1];
        org.hibernate.criterion.Criterion hLeft = fireCriterion2HibernateCriterion(left);
        org.hibernate.criterion.Criterion hRight = fireCriterion2HibernateCriterion(right);
        return Restrictions.or(hLeft, hRight);

    }
    return null;
}

From source file:org.fornax.cartridges.sculptor.framework.accessimpl.jpahibernate.JpaHibFindByConditionAccessImpl.java

License:Apache License

private Criterion makeCriterion(ConditionalCriteria crit) {
    if (crit == null) {
        return null;
    }/*from   w  w w .  j  ava 2 s .  c  o m*/

    ConditionalCriteria.Operator operator = crit.getOperator();
    if (Operator.Equal.equals(operator)) {
        return Restrictions.eq(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.IgnoreCaseEqual.equals(operator)) {
        return Restrictions.eq(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant())
                .ignoreCase();
    } else if (Operator.LessThan.equals(operator)) {
        return Restrictions.lt(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.LessThanOrEqual.equals(operator)) {
        return Restrictions.le(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.GreatThan.equals(operator)) {
        return Restrictions.gt(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.GreatThanOrEqual.equals(operator)) {
        return Restrictions.ge(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.Like.equals(operator)) {
        return Restrictions.like(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.IgnoreCaseLike.equals(operator)) {
        return Restrictions.ilike(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant());
    } else if (Operator.IsNull.equals(operator)) {
        return Restrictions.isNull(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.IsNotNull.equals(operator)) {
        return Restrictions.isNotNull(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.IsEmpty.equals(operator)) {
        return Restrictions.isEmpty(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.IsNotEmpty.equals(operator)) {
        return Restrictions.isNotEmpty(makePathWithAlias(crit.getPropertyFullName()));
    } else if (Operator.Not.equals(operator)) {
        return Restrictions.not(makeCriterion((ConditionalCriteria) crit.getFirstOperant()));
    } else if (Operator.Or.equals(operator) && crit.getFirstOperant() instanceof List<?>) {
        Disjunction disj = Restrictions.disjunction();
        List<?> disjList = (List<?>) crit.getFirstOperant();
        for (Object disjPart : disjList) {
            disj.add(makeCriterion((ConditionalCriteria) disjPart));
        }
        return disj;
    } else if (Operator.Or.equals(operator)) {
        return Restrictions.or(makeCriterion((ConditionalCriteria) crit.getFirstOperant()),
                makeCriterion((ConditionalCriteria) crit.getSecondOperant()));
    } else if (Operator.And.equals(operator) && crit.getFirstOperant() instanceof List<?>) {
        Conjunction conj = Restrictions.conjunction();
        List<?> conjList = (List<?>) crit.getFirstOperant();
        for (Object conjPart : conjList) {
            conj.add(makeCriterion((ConditionalCriteria) conjPart));
        }
        return conj;
    } else if (Operator.And.equals(operator)) {
        return Restrictions.and(makeCriterion((ConditionalCriteria) crit.getFirstOperant()),
                makeCriterion((ConditionalCriteria) crit.getSecondOperant()));
    } else if (Operator.In.equals(operator)) {
        if (crit.getFirstOperant() instanceof Collection<?>) {
            return Restrictions.in(makePathWithAlias(crit.getPropertyFullName()),
                    (Collection<?>) crit.getFirstOperant());
        } else {
            return Restrictions.in(makePathWithAlias(crit.getPropertyFullName()),
                    (Object[]) crit.getFirstOperant());
        }
    } else if (Operator.Between.equals(operator)) {
        return Restrictions.between(makePathWithAlias(crit.getPropertyFullName()), crit.getFirstOperant(),
                crit.getSecondOperant());
    } else if (Operator.DistinctRoot.equals(operator)) {
        realDistinctRoot = true;
        return null;
    } else if (Operator.ProjectionRoot.equals(operator)) {
        resultTransformer = Criteria.PROJECTION;
        return null;
    } else if (Operator.EqualProperty.equals(operator)) {
        return Restrictions.eqProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.LessThanProperty.equals(operator)) {
        return Restrictions.eqProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.LessThanOrEqualProperty.equals(operator)) {
        return Restrictions.eqProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.GreatThanProperty.equals(operator)) {
        return Restrictions.eqProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else if (Operator.GreatThanOrEqualProperty.equals(operator)) {
        return Restrictions.eqProperty(makePathWithAlias(crit.getPropertyFullName()),
                (String) crit.getFirstOperant());
    } else {
        return null;
    }
}

From source file:org.geomajas.layer.hibernate.CriteriaVisitor.java

License:Open Source License

/** {@inheritDoc} */
@Override//from   www  .ja v  a  2  s . com
public Object visit(PropertyIsBetween filter, Object userData) {
    String propertyName = getPropertyName(filter.getExpression());
    String finalName = parsePropertyName(propertyName, userData);

    Object lo = castLiteral(getLiteralValue(filter.getLowerBoundary()), propertyName);
    Object hi = castLiteral(getLiteralValue(filter.getUpperBoundary()), propertyName);
    return Restrictions.between(finalName, lo, hi);
}

From source file:org.geomajas.layer.hibernate.CriteriaVisitor.java

License:Open Source License

/** {@inheritDoc} */
@Override//from  ww  w .ja v  a  2  s.  c  o  m
public Object visit(During during, Object userData) {
    String propertyName = getPropertyName(during.getExpression1());
    String finalName = parsePropertyName(propertyName, userData);
    Object literal = getLiteralValue(during.getExpression2());
    if (literal instanceof Period) {
        Period p = (Period) literal;
        Date begin = p.getBeginning().getPosition().getDate();
        Date end = p.getEnding().getPosition().getDate();
        return Restrictions.between(finalName, begin, end);
    } else {
        throw new UnsupportedOperationException("visit(Object userData)");
    }
}

From source file:org.glite.security.voms.admin.persistence.dao.VOMSUserDAO.java

License:Apache License

public Long countExpiringUsers(Integer intervalInDays) {

    Criteria crit = HibernateFactory.getSession().createCriteria(VOMSUser.class);

    Calendar cal = Calendar.getInstance();

    Date now = cal.getTime();//from   w  ww  . j  a  v  a 2s.c  o m
    cal.add(Calendar.DAY_OF_YEAR, intervalInDays);

    Date intervalDate = cal.getTime();

    crit.add(Restrictions.between("endTime", now, intervalDate));
    crit.add(Restrictions.eq("suspended", false));

    crit.setProjection(Projections.rowCount());

    return (Long) crit.list().get(0);

}

From source file:org.glite.security.voms.admin.persistence.dao.VOMSUserDAO.java

License:Apache License

@SuppressWarnings("unchecked")
public List<VOMSUser> findExpiringUsers(Integer intervalInDays) {

    Criteria crit = HibernateFactory.getSession().createCriteria(VOMSUser.class);

    Calendar cal = Calendar.getInstance();

    Date now = cal.getTime();// w  w w  .  j a  v a2  s. com
    cal.add(Calendar.DAY_OF_YEAR, intervalInDays);

    Date intervalDate = cal.getTime();

    crit.add(Restrictions.between("endTime", now, intervalDate));
    crit.add(Restrictions.eq("suspended", false));
    crit.addOrder(Order.asc("endTime"));

    return crit.list();

}