Example usage for org.hibernate.criterion Restrictions gt

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

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

Introduction

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

Prototype

public static SimpleExpression gt(String propertyName, Object value)

Source Link

Document

Apply a "greater than" constraint to the named property

Usage

From source file:edu.nps.moves.mmowgli.AbstractMmowgliControllerHelper.java

License:Open Source License

private Criteria getImplementationGreaterThanTL(Float f) {
    if (f == null)
        return null;
    Criteria crit = HSess.get().createCriteria(User.class).add(Restrictions.eq("gameMaster", false))
            .add(Restrictions.gt("innovationScore", f)).addOrder(Order.desc("innovationScore"));
    return crit;//from   www . j a  va2  s.c  o m
}

From source file:edu.nps.moves.mmowgli.cache.MCacheGameEventHelper.java

License:Open Source License

@SuppressWarnings("unchecked")
private List<GameEvent> eventsQuery(Session sess) {
    // Attempt to speed up query
    Long num = (Long) sess.createCriteria(GameEvent.class)
            //.setProjection(Projections.rowCount()).uniqueResult();
            .setProjection(Projections.max("id")).uniqueResult();

    List<GameEvent> evs = null;
    if (num != null) {
        long lowlimit = Math.max(0L, num.longValue() - GAMEEVENTCAPACITY);
        evs = (List<GameEvent>) sess.createCriteria(GameEvent.class).add(Restrictions.gt("id", lowlimit))
                .addOrder(Order.desc("dateTime")).list();
    } else//from  w w w  . jav a  2 s.c om
        evs = new ArrayList<GameEvent>();

    // Old version
    //    List<GameEvent> evs = (List<GameEvent>) sess.createCriteria(GameEvent.class).
    //    addOrder(Order.desc("dateTime")).
    //    setMaxResults(GAMEEVENTCAPACITY).list();
    return evs;
}

From source file:edu.nps.moves.mmowgli.export.BaseExporter.java

License:Open Source License

protected boolean isMultipleMoves(Session session) {
    Game g = Game.get(session);/*from   w w w .  jav a2  s .  c om*/
    if (g.getCurrentMove().getNumber() > 1)
        return true;

    Criteria criteria = session.createCriteria(Card.class).createAlias("createdInMove", "MOVE")
            .add(Restrictions.gt("MOVE.number", 1)).setProjection(Projections.rowCount());

    int count = ((Long) criteria.list().get(0)).intValue();
    if (count > 0)
        return true;

    criteria = session.createCriteria(ActionPlan.class).createAlias("createdInMove", "MOVE")
            .add(Restrictions.gt("MOVE.number", 1)).setProjection(Projections.rowCount());

    count = ((Long) criteria.list().get(0)).intValue();
    return count > 0;
}

From source file:edu.nps.moves.mmowgli.hibernate.HSessionAccessor.java

License:Open Source License

static <T> T getRevision(Class<T> cls, Object id, long revision, Session sess)
//--------------------------------------------------------------------------
{
    MSysOut.println(HIBERNATE_SESSION_LOGS, "Session getRevision of " + cls.getSimpleName() + " " + id
            + " revision: " + revision + " session: " + sess.hashCode());
    List<T> lis = (List<T>) sess.createCriteria(cls).add(Restrictions.eq("id", id))
            .add(Restrictions.gt("revision", revision)).list();
    if (lis.size() > 0)
        return lis.get(0);
    return null;/*from  www.j  a v a 2  s . c  om*/
}

From source file:edu.nps.moves.mmowgli.modules.registrationlogin.RegistrationPagePopupFirst.java

License:Open Source License

@SuppressWarnings("unchecked")
public static Criterion getIntervalRestrictionTL() {
    Game game = Game.getTL();/*w w w . j  ava2 s  .co m*/
    if (!game.isRestrictByQueryListInterval())
        return null;

    Date startDate = null, endDate = null;

    Session piiSess = VHibPii.getASession();
    List<Query2Pii> lis = piiSess.createCriteria(Query2Pii.class)
            .add(Restrictions.eq(QUERY_MARKER_FIELD, QUERY_START_MARKER)).list();
    if (!lis.isEmpty())
        startDate = lis.get(0).getDate();

    lis = piiSess.createCriteria(Query2Pii.class).add(Restrictions.eq(QUERY_MARKER_FIELD, QUERY_END_MARKER))
            .list();
    piiSess.close();

    if (!lis.isEmpty())
        endDate = lis.get(0).getDate();

    if (startDate == null) {
        if (endDate == null)
            return null;
        return Restrictions.lt("date", endDate);
    } else {
        if (endDate == null)
            return Restrictions.gt("date", startDate);
        else
            return Restrictions.between("date", startDate, endDate);
    }
}

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 ww  w  .j a v  a 2s .co 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:es.jpons.persistence.query.CriteriaAllenRelations.java

License:Open Source License

/**
 * Implementation of the after allen rellation.
 *
 * @param initializedCriteria//from w ww.  j  a va2s. c o  m
 * @param pvp
 * @return
 */
public static Criteria after(Criteria initializedCriteria, PossibilisticVTP pvp) {
    initializedCriteria = initializedCriteria.add(Restrictions.gt("pvp.startMP", pvp.getEndMP()));
    return initializedCriteria;
}

From source file:es.jpons.persistence.TemporalPersistenceManager.java

License:Open Source License

/**
 * Function that stablishes the constrains for the temporal insertion.
 *
 * @param c An initialized criteria object.
 * @param validTime The valid time to intert
 * @return A criteria to query the database.
 */// ww w .j  a v  a2 s .  c om
protected Criteria criteriaInsert(Criteria c, PossibilisticVTP validTime, TemporalPK key) {

    if (c == null) {
        return null;
    }
    c = c.add(Restrictions.and(Restrictions.gt("pvp.startMP", validTime.getStartMP()),
            Restrictions.or(
                    Restrictions.and(Restrictions.lt("pvp.startMP", validTime.getEndMP()),
                            Restrictions.gt("pvp.endMP", validTime.getEndMP())),
                    Restrictions.lt("pvp.endMP", validTime.getEndMP())),
            Restrictions.eq("tid.id", key.getId())));

    return c;
}

From source file:es.sm2.openppm.core.dao.ProjectFollowupDAO.java

License:Open Source License

/**
 * followup returns after the date//from w  w w . j  ava 2 s.  c  o  m
 * @param project
 * @param date
 * @return
 */
public Projectfollowup afterFollowup(Project project, Date date) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setMaxResults(1)
            .add(Restrictions.eq(Projectfollowup.PROJECT, project))
            .add(Restrictions.gt(Projectfollowup.FOLLOWUPDATE, date))
            .addOrder(Order.asc(Projectfollowup.FOLLOWUPDATE));

    return (Projectfollowup) crit.uniqueResult();
}

From source file:es.tekniker.framework.ktek.questionnaire.mng.db.QuestionnaireManagerDB.java

License:Open Source License

public Ktek_questionnaire getQuestionnaireModel(int idquestionnaire) {

    Ktek_questionnaire instance = null;//from  ww  w  .  jav  a  2 s .c o m

    PersistentSession session = null;
    DAOFactory lDAOFactory = null;
    Ktek_questionnaireDAO instanceDAO = null;
    Ktek_questionnaireCriteria objKtek_questionnaireCriteria = null;
    long nowInMillis = 0;
    try {
        nowInMillis = Utils.getCalendarGMT().getTimeInMillis();

        session = es.tekniker.framework.ktek.questionnaire.KTEKPersistentManager.instance().getSession();
        session.beginTransaction();

        lDAOFactory = es.tekniker.framework.ktek.questionnaire.DAOFactory.getDAOFactory();
        instanceDAO = lDAOFactory.getKtek_questionnaireDAO();

        objKtek_questionnaireCriteria = new Ktek_questionnaireCriteria();
        objKtek_questionnaireCriteria.isdeleted.eq((short) 0);
        objKtek_questionnaireCriteria.datevalidfrom.lt(nowInMillis);

        objKtek_questionnaireCriteria.add(Restrictions.or(Restrictions.isNull("datevalidto"),
                Restrictions.gt("datevalidto", nowInMillis)));

        objKtek_questionnaireCriteria.ktek_pk_idquestionnaire.eq(idquestionnaire);
        instance = instanceDAO.loadKtek_questionnaireByCriteria(objKtek_questionnaireCriteria);

        session.close();

        if (instance != null) {
            log.debug("getQuestionnaireModel is not null ");
        } else {
            log.debug("getQuestionnaireModel is null ");
        }

    } catch (Exception e) {
        log.error("getQuestionnaireModel Exception " + e.getMessage());
        e.printStackTrace();
        try {
            if (session != null)
                session.close();
        } catch (PersistentException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
    }
    return instance;
}