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

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

private void applySortingAndOrdering(Collection collection) {
	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 ) {
				isSortedCollection = true;
			}
			else if ( deprecatedSort.type() == SortType.COMPARATOR ) {
				isSortedCollection = 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.REMOVE,mappedBy="table")
@OrderBy(clause="orderNum asc")
public List<CgFormFieldEntity> getColumns() {
	return columns;
}
 

@OneToMany(cascade=CascadeType.REMOVE,mappedBy="table")
@OrderBy(clause="orderNum asc")
public List<CgFormFieldEntity> getColumns() {
	return columns;
}