private CriteriaQuery<Object[]> buildQueryOfStreamPrevios(Build build, Status status, String...fields) {
	CriteriaBuilder builder = getSession().getCriteriaBuilder();
	CriteriaQuery<Object[]> query = builder.createQuery(Object[].class);
	Root<Build> root = query.from(Build.class);
	
	List<Predicate> predicates = new ArrayList<>();
	predicates.add(builder.equal(root.get("project"), build.getProject()));
	predicates.add(builder.equal(root.get("jobName"), build.getJobName()));
	if (status != null)
		predicates.add(builder.equal(root.get("status"), status));
	predicates.add(builder.lessThan(root.get("number"), build.getNumber()));
	query.where(predicates.toArray(new Predicate[0]));
	List<Selection<?>> selections = new ArrayList<>();
	for (String field: fields)
		selections.add(root.get(field));
	query.multiselect(selections);
	
	return query;
}
 

public <T extends JpaObject> List<T> fetchAll(Class<T> clz, List<String> attributes) throws Exception {
	List<T> list = new ArrayList<>();
	List<String> fields = ListTools.trim(attributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	for (Tuple o : em.createQuery(cq.multiselect(selections)).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, attributes.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject> List<T> fetchEqualAndEqual(Class<T> clz, List<String> fetchAttributes,
		String attribute, Object value, String otherAttribute, Object otherValue) throws Exception {
	List<T> list = new ArrayList<>();
	List<String> fields = ListTools.trim(fetchAttributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.and(cb.equal(root.get(attribute), value), cb.equal(root.get(otherAttribute), otherValue));
	cq.multiselect(selections).where(p);
	for (Tuple o : em.createQuery(cq).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject> List<T> fetchNotEqual(Class<T> clz, List<String> attributes, String attribute,
		Object value) throws Exception {
	List<T> list = new ArrayList<>();
	List<String> fields = ListTools.trim(attributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.or(cb.isNull(root.get(attribute)), cb.notEqual(root.get(attribute), value));
	cq.multiselect(selections).where(p);
	for (Tuple o : em.createQuery(cq).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject, W extends Object> List<T> fetchIn(Class<T> clz, List<String> attributes,
		String attribute, Collection<W> values) throws Exception {
	List<T> list = new ArrayList<>();
	List<String> fields = ListTools.trim(attributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.isMember(root.get(attribute), cb.literal(values));
	cq.multiselect(selections).where(p);
	for (Tuple o : em.createQuery(cq).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject, V extends Object> List<T> fetchEqualAndIn(Class<T> clz, List<String> fetchAttributes,
		String attribute, Object value, String otherAttribute, Collection<V> otherValues) throws Exception {
	List<T> list = new ArrayList<>();
	List<String> fields = ListTools.trim(fetchAttributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.and(cb.equal(root.get(attribute), value),
			cb.isMember(root.get(otherAttribute), cb.literal(otherValues)));
	cq.multiselect(selections).where(p);
	for (Tuple o : em.createQuery(cq).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject> List<T> fetchEuqalOrIsMember(Class<T> clz, List<String> attributes,
		String equalAttribute, Object equalValue, String isMemberAttribute, Object isMemberValue) throws Exception {
	List<T> list = new ArrayList<>();
	List<String> fields = ListTools.trim(attributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.equal(root.get(equalAttribute), equalValue);
	p = cb.or(p, cb.isMember(isMemberValue, root.get(isMemberAttribute)));
	cq.multiselect(selections).where(p);
	for (Tuple o : em.createQuery(cq).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject, W extends GsonPropertyObject> List<T> fetchDescPaging(Class<T> clz,
		List<String> fetchAttributes, Predicate predicate, Integer page, Integer pageSize, String orderAttribute)
		throws Exception {
	List<T> list = new ArrayList<>();
	int max = (pageSize == null || pageSize < 1 || pageSize > MAX_PAGESIZE) ? DEFAULT_PAGESIZE : pageSize;
	int startPosition = (page == null || page < 1) ? 0 : (page - 1) * max;
	List<String> fields = ListTools.trim(fetchAttributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	cq.multiselect(selections).where(predicate).orderBy(cb.desc(root.get(orderAttribute)));
	T t = null;
	for (Tuple o : em.createQuery(cq).setFirstResult(startPosition).setMaxResults(max).getResultList()) {
		t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject, W extends GsonPropertyObject> List<T> fetchAscPaging(Class<T> clz,
		List<String> fetchAttributes, Predicate predicate, Integer page, Integer pageSize, String orderAttribute)
		throws Exception {
	List<T> list = new ArrayList<>();
	int max = (pageSize == null || pageSize < 1 || pageSize > MAX_PAGESIZE) ? DEFAULT_PAGESIZE : pageSize;
	int startPosition = (page == null || page < 1) ? 0 : (page - 1) * max;
	List<String> fields = ListTools.trim(fetchAttributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	cq.multiselect(selections).where(predicate).orderBy(cb.asc(root.get(orderAttribute)));
	T t = null;
	for (Tuple o : em.createQuery(cq).setFirstResult(startPosition).setMaxResults(max).getResultList()) {
		t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject, W extends GsonPropertyObject> List<T> fetchEqualDescPaging(Class<T> clz,
		List<String> fetchAttributes, String equalAttribute, Object equalValue, Integer page, Integer pageSize,
		String orderAttribute) throws Exception {
	List<T> list = new ArrayList<>();
	int max = (pageSize == null || pageSize < 1 || pageSize > MAX_PAGESIZE) ? DEFAULT_PAGESIZE : pageSize;
	int startPosition = (page == null || page < 1) ? 0 : (page - 1) * max;
	List<String> fields = ListTools.trim(fetchAttributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.equal(root.get(equalAttribute), equalValue);
	cq.multiselect(selections).where(p).orderBy(cb.desc(root.get(orderAttribute)));
	for (Tuple o : em.createQuery(cq).setFirstResult(startPosition).setMaxResults(max).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public List<AttendanceCycles> getCyclesFromDetailWithDateSplit( Date startDate, Date endDate )  throws Exception{
	if( startDate == null || startDate == null ){
		return null;
	}
	EntityManager em = this.entityManagerContainer().get( AttendanceDetail.class );
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<AttendanceCycles> cq = cb.createQuery(AttendanceCycles.class);
	Root<AttendanceDetail> root = cq.from( AttendanceDetail.class);
	Predicate p = cb.between( root.get(AttendanceDetail_.recordDate), startDate, endDate);
	
	List<Selection<?>> selectionList = new ArrayList<Selection<?>>();
	selectionList.add(root.get(AttendanceDetail_.cycleYear ));
	selectionList.add(root.get(AttendanceDetail_.cycleMonth ));
	cq.distinct(true).multiselect(selectionList);
	
	return em.createQuery(cq.where(p)).getResultList();
}
 

public List<AttendanceCycles> getCyclesFromDetailWithDateSplit( String empName, Date startDate, Date endDate )  throws Exception{
	if( startDate == null || startDate == null ){
		return null;
	}
	EntityManager em = this.entityManagerContainer().get( AttendanceDetail.class );
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<AttendanceCycles> cq = cb.createQuery(AttendanceCycles.class);
	Root<AttendanceDetail> root = cq.from( AttendanceDetail.class);
	Predicate p = cb.between( root.get(AttendanceDetail_.recordDate), startDate, endDate);
	p = cb.and( p, cb.equal( root.get(AttendanceDetail_.empName), empName));
	List<Selection<?>> selectionList = new ArrayList<Selection<?>>();
	selectionList.add(root.get(AttendanceDetail_.cycleYear ));
	selectionList.add(root.get(AttendanceDetail_.cycleMonth ));
	cq.distinct(true).multiselect(selectionList);
	
	return em.createQuery(cq.where(p)).getResultList();
}
 

public List<AttendanceCycles> getCyclesFromDetailWithDateSplit( Date startDate, Date endDate )  throws Exception{
	if( startDate == null || startDate == null ){
		return null;
	}
	EntityManager em = this.entityManagerContainer().get( AttendanceDetail.class );
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<AttendanceCycles> cq = cb.createQuery(AttendanceCycles.class);
	Root<AttendanceDetail> root = cq.from( AttendanceDetail.class);
	Predicate p = cb.between( root.get(AttendanceDetail_.recordDate), startDate, endDate);
	
	List<Selection<?>> selectionList = new ArrayList<Selection<?>>();
	selectionList.add(root.get(AttendanceDetail_.cycleYear ));
	selectionList.add(root.get(AttendanceDetail_.cycleMonth ));
	cq.distinct(true).multiselect(selectionList);
	
	return em.createQuery(cq.where(p)).getResultList();
}
 

/**
 * Package-protected method to centralize checking of criteria query multi-selects as defined by the
 * {@link CriteriaQuery#multiselect(List)}  method.
 *
 * @param selections The selection varargs to check
 *
 * @throws IllegalArgumentException If the selection items are not valid per {@link CriteriaQuery#multiselect}
 * documentation.
 * <i>&quot;An argument to the multiselect method must not be a tuple-
    * or array-valued compound selection item.&quot;</i>
 */
void checkMultiselect(List<Selection<?>> selections) {
	final HashSet<String> aliases = new HashSet<String>( CollectionHelper.determineProperSizing( selections.size() ) );

	for ( Selection<?> selection : selections ) {
		if ( selection.isCompoundSelection() ) {
			if ( selection.getJavaType().isArray() ) {
				throw new IllegalArgumentException(
						"Selection items in a multi-select cannot contain compound array-valued elements"
				);
			}
			if ( Tuple.class.isAssignableFrom( selection.getJavaType() ) ) {
				throw new IllegalArgumentException(
						"Selection items in a multi-select cannot contain compound tuple-valued elements"
				);
			}
		}
		if ( StringHelper.isNotEmpty( selection.getAlias() ) ) {
			boolean added = aliases.add( selection.getAlias() );
			if ( ! added ) {
				throw new IllegalArgumentException( "Multi-select expressions defined duplicate alias : " + selection.getAlias() );
			}
		}
	}
}
 

public String render(RenderingContext renderingContext) {
	StringBuilder buff = new StringBuilder();
	if ( isConstructor ) {
		buff.append( "new " ).append( getJavaType().getName() ).append( '(' );
	}
	String sep = "";
	for ( Selection selection : selectionItems ) {
		buff.append( sep )
				.append( ( (Renderable) selection ).renderProjection( renderingContext ) );
		sep = ", ";
	}
	if ( isConstructor ) {
		buff.append( ')' );
	}
	return buff.toString();
}
 

@Override
public T select(Object... selections) {
	if (!beforeMethodInvoke()) {
		return (T) this;
	}
	List<Selection<?>> list = new ArrayList<Selection<?>>(selections.length);
	for (Object selection : selections) {
		if (selection instanceof String) {
			parseSelectionStr(list, (String) selection);
		} else if (selection instanceof Selection) {
			list.add((Selection<?>) selection);
		}
	}
	select(list.toArray(new Selection<?>[list.size()]));
	return (T) this;
}
 

private void parseSelectionStr(List<Selection<?>> result, String selection) {
	String[] ps = selection.split("\\s*,\\s*");
	for (String p : ps) {
		String alias = p.trim();
		String[] pa = alias.split("\\s+[aA][sS]\\s+");
		if (pa.length > 1) {
			alias = pa[1];
		} else {
			pa = alias.split("\\s+");
			if (pa.length > 1) {
				alias = pa[1];
			}
		}
		result.add(root.get(ps[0]).alias(alias));
	}
}
 

@Override
@SuppressWarnings("rawtypes")
public T select(Selection<?>... selections) {
	if (!beforeMethodInvoke()) {
		return (T) this;
	}
	Assert.isTrue(sq == null || selections.length == 1, "selections can only have one in subquery! ");
	Assert.isTrue(sq == null || selections[0] instanceof Expression, "Elements in the selections must implement the " + Expression.class.getName() + " interface in subquery! ");
	Assert.isTrue(sq != null || criteria instanceof CriteriaQuery, "Not supported!");
	if (sq == null) {
		((CriteriaQuery) criteria).multiselect(selections);
	} else {
		sq.select((Expression) selections[0]);
	}
	for (Selection<?> selection : selections) {
		aliases.add(selection.getAlias());
	}
	
	return (T) this;
}
 

@Override
public void addSelection(Expression<?> expression, String name) {
	Selection<?> selection = criteriaQuery.getSelection();

	List<Selection<?>> newSelection = new ArrayList<>();
	if (selection != null) {
		if (selection.isCompoundSelection()) {
			newSelection.addAll(selection.getCompoundSelectionItems());
		}
		else {
			newSelection.add(selection);
		}
	}
	newSelection.add(expression);
	criteriaQuery.multiselect(newSelection);
}
 

private boolean isQueryCreationEligible(
    EntityGraphBean entityGraphCandidate, MethodInvocation invocation) {
  Class<?> resultType = null;
  for (Object argument : invocation.getArguments()) {
    if (argument instanceof Class<?>) {
      resultType = (Class<?>) argument;
      break;
    } else if (argument instanceof CriteriaQuery<?>) {
      CriteriaQuery<?> criteriaQuery = (CriteriaQuery<?>) argument;
      Selection<?> selection = criteriaQuery.getSelection();
      if (selection == null) {
        continue;
      }
      resultType = selection.getJavaType();
      break;
    }
  }
  return resultType == null || resultType.equals(entityGraphCandidate.getDomainClass());
}
 

/**
 * Create a TypedQuery from a request page
 * @param page request page
 * @return new TypedQuery
 */
@SuppressWarnings("unchecked")
private <K> TypedQuery<K> getCriteriaQuery(Page<K> page) {
	CriteriaQuery<K> criteria = getCriteria(page);
	
	CriteriaQuery<Long> countCriteria = (CriteriaQuery<Long>) getCriteria(page);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	
	Root<?> root = countCriteria.getRoots().iterator().next();
	countCriteria.select(cb.count(root));
	
	page.setCount((em.createQuery(countCriteria).getSingleResult())
			.intValue());
	
	
	criteria.orderBy(getOrder(page, criteria));
	
	// Add default select to entity class if none was set.
	if (criteria.getSelection() == null) {
		criteria.select((Selection<? extends K>) root);
	}
	
	return em.createQuery(criteria);
}
 

protected List<Tuple> execute(Business business, WrapInStringList wrapIn) throws Exception {
	EntityManagerContainer emc = business.entityManagerContainer();
	EntityManager em = emc.get(Person.class);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<Person> root = cq.from(Person.class);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : wrapIn.getValueList()) {
		selections.add(root.get(str));
	}
	cq.multiselect(selections);
	List<Tuple> wraps = em.createQuery(cq).getResultList();
	return wraps;
}
 

private void fillAttributeSelectEntriesDocument(EntityManagerContainer emc, List<String> docIds,
		List<SelectEntry> selectEntries, Table table) throws Exception {
	EntityManager em = emc.get(Document.class);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<Document> root = cq.from(Document.class);
	List<Selection<?>> selections = new ArrayList<>();
	Selection<Object> selectionDoc = null;
	for (SelectEntry en : selectEntries) {
		if (en.available()) {
			if (StringUtils.equals(Document.id_FIELDNAME, en.getAttribute())) {
				selectionDoc = root.get(Document.id_FIELDNAME).alias(en.getColumn());
				selections.add(selectionDoc);
			} else {
				selections.add(root.get(en.getAttribute()).alias(en.getColumn()));
			}
		}
	}
	if (selectionDoc == null) {
		selectionDoc = root.get(Document.id_FIELDNAME);
		cq.multiselect(ListTools.add(selections, true, false, selectionDoc));
	} else {
		cq.multiselect(selections);
	}
	cq.where(root.get(Document.id_FIELDNAME).in(docIds));
	List<Tuple> tuples = em.createQuery(cq).getResultList();
	for (Tuple tuple : tuples) {
		Object job = tuple.get(selectionDoc);
		Row row = table.get(job.toString());
		for (Selection<?> selection : selections) {
			/* 前面已经填充了默认值,如果是null那么跳过这个值 */
			if (null != tuple.get(selection)) {
				row.put(selection.getAlias(), tuple.get(selection));
			}
		}
	}
}
 

public <T extends JpaObject> T fetch(String id, Class<T> clz, List<String> attributes) throws Exception {
	T t = null;
	if (StringUtils.isEmpty(id)) {
		return null;
	}
	if (!attributes.contains(JpaObject.id_FIELDNAME)) {
		attributes.add(JpaObject.id_FIELDNAME);
	}
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : attributes) {
		selections.add(root.get(str));
	}
	cq.multiselect(selections).where(cb.equal(root.get(JpaObject.id_FIELDNAME), id));
	List<Tuple> list = em.createQuery(cq).setMaxResults(1).getResultList();
	if (!list.isEmpty()) {
		Tuple tuple = list.get(0);
		t = clz.newInstance();
		for (int i = 0; i < selections.size(); i++) {
			PropertyUtils.setProperty(t, attributes.get(i), tuple.get(selections.get(i)));
		}
	}
	return t;
}
 

public <T extends JpaObject, W extends GsonPropertyObject> List<T> fetchEqualAndEqualDescPaging(Class<T> clz,
		List<String> fetchAttributes, String equalAttribute, Object equalValue, String otherEqualAttribute,
		Object otherEqualValue, Integer page, Integer pageSize, String orderAttribute) throws Exception {
	List<T> list = new ArrayList<>();
	int max = (pageSize == null || pageSize < 1 || pageSize > MAX_PAGESIZE) ? DEFAULT_PAGESIZE : pageSize;
	int startPosition = (page == null || page < 1) ? 0 : (page - 1) * max;
	List<String> fields = ListTools.trim(fetchAttributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.equal(root.get(equalAttribute), equalValue);
	p = cb.and(p, cb.equal(root.get(otherEqualAttribute), otherEqualValue));
	cq.multiselect(selections).where(p).orderBy(cb.desc(root.get(orderAttribute)));
	for (Tuple o : em.createQuery(cq).setFirstResult(startPosition).setMaxResults(max).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

public <T extends JpaObject, W extends GsonPropertyObject> List<T> fetchEqualAndNotEqualDescPaging(Class<T> clz,
		List<String> fetchAttributes, String equalAttribute, Object equalValue, String otherNotEqualAttribute,
		Object otherNotEqualValue, Integer page, Integer pageSize, String orderAttribute) throws Exception {
	List<T> list = new ArrayList<>();
	int max = (pageSize == null || pageSize < 1 || pageSize > MAX_PAGESIZE) ? DEFAULT_PAGESIZE : pageSize;
	int startPosition = (page == null || page < 1) ? 0 : (page - 1) * max;
	List<String> fields = ListTools.trim(fetchAttributes, true, true, JpaObject.id_FIELDNAME);
	EntityManager em = this.get(clz);
	CriteriaBuilder cb = em.getCriteriaBuilder();
	CriteriaQuery<Tuple> cq = cb.createQuery(Tuple.class);
	Root<T> root = cq.from(clz);
	List<Selection<?>> selections = new ArrayList<>();
	for (String str : fields) {
		selections.add(root.get(str));
	}
	Predicate p = cb.equal(root.get(equalAttribute), equalValue);
	p = cb.and(p, cb.notEqual(root.get(otherNotEqualAttribute), otherNotEqualValue));
	cq.multiselect(selections).where(p).orderBy(cb.desc(root.get(orderAttribute)));
	for (Tuple o : em.createQuery(cq).setFirstResult(startPosition).setMaxResults(max).getResultList()) {
		T t = clz.newInstance();
		for (int i = 0; i < fields.size(); i++) {
			PropertyUtils.setProperty(t, fields.get(i), o.get(selections.get(i)));
		}
		list.add(t);
	}
	return list;
}
 

@Override
@SuppressWarnings({"rawtypes"})
public long getTotalRowCount() {
    Selection<T> selection = query.getSelection();
    List<Order> orderList = query.getOrderList();
    try {
        CriteriaBuilder builder = em.getCriteriaBuilder();
        Expression<Long> countExpr;

        Set<Root<?>> roots = query.getRoots();
        if (roots.size() != 1) {
            throw new IllegalStateException("cannot compute totalRowCount in case of multiple query roots");
        }
        if (!query.getGroupList().isEmpty()) {
            throw new IllegalStateException("cannot compute totalRowCount for grouped queries");
        }

        // transform query to a count query
        Root root = roots.iterator().next();
        countExpr = isDistinct() ? builder.countDistinct(root) : builder.count(root);
        query.multiselect(countExpr);
        query.orderBy(new ArrayList<>());

        TypedQuery countQuery = em.createQuery(query);

        return (Long) countQuery.getSingleResult();
    } finally {
        // transform count query back to regular query
        query.multiselect(selection);
        query.orderBy(orderList);
    }
}
 

public CompoundSelectionImpl(
		CriteriaBuilderImpl criteriaBuilder,
		Class<X> javaType,
		List<Selection<?>> selectionItems) {
	super( criteriaBuilder, javaType );
	this.isConstructor = !javaType.isArray() && !Tuple.class.isAssignableFrom( javaType );
	this.selectionItems = selectionItems;
}
 

@Override
public List<ValueHandlerFactory.ValueHandler> getValueHandlers() {
	if ( isConstructor ) {
		return null;
	}
	boolean foundHandlers = false;
	ArrayList<ValueHandlerFactory.ValueHandler> valueHandlers = new ArrayList<ValueHandlerFactory.ValueHandler>();
	for ( Selection selection : getCompoundSelectionItems() ) {
		ValueHandlerFactory.ValueHandler valueHandler = ( (TupleElementImplementor) selection ).getValueHandler();
		valueHandlers.add( valueHandler );
		foundHandlers = foundHandlers || valueHandler != null;
	}
	return foundHandlers ? null : valueHandlers;
}
 

@Override
public <T> QueryImplementor<T> createQuery(
		String jpaqlString,
		Class<T> resultClass,
		Selection selection,
		QueryOptions queryOptions) {
	return delegate.createQuery( jpaqlString,resultClass, selection, queryOptions );
}