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

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

import paa.coder.noodleCriteriaBuilder.NoodleFactory;
import paa.coder.noodleCriteriaBuilder.interfaces.NoodlePredicate;
import paa.coder.noodleCriteriaBuilder.interfaces.PathFinder;
import paa.coder.noodleCriteriaBuilder.queryBuilder.expressions.SelectStore;
import paa.coder.noodleCriteriaBuilder.queryBuilder.specifications.NoodleSpecificationBuilder;

import javax.persistence.criteria.*;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;

public class SubqueryBuilder extends NoodleAbstractQuery.Select {


    protected final SelectStore.Single select;
    protected final Class from;
    protected final String alias;

    public SubqueryBuilder(NoodleFactory noodleFactory, Class from, String alias){
        super(noodleFactory);
        this.select = new SelectStore.Single();
        this.from = from;
        this.alias = alias;
    }

    public SubqueryBuilder(SubqueryBuilder builder){
        super(builder.noodleFactory);
        this.select = builder.select;
        this.groupBy = builder.groupBy;
        this.where = builder.where;
        this.having = builder.having;
        this.from = builder.from;
        this.alias = builder.alias;
    }

    @Override
    public SubqueryBuilder where(Function fPred){
        super.where(fPred);
        return this;
    }

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

    @Override
    public SubqueryBuilder having(Function fPred){
        super.having(fPred);
        return this;
    }

    @Override
    public SubqueryBuilder group(Consumer action){
        super.group(action);
        return this;
    }

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

    public static class Initiator {
        private final NoodleFactory noodleFactory;

        public Initiator(NoodleFactory noodleFactory){
            this.noodleFactory = noodleFactory;
        }

        public  SubqueryBuilder from(Class clazz, String alias){
            return new SubqueryBuilder<>(noodleFactory, clazz, alias);
        }

        public interface Runner extends Function> {

        }
    }

    public static class NoodleSubquery extends SubqueryBuilder {

        private final PathFinder parentPathFinder;
        private final Subquery subquery;

        public NoodleSubquery(SubqueryBuilder builder, PathFinder parentPathFinder, Subquery subquery){
            super(builder);
            this.parentPathFinder = parentPathFinder;
            this.subquery = subquery;
            this.subquery.alias(alias);
        }

        public static  NoodleSubquery sample(SubqueryBuilder builder, PathFinder parentPathFinder,CommonAbstractCriteria criteriaQuery){
            return new NoodleSubquery<>(builder,parentPathFinder, criteriaQuery.subquery(builder.from));
        }
        @Override
        public Optional parentFinder(){
            return Optional.of(parentPathFinder);
        }

        @Override
        public Optional alias(){
            return Optional.of(alias);
        }

        public Subquery build(){
            Root root = subquery.from(from);
            build(root, subquery, noodleFactory.getSession().getCriteriaBuilder());
            return subquery;
        }

        protected void build(Root root, Subquery criteriaQuery, CriteriaBuilder criteriaBuilder){
            select.apply(pathFinder(root), criteriaQuery, criteriaBuilder).or(() -> Optional.of(root)).ifPresent(i -> criteriaQuery.select((Expression) i));
            super.build(root, criteriaQuery, criteriaBuilder);
        }
    }
}