Example usage for org.hibernate.criterion Restrictions ne

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

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

Introduction

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

Prototype

public static SimpleExpression ne(String propertyName, Object value)

Source Link

Document

Apply a "not equal" constraint to the named property

Usage

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

License:Apache License

@SuppressWarnings("unchecked")
public List<HashTag> getListHashTagsByKeyword(final String keyword, final Integer maxResults,
        final Long[] excludes) {
    log.info("keyword " + keyword);
    List<HashTag> searchResult = (List) getHibernateTemplate().execute(new HibernateCallback() {
        @SuppressWarnings("deprecation")
        public Object doInHibernate(org.hibernate.Session session) {
            final Criteria criteria = session.createCriteria(HashTag.class);
            // limit results
            if (maxResults != null) {
                criteria.setMaxResults(maxResults.intValue());
            }//from  w ww.  j  a  v  a  2s .c  o m
            if (excludes != null && excludes.length > 0) {
                for (int i = 0; i < excludes.length; i++) {
                    log.debug("excluding hashtag... " + excludes[i]);
                    criteria.add(Restrictions.ne("hashTagId", excludes[i]));
                }
            }
            final QueryBuilder<HashTag> query = new QueryBuilder<>(getSessionFactory());
            List<HashTag> results = query.build(criteria, keyword, maxResults, 0, new String[] { "hashTag" },
                    "hashTag", HashTag.class);
            return results;
        }
    });
    return searchResult;
}

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  ww  w .ja v  a  2  s. c o  m
    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.faster.orm.criteria.GenericCriteria.java

License:Open Source License

public DetachedCriteria buildCriteria() {
    beforeBuildCriteria();/*  w w w.ja  va  2  s .  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 w w.j av  a2s.com*/
        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.gaixie.micrite.enterprise.dao.hibernate.EnterpriseDAOImpl.java

@SuppressWarnings("unchecked")
public List<Enterprise> advancedFindByPerPage(SearchBean[] queryBean, int start, int limit) {
    DetachedCriteria criteria = SearchFactory.generateCriteria(Enterprise.class, queryBean);
    criteria.add(Restrictions.ne("id", SYS_RECORD_ID));
    criteria.add(Expression.eq("status", IEnterpriseService.STATUS_NORMAL));
    criteria.addOrder(Order.desc("editDate"));
    return getHibernateTemplate().findByCriteria(criteria, start, limit);
}

From source file:org.gaixie.micrite.enterprise.dao.hibernate.EnterpriseDAOImpl.java

public int advancedFindCount(SearchBean[] queryBean) {
    DetachedCriteria criteria = SearchFactory.generateCriteria(Enterprise.class, queryBean);
    criteria.add(Restrictions.ne("id", SYS_RECORD_ID));
    criteria.add(Expression.eq("status", IEnterpriseService.STATUS_NORMAL));
    criteria.setProjection(Projections.rowCount());
    return (Integer) getHibernateTemplate().findByCriteria(criteria).get(0);
}

From source file:org.gaixie.micrite.enterprise.dao.hibernate.EnterpriseDAOImpl.java

public int findByCreateDateSpacingCount(Date startDate, Date endDate, int EnterpriseSourceType) {
    DetachedCriteria criteria = DetachedCriteria.forClass(Enterprise.class);
    criteria.createAlias("enterpriseSource8", "cs");
    if (0 != EnterpriseSourceType) {
        criteria.add(Expression.eq("cs.id", EnterpriseSourceType));
    }//from   ww w.  j av a 2s.  co  m
    criteria.add(Expression.between("createDate", startDate, endDate));
    criteria.add(Restrictions.ne("id", 1));
    criteria.setProjection(Projections.rowCount());
    return (Integer) getHibernateTemplate().findByCriteria(criteria).get(0);
}

From source file:org.gaixie.micrite.enterprise.dao.hibernate.EnterpriseDAOImpl.java

@SuppressWarnings("unchecked")
public List<Enterprise> findByCreateDateSpacingPerPage(Date startDate, Date endDate, int start, int limit,
        int EnterpriseSourceType) {
    DetachedCriteria criteria = DetachedCriteria.forClass(Enterprise.class);
    criteria.createAlias("enterpriseSource8", "cs");
    if (0 != EnterpriseSourceType) {
        criteria.add(Expression.eq("cs.id", EnterpriseSourceType));
    }/*w w  w.j av a2  s  .  c o  m*/
    criteria.add(Expression.between("createDate", startDate, endDate));
    criteria.add(Restrictions.ne("id", SYS_RECORD_ID));
    return getHibernateTemplate().findByCriteria(criteria, start, limit);
}

From source file:org.gaixie.micrite.enterprise.dao.hibernate.EnterpriseDAOImpl.java

@SuppressWarnings("unchecked")
public List findCSGroupByTelVague(SearchBean[] queryBean) {
    DetachedCriteria criteria = SearchFactory.generateCriteria(Enterprise.class, queryBean);
    criteria.add(Restrictions.ne("id", SYS_RECORD_ID));
    criteria.createAlias("qualification", "cs");
    criteria.setProjection(Projections.projectionList().add(Projections.count("cs.name"))
            .add(Projections.groupProperty("cs.name")));
    return getHibernateTemplate().findByCriteria(criteria);
}

From source file:org.gaixie.micrite.enterprise.dao.hibernate.EnterpriseDAOImpl.java

@Override
public boolean existEnterprise(Integer id, String license) {
    // TODO Auto-generated method stub
    DetachedCriteria criteria = DetachedCriteria.forClass(Enterprise.class);
    criteria.add(Expression.eq("status", IEnterpriseService.STATUS_NORMAL));
    criteria.setProjection(Projections.rowCount());
    criteria.add(Restrictions.ne("id", SYS_RECORD_ID));
    criteria.add(Expression.eq("license", license));
    if (id != null) {
        criteria.add(Expression.ne("id", id));
    }//ww w.ja v  a 2  s . co  m
    return ((Integer) getHibernateTemplate().findByCriteria(criteria).get(0)) > 0;
}