org.apache.hadoop.hive.ql.optimizer.calcite.HiveSubQRemoveRelBuilder Maven / Gradle / Ivy
Show all versions of hive-apache Show documentation
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.hadoop.hive.ql.optimizer.calcite;
import org.apache.calcite.linq4j.Ord;
import org.apache.calcite.plan.Context;
import org.apache.calcite.plan.Contexts;
import org.apache.calcite.plan.RelOptCluster;
import org.apache.calcite.plan.RelOptSchema;
import org.apache.calcite.plan.RelOptTable;
import org.apache.calcite.plan.RelOptUtil;
import org.apache.calcite.rel.RelCollation;
import org.apache.calcite.rel.RelCollations;
import org.apache.calcite.rel.RelFieldCollation;
import org.apache.calcite.rel.RelNode;
import org.apache.calcite.rel.core.Aggregate;
import org.apache.calcite.rel.core.AggregateCall;
import org.apache.calcite.rel.core.CorrelationId;
import org.apache.calcite.rel.core.JoinRelType;
import org.apache.calcite.rel.core.Project;
import org.apache.calcite.rel.core.RelFactories;
import org.apache.calcite.rel.core.Sort;
import org.apache.calcite.rel.core.TableScan;
import org.apache.calcite.rel.core.Values;
import org.apache.calcite.rel.type.RelDataType;
import org.apache.calcite.rel.type.RelDataTypeFactory;
import org.apache.calcite.rel.type.RelDataTypeField;
import org.apache.calcite.rex.RexBuilder;
import org.apache.calcite.rex.RexCall;
import org.apache.calcite.rex.RexCorrelVariable;
import org.apache.calcite.rex.RexInputRef;
import org.apache.calcite.rex.RexLiteral;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.rex.RexUtil;
import org.apache.calcite.rex.RexShuttle;
import org.apache.calcite.schema.SchemaPlus;
import org.apache.calcite.server.CalciteServerStatement;
import org.apache.calcite.sql.SemiJoinType;
import org.apache.calcite.sql.SqlAggFunction;
import org.apache.calcite.sql.SqlKind;
import org.apache.calcite.sql.SqlOperator;
import org.apache.calcite.sql.fun.SqlStdOperatorTable;
import org.apache.calcite.sql.type.SqlTypeName;
import org.apache.calcite.sql.validate.SqlValidatorUtil;
import org.apache.calcite.tools.RelBuilder;
import org.apache.calcite.tools.FrameworkConfig;
import org.apache.calcite.tools.Frameworks;
import org.apache.calcite.util.CompositeList;
import org.apache.calcite.util.Holder;
import org.apache.calcite.util.ImmutableBitSet;
import org.apache.calcite.util.ImmutableIntList;
import org.apache.calcite.util.Litmus;
import org.apache.calcite.util.NlsString;
import org.apache.calcite.util.Pair;
import org.apache.calcite.util.Static;
import org.apache.calcite.util.Util;
import org.apache.calcite.util.mapping.Mapping;
import org.apache.calcite.util.mapping.Mappings;
import io.prestosql.hive.$internal.com.google.common.base.Function;
import io.prestosql.hive.$internal.com.google.common.base.Joiner;
import io.prestosql.hive.$internal.com.google.common.base.Preconditions;
import io.prestosql.hive.$internal.com.google.common.collect.ImmutableList;
import io.prestosql.hive.$internal.com.google.common.collect.ImmutableSet;
import io.prestosql.hive.$internal.com.google.common.collect.Iterables;
import io.prestosql.hive.$internal.com.google.common.collect.Lists;
import java.math.BigDecimal;
import java.util.AbstractList;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
/**
* Builder for relational expressions.
* TODO:
* Note that this is copied from Calcite's RelBulder
* because CALCITE-1493 hasn't been fixed yet
* This should be deleted and replaced with RelBuilder in SubqueryRemoveRule
* once CALCITE-1493 is fixed.
* EDIT: Although CALCITE-1493 has been fixed and released but HIVE now has special handling
* in join (it gets a flag to see if semi join is to be created or not). So we still can not
* replace this with Calcite's RelBuilder
*
* {@code RelBuilder} does not make possible anything that you could not
* also accomplish by calling the factory methods of the particular relational
* expression. But it makes common tasks more straightforward and concise.
*
*
{@code RelBuilder} uses factories to create relational expressions.
* By default, it uses the default factories, which create logical relational
* expressions ({@link org.apache.calcite.rel.logical.LogicalFilter},
* {@link org.apache.calcite.rel.logical.LogicalProject} and so forth).
* But you could override those factories so that, say, {@code filter} creates
* instead a {@code HiveFilter}.
*
*
It is not thread-safe.
*/
public class HiveSubQRemoveRelBuilder {
private static final Function FN_TYPE =
new Function() {
public String apply(RexNode input) {
return input + ": " + input.getType();
}
};
private final RelOptCluster cluster;
private final RelOptSchema relOptSchema;
private final RelFactories.FilterFactory filterFactory;
private final RelFactories.ProjectFactory projectFactory;
private final RelFactories.AggregateFactory aggregateFactory;
private final RelFactories.SortFactory sortFactory;
private final RelFactories.SetOpFactory setOpFactory;
private final RelFactories.JoinFactory joinFactory;
private final RelFactories.SemiJoinFactory semiJoinFactory;
private final RelFactories.CorrelateFactory correlateFactory;
private final RelFactories.ValuesFactory valuesFactory;
private final RelFactories.TableScanFactory scanFactory;
private final Deque stack = new ArrayDeque<>();
public HiveSubQRemoveRelBuilder(Context context, RelOptCluster cluster,
RelOptSchema relOptSchema) {
this.cluster = cluster;
this.relOptSchema = relOptSchema;
if (context == null) {
context = Contexts.EMPTY_CONTEXT;
}
this.aggregateFactory =
Util.first(context.unwrap(RelFactories.AggregateFactory.class),
HiveRelFactories.HIVE_AGGREGATE_FACTORY);
this.filterFactory =
Util.first(context.unwrap(RelFactories.FilterFactory.class),
HiveRelFactories.HIVE_FILTER_FACTORY);
this.projectFactory =
Util.first(context.unwrap(RelFactories.ProjectFactory.class),
HiveRelFactories.HIVE_PROJECT_FACTORY);
this.sortFactory =
Util.first(context.unwrap(RelFactories.SortFactory.class),
HiveRelFactories.HIVE_SORT_FACTORY);
this.setOpFactory =
Util.first(context.unwrap(RelFactories.SetOpFactory.class),
HiveRelFactories.HIVE_SET_OP_FACTORY);
this.joinFactory =
Util.first(context.unwrap(RelFactories.JoinFactory.class),
HiveRelFactories.HIVE_JOIN_FACTORY);
this.semiJoinFactory =
Util.first(context.unwrap(RelFactories.SemiJoinFactory.class),
HiveRelFactories.HIVE_SEMI_JOIN_FACTORY);
this.correlateFactory =
Util.first(context.unwrap(RelFactories.CorrelateFactory.class),
RelFactories.DEFAULT_CORRELATE_FACTORY);
this.valuesFactory =
Util.first(context.unwrap(RelFactories.ValuesFactory.class),
RelFactories.DEFAULT_VALUES_FACTORY);
this.scanFactory =
Util.first(context.unwrap(RelFactories.TableScanFactory.class),
RelFactories.DEFAULT_TABLE_SCAN_FACTORY);
}
/** Creates a RelBuilder. */
public static HiveSubQRemoveRelBuilder create(FrameworkConfig config) {
final RelOptCluster[] clusters = {null};
final RelOptSchema[] relOptSchemas = {null};
Frameworks.withPrepare(
new Frameworks.PrepareAction(config) {
public Void apply(RelOptCluster cluster, RelOptSchema relOptSchema,
SchemaPlus rootSchema, CalciteServerStatement statement) {
clusters[0] = cluster;
relOptSchemas[0] = relOptSchema;
return null;
}
});
return new HiveSubQRemoveRelBuilder(config.getContext(), clusters[0], relOptSchemas[0]);
}
/** Returns the type factory. */
public RelDataTypeFactory getTypeFactory() {
return cluster.getTypeFactory();
}
/** Returns the builder for {@link RexNode} expressions. */
public RexBuilder getRexBuilder() {
return cluster.getRexBuilder();
}
/** Adds a relational expression to be the input to the next relational
* expression constructed.
*
* This method is usual when you want to weave in relational expressions
* that are not supported by the builder. If, while creating such expressions,
* you need to use previously built expressions as inputs, call
* {@link #build()} to pop those inputs. */
public HiveSubQRemoveRelBuilder push(RelNode node) {
stack.push(new Frame(node));
return this;
}
/** Pushes a collection of relational expressions. */
public HiveSubQRemoveRelBuilder pushAll(Iterable nodes) {
for (RelNode node : nodes) {
push(node);
}
return this;
}
/** Returns the final relational expression.
*
*
Throws if the stack is empty.
*/
public RelNode build() {
return stack.pop().rel;
}
/** Returns the relational expression at the top of the stack, but does not
* remove it. */
public RelNode peek() {
return peek_().rel;
}
private Frame peek_() {
return stack.peek();
}
/** Returns the relational expression {@code n} positions from the top of the
* stack, but does not remove it. */
public RelNode peek(int n) {
return peek_(n).rel;
}
private Frame peek_(int n) {
return Iterables.get(stack, n);
}
/** Returns the relational expression {@code n} positions from the top of the
* stack, but does not remove it. */
public RelNode peek(int inputCount, int inputOrdinal) {
return peek_(inputCount, inputOrdinal).rel;
}
private Frame peek_(int inputCount, int inputOrdinal) {
return peek_(inputCount - 1 - inputOrdinal);
}
/** Returns the number of fields in all inputs before (to the left of)
* the given input.
*
* @param inputCount Number of inputs
* @param inputOrdinal Input ordinal
*/
private int inputOffset(int inputCount, int inputOrdinal) {
int offset = 0;
for (int i = 0; i < inputOrdinal; i++) {
offset += peek(inputCount, i).getRowType().getFieldCount();
}
return offset;
}
// Methods that return scalar expressions
/** Creates a literal (constant expression). */
public RexNode literal(Object value) {
final RexBuilder rexBuilder = cluster.getRexBuilder();
if (value == null) {
return rexBuilder.constantNull();
} else if (value instanceof Boolean) {
return rexBuilder.makeLiteral((Boolean) value);
} else if (value instanceof BigDecimal) {
return rexBuilder.makeExactLiteral((BigDecimal) value);
} else if (value instanceof Float || value instanceof Double) {
return rexBuilder.makeApproxLiteral(
BigDecimal.valueOf(((Number) value).doubleValue()));
} else if (value instanceof Number) {
return rexBuilder.makeExactLiteral(
BigDecimal.valueOf(((Number) value).longValue()));
} else if (value instanceof String) {
return rexBuilder.makeLiteral((String) value);
} else {
throw new IllegalArgumentException("cannot convert " + value
+ " (" + value.getClass() + ") to a constant");
}
}
/** Creates a reference to a field by name.
*
*
Equivalent to {@code field(1, 0, fieldName)}.
*
* @param fieldName Field name
*/
public RexInputRef field(String fieldName) {
return field(1, 0, fieldName);
}
/** Creates a reference to a field of given input relational expression
* by name.
*
* @param inputCount Number of inputs
* @param inputOrdinal Input ordinal
* @param fieldName Field name
*/
public RexInputRef field(int inputCount, int inputOrdinal, String fieldName) {
final Frame frame = peek_(inputCount, inputOrdinal);
final List fieldNames = Pair.left(frame.fields());
int i = fieldNames.indexOf(fieldName);
if (i >= 0) {
return field(inputCount, inputOrdinal, i);
} else {
throw new IllegalArgumentException("field [" + fieldName
+ "] not found; input fields are: " + fieldNames);
}
}
/** Creates a reference to an input field by ordinal.
*
* Equivalent to {@code field(1, 0, ordinal)}.
*
* @param fieldOrdinal Field ordinal
*/
public RexInputRef field(int fieldOrdinal) {
return (RexInputRef) field(1, 0, fieldOrdinal, false);
}
/** Creates a reference to a field of a given input relational expression
* by ordinal.
*
* @param inputCount Number of inputs
* @param inputOrdinal Input ordinal
* @param fieldOrdinal Field ordinal within input
*/
public RexInputRef field(int inputCount, int inputOrdinal, int fieldOrdinal) {
return (RexInputRef) field(inputCount, inputOrdinal, fieldOrdinal, false);
}
/** As {@link #field(int, int, int)}, but if {@code alias} is true, the method
* may apply an alias to make sure that the field has the same name as in the
* input frame. If no alias is applied the expression is definitely a
* {@link RexInputRef}. */
private RexNode field(int inputCount, int inputOrdinal, int fieldOrdinal,
boolean alias) {
final Frame frame = peek_(inputCount, inputOrdinal);
final RelNode input = frame.rel;
final RelDataType rowType = input.getRowType();
if (fieldOrdinal < 0 || fieldOrdinal > rowType.getFieldCount()) {
throw new IllegalArgumentException("field ordinal [" + fieldOrdinal
+ "] out of range; input fields are: " + rowType.getFieldNames());
}
final RelDataTypeField field = rowType.getFieldList().get(fieldOrdinal);
final int offset = inputOffset(inputCount, inputOrdinal);
final RexInputRef ref = cluster.getRexBuilder()
.makeInputRef(field.getType(), offset + fieldOrdinal);
final RelDataTypeField aliasField = frame.fields().get(fieldOrdinal);
if (!alias || field.getName().equals(aliasField.getName())) {
return ref;
} else {
return alias(ref, aliasField.getName());
}
}
/** Creates a reference to a field of the current record which originated
* in a relation with a given alias. */
public RexNode field(String alias, String fieldName) {
Preconditions.checkNotNull(alias);
Preconditions.checkNotNull(fieldName);
final Frame frame = stack.peek();
final List aliases = new ArrayList<>();
int offset = 0;
for (Pair pair : frame.right) {
if (pair.left != null && pair.left.equals(alias)) {
int i = pair.right.getFieldNames().indexOf(fieldName);
if (i >= 0) {
return field(offset + i);
} else {
throw new IllegalArgumentException("no field '" + fieldName
+ "' in relation '" + alias
+ "'; fields are: " + pair.right.getFieldNames());
}
}
aliases.add(pair.left);
offset += pair.right.getFieldCount();
}
throw new IllegalArgumentException("no relation wtih alias '" + alias
+ "'; aliases are: " + aliases);
}
/** Returns references to the fields of the top input. */
public ImmutableList fields() {
return fields(1, 0);
}
/** Returns references to the fields of a given input. */
public ImmutableList fields(int inputCount, int inputOrdinal) {
final RelNode input = peek(inputCount, inputOrdinal);
final RelDataType rowType = input.getRowType();
final ImmutableList.Builder nodes = ImmutableList.builder();
for (int fieldOrdinal : Util.range(rowType.getFieldCount())) {
nodes.add(field(inputCount, inputOrdinal, fieldOrdinal));
}
return nodes.build();
}
/** Returns references to fields for a given collation. */
public ImmutableList fields(RelCollation collation) {
final ImmutableList.Builder nodes = ImmutableList.builder();
for (RelFieldCollation fieldCollation : collation.getFieldCollations()) {
RexNode node = field(fieldCollation.getFieldIndex());
switch (fieldCollation.direction) {
case DESCENDING:
node = desc(node);
}
switch (fieldCollation.nullDirection) {
case FIRST:
node = nullsFirst(node);
break;
case LAST:
node = nullsLast(node);
break;
}
nodes.add(node);
}
return nodes.build();
}
/** Returns references to fields for a given list of input ordinals. */
public ImmutableList fields(List ordinals) {
final ImmutableList.Builder nodes = ImmutableList.builder();
for (Number ordinal : ordinals) {
RexNode node = field(1, 0, ordinal.intValue(), true);
nodes.add(node);
}
return nodes.build();
}
/** Returns references to fields identified by name. */
public ImmutableList fields(Iterable fieldNames) {
final ImmutableList.Builder builder = ImmutableList.builder();
for (String fieldName : fieldNames) {
builder.add(field(fieldName));
}
return builder.build();
}
/** Returns references to fields identified by a mapping. */
public ImmutableList fields(Mappings.TargetMapping mapping) {
return fields(Mappings.asList(mapping));
}
/** Creates an access to a field by name. */
public RexNode dot(RexNode node, String fieldName) {
final RexBuilder builder = cluster.getRexBuilder();
return builder.makeFieldAccess(node, fieldName, true);
}
/** Creates an access to a field by ordinal. */
public RexNode dot(RexNode node, int fieldOrdinal) {
final RexBuilder builder = cluster.getRexBuilder();
return builder.makeFieldAccess(node, fieldOrdinal);
}
/** Creates a call to a scalar operator. */
public RexNode call(SqlOperator operator, RexNode... operands) {
final RexBuilder builder = cluster.getRexBuilder();
final List operandList = ImmutableList.copyOf(operands);
final RelDataType type = builder.deriveReturnType(operator, operandList);
if (type == null) {
throw new IllegalArgumentException("cannot derive type: " + operator
+ "; operands: " + Lists.transform(operandList, FN_TYPE));
}
return builder.makeCall(type, operator, operandList);
}
/** Creates a call to a scalar operator. */
public RexNode call(SqlOperator operator,
Iterable operands) {
return cluster.getRexBuilder().makeCall(operator,
ImmutableList.copyOf(operands));
}
/** Creates an AND. */
public RexNode and(RexNode... operands) {
return and(ImmutableList.copyOf(operands));
}
/** Creates an AND.
*
* Simplifies the expression a little:
* {@code e AND TRUE} becomes {@code e};
* {@code e AND e2 AND NOT e} becomes {@code e2}. */
public RexNode and(Iterable operands) {
return RexUtil.simplifyAnds(cluster.getRexBuilder(), operands);
}
/** Creates an OR. */
public RexNode or(RexNode... operands) {
return or(ImmutableList.copyOf(operands));
}
/** Creates an OR. */
public RexNode or(Iterable operands) {
return RexUtil.composeDisjunction(cluster.getRexBuilder(), operands, false);
}
/** Creates a NOT. */
public RexNode not(RexNode operand) {
return call(SqlStdOperatorTable.NOT, operand);
}
/** Creates an =. */
public RexNode equals(RexNode operand0, RexNode operand1) {
return call(SqlStdOperatorTable.EQUALS, operand0, operand1);
}
/** Creates a IS NULL. */
public RexNode isNull(RexNode operand) {
return call(SqlStdOperatorTable.IS_NULL, operand);
}
/** Creates a IS NOT NULL. */
public RexNode isNotNull(RexNode operand) {
return call(SqlStdOperatorTable.IS_NOT_NULL, operand);
}
/** Creates an expression that casts an expression to a given type. */
public RexNode cast(RexNode expr, SqlTypeName typeName) {
final RelDataType type = cluster.getTypeFactory().createSqlType(typeName);
return cluster.getRexBuilder().makeCast(type, expr);
}
/** Creates an expression that casts an expression to a type with a given name
* and precision or length. */
public RexNode cast(RexNode expr, SqlTypeName typeName, int precision) {
final RelDataType type =
cluster.getTypeFactory().createSqlType(typeName, precision);
return cluster.getRexBuilder().makeCast(type, expr);
}
/** Creates an expression that casts an expression to a type with a given
* name, precision and scale. */
public RexNode cast(RexNode expr, SqlTypeName typeName, int precision,
int scale) {
final RelDataType type =
cluster.getTypeFactory().createSqlType(typeName, precision, scale);
return cluster.getRexBuilder().makeCast(type, expr);
}
/**
* Returns an expression wrapped in an alias.
*
* @see #project
*/
public RexNode alias(RexNode expr, String alias) {
return call(SqlStdOperatorTable.AS, expr, literal(alias));
}
/** Converts a sort expression to descending. */
public RexNode desc(RexNode node) {
return call(SqlStdOperatorTable.DESC, node);
}
/** Converts a sort expression to nulls last. */
public RexNode nullsLast(RexNode node) {
return call(SqlStdOperatorTable.NULLS_LAST, node);
}
/** Converts a sort expression to nulls first. */
public RexNode nullsFirst(RexNode node) {
return call(SqlStdOperatorTable.NULLS_FIRST, node);
}
// Methods that create group keys and aggregate calls
/** Creates an empty group key. */
public GroupKey groupKey() {
return groupKey(ImmutableList.of());
}
/** Creates a group key. */
public GroupKey groupKey(RexNode... nodes) {
return groupKey(ImmutableList.copyOf(nodes));
}
/** Creates a group key. */
public GroupKey groupKey(Iterable nodes) {
return new GroupKeyImpl(ImmutableList.copyOf(nodes), false, null, null);
}
/** Creates a group key with grouping sets. */
public GroupKey groupKey(Iterable nodes, boolean indicator,
Iterable> nodeLists) {
final ImmutableList.Builder> builder =
ImmutableList.builder();
for (Iterable nodeList : nodeLists) {
builder.add(ImmutableList.copyOf(nodeList));
}
return new GroupKeyImpl(ImmutableList.copyOf(nodes), indicator, builder.build(), null);
}
/** Creates a group key of fields identified by ordinal. */
public GroupKey groupKey(int... fieldOrdinals) {
return groupKey(fields(ImmutableIntList.of(fieldOrdinals)));
}
/** Creates a group key of fields identified by name. */
public GroupKey groupKey(String... fieldNames) {
return groupKey(fields(ImmutableList.copyOf(fieldNames)));
}
/** Creates a group key with grouping sets, both identified by field positions
* in the underlying relational expression.
*
* This method of creating a group key does not allow you to group on new
* expressions, only column projections, but is efficient, especially when you
* are coming from an existing {@link Aggregate}. */
public GroupKey groupKey(ImmutableBitSet groupSet, boolean indicator,
ImmutableList groupSets) {
if (groupSet.length() > peek().getRowType().getFieldCount()) {
throw new IllegalArgumentException("out of bounds: " + groupSet);
}
if (groupSets == null) {
groupSets = ImmutableList.of(groupSet);
}
final ImmutableList nodes =
fields(ImmutableIntList.of(groupSet.toArray()));
final List> nodeLists =
Lists.transform(groupSets,
new Function>() {
public ImmutableList apply(ImmutableBitSet input) {
return fields(ImmutableIntList.of(input.toArray()));
}
});
return groupKey(nodes, indicator, nodeLists);
}
/** Creates a call to an aggregate function. */
public AggCall aggregateCall(SqlAggFunction aggFunction, boolean distinct,
RexNode filter, String alias, RexNode... operands) {
return aggregateCall(aggFunction, distinct, filter, alias,
ImmutableList.copyOf(operands));
}
/** Creates a call to an aggregate function. */
public AggCall aggregateCall(SqlAggFunction aggFunction, boolean distinct,
RexNode filter, String alias, Iterable operands) {
if (filter != null) {
if (filter.getType().getSqlTypeName() != SqlTypeName.BOOLEAN) {
throw Static.RESOURCE.filterMustBeBoolean().ex();
}
if (filter.getType().isNullable()) {
filter = call(SqlStdOperatorTable.IS_TRUE, filter);
}
}
return new AggCallImpl(aggFunction, distinct, filter, alias,
ImmutableList.copyOf(operands));
}
/** Creates a call to the COUNT aggregate function. */
public AggCall count(boolean distinct, String alias, RexNode... operands) {
return aggregateCall(SqlStdOperatorTable.COUNT, distinct, null, alias,
operands);
}
/** Creates a call to the COUNT(*) aggregate function. */
public AggCall countStar(String alias) {
return aggregateCall(SqlStdOperatorTable.COUNT, false, null, alias);
}
/** Creates a call to the SUM aggregate function. */
public AggCall sum(boolean distinct, String alias, RexNode operand) {
return aggregateCall(SqlStdOperatorTable.SUM, distinct, null, alias,
operand);
}
/** Creates a call to the AVG aggregate function. */
public AggCall avg(boolean distinct, String alias, RexNode operand) {
return aggregateCall(
SqlStdOperatorTable.AVG, distinct, null, alias, operand);
}
/** Creates a call to the MIN aggregate function. */
public AggCall min(String alias, RexNode operand) {
return aggregateCall(SqlStdOperatorTable.MIN, false, null, alias, operand);
}
/** Creates a call to the MAX aggregate function. */
public AggCall max(String alias, RexNode operand) {
return aggregateCall(SqlStdOperatorTable.MAX, false, null, alias, operand);
}
// Methods that create relational expressions
/** Creates a {@link org.apache.calcite.rel.core.TableScan} of the table
* with a given name.
*
* Throws if the table does not exist.
*
*
Returns this builder.
*
* @param tableNames Name of table (can optionally be qualified)
*/
public HiveSubQRemoveRelBuilder scan(Iterable tableNames) {
final List names = ImmutableList.copyOf(tableNames);
final RelOptTable relOptTable = relOptSchema.getTableForMember(names);
if (relOptTable == null) {
throw Static.RESOURCE.tableNotFound(Joiner.on(".").join(names)).ex();
}
final RelNode scan = scanFactory.createScan(cluster, relOptTable);
push(scan);
return this;
}
/** Creates a {@link org.apache.calcite.rel.core.TableScan} of the table
* with a given name.
*
* Throws if the table does not exist.
*
*
Returns this builder.
*
* @param tableNames Name of table (can optionally be qualified)
*/
public HiveSubQRemoveRelBuilder scan(String... tableNames) {
return scan(ImmutableList.copyOf(tableNames));
}
/** Creates a {@link org.apache.calcite.rel.core.Filter} of an array of
* predicates.
*
*
The predicates are combined using AND,
* and optimized in a similar way to the {@link #and} method.
* If the result is TRUE no filter is created. */
public HiveSubQRemoveRelBuilder filter(RexNode... predicates) {
return filter(ImmutableList.copyOf(predicates));
}
/** Creates a {@link org.apache.calcite.rel.core.Filter} of a list of
* predicates.
*
*
The predicates are combined using AND,
* and optimized in a similar way to the {@link #and} method.
* If the result is TRUE no filter is created. */
public HiveSubQRemoveRelBuilder filter(Iterable predicates) {
final RexNode x = RexUtil.simplifyAnds(cluster.getRexBuilder(), predicates, true);
if (x.isAlwaysFalse()) {
return empty();
}
if (!x.isAlwaysTrue()) {
final Frame frame = stack.pop();
final RelNode filter = filterFactory.createFilter(frame.rel, x);
stack.push(new Frame(filter, frame.right));
}
return this;
}
/** Creates a {@link org.apache.calcite.rel.core.Project} of the given list
* of expressions.
*
*
Infers names as would {@link #project(Iterable, Iterable)} if all
* suggested names were null.
*
* @param nodes Expressions
*/
public HiveSubQRemoveRelBuilder project(Iterable nodes) {
return project(nodes, ImmutableList.of());
}
/** Creates a {@link org.apache.calcite.rel.core.Project} of the given list
* of expressions and field names.
*
* Infers names as would {@link #project(Iterable, Iterable)} if all
* suggested names were null.
*
* @param nodes Expressions
* @param fieldNames field names for expressions
*/
public HiveSubQRemoveRelBuilder project(Iterable nodes,
Iterable fieldNames) {
return project(nodes, fieldNames, false);
}
/** Creates a {@link org.apache.calcite.rel.core.Project} of the given list
* of expressions, using the given names.
*
* Names are deduced as follows:
*
* - If the length of {@code fieldNames} is greater than the index of
* the current entry in {@code nodes}, and the entry in
* {@code fieldNames} is not null, uses it; otherwise
*
- If an expression projects an input field,
* or is a cast an input field,
* uses the input field name; otherwise
*
- If an expression is a call to
* {@link org.apache.calcite.sql.fun.SqlStdOperatorTable#AS}
* (see {@link #alias}), removes the call but uses the intended alias.
*
*
* After the field names have been inferred, makes the
* field names unique by appending numeric suffixes.
*
* @param nodes Expressions
* @param fieldNames Suggested field names
* @param force create project even if it is identity
*/
public HiveSubQRemoveRelBuilder project(
Iterable nodes,
Iterable fieldNames,
boolean force) {
final List names = new ArrayList<>();
final List exprList = Lists.newArrayList(nodes);
final Iterator nameIterator = fieldNames.iterator();
for (RexNode node : nodes) {
final String name = nameIterator.hasNext() ? nameIterator.next() : null;
final String name2 = inferAlias(exprList, node);
names.add(Util.first(name, name2));
}
final RelDataType inputRowType = peek().getRowType();
if (!force && RexUtil.isIdentity(exprList, inputRowType)) {
if (names.equals(inputRowType.getFieldNames())) {
// Do not create an identity project if it does not rename any fields
return this;
} else {
// create "virtual" row type for project only rename fields
final Frame frame = stack.pop();
final RelDataType rowType =
RexUtil.createStructType(cluster.getTypeFactory(), exprList,
names, SqlValidatorUtil.F_SUGGESTER);
stack.push(
new Frame(frame.rel,
ImmutableList.of(Pair.of(frame.right.get(0).left, rowType))));
return this;
}
}
final RelNode project =
projectFactory.createProject(build(), ImmutableList.copyOf(exprList),
names);
push(project);
return this;
}
/** Creates a {@link org.apache.calcite.rel.core.Project} of the given
* expressions. */
public HiveSubQRemoveRelBuilder project(RexNode... nodes) {
return project(ImmutableList.copyOf(nodes));
}
/** Infers the alias of an expression.
*
* If the expression was created by {@link #alias}, replaces the expression
* in the project list.
*/
private String inferAlias(List exprList, RexNode expr) {
switch (expr.getKind()) {
case INPUT_REF:
final RexInputRef ref = (RexInputRef) expr;
return peek(0).getRowType().getFieldNames().get(ref.getIndex());
case CAST:
return inferAlias(exprList, ((RexCall) expr).getOperands().get(0));
case AS:
final RexCall call = (RexCall) expr;
for (;;) {
final int i = exprList.indexOf(expr);
if (i < 0) {
break;
}
exprList.set(i, call.getOperands().get(0));
}
return ((NlsString) ((RexLiteral) call.getOperands().get(1)).getValue())
.getValue();
default:
return null;
}
}
/** Creates an {@link org.apache.calcite.rel.core.Aggregate} that makes the
* relational expression distinct on all fields. */
public HiveSubQRemoveRelBuilder distinct() {
return aggregate(groupKey(fields()));
}
/** Creates an {@link org.apache.calcite.rel.core.Aggregate} with an array of
* calls. */
public HiveSubQRemoveRelBuilder aggregate(GroupKey groupKey, AggCall... aggCalls) {
return aggregate(groupKey, ImmutableList.copyOf(aggCalls));
}
/** Creates an {@link org.apache.calcite.rel.core.Aggregate} with a list of
* calls. */
public HiveSubQRemoveRelBuilder aggregate(GroupKey groupKey, Iterable aggCalls) {
final RelDataType inputRowType = peek().getRowType();
final List extraNodes = projects(inputRowType);
final GroupKeyImpl groupKey_ = (GroupKeyImpl) groupKey;
final ImmutableBitSet groupSet =
ImmutableBitSet.of(registerExpressions(extraNodes, groupKey_.nodes));
final ImmutableList groupSets;
if (groupKey_.nodeLists != null) {
final int sizeBefore = extraNodes.size();
final SortedSet groupSetSet =
new TreeSet<>(ImmutableBitSet.ORDERING);
for (ImmutableList nodeList : groupKey_.nodeLists) {
final ImmutableBitSet groupSet2 =
ImmutableBitSet.of(registerExpressions(extraNodes, nodeList));
if (!groupSet.contains(groupSet2)) {
throw new IllegalArgumentException("group set element " + nodeList
+ " must be a subset of group key");
}
groupSetSet.add(groupSet2);
}
groupSets = ImmutableList.copyOf(groupSetSet);
if (extraNodes.size() > sizeBefore) {
throw new IllegalArgumentException(
"group sets contained expressions not in group key: "
+ extraNodes.subList(sizeBefore, extraNodes.size()));
}
} else {
groupSets = ImmutableList.of(groupSet);
}
for (AggCall aggCall : aggCalls) {
if (aggCall instanceof AggCallImpl) {
final AggCallImpl aggCall1 = (AggCallImpl) aggCall;
registerExpressions(extraNodes, aggCall1.operands);
if (aggCall1.filter != null) {
registerExpression(extraNodes, aggCall1.filter);
}
}
}
if (extraNodes.size() > inputRowType.getFieldCount()) {
project(extraNodes);
}
final RelNode r = build();
final List aggregateCalls = new ArrayList<>();
for (AggCall aggCall : aggCalls) {
final AggregateCall aggregateCall;
if (aggCall instanceof AggCallImpl) {
final AggCallImpl aggCall1 = (AggCallImpl) aggCall;
final List args = registerExpressions(extraNodes, aggCall1.operands);
final int filterArg = aggCall1.filter == null ? -1
: registerExpression(extraNodes, aggCall1.filter);
aggregateCall =
AggregateCall.create(aggCall1.aggFunction, aggCall1.distinct, args,
filterArg, groupSet.cardinality(), r, null, aggCall1.alias);
} else {
aggregateCall = ((AggCallImpl2) aggCall).aggregateCall;
}
aggregateCalls.add(aggregateCall);
}
assert ImmutableBitSet.ORDERING.isStrictlyOrdered(groupSets) : groupSets;
for (ImmutableBitSet set : groupSets) {
assert groupSet.contains(set);
}
RelNode aggregate = aggregateFactory.createAggregate(r,
groupKey_.indicator, groupSet, groupSets, aggregateCalls);
push(aggregate);
return this;
}
private List projects(RelDataType inputRowType) {
final List exprList = new ArrayList<>();
for (RelDataTypeField field : inputRowType.getFieldList()) {
final RexBuilder rexBuilder = cluster.getRexBuilder();
exprList.add(rexBuilder.makeInputRef(field.getType(), field.getIndex()));
}
return exprList;
}
private static int registerExpression(List exprList, RexNode node) {
int i = exprList.indexOf(node);
if (i < 0) {
i = exprList.size();
exprList.add(node);
}
return i;
}
private static List registerExpressions(List extraNodes,
Iterable nodes) {
final List builder = new ArrayList<>();
for (RexNode node : nodes) {
builder.add(registerExpression(extraNodes, node));
}
return builder;
}
private HiveSubQRemoveRelBuilder setOp(boolean all, SqlKind kind, int n) {
List inputs = new LinkedList<>();
for (int i = 0; i < n; i++) {
inputs.add(0, build());
}
switch (kind) {
case UNION:
case INTERSECT:
case EXCEPT:
if (n < 1) {
throw new IllegalArgumentException(
"bad INTERSECT/UNION/EXCEPT input count");
}
break;
default:
throw new AssertionError("bad setOp " + kind);
}
switch (n) {
case 1:
return push(inputs.get(0));
default:
return push(setOpFactory.createSetOp(kind, inputs, all));
}
}
/** Creates a {@link org.apache.calcite.rel.core.Union} of the two most recent
* relational expressions on the stack.
*
* @param all Whether to create UNION ALL
*/
public HiveSubQRemoveRelBuilder union(boolean all) {
return union(all, 2);
}
/** Creates a {@link org.apache.calcite.rel.core.Union} of the {@code n}
* most recent relational expressions on the stack.
*
* @param all Whether to create UNION ALL
* @param n Number of inputs to the UNION operator
*/
public HiveSubQRemoveRelBuilder union(boolean all, int n) {
return setOp(all, SqlKind.UNION, n);
}
/** Creates an {@link org.apache.calcite.rel.core.Intersect} of the two most
* recent relational expressions on the stack.
*
* @param all Whether to create INTERSECT ALL
*/
public HiveSubQRemoveRelBuilder intersect(boolean all) {
return intersect(all, 2);
}
/** Creates an {@link org.apache.calcite.rel.core.Intersect} of the {@code n}
* most recent relational expressions on the stack.
*
* @param all Whether to create INTERSECT ALL
* @param n Number of inputs to the INTERSECT operator
*/
public HiveSubQRemoveRelBuilder intersect(boolean all, int n) {
return setOp(all, SqlKind.INTERSECT, n);
}
/** Creates a {@link org.apache.calcite.rel.core.Minus} of the two most recent
* relational expressions on the stack.
*
* @param all Whether to create EXCEPT ALL
*/
public HiveSubQRemoveRelBuilder minus(boolean all) {
return minus(all, 2);
}
/** Creates a {@link org.apache.calcite.rel.core.Minus} of the {@code n}
* most recent relational expressions on the stack.
*
* @param all Whether to create EXCEPT ALL
*/
public HiveSubQRemoveRelBuilder minus(boolean all, int n) {
return setOp(all, SqlKind.EXCEPT, n);
}
/** Creates a {@link org.apache.calcite.rel.core.Join}. */
public HiveSubQRemoveRelBuilder join(JoinRelType joinType, RexNode condition0,
RexNode... conditions) {
return join(joinType, Lists.asList(condition0, conditions));
}
/** Creates a {@link org.apache.calcite.rel.core.Join} with multiple
* conditions. */
public HiveSubQRemoveRelBuilder join(JoinRelType joinType,
Iterable conditions) {
return join(joinType, and(conditions),
ImmutableSet.of());
}
public HiveSubQRemoveRelBuilder join(JoinRelType joinType, RexNode condition) {
return join(joinType, condition, ImmutableSet.of());
}
/** Creates a correlation variable for the current input, and writes it into
* a Holder. */
public HiveSubQRemoveRelBuilder variable(Holder v) {
v.set((RexCorrelVariable)
getRexBuilder().makeCorrel(peek().getRowType(),
cluster.createCorrel()));
return this;
}
/** Returns a reference to a given field of a record-valued expression. */
public RexNode field(RexNode e, String name) {
return getRexBuilder().makeFieldAccess(e, name, false);
}
public HiveSubQRemoveRelBuilder join(JoinRelType joinType, RexNode condition,
Set variablesSet, boolean createSemiJoin) {
Frame right = stack.pop();
final Frame left = stack.pop();
final RelNode join;
final boolean correlate = variablesSet.size() == 1;
RexNode postCondition = literal(true);
if (correlate) {
final CorrelationId id = Iterables.getOnlyElement(variablesSet);
final ImmutableBitSet requiredColumns =
RelOptUtil.correlationColumns(id, right.rel);
if (!RelOptUtil.notContainsCorrelation(left.rel, id, Litmus.IGNORE)) {
throw new IllegalArgumentException("variable " + id
+ " must not be used by left input to correlation");
}
switch (joinType) {
case LEFT:
// Correlate does not have an ON clause.
// For a LEFT correlate, predicate must be evaluated first.
// For INNER, we can defer.
stack.push(right);
filter(condition.accept(new Shifter(left.rel, id, right.rel)));
right = stack.pop();
break;
default:
postCondition = condition;
}
if(createSemiJoin) {
join = correlateFactory.createCorrelate(left.rel, right.rel, id,
requiredColumns, SemiJoinType.SEMI);
} else {
join = correlateFactory.createCorrelate(left.rel, right.rel, id,
requiredColumns, SemiJoinType.of(joinType));
}
} else {
join = joinFactory.createJoin(left.rel, right.rel, condition,
variablesSet, joinType, false);
}
final List> pairs = new ArrayList<>();
pairs.addAll(left.right);
pairs.addAll(right.right);
stack.push(new Frame(join, ImmutableList.copyOf(pairs)));
filter(postCondition);
return this;
}
/** Creates a {@link org.apache.calcite.rel.core.Join} with correlating
* variables. */
public HiveSubQRemoveRelBuilder join(JoinRelType joinType, RexNode condition,
Set variablesSet) {
return join(joinType, condition, variablesSet, false);
}
/** Creates a {@link org.apache.calcite.rel.core.Join} using USING syntax.
*
* For each of the field names, both left and right inputs must have a
* field of that name. Constructs a join condition that the left and right
* fields are equal.
*
* @param joinType Join type
* @param fieldNames Field names
*/
public HiveSubQRemoveRelBuilder join(JoinRelType joinType, String... fieldNames) {
final List conditions = new ArrayList<>();
for (String fieldName : fieldNames) {
conditions.add(
call(SqlStdOperatorTable.EQUALS,
field(2, 0, fieldName),
field(2, 1, fieldName)));
}
return join(joinType, conditions);
}
/** Creates a {@link org.apache.calcite.rel.core.SemiJoin}. */
public HiveSubQRemoveRelBuilder semiJoin(Iterable conditions) {
final Frame right = stack.pop();
final Frame left = stack.pop();
final RelNode semiJoin =
semiJoinFactory.createSemiJoin(left.rel, right.rel, and(conditions));
stack.push(new Frame(semiJoin, left.right));
return this;
}
/** Creates a {@link org.apache.calcite.rel.core.SemiJoin}. */
public HiveSubQRemoveRelBuilder semiJoin(RexNode... conditions) {
return semiJoin(ImmutableList.copyOf(conditions));
}
/** Assigns a table alias to the top entry on the stack. */
public HiveSubQRemoveRelBuilder as(String alias) {
final Frame pair = stack.pop();
stack.push(
new Frame(pair.rel,
ImmutableList.of(Pair.of(alias, pair.right.get(0).right))));
return this;
}
/** Creates a {@link Values}.
*
* The {@code values} array must have the same number of entries as
* {@code fieldNames}, or an integer multiple if you wish to create multiple
* rows.
*
*
If there are zero rows, or if all values of a any column are
* null, this method cannot deduce the type of columns. For these cases,
* call {@link #values(Iterable, RelDataType)}.
*
* @param fieldNames Field names
* @param values Values
*/
public HiveSubQRemoveRelBuilder values(String[] fieldNames, Object... values) {
if (fieldNames == null
|| fieldNames.length == 0
|| values.length % fieldNames.length != 0
|| values.length < fieldNames.length) {
throw new IllegalArgumentException(
"Value count must be a positive multiple of field count");
}
final int rowCount = values.length / fieldNames.length;
for (Ord fieldName : Ord.zip(fieldNames)) {
if (allNull(values, fieldName.i, fieldNames.length)) {
throw new IllegalArgumentException("All values of field '" + fieldName.e
+ "' are null; cannot deduce type");
}
}
final ImmutableList> tupleList =
tupleList(fieldNames.length, values);
final RelDataTypeFactory.FieldInfoBuilder rowTypeBuilder =
cluster.getTypeFactory().builder();
for (final Ord fieldName : Ord.zip(fieldNames)) {
final String name =
fieldName.e != null ? fieldName.e : "expr$" + fieldName.i;
final RelDataType type = cluster.getTypeFactory().leastRestrictive(
new AbstractList() {
public RelDataType get(int index) {
return tupleList.get(index).get(fieldName.i).getType();
}
public int size() {
return rowCount;
}
});
rowTypeBuilder.add(name, type);
}
final RelDataType rowType = rowTypeBuilder.build();
return values(tupleList, rowType);
}
private ImmutableList> tupleList(int columnCount,
Object[] values) {
final ImmutableList.Builder> listBuilder =
ImmutableList.builder();
final List valueList = new ArrayList<>();
for (int i = 0; i < values.length; i++) {
Object value = values[i];
valueList.add((RexLiteral) literal(value));
if ((i + 1) % columnCount == 0) {
listBuilder.add(ImmutableList.copyOf(valueList));
valueList.clear();
}
}
return listBuilder.build();
}
/** Returns whether all values for a given column are null. */
private boolean allNull(Object[] values, int column, int columnCount) {
for (int i = column; i < values.length; i += columnCount) {
if (values[i] != null) {
return false;
}
}
return true;
}
/**
* Empty relationship can be expressed in many different ways, e.g.,
* filter(cond=false), empty LogicalValues(), etc. Calcite default implementation
* uses empty LogicalValues(); however, currently there is not an equivalent to
* this expression in Hive. Thus, we use limit 0, since Hive already includes
* optimizations that will do early pruning of the result tree when it is found,
* e.g., GlobalLimitOptimizer.
*/
public HiveSubQRemoveRelBuilder empty() {
final RelNode input = build();
final RelNode sort = HiveRelFactories.HIVE_SORT_FACTORY.createSort(
input, RelCollations.of(), null, literal(0));
return this.push(sort);
}
/** Creates a {@link Values} with a specified row type.
*
* This method can handle cases that {@link #values(String[], Object...)}
* cannot, such as all values of a column being null, or there being zero
* rows.
*
* @param rowType Row type
* @param columnValues Values
*/
public HiveSubQRemoveRelBuilder values(RelDataType rowType, Object... columnValues) {
final ImmutableList> tupleList =
tupleList(rowType.getFieldCount(), columnValues);
RelNode values = valuesFactory.createValues(cluster, rowType,
ImmutableList.copyOf(tupleList));
push(values);
return this;
}
/** Creates a {@link Values} with a specified row type.
*
* This method can handle cases that {@link #values(String[], Object...)}
* cannot, such as all values of a column being null, or there being zero
* rows.
*
* @param tupleList Tuple list
* @param rowType Row type
*/
public HiveSubQRemoveRelBuilder values(Iterable> tupleList,
RelDataType rowType) {
RelNode values =
valuesFactory.createValues(cluster, rowType, copy(tupleList));
push(values);
return this;
}
/** Creates a {@link Values} with a specified row type and
* zero rows.
*
* @param rowType Row type
*/
public HiveSubQRemoveRelBuilder values(RelDataType rowType) {
return values(ImmutableList.>of(), rowType);
}
/** Converts an iterable of lists into an immutable list of immutable lists
* with the same contents. Returns the same object if possible. */
private static ImmutableList> copy(Iterable> tupleList) {
final ImmutableList.Builder> builder =
ImmutableList.builder();
int changeCount = 0;
for (List literals : tupleList) {
final ImmutableList literals2 =
ImmutableList.copyOf(literals);
builder.add(literals2);
if (literals != literals2) {
++changeCount;
}
}
if (changeCount == 0) {
// don't make a copy if we don't have to
//noinspection unchecked
return (ImmutableList>) tupleList;
}
return builder.build();
}
/** Creates a limit without a sort. */
public HiveSubQRemoveRelBuilder limit(int offset, int fetch) {
return sortLimit(offset, fetch, ImmutableList.of());
}
/** Creates a {@link Sort} by field ordinals.
*
* Negative fields mean descending: -1 means field(0) descending,
* -2 means field(1) descending, etc.
*/
public HiveSubQRemoveRelBuilder sort(int... fields) {
final ImmutableList.Builder builder = ImmutableList.builder();
for (int field : fields) {
builder.add(field < 0 ? desc(field(-field - 1)) : field(field));
}
return sortLimit(-1, -1, builder.build());
}
/** Creates a {@link Sort} by expressions. */
public HiveSubQRemoveRelBuilder sort(RexNode... nodes) {
return sortLimit(-1, -1, ImmutableList.copyOf(nodes));
}
/** Creates a {@link Sort} by expressions. */
public HiveSubQRemoveRelBuilder sort(Iterable nodes) {
return sortLimit(-1, -1, nodes);
}
/** Creates a {@link Sort} by expressions, with limit and offset. */
public HiveSubQRemoveRelBuilder sortLimit(int offset, int fetch, RexNode... nodes) {
return sortLimit(offset, fetch, ImmutableList.copyOf(nodes));
}
/** Creates a {@link Sort} by a list of expressions, with limit and offset.
*
* @param offset Number of rows to skip; non-positive means don't skip any
* @param fetch Maximum number of rows to fetch; negative means no limit
* @param nodes Sort expressions
*/
public HiveSubQRemoveRelBuilder sortLimit(int offset, int fetch,
Iterable nodes) {
final List fieldCollations = new ArrayList<>();
final RelDataType inputRowType = peek().getRowType();
final List extraNodes = projects(inputRowType);
final List originalExtraNodes = ImmutableList.copyOf(extraNodes);
for (RexNode node : nodes) {
fieldCollations.add(
collation(node, RelFieldCollation.Direction.ASCENDING, null,
extraNodes));
}
final RexNode offsetNode = offset <= 0 ? null : literal(offset);
final RexNode fetchNode = fetch < 0 ? null : literal(fetch);
if (offsetNode == null && fetch == 0) {
return empty();
}
if (offsetNode == null && fetchNode == null && fieldCollations.isEmpty()) {
return this; // sort is trivial
}
final boolean addedFields = extraNodes.size() > originalExtraNodes.size();
if (fieldCollations.isEmpty()) {
assert !addedFields;
RelNode top = peek();
if (top instanceof Sort) {
final Sort sort2 = (Sort) top;
if (sort2.offset == null && sort2.fetch == null) {
stack.pop();
push(sort2.getInput());
final RelNode sort =
sortFactory.createSort(build(), sort2.collation,
offsetNode, fetchNode);
push(sort);
return this;
}
}
if (top instanceof Project) {
final Project project = (Project) top;
if (project.getInput() instanceof Sort) {
final Sort sort2 = (Sort) project.getInput();
if (sort2.offset == null && sort2.fetch == null) {
stack.pop();
push(sort2.getInput());
final RelNode sort =
sortFactory.createSort(build(), sort2.collation,
offsetNode, fetchNode);
push(sort);
project(project.getProjects());
return this;
}
}
}
}
if (addedFields) {
project(extraNodes);
}
final RelNode sort =
sortFactory.createSort(build(), RelCollations.of(fieldCollations),
offsetNode, fetchNode);
push(sort);
if (addedFields) {
project(originalExtraNodes);
}
return this;
}
private static RelFieldCollation collation(RexNode node,
RelFieldCollation.Direction direction,
RelFieldCollation.NullDirection nullDirection,
List extraNodes) {
switch (node.getKind()) {
case INPUT_REF:
return new RelFieldCollation(((RexInputRef) node).getIndex(), direction,
Util.first(nullDirection, direction.defaultNullDirection()));
case DESCENDING:
return collation(((RexCall) node).getOperands().get(0),
RelFieldCollation.Direction.DESCENDING,
nullDirection, extraNodes);
case NULLS_FIRST:
return collation(((RexCall) node).getOperands().get(0), direction,
RelFieldCollation.NullDirection.FIRST, extraNodes);
case NULLS_LAST:
return collation(((RexCall) node).getOperands().get(0), direction,
RelFieldCollation.NullDirection.LAST, extraNodes);
default:
final int fieldIndex = extraNodes.size();
extraNodes.add(node);
return new RelFieldCollation(fieldIndex, direction,
Util.first(nullDirection, direction.defaultNullDirection()));
}
}
/**
* Creates a projection that converts the current relational expression's
* output to a desired row type.
*
* @param castRowType row type after cast
* @param rename if true, use field names from castRowType; if false,
* preserve field names from rel
*/
public HiveSubQRemoveRelBuilder convert(RelDataType castRowType, boolean rename) {
final RelNode r = build();
final RelNode r2 =
RelOptUtil.createCastRel(r, castRowType, rename, projectFactory);
push(r2);
return this;
}
public HiveSubQRemoveRelBuilder permute(Mapping mapping) {
assert mapping.getMappingType().isSingleSource();
assert mapping.getMappingType().isMandatorySource();
if (mapping.isIdentity()) {
return this;
}
final List exprList = Lists.newArrayList();
for (int i = 0; i < mapping.getTargetCount(); i++) {
exprList.add(field(mapping.getSource(i)));
}
return project(exprList);
}
public HiveSubQRemoveRelBuilder aggregate(GroupKey groupKey,
List aggregateCalls) {
return aggregate(groupKey,
Lists.transform(
aggregateCalls, new Function() {
public AggCall apply(AggregateCall input) {
return new AggCallImpl2(input);
}
}));
}
/** Clears the stack.
*
* The builder's state is now the same as when it was created. */
public void clear() {
stack.clear();
}
protected String getAlias() {
final Frame frame = stack.peek();
return frame.right.size() == 1
? frame.right.get(0).left
: null;
}
/** Information necessary to create a call to an aggregate function.
*
* @see RelBuilder#aggregateCall */
public interface AggCall {
}
/** Information necessary to create the GROUP BY clause of an Aggregate.
*
* @see RelBuilder#groupKey */
public interface GroupKey {
/** Assigns an alias to this group key.
*
*
Used to assign field names in the {@code group} operation. */
GroupKey alias(String alias);
}
/** Implementation of {@link RelBuilder.GroupKey}. */
protected static class GroupKeyImpl implements GroupKey {
private final ImmutableList nodes;
private final boolean indicator;
private final ImmutableList> nodeLists;
private final String alias;
GroupKeyImpl(ImmutableList nodes, boolean indicator,
ImmutableList> nodeLists, String alias) {
this.nodes = Preconditions.checkNotNull(nodes);
this.indicator = indicator;
this.nodeLists = nodeLists;
this.alias = alias;
}
@Override public String toString() {
return alias == null ? nodes.toString() : nodes + " as " + alias;
}
public GroupKey alias(String alias) {
return Objects.equals(this.alias, alias)
? this
: new GroupKeyImpl(nodes, indicator, nodeLists, alias);
}
}
/** Implementation of {@link RelBuilder.AggCall}. */
private static class AggCallImpl implements AggCall {
private final SqlAggFunction aggFunction;
private final boolean distinct;
private final RexNode filter;
private final String alias;
private final ImmutableList operands;
AggCallImpl(SqlAggFunction aggFunction, boolean distinct, RexNode filter,
String alias, ImmutableList operands) {
this.aggFunction = aggFunction;
this.distinct = distinct;
this.filter = filter;
this.alias = alias;
this.operands = operands;
}
}
/** Implementation of {@link RelBuilder.AggCall} that wraps an
* {@link AggregateCall}. */
private static class AggCallImpl2 implements AggCall {
private final AggregateCall aggregateCall;
AggCallImpl2(AggregateCall aggregateCall) {
this.aggregateCall = Preconditions.checkNotNull(aggregateCall);
}
}
/** Builder stack frame.
*
* Describes a previously created relational expression and
* information about how table aliases map into its row type. */
private static final class Frame {
static final Function, List> FN =
new Function, List>() {
public List apply(Pair input) {
return input.right.getFieldList();
}
};
private final RelNode rel;
private final ImmutableList> right;
private Frame(RelNode rel, ImmutableList> pairs) {
this.rel = rel;
this.right = pairs;
}
private Frame(RelNode rel) {
this(rel, ImmutableList.of(Pair.of(deriveAlias(rel), rel.getRowType())));
}
private static String deriveAlias(RelNode rel) {
if (rel instanceof TableScan) {
final List names = rel.getTable().getQualifiedName();
if (!names.isEmpty()) {
return Util.last(names);
}
}
return null;
}
List fields() {
return CompositeList.ofCopy(Iterables.transform(right, FN));
}
}
/** Shuttle that shifts a predicate's inputs to the left, replacing early
* ones with references to a
* {@link org.apache.calcite.rex.RexCorrelVariable}. */
private class Shifter extends RexShuttle {
private final RelNode left;
private final CorrelationId id;
private final RelNode right;
Shifter(RelNode left, CorrelationId id, RelNode right) {
this.left = left;
this.id = id;
this.right = right;
}
public RexNode visitInputRef(RexInputRef inputRef) {
final RelDataType leftRowType = left.getRowType();
final RexBuilder rexBuilder = getRexBuilder();
final int leftCount = leftRowType.getFieldCount();
if (inputRef.getIndex() < leftCount) {
final RexNode v = rexBuilder.makeCorrel(leftRowType, id);
return rexBuilder.makeFieldAccess(v, inputRef.getIndex());
} else {
return rexBuilder.makeInputRef(right, inputRef.getIndex() - leftCount);
}
}
}
}
// End RelBuilder.java