RelBuilder (Calcite Core 1.16.0 API)

java.lang.Object
- org.apache.calcite.tools.RelBuilder

Direct Known Subclasses:

PigRelBuilder
```
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 and Description
`static interface`	`RelBuilder.AggCall` Information necessary to create a call to an aggregate function.
`private static class`	`RelBuilder.AggCallImpl` Implementation of `RelBuilder.AggCall`.
`private static class`	`RelBuilder.AggCallImpl2` Implementation of `RelBuilder.AggCall` that wraps an `AggregateCall`.
`private static class`	`RelBuilder.Field` A field that belongs to a stack `RelBuilder.Frame`.
`private static class`	`RelBuilder.Frame` Builder stack frame.
`static interface`	`RelBuilder.GroupKey` Information necessary to create the GROUP BY clause of an Aggregate.
`protected static class`	`RelBuilder.GroupKeyImpl` Implementation of `RelBuilder.GroupKey`.
`private static class`	`RelBuilder.Registrar` Collects the extra expressions needed for `aggregate(org.apache.calcite.tools.RelBuilder.GroupKey, org.apache.calcite.tools.RelBuilder.AggCall...)`.
`private class`	`RelBuilder.Shifter` Shuttle that shifts a predicate's inputs to the left, replacing early ones with references to a `RexCorrelVariable`.

Field Summary

Fields
Modifier and Type	Field and Description
`private RelFactories.AggregateFactory`	`aggregateFactory`
`protected RelOptCluster`	`cluster`
`private RelFactories.CorrelateFactory`	`correlateFactory`
`private RelFactories.FilterFactory`	`filterFactory`
`private static com.google.common.base.Function<RexNode,String>`	`FN_TYPE`
`private RelFactories.JoinFactory`	`joinFactory`
`private RelFactories.MatchFactory`	`matchFactory`
`private RelFactories.ProjectFactory`	`projectFactory`
`protected RelOptSchema`	`relOptSchema`
`private RelFactories.TableScanFactory`	`scanFactory`
`private RelFactories.SemiJoinFactory`	`semiJoinFactory`
`private RelFactories.SetOpFactory`	`setOpFactory`
`private RexSimplify`	`simplifier`
`private RexSimplify`	`simplifierUnknownAsFalse`
`private boolean`	`simplify`
`private RelFactories.SortFactory`	`sortFactory`
`private Deque<RelBuilder.Frame>`	`stack`
`private RelFactories.ValuesFactory`	`valuesFactory`

Constructor Summary

Constructors
Modifier Constructor and Description

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

Constructors
Modifier	Constructor and Description
`protected`	`RelBuilder(Context context, RelOptCluster cluster, RelOptSchema relOptSchema)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`RelBuilder`	`aggregate(RelBuilder.GroupKey groupKey, Iterable<RelBuilder.AggCall> aggCalls)` Creates an `Aggregate` with a list of calls.
`RelBuilder`	`aggregate(RelBuilder.GroupKey groupKey, List<AggregateCall> aggregateCalls)`
`RelBuilder`	`aggregate(RelBuilder.GroupKey groupKey, RelBuilder.AggCall... aggCalls)` Creates an `Aggregate` with an array of calls.
`RelBuilder.AggCall`	`aggregateCall(SqlAggFunction aggFunction, boolean distinct, boolean approximate, RexNode filter, String alias, Iterable<? extends RexNode> operands)` Creates a call to an aggregate function.
`RelBuilder.AggCall`	`aggregateCall(SqlAggFunction aggFunction, boolean distinct, boolean approximate, RexNode filter, String alias, RexNode... operands)` Creates a call to an aggregate function.
`RelBuilder.AggCall`	`aggregateCall(SqlAggFunction aggFunction, boolean distinct, RexNode filter, String alias, Iterable<? extends RexNode> operands)` Deprecated.
`RelBuilder.AggCall`	`aggregateCall(SqlAggFunction aggFunction, boolean distinct, RexNode filter, String alias, RexNode... operands)` Deprecated.
`RexNode`	`alias(RexNode expr, String alias)` Returns an expression wrapped in an alias.
`private boolean`	`allNull(Object[] values, int column, int columnCount)` Returns whether all values for a given column are null.
`RexNode`	`and(Iterable<? extends RexNode> operands)` Creates an AND.
`RexNode`	`and(RexNode... operands)` Creates an AND.
`RelBuilder`	`as(String alias)` Assigns a table alias to the top entry on the stack.
`RelBuilder.AggCall`	`avg(boolean distinct, String alias, RexNode operand)` Creates a call to the AVG aggregate function.
`RelNode`	`build()` Returns the final relational expression.
`RexNode`	`call(SqlOperator operator, Iterable<? extends RexNode> operands)` Creates a call to a scalar operator.
`private RexNode`	`call(SqlOperator operator, List<RexNode> operandList)` 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.
`private static RelFieldCollation`	`collation(RexNode node, RelFieldCollation.Direction direction, RelFieldCollation.NullDirection nullDirection, List<RexNode> extraNodes)`
`RelBuilder`	`convert(RelDataType castRowType, boolean rename)` Creates a projection that converts the current relational expression's output to a desired row type.
`private static <E> com.google.common.collect.ImmutableList<com.google.common.collect.ImmutableList<E>>`	`copy(Iterable<? extends List<E>> tupleList)` Converts an iterable of lists into an immutable list of immutable lists with the same contents.
`RelBuilder.AggCall`	`count(boolean distinct, String alias, RexNode... operands)` Creates a call to the COUNT aggregate function.
`RelBuilder.AggCall`	`countStar(String alias)` Creates a call to the COUNT(*) aggregate function.
`static RelBuilder`	`create(FrameworkConfig config)` Creates a RelBuilder.
`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 `=`.
`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.
`private RexNode`	`field(int inputCount, int inputOrdinal, int fieldOrdinal, boolean alias)` As `field(int, int, int)`, but if `alias` is true, the method may apply an alias to make sure that the field has the same name as in the input frame.
`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.
`RexNode`	`field(RexNode e, String name)` Returns a reference to a given field of a record-valued expression.
`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.
`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(Mappings.TargetMapping mapping)` Returns references to fields identified by a mapping.
`com.google.common.collect.ImmutableList<RexNode>`	`fields(RelCollation collation)` Returns references to fields for a given collation.
`RelBuilder`	`filter(Iterable<? extends RexNode> predicates)` Creates a `Filter` of a list of predicates.
`RelBuilder`	`filter(RexNode... predicates)` Creates a `Filter` of an array of predicates.
`RexBuilder`	`getRexBuilder()` Returns the builder for `RexNode` expressions.
`RelDataTypeFactory`	`getTypeFactory()` Returns the type factory.
`private RelBuilder.GroupKey`	`groupKey_(ImmutableBitSet groupSet, boolean indicator, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets)`
`RelBuilder.GroupKey`	`groupKey()` Creates an empty group key.
`RelBuilder.GroupKey`	`groupKey(ImmutableBitSet groupSet, boolean indicator, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets)` Deprecated. Use `groupKey(ImmutableBitSet, ImmutableList)`.
`RelBuilder.GroupKey`	`groupKey(ImmutableBitSet groupSet, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets)` Creates a group key with grouping sets, both identified by field positions in the underlying relational expression.
`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)` Creates a group key with grouping sets.
`RelBuilder.GroupKey`	`groupKey(RexNode... nodes)` Creates a group key.
`RelBuilder.GroupKey`	`groupKey(String... fieldNames)` Creates a group key of fields identified by name.
`private String`	`inferAlias(List<RexNode> exprList, RexNode expr)` Infers the alias of an expression.
`private int`	`inputOffset(int inputCount, int inputOrdinal)` Returns the number of fields in all inputs before (to the left of) the given input.
`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`	`isNotNull(RexNode operand)` Creates a IS NOT NULL.
`RexNode`	`isNull(RexNode operand)` Creates a IS NULL.
`RelBuilder`	`join(JoinRelType joinType, Iterable<? extends RexNode> conditions)` Creates a `Join` with multiple conditions.
`RelBuilder`	`join(JoinRelType joinType, RexNode condition)`
`RelBuilder`	`join(JoinRelType joinType, RexNode condition0, RexNode... conditions)` Creates a `Join`.
`RelBuilder`	`join(JoinRelType joinType, RexNode condition, Set<CorrelationId> variablesSet)` Creates a `Join` with correlating variables.
`RelBuilder`	`join(JoinRelType joinType, String... fieldNames)` Creates a `Join` using USING syntax.
`RelBuilder`	`limit(int offset, int fetch)` Creates a limit without a sort.
`RexNode`	`literal(Object value)` Creates a literal (constant expression).
`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(String alias, RexNode operand)` Creates a call to the MAX aggregate function.
`RelBuilder.AggCall`	`min(String alias, 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.
`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)`.
`private RelBuilder.Frame`	`peek_()`
`private RelBuilder.Frame`	`peek_(int n)`
`private RelBuilder.Frame`	`peek_(int inputCount, int inputOrdinal)`
`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`	`project(Iterable<? extends RexNode> nodes)` Creates a `Project` of the given list of expressions.
`RelBuilder`	`project(Iterable<? extends RexNode> nodes, Iterable<String> fieldNames)` Creates a `Project` of the given list of expressions and field names.
`RelBuilder`	`project(Iterable<? extends RexNode> nodes, Iterable<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.
`static RelBuilderFactory`	`proto(Context context)` Creates a `RelBuilderFactory`, a partially-created RelBuilder.
`static RelBuilderFactory`	`proto(Object... factories)` Creates a `RelBuilderFactory` that uses a given set of factories.
`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<String> fieldNames)` Ensures that the field names match those given.
`private void`	`replaceTop(RelNode node)` Adds a rel node to the top of the stack while preserving the field names and aliases.
`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 `SemiJoin`.
`RelBuilder`	`semiJoin(RexNode... conditions)` Creates a `SemiJoin`.
`private RelBuilder`	`setOp(boolean all, SqlKind kind, int n)`
`RelBuilder`	`sort(int... fields)` Creates a `Sort` by field ordinals.
`RelBuilder`	`sort(Iterable<? extends RexNode> nodes)` Creates a `Sort` by expressions.
`RelBuilder`	`sort(RexNode... nodes)` Creates a `Sort` by expressions.
`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.AggCall`	`sum(boolean distinct, String alias, RexNode operand)` Creates a call to the SUM aggregate function.
`private com.google.common.collect.ImmutableList<com.google.common.collect.ImmutableList<RexLiteral>>`	`tupleList(int columnCount, Object[] values)`
`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.
`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`	`values(String[] fieldNames, Object... values)` Creates a `Values`.
`RelBuilder`	`variable(Holder<RexCorrelVariable> v)` Creates a correlation variable for the current input, and writes it into a Holder.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - FN_TYPE
```
private static final com.google.common.base.Function<RexNode,String> FN_TYPE
```
  - cluster
```
protected final RelOptCluster cluster
```
  - relOptSchema
```
protected final RelOptSchema relOptSchema
```
  - filterFactory
```
private final RelFactories.FilterFactory filterFactory
```
  - projectFactory
```
private final RelFactories.ProjectFactory projectFactory
```
  - aggregateFactory
```
private final RelFactories.AggregateFactory aggregateFactory
```
  - sortFactory
```
private final RelFactories.SortFactory sortFactory
```
  - setOpFactory
```
private final RelFactories.SetOpFactory setOpFactory
```
  - joinFactory
```
private final RelFactories.JoinFactory joinFactory
```
  - semiJoinFactory
```
private final RelFactories.SemiJoinFactory semiJoinFactory
```
  - correlateFactory
```
private final RelFactories.CorrelateFactory correlateFactory
```
  - valuesFactory
```
private final RelFactories.ValuesFactory valuesFactory
```
  - scanFactory
```
private final RelFactories.TableScanFactory scanFactory
```
  - matchFactory
```
private final RelFactories.MatchFactory matchFactory
```
  - stack
```
private final Deque<RelBuilder.Frame> stack
```
  - simplify
```
private final boolean simplify
```
  - simplifier
```
private final RexSimplify simplifier
```
  - simplifierUnknownAsFalse
```
private final RexSimplify simplifierUnknownAsFalse
```
- Constructor Detail
  - RelBuilder
```
protected RelBuilder(Context context,
                     RelOptCluster cluster,
                     RelOptSchema relOptSchema)
```
- Method Detail
  - create
```
public static RelBuilder create(FrameworkConfig config)
```
    Creates a RelBuilder.
  - getTypeFactory
```
public RelDataTypeFactory getTypeFactory()
```
    Returns the type factory.
  - 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.
  - 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.
  - replaceTop
```
private void replaceTop(RelNode node)
```
    Adds a rel node to the top of the stack while preserving the field names and aliases.
  - pushAll
```
public RelBuilder pushAll(Iterable<? extends RelNode> nodes)
```
    Pushes a collection of relational expressions.
  - 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_
```
private RelBuilder.Frame peek_()
```
  - peek
```
public RelNode peek(int n)
```
    Returns the relational expression n positions from the top of the stack, but does not remove it.
  - peek_
```
private RelBuilder.Frame peek_(int n)
```
  - 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.
  - peek_
```
private RelBuilder.Frame peek_(int inputCount,
                               int inputOrdinal)
```
  - inputOffset
```
private int inputOffset(int inputCount,
                        int inputOrdinal)
```
    Returns the number of fields in all inputs before (to the left of) the given input.
    
    Parameters:
    
    inputCount - Number of inputs
    
    inputOrdinal - Input ordinal
  - literal
```
public RexNode literal(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
```
private RexNode field(int inputCount,
                      int inputOrdinal,
                      int fieldOrdinal,
                      boolean alias)
```
    As field(int, int, int), but if 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 RexInputRef.
  - 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(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
```
private RexNode call(SqlOperator operator,
                     List<RexNode> operandList)
```
    Creates a call to a scalar operator.
  - call
```
public RexNode call(SqlOperator operator,
                    Iterable<? extends RexNode> operands)
```
    Creates a call to a scalar operator.
  - 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 =.
  - notEquals
```
public RexNode notEquals(RexNode operand0,
                         RexNode operand1)
```
    Creates a <>.
  - isNull
```
public RexNode isNull(RexNode operand)
```
    Creates a IS NULL.
  - isNotNull
```
public RexNode isNotNull(RexNode operand)
```
    Creates a 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,
                     String alias)
```
    Returns an expression wrapped in an alias.
    
    See Also:
    
    project(java.lang.Iterable<? extends 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.
  - 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,
                                    boolean indicator,
                                    Iterable<? extends Iterable<? extends RexNode>> nodeLists)
```
    Creates a group key with grouping sets.
  - 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,
                                    com.google.common.collect.ImmutableList<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.
  - groupKey
```
@Deprecated
public RelBuilder.GroupKey groupKey(ImmutableBitSet groupSet,
                                                boolean indicator,
                                                com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets)
```
    Deprecated. Use groupKey(ImmutableBitSet, ImmutableList).
  - groupKey_
```
private RelBuilder.GroupKey groupKey_(ImmutableBitSet groupSet,
                                      boolean indicator,
                                      com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets)
```
  - aggregateCall
```
@Deprecated
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
                                                    boolean distinct,
                                                    RexNode filter,
                                                    String alias,
                                                    RexNode... operands)
```
    Deprecated.
  - aggregateCall
```
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
                                        boolean distinct,
                                        boolean approximate,
                                        RexNode filter,
                                        String alias,
                                        RexNode... operands)
```
    Creates a call to an aggregate function.
  - aggregateCall
```
@Deprecated
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
                                                    boolean distinct,
                                                    RexNode filter,
                                                    String alias,
                                                    Iterable<? extends RexNode> operands)
```
    Deprecated.
  - aggregateCall
```
public RelBuilder.AggCall aggregateCall(SqlAggFunction aggFunction,
                                        boolean distinct,
                                        boolean approximate,
                                        RexNode filter,
                                        String alias,
                                        Iterable<? extends RexNode> operands)
```
    Creates a call to an aggregate function.
  - count
```
public RelBuilder.AggCall count(boolean distinct,
                                String alias,
                                RexNode... operands)
```
    Creates a call to the COUNT aggregate function.
  - countStar
```
public RelBuilder.AggCall countStar(String alias)
```
    Creates a call to the COUNT(*) aggregate function.
  - sum
```
public RelBuilder.AggCall sum(boolean distinct,
                              String alias,
                              RexNode operand)
```
    Creates a call to the SUM aggregate function.
  - avg
```
public RelBuilder.AggCall avg(boolean distinct,
                              String alias,
                              RexNode operand)
```
    Creates a call to the AVG aggregate function.
  - min
```
public RelBuilder.AggCall min(String alias,
                              RexNode operand)
```
    Creates a call to the MIN aggregate function.
  - max
```
public RelBuilder.AggCall max(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)
  - 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.
  - 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<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<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
  - project
```
public RelBuilder project(RexNode... nodes)
```
    Creates a Project of the given expressions.
  - rename
```
public RelBuilder rename(List<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
  - inferAlias
```
private String inferAlias(List<RexNode> exprList,
                          RexNode expr)
```
    Infers the alias of an expression.
    If the expression was created by alias(org.apache.calcite.rex.RexNode, java.lang.String), replaces the expression in the project list.
  - 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,
                            Iterable<RelBuilder.AggCall> aggCalls)
```
    Creates an Aggregate with a list of calls.
  - setOp
```
private RelBuilder setOp(boolean all,
                         SqlKind kind,
                         int n)
```
  - 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
  - join
```
public RelBuilder join(JoinRelType joinType,
                       RexNode condition0,
                       RexNode... conditions)
```
    Creates a Join.
  - join
```
public RelBuilder join(JoinRelType joinType,
                       Iterable<? extends RexNode> conditions)
```
    Creates a Join with multiple conditions.
  - join
```
public RelBuilder join(JoinRelType joinType,
                       RexNode condition)
```
  - join
```
public RelBuilder join(JoinRelType joinType,
                       RexNode condition,
                       Set<CorrelationId> variablesSet)
```
    Creates a Join with correlating variables.
  - 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 SemiJoin.
  - semiJoin
```
public RelBuilder semiJoin(RexNode... conditions)
```
    Creates a SemiJoin.
  - as
```
public RelBuilder as(String alias)
```
    Assigns a table alias to the top entry on the stack.
  - values
```
public RelBuilder values(String[] fieldNames,
                         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
  - tupleList
```
private com.google.common.collect.ImmutableList<com.google.common.collect.ImmutableList<RexLiteral>> tupleList(int columnCount,
                                                                                                               Object[] values)
```
  - allNull
```
private boolean allNull(Object[] values,
                        int column,
                        int columnCount)
```
    Returns whether all values for a given column are null.
  - 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 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
  - copy
```
private static <E> com.google.common.collect.ImmutableList<com.google.common.collect.ImmutableList<E>> copy(Iterable<? extends List<E>> tupleList)
```
    Converts an iterable of lists into an immutable list of immutable lists with the same contents. Returns the same object if possible.
  - limit
```
public RelBuilder limit(int offset,
                        int fetch)
```
    Creates a limit without a sort.
  - 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.
  - 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
  - collation
```
private static RelFieldCollation collation(RexNode node,
                                           RelFieldCollation.Direction direction,
                                           RelFieldCollation.NullDirection nullDirection,
                                           List<RexNode> extraNodes)
```
  - convert
```
public RelBuilder convert(RelDataType castRowType,
                          boolean rename)
```
    Creates a projection that converts the current relational expression's output to a desired row type.
    
    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)
```
  - aggregate
```
public RelBuilder aggregate(RelBuilder.GroupKey groupKey,
                            List<AggregateCall> aggregateCalls)
```
  - 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.
  - clear
```
public void clear()
```
    Clears the stack.
    The builder's state is now the same as when it was created.

Class RelBuilder

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

FN_TYPE

cluster

relOptSchema

filterFactory

projectFactory

aggregateFactory

sortFactory

setOpFactory

joinFactory

semiJoinFactory

correlateFactory

valuesFactory

scanFactory

matchFactory

stack

simplify

simplifier

simplifierUnknownAsFalse

Constructor Detail

RelBuilder

Method Detail

create

getTypeFactory

getRexBuilder

proto

proto

push

replaceTop

pushAll

build

peek

peek_

peek

peek_

peek

peek_

inputOffset

literal

variable

field

field

field

field

field

field

field

field

fields

fields

fields

fields

fields

fields

dot

dot

call

call

call

and

and

or

or

not

equals

notEquals

isNull

isNotNull

cast

cast

cast

alias

desc

nullsLast