import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
/**
 * Get the list of Problems
 */
// problemsPK
@OneToMany(mappedBy = "series", cascade = CascadeType.REMOVE)
@OrderBy(clause = "abbrev")
public List<Problems> getProblemss() {
    return this.problemss;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@CollectionOfElements
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY, mappedBy="purchaseOrder")
@OrderBy (
        clause = "id desc"
)
public Set<OrderProcessDTO> getOrderProcesses() {
    return this.orderProcesses;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@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;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "company")
@OrderBy(
        clause = "status_id"
)
public Set<AgeingEntityStepDTO> getAgeingEntitySteps() {
    return this.ageingEntitySteps;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "entity")
@OrderBy(
        clause = "id"
)
public Set<ContactTypeDTO> getContactTypes() {
    return this.contactTypes;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@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;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@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;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
public void setJpaOrderBy(javax.persistence.OrderBy jpaOrderBy) {
	this.jpaOrderBy = jpaOrderBy;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
public void setSqlOrderBy(OrderBy sqlOrderBy) {
	this.sqlOrderBy = sqlOrderBy;
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
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()
					)
			);
		}
	}
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
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.
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@Override
public void setSqlOrderBy(OrderBy orderByAnn) {
	if ( orderByAnn != null )
		LOG.orderByAnnotationIndexedCollection();
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@Override
   public void setSqlOrderBy(OrderBy orderByAnn) {
	if ( orderByAnn != null ) {
           super.setSqlOrderBy( orderByAnn );
	}
}
 

import org.hibernate.annotations.OrderBy; //导入依赖的package包/类
@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.LAZY, mappedBy="purchaseOrder")
@OrderBy(clause="id")
public List<OrderLineDTO> getLines() {
    return this.lines;
}