import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
public static <K extends Serializable & Comparable<K>, T extends GenericEntity<K, ?>> BooleanExpression idEqIfGiven(SimpleExpression<K> path, T value) {
	if (value != null) {
		return path.eq(value.getId());
	} else {
		return null;
	}
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
public static <T> BooleanExpression inIfGiven(SimpleExpression<T> path, Collection<? extends T> subset) {
	if (subset != null && !subset.isEmpty()) {
		return path.in(subset);
	} else {
		return null;
	}
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
protected <P extends Comparable<?>> BooleanExpression matchAllIfGiven(SimpleExpression<P> simpleExpression, Collection<? extends P> possibleValues) {
	if (possibleValues != null && !possibleValues.isEmpty()) {
		BooleanExpression rootExpression = null;
		for (P possibleValue : possibleValues) {
			if (rootExpression == null) {
				rootExpression = simpleExpression.eq(possibleValue);
			} else {
				rootExpression = rootExpression.and(simpleExpression.eq(possibleValue));
			}
		}
		return rootExpression;
	}
	return null;
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@SafeVarargs
public static <T extends SimpleExpression<?>, V> void append(BooleanBuilder builder,
                                                             V value,
                                                             BiFunction<T, V, BooleanExpression> operation,
                                                             T path,
                                                             T... paths) {
    checkNotNull(builder);
    checkNotNull(operation);
    checkNotNull(path);
    builder.and(Stream.concat(Stream.of(path), Stream.of(paths))
            .filter(e -> value != null && e != null)
            .map(e -> operation.apply(e, value))
            .collect(toBooleanBuilder()));
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@Test
public void testAppendNullWithOperationAndTwoArguments() throws Exception {
	BooleanBuilder builder = new BooleanBuilder();
	Arguments.<SimpleExpression, CustomNumberType>append(builder, null, SimpleExpression::eq, QPerson.person.oneCustomNumberType, QPerson.person.anotherCustomNumberType);
	List<Person> result = new JPAQuery<Void>(entityManager).select(QPerson.person).from(QPerson.person).where(builder).fetch();
	assertThat(result.size()).isEqualTo(1);
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
public <T extends CatalogItem, P extends CatalogItem> List<P> findForeignHolder(EntityPath<P> hp,
                                                                                ListPath<T, ? extends SimpleExpression<T>> h, T c) {

    return new JPAQueryFactory(entityManager)
            .selectFrom(hp)
            .where(h.contains(c))
            .fetch();
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@Override
public void addParentPredicate(MetaAttribute primaryKeyAttr) {
	List<?> parentIds = queryImpl.getParentIds();
	SimpleExpression<?> parentIdPath = (SimpleExpression<?>) QuerydslUtils.get(parentFrom, primaryKeyAttr.getName());
	addPredicate(parentIdPath.in((List) parentIds));
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
public static <T> BooleanExpression eqIfGiven(SimpleExpression<T> path, T value) {
	return value == null ? null : path.eq(value);
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
protected <T extends E, V extends Comparable<?>> T getByField(EntityPath<T> entityPath, SimpleExpression<V> field, V fieldValue) {
	return queryByPredicate(entityPath, eqOrIsNull(field, fieldValue)).fetchOne();
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
protected <T extends E, V extends Comparable<?>> List<T> listByField(EntityPath<T> entityPath, SimpleExpression<V> field, V fieldValue, OrderSpecifier<?>... orderSpecifiers) {
	return queryByPredicateOrdered(entityPath, eqOrIsNull(field, fieldValue), orderSpecifiers).fetch();
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
protected <V extends Comparable<?>> Long countByField(EntityPath<? extends E> entityPath, SimpleExpression<V> field, V fieldValue) {
	return queryByPredicate(entityPath, eqOrIsNull(field, fieldValue)).distinct().fetchCount();
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
private static <V extends Comparable<?>> Predicate eqOrIsNull(SimpleExpression<V> field, V fieldValue) {
	return fieldValue != null ? field.eq(fieldValue) : field.isNull() ;
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@Override
public <T extends Person, V extends Comparable<?>> T getByField(EntityPath<T> entityPath,
		SimpleExpression<V> field, V fieldValue) {
	return super.getByField(entityPath, field, fieldValue);
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@Override
public <T extends Person, V extends Comparable<?>> List<T> listByField(EntityPath<T> entityPath,
		SimpleExpression<V> field, V fieldValue, OrderSpecifier<?> orderSpecifier) {
	return super.listByField(entityPath, field, fieldValue, orderSpecifier);
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@Override
public <V extends Comparable<?>> Long countByField(EntityPath<? extends Person> entityPath,
		SimpleExpression<V> field, V fieldValue) {
	return super.countByField(entityPath, field, fieldValue);
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
<T extends Person, V extends Comparable<?>> List<T> listByField(EntityPath<T> entityPath,
SimpleExpression<V> field, V fieldValue, OrderSpecifier<?> orderSpecifier);
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
<T extends GenericListItem<?>, V extends Comparable<?>> List<T> listByField(EntityPath<T> entityPath,
SimpleExpression<V> field, V fieldValue, OrderSpecifier<?> orderSpecifier);
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
<V extends Comparable<?>> Long countByField(EntityPath<? extends GenericListItem<?>> entityPath,
SimpleExpression<V> field, V fieldValue);
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@Override
public <T extends GenericListItem<?>, V extends Comparable<?>> T getByField(EntityPath<T> entityPath,
		SimpleExpression<V> field, V fieldValue) {
	return super.getByField(entityPath, field, fieldValue);
}
 

import com.querydsl.core.types.dsl.SimpleExpression; //导入依赖的package包/类
@Override
public <T extends GenericListItem<?>, V extends Comparable<?>> List<T> listByField(EntityPath<T> entityPath,
		SimpleExpression<V> field, V fieldValue, OrderSpecifier<?> orderSpecifier) {
	return super.listByField(entityPath, field, fieldValue, orderSpecifier);
}