http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java b/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java index 6e1af24..e89c3f0 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java @@ -43,11 +43,11 @@ import org.apache.calcite.tools.Programs; import org.apache.calcite.util.Util; import org.apache.calcite.util.mapping.Mappings; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; -import com.google.common.collect.Lists; +import java.util.ArrayList; import java.util.List; +import java.util.Objects; /** * Records that a particular query is materialized by a particular table. @@ -158,7 +158,7 @@ public class RelOptMaterialization { final RelNode project = RelOptUtil.createProject( LogicalTableScan.create(cluster, leftRelOptTable), Mappings.asList(mapping.inverse())); - final List<RexNode> conditions = Lists.newArrayList(); + final List<RexNode> conditions = new ArrayList<>(); if (left.condition != null) { conditions.add(left.condition); } @@ -182,7 +182,7 @@ public class RelOptMaterialization { final RelNode project = RelOptUtil.createProject( LogicalTableScan.create(cluster, rightRelOptTable), Mappings.asList(mapping.inverse())); - final List<RexNode> conditions = Lists.newArrayList(); + final List<RexNode> conditions = new ArrayList<>(); if (left.condition != null) { conditions.add( RexUtil.apply(mapping, @@ -208,8 +208,8 @@ public class RelOptMaterialization { false, DefaultRelMetadataProvider.INSTANCE); return program.run(null, rel2, null, - ImmutableList.<RelOptMaterialization>of(), - ImmutableList.<RelOptLattice>of()); + ImmutableList.of(), + ImmutableList.of()); } /** A table scan and optional project mapping and filter condition. */ @@ -222,7 +222,7 @@ public class RelOptMaterialization { Mappings.TargetMapping mapping, TableScan scan) { this.condition = condition; this.mapping = mapping; - this.scan = Preconditions.checkNotNull(scan); + this.scan = Objects.requireNonNull(scan); } static ProjectFilterTable of(RelNode node) { @@ -285,8 +285,8 @@ public class RelOptMaterialization { SqlExplainLevel.DIGEST_ATTRIBUTES)); } final RelNode rel2 = program.run(null, rel, null, - ImmutableList.<RelOptMaterialization>of(), - ImmutableList.<RelOptLattice>of()); + ImmutableList.of(), + ImmutableList.of()); if (CalcitePrepareImpl.DEBUG) { System.out.println( RelOptUtil.dumpPlan("after", rel2, SqlExplainFormat.TEXT,
http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java b/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java index 3c0362c..c4553fb 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java @@ -31,12 +31,9 @@ import org.apache.calcite.util.graph.DirectedGraph; import org.apache.calcite.util.graph.Graphs; import org.apache.calcite.util.graph.TopologicalOrderIterator; -import com.google.common.base.Function; -import com.google.common.base.Supplier; import com.google.common.base.Suppliers; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; -import com.google.common.collect.Lists; import com.google.common.collect.Sets; import java.util.ArrayList; @@ -44,6 +41,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.function.Supplier; /** * Utility methods for using @@ -66,9 +64,7 @@ public abstract class RelOptMaterializations { getApplicableMaterializations(rel, materializations); final List<Pair<RelNode, List<RelOptMaterialization>>> applied = new ArrayList<>(); - applied.add( - Pair.<RelNode, List<RelOptMaterialization>>of( - rel, ImmutableList.<RelOptMaterialization>of())); + applied.add(Pair.of(rel, ImmutableList.of())); for (RelOptMaterialization m : applicableMaterializations) { int count = applied.size(); for (int i = 0; i < count; i++) { @@ -102,16 +98,13 @@ public abstract class RelOptMaterializations { final Set<RelOptTable> queryTables = RelOptUtil.findTables(rel); // Use a lattice if the query uses at least the central (fact) table of the // lattice. - final List<Pair<RelNode, RelOptLattice>> latticeUses = Lists.newArrayList(); + final List<Pair<RelNode, RelOptLattice>> latticeUses = new ArrayList<>(); final Set<List<String>> queryTableNames = - Sets.newHashSet(Iterables.transform(queryTables, GET_QUALIFIED_NAME)); + Sets.newHashSet( + Iterables.transform(queryTables, RelOptTable::getQualifiedName)); // Remember leaf-join form of root so we convert at most once. - final Supplier<RelNode> leafJoinRoot = Suppliers.memoize( - new Supplier<RelNode>() { - public RelNode get() { - return RelOptMaterialization.toLeafJoinForm(rel); - } - }); + final Supplier<RelNode> leafJoinRoot = + Suppliers.memoize(() -> RelOptMaterialization.toLeafJoinForm(rel))::get; for (RelOptLattice lattice : lattices) { if (queryTableNames.contains(lattice.rootTable().getQualifiedName())) { RelNode rel2 = lattice.rewrite(leafJoinRoot.get()); @@ -163,7 +156,8 @@ public abstract class RelOptMaterializations { final Graphs.FrozenGraph<List<String>, DefaultEdge> frozenGraph = Graphs.makeImmutable(usesGraph); final Set<RelOptTable> queryTablesUsed = RelOptUtil.findTables(rel); - final List<RelOptMaterialization> applicableMaterializations = Lists.newArrayList(); + final List<RelOptMaterialization> applicableMaterializations = + new ArrayList<>(); for (List<String> qname : TopologicalOrderIterator.of(usesGraph)) { RelOptMaterialization materialization = qnameMap.get(qname); if (materialization != null @@ -174,13 +168,6 @@ public abstract class RelOptMaterializations { return applicableMaterializations; } - private static final Function<RelOptTable, List<String>> GET_QUALIFIED_NAME = - new Function<RelOptTable, List<String>>() { - public List<String> apply(RelOptTable relOptTable) { - return relOptTable.getQualifiedName(); - } - }; - private static List<RelNode> substitute( RelNode root, RelOptMaterialization materialization) { // First, if the materialization is in terms of a star table, rewrite http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java b/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java index d163905..5523cfc 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptPredicateList.java @@ -20,10 +20,11 @@ import org.apache.calcite.rex.RexBuilder; import org.apache.calcite.rex.RexNode; import org.apache.calcite.rex.RexUtil; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import java.util.Objects; + /** * Predicates that are known to hold in the output of a particular relational * expression. @@ -67,7 +68,7 @@ public class RelOptPredicateList { private static final ImmutableList<RexNode> EMPTY_LIST = ImmutableList.of(); public static final RelOptPredicateList EMPTY = new RelOptPredicateList(EMPTY_LIST, EMPTY_LIST, EMPTY_LIST, - ImmutableMap.<RexNode, RexNode>of()); + ImmutableMap.of()); /** Predicates that can be pulled up from the relational expression and its * inputs. */ @@ -89,12 +90,12 @@ public class RelOptPredicateList { ImmutableList<RexNode> leftInferredPredicates, ImmutableList<RexNode> rightInferredPredicates, ImmutableMap<RexNode, RexNode> constantMap) { - this.pulledUpPredicates = Preconditions.checkNotNull(pulledUpPredicates); + this.pulledUpPredicates = Objects.requireNonNull(pulledUpPredicates); this.leftInferredPredicates = - Preconditions.checkNotNull(leftInferredPredicates); + Objects.requireNonNull(leftInferredPredicates); this.rightInferredPredicates = - Preconditions.checkNotNull(rightInferredPredicates); - this.constantMap = Preconditions.checkNotNull(constantMap); + Objects.requireNonNull(rightInferredPredicates); + this.constantMap = Objects.requireNonNull(constantMap); } /** Creates a RelOptPredicateList with only pulled-up predicates, no inferred http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptRule.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRule.java b/core/src/main/java/org/apache/calcite/plan/RelOptRule.java index c5af926..1f23bc2 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptRule.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptRule.java @@ -22,15 +22,13 @@ import org.apache.calcite.rel.convert.ConverterRule; import org.apache.calcite.rel.core.RelFactories; import org.apache.calcite.tools.RelBuilderFactory; -import com.google.common.base.Function; -import com.google.common.base.Preconditions; -import com.google.common.base.Predicate; -import com.google.common.base.Predicates; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; import java.util.ArrayList; import java.util.List; +import java.util.Objects; +import java.util.function.Predicate; /** * A <code>RelOptRule</code> transforms an expression into another. It has a @@ -97,8 +95,8 @@ public abstract class RelOptRule { */ public RelOptRule(RelOptRuleOperand operand, RelBuilderFactory relBuilderFactory, String description) { - this.operand = Preconditions.checkNotNull(operand); - this.relBuilderFactory = Preconditions.checkNotNull(relBuilderFactory); + this.operand = Objects.requireNonNull(operand); + this.relBuilderFactory = Objects.requireNonNull(relBuilderFactory); if (description == null) { description = guessDescription(getClass().getName()); } @@ -126,7 +124,7 @@ public abstract class RelOptRule { public static <R extends RelNode> RelOptRuleOperand operand( Class<R> clazz, RelOptRuleOperandChildren operandList) { - return new RelOptRuleOperand(clazz, null, Predicates.<R>alwaysTrue(), + return new RelOptRuleOperand(clazz, null, r -> true, operandList.policy, operandList.operands); } @@ -145,7 +143,7 @@ public abstract class RelOptRule { Class<R> clazz, RelTrait trait, RelOptRuleOperandChildren operandList) { - return new RelOptRuleOperand(clazz, trait, Predicates.<R>alwaysTrue(), + return new RelOptRuleOperand(clazz, trait, r -> true, operandList.policy, operandList.operands); } @@ -161,7 +159,7 @@ public abstract class RelOptRule { * @return Operand that matches a relational expression that has a * particular trait and predicate */ - public static <R extends RelNode> RelOptRuleOperand operand( + public static <R extends RelNode> RelOptRuleOperand operandJ( Class<R> clazz, RelTrait trait, Predicate<? super R> predicate, @@ -170,6 +168,18 @@ public abstract class RelOptRule { operandList.operands); } + /** @deprecated Use {@link #operandJ} */ + @SuppressWarnings("Guava") + @Deprecated // to be removed before 2.0 + public static <R extends RelNode> RelOptRuleOperand operand( + Class<R> clazz, + RelTrait trait, + com.google.common.base.Predicate<? super R> predicate, + RelOptRuleOperandChildren operandList) { + return operandJ(clazz, trait, (Predicate<? super R>) predicate::apply, + operandList); + } + /** * Creates an operand that matches a relational expression that has no * children. @@ -182,13 +192,25 @@ public abstract class RelOptRule { * @param <R> Class of relational expression to match * @return Operand */ - public static <R extends RelNode> RelOptRuleOperand operand( + public static <R extends RelNode> RelOptRuleOperand operandJ( Class<R> clazz, RelTrait trait, Predicate<? super R> predicate, RelOptRuleOperand first, RelOptRuleOperand... rest) { - return operand(clazz, trait, predicate, some(first, rest)); + return operandJ(clazz, trait, predicate, some(first, rest)); + } + + @SuppressWarnings("Guava") + @Deprecated // to be removed before 2.0 + public static <R extends RelNode> RelOptRuleOperand operand( + Class<R> clazz, + RelTrait trait, + com.google.common.base.Predicate<? super R> predicate, + RelOptRuleOperand first, + RelOptRuleOperand... rest) { + return operandJ(clazz, trait, (Predicate<? super R>) predicate::apply, + first, rest); } /** @@ -230,6 +252,16 @@ public abstract class RelOptRule { return new ConverterRelOptRuleOperand(clazz, trait, predicate); } + /** @deprecated Use {@link #convertOperand(Class, Predicate, RelTrait)}. */ + @SuppressWarnings("Guava") + @Deprecated // to be removed before 2.0 + protected static <R extends RelNode> ConverterRelOptRuleOperand + convertOperand(Class<R> clazz, + com.google.common.base.Predicate<? super R> predicate, + RelTrait trait) { + return new ConverterRelOptRuleOperand(clazz, trait, predicate::apply); + } + //~ Methods for creating lists of child operands --------------------------- /** @@ -572,11 +604,7 @@ public abstract class RelOptRule { protected static List<RelNode> convertList(List<RelNode> rels, final RelTrait trait) { return Lists.transform(rels, - new Function<RelNode, RelNode>() { - public RelNode apply(RelNode rel) { - return convert(rel, rel.getTraitSet().replace(trait)); - } - }); + rel -> convert(rel, rel.getTraitSet().replace(trait))); } /** @@ -619,7 +647,7 @@ public abstract class RelOptRule { <R extends RelNode> ConverterRelOptRuleOperand(Class<R> clazz, RelTrait in, Predicate<? super R> predicate) { super(clazz, in, predicate, RelOptRuleOperandChildPolicy.ANY, - ImmutableList.<RelOptRuleOperand>of()); + ImmutableList.of()); } public boolean matches(RelNode rel) { http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java index d753b66..2654b54 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java @@ -231,7 +231,7 @@ public abstract class RelOptRuleCall { * expression of the rule call, {@code call.rels(0)} */ public final void transformTo(RelNode rel) { - transformTo(rel, ImmutableMap.<RelNode, RelNode>of()); + transformTo(rel, ImmutableMap.of()); } /** Creates a {@link org.apache.calcite.tools.RelBuilder} to be used by http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java index d3c5f2f..7506010 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperand.java @@ -18,12 +18,11 @@ package org.apache.calcite.plan; import org.apache.calcite.rel.RelNode; -import com.google.common.base.Preconditions; -import com.google.common.base.Predicate; import com.google.common.collect.ImmutableList; import java.util.List; import java.util.Objects; +import java.util.function.Predicate; /** * Operand that determines whether a {@link RelOptRule} @@ -118,10 +117,10 @@ public class RelOptRuleOperand { assert children.size() > 0; } this.childPolicy = childPolicy; - this.clazz = Preconditions.checkNotNull(clazz); + this.clazz = Objects.requireNonNull(clazz); this.trait = trait; //noinspection unchecked - this.predicate = Preconditions.checkNotNull((Predicate) predicate); + this.predicate = Objects.requireNonNull((Predicate) predicate); this.children = children; for (RelOptRuleOperand child : this.children) { assert child.parent == null : "cannot re-use operands"; @@ -212,7 +211,7 @@ public class RelOptRuleOperand { if ((trait != null) && !rel.getTraitSet().contains(trait)) { return false; } - return predicate.apply(rel); + return predicate.test(rel); } } http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java index 9d7dc18..3dfab3e 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleOperandChildren.java @@ -34,12 +34,12 @@ public class RelOptRuleOperandChildren { static final RelOptRuleOperandChildren ANY_CHILDREN = new RelOptRuleOperandChildren( RelOptRuleOperandChildPolicy.ANY, - ImmutableList.<RelOptRuleOperand>of()); + ImmutableList.of()); static final RelOptRuleOperandChildren LEAF_CHILDREN = new RelOptRuleOperandChildren( RelOptRuleOperandChildPolicy.LEAF, - ImmutableList.<RelOptRuleOperand>of()); + ImmutableList.of()); final RelOptRuleOperandChildPolicy policy; final ImmutableList<RelOptRuleOperand> operands; http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java index b4d666b..38912ca 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java +++ b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java @@ -80,7 +80,6 @@ import org.apache.calcite.rex.RexToSqlNodeConverterImpl; import org.apache.calcite.rex.RexUtil; import org.apache.calcite.rex.RexVisitorImpl; import org.apache.calcite.runtime.CalciteContextException; -import org.apache.calcite.runtime.PredicateImpl; import org.apache.calcite.schema.ModifiableView; import org.apache.calcite.sql.SqlExplainFormat; import org.apache.calcite.sql.SqlExplainLevel; @@ -102,14 +101,10 @@ import org.apache.calcite.util.mapping.Mapping; import org.apache.calcite.util.mapping.MappingType; import org.apache.calcite.util.mapping.Mappings; -import com.google.common.base.Function; -import com.google.common.base.Predicate; -import com.google.common.base.Supplier; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; import com.google.common.collect.LinkedHashMultimap; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; import com.google.common.collect.Multimap; import java.io.PrintWriter; @@ -118,6 +113,7 @@ import java.util.AbstractList; import java.util.ArrayList; import java.util.BitSet; import java.util.Collection; +import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; @@ -126,6 +122,7 @@ import java.util.Map.Entry; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; +import java.util.function.Supplier; /** * <code>RelOptUtil</code> defines static utility methods for use in optimizing @@ -134,49 +131,26 @@ import java.util.TreeSet; public abstract class RelOptUtil { //~ Static fields/initializers --------------------------------------------- - public static final double EPSILON = 1.0e-5; - - /** Predicate for whether a filter contains multisets or windowed - * aggregates. */ - public static final Predicate<Filter> FILTER_PREDICATE = - new PredicateImpl<Filter>() { - public boolean test(Filter filter) { - return !(B - && RexMultisetUtil.containsMultiset(filter.getCondition(), true) - || RexOver.containsOver(filter.getCondition())); - } - }; + static final boolean B = false; - /** Predicate for whether a project contains multisets or windowed - * aggregates. */ - public static final Predicate<Project> PROJECT_PREDICATE = - new PredicateImpl<Project>() { - public boolean test(Project project) { - return !(B - && RexMultisetUtil.containsMultiset(project.getProjects(), true) - || RexOver.containsOver(project.getProjects(), null)); - } - }; + public static final double EPSILON = 1.0e-5; - /** Predicate for whether a calc contains multisets or windowed - * aggregates. */ - public static final Predicate<Calc> CALC_PREDICATE = - new PredicateImpl<Calc>() { - public boolean test(Calc calc) { - return !(B - && RexMultisetUtil.containsMultiset(calc.getProgram()) - || calc.getProgram().containsAggs()); - } - }; + @SuppressWarnings("Guava") + @Deprecated // to be removed before 2.0 + public static final com.google.common.base.Predicate<Filter> + FILTER_PREDICATE = + RelOptUtil::containsMultisetOrWindowedAgg; - static final boolean B = false; + @SuppressWarnings("Guava") + @Deprecated // to be removed before 2.0 + public static final com.google.common.base.Predicate<Project> + PROJECT_PREDICATE = + RelOptUtil::containsMultisetOrWindowedAgg; - private static final Function<RelDataTypeField, RelDataType> GET_TYPE = - new Function<RelDataTypeField, RelDataType>() { - public RelDataType apply(RelDataTypeField field) { - return field.getType(); - } - }; + @SuppressWarnings("Guava") + @Deprecated // to be removed before 2.0 + public static final com.google.common.base.Predicate<Calc> CALC_PREDICATE = + RelOptUtil::containsMultisetOrWindowedAgg; //~ Methods ---------------------------------------------------------------- @@ -244,11 +218,7 @@ public abstract class RelOptUtil { */ public static List<String> findAllTableQualifiedNames(RelNode rel) { return Lists.transform(findAllTables(rel), - new Function<RelOptTable, String>() { - @Override public String apply(RelOptTable arg0) { - return arg0.getQualifiedName().toString(); - } - }); + table -> table.getQualifiedName().toString()); } /** @@ -347,7 +317,7 @@ public abstract class RelOptUtil { * @see org.apache.calcite.rel.type.RelDataType#getFieldNames() */ public static List<RelDataType> getFieldTypeList(final RelDataType type) { - return Lists.transform(type.getFieldList(), GET_TYPE); + return Lists.transform(type.getFieldList(), RelDataTypeField::getType); } public static boolean areRowTypesEqual( @@ -574,7 +544,7 @@ public abstract class RelOptUtil { if (!outerJoin) { final LogicalAggregate aggregate = LogicalAggregate.create(ret, ImmutableBitSet.range(keyCount), null, - ImmutableList.<AggregateCall>of()); + ImmutableList.of()); return new Exists(aggregate, false, false); } @@ -635,7 +605,7 @@ public abstract class RelOptUtil { assert inputField.getType().equals(outputField.getType()); final RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); renames.add( - Pair.<RexNode, String>of( + Pair.of( rexBuilder.makeInputRef(inputField.getType(), inputField.getIndex()), outputField.getName())); @@ -814,7 +784,7 @@ public abstract class RelOptUtil { public static RelNode createDistinctRel(RelNode rel) { return LogicalAggregate.create(rel, ImmutableBitSet.range(rel.getRowType().getFieldCount()), null, - ImmutableList.<AggregateCall>of()); + ImmutableList.of()); } @Deprecated // to be removed before 2.0 @@ -1720,7 +1690,7 @@ public abstract class RelOptUtil { for (int fieldIndex : outputProj) { final RelDataTypeField field = joinOutputFields.get(fieldIndex); newProjects.add( - Pair.<RexNode, String>of( + Pair.of( rexBuilder.makeInputRef(field.getType(), fieldIndex), field.getName())); } @@ -2287,7 +2257,7 @@ public abstract class RelOptUtil { final RexBuilder rexBuilder = new RexBuilder(typeFactory); final RexNode constraint = modifiableViewTable.getConstraint(rexBuilder, targetRowType); - final Map<Integer, RexNode> projectMap = Maps.newHashMap(); + final Map<Integer, RexNode> projectMap = new HashMap<>(); final List<RexNode> filters = new ArrayList<>(); RelOptUtil.inferViewPredicates(projectMap, filters, constraint); assert filters.isEmpty(); @@ -2430,7 +2400,7 @@ public abstract class RelOptUtil { ImmutableBitSet rightBitmap = ImmutableBitSet.range(nSysFields + nFieldsLeft, nTotalFields); - final List<RexNode> filtersToRemove = Lists.newArrayList(); + final List<RexNode> filtersToRemove = new ArrayList<>(); for (RexNode filter : filters) { final InputFinder inputFinder = InputFinder.analyze(filter); final ImmutableBitSet inputBits = inputFinder.inputBitSet.build(); @@ -2691,7 +2661,7 @@ public abstract class RelOptUtil { // create new copies of the bitmaps List<RelNode> multiJoinInputs = multiJoin.getInputs(); - List<BitSet> newProjFields = Lists.newArrayList(); + List<BitSet> newProjFields = new ArrayList<>(); for (RelNode multiJoinInput : multiJoinInputs) { newProjFields.add( new BitSet(multiJoinInput.getRowType().getFieldCount())); @@ -2722,7 +2692,7 @@ public abstract class RelOptUtil { multiJoin.isFullOuterJoin(), multiJoin.getOuterJoinConditions(), multiJoin.getJoinTypes(), - Lists.transform(newProjFields, ImmutableBitSet.FROM_BIT_SET), + Lists.transform(newProjFields, ImmutableBitSet::fromBitSet), multiJoin.getJoinFieldRefCountsMap(), multiJoin.getPostJoinFilter()); } @@ -3093,8 +3063,8 @@ public abstract class RelOptUtil { if (mapping.isIdentity()) { return rel; } - final List<String> outputNameList = Lists.newArrayList(); - final List<RexNode> exprList = Lists.newArrayList(); + final List<String> outputNameList = new ArrayList<>(); + final List<RexNode> exprList = new ArrayList<>(); final List<RelDataTypeField> fields = rel.getRowType().getFieldList(); final RexBuilder rexBuilder = rel.getCluster().getRexBuilder(); for (int i = 0; i < mapping.getTargetCount(); i++) { @@ -3110,6 +3080,30 @@ public abstract class RelOptUtil { return projectFactory.createProject(rel, exprList, outputNameList); } + /** Predicate for whether a {@link Calc} contains multisets or windowed + * aggregates. */ + public static boolean containsMultisetOrWindowedAgg(Calc calc) { + return !(B + && RexMultisetUtil.containsMultiset(calc.getProgram()) + || calc.getProgram().containsAggs()); + } + + /** Predicate for whether a {@link Filter} contains multisets or windowed + * aggregates. */ + public static boolean containsMultisetOrWindowedAgg(Filter filter) { + return !(B + && RexMultisetUtil.containsMultiset(filter.getCondition(), true) + || RexOver.containsOver(filter.getCondition())); + } + + /** Predicate for whether a {@link Project} contains multisets or windowed + * aggregates. */ + public static boolean containsMultisetOrWindowedAgg(Project project) { + return !(B + && RexMultisetUtil.containsMultiset(project.getProjects(), true) + || RexOver.containsOver(project.getProjects(), null)); + } + /** Policies for handling two- and three-valued boolean logic. */ public enum Logic { /** Three-valued boolean logic. */ @@ -3221,7 +3215,7 @@ public abstract class RelOptUtil { public Pair<RexNode, String> get(int index) { if (index < leftCount) { RelDataTypeField field = fields.get(index); - return Pair.<RexNode, String>of( + return Pair.of( new RexInputRef(index, field.getType()), field.getName()); } else { return Pair.of(extraLeftExprs.get(index - leftCount), null); @@ -3245,7 +3239,7 @@ public abstract class RelOptUtil { public Pair<RexNode, String> get(int index) { if (index < rightCount) { RelDataTypeField field = fields.get(index); - return Pair.<RexNode, String>of( + return Pair.of( new RexInputRef(index, field.getType()), field.getName()); } else { http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java b/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java index 809dd21..1f0bdf8 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java +++ b/core/src/main/java/org/apache/calcite/plan/RelTraitDef.java @@ -59,12 +59,7 @@ public abstract class RelTraitDef<T extends RelTrait> { private final LoadingCache<T, T> canonicalMap = CacheBuilder.newBuilder() .softValues() - .build( - new CacheLoader<T, T>() { - @Override public T load(@Nonnull T key) throws Exception { - return key; - } - }); + .build(CacheLoader.from(key -> key)); /** Cache of composite traits. * http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java b/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java index 5499bdb..717ef07 100644 --- a/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java +++ b/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java @@ -19,7 +19,6 @@ package org.apache.calcite.plan; import org.apache.calcite.runtime.FlatLists; import org.apache.calcite.util.Pair; -import com.google.common.base.Supplier; import com.google.common.collect.ImmutableList; import java.util.AbstractList; @@ -27,6 +26,7 @@ import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.function.Supplier; /** * RelTraitSet represents an ordered set of {@link RelTrait}s. @@ -551,7 +551,7 @@ public final class RelTraitSet extends AbstractList<RelTrait> { return traitSet1; } final RelTraitSet traitSet = - new RelTraitSet(this, traits.toArray(new RelTrait[traits.size()])); + new RelTraitSet(this, traits.toArray(new RelTrait[0])); map.put(traits, traitSet); return traitSet; } http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/RexImplicationChecker.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/RexImplicationChecker.java b/core/src/main/java/org/apache/calcite/plan/RexImplicationChecker.java index f7cd9e1..f2b32f2 100644 --- a/core/src/main/java/org/apache/calcite/plan/RexImplicationChecker.java +++ b/core/src/main/java/org/apache/calcite/plan/RexImplicationChecker.java @@ -32,7 +32,6 @@ import org.apache.calcite.sql.fun.SqlCastFunction; import org.apache.calcite.util.Pair; import org.apache.calcite.util.trace.CalciteLogger; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; @@ -43,6 +42,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; /** @@ -70,9 +70,9 @@ public class RexImplicationChecker { RexBuilder builder, RexExecutorImpl executor, RelDataType rowType) { - this.builder = Preconditions.checkNotNull(builder); - this.executor = Preconditions.checkNotNull(executor); - this.rowType = Preconditions.checkNotNull(rowType); + this.builder = Objects.requireNonNull(builder); + this.executor = Objects.requireNonNull(executor); + this.rowType = Objects.requireNonNull(rowType); } /** @@ -196,8 +196,8 @@ public class RexImplicationChecker { final InputUsageFinder firstUsageFinder = new InputUsageFinder(); final InputUsageFinder secondUsageFinder = new InputUsageFinder(); - RexUtil.apply(firstUsageFinder, ImmutableList.<RexNode>of(), first); - RexUtil.apply(secondUsageFinder, ImmutableList.<RexNode>of(), second); + RexUtil.apply(firstUsageFinder, ImmutableList.of(), first); + RexUtil.apply(secondUsageFinder, ImmutableList.of(), second); // Check Support if (!checkSupport(firstUsageFinder, secondUsageFinder)) { http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/Strong.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/Strong.java b/core/src/main/java/org/apache/calcite/plan/Strong.java index e631d90..39a4515 100644 --- a/core/src/main/java/org/apache/calcite/plan/Strong.java +++ b/core/src/main/java/org/apache/calcite/plan/Strong.java @@ -24,7 +24,6 @@ import org.apache.calcite.rex.RexUtil; import org.apache.calcite.sql.SqlKind; import org.apache.calcite.util.ImmutableBitSet; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -32,6 +31,7 @@ import java.util.ArrayList; import java.util.EnumMap; import java.util.List; import java.util.Map; +import java.util.Objects; /** Utilities for strong predicates. * @@ -87,7 +87,7 @@ public class Strong { /** Returns how to deduce whether a particular kind of expression is null, * given whether its arguments are null. */ public static Policy policy(SqlKind kind) { - return Preconditions.checkNotNull(MAP.get(kind), kind); + return Objects.requireNonNull(MAP.get(kind), kind.toString()); } /** Returns whether an expression is definitely not true. */ http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java b/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java index 0625bff..c8f92c7 100644 --- a/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java +++ b/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java @@ -44,7 +44,6 @@ import org.apache.calcite.rex.RexNode; import org.apache.calcite.rex.RexShuttle; import org.apache.calcite.rex.RexSimplify; import org.apache.calcite.rex.RexUtil; -import org.apache.calcite.runtime.PredicateImpl; import org.apache.calcite.sql.SqlAggFunction; import org.apache.calcite.sql.fun.SqlStdOperatorTable; import org.apache.calcite.tools.RelBuilder; @@ -60,13 +59,9 @@ import org.apache.calcite.util.mapping.Mappings; import org.apache.calcite.util.trace.CalciteTrace; import com.google.common.annotations.VisibleForTesting; -import com.google.common.base.Function; -import com.google.common.base.Preconditions; -import com.google.common.base.Predicate; import com.google.common.collect.ImmutableList; import com.google.common.collect.LinkedHashMultimap; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; import com.google.common.collect.Multimap; import com.google.common.collect.Sets; @@ -78,6 +73,7 @@ import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.SortedMap; import java.util.TreeMap; @@ -122,7 +118,7 @@ public class SubstitutionVisitor { private static final Logger LOGGER = CalciteTrace.getPlannerTracer(); protected static final ImmutableList<UnifyRule> DEFAULT_RULES = - ImmutableList.<UnifyRule>of( + ImmutableList.of( TrivialRule.INSTANCE, ScanToProjectUnifyRule.INSTANCE, ProjectToProjectUnifyRule.INSTANCE, @@ -472,7 +468,7 @@ public class SubstitutionVisitor { if (matches.isEmpty()) { return ImmutableList.of(); } - List<RelNode> sub = Lists.newArrayList(); + List<RelNode> sub = new ArrayList<>(); sub.add(MutableRels.fromMutable(query.getInput(), relBuilder)); reverseSubstitute(relBuilder, query, matches, sub, 0, matches.size()); return sub; @@ -493,7 +489,7 @@ public class SubstitutionVisitor { // Populate "equivalents" with (q, t) for each query descendant q and // target descendant t that are equal. - final Map<MutableRel, MutableRel> map = Maps.newHashMap(); + final Map<MutableRel, MutableRel> map = new HashMap<>(); for (MutableRel queryDescendant : queryDescendants) { map.put(queryDescendant, queryDescendant); } @@ -506,8 +502,8 @@ public class SubstitutionVisitor { } map.clear(); - final List<Replacement> attempted = Lists.newArrayList(); - List<List<Replacement>> substitutions = Lists.newArrayList(); + final List<Replacement> attempted = new ArrayList<>(); + List<List<Replacement>> substitutions = new ArrayList<>(); for (;;) { int count = 0; @@ -863,10 +859,10 @@ public class SubstitutionVisitor { public UnifyRuleCall(UnifyRule rule, MutableRel query, MutableRel target, ImmutableList<MutableRel> slots) { - this.rule = Preconditions.checkNotNull(rule); - this.query = Preconditions.checkNotNull(query); - this.target = Preconditions.checkNotNull(target); - this.slots = Preconditions.checkNotNull(slots); + this.rule = Objects.requireNonNull(rule); + this.query = Objects.requireNonNull(query); + this.target = Objects.requireNonNull(target); + this.slots = Objects.requireNonNull(slots); } public UnifyResult result(MutableRel result) { @@ -1257,12 +1253,8 @@ public class SubstitutionVisitor { private static List<AggregateCall> apply(final Mapping mapping, List<AggregateCall> aggCallList) { return Lists.transform(aggCallList, - new Function<AggregateCall, AggregateCall>() { - public AggregateCall apply(AggregateCall call) { - return call.copy(Mappings.apply2(mapping, call.getArgList()), - Mappings.apply(mapping, call.filterArg)); - } - }); + call -> call.copy(Mappings.apply2(mapping, call.getArgList()), + Mappings.apply(mapping, call.filterArg))); } public static MutableRel unifyAggregates(MutableAggregate query, @@ -1274,7 +1266,7 @@ public class SubstitutionVisitor { MutableRel result; if (query.groupSet.equals(target.groupSet)) { // Same level of aggregation. Generate a project. - final List<Integer> projects = Lists.newArrayList(); + final List<Integer> projects = new ArrayList<>(); final int groupCount = query.groupSet.cardinality(); for (int i = 0; i < groupCount; i++) { projects.add(i); @@ -1298,7 +1290,7 @@ public class SubstitutionVisitor { } groupSet.set(c2); } - final List<AggregateCall> aggregateCalls = Lists.newArrayList(); + final List<AggregateCall> aggregateCalls = new ArrayList<>(); for (AggregateCall aggregateCall : query.aggCalls) { if (aggregateCall.isDistinct()) { return null; @@ -1582,13 +1574,6 @@ public class SubstitutionVisitor { * trivial filter (on a boolean column). */ public static class FilterOnProjectRule extends RelOptRule { - private static final Predicate<LogicalFilter> PREDICATE = - new PredicateImpl<LogicalFilter>() { - public boolean test(LogicalFilter input) { - return input.getCondition() instanceof RexInputRef; - } - }; - public static final FilterOnProjectRule INSTANCE = new FilterOnProjectRule(RelFactories.LOGICAL_BUILDER); @@ -1599,7 +1584,8 @@ public class SubstitutionVisitor { */ public FilterOnProjectRule(RelBuilderFactory relBuilderFactory) { super( - operand(LogicalFilter.class, null, PREDICATE, + operandJ(LogicalFilter.class, null, + filter -> filter.getCondition() instanceof RexInputRef, some(operand(LogicalProject.class, any()))), relBuilderFactory, null); } http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/hep/HepPlanner.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/hep/HepPlanner.java b/core/src/main/java/org/apache/calcite/plan/hep/HepPlanner.java index c022d8b..3f7f73e 100644 --- a/core/src/main/java/org/apache/calcite/plan/hep/HepPlanner.java +++ b/core/src/main/java/org/apache/calcite/plan/hep/HepPlanner.java @@ -133,7 +133,7 @@ public class HepPlanner extends AbstractRelOptPlanner { super(costFactory, context); this.mainProgram = program; this.onCopyHook = - Util.first(onCopyHook, Functions.<RelNode, RelNode, Void>ignore2()); + Util.first(onCopyHook, Functions.ignore2()); mapDigestToVertex = new HashMap<>(); graph = DefaultDirectedGraph.create(); @@ -544,7 +544,7 @@ public class HepPlanner extends AbstractRelOptPlanner { new HepRuleCall( this, rule.getOperand(), - bindings.toArray(new RelNode[bindings.size()]), + bindings.toArray(new RelNode[0]), nodeChildren, parents); http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/hep/HepRelMetadataProvider.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/hep/HepRelMetadataProvider.java b/core/src/main/java/org/apache/calcite/plan/hep/HepRelMetadataProvider.java index 48681eb..103018b 100644 --- a/core/src/main/java/org/apache/calcite/plan/hep/HepRelMetadataProvider.java +++ b/core/src/main/java/org/apache/calcite/plan/hep/HepRelMetadataProvider.java @@ -21,7 +21,6 @@ import org.apache.calcite.rel.metadata.Metadata; import org.apache.calcite.rel.metadata.MetadataDef; import org.apache.calcite.rel.metadata.MetadataHandler; import org.apache.calcite.rel.metadata.RelMetadataProvider; -import org.apache.calcite.rel.metadata.RelMetadataQuery; import org.apache.calcite.rel.metadata.UnboundMetadata; import com.google.common.collect.ImmutableMultimap; @@ -47,18 +46,16 @@ class HepRelMetadataProvider implements RelMetadataProvider { public <M extends Metadata> UnboundMetadata<M> apply( Class<? extends RelNode> relClass, final Class<? extends M> metadataClass) { - return new UnboundMetadata<M>() { - public M bind(RelNode rel, RelMetadataQuery mq) { - if (!(rel instanceof HepRelVertex)) { - return null; - } - HepRelVertex vertex = (HepRelVertex) rel; - final RelNode rel2 = vertex.getCurrentRel(); - UnboundMetadata<M> function = - rel.getCluster().getMetadataProvider().apply(rel2.getClass(), - metadataClass); - return function.bind(rel2, mq); + return (rel, mq) -> { + if (!(rel instanceof HepRelVertex)) { + return null; } + HepRelVertex vertex = (HepRelVertex) rel; + final RelNode rel2 = vertex.getCurrentRel(); + UnboundMetadata<M> function = + rel.getCluster().getMetadataProvider().apply(rel2.getClass(), + metadataClass); + return function.bind(rel2, mq); }; } http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java b/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java index 60f4a07..8352ffe 100644 --- a/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java +++ b/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java @@ -17,7 +17,6 @@ package org.apache.calcite.plan.volcano; import org.apache.calcite.linq4j.Linq4j; -import org.apache.calcite.linq4j.function.Predicate1; import org.apache.calcite.plan.RelOptCluster; import org.apache.calcite.plan.RelOptCost; import org.apache.calcite.plan.RelOptListener; @@ -41,7 +40,6 @@ import java.io.PrintWriter; import java.io.StringWriter; import java.util.ArrayList; import java.util.Collection; -import java.util.Iterator; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; @@ -387,18 +385,9 @@ public class RelSubset extends AbstractRelNode { * @return all the rels in the subset */ public Iterable<RelNode> getRels() { - return new Iterable<RelNode>() { - public Iterator<RelNode> iterator() { - return Linq4j.asEnumerable(set.rels) - .where( - new Predicate1<RelNode>() { - public boolean apply(RelNode v1) { - return v1.getTraitSet().satisfies(traitSet); - } - }) - .iterator(); - } - }; + return () -> Linq4j.asEnumerable(set.rels) + .where(v1 -> v1.getTraitSet().satisfies(traitSet)) + .iterator(); } /** http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/volcano/RuleQueue.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/RuleQueue.java b/core/src/main/java/org/apache/calcite/plan/volcano/RuleQueue.java index 1e2713f..10b9553 100644 --- a/core/src/main/java/org/apache/calcite/plan/volcano/RuleQueue.java +++ b/core/src/main/java/org/apache/calcite/plan/volcano/RuleQueue.java @@ -37,7 +37,6 @@ import java.io.StringWriter; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.Comparator; import java.util.Deque; import java.util.EnumMap; @@ -235,32 +234,30 @@ class RuleQueue { } } - Collections.sort( - boostRemovals, - new Comparator<RelSubset>() { - public int compare(RelSubset o1, RelSubset o2) { - int o1children = countChildren(o1); - int o2children = countChildren(o2); - int c = compare(o1children, o2children); - if (c == 0) { - // for determinism - c = compare(o1.getId(), o2.getId()); - } - return c; - } + boostRemovals.sort(new Comparator<RelSubset>() { + public int compare(RelSubset o1, RelSubset o2) { + int o1children = countChildren(o1); + int o2children = countChildren(o2); + int c = compare(o1children, o2children); + if (c == 0) { + // for determinism + c = compare(o1.getId(), o2.getId()); + } + return c; + } - private int compare(int i1, int i2) { - return (i1 < i2) ? -1 : ((i1 == i2) ? 0 : 1); - } + private int compare(int i1, int i2) { + return (i1 < i2) ? -1 : ((i1 == i2) ? 0 : 1); + } - private int countChildren(RelSubset subset) { - int count = 0; - for (RelNode rel : subset.getRels()) { - count += rel.getInputs().size(); - } - return count; - } - }); + private int countChildren(RelSubset subset) { + int count = 0; + for (RelNode rel : subset.getRels()) { + count += rel.getInputs().size(); + } + return count; + } + }); for (RelSubset subset : boostRemovals) { subset.propagateBoostRemoval(planner); @@ -452,7 +449,7 @@ class RuleQueue { return null; } if (LOGGER.isTraceEnabled()) { - Collections.sort(matchList, MATCH_COMPARATOR); + matchList.sort(MATCH_COMPARATOR); match = matchList.remove(0); StringBuilder b = new StringBuilder(); http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java index 281e472..231de4d 100644 --- a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java +++ b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java @@ -69,12 +69,9 @@ import org.apache.calcite.util.Util; import com.google.common.collect.ImmutableList; import com.google.common.collect.LinkedHashMultimap; import com.google.common.collect.LinkedListMultimap; -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; import com.google.common.collect.Multimap; import com.google.common.collect.Ordering; import com.google.common.collect.SetMultimap; -import com.google.common.collect.Sets; import java.io.PrintWriter; import java.io.StringWriter; @@ -82,12 +79,12 @@ import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; -import java.util.Comparator; import java.util.Deque; import java.util.HashMap; import java.util.HashSet; import java.util.IdentityHashMap; import java.util.Iterator; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; @@ -230,11 +227,13 @@ public class VolcanoPlanner extends AbstractRelOptPlanner { private boolean locked; private final List<RelOptMaterialization> materializations = - Lists.newArrayList(); + new ArrayList<>(); - /** Map of lattices by the qualified name of their star table. */ + /** + * Map of lattices by the qualified name of their star table. + */ private final Map<List<String>, RelOptLattice> latticeByName = - Maps.newLinkedHashMap(); + new LinkedHashMap<>(); final Map<RelNode, Provenance> provenanceMap = new HashMap<>(); @@ -283,14 +282,11 @@ public class VolcanoPlanner extends AbstractRelOptPlanner { protected VolcanoPlannerPhaseRuleMappingInitializer getPhaseRuleMappingInitializer() { - return new VolcanoPlannerPhaseRuleMappingInitializer() { - public void initialize( - Map<VolcanoPlannerPhase, Set<String>> phaseRuleMap) { - // Disable all phases except OPTIMIZE by adding one useless rule name. - phaseRuleMap.get(VolcanoPlannerPhase.PRE_PROCESS_MDR).add("xxx"); - phaseRuleMap.get(VolcanoPlannerPhase.PRE_PROCESS).add("xxx"); - phaseRuleMap.get(VolcanoPlannerPhase.CLEANUP).add("xxx"); - } + return phaseRuleMap -> { + // Disable all phases except OPTIMIZE by adding one useless rule name. + phaseRuleMap.get(VolcanoPlannerPhase.PRE_PROCESS_MDR).add("xxx"); + phaseRuleMap.get(VolcanoPlannerPhase.PRE_PROCESS).add("xxx"); + phaseRuleMap.get(VolcanoPlannerPhase.CLEANUP).add("xxx"); }; } @@ -689,7 +685,7 @@ public class VolcanoPlanner extends AbstractRelOptPlanner { * will be asking for the result in a particular convention, but the root has * no consumers. */ void ensureRootConverters() { - final Set<RelSubset> subsets = Sets.newHashSet(); + final Set<RelSubset> subsets = new HashSet<>(); for (RelNode rel : root.getRels()) { if (rel instanceof AbstractConverter) { subsets.add((RelSubset) ((AbstractConverter) rel).getInput()); @@ -1172,14 +1168,7 @@ public class VolcanoPlanner extends AbstractRelOptPlanner { pw.println("Original rel:"); pw.println(originalRootString); pw.println("Sets:"); - Ordering<RelSet> ordering = Ordering.from( - new Comparator<RelSet>() { - public int compare( - RelSet o1, - RelSet o2) { - return o1.id - o2.id; - } - }); + Ordering<RelSet> ordering = Ordering.from((o1, o2) -> o1.id - o2.id); for (RelSet set : ordering.immutableSortedCopy(allSets)) { pw.println("Set#" + set.id + ", type: " + set.subsets.get(0).getRowType()); http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java index 17f28f7..9d96fef 100644 --- a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java +++ b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java @@ -21,7 +21,6 @@ import org.apache.calcite.rel.metadata.Metadata; import org.apache.calcite.rel.metadata.MetadataDef; import org.apache.calcite.rel.metadata.MetadataHandler; import org.apache.calcite.rel.metadata.RelMetadataProvider; -import org.apache.calcite.rel.metadata.RelMetadataQuery; import org.apache.calcite.rel.metadata.UnboundMetadata; import com.google.common.collect.ImmutableMultimap; @@ -52,66 +51,64 @@ public class VolcanoRelMetadataProvider implements RelMetadataProvider { return null; } - return new UnboundMetadata<M>() { - public M bind(RelNode rel, RelMetadataQuery mq) { - final RelSubset subset = (RelSubset) rel; - final RelMetadataProvider provider = - rel.getCluster().getMetadataProvider(); - - // REVIEW jvs 29-Mar-2006: I'm not sure what the correct precedence - // should be here. Letting the current best plan take the first shot is - // probably the right thing to do for physical estimates such as row - // count. Dunno about others, and whether we need a way to - // discriminate. - - // First, try current best implementation. If it knows how to answer - // this query, treat it as the most reliable. - if (subset.best != null) { - final UnboundMetadata<M> function = - provider.apply(subset.best.getClass(), metadataClass); - if (function != null) { - final M metadata = function.bind(subset.best, mq); - if (metadata != null) { - return metadata; - } + return (rel, mq) -> { + final RelSubset subset = (RelSubset) rel; + final RelMetadataProvider provider = + rel.getCluster().getMetadataProvider(); + + // REVIEW jvs 29-Mar-2006: I'm not sure what the correct precedence + // should be here. Letting the current best plan take the first shot is + // probably the right thing to do for physical estimates such as row + // count. Dunno about others, and whether we need a way to + // discriminate. + + // First, try current best implementation. If it knows how to answer + // this query, treat it as the most reliable. + if (subset.best != null) { + final UnboundMetadata<M> function = + provider.apply(subset.best.getClass(), metadataClass); + if (function != null) { + final M metadata = function.bind(subset.best, mq); + if (metadata != null) { + return metadata; } } + } - // Otherwise, try rels in same logical equivalence class to see if any - // of them have a good answer. We use the full logical equivalence - // class rather than just the subset because many metadata providers - // only know about logical metadata. - - // Equivalence classes can get tangled up in interesting ways, so avoid - // an infinite loop. REVIEW: There's a chance this will cause us to - // fail on metadata queries which invoke other queries, e.g. - // PercentageOriginalRows -> Selectivity. If we implement caching at - // this level, we could probably kill two birds with one stone (use - // presence of pending cache entry to detect re-entrancy at the correct - // granularity). - if (subset.set.inMetadataQuery) { - return null; - } + // Otherwise, try rels in same logical equivalence class to see if any + // of them have a good answer. We use the full logical equivalence + // class rather than just the subset because many metadata providers + // only know about logical metadata. + + // Equivalence classes can get tangled up in interesting ways, so avoid + // an infinite loop. REVIEW: There's a chance this will cause us to + // fail on metadata queries which invoke other queries, e.g. + // PercentageOriginalRows -> Selectivity. If we implement caching at + // this level, we could probably kill two birds with one stone (use + // presence of pending cache entry to detect re-entrancy at the correct + // granularity). + if (subset.set.inMetadataQuery) { + return null; + } - subset.set.inMetadataQuery = true; - try { - for (RelNode relCandidate : subset.set.rels) { - final UnboundMetadata<M> function = - provider.apply(relCandidate.getClass(), metadataClass); - if (function != null) { - final M result = function.bind(relCandidate, mq); - if (result != null) { - return result; - } + subset.set.inMetadataQuery = true; + try { + for (RelNode relCandidate : subset.set.rels) { + final UnboundMetadata<M> function = + provider.apply(relCandidate.getClass(), metadataClass); + if (function != null) { + final M result = function.bind(relCandidate, mq); + if (result != null) { + return result; } } - } finally { - subset.set.inMetadataQuery = false; } - - // Give up. - return null; + } finally { + subset.set.inMetadataQuery = false; } + + // Give up. + return null; }; } http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java index 392581d..ac883f0 100644 --- a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java +++ b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java @@ -80,7 +80,7 @@ public class VolcanoRuleCall extends RelOptRuleCall { planner, operand, new RelNode[operand.getRule().operands.size()], - ImmutableMap.<RelNode, List<RelNode>>of()); + ImmutableMap.of()); } //~ Methods ---------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java b/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java index c49a9cb..cbfd145 100644 --- a/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java +++ b/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java @@ -26,7 +26,6 @@ import org.apache.calcite.rel.type.RelDataTypeFactory; import org.apache.calcite.rel.type.RelDataTypeFactoryImpl; import org.apache.calcite.rel.type.RelDataTypeField; import org.apache.calcite.rel.type.RelDataTypeSystem; -import org.apache.calcite.runtime.PredicateImpl; import org.apache.calcite.schema.AggregateFunction; import org.apache.calcite.schema.Function; import org.apache.calcite.schema.FunctionParameter; @@ -39,7 +38,6 @@ import org.apache.calcite.schema.impl.ScalarFunctionImpl; import org.apache.calcite.sql.SqlFunctionCategory; import org.apache.calcite.sql.SqlIdentifier; import org.apache.calcite.sql.SqlOperator; -import org.apache.calcite.sql.SqlOperatorBinding; import org.apache.calcite.sql.SqlOperatorTable; import org.apache.calcite.sql.SqlSyntax; import org.apache.calcite.sql.parser.SqlParserPos; @@ -64,10 +62,6 @@ import org.apache.calcite.sql.validate.SqlUserDefinedTableMacro; import org.apache.calcite.sql.validate.SqlValidatorUtil; import org.apache.calcite.util.Util; -import com.google.common.base.Preconditions; -import com.google.common.base.Predicate; -import com.google.common.base.Predicates; -import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; import com.google.common.collect.Lists; @@ -78,6 +72,8 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.NavigableSet; +import java.util.Objects; +import java.util.function.Predicate; /** * Implementation of {@link org.apache.calcite.prepare.Prepare.CatalogReader} @@ -94,15 +90,15 @@ public class CalciteCatalogReader implements Prepare.CatalogReader { public CalciteCatalogReader(CalciteSchema rootSchema, List<String> defaultSchema, RelDataTypeFactory typeFactory, CalciteConnectionConfig config) { this(rootSchema, SqlNameMatchers.withCaseSensitive(config != null && config.caseSensitive()), - ImmutableList.of(Preconditions.checkNotNull(defaultSchema), - ImmutableList.<String>of()), + ImmutableList.of(Objects.requireNonNull(defaultSchema), + ImmutableList.of()), typeFactory, config); } protected CalciteCatalogReader(CalciteSchema rootSchema, SqlNameMatcher nameMatcher, List<List<String>> schemaPaths, RelDataTypeFactory typeFactory, CalciteConnectionConfig config) { - this.rootSchema = Preconditions.checkNotNull(rootSchema); + this.rootSchema = Objects.requireNonNull(rootSchema); this.nameMatcher = nameMatcher; this.schemaPaths = Util.immutableCopy(Util.isDistinct(schemaPaths) @@ -114,7 +110,7 @@ public class CalciteCatalogReader implements Prepare.CatalogReader { public CalciteCatalogReader withSchemaPath(List<String> schemaPath) { return new CalciteCatalogReader(rootSchema, nameMatcher, - ImmutableList.of(schemaPath, ImmutableList.<String>of()), typeFactory, config); + ImmutableList.of(schemaPath, ImmutableList.of()), typeFactory, config); } public Prepare.PreparingTable getTable(final List<String> names) { @@ -141,7 +137,7 @@ public class CalciteCatalogReader implements Prepare.CatalogReader { } private Collection<Function> getFunctionsFrom(List<String> names) { - final List<Function> functions2 = Lists.newArrayList(); + final List<Function> functions2 = new ArrayList<>(); final List<List<String>> schemaNameList = new ArrayList<>(); if (names.size() > 1) { // Name qualified: ignore path. But we do look in "/catalog" and "/", @@ -256,34 +252,21 @@ public class CalciteCatalogReader implements Prepare.CatalogReader { final Predicate<Function> predicate; if (category == null) { - predicate = Predicates.alwaysTrue(); + predicate = function -> true; } else if (category.isTableFunction()) { - predicate = new PredicateImpl<Function>() { - public boolean test(Function function) { - return function instanceof TableMacro + predicate = function -> + function instanceof TableMacro || function instanceof TableFunction; - } - }; } else { - predicate = new PredicateImpl<Function>() { - public boolean test(Function function) { - return !(function instanceof TableMacro + predicate = function -> + !(function instanceof TableMacro || function instanceof TableFunction); - } - }; - } - final Collection<Function> functions = - Collections2.filter(getFunctionsFrom(opName.names), predicate); - if (functions.isEmpty()) { - return; } - operatorList.addAll( - Collections2.transform(functions, - new com.google.common.base.Function<Function, SqlOperator>() { - public SqlOperator apply(Function function) { - return toOp(opName, function); - } - })); + getFunctionsFrom(opName.names) + .stream() + .filter(predicate) + .map(function -> toOp(opName, function)) + .forEachOrdered(operatorList::add); } /** Creates an operator table that contains functions in the given class. @@ -293,7 +276,7 @@ public class CalciteCatalogReader implements Prepare.CatalogReader { // Dummy schema to collect the functions final CalciteSchema schema = CalciteSchema.createRootSchema(false, false); - ModelHandler.addFunctions(schema.plus(), null, ImmutableList.<String>of(), + ModelHandler.addFunctions(schema.plus(), null, ImmutableList.of(), className, "*", true); // The following is technical debt; see [CALCITE-2082] Remove @@ -331,14 +314,9 @@ public class CalciteCatalogReader implements Prepare.CatalogReader { typeFamilies.add( Util.first(type.getSqlTypeName().getFamily(), SqlTypeFamily.ANY)); } - final Predicate<Integer> optional = - new PredicateImpl<Integer>() { - public boolean test(Integer input) { - return function.getParameters().get(input).isOptional(); - } - }; final FamilyOperandTypeChecker typeChecker = - OperandTypes.family(typeFamilies, optional); + OperandTypes.family(typeFamilies, i -> + function.getParameters().get(i).isOptional()); final List<RelDataType> paramTypes = toSql(typeFactory, argTypes); if (function instanceof ScalarFunction) { return new SqlUserDefinedFunction(name, infer((ScalarFunction) function), @@ -361,40 +339,31 @@ public class CalciteCatalogReader implements Prepare.CatalogReader { } private static SqlReturnTypeInference infer(final ScalarFunction function) { - return new SqlReturnTypeInference() { - public RelDataType inferReturnType(SqlOperatorBinding opBinding) { - final RelDataTypeFactory typeFactory = opBinding.getTypeFactory(); - final RelDataType type; - if (function instanceof ScalarFunctionImpl) { - type = ((ScalarFunctionImpl) function).getReturnType(typeFactory, - opBinding); - } else { - type = function.getReturnType(typeFactory); - } - return toSql(typeFactory, type); + return opBinding -> { + final RelDataTypeFactory typeFactory = opBinding.getTypeFactory(); + final RelDataType type; + if (function instanceof ScalarFunctionImpl) { + type = ((ScalarFunctionImpl) function).getReturnType(typeFactory, + opBinding); + } else { + type = function.getReturnType(typeFactory); } + return toSql(typeFactory, type); }; } private static SqlReturnTypeInference infer( final AggregateFunction function) { - return new SqlReturnTypeInference() { - public RelDataType inferReturnType(SqlOperatorBinding opBinding) { - final RelDataTypeFactory typeFactory = opBinding.getTypeFactory(); - final RelDataType type = function.getReturnType(typeFactory); - return toSql(typeFactory, type); - } + return opBinding -> { + final RelDataTypeFactory typeFactory = opBinding.getTypeFactory(); + final RelDataType type = function.getReturnType(typeFactory); + return toSql(typeFactory, type); }; } private static List<RelDataType> toSql( final RelDataTypeFactory typeFactory, List<RelDataType> types) { - return Lists.transform(types, - new com.google.common.base.Function<RelDataType, RelDataType>() { - public RelDataType apply(RelDataType type) { - return toSql(typeFactory, type); - } - }); + return Lists.transform(types, type -> toSql(typeFactory, type)); } private static RelDataType toSql(RelDataTypeFactory typeFactory, http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java b/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java index 92cb104..45c4850 100644 --- a/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java +++ b/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java @@ -50,8 +50,8 @@ import org.apache.calcite.sql2rel.SqlRexConvertletTable; import org.apache.calcite.sql2rel.SqlToRelConverter; import com.google.common.collect.ImmutableList; -import com.google.common.collect.Lists; +import java.util.ArrayList; import java.util.List; /** @@ -126,7 +126,7 @@ class CalciteMaterializer extends CalcitePrepareImpl.CalcitePreparingStmt { // Don't waste effort converting to leaf-join form. return ImmutableList.of(); } - final List<Callback> list = Lists.newArrayList(); + final List<Callback> list = new ArrayList<>(); final RelNode rel2 = RelOptMaterialization.toLeafJoinForm(queryRel); for (CalciteSchema.TableEntry starTable : starTables) { http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java index 9b772be..5a6d521 100644 --- a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java +++ b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java @@ -16,7 +16,6 @@ */ package org.apache.calcite.prepare; -import org.apache.calcite.DataContext; import org.apache.calcite.adapter.enumerable.EnumerableBindable; import org.apache.calcite.adapter.enumerable.EnumerableCalc; import org.apache.calcite.adapter.enumerable.EnumerableConvention; @@ -36,7 +35,6 @@ import org.apache.calcite.interpreter.Interpreters; import org.apache.calcite.jdbc.CalcitePrepare; import org.apache.calcite.jdbc.CalciteSchema; import org.apache.calcite.jdbc.CalciteSchema.LatticeEntry; -import org.apache.calcite.linq4j.Enumerable; import org.apache.calcite.linq4j.Linq4j; import org.apache.calcite.linq4j.Ord; import org.apache.calcite.linq4j.Queryable; @@ -142,7 +140,6 @@ import com.google.common.base.Supplier; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Maps; import java.lang.reflect.Type; import java.math.BigDecimal; @@ -151,6 +148,7 @@ import java.sql.Types; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; @@ -501,12 +499,8 @@ public class CalcitePrepareImpl implements CalcitePrepare { * {@link #createPlanner(org.apache.calcite.jdbc.CalcitePrepare.Context)}.</p> */ protected List<Function1<Context, RelOptPlanner>> createPlannerFactories() { - return Collections.<Function1<Context, RelOptPlanner>>singletonList( - new Function1<Context, RelOptPlanner>() { - public RelOptPlanner apply(Context context) { - return createPlanner(context, null, null); - } - }); + return Collections.singletonList( + context -> createPlanner(context, null, null)); } /** Creates a query planner and initializes it with a default set of @@ -667,19 +661,14 @@ public class CalcitePrepareImpl implements CalcitePrepare { Meta.CursorFactory.deduce(columns, null); return new CalciteSignature<>( sql, - ImmutableList.<AvaticaParameter>of(), - ImmutableMap.<String, Object>of(), + ImmutableList.of(), + ImmutableMap.of(), x, columns, cursorFactory, context.getRootSchema(), - ImmutableList.<RelCollation>of(), - -1, - new Bindable<T>() { - public Enumerable<T> bind(DataContext dataContext) { - return Linq4j.asEnumerable(list); - } - }, + ImmutableList.of(), + -1, dataContext -> Linq4j.asEnumerable(list), Meta.StatementType.SELECT); } @@ -768,10 +757,10 @@ public class CalcitePrepareImpl implements CalcitePrepare { executeDdl(context, sqlNode); return new CalciteSignature<>(query.sql, - ImmutableList.<AvaticaParameter>of(), - ImmutableMap.<String, Object>of(), null, - ImmutableList.<ColumnMetaData>of(), Meta.CursorFactory.OBJECT, - null, ImmutableList.<RelCollation>of(), -1, null, + ImmutableList.of(), + ImmutableMap.of(), null, + ImmutableList.of(), Meta.CursorFactory.OBJECT, + null, ImmutableList.of(), -1, null, Meta.StatementType.OTHER_DDL); } @@ -844,7 +833,7 @@ public class CalcitePrepareImpl implements CalcitePrepare { context.getRootSchema(), preparedResult instanceof Prepare.PreparedResultImpl ? ((Prepare.PreparedResultImpl) preparedResult).collations - : ImmutableList.<RelCollation>of(), + : ImmutableList.of(), maxRowCount, bindable, statementType); @@ -1066,7 +1055,7 @@ public class CalcitePrepareImpl implements CalcitePrepare { protected final SqlRexConvertletTable convertletTable; private final EnumerableRel.Prefer prefer; private final Map<String, Object> internalParameters = - Maps.newLinkedHashMap(); + new LinkedHashMap<>(); private int expansionDepth; private SqlValidator sqlValidator; @@ -1095,24 +1084,16 @@ public class CalcitePrepareImpl implements CalcitePrepare { public PreparedResult prepareQueryable( final Queryable queryable, RelDataType resultType) { - return prepare_( - new Supplier<RelNode>() { - public RelNode get() { - final RelOptCluster cluster = - prepare.createCluster(planner, rexBuilder); - return new LixToRelTranslator(cluster, CalcitePreparingStmt.this) - .translate(queryable); - } - }, resultType); + return prepare_(() -> { + final RelOptCluster cluster = + prepare.createCluster(planner, rexBuilder); + return new LixToRelTranslator(cluster, CalcitePreparingStmt.this) + .translate(queryable); + }, resultType); } public PreparedResult prepareRel(final RelNode rel) { - return prepare_( - new Supplier<RelNode>() { - public RelNode get() { - return rel; - } - }, rel.getRowType()); + return prepare_(() -> rel, rel.getRowType()); } private PreparedResult prepare_(Supplier<RelNode> fn, @@ -1273,7 +1254,7 @@ public class CalcitePrepareImpl implements CalcitePrepare { parameterRowType, fieldOrigins, root.collation.getFieldCollations().isEmpty() - ? ImmutableList.<RelCollation>of() + ? ImmutableList.of() : ImmutableList.of(root.collation), root.rel, mapTableModOp(isDml, root.kind), @@ -1296,7 +1277,7 @@ public class CalcitePrepareImpl implements CalcitePrepare { final List<Prepare.Materialization> materializations = context.config().materializationsEnabled() ? MaterializationService.instance().query(schema) - : ImmutableList.<Prepare.Materialization>of(); + : ImmutableList.of(); for (Prepare.Materialization materialization : materializations) { prepare.populateMaterializations(context, planner, materialization); } @@ -1321,15 +1302,13 @@ public class CalcitePrepareImpl implements CalcitePrepare { public Bindable getBindable(final Meta.CursorFactory cursorFactory) { final String explanation = getCode(); - return new Bindable() { - public Enumerable bind(DataContext dataContext) { - switch (cursorFactory.style) { - case ARRAY: - return Linq4j.singletonEnumerable(new String[] {explanation}); - case OBJECT: - default: - return Linq4j.singletonEnumerable(explanation); - } + return dataContext -> { + switch (cursorFactory.style) { + case ARRAY: + return Linq4j.singletonEnumerable(new String[] {explanation}); + case OBJECT: + default: + return Linq4j.singletonEnumerable(explanation); } }; } http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java b/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java index 3a52ba5..460e2ca 100644 --- a/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java +++ b/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java @@ -102,7 +102,7 @@ class LixToRelTranslator implements RelOptTable.ToRelContext { typeFactory.createJavaType( Types.toClass( Types.getElementType(call.targetExpression.getType()))), - ImmutableList.<String>of(), + ImmutableList.of(), call.targetExpression)); case SCHEMA_GET_TABLE: @@ -110,7 +110,7 @@ class LixToRelTranslator implements RelOptTable.ToRelContext { RelOptTableImpl.create(null, typeFactory.createJavaType((Class) ((ConstantExpression) call.expressions.get(1)).value), - ImmutableList.<String>of(), + ImmutableList.of(), call.targetExpression)); default: http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java b/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java index e5f2ae0..cb27ea2 100644 --- a/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java +++ b/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java @@ -23,10 +23,7 @@ import org.apache.calcite.config.CalciteConnectionProperty; import org.apache.calcite.jdbc.CalciteSchema; import org.apache.calcite.plan.Context; import org.apache.calcite.plan.RelOptCluster; -import org.apache.calcite.plan.RelOptLattice; -import org.apache.calcite.plan.RelOptMaterialization; import org.apache.calcite.plan.RelOptPlanner; -import org.apache.calcite.plan.RelOptSchema; import org.apache.calcite.plan.RelOptTable.ViewExpander; import org.apache.calcite.plan.RelTraitDef; import org.apache.calcite.plan.RelTraitSet; @@ -144,15 +141,12 @@ public class PlannerImpl implements Planner { } ensure(State.STATE_1_RESET); Frameworks.withPlanner( - new Frameworks.PlannerAction<Void>() { - public Void apply(RelOptCluster cluster, RelOptSchema relOptSchema, - SchemaPlus rootSchema) { - Util.discard(rootSchema); // use our own defaultSchema - typeFactory = (JavaTypeFactory) cluster.getTypeFactory(); - planner = cluster.getPlanner(); - planner.setExecutor(executor); - return null; - } + (cluster, relOptSchema, rootSchema) -> { + Util.discard(rootSchema); // use our own defaultSchema + typeFactory = (JavaTypeFactory) cluster.getTypeFactory(); + planner = cluster.getPlanner(); + planner.setExecutor(executor); + return null; }, config); @@ -340,9 +334,8 @@ public class PlannerImpl implements Planner { rel.getCluster().getMetadataProvider(), rel.getCluster().getPlanner())); Program program = programs.get(ruleSetIndex); - return program.run(planner, rel, requiredOutputTraits, - ImmutableList.<RelOptMaterialization>of(), - ImmutableList.<RelOptLattice>of()); + return program.run(planner, rel, requiredOutputTraits, ImmutableList.of(), + ImmutableList.of()); } /** Stage of a statement in the query-preparation lifecycle. */ http://git-wip-us.apache.org/repos/asf/calcite/blob/d59b639d/core/src/main/java/org/apache/calcite/prepare/Prepare.java ---------------------------------------------------------------------- diff --git a/core/src/main/java/org/apache/calcite/prepare/Prepare.java b/core/src/main/java/org/apache/calcite/prepare/Prepare.java index 95758e5..8d1a55b 100644 --- a/core/src/main/java/org/apache/calcite/prepare/Prepare.java +++ b/core/src/main/java/org/apache/calcite/prepare/Prepare.java @@ -69,7 +69,6 @@ import org.apache.calcite.util.TryThreadLocal; import org.apache.calcite.util.trace.CalciteTimingTracer; import org.apache.calcite.util.trace.CalciteTrace; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import org.slf4j.Logger; @@ -78,6 +77,7 @@ import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import java.util.Objects; /** * Abstract base for classes that implement @@ -532,7 +532,7 @@ public abstract class Prepare { public List<List<String>> getFieldOrigins() { return Collections.singletonList( - Collections.<String>nCopies(4, null)); + Collections.nCopies(4, null)); } } @@ -599,11 +599,11 @@ public abstract class Prepare { RelNode rootRel, LogicalTableModify.Operation tableModOp, boolean isDml) { - this.rowType = Preconditions.checkNotNull(rowType); - this.parameterRowType = Preconditions.checkNotNull(parameterRowType); - this.fieldOrigins = Preconditions.checkNotNull(fieldOrigins); + this.rowType = Objects.requireNonNull(rowType); + this.parameterRowType = Objects.requireNonNull(parameterRowType); + this.fieldOrigins = Objects.requireNonNull(fieldOrigins); this.collations = ImmutableList.copyOf(collations); - this.rootRel = Preconditions.checkNotNull(rootRel); + this.rootRel = Objects.requireNonNull(rootRel); this.tableModOp = tableModOp; this.isDml = isDml; }
