Example usage for org.hibernate.criterion Restrictions and

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

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

Introduction

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

Prototype

public static LogicalExpression and(Criterion lhs, Criterion rhs)

Source Link

Document

Return the conjuction of two expressions

Usage

From source file:dz.alkhwarizmix.framework.java.dao.impl.RecordDAO.java

License:Open Source License

private Record getRecordFromHibernate(final Record recordToGet) throws AlKhwarizmixException {
    try {/* w w w.  j av  a  2s. co  m*/
        Record result = null;
        final Criteria criteria = getHibernateCurrentSession().createCriteria(Record.class);
        criteria.add(Restrictions.and(getEqualsRecordIdCriterion(recordToGet),
                getEqualsParentCriterion(recordToGet)));
        result = (Record) criteria.uniqueResult();
        return result;
    } catch (final DataAccessException e) {
        final AlKhwarizmixException ex = new AlKhwarizmixException(AlKhwarizmixErrorCode.ERROR_DATABASE, e);
        throw ex;
    }
}

From source file:dz.alkhwarizmix.framework.java.dao.impl.RecordDAO.java

License:Open Source License

/**
 *///from w w w  . j  av  a 2  s. c om
@Override
public Encryption getEncryption(final Encryption encryptionToGet) throws AlKhwarizmixException {
    try {
        Encryption result = null;
        final Criteria criteria = getHibernateCurrentSession().createCriteria(Encryption.class);
        criteria.add(Restrictions.and(getEqualsEncryptionIdCriterion(encryptionToGet),
                getEqualsUserCriterion(encryptionToGet)));
        result = (Encryption) criteria.uniqueResult();
        return result;
    } catch (final DataAccessException e) {
        throw new AlKhwarizmixException(AlKhwarizmixErrorCode.ERROR_DATABASE, e);
    }
}

From source file:edu.northwestern.bioinformatics.studycalendar.dao.delta.AmendmentDao.java

License:BSD License

@SuppressWarnings({ "unchecked" })
public Amendment getByNaturalKey(String key, Study study) {
    final Amendment.Key keyParts = Amendment.decomposeNaturalKey(key);
    List<Amendment> results = getHibernateTemplate().executeFind(new HibernateCallback() {
        public Object doInHibernate(Session session) throws HibernateException {
            //need to have both "lt & ge" or "eq" criterias to work on Oracle and Postgres dbs for date with timestamp.
            Criteria crit = session.createCriteria(Amendment.class)
                    .add(Restrictions.disjunction()
                            .add(Restrictions.and(Restrictions.lt("date", keyParts.getDateNext()),
                                    Restrictions.ge("date", keyParts.getDate())))
                            .add(Restrictions.eq("date", keyParts.getDate())));
            if (keyParts.getName() != null)
                crit.add(Restrictions.eq("name", keyParts.getName()));
            crit.addOrder(Order.asc("name"));
            return crit.list();
        }//from   w  ww .  j ava 2 s . c  o m
    });
    // filter out amendments for other studies
    for (Iterator<Amendment> it = results.iterator(); it.hasNext();) {
        Amendment result = it.next();
        if (!study.hasAmendment(result))
            it.remove();
    }
    if (results.size() == 0) {
        return null;
    } else if (results.size() > 1) {
        // if there's one with this date and no name, it matches
        for (Amendment result : results)
            if (result.getName() == null)
                return result;

        List<String> resultKeys = new ArrayList<String>(results.size());
        for (Amendment result : results)
            resultKeys.add(result.getNaturalKey());
        throw new StudyCalendarValidationException(
                "More than one amendment could match %s: %s.  Please be more specific.", key,
                StringUtils.join(resultKeys.iterator(), ", "));
    } else {
        return results.get(0);
    }
}

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

License:Open Source License

/**
 * Checks to see if a new snapshot of size volSize will exceed the quota
 * @param volSize/* w w w. ja v  a2 s.com*/
 * @return
 */
private boolean totalSnapshotSizeLimitExceeded(String snapshotId, int volSize) throws EucalyptusCloudException {

    int totalSnapshotSize = 0;
    EntityTransaction dbTrans = Entities.get(SnapshotInfo.class);
    Criteria query = Entities.createCriteria(SnapshotInfo.class);
    query.setReadOnly(true);

    //TODO: zhill, fix this logic by adding a size value to the snapshot record, should do the calculation on the DB
    // this will be very poor for performance as the number of snapshots increases.

    //Only look for snaps that are not failed and not error
    query.add(Restrictions
            .not(Restrictions.and(Restrictions.eq("status", StorageProperties.Status.failed.toString()),
                    Restrictions.eq("status", StorageProperties.Status.error.toString()))));
    try {
        List<SnapshotInfo> snapInfos = (List<SnapshotInfo>) query.list();
        for (SnapshotInfo sInfo : snapInfos) {
            try {
                totalSnapshotSize += blockManager.getSnapshotSize(sInfo.getSnapshotId());
            } catch (EucalyptusCloudException e) {
                LOG.error(e);
            }
        }
        int sizeLimitGB = WalrusInfo.getWalrusInfo().getStorageMaxTotalSnapshotSizeInGb();
        LOG.debug("Snapshot " + snapshotId + " checking snapshot total size of  " + totalSnapshotSize
                + " against limit of " + sizeLimitGB);
        return (totalSnapshotSize + volSize) > sizeLimitGB;
    } catch (final Throwable e) {
        LOG.error("Error finding total snapshot used size " + e.getMessage());
        throw new EucalyptusCloudException("Failed to check snapshot total size limit", e);
    } finally {
        if (dbTrans.isActive()) {
            dbTrans.rollback();
        }
    }

}

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();/*  w  w  w .j  ava2 s .  c  o m*/
    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  ww  w .  j a  va2s.  c  om
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:edu.wisc.my.portlets.bookmarks.dao.hibernate.HibernateBookmarkStore.java

License:Apache License

/**
 * @see edu.wisc.my.portlets.bookmarks.dao.BookmarkStore#getBookmarkSet(java.lang.String, java.lang.String)
 *//* w  w  w . j  a  v a 2s  . c  o  m*/
public BookmarkSet getBookmarkSet(String owner, String name) {
    try {
        final Session session = this.getSession(false);

        final Criteria c = session.createCriteria(BookmarkSet.class);
        c.add(Restrictions.and(this.smartEqual(PARAM_NAME, name), this.smartEqual(PARAM_OWNER, owner)));
        c.setCacheable(true);

        final BookmarkSet bs = (BookmarkSet) c.uniqueResult();

        return bs;
    } catch (HibernateException ex) {
        throw convertHibernateAccessException(ex);
    }
}

From source file:edu.wisc.my.portlets.bookmarks.dao.hibernate.HibernatePreferencesStore.java

License:Apache License

/**
 * @see edu.wisc.my.portlets.bookmarks.dao.PreferencesStore#getPreferences(java.lang.String, java.lang.String)
 *///from  w  ww. j a va  2 s .co  m
public Preferences getPreferences(String owner, String name) {
    try {
        final Session session = this.getSession(false);

        final Criteria c = session.createCriteria(Preferences.class);
        c.add(Restrictions.and(this.smartEqual(PARAM_NAME, name), this.smartEqual(PARAM_OWNER, owner)));
        c.setCacheable(true);

        final Preferences bs = (Preferences) c.uniqueResult();

        return bs;
    } catch (HibernateException ex) {
        throw convertHibernateAccessException(ex);
    }
}

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

License:Open Source License

private static void configureClientAndServiceProviderFilters(Criteria criteria, ClientId client,
        ClientId serviceProvider) {/*from www  .  j a  v a  2s .  com*/
    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:eionet.webq.dao.ProjectFileStorageImpl.java

License:Mozilla Public License

@Override
public ProjectFile findByNameAndProject(String name, ProjectEntry projectEntry) {
    return (ProjectFile) getCriteria()
            .add(Restrictions.and(eq("projectId", projectEntry.getId()), eq("file.name", name))).uniqueResult();
}