com.speedment.runtime.join.internal.component.stream.sql.InitialJoinStream Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of runtime-deploy Show documentation
Show all versions of runtime-deploy Show documentation
A Speedment bundle that shades all dependencies into one jar. This is
useful when deploying an application on a server.
/**
*
* Copyright (c) 2006-2019, Speedment, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); You may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.speedment.runtime.join.internal.component.stream.sql;
import com.speedment.runtime.core.db.AsynchronousQueryResult;
import com.speedment.runtime.core.db.DbmsType;
import com.speedment.runtime.core.stream.AutoClosingStream;
import com.speedment.runtime.core.stream.ComposeRunnableUtil;
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import static com.speedment.common.invariant.LongRangeUtil.requireNonNegative;
import static java.util.Objects.requireNonNull;
final class InitialJoinStream implements Stream/*, Java9StreamAdditions*/ {
private final AsynchronousQueryResult asynchronousQueryResult;
private final SqlInfo sqlInfo;
private final boolean allowStreamIteratorAndSpliterator;
private boolean parallel;
private boolean unordered;
private boolean consumed;
private List closeHandlers;
private long skip;
private long limit;
InitialJoinStream(
final AsynchronousQueryResult asynchronousQueryResult,
final SqlInfo sqlInfo,
final boolean allowStreamIteratorAndSpliterator
) {
this.asynchronousQueryResult = requireNonNull(asynchronousQueryResult);
this.sqlInfo = requireNonNull(sqlInfo);
this.allowStreamIteratorAndSpliterator = allowStreamIteratorAndSpliterator;
this.closeHandlers = new ArrayList<>();
this.skip = 0;
this.limit = Long.MAX_VALUE;
}
/* @Override
public Stream takeWhile(Predicate predicate) {
requireNonNull(predicate)
return materialize().takeWhile(predicate);
}
@Override
public Stream dropWhile(Predicate predicate) {
requireNonNull(predicate);
return materialize().dropWhile(predicate);
}*/
@Override
public Stream filter(Predicate predicate) {
requireNonNull(predicate);
return materialize().filter(predicate);
}
@Override
public Stream map(Function mapper) {
requireNonNull(mapper);
return materialize().map(mapper);
}
@Override
public IntStream mapToInt(ToIntFunction mapper) {
requireNonNull(mapper);
return materialize().mapToInt(mapper);
}
@Override
public LongStream mapToLong(ToLongFunction mapper) {
requireNonNull(mapper);
return materialize().mapToLong(mapper);
}
@Override
public DoubleStream mapToDouble(ToDoubleFunction mapper) {
requireNonNull(mapper);
return materialize().mapToDouble(mapper);
}
@Override
public Stream flatMap(Function> mapper) {
requireNonNull(mapper);
return materialize().flatMap(mapper);
}
@Override
public IntStream flatMapToInt(Function mapper) {
requireNonNull(mapper);
return materialize().flatMapToInt(mapper);
}
@Override
public LongStream flatMapToLong(Function mapper) {
requireNonNull(mapper);
return materialize().flatMapToLong(mapper);
}
@Override
public DoubleStream flatMapToDouble(Function mapper) {
requireNonNull(mapper);
return materialize().flatMapToDouble(mapper);
}
@Override
public Stream distinct() {
return materialize().distinct();
}
// Is this really applicable for a Tuple stream?
@Override
public Stream sorted() {
return materialize().sorted();
}
// Todo: Render ORDER BY if possible
@Override
public Stream sorted(Comparator comparator) {
requireNonNull(comparator);
return materialize().sorted(comparator);
}
@Override
public Stream peek(Consumer action) {
requireNonNull(action);
return materialize().peek(action);
}
@Override
public Stream limit(long maxSize) {
requireNonNegative(maxSize);
limit = Math.min(limit, maxSize);
return this;
}
@Override
public Stream skip(long n) {
requireNonNegative(n);
if (n == 0) {
return this; // Noop
}
skip += n;
return this;
}
@Override
public void forEach(Consumer action) {
requireNonNull(action);
materialize().forEach(action);
}
@Override
public void forEachOrdered(Consumer action) {
requireNonNull(action);
materialize().forEachOrdered(action);
}
@Override
public Object[] toArray() {
return materialize().toArray();
}
@Override
public A[] toArray(IntFunction generator) {
requireNonNull(generator);
return materialize().toArray(generator);
}
@Override
public T reduce(T identity, BinaryOperator accumulator) {
requireNonNull(accumulator);
return materialize().reduce(identity, accumulator);
}
@Override
public Optional reduce(BinaryOperator accumulator) {
requireNonNull(accumulator);
return materialize().reduce(accumulator);
}
@Override
public U reduce(U identity, BiFunction accumulator, BinaryOperator combiner) {
requireNonNull(identity);
requireNonNull(accumulator);
requireNonNull(combiner);
return materialize().reduce(identity, accumulator, combiner);
}
@Override
public R collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner) {
requireNonNull(supplier);
requireNonNull(accumulator);
requireNonNull(combiner);
return materialize().collect(supplier, accumulator, combiner);
}
@Override
public R collect(Collector collector) {
requireNonNull(collector);
return materialize().collect(collector);
}
@Override
public Optional min(Comparator comparator) {
requireNonNull(comparator);
return materialize().min(comparator);
}
@Override
public Optional max(Comparator comparator) {
requireNonNull(comparator);
return materialize().max(comparator);
}
// Todo: Optimize this by doing a select count(*) from (sub select)
@Override
public long count() {
return materialize().count();
}
@Override
public boolean anyMatch(Predicate predicate) {
requireNonNull(predicate);
return materialize().anyMatch(predicate);
}
@Override
public boolean allMatch(Predicate predicate) {
requireNonNull(predicate);
return materialize().allMatch(predicate);
}
@Override
public boolean noneMatch(Predicate predicate) {
requireNonNull(predicate);
return materialize().noneMatch(predicate);
}
// Todo
@Override
public Optional findFirst() {
limit(1); // This will optimize SQL
return materialize().findFirst();
}
// Todo
@Override
public Optional findAny() {
limit(1); // This will optimize SQL
return materialize().findAny();
}
@Override
public Iterator iterator() {
return materialize().iterator();
}
@Override
public Spliterator spliterator() {
return materialize().spliterator();
}
@Override
public boolean isParallel() {
return parallel;
}
@Override
public Stream sequential() {
parallel = false;
return this;
}
@Override
public Stream parallel() {
parallel = true;
return this;
}
@Override
public Stream unordered() {
unordered = true;
return this;
}
@Override
public Stream onClose(Runnable closeHandler) {
requireNonNull(closeHandler);
closeHandlers.add(closeHandler);
return this;
}
@Override
public void close() {
consumed = true;
try {
ComposeRunnableUtil.composedRunnable(closeHandlers);
} finally {
asynchronousQueryResult.close();
}
}
private Stream materialize() {
assertNotConsumed();
consumed = true;
final boolean skipLimitInSql = sqlInfo.dbmsType().getSkipLimitSupport() == DbmsType.SkipLimitSupport.STANDARD;
if (skipLimitInSql) {
// Render SKIP and LIMIT to SQL
@SuppressWarnings("unchecked")
final List