Example usage for org.hibernate.criterion Restrictions or

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

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

Introduction

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

Prototype

public static LogicalExpression or(Criterion lhs, Criterion rhs)

Source Link

Document

Return the disjuction of two expressions

Usage

From source file:edu.northwestern.bioinformatics.studycalendar.dao.SubjectDao.java

License:BSD License

/**
 * Finds the subjects doing a LIKE search with some search text for subject's firs name, middle name or last name.
 *
 * @param  searchText the text we are searching with
 * @return      a list of subjects found based on the search text
 *//*from  w  ww  .java 2 s . c o m*/
@SuppressWarnings({ "unchecked" })
public List<Subject> searchByName(final String searchText) {
    return (List<Subject>) getHibernateTemplate().execute(new HibernateCallback() {
        public Object doInHibernate(Session session) throws HibernateException, SQLException {
            Criteria criteria = session.createCriteria(Subject.class);
            if (searchText != null) {
                String like = new StringBuilder().append("%").append(searchText.toLowerCase()).append("%")
                        .toString();
                criteria.add(Restrictions.or(Restrictions.or(Restrictions.ilike("firstName", like),
                        Restrictions.ilike("lastName", like)), Restrictions.ilike("personId", like)));
            }
            return criteria.list();
        }
    });
}

From source file:edu.ucsb.eucalyptus.cloud.ws.WalrusManager.java

License:Open Source License

public ListVersionsResponseType listVersions(ListVersionsType request) throws EucalyptusCloudException {
    ListVersionsResponseType reply = (ListVersionsResponseType) request.getReply();
    String bucketName = request.getBucket();
    Context ctx = Contexts.lookup();
    Account account = ctx.getAccount();/*from w  w w.jav a  2 s.  c  om*/
    String prefix = request.getPrefix();
    if (prefix == null) {
        prefix = "";
    }

    String keyMarker = request.getKeyMarker();
    String versionMarker = request.getVersionIdMarker();

    int maxKeys = -1;
    String maxKeysString = request.getMaxKeys();
    if (maxKeysString != null) {
        maxKeys = Integer.parseInt(maxKeysString);
    } else {
        maxKeys = WalrusProperties.MAX_KEYS;
    }

    String delimiter = request.getDelimiter();

    EntityWrapper<BucketInfo> db = EntityWrapper.get(BucketInfo.class);
    BucketInfo bucketInfo = new BucketInfo(bucketName);
    bucketInfo.setHidden(false);
    List<BucketInfo> bucketList = db.queryEscape(bucketInfo);

    Hashtable<String, PrefixEntry> prefixes = new Hashtable<String, PrefixEntry>();

    if (bucketList.size() > 0) {
        BucketInfo bucket = bucketList.get(0);
        BucketLogData logData = bucket.getLoggingEnabled() ? request.getLogData() : null;

        if (ctx.hasAdministrativePrivileges() || (bucket.canRead(account.getAccountNumber())
                && (bucket.isGlobalRead() || Lookups.checkPrivilege(PolicySpec.S3_LISTBUCKETVERSIONS,
                        PolicySpec.VENDOR_S3, PolicySpec.S3_RESOURCE_BUCKET, bucketName, null)))) {

            if (bucket.isVersioningDisabled()) {
                db.rollback();
                throw new EucalyptusCloudException("Versioning has not been enabled for bucket: " + bucketName);
            }

            if (logData != null) {
                updateLogData(bucket, logData);
                reply.setLogData(logData);
            }

            if (Contexts.lookup().hasAdministrativePrivileges()) {
                try {
                    if (bucketHasSnapshots(bucketName)) {
                        db.rollback();
                        throw new NoSuchBucketException(bucketName);
                    }
                } catch (Exception e) {
                    db.rollback();
                    throw new EucalyptusCloudException(e);
                }
            }

            reply.setName(bucketName);
            reply.setIsTruncated(false);
            reply.setPrefix(prefix);
            if (maxKeys >= 0) {
                reply.setMaxKeys(maxKeys);
            }
            if (delimiter != null) {
                reply.setDelimiter(delimiter);
            }
            if (maxKeys == 0) {
                //No keys requested, so just return
                reply.setVersions(new ArrayList<VersionEntry>());
                db.commit();
                return reply;
            }

            final int queryStrideSize = maxKeys + 1;
            EntityWrapper<ObjectInfo> dbObject = db.recast(ObjectInfo.class);

            ObjectInfo searchObj = new ObjectInfo();
            searchObj.setBucketName(bucketName);
            //searchObj.setLast(true);
            searchObj.setDeleted(false);

            Criteria objCriteria = dbObject.createCriteria(ObjectInfo.class);
            objCriteria.add(Example.create(searchObj));
            objCriteria.addOrder(Order.asc("objectKey"));
            objCriteria.addOrder(Order.desc("lastModified"));
            objCriteria.setMaxResults(queryStrideSize); //add one to, hopefully, indicate truncation in one call                                    

            if (keyMarker != null) {
                if (versionMarker != null) {
                    Date resumeDate = null;
                    try {
                        ObjectInfo markerObj = new ObjectInfo();
                        markerObj.setBucketName(bucketName);
                        markerObj.setVersionId(versionMarker);
                        markerObj.setObjectKey(keyMarker);
                        ObjectInfo lastFromPrevObj = dbObject.uniqueResultEscape(markerObj);
                        if (lastFromPrevObj != null && lastFromPrevObj.getLastModified() != null) {
                            resumeDate = lastFromPrevObj.getLastModified();
                        } else {
                            throw new NoSuchEntityException("VersionIDMarker " + versionMarker
                                    + " does not match an existing object version");
                        }
                    } catch (TransactionException e) {
                        LOG.error(e);
                        dbObject.rollback();
                        throw new EucalyptusCloudException("Next-Key-Marker or Next-Version-Id marker invalid");
                    }
                    objCriteria.add(Restrictions.or(
                            Restrictions.and(Restrictions.ge("objectKey", keyMarker),
                                    Restrictions.le("lastModified", resumeDate)),
                            Restrictions.gt("objectKey", keyMarker)));
                } else {
                    objCriteria.add(Restrictions.ge("objectKey", keyMarker));
                }
            }

            if (prefix != null && !prefix.equals("")) {
                objCriteria.add(Restrictions.like("objectKey", prefix, MatchMode.START));
            }

            List<ObjectInfo> objectInfos = null;
            int resultKeyCount = 0;
            String objectKey = null;
            String[] parts = null;
            String prefixString = null;
            ArrayList<VersionEntry> versions = new ArrayList<VersionEntry>(); //contents for reply
            ArrayList<DeleteMarkerEntry> deleteMarkers = new ArrayList<DeleteMarkerEntry>(); //delete markers for reply                  

            //Iterate over result sets of size maxkeys + 1
            do {
                objectKey = null;
                parts = null;
                prefixString = null;
                if (resultKeyCount > 0) { //Start from end of last round-trip if necessary
                    objCriteria.setFirstResult(queryStrideSize);
                }

                objectInfos = (List<ObjectInfo>) objCriteria.list();

                if (objectInfos.size() > 0) {
                    for (ObjectInfo objectInfo : objectInfos) {
                        objectKey = objectInfo.getObjectKey();

                        //Look for Delete markers
                        if (objectInfo.getDeleted()) {
                            //
                        }

                        //Check if it will get aggregated as a commonprefix
                        if (delimiter != null) {
                            parts = objectKey.substring(prefix.length()).split(delimiter);
                            if (parts.length > 1) {
                                prefixString = parts[0] + delimiter;
                                if (!prefixes.containsKey(prefixString)) {
                                    if (resultKeyCount == maxKeys) {
                                        //This is a new record, so we know we're truncating if this is true
                                        reply.setNextKeyMarker(objectKey);
                                        reply.setNextVersionIdMarker(objectInfo.getVersionId());
                                        reply.setIsTruncated(true);
                                        resultKeyCount++;
                                        break;
                                    }

                                    prefixes.put(prefixString, new PrefixEntry(prefixString));
                                    resultKeyCount++; //count the unique commonprefix as a single return entry                                 
                                }
                                continue;
                            }
                        }

                        if (resultKeyCount == maxKeys) {
                            //This is a new (non-commonprefix) record, so we know we're truncating
                            reply.setNextKeyMarker(objectKey);
                            reply.setNextVersionIdMarker(objectInfo.getVersionId());
                            reply.setIsTruncated(true);
                            resultKeyCount++;
                            break;
                        }

                        if (!objectInfo.getDeleted()) {
                            VersionEntry versionEntry = new VersionEntry();
                            versionEntry.setKey(objectKey);
                            versionEntry.setVersionId(objectInfo.getVersionId());
                            versionEntry.setEtag(objectInfo.getEtag());
                            versionEntry
                                    .setLastModified(DateUtils.format(objectInfo.getLastModified().getTime(),
                                            DateUtils.ISO8601_DATETIME_PATTERN) + ".000Z");
                            try {
                                String displayName = Accounts.lookupAccountById(objectInfo.getOwnerId())
                                        .getName();
                                versionEntry
                                        .setOwner(new CanonicalUserType(objectInfo.getOwnerId(), displayName));

                            } catch (AuthException e) {
                                db.rollback();
                                throw new AccessDeniedException("Bucket", bucketName, logData);
                            }
                            versionEntry.setSize(objectInfo.getSize());
                            versionEntry.setStorageClass(objectInfo.getStorageClass());
                            versionEntry.setIsLatest(objectInfo.getLast());
                            versions.add(versionEntry);
                        } else {
                            DeleteMarkerEntry deleteMarkerEntry = new DeleteMarkerEntry();
                            deleteMarkerEntry.setKey(objectKey);
                            deleteMarkerEntry.setVersionId(objectInfo.getVersionId());
                            deleteMarkerEntry
                                    .setLastModified(DateUtils.format(objectInfo.getLastModified().getTime(),
                                            DateUtils.ISO8601_DATETIME_PATTERN) + ".000Z");

                            try {
                                String ownerId = objectInfo.getOwnerId();
                                String displayName = Accounts.lookupAccountById(ownerId).getName();
                                deleteMarkerEntry.setOwner(new CanonicalUserType(ownerId, displayName));
                            } catch (AuthException e) {
                                db.rollback();
                                throw new AccessDeniedException("Bucket", bucketName, logData);
                            }
                            deleteMarkerEntry.setIsLatest(objectInfo.getLast());
                            deleteMarkers.add(deleteMarkerEntry);
                        }

                        resultKeyCount++;
                    }
                }
                if (resultKeyCount <= maxKeys && objectInfos.size() <= maxKeys) {
                    break;
                }
            } while (resultKeyCount <= maxKeys);

            reply.setDeleteMarkers(deleteMarkers);
            reply.setVersions(versions);

            //Sort the prefixes from the hashtable and add to the reply
            if (prefixes != null && prefixes.size() > 0) {
                ArrayList<PrefixEntry> prefixList = new ArrayList<PrefixEntry>();
                prefixList.addAll(prefixes.values());

                Collections.sort(prefixList, new Comparator<PrefixEntry>() {
                    public int compare(PrefixEntry e1, PrefixEntry e2) {
                        return e1.getPrefix().compareTo(e2.getPrefix());
                    }
                });
                reply.setCommonPrefixes(prefixList);
            }

        } else {
            db.rollback();
            throw new AccessDeniedException("Bucket", bucketName, logData);
        }
    } else {
        db.rollback();
        throw new NoSuchBucketException(bucketName);
    }
    db.commit();
    return reply;
}

From source file:edu.utah.further.core.data.hibernate.query.CriterionBuilderHibernateImpl.java

License:Apache License

/**
 *
 *//*from  w w  w  . j a  va2 s . co m*/
private void visitBinary() {
    final SearchType searchType = criterion.getSearchType();
    switch (searchType) {
    case INTERSECTION:
    case AND: {
        result = Restrictions.and(convertedCriteria.get(0), convertedCriteria.get(1));
        break;
    }

    case UNION:
    case OR: {
        result = Restrictions.or(convertedCriteria.get(0), convertedCriteria.get(1));
        break;
    }

    default: {
        throw new BusinessRuleException(unsupportedMessage(searchType));
    }
    }
}

From source file:ee.ria.xroad.opmonitordaemon.OperationalDataRecordManager.java

License:Open Source License

private static void configureClientAndServiceProviderFilters(Criteria criteria, ClientId client,
        ClientId serviceProvider) {/*w w w. ja  va 2 s .c  om*/
    if (client != null) {
        if (serviceProvider != null) {
            // Filter by both the client and the service provider
            // using the fields corresponding to their roles.
            criteria.add(Restrictions.and(
                    Restrictions.or(getMemberCriterion(client, true), getMemberCriterion(client, false)),
                    getMemberCriterion(serviceProvider, false)));
        } else {
            // Filter by the client in either roles (client or
            // service provider).
            criteria.add(Restrictions.or(getMemberCriterion(client, true), getMemberCriterion(client, false)));
        }
    } else {
        if (serviceProvider != null) {
            // Filter by the service provider in its respective role.
            criteria.add(getMemberCriterion(serviceProvider, false));
        }
    }
}

From source file:es.emergya.bbdd.dao.IncidenciaHome.java

License:Open Source License

/**
 * Devuelve todas las incidencias que estuvieron abiertas en el intervalo
 * pasado y su posicin coincide con alguna de las zonas indicadas. Si no se
 * pasan zonas, la posicin no se utilizar como criterio para obtener la
 * lista de incidencias./*from  w w w  .j ava2  s .  c  o m*/
 * 
 * @param nombreUsuario
 *            el nombre de usuario del usuario que realiza la consulta.
 * @param fechaInicio
 *            el instante inicial a usar en el filtro.
 * @param fechaFinal
 *            el instante final a usar en el filtro.
 * @param zonas
 *            Lista de zonas en las que deben estar las incidencias.
 * @return La lista de zonas que estuvieron abiertas en algn momento del
 *         periodo en alguna de las zonas pasadas.
 */
@Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
public List<Incidencia> getIncidenciasEnPeriodo(String nombreUsuario, Calendar fechaInicio,
        Calendar fechaFinal) {
    Date inicio = null;
    Date fin = null;

    if (fechaInicio != null) {
        inicio = fechaInicio.getTime();
    } else {
        return new ArrayList<Incidencia>(0);
    }
    if (fechaFinal != null) {
        fin = fechaFinal.getTime();
    } else {
        return new ArrayList<Incidencia>(0);
    }

    Criteria c = getSession().createCriteria(Incidencia.class).addOrder(Order.asc("referenciaHumana"))
            .setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY)
            .createAlias("street", "st", Criteria.LEFT_JOIN).createAlias("portal", "pt", Criteria.LEFT_JOIN);
    if (fin != null) {
        c = c.add(Restrictions.le("fechaCreacion", fin));
    }
    if (inicio != null) {
        c = c.add(Restrictions.or(Restrictions.ge("fechaCierre", inicio),
                Property.forName("fechaCierre").isNull()));
    }

    log.trace("Criteria final: " + c);

    return c.list();
}

From source file:es.emergya.bbdd.dao.RecursoHome.java

License:Open Source License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true, rollbackFor = Throwable.class, propagation = Propagation.REQUIRED)
public Recurso[] getNotAsigned(Patrulla p) {
    Recurso[] res = new Recurso[0];
    try {//from  w  w  w . j a  v  a2  s.  c o  m
        if (p == null || p.getId() == null) {
            return getByFilter(filter).toArray(new Recurso[0]);
        }
        log.debug("getNotAsigned(" + p.getId() + ")");
        Session currentSession = getSession();
        currentSession.clear();
        Criterion rhs = Restrictions.isNull("patrullas");
        Criterion lhs = Restrictions.ne("patrullas", currentSession.load(Patrulla.class, p.getId()));
        Criteria criteria = currentSession.createCriteria(Recurso.class)
                .add(Restrictions.eq("habilitado", true)).add(Restrictions.or(lhs, rhs));
        criteria = criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
        res = ((List<Recurso>) criteria.list()).toArray(new Recurso[0]);

        for (Recurso r : res)
            try {
                r.getPatrullas().getId();
            } catch (Throwable t) {
            }

    } catch (Throwable t) {
        log.error(t, t);
    }
    return res;
}

From source file:es.emergya.bbdd.dao.RecursoHome.java

License:Open Source License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true, rollbackFor = Throwable.class, propagation = Propagation.REQUIRES_NEW)
public Recurso[] getNotAsigned(Flota p) {
    Recurso[] res = new Recurso[0];
    if (p == null || p.getId() == null) {
        return getByFilter(new Recurso()).toArray(new Recurso[0]);
    }/*from   w w  w  .j  ava2 s .  co m*/
    try {
        log.debug("getNotAsigned(" + p.getId() + ")");
        Session currentSession = getSession();
        currentSession.clear();
        Criterion rhs = Restrictions.isNull("flotas");
        Criterion lhs = Restrictions.ne("flotas", currentSession.load(Patrulla.class, p.getId()));
        Criteria criteria = currentSession.createCriteria(Recurso.class).add(Restrictions.or(lhs, rhs));
        criteria = criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
        res = ((List<Recurso>) criteria.list()).toArray(new Recurso[0]);

        for (Recurso r : res)
            try {
                r.getFlotas().getId();
            } catch (Throwable t) {
            }
    } catch (Throwable t) {
        log.error(t, t);
    }
    return res;
}

From source file:es.jpons.persistence.query.CriteriaAllenRelations.java

License:Open Source License

/**
 * Implements the during criteria//  w  w w . j  av a2  s . com
 *
 * @param initializedCriteria
 * @param pvp
 * @return
 */
public static Criteria during(Criteria initializedCriteria, PossibilisticVTP pvp) {
    Long jstart = pvp.getStartMP();
    Long jright = pvp.getEndMP() + pvp.getEndRight();
    Long jleft = pvp.getStartMP() - pvp.getStartLeft();
    Long jend = pvp.getEndMP();

    initializedCriteria = initializedCriteria.add(Restrictions.or(
            Restrictions.and(Restrictions.sqlRestriction("({alias}.startMP ) > ?", jstart, LongType.INSTANCE),
                    Restrictions.sqlRestriction("{alias}.endMP <= ?", jright, LongType.INSTANCE)),
            Restrictions.and(Restrictions.sqlRestriction("({alias}.startMP ) >= ?", jleft, LongType.INSTANCE),
                    Restrictions.sqlRestriction("{alias}.endMP < ?", jend, LongType.INSTANCE))));

    return initializedCriteria;

}

From source file:es.jpons.persistence.query.CriteriaAllenRelations.java

License:Open Source License

/**
 * Implements the contains/*from  w  w  w  .  j  a  v  a  2  s .  c om*/
 *
 * @param initializedCriteria
 * @param pvp
 * @return
 */
public static Criteria contains(Criteria initializedCriteria, PossibilisticVTP pvp) {
    Long jstart = pvp.getStartMP();
    Long jright = pvp.getStartMP() + pvp.getStartRight();
    Long jleft = pvp.getEndMP() - pvp.getEndLeft();
    Long jend = pvp.getEndMP();

    initializedCriteria = initializedCriteria.add(Restrictions.or(
            Restrictions.and(Restrictions.sqlRestriction("({alias}.startMP ) < ?", jstart, LongType.INSTANCE),
                    Restrictions.sqlRestriction("{alias}.endMP >= ?", jleft, LongType.INSTANCE)),
            Restrictions.and(Restrictions.sqlRestriction("({alias}.startMP ) <= ?", jright, LongType.INSTANCE),
                    Restrictions.sqlRestriction("{alias}.endMP > ?", jend, LongType.INSTANCE))));

    return initializedCriteria;

}

From source file:es.jpons.persistence.query.CriteriaAllenRelations.java

License:Open Source License

public static Criteria equals(Criteria initializedCriteria, PossibilisticVTP pvp) {

    initializedCriteria = initializedCriteria.add(Restrictions.and(
            Restrictions.or(
                    Restrictions.sqlRestriction("({alias}.startMP + {alias}.startRight ) <= ?",
                            pvp.getStartMP() - pvp.getStartLeft(), LongType.INSTANCE),
                    Restrictions.sqlRestriction("({alias}.startMP - {alias}.startLeft ) >= ?",
                            pvp.getStartMP() + pvp.getStartRight(), LongType.INSTANCE)),
            Restrictions.or(/*  w  ww  . j av a2s  .  c  om*/
                    Restrictions.sqlRestriction("({alias}.endMP + {alias}.endRight ) <= ?",
                            pvp.getEndMP() - pvp.getEndLeft(), LongType.INSTANCE),
                    Restrictions.sqlRestriction("({alias}.endMP - {alias}.endLeft ) >= ?",
                            pvp.getEndMP() + pvp.getEndRight(), LongType.INSTANCE))));

    return initializedCriteria;
}