paa.coder.noodleCriteriaBuilder.queryBuilder.MultiSelectQuery Maven / Gradle / Ivy

Go to download
package paa.coder.noodleCriteriaBuilder.queryBuilder;

import org.hibernate.query.Query;
import paa.coder.noodleCriteriaBuilder.NoodleFactory;
import paa.coder.noodleCriteriaBuilder.exceptions.SelectionIsEmpty;
import paa.coder.noodleCriteriaBuilder.interfaces.NoodlePredicate;
import paa.coder.noodleCriteriaBuilder.interfaces.NoodleQuery;
import paa.coder.noodleCriteriaBuilder.interfaces.NoodleResult;
import paa.coder.noodleCriteriaBuilder.queryBuilder.expressions.OrderBuilder;
import paa.coder.noodleCriteriaBuilder.queryBuilder.expressions.SelectStore;
import paa.coder.noodleCriteriaBuilder.queryBuilder.specifications.NoodleSpecificationBuilder;

import javax.persistence.Tuple;
import javax.persistence.criteria.*;
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class MultiSelectQuery extends NoodleAbstractQuery.Select implements NoodleQuery {

    protected final Class from;
    protected final SelectStore.Multiply select;
    protected final OrderBuilder orderBuilder;

    public MultiSelectQuery(Class from, List where, NoodleFactory noodleFactory,OrderBuilder orderBuilder){
        super(noodleFactory);
        this.select = new SelectStore.Multiply(noodleFactory);
        this.orderBuilder = orderBuilder;
        this.where = where;
        this.from = from;
    }

    public MultiSelectQuery where(Function fPred){
        super.where(fPred);
        return this;
    }

    public MultiSelectQuery order(Consumer fPred){
        fPred.accept(orderBuilder);
        return this;
    }

    public MultiSelectQuery select(Consumer action){
        action.accept(select);
        return this;
    }

    public MultiSelectQuery having(Function fPred){
        super.having(fPred);
        return this;
    }

    @Override
    public MultiSelectQuery itDistinct(Boolean d){
        super.itDistinct(d);
        return this;
    }

    public MultiSelectQuery group(Consumer action){
        return group(action,false);
    }

    public MultiSelectQuery group(Consumer action,Boolean addToSelect){
        super.group(action);
        if(addToSelect){
            action.accept(select);
        }
        return this;
    }

    public CriteriaQuery criteriaQuery(String alias){
        CriteriaQuery criteriaQuery = noodleFactory.getSession().getCriteriaBuilder().createTupleQuery();
        Root root = criteriaQuery.from(from);
        root.alias(alias);
        build(root, criteriaQuery, noodleFactory.getSession().getCriteriaBuilder());
        return criteriaQuery;
    }

    public CriteriaQuery criteriaQuery(){
        return criteriaQuery(null);
    }

    public Query query(){
        return noodleFactory.getSession().createQuery(criteriaQuery());
    }

    public Stream stream(Integer count, Integer offset){
        Query query = query();
        Optional.ofNullable(count).ifPresent(i->{
            query.setMaxResults(i);
            Optional.ofNullable(offset).ifPresent(query::setFirstResult);
        });
        return query.getResultStream().map(tuple -> {
            NoodleResult m = new NoodleResult();
            tuple.getElements().forEach(e -> m.put(e.getAlias(), tuple.get(e)));
            return m;
        });
    }

    public  Stream projection(Class tClass){
        return projection(tClass, null);
    }

    public  Stream projection(Class tClass, Integer count){
        return projection(tClass,count,null);
    }

    public  Stream projection(Class tClass, Integer count,Integer offset){
        return stream(count,offset).map(i -> noodleFactory.getObjectMapper().convertValue(i, tClass));
    }

    protected void build(Root root, CriteriaQuery criteriaQuery, CriteriaBuilder criteriaBuilder){
        List> selections = Optional
                .ofNullable(select.apply(pathFinder(root), criteriaQuery, criteriaBuilder))
                .filter(i -> ! i.isEmpty())
                .or(() -> Optional.of(getGroupBy().apply(pathFinder(root), criteriaQuery, criteriaBuilder)))
                .filter(i -> ! i.isEmpty())
                .or(() -> {
                    this.select.select(from);
                    return Optional.of(select.apply(pathFinder(root), criteriaQuery, criteriaBuilder));
                })
                .filter(i -> ! i.isEmpty())
                .orElseThrow(() -> new SelectionIsEmpty("not set find props"));


        criteriaQuery.multiselect(selections.stream().map(_i -> (Selection) _i).collect(Collectors.toList()));
        criteriaQuery.orderBy(orderBuilder.apply(pathFinder(root), criteriaQuery, criteriaBuilder));
        super.build(root, criteriaQuery, criteriaBuilder);
    }

}