All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.speedment.runtime.core.internal.stream.builder.streamterminator.StreamTerminatorUtil Maven / Gradle / Ivy

Go to download

A Speedment bundle that shades all dependencies into one jar. This is useful when deploying an application on a server.

The newest version!
/*
 *
 * 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.core.internal.stream.builder.streamterminator;

import com.speedment.runtime.core.component.sql.SqlStreamOptimizerInfo;
import com.speedment.runtime.core.db.AsynchronousQueryResult;
import com.speedment.runtime.core.db.DbmsType;
import com.speedment.runtime.core.db.FieldPredicateView;
import com.speedment.runtime.core.db.SqlPredicateFragment;
import com.speedment.runtime.core.internal.stream.builder.action.reference.FilterAction;
import com.speedment.runtime.core.internal.stream.builder.action.reference.SortedComparatorAction;
import com.speedment.runtime.core.internal.util.Cast;
import com.speedment.runtime.core.stream.Pipeline;
import com.speedment.runtime.core.stream.action.Action;
import com.speedment.runtime.field.Field;
import com.speedment.runtime.field.comparator.CombinedComparator;
import com.speedment.runtime.field.comparator.FieldComparator;
import com.speedment.runtime.field.internal.predicate.AbstractCombinedPredicate;
import com.speedment.runtime.field.predicate.CombinedPredicate;
import com.speedment.runtime.field.predicate.FieldPredicate;
import com.speedment.runtime.field.predicate.PredicateType;
import com.speedment.runtime.typemapper.TypeMapper;
import com.speedment.runtime.typemapper.TypeMapper.Ordering;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.function.Predicate;

import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

/**
 *
 * @author pemi
 */
public final class StreamTerminatorUtil {

    public static  List> topLevelAndPredicates(T initialPipeline) {
        final List> andPredicateBuilders = new ArrayList<>();

        for (final Action action : initialPipeline) {
            @SuppressWarnings("rawtypes")
            final Optional oFilterAction = Cast.cast(action, FilterAction.class);
            if (oFilterAction.isPresent()) {
                @SuppressWarnings("unchecked")
                final List> newAndPredicates = andPredicates(oFilterAction.get());
                andPredicateBuilders.addAll(newAndPredicates);
            } else {
                break; // We can only do initial consecutive FilterAction(s)
            }
        }
        return andPredicateBuilders;
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    public static  List> andPredicates(FilterAction action) {
        requireNonNull(action);
        final List> andPredicateBuilders = new ArrayList<>();
        final Predicate predicate = action.getPredicate();

        final Optional oPredicateBuilder = Cast.cast(predicate, FieldPredicate.class);
        if (oPredicateBuilder.isPresent()) {
            andPredicateBuilders.add(oPredicateBuilder.get()); // Just a top level predicate builder
        } else {

            final Optional oAndCombinedBasePredicate = Cast.cast(predicate, AbstractCombinedPredicate.AndCombinedBasePredicate.class);
            if (oAndCombinedBasePredicate.isPresent()) {

                final AbstractCombinedPredicate.AndCombinedBasePredicate andCombinedBasePredicate = (AbstractCombinedPredicate.AndCombinedBasePredicate) oAndCombinedBasePredicate.get();
                andCombinedBasePredicate.stream()
                    .map(p -> Cast.cast(p, FieldPredicate.class))
                    .filter(p -> p.isPresent())
                    .map(Optional::get)
                    .forEachOrdered(andPredicateBuilders::add);
            }
        }
        return andPredicateBuilders;
    }

    private static final Set NON_COMPARATIVE_PREDICATES
        = EnumSet.complementOf(
            EnumSet.of(
                PredicateType.BETWEEN,
                PredicateType.GREATER_OR_EQUAL,
                PredicateType.GREATER_THAN,
                PredicateType.LESS_OR_EQUAL,
                PredicateType.LESS_THAN,
                PredicateType.NOT_BETWEEN
            )
        );

    public static  boolean isContainingOnlyFieldPredicate(Predicate predicate) {
        if (predicate instanceof FieldPredicate) {
            final FieldPredicate fieldPredicate = (FieldPredicate) predicate;

            // We can only optimize filters if the ordering is retained.. Bar equal, isNull, isNotNull etc.
            return fieldPredicate.getField().typeMapper().getOrdering() == Ordering.RETAIN
                || NON_COMPARATIVE_PREDICATES.contains(fieldPredicate.getPredicateType());
        } else if (predicate instanceof CombinedPredicate) {
            return ((CombinedPredicate) predicate).stream().allMatch(StreamTerminatorUtil::isContainingOnlyFieldPredicate);
        }
        return false;
    }

    public static boolean isSortedActionWithFieldPredicate(Action action) {
        if (action instanceof SortedComparatorAction) {
            final SortedComparatorAction sortedComparatorAction = (SortedComparatorAction) action;
            final Comparator comparator = sortedComparatorAction.getComparator();
            if (comparator instanceof FieldComparator) {
                final FieldComparator fieldComparator = (FieldComparator) comparator;
                // We can only optimize filters if the ordering is retained.. Bar equal, isNull, isNotNull etc.
                return fieldComparator.getField().typeMapper().getOrdering() == Ordering.RETAIN;
            }
            if (comparator instanceof CombinedComparator) {
                final CombinedComparator combinedComparator = (CombinedComparator) comparator;
                // We can only optimize filters if the ordering is retained.. Bar equal, isNull, isNotNull etc.                
                return combinedComparator.stream()
                    .map(FieldComparator::getField)
                    .map(Field::typeMapper)
                    .map(TypeMapper::getOrdering)
                    .allMatch(o -> o == Ordering.RETAIN);
            }
        }
        return false;
    }

    public static  void modifySource(
        final List> predicateBuilders,
        final SqlStreamOptimizerInfo info,
        final AsynchronousQueryResult query
    ) {
        requireNonNull(predicateBuilders);
        requireNonNull(info);
        requireNonNull(query);

        final List> optimizedPredicateBuilders = optimize(predicateBuilders);

        final FieldPredicateView spv = info.getDbmsType().getFieldPredicateView();
        final List fragments = optimizedPredicateBuilders.stream()
            .map(sp -> spv.transform(info.getSqlColumnNamer(), info.getSqlDatabaseTypeFunction(), sp))
            .collect(toList());

        final String sql = info.getSqlSelect() + " WHERE "
            + fragments.stream()
                .map(SqlPredicateFragment::getSql)
                .collect(joining(" AND "));

        final List values = new ArrayList<>(fragments.size());
        for (int i = 0; i < fragments.size(); i++) {

            final FieldPredicate p = optimizedPredicateBuilders.get(i);
            final Field referenceFieldTrait = p.getField();

            @SuppressWarnings("unchecked")
            final TypeMapper tm = (TypeMapper) referenceFieldTrait.typeMapper();

            fragments.get(i).objects()
                .map(tm::toDatabaseType)
                .forEach(values::add);
        }

        query.setSql(sql);
        query.setValues(values);
    }


    private static  List> optimize(List> list) {
        return list.stream()
            .filter(sp -> sp.getPredicateType() != PredicateType.ALWAYS_TRUE) // Fix #495
            .collect(toList());
    }


    public interface RenderResult {

        String getSql();

        List getValues();

        //Pipeline getPipeline();
    }

    private static final class RenderResultImpl implements RenderResult {

        private final String sql;
        private final List values;

        RenderResultImpl(String sql, List values /*, Pipeline pipeline*/) {
            this.sql = sql;
            this.values = values;
        }

        @Override
        public String getSql() {
            return sql;
        }

        @Override
        public List getValues() {
            return values;
        }

        @Override
        public String toString() {
            return String.format("RenderResultImpl {sql=%s, values=%s}", sql, values);
        }
    }

    public static  RenderResult renderSqlWhere(
        final DbmsType dbmsType,
        final Function, String> columnNamer,
        final Function, Class> columnDbTypeFunction,
        final List> predicates
    ) {
        final FieldPredicateView predicateView = dbmsType.getFieldPredicateView();
        final StringBuilder sql = new StringBuilder();
        final List values = new ArrayList<>();
        final AtomicInteger cnt = new AtomicInteger();
        predicates
            .stream()
            // Optimize away ALWAYS_TRUE. Fix #495
            .filter(p -> {
                if (p instanceof FieldPredicate) {
                    return ((FieldPredicate)p).getPredicateType() != PredicateType.ALWAYS_TRUE;
                } else {
                    return true;
                }
            })
            .forEach(predicate -> {
            if (cnt.getAndIncrement() != 0) {
                sql.append(" AND ");
            }
            renderSqlWhereHelper(predicateView, columnNamer, columnDbTypeFunction, sql, values, predicate);
        });
        return new RenderResultImpl(sql.toString(), values);
    }

    // See JoinSqlUtil::renderPredicateHelper for JOIN streams

    private static  void renderSqlWhereHelper(
        final FieldPredicateView spv,
        final Function, String> columnNamer,
        final Function, Class> columnDbTypeFunction,
        final StringBuilder sql,
        final List values,
        final Predicate predicate
    ) {
        if (predicate instanceof FieldPredicate) {
            final FieldPredicate fieldPredicate = (FieldPredicate) predicate;
            final SqlPredicateFragment fragment = spv.transform(columnNamer, columnDbTypeFunction, fieldPredicate);
            final Field referenceFieldTrait = fieldPredicate.getField();
            @SuppressWarnings("unchecked")
            final TypeMapper tm = (TypeMapper) referenceFieldTrait.typeMapper();

            sql.append(fragment.getSql());
            fragment.objects().map(tm::toDatabaseType).forEachOrdered(values::add);
        } else if (predicate instanceof CombinedPredicate) {
            final CombinedPredicate combinedPredicate = (CombinedPredicate) predicate;
            final StringBuilder internalSql = new StringBuilder();
            final List internalValues = new ArrayList<>();
            final AtomicInteger cnt = new AtomicInteger();
            combinedPredicate.stream().forEachOrdered(internalPredicate -> {
                if (cnt.getAndIncrement() != 0) {
                    internalSql.append(" ").append(combinedPredicate.getType().toString()).append(" ");
                }
                @SuppressWarnings("unchecked")
                final Predicate castedInternalPredicate = (Predicate) internalPredicate;
                renderSqlWhereHelper(
                    spv,
                    columnNamer,
                    columnDbTypeFunction,
                    internalSql,
                    internalValues,
                    castedInternalPredicate
                );
            });
            sql.append("(").append(internalSql).append(")");
            values.addAll(internalValues);
        } else {
            throw new IllegalArgumentException("A predicate that is nether an instanceof FieldPredicate nor CombinedPredicate was given:" + predicate.toString());
        }
    }

    private StreamTerminatorUtil() {
        throw new UnsupportedOperationException();
    }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy