412 lines
20 KiB
Java
412 lines
20 KiB
Java
package eu.eudat.queryable.jpa.hibernatequeryablelist;
|
|
|
|
import eu.eudat.queryable.QueryableList;
|
|
import eu.eudat.queryable.exceptions.NotSingleResultException;
|
|
import eu.eudat.queryable.jpa.predicates.NestedQuerySinglePredicate;
|
|
import eu.eudat.queryable.jpa.predicates.OrderByPredicate;
|
|
import eu.eudat.queryable.jpa.predicates.SelectPredicate;
|
|
import eu.eudat.queryable.jpa.predicates.SinglePredicate;
|
|
import eu.eudat.queryable.queryableentity.DataEntity;
|
|
import eu.eudat.queryable.types.FieldSelectionType;
|
|
import eu.eudat.queryable.types.SelectionField;
|
|
import org.springframework.scheduling.annotation.Async;
|
|
|
|
import javax.persistence.EntityManager;
|
|
import javax.persistence.Tuple;
|
|
import javax.persistence.TypedQuery;
|
|
import javax.persistence.criteria.*;
|
|
import java.util.*;
|
|
import java.util.concurrent.CompletableFuture;
|
|
import java.util.stream.Collectors;
|
|
|
|
public class QueryableHibernateList<T extends DataEntity> implements QueryableList<T> {
|
|
|
|
private EntityManager manager;
|
|
private CriteriaQuery query;
|
|
private Class<T> tClass;
|
|
private Root<T> root;
|
|
private Root<T> nestedQueryRoot;
|
|
private Subquery subquery;
|
|
private List<SinglePredicate<T>> singlePredicates = new LinkedList<>();
|
|
private List<NestedQuerySinglePredicate<T>> nestedPredicates = new LinkedList<>();
|
|
private boolean distinct = false;
|
|
private List<OrderByPredicate<T>> orderings = new LinkedList<>();
|
|
private List<String> fields = new LinkedList<>();
|
|
private Integer length;
|
|
private Integer offset;
|
|
private Set<String> hints;
|
|
private String hint;
|
|
|
|
public QueryableHibernateList(EntityManager manager, Class<T> tClass) {
|
|
this.manager = manager;
|
|
this.tClass = tClass;
|
|
}
|
|
|
|
public QueryableHibernateList<T> setManager(EntityManager manager) {
|
|
this.manager = manager;
|
|
return this;
|
|
}
|
|
|
|
public QueryableList<T> withHint(String hint) {
|
|
this.hint = hint;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public QueryableList<T> withFields(List<String> fields) {
|
|
this.fields = fields;
|
|
return this;
|
|
}
|
|
|
|
private QueryableList<T> selectFields() {
|
|
List<Selection> rootFields = fields.stream().map(field -> this.convertFieldToPath(field)).collect(Collectors.toList());
|
|
this.query.select(this.manager.getCriteriaBuilder().tuple(rootFields.toArray(new Selection[rootFields.size()])));
|
|
return this;
|
|
}
|
|
|
|
private Path convertFieldToPath(String field) {
|
|
if (!field.contains(".")) {
|
|
Path path = this.root.get(field);
|
|
path.alias(field);
|
|
return path;
|
|
} else {
|
|
String[] fields = field.split("\\.");
|
|
Path path = this.root.get(fields[0]);
|
|
Join join = null;
|
|
path.alias(fields[0]);
|
|
for (int i = 1; i < fields.length; i++) {
|
|
join = join != null ? join.join(fields[i - 1], JoinType.LEFT) : this.root.join(fields[i - 1], JoinType.LEFT) ;
|
|
path = join.get(fields[i]);
|
|
path.alias(String.join(".", Arrays.asList(fields).subList(0, i + 1)));
|
|
}
|
|
return path;
|
|
}
|
|
}
|
|
|
|
public QueryableHibernateList<T> setEntity(Class<T> type) {
|
|
|
|
return this;
|
|
}
|
|
|
|
public void initiateQueryableList(Class<T> type) {
|
|
CriteriaBuilder builder = this.manager.getCriteriaBuilder();
|
|
this.query = builder.createQuery(type);
|
|
}
|
|
|
|
@Override
|
|
public QueryableList<T> skip(Integer offset) {
|
|
this.offset = offset;
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public QueryableList<T> take(Integer length) {
|
|
this.length = length;
|
|
return this;
|
|
}
|
|
|
|
public QueryableList<T> where(SinglePredicate<T> predicate) {
|
|
this.singlePredicates.add(predicate);
|
|
return this;
|
|
}
|
|
|
|
public QueryableList<T> where(NestedQuerySinglePredicate<T> predicate) {
|
|
this.nestedPredicates.add(predicate);
|
|
return this;
|
|
}
|
|
|
|
public <R> List<R> select(SelectPredicate<T, R> predicate) {
|
|
return this.toList().stream().map(item -> predicate.applySelection(item)).collect(Collectors.toList());
|
|
}
|
|
|
|
public <R> CompletableFuture<List<R>> selectAsync(SelectPredicate<T, R> predicate) {
|
|
return this.toListAsync().thenApplyAsync(items -> items.stream().map(item -> predicate.applySelection(item)).collect(Collectors.toList()));
|
|
}
|
|
|
|
public QueryableList<T> distinct() {
|
|
this.distinct = true;
|
|
return this;
|
|
}
|
|
|
|
public QueryableList<T> orderBy(OrderByPredicate<T> predicate) {
|
|
this.orderings.add(predicate);
|
|
return this;
|
|
}
|
|
|
|
public Long count() {
|
|
CriteriaBuilder criteriaBuilder = this.manager.getCriteriaBuilder();
|
|
CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
|
|
this.root = criteriaQuery.from(tClass);
|
|
if (distinct) criteriaQuery.select(criteriaBuilder.countDistinct(this.root.get("id")));
|
|
else criteriaQuery.select(criteriaBuilder.count(this.root));
|
|
criteriaQuery.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
//if (distinct) criteriaQuery.distinct(true);
|
|
return this.manager.createQuery(criteriaQuery).getSingleResult();
|
|
}
|
|
|
|
@Async
|
|
public CompletableFuture<Long> countAsync() {
|
|
CriteriaBuilder criteriaBuilder = this.manager.getCriteriaBuilder();
|
|
CriteriaQuery<Long> criteriaQuery = criteriaBuilder.createQuery(Long.class);
|
|
this.root = criteriaQuery.from(tClass);
|
|
if (distinct) criteriaQuery.select(criteriaBuilder.countDistinct(this.root.get("id")));
|
|
else criteriaQuery.select(criteriaBuilder.count(this.root));
|
|
criteriaQuery.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
//if (distinct) criteriaQuery.distinct(true);
|
|
return CompletableFuture.supplyAsync(() -> this.manager.createQuery(criteriaQuery).getSingleResult());
|
|
}
|
|
|
|
|
|
private Predicate[] generateWherePredicates(List<SinglePredicate<T>> singlePredicates, Root<T> root, List<NestedQuerySinglePredicate<T>> nestedPredicates, Root<T> nestedQueryRoot) {
|
|
List<Predicate> predicates = new LinkedList<>();
|
|
predicates.addAll(Arrays.asList(this.generateSingleWherePredicates(singlePredicates, root)));
|
|
predicates.addAll(Arrays.asList(this.generateNestedWherePredicates(nestedPredicates, root, nestedQueryRoot)));
|
|
return predicates.toArray(new Predicate[predicates.size()]);
|
|
}
|
|
|
|
private Predicate[] generateSingleWherePredicates(List<SinglePredicate<T>> singlePredicates, Root<T> root) {
|
|
List<Predicate> predicates = new LinkedList<>();
|
|
for (SinglePredicate<T> singlePredicate : singlePredicates) {
|
|
predicates.add(singlePredicate.applyPredicate(this.manager.getCriteriaBuilder(), root));
|
|
}
|
|
return predicates.toArray(new Predicate[predicates.size()]);
|
|
}
|
|
|
|
private Predicate[] generateNestedWherePredicates(List<NestedQuerySinglePredicate<T>> nestedPredicates, Root<T> root, Root<T> nestedQueryRoot) {
|
|
List<Predicate> predicates = new LinkedList<>();
|
|
for (NestedQuerySinglePredicate<T> singlePredicate : nestedPredicates) {
|
|
predicates.add(singlePredicate.applyPredicate(this.manager.getCriteriaBuilder(), root, nestedQueryRoot));
|
|
}
|
|
return predicates.toArray(new Predicate[predicates.size()]);
|
|
}
|
|
|
|
private Order[] generateOrderPredicates(List<OrderByPredicate<T>> orderByPredicates, Root<T> root) {
|
|
List<Order> predicates = new LinkedList<>();
|
|
for (OrderByPredicate<T> orderPredicate : orderByPredicates) {
|
|
predicates.add(orderPredicate.applyPredicate(this.manager.getCriteriaBuilder(), root));
|
|
}
|
|
return predicates.toArray(new Order[predicates.size()]);
|
|
}
|
|
|
|
public List<T> toList() {
|
|
CriteriaBuilder builder = this.manager.getCriteriaBuilder();
|
|
if (!this.fields.isEmpty()) this.query = builder.createTupleQuery();
|
|
else this.query = builder.createQuery(this.tClass);
|
|
this.root = this.query.from(this.tClass);
|
|
this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
if (!this.orderings.isEmpty()) this.query.orderBy(this.generateOrderPredicates(this.orderings, this.root));
|
|
if (!this.fields.isEmpty()) this.selectFields();
|
|
if (distinct) this.query.distinct(true);
|
|
if (!this.fields.isEmpty()) return this.toListWithFields();
|
|
else return this.toListWithOutFields();
|
|
}
|
|
|
|
private List<T> toListWithFields() {
|
|
List<Tuple> results = this.manager.createQuery(query).getResultList();
|
|
Map<Object, List<Tuple>> groupedResults = results.stream()
|
|
.collect(Collectors.groupingBy(x -> x.get("id")));
|
|
return results.stream().map(x -> {
|
|
try {
|
|
return (T) this.tClass.newInstance().buildFromTuple(groupedResults.get(x.get("id")), "");
|
|
} catch (InstantiationException | IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return null;
|
|
}).collect(Collectors.toList());
|
|
}
|
|
|
|
private List<T> toListWithOutFields() {
|
|
TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
|
|
if (this.offset != null) typedQuery.setFirstResult(this.offset);
|
|
if (this.length != null) typedQuery.setMaxResults(this.length);
|
|
if (this.hint != null) {
|
|
List ids = typedQuery.getResultList().stream().map(item -> item.getKeys()).collect(Collectors.toList());
|
|
if (ids != null && !ids.isEmpty()) typedQuery = queryWithHint(ids);
|
|
}
|
|
return typedQuery.getResultList();
|
|
}
|
|
|
|
@Async
|
|
public CompletableFuture<List<T>> toListAsync() {
|
|
CriteriaBuilder builder = this.manager.getCriteriaBuilder();
|
|
if (!this.fields.isEmpty()) this.query = builder.createTupleQuery();
|
|
else this.query = builder.createQuery(this.tClass);
|
|
this.root = this.query.from(this.tClass);
|
|
this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
if (!this.orderings.isEmpty()) this.query.orderBy(this.generateOrderPredicates(this.orderings, this.root));
|
|
if (!this.fields.isEmpty()) this.selectFields();
|
|
if (distinct) this.query.distinct(true);
|
|
if (!this.fields.isEmpty()) return this.toListAsyncWithFields();
|
|
else return this.toListAsyncWithOutFields();
|
|
}
|
|
|
|
private CompletableFuture<List<T>> toListAsyncWithFields() {
|
|
List<Tuple> results = this.manager.createQuery(query).getResultList();
|
|
Map<Object, List<Tuple>> groupedResults = results.stream()
|
|
.collect(Collectors.groupingBy(x -> x.get("id")));
|
|
return CompletableFuture.supplyAsync(() -> results.stream().map(x -> {
|
|
try {
|
|
return (T) this.tClass.newInstance().buildFromTuple(groupedResults.get(x.get("id")), "");
|
|
} catch (InstantiationException | IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return null;
|
|
}).collect(Collectors.toList()));
|
|
}
|
|
|
|
private CompletableFuture<List<T>> toListAsyncWithOutFields() {
|
|
TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
|
|
if (this.offset != null) typedQuery.setFirstResult(this.offset);
|
|
if (this.length != null) typedQuery.setMaxResults(this.length);
|
|
return CompletableFuture.supplyAsync(() -> {
|
|
if (this.hint != null) {
|
|
List ids = typedQuery.getResultList().stream().map(item -> item.getKeys()).collect(Collectors.toList());
|
|
if (ids != null && !ids.isEmpty()) return queryWithHint(ids).getResultList();
|
|
}
|
|
return typedQuery.getResultList();
|
|
});
|
|
}
|
|
|
|
public T getSingle() {
|
|
CriteriaBuilder builder = this.manager.getCriteriaBuilder();
|
|
if (!this.fields.isEmpty()) this.query = builder.createTupleQuery();
|
|
else this.query = builder.createQuery(this.tClass);
|
|
this.root = this.query.from(this.tClass);
|
|
this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
if (!this.fields.isEmpty()) this.selectFields();
|
|
TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
|
|
if (this.hint != null)
|
|
typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
|
|
return typedQuery.getSingleResult();
|
|
}
|
|
|
|
@Async
|
|
public CompletableFuture<T> getSingleAsync() {
|
|
CriteriaBuilder builder = this.manager.getCriteriaBuilder();
|
|
if (!this.fields.isEmpty()) this.query = builder.createTupleQuery();
|
|
else this.query = builder.createQuery(this.tClass);
|
|
this.root = this.query.from(this.tClass);
|
|
this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
if (!this.fields.isEmpty()) this.selectFields();
|
|
TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
|
|
if (this.hint != null)
|
|
typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
|
|
return CompletableFuture.supplyAsync(() -> typedQuery.getSingleResult());
|
|
}
|
|
|
|
public T getSingleOrDefault() {
|
|
CriteriaBuilder builder = this.manager.getCriteriaBuilder();
|
|
if (!this.fields.isEmpty()) this.query = builder.createTupleQuery();
|
|
else this.query = builder.createQuery(this.tClass);
|
|
this.root = this.query.from(this.tClass);
|
|
this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
if (!this.fields.isEmpty()) this.selectFields();
|
|
TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
|
|
if (this.hint != null)
|
|
typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
|
|
List<T> results = typedQuery.getResultList();
|
|
if (results.size() == 0) return null;
|
|
if (results.size() == 1) return results.get(0);
|
|
else throw new NotSingleResultException("Query returned more than one items");
|
|
}
|
|
|
|
@Async
|
|
public CompletableFuture<T> getSingleOrDefaultAsync() {
|
|
CriteriaBuilder builder = this.manager.getCriteriaBuilder();
|
|
if (!this.fields.isEmpty()) this.query = builder.createTupleQuery();
|
|
else this.query = builder.createQuery(this.tClass);
|
|
this.root = this.query.from(this.tClass);
|
|
this.query.where(this.generateWherePredicates(this.singlePredicates, this.root, this.nestedPredicates, this.nestedQueryRoot));
|
|
if (!this.fields.isEmpty()) this.selectFields();
|
|
TypedQuery<T> typedQuery = this.manager.createQuery(this.query);
|
|
if (this.hint != null)
|
|
typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
|
|
return CompletableFuture.supplyAsync(() -> typedQuery.getResultList()).thenApply(list -> {
|
|
if (list.size() == 0) return null;
|
|
if (list.size() == 1) return list.get(0);
|
|
else throw new NotSingleResultException("Query returned more than one items");
|
|
});
|
|
}
|
|
|
|
private TypedQuery<T> queryWithHint(List ids) {
|
|
CriteriaBuilder criteriaBuilder = this.manager.getCriteriaBuilder();
|
|
CriteriaQuery<T> criteriaQuery = criteriaBuilder.createQuery(tClass);
|
|
Root<T> criteriaRoot = criteriaQuery.from(this.tClass);
|
|
criteriaQuery.where(criteriaRoot.get("id").in(ids));
|
|
if (!this.orderings.isEmpty())
|
|
criteriaQuery.orderBy(this.generateOrderPredicates(this.orderings, criteriaRoot));
|
|
|
|
TypedQuery<T> typedQuery = this.manager.createQuery(criteriaQuery);
|
|
typedQuery.setHint("javax.persistence.fetchgraph", this.manager.getEntityGraph(this.hint));
|
|
return typedQuery;
|
|
}
|
|
|
|
@Override
|
|
public Subquery<T> subQuery(SinglePredicate<T> predicate, List<SelectionField> fields) {
|
|
Subquery<T> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(this.tClass);
|
|
this.nestedQueryRoot = subquery.from(this.tClass);
|
|
subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.nestedQueryRoot));
|
|
subquery.select(this.nestedQueryRoot.get(fields.get(0).getField()));
|
|
return subquery;
|
|
}
|
|
|
|
@Override
|
|
public Subquery<T> subQuery(NestedQuerySinglePredicate<T> predicate, List<SelectionField> fields) {
|
|
Subquery<T> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(this.tClass);
|
|
this.nestedQueryRoot = subquery.from(this.tClass);
|
|
subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root, this.nestedQueryRoot));
|
|
subquery.select(this.nestedQueryRoot.get(fields.get(0).getField()));
|
|
return subquery;
|
|
}
|
|
|
|
@Override
|
|
public Subquery<Long> subQueryCount(SinglePredicate<T> predicate, List<SelectionField> fields) {
|
|
Subquery<Long> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(Long.class);
|
|
this.nestedQueryRoot = subquery.from(this.tClass);
|
|
subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.nestedQueryRoot));
|
|
subquery.select(this.manager.getCriteriaBuilder().count(this.nestedQueryRoot.get(fields.get(0).getField())));
|
|
return subquery;
|
|
}
|
|
|
|
@Override
|
|
public Subquery<Long> subQueryCount(NestedQuerySinglePredicate<T> predicate, List<SelectionField> fields) {
|
|
Subquery<Long> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(Long.class);
|
|
this.nestedQueryRoot = subquery.from(this.tClass);
|
|
subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root, this.nestedQueryRoot));
|
|
subquery.select(this.manager.getCriteriaBuilder().count(this.nestedQueryRoot.get(fields.get(0).getField())));
|
|
return subquery;
|
|
}
|
|
|
|
@Override
|
|
public <U extends Comparable> Subquery<U> subQueryMax(SinglePredicate<T> predicate, List<SelectionField> fields, Class<U> uClass) {
|
|
Subquery<U> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(uClass);
|
|
this.nestedQueryRoot = subquery.from(this.tClass);
|
|
subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.nestedQueryRoot));
|
|
if (fields.get(0).getType() == FieldSelectionType.FIELD)
|
|
subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.<U>get(fields.get(0).getField())));
|
|
else if (fields.get(0).getType() == FieldSelectionType.COMPOSITE_FIELD) {
|
|
subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.get(fields.get(0).getField().split(":")[0]).<U>get(fields.get(0).getField().split(":")[1])));
|
|
}
|
|
return subquery;
|
|
}
|
|
|
|
@Override
|
|
public <U extends Comparable> Subquery<U> subQueryMax(NestedQuerySinglePredicate<T> predicate, List<SelectionField> fields, Class<U> uClass) {
|
|
//Subquery<U> subquery = this.manager.getCriteriaBuilder().createQuery().subquery(uClass);
|
|
//this.nestedQueryRoot = subquery.from(this.tClass);
|
|
subquery.where(predicate.applyPredicate(this.manager.getCriteriaBuilder(), this.root, this.nestedQueryRoot));
|
|
if (fields.get(0).getType() == FieldSelectionType.FIELD)
|
|
subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.<U>get(fields.get(0).getField())));
|
|
else if (fields.get(0).getType() == FieldSelectionType.COMPOSITE_FIELD) {
|
|
subquery.select(this.manager.getCriteriaBuilder().greatest(this.nestedQueryRoot.get(fields.get(0).getField().split(":")[0]).<U>get(fields.get(0).getField().split(":")[1])));
|
|
}
|
|
return subquery;
|
|
}
|
|
|
|
public <U extends Comparable> QueryableList<T> initSubQuery(Class<U> uClass) {
|
|
this.subquery = this.manager.getCriteriaBuilder().createQuery().subquery(uClass);
|
|
this.nestedQueryRoot = subquery.from(this.tClass);
|
|
return this;
|
|
}
|
|
}
|