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:com.db4o.drs.hibernate.impl.HibernateReplicationProvider.java

License:Open Source License

private Collection getChangedObjectsSinceLastReplication(PersistentClass persistentClass) {
    Criteria criteria = getSession().createCriteria(ObjectReference.class);
    long lastReplicationVersion = getLastReplicationVersion();
    criteria.add(Restrictions.gt(ObjectReference.Fields.VERSION, lastReplicationVersion));
    criteria.add(Restrictions.lt(ObjectReference.Fields.VERSION, _commitTimestamp));
    Disjunction disjunction = Restrictions.disjunction();

    List<String> names = new ArrayList<String>();
    names.add(persistentClass.getClassName());
    if (persistentClass.hasSubclasses()) {
        final Iterator it = persistentClass.getSubclassClosureIterator();
        while (it.hasNext()) {
            PersistentClass subC = (PersistentClass) it.next();
            names.add(subC.getClassName());
        }//from   ww  w . j  a  v  a  2  s .c o  m
    }

    for (String s : names)
        disjunction.add(Restrictions.eq(ObjectReference.Fields.CLASS_NAME, s));

    criteria.add(disjunction);

    Set out = new HashSet();
    for (Object o : criteria.list()) {
        ObjectReference ref = (ObjectReference) o;
        out.add(getSession().load(persistentClass.getRootClass().getClassName(), ref.getTypedId()));
    }
    return out;
}

From source file:com.denimgroup.threadfix.data.dao.hibernate.VulnerabilitySearchCriteriaConstructor.java

License:Mozilla Public License

private void addDateRangeRestrictions() {
    if (parameters.getStartDate() != null || parameters.getEndDate() != null) {

        if (parameters.getStartDate() != null) {
            Calendar targetDate = Calendar.getInstance();
            targetDate.setTime(parameters.getStartDate());

            LOG.debug("Adding start date " + targetDate);
            criteria.add(Restrictions.gt("openTime", targetDate));
        }// www .  jav  a 2  s  . co  m

        if (parameters.getEndDate() != null) {
            Calendar targetDate = Calendar.getInstance();
            targetDate.setTime(parameters.getEndDate());

            LOG.debug("Adding end date " + targetDate);
            criteria.add(Restrictions.lt("openTime", targetDate));
        }
    }

    if (parameters.getStartCloseDate() != null || parameters.getEndCloseDate() != null) {

        if (parameters.getStartCloseDate() != null) {
            Calendar targetDate = Calendar.getInstance();
            targetDate.setTime(parameters.getStartCloseDate());

            LOG.debug("Adding start close date " + targetDate);
            criteria.add(Restrictions.or(Restrictions.eq("closeTime", null),
                    Restrictions.gt("closeTime", targetDate)));
        }

        if (parameters.getEndCloseDate() != null) {
            Calendar targetDate = Calendar.getInstance();
            targetDate.setTime(parameters.getEndCloseDate());

            LOG.debug("Adding end close date " + targetDate);
            criteria.add(Restrictions.or(Restrictions.eq("closeTime", null),
                    Restrictions.lt("closeTime", targetDate)));
        }
    }
}

From source file:com.denimgroup.threadfix.data.dao.hibernate.VulnerabilitySearchCriteriaConstructor.java

License:Mozilla Public License

private void addAgeRestrictions() {
    // Limit scanner if present
    if (parameters.getDaysOldModifier() != null
            && (parameters.getDaysOldModifier().equals("Less")
                    || parameters.getDaysOldModifier().equals("More"))
            && parameters.getDaysOld() != null && parameters.getDaysOld() > 0) {

        Criteria subCriteria = session.createCriteria(Finding.class);

        Calendar targetDate = Calendar.getInstance();
        targetDate.add(Calendar.DAY_OF_YEAR, -parameters.getDaysOld());

        subCriteria.createAlias("scan", "scanAlias");
        if (parameters.getDaysOldModifier().equals("More")) {
            //subCriteria.add(Restrictions.lt("scanAlias.openTime", targetDate));
            criteria.add(Restrictions.lt("openTime", targetDate));
            LOG.debug("Set age restriction to after " + parameters.getDaysOld() + " days ago.");
        } else if (parameters.getDaysOldModifier().equals("Less")) {
            //subCriteria.add(Restrictions.gt("scanAlias.openTime", targetDate));
            criteria.add(Restrictions.gt("openTime", targetDate));
            LOG.debug("Set age restriction to before " + parameters.getDaysOld() + " days ago.");
        }//from  w w  w .  ja  va 2 s . co  m
    }
}

From source file:com.duroty.application.mail.manager.MailManager.java

License:Open Source License

/**
 * DOCUMENT ME!//from  w  ww .  j  a  v  a2  s .  co m
 *
 * @param hsession DOCUMENT ME!
 * @param user DOCUMENT ME!
 * @param mid DOCUMENT ME!
 * @param midReferences DOCUMENT ME!
 * @param date DOCUMENT ME!
 * @param beforeSent DOCUMENT ME!
 * @param isHtml DOCUMENT ME!
 *
 * @return DOCUMENT ME!
 */
private Vector readReference(Session hsession, Users user, String mid, String midReferences, Date date1,
        boolean beforeSent, boolean isHtml, boolean displayImages) {
    Vector references = new Vector();
    ByteArrayOutputStream baos = null;

    try {
        Locale locale = new Locale(user.getUseLanguage());
        TimeZone timeZone = TimeZone.getDefault();

        Date now = new Date();
        Calendar calendar = Calendar.getInstance(timeZone, locale);
        calendar.setTime(now);

        SimpleDateFormat formatter1 = new SimpleDateFormat("MMM dd", locale);
        SimpleDateFormat formatter2 = new SimpleDateFormat("HH:mm:ss", locale);
        SimpleDateFormat formatter3 = new SimpleDateFormat("MM/yy", locale);

        Criteria crit = hsession.createCriteria(Message.class);
        crit.add(Restrictions.not(Restrictions.eq("mesName", mid)));
        crit.add(Restrictions.eq("mesReferences", midReferences));
        crit.add(Restrictions.eq("users", user));
        crit.add(Restrictions.not(Restrictions.eq("mesBox", this.folderSpam)));
        crit.add(Restrictions.not(Restrictions.eq("mesBox", this.folderTrash)));
        crit.add(Restrictions.not(Restrictions.eq("mesBox", FOLDER_DELETE)));

        if (beforeSent) {
            crit.add(Restrictions.le("mesDate", date1));
        } else {
            crit.add(Restrictions.gt("mesDate", date1));
        }

        crit.addOrder(Order.asc("mesDate"));

        ScrollableResults scroll = crit.scroll();

        while (scroll.next()) {
            Message message = (Message) scroll.get(0);

            message.setMesRecent(false);
            hsession.update(message);
            hsession.flush();

            MessageObj obj = new MessageObj(message.getMesName());

            obj.setBox(message.getMesBox());

            obj.setFrom(message.getMesFrom());
            obj.setTo(message.getMesTo());
            obj.setReplyTo(message.getMesReplyTo());
            obj.setCc(message.getMesCc());

            if ((message.getAttachments() != null) && (message.getAttachments().size() > 0)) {
                obj.setHasAttachment(true);

                Set set = message.getAttachments();
                Iterator it = set.iterator();
                Vector attachments = new Vector();

                while (it.hasNext()) {
                    Attachment attachment = (Attachment) it.next();
                    AttachmentObj attachmentObj = new AttachmentObj();
                    attachmentObj.setIdint(attachment.getAttPart());
                    attachmentObj.setName(attachment.getAttName());

                    int size = attachment.getAttSize();
                    size /= 1024;

                    if (size > 1024) {
                        size /= 1024;
                        attachmentObj.setSize(size + " MB");
                    } else {
                        attachmentObj.setSize(((size > 0) ? (size + "") : "<1") + " kB");
                    }

                    String extension = (String) this.extensions.get(attachment.getAttContentType());

                    if (StringUtils.isBlank(extension)) {
                        extension = "generic";
                    }

                    attachmentObj.setExtension(extension);

                    attachmentObj.setContentType(attachment.getAttContentType());
                    attachments.addElement(attachmentObj);
                    obj.setAttachments(attachments);
                }
            } else {
                obj.setHasAttachment(false);
            }

            int size = message.getMesSize();
            size /= 1024;

            if (size > 1024) {
                size /= 1024;
                obj.setSize(size + " MB");
            } else {
                obj.setSize(((size > 0) ? (size + "") : "<1") + " kB");
            }

            if (message.getMesBox().equals(folderSent)) {
                try {
                    obj.setEmail(message.getMesTo());
                } catch (Exception e) {
                    obj.setEmail("unknown to");
                }
            } else {
                obj.setEmail(message.getMesFrom());
            }

            Date date = message.getMesDate();

            if (date != null) {
                Calendar calendar2 = Calendar.getInstance(timeZone, locale);
                calendar2.setTime(date);

                if ((calendar.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR))
                        && (calendar.get(Calendar.MONTH) == calendar2.get(Calendar.MONTH))
                        && (calendar.get(Calendar.DATE) == calendar2.get(Calendar.DATE))) {
                    obj.setDateStr(formatter2.format(calendar2.getTime()));
                } else if (calendar.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR)) {
                    obj.setDateStr(formatter1.format(calendar2.getTime()));
                } else {
                    obj.setDateStr(formatter3.format(calendar2.getTime()));
                }
            }

            obj.setDate(date);

            if (message.getLabMeses() != null) {
                Iterator it = message.getLabMeses().iterator();
                StringBuffer label = new StringBuffer();

                while (it.hasNext()) {
                    if (label.length() > 0) {
                        label.append(", ");
                    }

                    LabMes labMes = (LabMes) it.next();
                    label.append(labMes.getId().getLabel().getLabName());
                }

                obj.setLabel(label.toString());
            }

            try {
                if (StringUtils.isBlank(message.getMesSubject())) {
                    obj.setSubject("(no subject)");
                } else {
                    obj.setSubject(message.getMesSubject());
                }
            } catch (Exception ex) {
                obj.setSubject("(no subject)");
            }

            if (message.isMesFlagged()) {
                obj.setFlagged(true);
            } else {
                obj.setFlagged(false);
            }

            if (message.isMesRecent()) {
                obj.setRecent(true);
            } else {
                obj.setRecent(false);
            }

            String priority = "normal";

            if (MessageUtilities.isHighPriority(message.getMesHeaders())) {
                priority = "high";
            } else if (MessageUtilities.isLowPriority(message.getMesHeaders())) {
                priority = "low";
            }

            obj.setPriority(priority);

            String body = message.getMesBody();

            if (!StringUtils.isBlank(body)) {
                obj.setBody(bodyCleaner(body, displayImages));
            } else {
                obj.setBody("");
            }

            references.addElement(obj);
        }

        scroll.close();
    } catch (Exception ex) {
        return null;
    } finally {
        IOUtils.closeQuietly(baos);
    }

    if (references.size() <= 0) {
        return null;
    }

    return references;
}

From source file:com.eharmony.matching.seeking.translator.hibernate.HibernateQueryTranslator.java

License:Apache License

@Override
public Criterion gt(String fieldName, Object value) {
    return Restrictions.gt(fieldName, value);
}

From source file:com.eryansky.common.orm.core.hibernate.restriction.support.GtRestriction.java

License:Apache License

public Criterion build(String propertyName, Object value) {
    return Restrictions.gt(propertyName, value);
}

From source file:com.eucalyptus.cloudwatch.common.internal.domain.NextTokenUtils.java

License:Open Source License

public static Criteria addNextTokenConstraints(Integer maxRecords, String nextToken, Date nextTokenCreated,
        Criteria criteria) {//from w  w  w.j a  v a 2 s.c o m
    if (nextTokenCreated != null) {
        // add (WHERE creationTimestamp > nextTokenCreated OR 
        // (creationTimestamp = nextTokenCreated AND naturalId > nextToken
        Junction or = Restrictions.disjunction();
        or.add(Restrictions.gt("creationTimestamp", nextTokenCreated));
        Junction and = Restrictions.conjunction();
        and.add(Restrictions.eq("creationTimestamp", nextTokenCreated));
        and.add(Restrictions.gt("naturalId", nextToken));
        or.add(and);
        criteria.add(or);
    }
    criteria.addOrder(Order.asc("creationTimestamp"));
    criteria.addOrder(Order.asc("naturalId"));
    if (maxRecords != null) {
        criteria.setMaxResults(maxRecords);
    }
    return criteria;
}

From source file:com.eucalyptus.objectstorage.DbObjectManagerImpl.java

License:Open Source License

@Override
public PaginatedResult<ObjectEntity> listVersionsPaginated(final Bucket bucket, int maxEntries, String prefix,
        String delimiter, String fromKeyMarker, String fromVersionId, boolean latestOnly) throws Exception {

    EntityTransaction db = Entities.get(ObjectEntity.class);
    try {/*from   w  w  w  .  j  a  v  a2s.  c  o  m*/
        PaginatedResult<ObjectEntity> result = new PaginatedResult<ObjectEntity>();
        HashSet<String> commonPrefixes = new HashSet<String>();

        // Include zero since 'istruncated' is still valid
        if (maxEntries >= 0) {
            final int queryStrideSize = maxEntries + 1;
            ObjectEntity searchObj = new ObjectEntity();
            searchObj.setBucketName(bucket.getBucketName());

            // Return latest version, so exclude delete markers as well.
            // This makes listVersion act like listObjects
            if (latestOnly) {
                searchObj.setDeleted(false);
                searchObj.setIsLatest(true);
            }

            Criteria objCriteria = Entities.createCriteria(ObjectEntity.class);
            objCriteria.setReadOnly(true);
            objCriteria.setFetchSize(queryStrideSize);
            objCriteria.add(Example.create(searchObj));
            objCriteria.add(ObjectEntity.QueryHelpers.getNotPendingRestriction());
            objCriteria.add(ObjectEntity.QueryHelpers.getNotDeletingRestriction());
            objCriteria.addOrder(Order.asc("objectKey"));
            objCriteria.addOrder(Order.desc("objectModifiedTimestamp"));
            objCriteria.setMaxResults(queryStrideSize);

            if (!Strings.isNullOrEmpty(fromKeyMarker)) {
                objCriteria.add(Restrictions.gt("objectKey", fromKeyMarker));
            } else {
                fromKeyMarker = "";
            }

            if (!Strings.isNullOrEmpty(fromVersionId)) {
                objCriteria.add(Restrictions.gt("versionId", fromVersionId));
            } else {
                fromVersionId = "";
            }

            if (!Strings.isNullOrEmpty(prefix)) {
                objCriteria.add(Restrictions.like("objectKey", prefix, MatchMode.START));
            } else {
                prefix = "";
            }

            // Ensure not null.
            if (Strings.isNullOrEmpty(delimiter)) {
                delimiter = "";
            }

            List<ObjectEntity> objectInfos = null;
            int resultKeyCount = 0;
            String[] parts = null;
            String prefixString = null;
            boolean useDelimiter = !Strings.isNullOrEmpty(delimiter);
            int pages = 0;

            // Iterate over result sets of size maxkeys + 1 since
            // commonPrefixes collapse the list, we may examine many more
            // records than maxkeys + 1
            do {
                parts = null;
                prefixString = null;

                // Skip ahead the next page of 'queryStrideSize' results.
                objCriteria.setFirstResult(pages++ * queryStrideSize);

                objectInfos = (List<ObjectEntity>) objCriteria.list();
                if (objectInfos == null) {
                    // nothing to do.
                    break;
                }

                for (ObjectEntity objectRecord : objectInfos) {
                    if (useDelimiter) {
                        // Check if it will get aggregated as a commonprefix
                        parts = objectRecord.getObjectKey().substring(prefix.length()).split(delimiter);
                        if (parts.length > 1) {
                            prefixString = prefix + parts[0] + delimiter;
                            if (!commonPrefixes.contains(prefixString)) {
                                if (resultKeyCount == maxEntries) {
                                    // This is a new record, so we know
                                    // we're truncating if this is true
                                    result.setIsTruncated(true);
                                    resultKeyCount++;
                                    break;
                                } else {
                                    // Add it to the common prefix set
                                    commonPrefixes.add(prefixString);
                                    result.lastEntry = prefixString;
                                    // count the unique commonprefix as a
                                    // single return entry
                                    resultKeyCount++;
                                }
                            } else {
                                // Already have this prefix, so skip
                            }
                            continue;
                        }
                    }

                    if (resultKeyCount == maxEntries) {
                        // This is a new (non-commonprefix) record, so
                        // we know we're truncating
                        result.setIsTruncated(true);
                        resultKeyCount++;
                        break;
                    }

                    result.entityList.add(objectRecord);
                    result.lastEntry = objectRecord;
                    resultKeyCount++;
                }

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

            // Sort the prefixes from the hashtable and add to the reply
            if (commonPrefixes != null) {
                result.getCommonPrefixes().addAll(commonPrefixes);
                Collections.sort(result.getCommonPrefixes());
            }
        } else {
            throw new IllegalArgumentException("MaxKeys must be positive integer");
        }

        return result;
    } catch (Exception e) {
        LOG.error("Error generating paginated object list of bucket " + bucket.getBucketName(), e);
        throw e;
    } finally {
        db.rollback();
    }
}

From source file:com.eucalyptus.objectstorage.metadata.DbMpuPartMetadataManagerImpl.java

License:Open Source License

@Override
public PaginatedResult<PartEntity> listPartsForUpload(final Bucket bucket, final String objectKey,
        final String uploadId, final Integer partNumberMarker, final Integer maxParts) throws Exception {

    EntityTransaction db = Entities.get(PartEntity.class);
    try {// ww w .  ja  v  a2 s . c o m
        PaginatedResult<PartEntity> result = new PaginatedResult<PartEntity>();
        HashSet<String> commonPrefixes = new HashSet<String>();

        // Include zero since 'istruncated' is still valid
        if (maxParts >= 0) {
            final int queryStrideSize = maxParts + 1;
            PartEntity searchPart = new PartEntity(bucket, objectKey, uploadId).withState(ObjectState.extant);

            Criteria objCriteria = Entities.createCriteria(PartEntity.class);
            objCriteria.setReadOnly(true);
            objCriteria.setFetchSize(queryStrideSize);
            objCriteria.add(Example.create(searchPart));
            objCriteria.addOrder(Order.asc("partNumber"));
            objCriteria.addOrder(Order.desc("objectModifiedTimestamp"));
            objCriteria.setMaxResults(queryStrideSize);

            if (partNumberMarker != null) {
                objCriteria.add(Restrictions.gt("partNumber", partNumberMarker));
            }
            objCriteria = getSearchByBucket(objCriteria, bucket);

            List<PartEntity> partInfos = null;
            int resultKeyCount = 0;
            String[] parts = null;
            int pages = 0;

            // Iterate over result sets of size maxkeys + 1 since
            // commonPrefixes collapse the list, we may examine many more
            // records than maxkeys + 1
            do {
                parts = null;

                // Skip ahead the next page of 'queryStrideSize' results.
                objCriteria.setFirstResult(pages++ * queryStrideSize);

                partInfos = (List<PartEntity>) objCriteria.list();
                if (partInfos == null) {
                    // nothing to do.
                    break;
                }

                for (PartEntity partRecord : partInfos) {

                    if (resultKeyCount == maxParts) {
                        result.setIsTruncated(true);
                        resultKeyCount++;
                        break;
                    }

                    result.getEntityList().add(partRecord);
                    result.setLastEntry(partRecord);
                    resultKeyCount++;
                }

                if (resultKeyCount <= maxParts && partInfos.size() <= maxParts) {
                    break;
                }
            } while (resultKeyCount <= maxParts);
        } else {
            throw new IllegalArgumentException("MaxKeys must be positive integer");
        }

        return result;
    } catch (Exception e) {
        LOG.error("Error generating paginated parts list for upload ID " + uploadId, e);
        throw e;
    } finally {
        db.rollback();
    }
}

From source file:com.eucalyptus.objectstorage.metadata.DbObjectMetadataManagerImpl.java

License:Open Source License

@Override
public PaginatedResult<ObjectEntity> listUploads(Bucket bucket, int maxUploads, String prefix, String delimiter,
        String keyMarker, String uploadIdMarker) throws Exception {

    try (TransactionResource trans = Entities.transactionFor(ObjectEntity.class)) {
        PaginatedResult<ObjectEntity> result = new PaginatedResult<ObjectEntity>();
        HashSet<String> commonPrefixes = new HashSet<String>();

        // Include zero since 'istruncated' is still valid
        if (maxUploads >= 0) {
            final int queryStrideSize = maxUploads + 1;
            ObjectEntity searchObj = new ObjectEntity();
            searchObj.withBucket(bucket); //This doesn't actually filter, but do it anyway
            searchObj.withState(ObjectState.mpu_pending);

            Criteria objCriteria = Entities.createCriteria(ObjectEntity.class);
            objCriteria.setReadOnly(true);
            objCriteria.setFetchSize(queryStrideSize);
            objCriteria.add(Example.create(searchObj));
            objCriteria.addOrder(Order.asc("objectKey"));
            objCriteria.setMaxResults(queryStrideSize);

            if (!Strings.isNullOrEmpty(keyMarker)) {
                objCriteria.add(Restrictions.gt("objectKey", keyMarker));
            } else {
                keyMarker = "";
            }/*from w  w w . ja v  a 2 s.  c o m*/

            if (!Strings.isNullOrEmpty(uploadIdMarker)) {
                objCriteria.add(Restrictions.gt("uploadId", uploadIdMarker));
            } else {
                uploadIdMarker = "";
            }

            if (!Strings.isNullOrEmpty(prefix)) {
                objCriteria.add(Restrictions.like("objectKey", prefix, MatchMode.START));
            } else {
                prefix = "";
            }

            //Be sure to add the bucket restriction last
            objCriteria = getSearchByBucket(objCriteria, bucket);

            // Ensure not null.
            if (Strings.isNullOrEmpty(delimiter)) {
                delimiter = "";
            }

            List<ObjectEntity> objectInfos = null;
            int resultKeyCount = 0;
            String[] parts = null;
            String prefixString = null;
            boolean useDelimiter = !Strings.isNullOrEmpty(delimiter);
            int pages = 0;

            // Iterate over result sets of size maxkeys + 1 since
            // commonPrefixes collapse the list, we may examine many more
            // records than maxkeys + 1
            do {
                parts = null;
                prefixString = null;

                // Skip ahead the next page of 'queryStrideSize' results.
                objCriteria.setFirstResult(pages++ * queryStrideSize);

                objectInfos = (List<ObjectEntity>) objCriteria.list();
                if (objectInfos == null) {
                    // nothing to do.
                    break;
                }

                for (ObjectEntity objectRecord : objectInfos) {
                    if (useDelimiter) {
                        // Check if it will get aggregated as a commonprefix
                        parts = objectRecord.getObjectKey().substring(prefix.length()).split(delimiter);
                        if (parts.length > 1) {
                            prefixString = prefix + parts[0] + delimiter;
                            if (!prefixString.equals(keyMarker) && !commonPrefixes.contains(prefixString)) {
                                if (resultKeyCount == maxUploads) {
                                    // This is a new record, so we know
                                    // we're truncating if this is true
                                    result.setIsTruncated(true);
                                    resultKeyCount++;
                                    break;
                                } else {
                                    // Add it to the common prefix set
                                    commonPrefixes.add(prefixString);
                                    result.setLastEntry(prefixString);
                                    // count the unique commonprefix as a
                                    // single return entry
                                    resultKeyCount++;
                                }
                            } else {
                                // Already have this prefix, so skip
                            }
                            continue;
                        }
                    }

                    if (resultKeyCount == maxUploads) {
                        // This is a new (non-commonprefix) record, so
                        // we know we're truncating
                        result.setIsTruncated(true);
                        resultKeyCount++;
                        break;
                    }

                    result.getEntityList().add(objectRecord);
                    result.setLastEntry(objectRecord);
                    resultKeyCount++;
                }

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

            // Sort the prefixes from the hashtable and add to the reply
            if (commonPrefixes != null) {
                result.getCommonPrefixes().addAll(commonPrefixes);
                Collections.sort(result.getCommonPrefixes());
            }
        } else {
            throw new IllegalArgumentException("max uploads must be positive integer");
        }

        return result;
    } catch (Exception e) {
        LOG.error("Error generating paginated multipart upload list for bucket " + bucket.getBucketName(), e);
        throw e;
    }
}