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

Go to download

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

package org.dellroad.querystream.jpa;

import java.util.Map;
import java.util.function.BiConsumer;
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.Query;
import javax.persistence.criteria.CriteriaUpdate;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.SingularAttribute;

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

class UpdateStreamImpl
  extends QueryStreamImpl, CriteriaUpdate, CriteriaUpdate, Query, UpdateType>
  implements UpdateStream {

// Constructors

    UpdateStreamImpl(EntityManager entityManager, Class type) {
        this(entityManager, new UpdateType(type));
    }

    // Separate constructor to avoid bogus error ("cannot reference queryType before supertype constructor has been called")
    private UpdateStreamImpl(EntityManager entityManager, UpdateType queryType) {
        super(entityManager, queryType, (builder, query) -> query.from(queryType.getType()), new QueryInfo());
    }

    private UpdateStreamImpl(EntityManager entityManager, UpdateType queryType,
      QueryConfigurer, X, ? extends Root> configurer, QueryInfo queryInfo) {
        super(entityManager, queryType, configurer, queryInfo);
    }

// UpdateStream

    @Override
    public int update() {
        return this.toQuery().executeUpdate();
    }

    @Override
    public  UpdateStream set(Path path, Expression value) {
        if (path == null)
            throw new IllegalArgumentException("null path");
        if (value == null)
            throw new IllegalArgumentException("null value expression");
        QueryStreamImpl.checkOffsetLimit(this, "set()");
        return this.modQuery((query, selection) -> query.set(path, value));
    }

    @Override
    public  UpdateStream set(Path path, V value) {
        if (path == null)
            throw new IllegalArgumentException("null path");
        QueryStreamImpl.checkOffsetLimit(this, "set()");
        return this.modQuery((query, selection) -> query.set(path, value));
    }

    @Override
    public  UpdateStream set(SingularAttribute attribute, Expression value) {
        if (attribute == null)
            throw new IllegalArgumentException("null attribute");
        if (value == null)
            throw new IllegalArgumentException("null value expression");
        QueryStreamImpl.checkOffsetLimit(this, "set()");
        return this.modQuery((query, selection) -> query.set(attribute, value));
    }

    @Override
    public  UpdateStream set(SingularAttribute attribute, V value) {
        if (attribute == null)
            throw new IllegalArgumentException("null attribute");
        QueryStreamImpl.checkOffsetLimit(this, "set()");
        return this.modQuery((query, selection) -> query.set(attribute, value));
    }

    @Override
    public  UpdateStream set(Path path, Function, ? extends Expression> expressionBuilder) {
        if (path == null)
            throw new IllegalArgumentException("null path");
        if (expressionBuilder == null)
            throw new IllegalArgumentException("null expressionBuilder");
        QueryStreamImpl.checkOffsetLimit(this, "set()");
        return this.modQuery((query, selection) -> query.set(path, expressionBuilder.apply(selection)));
    }

    @Override
    public  UpdateStream set(SingularAttribute attribute,
      Function, ? extends Expression> expressionBuilder) {
        if (attribute == null)
            throw new IllegalArgumentException("null attribute");
        if (expressionBuilder == null)
            throw new IllegalArgumentException("null expressionBuilder");
        QueryStreamImpl.checkOffsetLimit(this, "set()");
        return this.modQuery((query, selection) -> query.set(attribute, expressionBuilder.apply(selection)));
    }

// Subclass required methods

    @Override
    UpdateStream create(EntityManager entityManager, UpdateType queryType,
      QueryConfigurer, X, ? extends Root> configurer, QueryInfo queryInfo) {
        return new UpdateStreamImpl<>(entityManager, queryType, configurer, queryInfo);
    }

    @Override
    CriteriaUpdate select(CriteriaUpdate query, Root selection) {
        return query;
    }

// Narrowing overrides (QueryStreamImpl)

    @Override
    public UpdateType getQueryType() {
        return this.queryType;
    }

    @Override
    UpdateStream modQuery(BiConsumer, ? super Root> modifier) {
        return (UpdateStream)super.modQuery(modifier);
    }

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

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

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

    @Override
    public UpdateStream filter(Function, ? extends Expression> predicateBuilder) {
        return (UpdateStream)super.filter(predicateBuilder);
    }

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

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

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

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

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

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

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

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