Java 类org.hibernate.annotations.OrderBy 实例源码

/**
 * Get the list of Problems
 */
// problemsPK
@OneToMany(mappedBy = "series", cascade = CascadeType.REMOVE)
@OrderBy(clause = "abbrev")
public List<Problems> getProblemss() {
    return this.problemss;
}

@CollectionOfElements
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY, mappedBy="purchaseOrder")
@OrderBy (
        clause = "id desc"
)
public Set<OrderProcessDTO> getOrderProcesses() {
    return this.orderProcesses;
}

@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "permission_role_map",
           joinColumns = {@JoinColumn(name = "role_id", updatable = false)},
           inverseJoinColumns = {@JoinColumn(name = "permission_id", updatable = false)}
)
@OrderBy(clause = "permission_id")
public Set<PermissionDTO> getPermissions() {
    return this.permissions;
}

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "company")
@OrderBy(
        clause = "status_id"
)
public Set<AgeingEntityStepDTO> getAgeingEntitySteps() {
    return this.ageingEntitySteps;
}

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "entity")
@OrderBy(
        clause = "id"
)
public Set<ContactTypeDTO> getContactTypes() {
    return this.contactTypes;
}

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER, mappedBy="enumeration")
@Cascade( 
        value= org.hibernate.annotations.CascadeType.DELETE_ORPHAN
        )
@Fetch (FetchMode.SUBSELECT)
@OrderBy(clause="id")
@Valid
public List<EnumerationValueDTO> getValues() {
    return this.values;
}

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "notificationMessage")
@OrderBy(clause = "section")
@Fetch(FetchMode.JOIN)
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public Set<NotificationMessageSectionDTO> getNotificationMessageSections() {
    return this.notificationMessageSections;
}

public void setJpaOrderBy(javax.persistence.OrderBy jpaOrderBy) {
    this.jpaOrderBy = jpaOrderBy;
}

public void setSqlOrderBy(OrderBy sqlOrderBy) {
    this.sqlOrderBy = sqlOrderBy;
}

private void applySortingAndOrdering(Collection collection) {
    boolean isSorted = isSortedCollection;

    boolean hadOrderBy = false;
    boolean hadExplicitSort = false;

    Class<? extends Comparator> comparatorClass = null;

    if ( jpaOrderBy == null && sqlOrderBy == null ) {
        if ( deprecatedSort != null ) {
            LOG.debug( "Encountered deprecated @Sort annotation; use @SortNatural or @SortComparator instead." );
            if ( naturalSort != null || comparatorSort != null ) {
                throw buildIllegalSortCombination();
            }
            hadExplicitSort = deprecatedSort.type() != SortType.UNSORTED;
            if ( deprecatedSort.type() == SortType.NATURAL ) {
                isSorted = true;
            }
            else if ( deprecatedSort.type() == SortType.COMPARATOR ) {
                isSorted = true;
                comparatorClass = deprecatedSort.comparator();
            }
        }
        else if ( naturalSort != null ) {
            if ( comparatorSort != null ) {
                throw buildIllegalSortCombination();
            }
            hadExplicitSort = true;
        }
        else if ( comparatorSort != null ) {
            hadExplicitSort = true;
            comparatorClass = comparatorSort.value();
        }
    }
    else {
        if ( jpaOrderBy != null && sqlOrderBy != null ) {
            throw new AnnotationException(
                    String.format(
                            "Illegal combination of @%s and @%s on %s",
                            javax.persistence.OrderBy.class.getName(),
                            OrderBy.class.getName(),
                            safeCollectionRole()
                    )
            );
        }

        hadOrderBy = true;
        hadExplicitSort = false;

        // we can only apply the sql-based order by up front.  The jpa order by has to wait for second pass
        if ( sqlOrderBy != null ) {
            collection.setOrderBy( sqlOrderBy.clause() );
        }
    }

    if ( isSortedCollection ) {
        if ( ! hadExplicitSort && !hadOrderBy ) {
            throw new AnnotationException(
                    "A sorted collection must define and ordering or sorting : " + safeCollectionRole()
            );
        }
    }

    collection.setSorted( isSortedCollection || hadExplicitSort );

    if ( comparatorClass != null ) {
        try {
            collection.setComparator( comparatorClass.newInstance() );
        }
        catch (Exception e) {
            throw new AnnotationException(
                    String.format(
                            "Could not instantiate comparator class [%s] for %s",
                            comparatorClass.getName(),
                            safeCollectionRole()
                    )
            );
        }
    }
}

private String extractHqlOrderBy(javax.persistence.OrderBy jpaOrderBy) {
    if ( jpaOrderBy != null ) {
        return jpaOrderBy.value(); // Null not possible. In case of empty expression, apply default ordering.
    }
    return null; // @OrderBy not found.
}

@Override
public void setSqlOrderBy(OrderBy orderByAnn) {
    if ( orderByAnn != null )
        LOG.orderByAnnotationIndexedCollection();
}

@Override
   public void setSqlOrderBy(OrderBy orderByAnn) {
    if ( orderByAnn != null ) {
           super.setSqlOrderBy( orderByAnn );
    }
}

@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY, mappedBy="purchaseOrder")
@OrderBy(clause="id")
public List<OrderLineDTO> getLines() {
    return this.lines;
}