Example usage for org.hibernate.criterion Restrictions isNotNull

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

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

Introduction

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

Prototype

public static Criterion isNotNull(String propertyName)

Source Link

Document

Apply an "is not null" constraint to the named property

Usage

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

License:Apache License

@SuppressWarnings("unchecked")
public List<TweetPollSavedPublishedStatus> getSocialLinksByTweetPollSearch(final TweetPoll tweetPoll,
        final TypeSearchResult itemType, final List<SocialProvider> splist,
        final List<SocialAccount> socialAccounts) {
    final DetachedCriteria criteria = DetachedCriteria.forClass(TweetPollSavedPublishedStatus.class);
    criteria.createAlias("socialAccount", "socialAccount");
    if (itemType.equals(TypeSearchResult.TWEETPOLL)) {
        criteria.add(Restrictions.eq("tweetPoll", tweetPoll));
        criteria.add(Restrictions.isNotNull("tweetId"));
        criteria.add(Restrictions.eq("status", Status.SUCCESS));
        if (splist.size() > 0) {
            criteria.add(Restrictions.in("apiType", splist));
        }/*from w  w  w.j a va 2 s  .co  m*/
        if (socialAccounts.size() > 0) {
            criteria.add(Restrictions.in("socialAccount", socialAccounts));
        }
    }
    return (List<TweetPollSavedPublishedStatus>) getHibernateTemplate().findByCriteria(criteria);
}

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

License:Apache License

@SuppressWarnings("unchecked")
public Long getSocialLinksByType(final TweetPoll tweetPoll, final Survey survey, final Poll poll,
        final TypeSearchResult itemType) {
    final DetachedCriteria criteria = DetachedCriteria.forClass(TweetPollSavedPublishedStatus.class);
    criteria.setProjection(Projections.rowCount());
    if (itemType.equals(TypeSearchResult.TWEETPOLL)) {
        criteria.add(Restrictions.eq("tweetPoll", tweetPoll));
    } else if (itemType.equals(TypeSearchResult.SURVEY)) {
        criteria.createAlias("survey", "survey");
        criteria.add(Restrictions.eq("survey", survey));
        // criteria.addOrder(Order.desc("survey.createdAt"));
    } else if (itemType.equals(TypeSearchResult.POLL)) {
        criteria.add(Restrictions.eq("poll", poll));
        // criteria.addOrder(Order.desc("poll.createdAt"));
    } else {/*from   w  ww  . j  av  a 2 s  .  c  om*/
        log.error("Item type not valid: " + itemType);
    }
    criteria.add(Restrictions.isNotNull("apiType"));
    criteria.add(Restrictions.isNotNull("tweetId"));
    criteria.add(Restrictions.eq("status", Status.SUCCESS));

    List<TweetPollSavedPublishedStatus> results = (List<TweetPollSavedPublishedStatus>) getHibernateTemplate()
            .findByCriteria(criteria);
    log.debug("Retrieve total Social Links:" + "--->" + results.size());
    return (Long) (results.get(0) == null ? 0 : results.get(0));

}

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

License:Apache License

@SuppressWarnings("unchecked")
public List<TweetPollSavedPublishedStatus> getSocialLinksByTypeAndDateRange(final TweetPoll tweetPoll,
        final Survey survey, final Poll poll, final TypeSearchResult itemType) {

    final DetachedCriteria criteria = DetachedCriteria.forClass(TweetPollSavedPublishedStatus.class);
    if (itemType.equals(TypeSearchResult.TWEETPOLL)) {
        criteria.createAlias("tweetPoll", "tweetPoll");
        criteria.add(Restrictions.eq("tweetPoll", tweetPoll));

    } else if (itemType.equals(TypeSearchResult.SURVEY)) {
        criteria.createAlias("survey", "survey");
        criteria.add(Restrictions.eq("survey", survey));

    } else if (itemType.equals(TypeSearchResult.POLL)) {
        criteria.add(Restrictions.eq("poll", poll));

    } else {//from w  ww  .j a  v a2  s. c o  m
        log.error("Item type not valid: " + itemType);
    }

    criteria.add(Restrictions.isNotNull("apiType"));
    criteria.add(Restrictions.isNotNull("tweetId"));
    criteria.add(Restrictions.eq("status", Status.SUCCESS));
    return (List<TweetPollSavedPublishedStatus>) getHibernateTemplate().findByCriteria(criteria);
}

From source file:org.evolizer.famix.model.utils.SnapshotAnalyzer.java

License:Apache License

/**
 * Query incoming or outgoing FAMIX associations of the given type and set of entities.
 * /*from   w ww  .  j  av  a2 s . c  o m*/
 * @param entities   The set of entities.
 * @param associationType   FamixAssociation type - if null all associations are queried.
 * @param direction   The direction of associations either "from" (i.e., outgoing) or "to" (i.e., incoming).
 * @return   The list of associations.
 * 
 * TODO: Handle null values for direction or introduce constants
 */
@SuppressWarnings("unchecked")
public <T extends FamixAssociation> List<T> queryAssociationsOfEntities(
        Collection<? extends AbstractFamixEntity> entities, java.lang.Class<T> associationType,
        String direction) throws EvolizerRuntimeException {
    associationType = (associationType != null) ? associationType
            : (Class<T>) org.evolizer.famix.model.entities.FamixAssociation.class;

    String oppositeDirection = "";
    if (direction.equals("from")) {
        oppositeDirection = "to";
    } else if (direction.equals("to")) {
        oppositeDirection = "from";
    }

    List<T> associations = new ArrayList<T>();
    try {
        if (entities.size() > 0) {
            Criteria invocationQuery = getHibernateSession().createCriteria(associationType)
                    .add(Restrictions.and(Restrictions.in(direction, entities),
                            Restrictions.not(Restrictions.in(oppositeDirection, entities))));
            invocationQuery.createAlias("from", "f");
            invocationQuery.createAlias("to", "t");

            invocationQuery.add(
                    Restrictions.and(Restrictions.isNotNull("f.parent"), Restrictions.isNotNull("t.parent")));

            associations = invocationQuery.list();
        }
    } catch (HibernateException he) {
        fLogger.error("Error in queryAssociationsOfEntities " + he.getMessage());
        throw new EvolizerRuntimeException("Error in queryAssociationsOfEntities", he);
    } catch (EvolizerException ee) {
        fLogger.error("Error in queryAssociationsOfEntities " + ee.getMessage());
        throw new EvolizerRuntimeException("Error in queryAssociationsOfEntities", ee);
    }

    return associations;
}

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

License:Open Source License

public static final void renderIntegerField(DetachedCriteria dc, String fieldName, String value) {
    if (isBlank(value) || ALL.equalsIgnoreCase(value)) {
        return;//from  ww  w . j  ava  2 s .c o  m
    }

    if (NULL.equalsIgnoreCase(value)) {
        dc.add(Restrictions.isNull(fieldName));
        return;
    }

    if (NOT_NULL.equalsIgnoreCase(value)) {
        dc.add(Restrictions.isNotNull(fieldName));
    }
}

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

License:Open Source License

/**
 * ??//from  ww  w. j  a v a  2 s  .  c om
 *
 * @param dc
 *            ??
 * @param fieldName
 *            ??
 * @param value
 *            
 */
public static void renderField(DetachedCriteria dc, String fieldName, Object value) {
    if (value == null) {
        return;
    }

    if (value instanceof String) {
        String stringValue = (String) value;
        if (isBlank(stringValue) || ALL.equalsIgnoreCase(stringValue)) {
            return;
        }

        if (NULL.equalsIgnoreCase(stringValue)) {
            dc.add(Restrictions.isNull(fieldName));
            return;
        }

        if (NOT_NULL.equalsIgnoreCase(stringValue)) {
            dc.add(Restrictions.isNotNull(fieldName));
            return;
        }
    }

    dc.add(Restrictions.eq(fieldName, value));
}

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

License:Open Source License

/**
 * ?like?/* w w  w . java  2  s .c  o m*/
 *
 * @param dc
 *            ??
 * @param fieldName
 *            ??
 * @param value
 *            
 */
public static void renderFieldLike(DetachedCriteria dc, String fieldName, String value) {
    if (isBlank(value) || ALL.equalsIgnoreCase(value)) {
        return;
    }

    if (NULL.equalsIgnoreCase(value)) {
        dc.add(Restrictions.isNull(fieldName));
        return;
    }

    if (NOT_NULL.equalsIgnoreCase(value)) {
        dc.add(Restrictions.isNotNull(fieldName));
        return;
    }

    dc.add(Restrictions.ilike(fieldName, value, MatchMode.ANYWHERE));
}

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

License:Open Source License

public DetachedCriteria buildCriteria() {
    beforeBuildCriteria();//from w w  w  .  ja  va 2s.  c  o  m
    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. j  a  v a2  s  .  c  o 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 www . j  ava  2s. co  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;
    }
}