Package org.apache.calcite.tools

Class RelBuilder

java.lang.Object

org.apache.calcite.tools.RelBuilder

Direct Known Subclasses:

PigRelBuilder, PigRelBuilder

@Enclosing
public class RelBuilder
extends Object

Builder for relational expressions.

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.

RelBuilder uses factories to create relational expressions. By default, it uses the default factories, which create logical relational expressions (LogicalFilter, LogicalProject and so forth). But you could override those factories so that, say, filter creates instead a HiveFilter.

It is not thread-safe.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	RelBuilder.AggCall	Information necessary to create a call to an aggregate function.
static interface	RelBuilder.Config	Configuration of RelBuilder.
static interface	RelBuilder.GroupKey	Information necessary to create the GROUP BY clause of an Aggregate.
static interface	RelBuilder.OverCall	Call to a windowed aggregate function.

Field Summary

Fields

Modifier and Type	Field	Description
protected final RelOptCluster	cluster
protected final @Nullable RelOptSchema	relOptSchema

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	RelBuilder(@Nullable Context context, RelOptCluster cluster, @Nullable RelOptSchema relOptSchema)

Method Summary

Modifier and Type	Method	Description
RelBuilder	adoptConvention(Convention convention)	Returns new RelBuilder that adopts the convention provided.
RelBuilder	aggregate(RelBuilder.GroupKey groupKey, Iterable<RelBuilder.AggCall> aggCalls)	Creates an Aggregate with multiple calls.
RelBuilder	aggregate(RelBuilder.GroupKey groupKey, List<AggregateCall> aggregateCalls)	Creates an Aggregate with an array of AggregateCalls.
RelBuilder	aggregate(RelBuilder.GroupKey groupKey, RelBuilder.AggCall... aggCalls)	Creates an Aggregate with an array of calls.
RelBuilder.AggCall	aggregateCall(AggregateCall a)	Creates a call to an aggregate function as a copy of an AggregateCall.
RelBuilder.AggCall	aggregateCall(AggregateCall a, Mapping mapping)	Creates a call to an aggregate function as a copy of an AggregateCall, applying a mapping.
protected RelBuilder.AggCall	aggregateCall(SqlAggFunction aggFunction, boolean distinct, boolean approximate, boolean ignoreNulls, @Nullable RexNode filter, @Nullable com.google.common.collect.ImmutableList<RexNode> distinctKeys, com.google.common.collect.ImmutableList<RexNode> orderKeys, @Nullable String alias, com.google.common.collect.ImmutableList<RexNode> operands)	Creates a call to an aggregate function with all applicable operands.
RelBuilder.AggCall	aggregateCall(SqlAggFunction aggFunction, boolean distinct, boolean approximate, RexNode filter, @Nullable String alias, Iterable<? extends RexNode> operands)	Deprecated.
RelBuilder.AggCall	aggregateCall(SqlAggFunction aggFunction, boolean distinct, boolean approximate, RexNode filter, @Nullable String alias, RexNode... operands)	Deprecated.
RelBuilder.AggCall	aggregateCall(SqlAggFunction aggFunction, boolean distinct, RexNode filter, @Nullable String alias, Iterable<? extends RexNode> operands)	Deprecated.
RelBuilder.AggCall	aggregateCall(SqlAggFunction aggFunction, boolean distinct, RexNode filter, @Nullable String alias, RexNode... operands)	Deprecated.
RelBuilder.AggCall	aggregateCall(SqlAggFunction aggFunction, Iterable<? extends RexNode> operands)	Creates a call to an aggregate function.
RelBuilder.AggCall	aggregateCall(SqlAggFunction aggFunction, RexNode... operands)	Creates a call to an aggregate function.
RexNode	alias(RexNode expr, @Nullable String alias)	Returns an expression wrapped in an alias.
RexNode	all(RexNode node, SqlOperator op, Function<RelBuilder,RelNode> f)	Creates an ALL predicate.
RexNode	and(Iterable<? extends RexNode> operands)	Creates an AND.
RexNode	and(RexNode... operands)	Creates an AND.
RelBuilder	antiJoin(Iterable<? extends RexNode> conditions)	Creates an anti-join.
RelBuilder	antiJoin(RexNode... conditions)	Creates an anti-join.
RexSubQuery	arrayQuery(Function<RelBuilder,RelNode> f)	Creates an ARRAY sub-query.
RelBuilder	as(String alias)	Assigns a table alias to the top entry on the stack.
RelBuilder.AggCall	avg(boolean distinct, @Nullable String alias, RexNode operand)	Creates a call to the AVG aggregate function, optionally distinct and with an alias.
RelBuilder.AggCall	avg(RexNode operand)	Creates a call to the AVG aggregate function.
RexNode	between(RexNode arg, RexNode lower, RexNode upper)	Creates a BETWEEN.
RelNode	build()	Returns the final relational expression.
RexNode	call(SqlOperator operator, Iterable<? extends RexNode> operands)	Creates a call to a scalar operator.
RexNode	call(SqlOperator operator, RexNode... operands)	Creates a call to a scalar operator.
RexNode	cast(RexNode expr, SqlTypeName typeName)	Creates an expression that casts an expression to a given type.
RexNode	cast(RexNode expr, SqlTypeName typeName, int precision)	Creates an expression that casts an expression to a type with a given name and precision or length.
RexNode	cast(RexNode expr, SqlTypeName typeName, int precision, int scale)	Creates an expression that casts an expression to a type with a given name, precision and scale.
void	clear()	Clears the stack.
RelBuilder	convert(RelDataType castRowType, boolean rename)	Creates a projection that converts the current relational expression's output to a desired row type.
RelBuilder	correlate(JoinRelType joinType, CorrelationId correlationId, Iterable<? extends RexNode> requiredFields)	Creates a Correlate with a CorrelationId and a list of fields that are used by correlation.
RelBuilder	correlate(JoinRelType joinType, CorrelationId correlationId, RexNode... requiredFields)	Creates a Correlate with a CorrelationId and an array of fields that are used by correlation.
RelBuilder.AggCall	count(boolean distinct, @Nullable String alias, Iterable<? extends RexNode> operands)	Creates a call to the COUNT aggregate function, optionally distinct and with an alias.
RelBuilder.AggCall	count(boolean distinct, @Nullable String alias, RexNode... operands)	Creates a call to the COUNT aggregate function, optionally distinct and with an alias.
RelBuilder.AggCall	count(Iterable<? extends RexNode> operands)	Creates a call to the COUNT aggregate function.
RelBuilder.AggCall	count(RexNode... operands)	Creates a call to the COUNT aggregate function.
RelBuilder.AggCall	countStar(@Nullable String alias)	Creates a call to the COUNT(*) aggregate function.
static RelBuilder	create(FrameworkConfig config)	Creates a RelBuilder.
RexWindowBound	currentRow()	Creates a CURRENT ROW window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).
RexNode	cursor(int inputCount, int ordinal)	Creates a RexCall to the CURSOR function by ordinal.
RexNode	desc(RexNode node)	Converts a sort expression to descending.
RelBuilder	distinct()	Creates an Aggregate that makes the relational expression distinct on all fields.
RexNode	dot(RexNode node, int fieldOrdinal)	Creates an access to a field by ordinal.
RexNode	dot(RexNode node, String fieldName)	Creates an access to a field by name.
RelBuilder	empty()	Creates a relational expression that reads from an input and throws all of the rows away.
RexNode	equals(RexNode operand0, RexNode operand1)	Creates an =.
RelBuilder	exchange(RelDistribution distribution)	Creates an Exchange by distribution.
RexSubQuery	exists(Function<RelBuilder,RelNode> f)	Creates an EXISTS predicate.
RexInputRef	field(int fieldOrdinal)	Creates a reference to an input field by ordinal.
RexInputRef	field(int inputCount, int inputOrdinal, int fieldOrdinal)	Creates a reference to a field of a given input relational expression by ordinal.
RexInputRef	field(int inputCount, int inputOrdinal, String fieldName)	Creates a reference to a field of given input relational expression by name.
RexNode	field(int inputCount, String alias, String fieldName)	Creates a reference to a field which originated in a relation with the given alias.
RexInputRef	field(String fieldName)	Creates a reference to a field by name.
RexNode	field(String alias, String fieldName)	Creates a reference to a field of the current record which originated in a relation with a given alias.
RexNode	field(RexNode e, String name)	Returns a reference to a given field of a record-valued expression.
com.google.common.collect.ImmutableList<RexNode>	fields()	Returns references to the fields of the top input.
com.google.common.collect.ImmutableList<RexNode>	fields(int inputCount, int inputOrdinal)	Returns references to the fields of a given input.
com.google.common.collect.ImmutableList<RexNode>	fields(Iterable<String> fieldNames)	Returns references to fields identified by name.
com.google.common.collect.ImmutableList<RexNode>	fields(List<? extends Number> ordinals)	Returns references to fields for a given list of input ordinals.
com.google.common.collect.ImmutableList<RexNode>	fields(RelCollation collation)	Returns references to fields for a given collation.
com.google.common.collect.ImmutableList<RexNode>	fields(ImmutableBitSet ordinals)	Returns references to fields for a given bit set of input ordinals.
com.google.common.collect.ImmutableList<RexNode>	fields(Mappings.TargetMapping mapping)	Returns references to fields identified by a mapping.
RelBuilder	filter(Iterable<? extends RexNode> predicates)	Creates a Filter of a list of predicates.
RelBuilder	filter(Iterable<CorrelationId> variablesSet, Iterable<? extends RexNode> predicates)	Creates a Filter of a list of correlation variables and a list of predicates.
RelBuilder	filter(Iterable<CorrelationId> variablesSet, RexNode... predicates)	Creates a Filter of a list of correlation variables and an array of predicates.
RelBuilder	filter(RexNode... predicates)	Creates a Filter of an array of predicates.
RexWindowBound	following(RexNode bound)	Creates a bound FOLLOWING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).
RelBuilder	functionScan(SqlOperator operator, int inputCount, Iterable<? extends RexNode> operands)	Creates a TableFunctionScan.
RelBuilder	functionScan(SqlOperator operator, int inputCount, RexNode... operands)	Creates a TableFunctionScan.
RelOptCluster	getCluster()
@Nullable RelOptSchema	getRelOptSchema()
RexBuilder	getRexBuilder()	Returns the builder for RexNode expressions.
RelFactories.TableScanFactory	getScanFactory()
RelDataTypeFactory	getTypeFactory()	Returns the type factory.
RexNode	greaterThan(RexNode operand0, RexNode operand1)	Creates a >.
RexNode	greaterThanOrEqual(RexNode operand0, RexNode operand1)	Creates a >=.
RelBuilder.GroupKey	groupKey()	Creates an empty group key.
RelBuilder.GroupKey	groupKey(int... fieldOrdinals)	Creates a group key of fields identified by ordinal.
RelBuilder.GroupKey	groupKey(Iterable<? extends RexNode> nodes)	Creates a group key.
RelBuilder.GroupKey	groupKey(Iterable<? extends RexNode> nodes, boolean indicator, Iterable<? extends Iterable<? extends RexNode>> nodeLists)	Deprecated. Now that indicator is deprecated, use groupKey(Iterable, Iterable), which has the same behavior as calling this method with indicator = false.
RelBuilder.GroupKey	groupKey(Iterable<? extends RexNode> nodes, Iterable<? extends Iterable<? extends RexNode>> nodeLists)	Creates a group key with grouping sets.
RelBuilder.GroupKey	groupKey(String... fieldNames)	Creates a group key of fields identified by name.
RelBuilder.GroupKey	groupKey(RexNode... nodes)	Creates a group key.
RelBuilder.GroupKey	groupKey(ImmutableBitSet groupSet)	Creates a group key, identified by field positions in the underlying relational expression.
RelBuilder.GroupKey	groupKey(ImmutableBitSet groupSet, boolean indicator, @Nullable com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets)	Deprecated. Use groupKey(ImmutableBitSet, Iterable).
RelBuilder.GroupKey	groupKey(ImmutableBitSet groupSet, Iterable<? extends ImmutableBitSet> groupSets)	Creates a group key with grouping sets, both identified by field positions in the underlying relational expression.
RelBuilder	hints(Iterable<RelHint> hints)	Attaches multiple hints to the stack top relational expression.
RelBuilder	hints(RelHint... hints)	Attaches an array of hints to the stack top relational expression.
RexSubQuery	in(RelNode rel, Iterable<? extends RexNode> nodes)	Creates an IN predicate with a sub-query.
RexNode	in(RexNode arg, Iterable<? extends RexNode> ranges)	Creates an IN predicate with a list of values.
RexNode	in(RexNode arg, Function<RelBuilder,RelNode> f)	Creates an IN predicate with a sub-query.
RexNode	in(RexNode arg, RexNode... ranges)	Creates an IN predicate with a list of values.
RelBuilder	intersect(boolean all)	Creates an Intersect of the two most recent relational expressions on the stack.
RelBuilder	intersect(boolean all, int n)	Creates an Intersect of the n most recent relational expressions on the stack.
RexNode	isDistinctFrom(RexNode operand0, RexNode operand1)	Creates an expression equivalent to o0 IS DISTINCT FROM o1.
RexNode	isNotDistinctFrom(RexNode operand0, RexNode operand1)	Creates an expression equivalent to "o0 IS NOT DISTINCT FROM o1".
RexNode	isNotNull(RexNode operand)	Creates an IS NOT NULL.
RexNode	isNull(RexNode operand)	Creates ab IS NULL.
RelBuilder	join(JoinRelType joinType, Iterable<? extends RexNode> conditions)	Creates a Join with multiple conditions.
RelBuilder	join(JoinRelType joinType, String... fieldNames)	Creates a Join using USING syntax.
RelBuilder	join(JoinRelType joinType, RexNode condition)	Creates a Join with one condition.
RelBuilder	join(JoinRelType joinType, RexNode condition, Set<CorrelationId> variablesSet)	Creates a Join with correlating variables.
RelBuilder	join(JoinRelType joinType, RexNode condition0, RexNode... conditions)	Creates a Join with an array of conditions.
RexNode	lessThan(RexNode operand0, RexNode operand1)	Creates a <.
RexNode	lessThanOrEqual(RexNode operand0, RexNode operand1)	Creates a <=.
<R> R	let(Function<RelBuilder,R> consumer)	Performs an action on this RelBuilder.
RelBuilder	limit(int offset, int fetch)	Creates a limit without a sort.
RexLiteral	literal(@Nullable Object value)	Creates a literal (constant expression).
RexSubQuery	mapQuery(Function<RelBuilder,RelNode> f)	Creates a MAP sub-query.
RelBuilder	match(RexNode pattern, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Iterable<? extends RexNode> measureList, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, Iterable<? extends RexNode> partitionKeys, Iterable<? extends RexNode> orderKeys, RexNode interval)	Creates a Match.
RelBuilder.AggCall	max(@Nullable String alias, RexNode operand)	Creates a call to the MAX aggregate function.
RelBuilder.AggCall	max(RexNode operand)	Creates a call to the MAX aggregate function, optionally with an alias.
RelBuilder.AggCall	min(@Nullable String alias, RexNode operand)	Creates a call to the MIN aggregate function, optionally with an alias.
RelBuilder.AggCall	min(RexNode operand)	Creates a call to the MIN aggregate function.
RelBuilder	minus(boolean all)	Creates a Minus of the two most recent relational expressions on the stack.
RelBuilder	minus(boolean all, int n)	Creates a Minus of the n most recent relational expressions on the stack.
RexSubQuery	multisetQuery(Function<RelBuilder,RelNode> f)	Creates a MULTISET sub-query.
RexNode	not(RexNode operand)	Creates a NOT.
RexNode	notEquals(RexNode operand0, RexNode operand1)	Creates a <>.
RexNode	nullsFirst(RexNode node)	Converts a sort expression to nulls first.
RexNode	nullsLast(RexNode node)	Converts a sort expression to nulls last.
RexNode	or(Iterable<? extends RexNode> operands)	Creates an OR.
RexNode	or(RexNode... operands)	Creates an OR.
RexNode	patternAlter(Iterable<? extends RexNode> nodes)	Creates a call that creates alternate patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternAlter(RexNode... nodes)	Creates a call that creates alternate patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternConcat(Iterable<? extends RexNode> nodes)	Creates a call that concatenates patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternConcat(RexNode... nodes)	Creates a call that concatenates patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternExclude(RexNode node)	Creates a call that creates an exclude pattern; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternField(String alpha, RelDataType type, int i)	Creates a reference to a given field of the pattern.
RexNode	patternPermute(Iterable<? extends RexNode> nodes)	Creates a call that creates permute patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternPermute(RexNode... nodes)	Creates a call that creates permute patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternQuantify(Iterable<? extends RexNode> nodes)	Creates a call that creates quantify patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RexNode	patternQuantify(RexNode... nodes)	Creates a call that creates quantify patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).
RelNode	peek()	Returns the relational expression at the top of the stack, but does not remove it.
RelNode	peek(int n)	Returns the relational expression n positions from the top of the stack, but does not remove it.
RelNode	peek(int inputCount, int inputOrdinal)	Returns the relational expression n positions from the top of the stack, but does not remove it.
RelBuilder	permute(Mapping mapping)
RelBuilder	pivot(RelBuilder.GroupKey groupKey, Iterable<? extends RelBuilder.AggCall> aggCalls, Iterable<? extends RexNode> axes, Iterable<? extends Map.Entry<String,? extends Iterable<? extends RexNode>>> values)	Creates a Pivot.
RexWindowBound	preceding(RexNode bound)	Creates a bound PRECEDING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).
RelBuilder	project(Iterable<? extends RexNode> nodes)	Creates a Project of the given list of expressions.
RelBuilder	project(Iterable<? extends RexNode> nodes, Iterable<? extends @Nullable String> fieldNames)	Creates a Project of the given list of expressions and field names.
RelBuilder	project(Iterable<? extends RexNode> nodes, Iterable<? extends @Nullable String> fieldNames, boolean force)	Creates a Project of the given list of expressions, using the given names.
RelBuilder	project(RexNode... nodes)	Creates a Project of the given expressions.
RelBuilder	projectExcept(Iterable<RexNode> expressions)	Creates a Project of all original fields, except the given list of expressions.
RelBuilder	projectExcept(RexNode... expressions)	Creates a Project of all original fields, except the given expressions.
RelBuilder	projectNamed(Iterable<? extends RexNode> nodes, @Nullable Iterable<? extends @Nullable String> fieldNames, boolean force)	Creates a Project of the given expressions and field names, and optionally optimizing.
RelBuilder	projectPlus(Iterable<RexNode> nodes)	Creates a Project of all original fields, plus the given list of expressions.
RelBuilder	projectPlus(RexNode... nodes)	Creates a Project of all original fields, plus the given expressions.
static RelBuilderFactory	proto(Object... factories)	Creates a RelBuilderFactory that uses a given set of factories.
static RelBuilderFactory	proto(Context context)	Creates a RelBuilderFactory, a partially-created RelBuilder.
RelBuilder	push(RelNode node)	Adds a relational expression to be the input to the next relational expression constructed.
RelBuilder	pushAll(Iterable<? extends RelNode> nodes)	Pushes a collection of relational expressions.
RelBuilder	rename(List<? extends @Nullable String> fieldNames)	Ensures that the field names match those given.
RelBuilder	repeatUnion(String tableName, boolean all)	Creates a RepeatUnion associated to a TransientTable without a maximum number of iterations, i.e.
RelBuilder	repeatUnion(String tableName, boolean all, int iterationLimit)	Creates a RepeatUnion associated to a TransientTable of the two most recent relational expressions on the stack.
RexSubQuery	scalarQuery(Function<RelBuilder,RelNode> f)	Creates a scalar sub-query.
RelBuilder	scan(Iterable<String> tableNames)	Creates a TableScan of the table with a given name.
RelBuilder	scan(String... tableNames)	Creates a TableScan of the table with a given name.
RelBuilder	semiJoin(Iterable<? extends RexNode> conditions)	Creates a Join with JoinRelType.SEMI.
RelBuilder	semiJoin(RexNode... conditions)	Creates a Join with JoinRelType.SEMI.
int	size()	Returns the size of the stack.
RelBuilder	snapshot(RexNode period)	Creates a Snapshot of a given snapshot period.
RexSubQuery	some(RexNode node, SqlOperator op, Function<RelBuilder,RelNode> f)	Creates a SOME (or ANY) predicate.
RelBuilder	sort(int... fields)	Creates a Sort by field ordinals.
RelBuilder	sort(Iterable<? extends RexNode> nodes)	Creates a Sort by expressions.
RelBuilder	sort(RelCollation collation)	Creates a Sort by specifying collations.
RelBuilder	sort(RexNode... nodes)	Creates a Sort by expressions.
RelBuilder	sortExchange(RelDistribution distribution, RelCollation collation)	Creates a SortExchange by distribution and collation.
RelBuilder	sortLimit(int offset, int fetch, Iterable<? extends RexNode> nodes)	Creates a Sort by a list of expressions, with limit and offset.
RelBuilder	sortLimit(int offset, int fetch, RexNode... nodes)	Creates a Sort by expressions, with limit and offset.
RelBuilder	sortLimit(@Nullable RexNode offsetNode, @Nullable RexNode fetchNode, Iterable<? extends RexNode> nodes)	Creates a Sort by a list of expressions, with limitNode and offsetNode.
RelBuilder.AggCall	sum(boolean distinct, @Nullable String alias, RexNode operand)	Creates a call to the SUM aggregate function, optionally distinct and with an alias.
RelBuilder.AggCall	sum(RexNode operand)	Creates a call to the SUM aggregate function.
String	toString()	Converts this RelBuilder to a string.
RelBuilder	transform(UnaryOperator<RelBuilder.Config> transform)	Creates a copy of this RelBuilder, with the same state as this, applying a transform to the config.
RelBuilder	transientScan(String tableName)	Creates a TableScan on a TransientTable with the given name, using as type the top of the stack's type.
RelBuilder	transientScan(String tableName, RelDataType rowType)	Creates a TableScan on a TransientTable with the given name and type.
RexWindowBound	unboundedFollowing()	Creates an UNBOUNDED FOLLOWING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).
RexWindowBound	unboundedPreceding()	Creates an UNBOUNDED PRECEDING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).
RelBuilder	uncollect(List<String> itemAliases, boolean withOrdinality)	Creates an Uncollect with given item aliases.
RelBuilder	union(boolean all)	Creates a Union of the two most recent relational expressions on the stack.
RelBuilder	union(boolean all, int n)	Creates a Union of the n most recent relational expressions on the stack.
RexSubQuery	unique(Function<RelBuilder,RelNode> f)	Creates a UNIQUE predicate.
RelBuilder	unpivot(boolean includeNulls, Iterable<String> measureNames, Iterable<String> axisNames, Iterable<? extends Map.Entry<? extends List<? extends RexLiteral>,? extends List<? extends RexNode>>> axisMap)	Creates an Unpivot.
RelBuilder	values(@Nullable String[] fieldNames, @Nullable Object... values)	Creates a Values.
RelBuilder	values(Iterable<? extends List<RexLiteral>> tupleList, RelDataType rowType)	Creates a Values with a specified row type.
RelBuilder	values(RelDataType rowType)	Creates a Values with a specified row type and zero rows.
RelBuilder	values(RelDataType rowType, Object... columnValues)	Creates a Values with a specified row type.
RelBuilder	variable(Holder<RexCorrelVariable> v)	Creates a correlation variable for the current input, and writes it into a Holder.
<E> E	with(RelNode r, Function<RelBuilder,E> fn)	Evaluates an expression with a relational expression temporarily on the stack.
<E> E	withPredicates(RelMetadataQuery mq, Function<RelBuilder,E> fn)	Performs an action using predicates of the current node to simplify.
<E> E	withSimplifier(BiFunction<RelBuilder,RexSimplify,RexSimplify> simplifierTransform, Function<RelBuilder,E> fn)	Performs an action with a temporary simplifier.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Details

cluster

protected final RelOptCluster cluster

relOptSchema

protected final @Nullable RelOptSchema relOptSchema

Constructor Details

RelBuilder

protected RelBuilder(@Nullable Context context,
 RelOptCluster cluster,
 @Nullable RelOptSchema relOptSchema)

Method Details

create

public static RelBuilder create(FrameworkConfig config)

Creates a RelBuilder.

transform

public RelBuilder transform(UnaryOperator<RelBuilder.Config> transform)

Creates a copy of this RelBuilder, with the same state as this, applying a transform to the config.

let

public <R> R let(Function<RelBuilder,R> consumer)

Performs an action on this RelBuilder.

For example, consider the following code:

   RelNode filterAndRename(RelBuilder relBuilder, RelNode rel,
       RexNode condition, List<String> fieldNames) {
     relBuilder.push(rel)
         .filter(condition);
     if (fieldNames != null) {
       relBuilder.rename(fieldNames);
     }
     return relBuilder
         .build();

The pipeline is disrupted by the 'if'. The let method allows you to perform the flow as a single pipeline:

   RelNode filterAndRename(RelBuilder relBuilder, RelNode rel,
       RexNode condition, List<String> fieldNames) {
     return relBuilder.push(rel)
         .filter(condition)
         .let(r -> fieldNames == null ? r : r.rename(fieldNames))
         .build();

In pipelined cases such as this one, the lambda must return this RelBuilder. But let return values of other types.

toString

public String toString()

Converts this RelBuilder to a string. The string is the string representation of all of the RelNodes on the stack.

Overrides:

toString in class Object

getTypeFactory

public RelDataTypeFactory getTypeFactory()

Returns the type factory.

adoptConvention

public RelBuilder adoptConvention(Convention convention)

Returns new RelBuilder that adopts the convention provided. RelNode will be created with such convention if corresponding factory is provided.

getRexBuilder

public RexBuilder getRexBuilder()

Returns the builder for RexNode expressions.

proto

public static RelBuilderFactory proto(Context context)

Creates a RelBuilderFactory, a partially-created RelBuilder. Just add a RelOptCluster and a RelOptSchema

proto

public static RelBuilderFactory proto(Object... factories)

Creates a RelBuilderFactory that uses a given set of factories.

getCluster

public RelOptCluster getCluster()

getRelOptSchema

public @Nullable RelOptSchema getRelOptSchema()

getScanFactory

public RelFactories.TableScanFactory getScanFactory()

push

public RelBuilder push(RelNode node)

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 build() to pop those inputs.

pushAll

public RelBuilder pushAll(Iterable<? extends RelNode> nodes)

Pushes a collection of relational expressions.

size

public int size()

Returns the size of the stack.

build

public RelNode build()

Returns the final relational expression.

Throws if the stack is empty.

peek

public RelNode peek()

Returns the relational expression at the top of the stack, but does not remove it.

peek

public RelNode peek(int n)

Returns the relational expression n positions from the top of the stack, but does not remove it.

peek

public RelNode peek(int inputCount,
 int inputOrdinal)

Returns the relational expression n positions from the top of the stack, but does not remove it.

with

public <E> E with(RelNode r,
 Function<RelBuilder,E> fn)

Evaluates an expression with a relational expression temporarily on the stack.

withSimplifier

public <E> E withSimplifier(BiFunction<RelBuilder,RexSimplify,RexSimplify> simplifierTransform,
 Function<RelBuilder,E> fn)

Performs an action with a temporary simplifier.

withPredicates

public <E> E withPredicates(RelMetadataQuery mq,
 Function<RelBuilder,E> fn)

Performs an action using predicates of the current node to simplify.

literal

public RexLiteral literal(@Nullable Object value)

Creates a literal (constant expression).

variable

public RelBuilder variable(Holder<RexCorrelVariable> v)

Creates a correlation variable for the current input, and writes it into a Holder.

field

public RexInputRef field(String fieldName)

Creates a reference to a field by name.

Equivalent to field(1, 0, fieldName).

Parameters:

fieldName - Field name

field

public RexInputRef field(int inputCount,
 int inputOrdinal,
 String fieldName)

Creates a reference to a field of given input relational expression by name.

Parameters:

inputCount - Number of inputs

inputOrdinal - Input ordinal

fieldName - Field name

field

public RexInputRef field(int fieldOrdinal)

Creates a reference to an input field by ordinal.

Equivalent to field(1, 0, ordinal).

Parameters:

fieldOrdinal - Field ordinal

field

public RexInputRef field(int inputCount,
 int inputOrdinal,
 int fieldOrdinal)

Creates a reference to a field of a given input relational expression by ordinal.

Parameters:

inputCount - Number of inputs

inputOrdinal - Input ordinal

fieldOrdinal - Field ordinal within input

field

public RexNode field(String alias,
 String fieldName)

Creates a reference to a field of the current record which originated in a relation with a given alias.

field

public RexNode field(int inputCount,
 String alias,
 String fieldName)

Creates a reference to a field which originated in a relation with the given alias. Searches for the relation starting at the top of the stack.

field

public RexNode field(RexNode e,
 String name)

Returns a reference to a given field of a record-valued expression.

fields

public com.google.common.collect.ImmutableList<RexNode> fields()

Returns references to the fields of the top input.

fields

public com.google.common.collect.ImmutableList<RexNode> fields(int inputCount,
 int inputOrdinal)

Returns references to the fields of a given input.

fields

public com.google.common.collect.ImmutableList<RexNode> fields(RelCollation collation)

Returns references to fields for a given collation.

fields

public com.google.common.collect.ImmutableList<RexNode> fields(List<? extends Number> ordinals)

Returns references to fields for a given list of input ordinals.

fields

public com.google.common.collect.ImmutableList<RexNode> fields(ImmutableBitSet ordinals)

Returns references to fields for a given bit set of input ordinals.

fields

public com.google.common.collect.ImmutableList<RexNode> fields(Iterable<String> fieldNames)

Returns references to fields identified by name.

fields

public com.google.common.collect.ImmutableList<RexNode> fields(Mappings.TargetMapping mapping)

Returns references to fields identified by a mapping.

dot

public RexNode dot(RexNode node,
 String fieldName)

Creates an access to a field by name.

dot

public RexNode dot(RexNode node,
 int fieldOrdinal)

Creates an access to a field by ordinal.

call

public RexNode call(SqlOperator operator,
 RexNode... operands)

Creates a call to a scalar operator.

call

public RexNode call(SqlOperator operator,
 Iterable<? extends RexNode> operands)

Creates a call to a scalar operator.

in

public RexNode in(RexNode arg,
 RexNode... ranges)

Creates an IN predicate with a list of values.

For example,

 b.scan("Emp")
     .filter(b.in(b.field("deptno"), b.literal(10), b.literal(20)))
 

is equivalent to SQL

 SELECT *
 FROM Emp
 WHERE deptno IN (10, 20)
 

in

public RexNode in(RexNode arg,
 Iterable<? extends RexNode> ranges)

Creates an IN predicate with a list of values.

For example,

 b.scan("Emps")
     .filter(
         b.in(b.field("deptno"),
             Arrays.asList(b.literal(10), b.literal(20))))
 

is equivalent to the SQL

 SELECT *
 FROM Emps
 WHERE deptno IN (10, 20)
 

in

public RexSubQuery in(RelNode rel,
 Iterable<? extends RexNode> nodes)

Creates an IN predicate with a sub-query.

in

public RexNode in(RexNode arg,
 Function<RelBuilder,RelNode> f)

Creates an IN predicate with a sub-query.

For example,

 b.scan("Emps")
     .filter(
         b.in(b.field("deptno"),
             b2 -> b2.scan("Depts")
                 .filter(
                     b2.eq(b2.field("location"), b2.literal("Boston")))
                 .project(b.field("deptno"))
                 .build()))
 

is equivalent to the SQL

 SELECT *
 FROM Emps
 WHERE deptno IN (SELECT deptno FROM Dept WHERE location = 'Boston')
 

some

public RexSubQuery some(RexNode node,
 SqlOperator op,
 Function<RelBuilder,RelNode> f)

Creates a SOME (or ANY) predicate.

For example,

 b.scan("Emps")
     .filter(
         b.some(b.field("commission"),
             SqlStdOperatorTable.GREATER_THAN,
             b2 -> b2.scan("Emps")
                 .filter(
                     b2.eq(b2.field("job"), b2.literal("Manager")))
                 .project(b2.field("sal"))
                 .build()))
 

is equivalent to the SQL

 SELECT *
 FROM Emps
 WHERE commission > SOME (SELECT sal FROM Emps WHERE job = 'Manager')
 

or (since SOME and ANY are synonyms) the SQL

 SELECT *
 FROM Emps
 WHERE commission > ANY (SELECT sal FROM Emps WHERE job = 'Manager')
 

all

public RexNode all(RexNode node,
 SqlOperator op,
 Function<RelBuilder,RelNode> f)

Creates an ALL predicate.

For example,

 b.scan("Emps")
     .filter(
         b.all(b.field("commission"),
             SqlStdOperatorTable.GREATER_THAN,
             b2 -> b2.scan("Emps")
                 .filter(
                     b2.eq(b2.field("job"), b2.literal("Manager")))
                 .project(b2.field("sal"))
                 .build()))
 

is equivalent to the SQL

 SELECT *
 FROM Emps
 WHERE commission > ALL (SELECT sal FROM Emps WHERE job = 'Manager')
 

Calcite translates ALL predicates to NOT SOME. The following SQL is equivalent to the previous:

 SELECT *
 FROM Emps
 WHERE NOT (commission <= SOME (SELECT sal FROM Emps WHERE job = 'Manager'))
 

exists

public RexSubQuery exists(Function<RelBuilder,RelNode> f)

Creates an EXISTS predicate.

For example,

 b.scan("Depts")
     .filter(
         b.exists(b2 ->
             b2.scan("Emps")
                 .filter(
                     b2.eq(b2.field("job"), b2.literal("Manager")))
                 .build()))
 

is equivalent to the SQL

 SELECT *
 FROM Depts
 WHERE EXISTS (SELECT 1 FROM Emps WHERE job = 'Manager')
 

unique

public RexSubQuery unique(Function<RelBuilder,RelNode> f)

Creates a UNIQUE predicate.

For example,

 b.scan("Depts")
     .filter(
         b.exists(b2 ->
             b2.scan("Emps")
                 .filter(
                     b2.eq(b2.field("job"), b2.literal("Manager")))
                 .project(b2.field("deptno")
                 .build()))
 

is equivalent to the SQL

 SELECT *
 FROM Depts
 WHERE UNIQUE (SELECT deptno FROM Emps WHERE job = 'Manager')
 

scalarQuery

public RexSubQuery scalarQuery(Function<RelBuilder,RelNode> f)

Creates a scalar sub-query.

For example,

 b.scan("Depts")
     .project(
         b.field("deptno")
         b.scalarQuery(b2 ->
             b2.scan("Emps")
                 .aggregate(
                     b2.eq(b2.field("job"), b2.literal("Manager")))
                 .build()))
 

is equivalent to the SQL

 SELECT deptno, (SELECT MAX(sal) FROM Emps)
 FROM Depts
 

arrayQuery

public RexSubQuery arrayQuery(Function<RelBuilder,RelNode> f)

Creates an ARRAY sub-query.

For example,

 b.scan("Depts")
     .project(
         b.field("deptno")
         b.arrayQuery(b2 ->
             b2.scan("Emps")
                 .build()))
 

is equivalent to the SQL

 SELECT deptno, ARRAY (SELECT * FROM Emps)
 FROM Depts
 

multisetQuery

public RexSubQuery multisetQuery(Function<RelBuilder,RelNode> f)

Creates a MULTISET sub-query.

For example,

 b.scan("Depts")
     .project(
         b.field("deptno")
         b.multisetQuery(b2 ->
             b2.scan("Emps")
                 .build()))
 

is equivalent to the SQL

 SELECT deptno, MULTISET (SELECT * FROM Emps)
 FROM Depts
 

mapQuery

public RexSubQuery mapQuery(Function<RelBuilder,RelNode> f)

Creates a MAP sub-query.

For example,

 b.scan("Depts")
     .project(
         b.field("deptno")
         b.multisetQuery(b2 ->
             b2.scan("Emps")
                 .project(b2.field("empno"), b2.field("job"))
                 .build()))
 

is equivalent to the SQL

 SELECT deptno, MAP (SELECT empno, job FROM Emps)
 FROM Depts
 

and

public RexNode and(RexNode... operands)

Creates an AND.

and

public RexNode and(Iterable<? extends RexNode> operands)

Creates an AND.

Simplifies the expression a little: e AND TRUE becomes e; e AND e2 AND NOT e becomes e2.

or

public RexNode or(RexNode... operands)

Creates an OR.

or

public RexNode or(Iterable<? extends RexNode> operands)

Creates an OR.

not

public RexNode not(RexNode operand)

Creates a NOT.

equals

public RexNode equals(RexNode operand0,
 RexNode operand1)

Creates an =.

greaterThan

public RexNode greaterThan(RexNode operand0,
 RexNode operand1)

Creates a >.

greaterThanOrEqual

public RexNode greaterThanOrEqual(RexNode operand0,
 RexNode operand1)

Creates a >=.

lessThan

public RexNode lessThan(RexNode operand0,
 RexNode operand1)

Creates a <.

lessThanOrEqual

public RexNode lessThanOrEqual(RexNode operand0,
 RexNode operand1)

Creates a <=.

notEquals

public RexNode notEquals(RexNode operand0,
 RexNode operand1)

Creates a <>.

isNotDistinctFrom

public RexNode isNotDistinctFrom(RexNode operand0,
 RexNode operand1)

Creates an expression equivalent to "o0 IS NOT DISTINCT FROM o1". It is also equivalent to "o0 = o1 OR (o0 IS NULL AND o1 IS NULL)".

isDistinctFrom

public RexNode isDistinctFrom(RexNode operand0,
 RexNode operand1)

Creates an expression equivalent to o0 IS DISTINCT FROM o1. It is also equivalent to "NOT (o0 = o1 OR (o0 IS NULL AND o1 IS NULL)).

between

public RexNode between(RexNode arg,
 RexNode lower,
 RexNode upper)

Creates a BETWEEN.

isNull

public RexNode isNull(RexNode operand)

Creates ab IS NULL.

isNotNull

public RexNode isNotNull(RexNode operand)

Creates an IS NOT NULL.

cast

public RexNode cast(RexNode expr,
 SqlTypeName typeName)

Creates an expression that casts an expression to a given type.

cast

public RexNode cast(RexNode expr,
 SqlTypeName typeName,
 int precision)

Creates an expression that casts an expression to a type with a given name and precision or length.

cast

public RexNode cast(RexNode expr,
 SqlTypeName typeName,
 int precision,
 int scale)

Creates an expression that casts an expression to a type with a given name, precision and scale.

alias

public RexNode alias(RexNode expr,
 @Nullable String alias)

Returns an expression wrapped in an alias.

This method is idempotent: If the expression is already wrapped in the correct alias, does nothing; if wrapped in an incorrect alias, removes the incorrect alias and applies the correct alias.

See Also:

• project(org.apache.calcite.rex.RexNode...)

desc

public RexNode desc(RexNode node)

Converts a sort expression to descending.

nullsLast

public RexNode nullsLast(RexNode node)

Converts a sort expression to nulls last.

nullsFirst

public RexNode nullsFirst(RexNode node)

Converts a sort expression to nulls first.

unboundedPreceding

public RexWindowBound unboundedPreceding()

Creates an UNBOUNDED PRECEDING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).

preceding

public RexWindowBound preceding(RexNode bound)

Creates a bound PRECEDING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).

currentRow

public RexWindowBound currentRow()

Creates a CURRENT ROW window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).

following

public RexWindowBound following(RexNode bound)

Creates a bound FOLLOWING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).

unboundedFollowing

public RexWindowBound unboundedFollowing()

Creates an UNBOUNDED FOLLOWING window bound, for use in methods such as RelBuilder.OverCall.rowsFrom(RexWindowBound) and RelBuilder.OverCall.rangeBetween(RexWindowBound, RexWindowBound).

groupKey

public RelBuilder.GroupKey groupKey()

Creates an empty group key.

groupKey

public RelBuilder.GroupKey groupKey(RexNode... nodes)

Creates a group key.

groupKey

public RelBuilder.GroupKey groupKey(Iterable<? extends RexNode> nodes)

Creates a group key.

groupKey

public RelBuilder.GroupKey groupKey(Iterable<? extends RexNode> nodes,
 Iterable<? extends Iterable<? extends RexNode>> nodeLists)

Creates a group key with grouping sets.

groupKey

@Deprecated
public RelBuilder.GroupKey groupKey(Iterable<? extends RexNode> nodes,
 boolean indicator,
 Iterable<? extends Iterable<? extends RexNode>> nodeLists)

Deprecated.

Now that indicator is deprecated, use groupKey(Iterable, Iterable), which has the same behavior as calling this method with indicator = false.

groupKey

public RelBuilder.GroupKey groupKey(int... fieldOrdinals)

Creates a group key of fields identified by ordinal.

groupKey

public RelBuilder.GroupKey groupKey(String... fieldNames)

Creates a group key of fields identified by name.

groupKey

public RelBuilder.GroupKey groupKey(ImmutableBitSet groupSet)

Creates a group key, 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 Aggregate.

groupKey

public RelBuilder.GroupKey groupKey(ImmutableBitSet groupSet,
 Iterable<? extends ImmutableBitSet> groupSets)

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 Aggregate.

It is possible for groupSet to be strict superset of all groupSets. For example, in the pseudo SQL

 GROUP BY 0, 1, 2
 GROUPING SETS ((0, 1), 0)
 

column 2 does not appear in either grouping set. This is not valid SQL. We can approximate in actual SQL by adding an extra grouping set and filtering out using HAVING, as follows:

 GROUP BY GROUPING SETS ((0, 1, 2), (0, 1), 0)
 HAVING GROUPING_ID(0, 1, 2) <> 0
 

groupKey

@Deprecated
public RelBuilder.GroupKey groupKey(ImmutableBitSet groupSet,
 boolean indicator,
 @Nullable com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets)

Deprecated.

Use groupKey(ImmutableBitSet, Iterable).

aggregateCall

@Deprecated
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
 boolean distinct,
 RexNode filter,
 @Nullable String alias,
 RexNode... operands)

Deprecated.

aggregateCall

@Deprecated
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
 boolean distinct,
 boolean approximate,
 RexNode filter,
 @Nullable String alias,
 RexNode... operands)

Deprecated.

aggregateCall

@Deprecated
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
 boolean distinct,
 RexNode filter,
 @Nullable String alias,
 Iterable<? extends RexNode> operands)

Deprecated.

aggregateCall

@Deprecated
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
 boolean distinct,
 boolean approximate,
 RexNode filter,
 @Nullable String alias,
 Iterable<? extends RexNode> operands)

Deprecated.

aggregateCall

public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
 Iterable<? extends RexNode> operands)

Creates a call to an aggregate function.

To add other operands, apply RelBuilder.AggCall.distinct(), RelBuilder.AggCall.approximate(boolean), filter(RexNode...), RelBuilder.AggCall.sort(java.lang.Iterable<org.apache.calcite.rex.RexNode>), RelBuilder.AggCall.as(java.lang.String) to the result.

aggregateCall

public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
 RexNode... operands)

Creates a call to an aggregate function.

To add other operands, apply RelBuilder.AggCall.distinct(), RelBuilder.AggCall.approximate(boolean), filter(RexNode...), RelBuilder.AggCall.sort(java.lang.Iterable<org.apache.calcite.rex.RexNode>), RelBuilder.AggCall.as(java.lang.String) to the result.

aggregateCall

public RelBuilder.AggCall aggregateCall(AggregateCall a)

Creates a call to an aggregate function as a copy of an AggregateCall.

aggregateCall

public RelBuilder.AggCall aggregateCall(AggregateCall a,
 Mapping mapping)

Creates a call to an aggregate function as a copy of an AggregateCall, applying a mapping.

aggregateCall

protected RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
 boolean distinct,
 boolean approximate,
 boolean ignoreNulls,
 @Nullable RexNode filter,
 @Nullable com.google.common.collect.ImmutableList<RexNode> distinctKeys,
 com.google.common.collect.ImmutableList<RexNode> orderKeys,
 @Nullable String alias,
 com.google.common.collect.ImmutableList<RexNode> operands)

Creates a call to an aggregate function with all applicable operands.

count

public RelBuilder.AggCall count(RexNode... operands)

Creates a call to the COUNT aggregate function.

count

public RelBuilder.AggCall count(Iterable<? extends RexNode> operands)

Creates a call to the COUNT aggregate function.

count

public RelBuilder.AggCall count(boolean distinct,
 @Nullable String alias,
 RexNode... operands)

Creates a call to the COUNT aggregate function, optionally distinct and with an alias.

count

public RelBuilder.AggCall count(boolean distinct,
 @Nullable String alias,
 Iterable<? extends RexNode> operands)

Creates a call to the COUNT aggregate function, optionally distinct and with an alias.

countStar

public RelBuilder.AggCall countStar(@Nullable String alias)

Creates a call to the COUNT(*) aggregate function.

sum

public RelBuilder.AggCall sum(RexNode operand)

Creates a call to the SUM aggregate function.

sum

public RelBuilder.AggCall sum(boolean distinct,
 @Nullable String alias,
 RexNode operand)

Creates a call to the SUM aggregate function, optionally distinct and with an alias.

avg

public RelBuilder.AggCall avg(RexNode operand)

Creates a call to the AVG aggregate function.

avg

public RelBuilder.AggCall avg(boolean distinct,
 @Nullable String alias,
 RexNode operand)

Creates a call to the AVG aggregate function, optionally distinct and with an alias.

min

public RelBuilder.AggCall min(RexNode operand)

Creates a call to the MIN aggregate function.

min

public RelBuilder.AggCall min(@Nullable String alias,
 RexNode operand)

Creates a call to the MIN aggregate function, optionally with an alias.

max

public RelBuilder.AggCall max(RexNode operand)

Creates a call to the MAX aggregate function, optionally with an alias.

max

public RelBuilder.AggCall max(@Nullable String alias,
 RexNode operand)

Creates a call to the MAX aggregate function.

patternField

public RexNode patternField(String alpha,
 RelDataType type,
 int i)

Creates a reference to a given field of the pattern.

Parameters:

alpha - the pattern name

type - Type of field

i - Ordinal of field

Returns:

Reference to field of pattern

patternConcat

public RexNode patternConcat(Iterable<? extends RexNode> nodes)

Creates a call that concatenates patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternConcat

public RexNode patternConcat(RexNode... nodes)

Creates a call that concatenates patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternAlter

public RexNode patternAlter(Iterable<? extends RexNode> nodes)

Creates a call that creates alternate patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternAlter

public RexNode patternAlter(RexNode... nodes)

Creates a call that creates alternate patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternQuantify

public RexNode patternQuantify(Iterable<? extends RexNode> nodes)

Creates a call that creates quantify patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternQuantify

public RexNode patternQuantify(RexNode... nodes)

Creates a call that creates quantify patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternPermute

public RexNode patternPermute(Iterable<? extends RexNode> nodes)

Creates a call that creates permute patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternPermute

public RexNode patternPermute(RexNode... nodes)

Creates a call that creates permute patterns; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

patternExclude

public RexNode patternExclude(RexNode node)

Creates a call that creates an exclude pattern; for use in match(org.apache.calcite.rex.RexNode, boolean, boolean, java.util.Map<java.lang.String, org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode, java.util.Map<java.lang.String, ? extends java.util.SortedSet<java.lang.String>>, boolean, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, java.lang.Iterable<? extends org.apache.calcite.rex.RexNode>, org.apache.calcite.rex.RexNode).

scan

public RelBuilder scan(Iterable<String> tableNames)

Creates a TableScan of the table with a given name.

Throws if the table does not exist.

Returns this builder.

Parameters:

tableNames - Name of table (can optionally be qualified)

scan

public RelBuilder scan(String... tableNames)

Creates a TableScan of the table with a given name.

Throws if the table does not exist.

Returns this builder.

Parameters:

tableNames - Name of table (can optionally be qualified)

snapshot

public RelBuilder snapshot(RexNode period)

Creates a Snapshot of a given snapshot period.

Returns this builder.

Parameters:

period - Name of table (can optionally be qualified)

cursor

public RexNode cursor(int inputCount,
 int ordinal)

Creates a RexCall to the CURSOR function by ordinal.

Parameters:

inputCount - Number of inputs

ordinal - The reference to the relational input

Returns:

RexCall to CURSOR function

functionScan

public RelBuilder functionScan(SqlOperator operator,
 int inputCount,
 RexNode... operands)

Creates a TableFunctionScan.

functionScan

public RelBuilder functionScan(SqlOperator operator,
 int inputCount,
 Iterable<? extends RexNode> operands)

Creates a TableFunctionScan.

filter

public RelBuilder filter(RexNode... predicates)

Creates a Filter of an array of predicates.

The predicates are combined using AND, and optimized in a similar way to the and(org.apache.calcite.rex.RexNode...) method. If the result is TRUE no filter is created.

filter

public RelBuilder filter(Iterable<? extends RexNode> predicates)

Creates a Filter of a list of predicates.

The predicates are combined using AND, and optimized in a similar way to the and(org.apache.calcite.rex.RexNode...) method. If the result is TRUE no filter is created.

filter

public RelBuilder filter(Iterable<CorrelationId> variablesSet,
 RexNode... predicates)

Creates a Filter of a list of correlation variables and an array of predicates.

The predicates are combined using AND, and optimized in a similar way to the and(org.apache.calcite.rex.RexNode...) method. If the result is TRUE no filter is created.

filter

public RelBuilder filter(Iterable<CorrelationId> variablesSet,
 Iterable<? extends RexNode> predicates)

Creates a Filter of a list of correlation variables and a list of predicates.

The predicates are combined using AND, and optimized in a similar way to the and(org.apache.calcite.rex.RexNode...) method. If simplification is on and the result is TRUE, no filter is created.

project

public RelBuilder project(RexNode... nodes)

Creates a Project of the given expressions.

project

public RelBuilder project(Iterable<? extends RexNode> nodes)

Creates a Project of the given list of expressions.

Infers names as would project(Iterable, Iterable) if all suggested names were null.

Parameters:

nodes - Expressions

project

public RelBuilder project(Iterable<? extends RexNode> nodes,
 Iterable<? extends @Nullable String> fieldNames)

Creates a Project of the given list of expressions and field names.

Parameters:

nodes - Expressions

fieldNames - field names for expressions

project

public RelBuilder project(Iterable<? extends RexNode> nodes,
 Iterable<? extends @Nullable String> fieldNames,
 boolean force)

Creates a Project of the given list of expressions, using the given names.

Names are deduced as follows:

• If the length of fieldNames is greater than the index of the current entry in nodes, and the entry in 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 SqlStdOperatorTable.AS (see alias(org.apache.calcite.rex.RexNode, java.lang.String)), removes the call but uses the intended alias.

After the field names have been inferred, makes the field names unique by appending numeric suffixes.

Parameters:

nodes - Expressions

fieldNames - Suggested field names

force - create project even if it is identity

projectPlus

public RelBuilder projectPlus(RexNode... nodes)

Creates a Project of all original fields, plus the given expressions.

projectPlus

public RelBuilder projectPlus(Iterable<RexNode> nodes)

Creates a Project of all original fields, plus the given list of expressions.

projectExcept

public RelBuilder projectExcept(RexNode... expressions)

Creates a Project of all original fields, except the given expressions.

Throws:

IllegalArgumentException - if the given expressions contain duplicates or there is an expression that does not match an existing field

projectExcept

public RelBuilder projectExcept(Iterable<RexNode> expressions)

Creates a Project of all original fields, except the given list of expressions.

Throws:

IllegalArgumentException - if the given expressions contain duplicates or there is an expression that does not match an existing field

projectNamed

public RelBuilder projectNamed(Iterable<? extends RexNode> nodes,
 @Nullable Iterable<? extends @Nullable String> fieldNames,
 boolean force)

Creates a Project of the given expressions and field names, and optionally optimizing.

If fieldNames is null, or if a particular entry in fieldNames is null, derives field names from the input expressions.

If force is false, and the input is a Project, and the expressions make the trivial projection ($0, $1, ...), modifies the input.

Parameters:

nodes - Expressions

fieldNames - Suggested field names, or null to generate

force - Whether to create a renaming Project if the projections are trivial

uncollect

public RelBuilder uncollect(List<String> itemAliases,
 boolean withOrdinality)

Creates an Uncollect with given item aliases.

Parameters:

itemAliases - Operand item aliases, never null

withOrdinality - If withOrdinality, the output contains an extra ORDINALITY column

rename

public RelBuilder rename(List<? extends @Nullable String> fieldNames)

Ensures that the field names match those given.

If all fields have the same name, adds nothing; if any fields do not have the same name, adds a Project.

Note that the names can be short-lived. Other RelBuilder operations make no guarantees about the field names of the rows they produce.

Parameters:

fieldNames - List of desired field names; may contain null values or have fewer fields than the current row type

distinct

public RelBuilder distinct()

Creates an Aggregate that makes the relational expression distinct on all fields.

aggregate

public RelBuilder aggregate(RelBuilder.GroupKey groupKey,
 RelBuilder.AggCall... aggCalls)

Creates an Aggregate with an array of calls.

aggregate

public RelBuilder aggregate(RelBuilder.GroupKey groupKey,
 List<AggregateCall> aggregateCalls)

Creates an Aggregate with an array of AggregateCalls.

aggregate

public RelBuilder aggregate(RelBuilder.GroupKey groupKey,
 Iterable<RelBuilder.AggCall> aggCalls)

Creates an Aggregate with multiple calls.

union

public RelBuilder union(boolean all)

Creates a Union of the two most recent relational expressions on the stack.

Parameters:

all - Whether to create UNION ALL

union

public RelBuilder union(boolean all,
 int n)

Creates a Union of the n most recent relational expressions on the stack.

Parameters:

all - Whether to create UNION ALL

n - Number of inputs to the UNION operator

intersect

public RelBuilder intersect(boolean all)

Creates an Intersect of the two most recent relational expressions on the stack.

Parameters:

all - Whether to create INTERSECT ALL

intersect

public RelBuilder intersect(boolean all,
 int n)

Creates an Intersect of the n most recent relational expressions on the stack.

Parameters:

all - Whether to create INTERSECT ALL

n - Number of inputs to the INTERSECT operator

minus

public RelBuilder minus(boolean all)

Creates a Minus of the two most recent relational expressions on the stack.

Parameters:

all - Whether to create EXCEPT ALL

minus

public RelBuilder minus(boolean all,
 int n)

Creates a Minus of the n most recent relational expressions on the stack.

Parameters:

all - Whether to create EXCEPT ALL

transientScan

public RelBuilder transientScan(String tableName)

Creates a TableScan on a TransientTable with the given name, using as type the top of the stack's type.

Parameters:

tableName - table name

transientScan

public RelBuilder transientScan(String tableName,
 RelDataType rowType)

Creates a TableScan on a TransientTable with the given name and type.

Parameters:

tableName - table name

rowType - row type of the table

repeatUnion

public RelBuilder repeatUnion(String tableName,
 boolean all)

Creates a RepeatUnion associated to a TransientTable without a maximum number of iterations, i.e. repeatUnion(tableName, all, -1).

Parameters:

tableName - name of the TransientTable associated to the RepeatUnion

all - whether duplicates will be considered or not

repeatUnion

public RelBuilder repeatUnion(String tableName,
 boolean all,
 int iterationLimit)

Creates a RepeatUnion associated to a TransientTable of the two most recent relational expressions on the stack.

Warning: if these relational expressions are not correctly defined, this operation might lead to an infinite loop.

The generated RepeatUnion operates as follows:

• Evaluate its left term once, propagating the results into the TransientTable;
• Evaluate its right term (which may contain a TableScan on the TransientTable) over and over until it produces no more results (or until an optional maximum number of iterations is reached). On each iteration, the results are propagated into the TransientTable, overwriting the results from the previous one.

Parameters:

tableName - Name of the TransientTable associated to the RepeatUnion

all - Whether duplicates are considered

iterationLimit - Maximum number of iterations; negative value means no limit

join

public RelBuilder join(JoinRelType joinType,
 RexNode condition0,
 RexNode... conditions)

Creates a Join with an array of conditions.

join

public RelBuilder join(JoinRelType joinType,
 Iterable<? extends RexNode> conditions)

Creates a Join with multiple conditions.

join

public RelBuilder join(JoinRelType joinType,
 RexNode condition)

Creates a Join with one condition.

join

public RelBuilder join(JoinRelType joinType,
 RexNode condition,
 Set<CorrelationId> variablesSet)

Creates a Join with correlating variables.

correlate

public RelBuilder correlate(JoinRelType joinType,
 CorrelationId correlationId,
 RexNode... requiredFields)

Creates a Correlate with a CorrelationId and an array of fields that are used by correlation.

correlate

public RelBuilder correlate(JoinRelType joinType,
 CorrelationId correlationId,
 Iterable<? extends RexNode> requiredFields)

Creates a Correlate with a CorrelationId and a list of fields that are used by correlation.

join

public RelBuilder join(JoinRelType joinType,
 String... fieldNames)

Creates a 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.

Parameters:

joinType - Join type

fieldNames - Field names

semiJoin

public RelBuilder semiJoin(Iterable<? extends RexNode> conditions)

Creates a Join with JoinRelType.SEMI.

A semi-join is a form of join that combines two relational expressions according to some condition, and outputs only rows from the left input for which at least one row from the right input matches. It only outputs columns from the left input, and ignores duplicates on the right.

For example, EMP semi-join DEPT finds all EMP records that do not have a corresponding DEPT record, similar to the following SQL:

 SELECT * FROM EMP
 WHERE EXISTS (SELECT 1 FROM DEPT
     WHERE DEPT.DEPTNO = EMP.DEPTNO)

semiJoin

public RelBuilder semiJoin(RexNode... conditions)

Creates a Join with JoinRelType.SEMI.

See Also:

• semiJoin(Iterable)

antiJoin

public RelBuilder antiJoin(Iterable<? extends RexNode> conditions)

Creates an anti-join.

An anti-join is a form of join that combines two relational expressions according to some condition, but outputs only rows from the left input for which no rows from the right input match.

For example, EMP anti-join DEPT finds all EMP records that do not have a corresponding DEPT record, similar to the following SQL:

 SELECT * FROM EMP
 WHERE NOT EXISTS (SELECT 1 FROM DEPT
     WHERE DEPT.DEPTNO = EMP.DEPTNO)

antiJoin

public RelBuilder antiJoin(RexNode... conditions)

Creates an anti-join.

See Also:

• antiJoin(Iterable)

as

public RelBuilder as(String alias)

Assigns a table alias to the top entry on the stack.

values

public RelBuilder values(@Nullable String[] fieldNames,
 @Nullable Object... values)

Creates a Values.

The values array must have the same number of entries as 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 values(Iterable, RelDataType).

Parameters:

fieldNames - Field names

values - Values

empty

public RelBuilder empty()

Creates a relational expression that reads from an input and throws all of the rows away.

Note that this method always pops one relational expression from the stack. values, in contrast, does not pop any relational expressions, and always produces a leaf.

The default implementation creates a Values with the same specified row type and aliases as the input, and ignores the input entirely. But schema-on-query systems such as Drill might override this method to create a relation expression that retains the input, just to read its schema.

values

public RelBuilder values(RelDataType rowType,
 Object... columnValues)

Creates a Values with a specified row type.

This method can handle cases that values(String[], Object...) cannot, such as all values of a column being null, or there being zero rows.

Parameters:

rowType - Row type

columnValues - Values

values

public RelBuilder values(Iterable<? extends List<RexLiteral>> tupleList,
 RelDataType rowType)

Creates a Values with a specified row type.

This method can handle cases that values(String[], Object...) cannot, such as all values of a column being null, or there being zero rows.

Parameters:

tupleList - Tuple list

rowType - Row type

values

public RelBuilder values(RelDataType rowType)

Creates a Values with a specified row type and zero rows.

Parameters:

rowType - Row type

limit

public RelBuilder limit(int offset,
 int fetch)

Creates a limit without a sort.

exchange

public RelBuilder exchange(RelDistribution distribution)

Creates an Exchange by distribution.

sortExchange

public RelBuilder sortExchange(RelDistribution distribution,
 RelCollation collation)

Creates a SortExchange by distribution and collation.

sort

public RelBuilder sort(int... fields)

Creates a Sort by field ordinals.

Negative fields mean descending: -1 means field(0) descending, -2 means field(1) descending, etc.

sort

public RelBuilder sort(RexNode... nodes)

Creates a Sort by expressions.

sort

public RelBuilder sort(Iterable<? extends RexNode> nodes)

Creates a Sort by expressions.

sortLimit

public RelBuilder sortLimit(int offset,
 int fetch,
 RexNode... nodes)

Creates a Sort by expressions, with limit and offset.

sort

public RelBuilder sort(RelCollation collation)

Creates a Sort by specifying collations.

sortLimit

public RelBuilder sortLimit(int offset,
 int fetch,
 Iterable<? extends RexNode> nodes)

Creates a Sort by a list of expressions, with limit and offset.

Parameters:

offset - Number of rows to skip; non-positive means don't skip any

fetch - Maximum number of rows to fetch; negative means no limit

nodes - Sort expressions

sortLimit

public RelBuilder sortLimit(@Nullable RexNode offsetNode,
 @Nullable RexNode fetchNode,
 Iterable<? extends RexNode> nodes)

Creates a Sort by a list of expressions, with limitNode and offsetNode.

Parameters:

offsetNode - RexLiteral means number of rows to skip is deterministic, RexDynamicParam means number of rows to skip is dynamic.

fetchNode - RexLiteral means maximum number of rows to fetch is deterministic, RexDynamicParam mean maximum number is dynamic.

nodes - Sort expressions

convert

public RelBuilder convert(RelDataType castRowType,
 boolean rename)

Creates a projection that converts the current relational expression's output to a desired row type.

The desired row type and the row type to be converted must have the same number of fields.

Parameters:

castRowType - row type after cast

rename - if true, use field names from castRowType; if false, preserve field names from rel

permute

public RelBuilder permute(Mapping mapping)

match

public RelBuilder match(RexNode pattern,
 boolean strictStart,
 boolean strictEnd,
 Map<String,RexNode> patternDefinitions,
 Iterable<? extends RexNode> measureList,
 RexNode after,
 Map<String,? extends SortedSet<String>> subsets,
 boolean allRows,
 Iterable<? extends RexNode> partitionKeys,
 Iterable<? extends RexNode> orderKeys,
 RexNode interval)

Creates a Match.

pivot

public RelBuilder pivot(RelBuilder.GroupKey groupKey,
 Iterable<? extends RelBuilder.AggCall> aggCalls,
 Iterable<? extends RexNode> axes,
 Iterable<? extends Map.Entry<String,? extends Iterable<? extends RexNode>>> values)

Creates a Pivot.

To achieve the same effect as the SQL

 SELECT *
 FROM (SELECT mgr, deptno, job, sal FROM emp)
 PIVOT (SUM(sal) AS ss, COUNT(*) AS c
     FOR (job, deptno)
     IN (('CLERK', 10) AS c10, ('MANAGER', 20) AS m20))
 

use the builder as follows:

 RelBuilder b;
 b.scan("EMP");
 final RelBuilder.GroupKey groupKey = b.groupKey("MGR");
 final List<RelBuilder.AggCall> aggCalls =
     Arrays.asList(b.sum(b.field("SAL")).as("SS"),
         b.count().as("C"));
 final List<RexNode> axes =
     Arrays.asList(b.field("JOB"),
         b.field("DEPTNO"));
 final ImmutableMap.Builder<String, List<RexNode>> valueMap =
     ImmutableMap.builder();
 valueMap.put("C10",
     Arrays.asList(b.literal("CLERK"), b.literal(10)));
 valueMap.put("M20",
     Arrays.asList(b.literal("MANAGER"), b.literal(20)));
 b.pivot(groupKey, aggCalls, axes, valueMap.build().entrySet());
 

Note that the SQL uses a sub-query to project away columns (e.g. HIREDATE) that it does not reference, so that they do not appear in the GROUP BY. You do not need to do that in this API, because the groupKey parameter specifies the keys.

Pivot is implemented by desugaring. The above example becomes the following:

 SELECT mgr,
     SUM(sal) FILTER (WHERE job = 'CLERK' AND deptno = 10) AS c10_ss,
     COUNT(*) FILTER (WHERE job = 'CLERK' AND deptno = 10) AS c10_c,
     SUM(sal) FILTER (WHERE job = 'MANAGER' AND deptno = 20) AS m20_ss,
      COUNT(*) FILTER (WHERE job = 'MANAGER' AND deptno = 20) AS m20_c
 FROM emp
 GROUP BY mgr
 

Parameters:

groupKey - Key columns

aggCalls - Aggregate expressions to compute for each value

axes - Columns to pivot

values - Values to pivot, and the alias for each column group

Returns:

this RelBuilder

unpivot

public RelBuilder unpivot(boolean includeNulls,
 Iterable<String> measureNames,
 Iterable<String> axisNames,
 Iterable<? extends Map.Entry<? extends List<? extends RexLiteral>,? extends List<? extends RexNode>>> axisMap)

Creates an Unpivot.

To achieve the same effect as the SQL

 SELECT *
 FROM (SELECT deptno, job, sal, comm FROM emp)
   UNPIVOT INCLUDE NULLS (remuneration
     FOR remuneration_type IN (comm AS 'commission',
                               sal AS 'salary'))
 

use the builder as follows:

 RelBuilder b;
 b.scan("EMP");
 final List<String> measureNames = Arrays.asList("REMUNERATION");
 final List<String> axisNames = Arrays.asList("REMUNERATION_TYPE");
 final Map<List<RexLiteral>, List<RexNode>> axisMap =
     ImmutableMap.<List<RexLiteral>, List<RexNode>>builder()
         .put(Arrays.asList(b.literal("commission")),
             Arrays.asList(b.field("COMM")))
         .put(Arrays.asList(b.literal("salary")),
             Arrays.asList(b.field("SAL")))
         .build();
 b.unpivot(false, measureNames, axisNames, axisMap);
 

The query generates two columns: remuneration_type (an axis column) and remuneration (a measure column). Axis columns contain values to indicate the source of the row (in this case, 'salary' if the row came from the sal column, and 'commission' if the row came from the comm column).

Parameters:

includeNulls - Whether to include NULL values in the output

measureNames - Names of columns to be generated to hold pivoted measures

axisNames - Names of columns to be generated to hold qualifying values

axisMap - Mapping from the columns that hold measures to the values that the axis columns will hold in the generated rows

Returns:

This RelBuilder

hints

public RelBuilder hints(RelHint... hints)

Attaches an array of hints to the stack top relational expression.

The redundant hints would be eliminated.

Parameters:

hints - Hints

Throws:

AssertionError - if the top relational expression does not implement Hintable

hints

public RelBuilder hints(Iterable<RelHint> hints)

Attaches multiple hints to the stack top relational expression.

The redundant hints would be eliminated.

Parameters:

hints - Hints

Throws:

AssertionError - if the top relational expression does not implement Hintable

clear

public void clear()

Clears the stack.

The builder's state is now the same as when it was created.