In this tutorial, we will continue implementing an extension for the Criteria API using the Builder pattern and JPA Static Metamodel Generator. Please check the previous parts: Improving your experience with Criteria API using Builder pattern and JPA Static Metamodel - Part I Improving your experience with Criteria API using Builder pattern and JPA Static Metamodel - Part II In this chapter, we provide the (subquery) operator, for example: IN List<Order> ordersToSpainWithActiveMembership = criteriaApiHelper.select(Order.class)
 .in(Order_.customer,
 subquery(CustomerMembership.class)
 .isTrue(CustomerMembership_.isActive)
 .select(CustomerMembership_.customer),
 subquery(CustomerAddress.class)
 .equal(CustomerAddress_.country, Country_.name, "Spain")
 .select(CustomerAddress_.customer)
 )
 .findAll(); This query should fetch orders for the customers matching two subqueries: the customers with an active membership and the customers who live in Spain. 1. SubqueryPredicate First of all, to store the details, we define the interface. It will help us to construct the the same way as , which we created earlier to construct the : javax.persistence.criteria.Subquery SubqueryPredicate javax.persistence.criteria.Subquery QueryPredicate javax.persistence.criteria.Predicate @FunctionalInterface
public interface SubqueryPredicate {
 Subquery apply(CommonAbstractCriteria criteria, CriteriaBuilder cb);
} 2. SubQuery In this step, we create the interface to be able to filter the subquery using predicates methods from the inheriting interface: SubQuery BaseQuery public interface SubQuery<R, Q extends SubQuery<R, Q>> extends BaseQuery<R, Q> {
} Then after we provided the necessary filters with methods, in order to finish a subquery, we may need to specify the custom subquery’s path to select that will be used for the operator. BaseQuery IN For example, with the following method, we can select the entity from the root entity type: select() Customer CustomerAddress subquery(CustomerAddress.class)
 .equal(CustomerAddress_.country, Country_.name, "Spain")
 .equal(CustomerAddress_.city, City_.name, "Madrid")
 .select(CustomerAddress_.customer) Let’s provide the necessary methods with a different set of a parent-child relations chain, returning the instance, which we can use later to construct the : select() SubqueryPredicate javax.persistence.criteria.Subquery public interface SubQuery<R, Q extends SubQuery<R, Q>> extends BaseQuery<R, Q> {
 SubqueryPredicate<R> select();

 SubqueryPredicate select(SingularAttribute<R, P> attribute);

 <P1, P2> SubqueryPredicate<P2> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2);

 <P1, P2, P3> SubqueryPredicate<P3> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2, SingularAttribute<P2, P3> attribute3);
} Next, let’s create the implementation of the interface, and implement the defined methods: SubQuery select() public class SubQueryImpl<R> extends BaseQueryImpl<R, SubQueryImpl<R>> implements SubQuery<R, SubQueryImpl<R>> {
} When we construct a subquery, first we specify the Root type as the entity that we use to start a query from. Therefore, the constructor should accept the Root type: public class SubQueryImpl<R> extends BaseQueryImpl<R, SubQueryImpl<R>> implements SubQuery<R, SubQueryImpl<R>> {
 private final Class<R> type;

 public SubQueryImpl(Class<R> type) {
 this.type = type;
 }

 @Override
 protected SubQueryImpl<R> self() {
 return this;
 }
} Next, we implement the defined methods. Each method should return an instance of : select() SubqueryPredicate new SubqueryPredicate<R>() {
 @Override
 public Subquery<R> apply(CommonAbstractCriteria criteria, CriteriaBuilder cb) {
 Subquery<R> subquery = criteria.subquery(type);
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot)
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 }
}; The complete implementation of all the defined methods: select() public class SubQueryImpl<R> extends BaseQueryImpl<R, SubQueryImpl<R>> implements SubQuery<R, SubQueryImpl<R>> {
 ...

 @Override
 public SubqueryPredicate<R> select() {
 return (query, cb) -> {
 Subquery<R> subquery = query.subquery(type);
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot)
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }

 @Override
 public SubqueryPredicate select(SingularAttribute<R, P> attribute) {
 return (query, cb) -> {
 Subquery subquery = query.subquery(attribute.getJavaType());
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot.get(attribute))
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }

 @Override
 public <P1, P2> SubqueryPredicate<P2> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2) {
 return (query, cb) -> {
 Subquery<P2> subquery = query.subquery(attribute2.getJavaType());
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot.get(attribute1).get(attribute2))
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }

 @Override
 public <P1, P2, P3> SubqueryPredicate<P3> select(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2, SingularAttribute<P2, P3> attribute3) {
 return (query, cb) -> {
 Subquery<P3> subquery = query.subquery(attribute3.getJavaType());
 Root<R> subqueryRoot = subquery.from(type);
 subquery
 .select(subqueryRoot.get(attribute1).get(attribute2).get(attribute3))
 .where(buildPredicates(subquery, predicates, cb, subqueryRoot));
 return subquery;
 };
 }
} Now, we can compose a subquery using the and build an instance of the . But to apply the operator, we should define the filter in the interface. SubQueryImpl SubqueryPredicate IN in() BaseQuery 3. IN Operator In this section, we will define the absent filter in the interface. This method should accept the varargs argument as the selected value of : IN BaseQuery SubqueryPredicate<R> SubQuery public interface BaseQuery<R, Q extends BaseQuery<R, Q>> {
 ...

 Q in(SubqueryPredicate<R>... values);
} Next, we can specify additional methods accepting parameters to reach the nested relation which should be used in the operator. in() SingularAttribute IN In the following example, we use the filter to match the entity with the subquery, returning the entity: in() Address’s city Location City .in(Address_.city,
 subquery(Location.class)
 .isTrue(Location_.hasPriority)
 .select(Location_.city)
) Let’s define these additional methods accepting a different set of parent-child arguments, allowing us to use nested relations: in() SingularAttribute public interface BaseQuery<R, Q extends BaseQuery<R, Q>> {
 ...

 <V> Q in(SingularAttribute<R, V> attribute, SubqueryPredicate<V>... values);

 <P, V> Q in(SingularAttribute<R, P> attribute1, SingularAttribute<P, V> attribute2, SubqueryPredicate<V>... values);

 <P1, P2, V> Q in(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2, SingularAttribute<P2, V> attribute3, SubqueryPredicate<V>... values);
} Next, let’s implement defined methods in the . Each method should first map the varargs parameters to the instances using method and, after that, create a predicate with the operator for the path provided by parameters: in() BaseQueryImpl SubqueryPredicate javax.persistence.criteria.Subquery SubqueryPredicate#apply() IN SingularAttribute Predicate[] predicates = Arrays.stream(subqueryPredicates)
 .map(t -> t.apply(CommonAbstractCriteria, CriteriaBuilder))
 .map(subquery -> root.get(attribute).in(subquery))
 .toArray(Predicate[]::new); Now we can apply the to make a conjunction of the obtained predicates and finally, construct an instance of the : CriteriaBuilder#and() QueryPredicate new QueryPredicate<R>() {
 @Override
 public Predicate apply(CommonAbstractCriteria criteria, CriteriaBuilder cb, Path<R> root) {
 Predicate[] predicates = Arrays.stream(subqueryPredicates)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute).in(subquery))
 .toArray(Predicate[]::new);
 return cb.and(predicates);
 }
}; There is the complete implementation of all methods: in() public abstract class BaseQueryImpl<R, Q extends BaseQueryImpl<R, Q>> implements BaseQuery<R, Q> {
 ...

 @SafeVarargs
 @Override
 public final Q in(SubqueryPredicate<R>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(root::in)
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }

 @SafeVarargs
 @Override
 public final <V> Q in(SingularAttribute<R, V> attribute, SubqueryPredicate<V>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute).in(subquery))
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }

 @SafeVarargs
 @Override
 public final <P, V> Q in(SingularAttribute<R, P> attribute1, SingularAttribute<P, V> attribute2, SubqueryPredicate<V>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute1).get(attribute2).in(subquery))
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }



 @SafeVarargs
 @Override
 public final <P1, P2, V> Q in(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2,
 SingularAttribute<P2, V> attribute3, SubqueryPredicate<V>... values) {
 predicates.add((criteria, cb, root) ->
 cb.and(
 Arrays.stream(values)
 .map(t -> t.apply(criteria, cb))
 .map(subquery -> root.get(attribute1).get(attribute2).get(attribute3).in(subquery))
 .toArray(Predicate[]::new)
 )
 );
 return self();
 }

} Lastly, to finish the implementation, we can provide static methods, allowing us to create nested predicates within the filters. in() IN and/or For example, the following query will retrieve the orders with a customer matching any of the provided subqueries: List<Order> ordersToSpainOrWithActiveMembership = criteriaApiHelper.select(Order.class)
 .or(Order_.customer,
 in(
 subquery(CustomerDetails.class)
 .isTrue(CustomerDetails_.isActiveMembership)
 .select(CustomerDetails_.customer)
 ),
 in(Customer_.address,
 subquery(AddressDetails.class)
 .equal(AddressDetails_.country, Country_.name, "Spain")
 .select(AddressDetails_.address)
 )
 )
 .findAll(); There is the implementation for all the static methods in the class: in() CriteriaApiHelper public class CriteriaApiHelper {
 ...
	
 @SafeVarargs
 public static <R> QueryPart<R> in(SubqueryPredicate<R>... values) {
 return new QueryPart<R>()
 .in(values);
 }

 @SafeVarargs
 public static <R, V> QueryPart<R> in(SingularAttribute<R, V> attribute, SubqueryPredicate<V>... values) {
 return new QueryPart<R>()
 .in(attribute, values);
 }

 @SafeVarargs
 public static <R, P, V> QueryPart<R> in(SingularAttribute<R, P> attribute1, SingularAttribute<P, V> attribute2,
 SubqueryPredicate<V>... values) {
 return new QueryPart<R>()
 .in(attribute1, attribute2, values);
 }

 @SafeVarargs
 public static <R, P1, P2, V> QueryPart<R> in(SingularAttribute<R, P1> attribute1, SingularAttribute<P1, P2> attribute2,
 SingularAttribute<P2, V> attribute3, SubqueryPredicate<V>... values) {
 return new QueryPart<R>()
 .in(attribute1, attribute2, attribute3, values);
 }
} 4. Wrapping Up In this part, we slightly improved extension for the Criteria API. Now we can perform the operator. IN

Chain

Fetch

2022 - HackerNoon Contributor of the Year - Algorithms

2022 - HackerNoon Contributor of the Year - Coding Skills

2022 - HackerNoon Contributor of the Year - Functional Programming

2022 - HackerNoon Contributor of the Year - Java

2022 - HackerNoon Contributor of the Year - Programming

2022 - HackerNoon Contributor of the Year - Sql

2022 - Rawr For Ror

Coding Guru of 2022

Nominated for 2022 - Rawr For Ror

Nominated for 2022 - HackerNoon Contributor of the Year - Sql

Nominated for Coding Guru of 2022

Nominated for 2022 - HackerNoon Contributor of the Year - Coding Skills

Nominated for 2022 - HackerNoon Contributor of the Year - Java

Nominated for 2022 - HackerNoon Contributor of the Year - Algorithms

Building Your Own Programming Language From Scratch

Parallel Merge Sort with Fork/Join Framework

3 Ways to Deal With Hibernate N+1 Problem

Too Long; Didn't Read

In your car, at home, or at work — Bosch technology shapes many areas of life.

Improving Your Experience With CriteriaAPI Using Builder Pattern and JPA Static Metamodel - Part III

Improving Your Experience With CriteriaAPI Using Builder Pattern and JPA Static Metamodel - Part III

Too Long; Didn't Read

Company Mentioned

Coin Mentioned

Alexander Makeev

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

Improving Your Experience With CriteriaAPI Using Builder Pattern and JPA Static Metamodel - Part III

Too Long; Didn't Read

Company Mentioned

Coin Mentioned

Alexander Makeev

About Author

TOPICS

THIS ARTICLE WAS FEATURED IN...

RELATED STORIES