org.dellroad.querystream.jpa.ExprStreamImpl Maven / Gradle / Ivy

Go to download

/*
 * Copyright (C) 2018 Archie L. Cobbs. All rights reserved.
 */

package org.dellroad.querystream.jpa;

import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;

import javax.persistence.EntityManager;
import javax.persistence.FlushModeType;
import javax.persistence.LockModeType;
import javax.persistence.Parameter;
import javax.persistence.TemporalType;
import javax.persistence.criteria.AbstractQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Order;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Selection;
import javax.persistence.criteria.Subquery;
import javax.persistence.metamodel.PluralAttribute;
import javax.persistence.metamodel.SingularAttribute;

import org.dellroad.querystream.jpa.querytype.SearchType;

class ExprStreamImpl> extends SearchStreamImpl implements ExprStream {

// Constructors

    ExprStreamImpl(EntityManager entityManager, SearchType queryType,
      QueryConfigurer, X, ? extends S> configurer, QueryInfo queryInfo) {
        super(entityManager, queryType, configurer, queryInfo);
    }

// Subqueries

    @Override
    public Subquery asSubquery() {
        final CurrentQuery outer = QueryStreamImpl.getCurrentQuery();
        final CriteriaBuilder builder = outer.getBuilder();
        final Subquery subquery = outer.getQuery().subquery(this.queryType.getType());
        final Subquery subquery2 = subquery.select(QueryStreamImpl.withCurrentQuery(builder, subquery,
          () -> this.configurer.configure(builder, subquery)));
        QueryStreamImpl.mergeQueryInfo(this.queryInfo);         // propagage any parameters, etc., up to the outer query
        return subquery2;
    }

// Aggregation

    @Override
    public Predicate exists() {
        return QueryStreamImpl.getCurrentQuery().getBuilder().exists(this.asSubquery());
    }

    @Override
    public LongValue count() {
        QueryStreamImpl.checkOffsetLimit(this, "count()");
        return new LongValueImpl(this.entityManager,
          (builder, query) -> builder.count(this.configurer.configure(builder, query)), this.queryInfo);
    }

    @Override
    public LongValue countDistinct() {
        QueryStreamImpl.checkOffsetLimit(this, "countDistinct()");
        return new LongValueImpl(this.entityManager,
          (builder, query) -> builder.countDistinct(this.configurer.configure(builder, query)), this.queryInfo);
    }

// Narrowing overrides (SearchStreamImpl)

    @Override
    ExprStream create(EntityManager entityManager, SearchType queryType,
      QueryConfigurer, X, ? extends S> configurer, QueryInfo queryInfo) {
        return new ExprStreamImpl<>(entityManager, queryType, configurer, queryInfo);
    }

    @Override
    ExprValue toValue() {
        return this.toValue(false);
    }

    @Override
    ExprValue toValue(boolean forceLimit) {
        return new ExprValueImpl<>(this.entityManager, this.queryType,
          this.configurer, forceLimit ? this.queryInfo.withMaxResults(1) : this.queryInfo);
    }

    @Override
    public ExprStream distinct() {
        return (ExprStream)super.distinct();
    }

    @Override
    public ExprStream orderBy(Ref> ref, boolean asc) {
        return (ExprStream)super.orderBy(ref, asc);
    }

    @Override
    public ExprStream orderBy(SingularAttribute attribute, boolean asc) {
        return (ExprStream)super.orderBy(attribute, asc);
    }

    @Override
    public ExprStream orderBy(SingularAttribute attribute1, boolean asc1,
      SingularAttribute attribute2, boolean asc2) {
        return (ExprStream)super.orderBy(attribute1, asc1, attribute2, asc2);
    }

    @Override
    public ExprStream orderBy(SingularAttribute attribute1, boolean asc1,
      SingularAttribute attribute2, boolean asc2, SingularAttribute attribute3, boolean asc3) {
        return (ExprStream)super.orderBy(attribute1, asc1, attribute2, asc2, attribute3, asc3);
    }

    @Override
    public ExprStream orderBy(Function> orderExprFunction, boolean asc) {
        return (ExprStream)super.orderBy(orderExprFunction, asc);
    }

    @Override
    public ExprStream orderBy(Order... orders) {
        return (ExprStream)super.orderBy(orders);
    }

    @Override
    public ExprStream orderByMulti(Function> orderListFunction) {
        return (ExprStream)super.orderByMulti(orderListFunction);
    }

    @Override
    public ExprStream thenOrderBy(Ref> ref, boolean asc) {
        return (ExprStream)super.thenOrderBy(ref, asc);
    }

    @Override
    public ExprStream thenOrderBy(Order... orders) {
        return (ExprStream)super.thenOrderBy(orders);
    }

    @Override
    public ExprStream thenOrderBy(SingularAttribute attribute, boolean asc) {
        return (ExprStream)super.thenOrderBy(attribute, asc);
    }

    @Override
    public ExprStream thenOrderBy(Function> orderExprFunction, boolean asc) {
        return (ExprStream)super.thenOrderBy(orderExprFunction, asc);
    }

    @Override
    public ExprStream groupBy(Ref> ref) {
        return (ExprStream)super.groupBy(ref);
    }

    @Override
    public ExprStream groupBy(SingularAttribute attribute) {
        return (ExprStream)super.groupBy(attribute);
    }

    @Override
    public ExprStream groupBy(Function> groupFunction) {
        return (ExprStream)super.groupBy(groupFunction);
    }

    @Override
    public ExprStream groupByMulti(Function>> groupFunction) {
        return (ExprStream)super.groupByMulti(groupFunction);
    }

    @Override
    public ExprStream having(Function> havingFunction) {
        return (ExprStream)super.having(havingFunction);
    }

    @Override
    public ExprValue findAny() {
        return (ExprValue)super.findAny();
    }

    @Override
    public ExprValue findFirst() {
        return (ExprValue)super.findFirst();
    }

    @Override
    public ExprValue findSingle() {
        return (ExprValue)super.findSingle();
    }

    @Override
    public  ExprStream addRoot(Ref> ref, Class type) {
        return (ExprStream)super.addRoot(ref, type);
    }

    @Override
    public ExprStream fetch(SingularAttribute attribute) {
        return (ExprStream)super.fetch(attribute);
    }

    @Override
    public ExprStream fetch(SingularAttribute attribute, JoinType joinType) {
        return (ExprStream)super.fetch(attribute, joinType);
    }

    @Override
    public ExprStream fetch(PluralAttribute attribute) {
        return (ExprStream)super.fetch(attribute);
    }

    @Override
    public ExprStream fetch(PluralAttribute attribute, JoinType joinType) {
        return (ExprStream)super.fetch(attribute, joinType);
    }

// Narrowing overrides (QueryStreamImpl)

    @Override
    public ExprStream bind(Ref ref) {
        return (ExprStream)super.bind(ref);
    }

    @Override
    public ExprStream peek(Consumer peeker) {
        return (ExprStream)super.peek(peeker);
    }

    @Override
    public > ExprStream bind(
      Ref ref, Function refFunction) {
        return (ExprStream)super.bind(ref, refFunction);
    }

    @Override
    public ExprStream filter(SingularAttribute attribute) {
        return (ExprStream)super.filter(attribute);
    }

    @Override
    public ExprStream filter(Function> predicateBuilder) {
        return (ExprStream)super.filter(predicateBuilder);
    }

    @Override
    public ExprStream limit(int limit) {
        return (ExprStream)super.limit(limit);
    }

    @Override
    public ExprStream skip(int skip) {
        return (ExprStream)super.skip(skip);
    }

    @Override
    public ExprStream withFlushMode(FlushModeType flushMode) {
        return (ExprStream)super.withFlushMode(flushMode);
    }

    @Override
    public ExprStream withLockMode(LockModeType lockMode) {
        return (ExprStream)super.withLockMode(lockMode);
    }

    @Override
    public ExprStream withHint(String name, Object value) {
        return (ExprStream)super.withHint(name, value);
    }

    @Override
    public ExprStream withHints(Map hints) {
        return (ExprStream)super.withHints(hints);
    }

    @Override
    public  ExprStream withParam(Parameter parameter, T value) {
        return (ExprStream)super.withParam(parameter, value);
    }

    @Override
    public ExprStream withParam(Parameter parameter, Date value, TemporalType temporalType) {
        return (ExprStream)super.withParam(parameter, value, temporalType);
    }

    @Override
    public ExprStream withParam(Parameter parameter, Calendar value, TemporalType temporalType) {
        return (ExprStream)super.withParam(parameter, value, temporalType);
    }

    @Override
    public ExprStream withParams(Set> params) {
        return (ExprStream)super.withParams(params);
    }

    @Override
    public ExprStream withLoadGraph(String name) {
        return (ExprStream)super.withLoadGraph(name);
    }

    @Override
    public ExprStream withFetchGraph(String name) {
        return (ExprStream)super.withFetchGraph(name);
    }
}