Uses of Interface
org.apache.calcite.rel.RelNode

Packages that use RelNode

Package	Description
org.apache.calcite.adapter.elasticsearch	Base classes for a query provider based on an Elasticsearch DB.
org.apache.calcite.adapter.enumerable	Query optimizer rules for Java calling convention.
org.apache.calcite.adapter.jdbc	Query provider based on a JDBC data source.
org.apache.calcite.interpreter	Provides an implementation of relational expressions using an interpreter.
org.apache.calcite.jdbc	JDBC driver for Calcite.
org.apache.calcite.materialize	Management of materialized query results.
org.apache.calcite.plan	Defines interfaces for constructing rule-based optimizers of relational expressions.
org.apache.calcite.plan.hep	Provides a heuristic planner implementation for the interfaces in org.apache.calcite.plan.
org.apache.calcite.plan.volcano	Optimizes relational expressions.
org.apache.calcite.prepare	Preparation of queries (parsing, planning and implementation).
org.apache.calcite.rel	Defines relational expressions.
org.apache.calcite.rel.convert	Defines relational expressions and rules for converting between calling conventions.
org.apache.calcite.rel.core	Defines core relational expressions.
org.apache.calcite.rel.externalize	Facilities to externalize RelNodes to and from XML and JSON format.
org.apache.calcite.rel.logical	Defines logical relational expressions.
org.apache.calcite.rel.metadata	Defines metadata interfaces and utilities for relational expressions.
org.apache.calcite.rel.mutable	Defines mutable relational expressions.
org.apache.calcite.rel.rel2sql	Translates a relational expression to SQL parse tree.
org.apache.calcite.rel.rules	Provides a core set of planner rules.
org.apache.calcite.rel.stream	Defines relational expressions for streaming.
org.apache.calcite.rex	Provides a language for representing row-expressions.
org.apache.calcite.schema	Schema SPI.
org.apache.calcite.schema.impl	Utilities to help implement Calcite's SPIs.
org.apache.calcite.sql2rel	Translates a SQL parse tree to relational expression.
org.apache.calcite.tools	Provides utility classes.

Uses of RelNode in org.apache.calcite.adapter.elasticsearch

Subinterfaces of RelNode in org.apache.calcite.adapter.elasticsearch

Modifier and Type	Interface and Description
interface	ElasticsearchRel Relational expression that uses Elasticsearch calling convention.

Classes in org.apache.calcite.adapter.elasticsearch that implement RelNode

Modifier and Type	Class and Description
class	ElasticsearchFilter Implementation of a Filter relational expression in Elasticsearch.
class	ElasticsearchProject Implementation of Project relational expression in Elasticsearch.
class	ElasticsearchSort Implementation of Sort relational expression in Elasticsearch.
class	ElasticsearchTableScan Relational expression representing a scan of an Elasticsearch type.
class	ElasticsearchToEnumerableConverter Relational expression representing a scan of a table in an Elasticsearch data source.

Methods in org.apache.calcite.adapter.elasticsearch that return RelNode

Modifier and Type	Method and Description
RelNode	ElasticsearchRules.ElasticsearchSortRule.convert(RelNode relNode)
RelNode	ElasticsearchRules.ElasticsearchFilterRule.convert(RelNode relNode)
RelNode	ElasticsearchRules.ElasticsearchProjectRule.convert(RelNode relNode)
RelNode	ElasticsearchToEnumerableConverterRule.convert(RelNode relNode)
RelNode	ElasticsearchToEnumerableConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	ElasticsearchTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	AbstractElasticsearchTable.toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable)

Methods in org.apache.calcite.adapter.elasticsearch with parameters of type RelNode

Modifier and Type	Method and Description
RelNode	ElasticsearchRules.ElasticsearchSortRule.convert(RelNode relNode)
RelNode	ElasticsearchRules.ElasticsearchFilterRule.convert(RelNode relNode)
RelNode	ElasticsearchRules.ElasticsearchProjectRule.convert(RelNode relNode)
RelNode	ElasticsearchToEnumerableConverterRule.convert(RelNode relNode)
Project	ElasticsearchProject.copy(RelTraitSet relTraitSet, RelNode input, List<RexNode> projects, RelDataType relDataType)
Sort	ElasticsearchSort.copy(RelTraitSet traitSet, RelNode relNode, RelCollation relCollation, RexNode offset, RexNode fetch)
Filter	ElasticsearchFilter.copy(RelTraitSet relTraitSet, RelNode input, RexNode condition)
void	ElasticsearchRel.Implementor.visitChild(int ordinal, RelNode input)

Method parameters in org.apache.calcite.adapter.elasticsearch with type arguments of type RelNode

Modifier and Type	Method and Description
RelNode	ElasticsearchToEnumerableConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	ElasticsearchTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)

Constructors in org.apache.calcite.adapter.elasticsearch with parameters of type RelNode

Constructor and Description
ElasticsearchFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RexNode condition)
ElasticsearchProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType)
ElasticsearchSort(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RelCollation collation, RexNode offset, RexNode fetch)
ElasticsearchToEnumerableConverter(RelOptCluster cluster, RelTraitSet traits, RelNode input)

Constructor parameters in org.apache.calcite.adapter.elasticsearch with type arguments of type RelNode

Constructor and Description
ElasticsearchConverterRule(Class<? extends RelNode> clazz, RelTrait in, Convention out, String description)

Uses of RelNode in org.apache.calcite.adapter.enumerable

Subinterfaces of RelNode in org.apache.calcite.adapter.enumerable

Modifier and Type	Interface and Description
interface	EnumerableRel A relational expression of one of the EnumerableConvention calling conventions.

Classes in org.apache.calcite.adapter.enumerable that implement RelNode

Modifier and Type	Class and Description
class	EnumerableAggregate Implementation of Aggregate in enumerable calling convention.
class	EnumerableBindable Relational expression that converts an enumerable input to interpretable calling convention.
class	EnumerableCalc Implementation of Calc in enumerable calling convention.
class	EnumerableCollect Implementation of Collect in enumerable calling convention.
class	EnumerableCorrelate Implementation of Correlate in enumerable calling convention.
class	EnumerableFilter Implementation of Filter in enumerable calling convention.
class	EnumerableInterpretable Relational expression that converts an enumerable input to interpretable calling convention.
class	EnumerableInterpreter Relational expression that executes its children using an interpreter.
class	EnumerableIntersect Implementation of Intersect in enumerable calling convention.
class	EnumerableJoin Implementation of Join in enumerable calling convention.
class	EnumerableLimit Relational expression that applies a limit and/or offset to its input.
class	EnumerableMergeJoin Implementation of Join in enumerable calling convention using a merge algorithm.
class	EnumerableMinus Implementation of Minus in enumerable calling convention.
class	EnumerableProject Implementation of Project in enumerable calling convention.
class	EnumerableSemiJoin Implementation of SemiJoin in enumerable calling convention.
class	EnumerableSort Implementation of Sort in enumerable calling convention.
class	EnumerableTableFunctionScan Implementation of TableFunctionScan in enumerable calling convention.
class	EnumerableTableModify Implementation of TableModify in enumerable calling convention.
class	EnumerableTableScan Implementation of TableScan in enumerable calling convention.
class	EnumerableThetaJoin Implementation of Join in enumerable calling convention that allows conditions that are not just = (equals).
class	EnumerableUncollect Implementation of Uncollect in enumerable calling convention.
class	EnumerableUnion Implementation of Union in enumerable calling convention.
class	EnumerableValues Implementation of Values in enumerable calling convention.
class	EnumerableWindow Implementation of Window in enumerable calling convention.

Methods in org.apache.calcite.adapter.enumerable that return RelNode

Modifier and Type	Method and Description
RelNode	EnumerableAggregateRule.convert(RelNode rel)
RelNode	EnumerableBindable.EnumerableToBindableConverterRule.convert(RelNode rel)
RelNode	EnumerableJoinRule.convert(RelNode rel)
RelNode	EnumerableTableModifyRule.convert(RelNode rel)
RelNode	EnumerableIntersectRule.convert(RelNode rel)
RelNode	EnumerableWindowRule.convert(RelNode rel)
RelNode	EnumerableUncollectRule.convert(RelNode rel)
RelNode	EnumerableSemiJoinRule.convert(RelNode rel)
RelNode	EnumerableValuesRule.convert(RelNode rel)
RelNode	EnumerableTableFunctionScanRule.convert(RelNode rel)
RelNode	EnumerableUnionRule.convert(RelNode rel)
RelNode	EnumerableMergeJoinRule.convert(RelNode rel)
RelNode	EnumerableProjectRule.convert(RelNode rel)
RelNode	EnumerableTableScanRule.convert(RelNode rel)
RelNode	EnumerableSortRule.convert(RelNode rel)
RelNode	EnumerableCalcRule.convert(RelNode rel)
RelNode	EnumerableFilterRule.convert(RelNode rel)
RelNode	EnumerableCorrelateRule.convert(RelNode rel)
RelNode	EnumerableInterpreterRule.convert(RelNode rel)
RelNode	EnumerableCollectRule.convert(RelNode rel)
RelNode	EnumerableMinusRule.convert(RelNode rel)
RelNode	EnumerableInterpreter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableTableModify.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableWindow.copy(RelTraitSet traitSet, List<RelNode> inputs)

Methods in org.apache.calcite.adapter.enumerable with parameters of type RelNode

Modifier and Type	Method and Description
RelNode	EnumerableAggregateRule.convert(RelNode rel)
RelNode	EnumerableBindable.EnumerableToBindableConverterRule.convert(RelNode rel)
RelNode	EnumerableJoinRule.convert(RelNode rel)
RelNode	EnumerableTableModifyRule.convert(RelNode rel)
RelNode	EnumerableIntersectRule.convert(RelNode rel)
RelNode	EnumerableWindowRule.convert(RelNode rel)
RelNode	EnumerableUncollectRule.convert(RelNode rel)
RelNode	EnumerableSemiJoinRule.convert(RelNode rel)
RelNode	EnumerableValuesRule.convert(RelNode rel)
RelNode	EnumerableTableFunctionScanRule.convert(RelNode rel)
RelNode	EnumerableUnionRule.convert(RelNode rel)
RelNode	EnumerableMergeJoinRule.convert(RelNode rel)
RelNode	EnumerableProjectRule.convert(RelNode rel)
RelNode	EnumerableTableScanRule.convert(RelNode rel)
RelNode	EnumerableSortRule.convert(RelNode rel)
RelNode	EnumerableCalcRule.convert(RelNode rel)
RelNode	EnumerableFilterRule.convert(RelNode rel)
RelNode	EnumerableCorrelateRule.convert(RelNode rel)
RelNode	EnumerableInterpreterRule.convert(RelNode rel)
RelNode	EnumerableCollectRule.convert(RelNode rel)
RelNode	EnumerableMinusRule.convert(RelNode rel)
EnumerableUncollect	EnumerableUncollect.copy(RelTraitSet traitSet, RelNode newInput)
EnumerableCollect	EnumerableCollect.copy(RelTraitSet traitSet, RelNode newInput)
EnumerableAggregate	EnumerableAggregate.copy(RelTraitSet traitSet, RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
EnumerableProject	EnumerableProject.copy(RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType)
EnumerableSort	EnumerableSort.copy(RelTraitSet traitSet, RelNode newInput, RelCollation newCollation, RexNode offset, RexNode fetch)
EnumerableCorrelate	EnumerableCorrelate.copy(RelTraitSet traitSet, RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType)
EnumerableFilter	EnumerableFilter.copy(RelTraitSet traitSet, RelNode input, RexNode condition)
EnumerableCalc	EnumerableCalc.copy(RelTraitSet traitSet, RelNode child, RexProgram program)
SemiJoin	EnumerableSemiJoin.copy(RelTraitSet traitSet, RexNode condition, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
EnumerableJoin	EnumerableJoin.copy(RelTraitSet traitSet, RexNode condition, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
EnumerableThetaJoin	EnumerableThetaJoin.copy(RelTraitSet traitSet, RexNode condition, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
EnumerableMergeJoin	EnumerableMergeJoin.copy(RelTraitSet traitSet, RexNode condition, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
static EnumerableInterpreter	EnumerableInterpreter.create(RelNode input, double factor) Creates an EnumerableInterpreter.
static EnumerableProject	EnumerableProject.create(RelNode input, List<? extends RexNode> projects, RelDataType rowType) Creates an EnumerableProject, specifying row type rather than field names.
static EnumerableSort	EnumerableSort.create(RelNode child, RelCollation collation, RexNode offset, RexNode fetch) Creates an EnumerableSort.
static EnumerableMergeJoin	EnumerableMergeJoin.create(RelNode left, RelNode right, RexLiteral condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, JoinRelType joinType)
static EnumerableSemiJoin	EnumerableSemiJoin.create(RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys) Creates an EnumerableSemiJoin.
static EnumerableJoin	EnumerableJoin.create(RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
static EnumerableJoin	EnumerableJoin.create(RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates an EnumerableJoin.
static EnumerableFilter	EnumerableFilter.create(RelNode input, RexNode condition) Creates an EnumerableFilter.
static EnumerableLimit	EnumerableLimit.create(RelNode input, RexNode offset, RexNode fetch) Creates an EnumerableLimit.
static EnumerableCalc	EnumerableCalc.create(RelNode input, RexProgram program) Creates an EnumerableCalc.
static EnumerableUncollect	EnumerableUncollect.create(RelTraitSet traitSet, RelNode input, boolean withOrdinality) Creates an EnumerableUncollect.

Method parameters in org.apache.calcite.adapter.enumerable with type arguments of type RelNode

Modifier and Type	Method and Description
EnumerableBindable	EnumerableBindable.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableInterpreter.copy(RelTraitSet traitSet, List<RelNode> inputs)
EnumerableLimit	EnumerableLimit.copy(RelTraitSet traitSet, List<RelNode> newInputs)
RelNode	EnumerableTableModify.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
EnumerableInterpretable	EnumerableInterpretable.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	EnumerableWindow.copy(RelTraitSet traitSet, List<RelNode> inputs)
EnumerableUnion	EnumerableUnion.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
EnumerableIntersect	EnumerableIntersect.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
EnumerableMinus	EnumerableMinus.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
EnumerableTableFunctionScan	EnumerableTableFunctionScan.copy(RelTraitSet traitSet, List<RelNode> inputs, RexNode rexCall, Type elementType, RelDataType rowType, Set<RelColumnMapping> columnMappings)

Constructors in org.apache.calcite.adapter.enumerable with parameters of type RelNode

Constructor and Description
EnumerableAggregate(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
EnumerableBindable(RelOptCluster cluster, RelNode input)
EnumerableCalc(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexProgram program) Creates an EnumerableCalc.
EnumerableCalc(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexProgram program, List<RelCollation> collationList) Deprecated.
EnumerableCollect(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, String fieldName)
EnumerableCorrelate(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType)
EnumerableFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RexNode condition) Creates an EnumerableFilter.
EnumerableInterpretable(RelOptCluster cluster, RelNode input)
EnumerableInterpreter(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, double factor) Creates an EnumerableInterpreter.
EnumerableJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
EnumerableJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates an EnumerableJoin.
EnumerableLimit(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexNode offset, RexNode fetch) Creates an EnumerableLimit.
EnumerableMergeJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
EnumerableMergeJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, Set<CorrelationId> variablesSet, JoinRelType joinType)
EnumerableProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType) Creates an EnumerableProject.
EnumerableProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType, int flags) Deprecated.
EnumerableSemiJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys) Creates an EnumerableSemiJoin.
EnumerableSort(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Creates an EnumerableSort.
EnumerableTableModify(RelOptCluster cluster, RelTraitSet traits, RelOptTable table, Prepare.CatalogReader catalogReader, RelNode child, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened)
EnumerableThetaJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
EnumerableThetaJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates an EnumerableThetaJoin.
EnumerableUncollect(RelOptCluster cluster, RelTraitSet traitSet, RelNode child) Deprecated.
EnumerableUncollect(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, boolean withOrdinality) Creates an EnumerableUncollect.
EnumerableWindow(RelOptCluster cluster, RelTraitSet traits, RelNode child, List<RexLiteral> constants, RelDataType rowType, List<Window.Group> groups) Creates an EnumerableWindowRel.

Constructor parameters in org.apache.calcite.adapter.enumerable with type arguments of type RelNode

Constructor and Description
EnumerableIntersect(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all)
EnumerableMinus(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all)
EnumerableTableFunctionScan(RelOptCluster cluster, RelTraitSet traits, List<RelNode> inputs, Type elementType, RelDataType rowType, RexNode call, Set<RelColumnMapping> columnMappings)
EnumerableUnion(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all)

Uses of RelNode in org.apache.calcite.adapter.jdbc

Subinterfaces of RelNode in org.apache.calcite.adapter.jdbc

Modifier and Type	Interface and Description
interface	JdbcRel Relational expression that uses JDBC calling convention.

Classes in org.apache.calcite.adapter.jdbc that implement RelNode

Modifier and Type	Class and Description
static class	JdbcRules.JdbcAggregate Aggregate operator implemented in JDBC convention.
static class	JdbcRules.JdbcCalc Calc operator implemented in JDBC convention.
static class	JdbcRules.JdbcFilter Implementation of Filter in jdbc calling convention.
static class	JdbcRules.JdbcIntersect Intersect operator implemented in JDBC convention.
static class	JdbcRules.JdbcJoin Join operator implemented in JDBC convention.
static class	JdbcRules.JdbcMinus Minus operator implemented in JDBC convention.
static class	JdbcRules.JdbcProject Implementation of Project in jdbc calling convention.
static class	JdbcRules.JdbcSort Sort operator implemented in JDBC convention.
static class	JdbcRules.JdbcTableModify Table-modification operator implemented in JDBC convention.
static class	JdbcRules.JdbcUnion Union operator implemented in JDBC convention.
static class	JdbcRules.JdbcValues Values operator implemented in JDBC convention.
class	JdbcTableScan Relational expression representing a scan of a table in a JDBC data source.
class	JdbcToEnumerableConverter Relational expression representing a scan of a table in a JDBC data source.

Methods in org.apache.calcite.adapter.jdbc that return RelNode

Modifier and Type	Method and Description
RelNode	JdbcRules.JdbcJoinRule.convert(Join join, boolean convertInputTraits) Converts a Join into a JdbcJoin.
RelNode	JdbcRules.JdbcJoinRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcCalcRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcProjectRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcFilterRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcAggregateRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcSortRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcUnionRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcIntersectRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcMinusRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcTableModificationRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcValuesRule.convert(RelNode rel)
RelNode	JdbcToEnumerableConverterRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcSortRule.convert(Sort sort, boolean convertInputTraits) Converts a Sort into a JdbcSort.
RelNode	JdbcToEnumerableConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcRules.JdbcCalc.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcRules.JdbcTableModify.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcRules.JdbcValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcTable.toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable)

Methods in org.apache.calcite.adapter.jdbc with parameters of type RelNode

Modifier and Type	Method and Description
RelNode	JdbcRules.JdbcJoinRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcCalcRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcProjectRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcFilterRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcAggregateRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcSortRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcUnionRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcIntersectRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcMinusRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcTableModificationRule.convert(RelNode rel)
RelNode	JdbcRules.JdbcValuesRule.convert(RelNode rel)
RelNode	JdbcToEnumerableConverterRule.convert(RelNode rel)
JdbcRules.JdbcAggregate	JdbcRules.JdbcAggregate.copy(RelTraitSet traitSet, RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
JdbcRules.JdbcProject	JdbcRules.JdbcProject.copy(RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType)
JdbcRules.JdbcSort	JdbcRules.JdbcSort.copy(RelTraitSet traitSet, RelNode newInput, RelCollation newCollation, RexNode offset, RexNode fetch)
JdbcRules.JdbcFilter	JdbcRules.JdbcFilter.copy(RelTraitSet traitSet, RelNode input, RexNode condition)
JdbcRules.JdbcJoin	JdbcRules.JdbcJoin.copy(RelTraitSet traitSet, RexNode condition, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
SqlImplementor.Result	JdbcImplementor.implement(RelNode node)
TableModify	JdbcTable.toModificationRel(RelOptCluster cluster, RelOptTable table, Prepare.CatalogReader catalogReader, RelNode input, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened)

Method parameters in org.apache.calcite.adapter.jdbc with type arguments of type RelNode

Modifier and Type	Method and Description
RelNode	JdbcToEnumerableConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcRules.JdbcCalc.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcRules.JdbcTableModify.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcRules.JdbcValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	JdbcTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
JdbcRules.JdbcUnion	JdbcRules.JdbcUnion.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
JdbcRules.JdbcIntersect	JdbcRules.JdbcIntersect.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
JdbcRules.JdbcMinus	JdbcRules.JdbcMinus.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)

Constructors in org.apache.calcite.adapter.jdbc with parameters of type RelNode

Constructor and Description
JdbcAggregate(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
JdbcCalc(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexProgram program)
JdbcCalc(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexProgram program, int flags) Deprecated.
JdbcFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexNode condition)
JdbcJoin(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
JdbcJoin(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates a JdbcJoin.
JdbcProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType)
JdbcProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType, int flags) Deprecated.
JdbcSort(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelCollation collation, RexNode offset, RexNode fetch)
JdbcTableModify(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable table, Prepare.CatalogReader catalogReader, RelNode input, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened)
JdbcToEnumerableConverter(RelOptCluster cluster, RelTraitSet traits, RelNode input)

Constructor parameters in org.apache.calcite.adapter.jdbc with type arguments of type RelNode

Constructor and Description
JdbcConverterRule(Class<? extends RelNode> clazz, RelTrait in, JdbcConvention out, String description)
JdbcIntersect(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all)
JdbcMinus(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all)
JdbcUnion(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all)

Uses of RelNode in org.apache.calcite.interpreter

Subinterfaces of RelNode in org.apache.calcite.interpreter

Modifier and Type	Interface and Description
interface	BindableRel Relational expression that can implement itself in Bindable convention.
interface	InterpretableRel Relational expression that can implement itself using an interpreter.

Classes in org.apache.calcite.interpreter that implement RelNode

Modifier and Type	Class and Description
static class	Bindables.BindableAggregate Implementation of Aggregate in bindable calling convention.
static class	Bindables.BindableFilter Implementation of Filter in bindable convention.
static class	Bindables.BindableJoin Implementation of Join in bindable calling convention.
static class	Bindables.BindableProject Implementation of Project in bindable calling convention.
static class	Bindables.BindableSort Implementation of Sort bindable calling convention.
static class	Bindables.BindableTableScan Scan of a table that implements ScannableTable and therefore can be converted into an Enumerable.
static class	Bindables.BindableUnion Implementation of Union in bindable calling convention.
static class	Bindables.BindableValues Implementation of Values in bindable calling convention.
static class	Bindables.BindableWindow Implementation of Window in bindable convention.
class	InterpretableConverter Relational expression that converts any relational expression input to InterpretableConvention, by wrapping it in an interpreter.

Fields in org.apache.calcite.interpreter declared as RelNode

Modifier and Type	Field and Description
(package private) RelNode	Interpreter.NodeInfo.rel
protected RelNode	Interpreter.CompilerImpl.rel
private RelNode	Interpreter.rootRel
protected RelNode	Interpreter.CompilerImpl.rootRel

Fields in org.apache.calcite.interpreter with type parameters of type RelNode

Modifier and Type	Field and Description
private ReflectiveVisitDispatcher<Interpreter.CompilerImpl,RelNode>	Interpreter.CompilerImpl.dispatcher
private Map<RelNode,Interpreter.NodeInfo>	Interpreter.nodes
(package private) Map<RelNode,Interpreter.NodeInfo>	Interpreter.CompilerImpl.nodes
(package private) com.google.common.collect.Multimap<RelNode,Interpreter.Edge>	Interpreter.CompilerImpl.outEdges
(package private) Map<RelNode,List<RelNode>>	Interpreter.CompilerImpl.relInputs
(package private) Map<RelNode,List<RelNode>>	Interpreter.CompilerImpl.relInputs
Map<RelNode,List<Sink>>	InterpretableRel.InterpreterImplementor.relSinks

Methods in org.apache.calcite.interpreter that return RelNode

Modifier and Type	Method and Description
RelNode	NoneToBindableConverterRule.convert(RelNode rel)
RelNode	Bindables.BindableFilterRule.convert(RelNode rel)
RelNode	Bindables.BindableProjectRule.convert(RelNode rel)
RelNode	Bindables.BindableSortRule.convert(RelNode rel)
RelNode	Bindables.BindableJoinRule.convert(RelNode rel)
RelNode	Bindables.BindableUnionRule.convert(RelNode rel)
RelNode	Bindables.BindableValuesRule.convert(RelNode rel)
RelNode	Bindables.BindableAggregateRule.convert(RelNode rel)
RelNode	Bindables.BindableWindowRule.convert(RelNode rel)
RelNode	InterpretableConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Bindables.BindableValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Bindables.BindableWindow.copy(RelTraitSet traitSet, List<RelNode> inputs)
private RelNode	Interpreter.CompilerImpl.getInput(RelNode rel, int ordinal)
private RelNode	Interpreter.optimize(RelNode rootRel)

Methods in org.apache.calcite.interpreter that return types with arguments of type RelNode

Modifier and Type	Method and Description
(package private) Pair<RelNode,Map<RelNode,Interpreter.NodeInfo>>	Interpreter.CompilerImpl.visitRoot(RelNode p) Visits the tree, starting from the root p.
(package private) Pair<RelNode,Map<RelNode,Interpreter.NodeInfo>>	Interpreter.CompilerImpl.visitRoot(RelNode p) Visits the tree, starting from the root p.

Methods in org.apache.calcite.interpreter with parameters of type RelNode

Modifier and Type	Method and Description
static ArrayBindable	Interpreters.bindable(RelNode rel) Creates a Bindable that interprets a given relational expression.
RelNode	NoneToBindableConverterRule.convert(RelNode rel)
RelNode	Bindables.BindableFilterRule.convert(RelNode rel)
RelNode	Bindables.BindableProjectRule.convert(RelNode rel)
RelNode	Bindables.BindableSortRule.convert(RelNode rel)
RelNode	Bindables.BindableJoinRule.convert(RelNode rel)
RelNode	Bindables.BindableUnionRule.convert(RelNode rel)
RelNode	Bindables.BindableValuesRule.convert(RelNode rel)
RelNode	Bindables.BindableAggregateRule.convert(RelNode rel)
RelNode	Bindables.BindableWindowRule.convert(RelNode rel)
Bindables.BindableAggregate	Bindables.BindableAggregate.copy(RelTraitSet traitSet, RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
Bindables.BindableProject	Bindables.BindableProject.copy(RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType)
Bindables.BindableSort	Bindables.BindableSort.copy(RelTraitSet traitSet, RelNode newInput, RelCollation newCollation, RexNode offset, RexNode fetch)
Bindables.BindableFilter	Bindables.BindableFilter.copy(RelTraitSet traitSet, RelNode input, RexNode condition)
Bindables.BindableJoin	Bindables.BindableJoin.copy(RelTraitSet traitSet, RexNode conditionExpr, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
static Bindables.BindableFilter	Bindables.BindableFilter.create(RelNode input, RexNode condition) Creates a BindableFilter.
void	Compiler.enumerable(RelNode rel, Enumerable<Row> rowEnumerable) Tells the interpreter that a given relational expression wishes to give its output as an enumerable.
void	Interpreter.CompilerImpl.enumerable(RelNode rel, Enumerable<Row> rowEnumerable)
private RelNode	Interpreter.CompilerImpl.getInput(RelNode rel, int ordinal)
private RelNode	Interpreter.optimize(RelNode rootRel)
void	Interpreter.CompilerImpl.rewrite(RelNode r) Fallback rewrite method.
Sink	Compiler.sink(RelNode rel) Creates a Sink for a relational expression to write into.
Sink	Interpreter.CompilerImpl.sink(RelNode rel)
Source	Compiler.source(RelNode rel, int ordinal)
Source	Interpreter.CompilerImpl.source(RelNode rel, int ordinal)
void	Interpreter.CompilerImpl.visit(RelNode p, int ordinal, RelNode parent)
(package private) Pair<RelNode,Map<RelNode,Interpreter.NodeInfo>>	Interpreter.CompilerImpl.visitRoot(RelNode p) Visits the tree, starting from the root p.

Method parameters in org.apache.calcite.interpreter with type arguments of type RelNode

Modifier and Type	Method and Description
RelDataType	Compiler.combinedRowType(List<RelNode> inputs)
RelDataType	Interpreter.CompilerImpl.combinedRowType(List<RelNode> inputs)
RelNode	InterpretableConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Bindables.BindableValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Bindables.BindableWindow.copy(RelTraitSet traitSet, List<RelNode> inputs)
Bindables.BindableUnion	Bindables.BindableUnion.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)

Constructors in org.apache.calcite.interpreter with parameters of type RelNode

Constructor and Description
BindableAggregate(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
BindableFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexNode condition)
BindableJoin(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
BindableJoin(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates a BindableJoin.
BindableProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType)
BindableSort(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelCollation collation, RexNode offset, RexNode fetch)
BindableWindow(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<RexLiteral> constants, RelDataType rowType, List<Window.Group> groups) Creates an BindableWindowRel.
Edge(RelNode parent, int ordinal)
InterpretableConverter(RelOptCluster cluster, RelTraitSet traits, RelNode input)
Interpreter(DataContext dataContext, RelNode rootRel) Creates an Interpreter.
NodeInfo(RelNode rel, Enumerable<Row> rowEnumerable)

Constructor parameters in org.apache.calcite.interpreter with type arguments of type RelNode

Constructor and Description
BindableUnion(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all)

Uses of RelNode in org.apache.calcite.jdbc

Fields in org.apache.calcite.jdbc declared as RelNode

Modifier and Type	Field and Description
RelNode	CalcitePrepare.Query.rel

Methods in org.apache.calcite.jdbc that return RelNode

Modifier and Type	Method and Description
RelNode	CalcitePrepare.SparkHandler.flattenTypes(RelOptPlanner planner, RelNode rootRel, boolean restructure)
RelNode	CalcitePrepare.Dummy.TrivialSparkHandler.flattenTypes(RelOptPlanner planner, RelNode rootRel, boolean restructure)

Methods in org.apache.calcite.jdbc with parameters of type RelNode

Modifier and Type	Method and Description
RelNode	CalcitePrepare.SparkHandler.flattenTypes(RelOptPlanner planner, RelNode rootRel, boolean restructure)
RelNode	CalcitePrepare.Dummy.TrivialSparkHandler.flattenTypes(RelOptPlanner planner, RelNode rootRel, boolean restructure)
static <T> CalcitePrepare.Query<T>	CalcitePrepare.Query.of(RelNode rel)

Constructors in org.apache.calcite.jdbc with parameters of type RelNode

Constructor and Description
Query(String sql, Queryable<T> queryable, RelNode rel)

Uses of RelNode in org.apache.calcite.materialize

Fields in org.apache.calcite.materialize with type parameters of type RelNode

Modifier and Type	Field and Description
static DirectedGraph.EdgeFactory<RelNode,Lattice.Edge>	Lattice.Edge.FACTORY

Methods in org.apache.calcite.materialize that return RelNode

Modifier and Type	Method and Description
RelNode	Lattice.Edge.getSource()
RelNode	Lattice.Edge.getTarget()

Methods in org.apache.calcite.materialize with parameters of type RelNode

Modifier and Type	Method and Description
private static boolean	Lattice.populate(List<RelNode> nodes, List<int[][]> tempLinks, RelNode rel)

Method parameters in org.apache.calcite.materialize with type arguments of type RelNode

Modifier and Type	Method and Description
private static int[][]	Lattice.grab(List<RelNode> leaves, RexNode rex) Converts an "t1.c1 = t2.c2" expression into two (input, field) pairs.
private static int[]	Lattice.inputField(List<RelNode> leaves, RexNode rex) Converts an expression into an (input, field) pair.
private static boolean	Lattice.populate(List<RelNode> nodes, List<int[][]> tempLinks, RelNode rel)

Constructors in org.apache.calcite.materialize with parameters of type RelNode

Constructor and Description
Edge(RelNode source, RelNode target)

Uses of RelNode in org.apache.calcite.plan

Fields in org.apache.calcite.plan declared as RelNode

Modifier and Type	Field and Description
RelNode	RelOptMaterialization.queryRel
RelNode	RelOptUtil.Exists.r
private RelNode	RelOptListener.RelEvent.rel
RelNode[]	RelOptRuleCall.rels
RelNode	RelOptMaterialization.tableRel

Fields in org.apache.calcite.plan with type parameters of type RelNode

Modifier and Type	Field and Description
private Set<Class<? extends RelNode>>	AbstractRelOptPlanner.classes
private Class<? extends RelNode>	RelOptRuleOperand.clazz
private Map<String,RelNode>	RelOptCluster.mapCorrelToRel
(package private) Map<String,RelNode>	RelOptQuery.mapCorrelToRel Maps name of correlating variable (e.g.
protected Map<RelNode,List<RelNode>>	RelOptRuleCall.nodeInputs
protected Map<RelNode,List<RelNode>>	RelOptRuleCall.nodeInputs
private List<RelNode>	RelOptRuleCall.parents
private com.google.common.base.Predicate<RelNode>	RelOptRuleOperand.predicate
private Class<? extends RelNode>	Convention.Impl.relClass

Methods in org.apache.calcite.plan with type parameters of type RelNode

Modifier and Type	Method and Description
static <T extends RelNode> T	RelOptUtil.addTrait(T rel, RelTrait trait)
protected static <R extends RelNode> RelOptRule.ConverterRelOptRuleOperand	RelOptRule.convertOperand(Class<R> clazz, com.google.common.base.Predicate<? super R> predicate, RelTrait trait) Creates an operand for a converter rule.
static <R extends RelNode> RelOptRuleOperand	RelOptRule.operand(Class<R> clazz, RelOptRuleOperandChildren operandList) Creates an operand that matches a relational expression that has no children.
static <R extends RelNode> RelOptRuleOperand	RelOptRule.operand(Class<R> clazz, RelOptRuleOperand first, RelOptRuleOperand... rest) Creates an operand that matches a relational expression with a given list of children.
static <R extends RelNode> RelOptRuleOperand	RelOptRule.operand(Class<R> clazz, RelTrait trait, com.google.common.base.Predicate<? super R> predicate, RelOptRuleOperandChildren operandList) Creates an operand that matches a relational expression that has a particular trait and predicate.
static <R extends RelNode> RelOptRuleOperand	RelOptRule.operand(Class<R> clazz, RelTrait trait, com.google.common.base.Predicate<? super R> predicate, RelOptRuleOperand first, RelOptRuleOperand... rest) Creates an operand that matches a relational expression that has no children.
static <R extends RelNode> RelOptRuleOperand	RelOptRule.operand(Class<R> clazz, RelTrait trait, RelOptRuleOperandChildren operandList) Creates an operand that matches a relational expression that has no children.
<T extends RelNode> T	RelOptRuleCall.rel(int ordinal) Retrieves the ordinalth matched relational expression.

Methods in org.apache.calcite.plan that return RelNode

Modifier and Type	Method and Description
private RelNode	ConventionTraitDef.changeConvention(RelNode rel, Convention source, Convention target, com.google.common.collect.Multimap<Pair<Convention,Convention>,ConverterRule> mapArcToConverterRule) Tries to convert a relational expression to the target convention of an arc.
RelNode	RelOptPlanner.changeTraits(RelNode rel, RelTraitSet toTraits) Changes a relational expression to an equivalent one with a different set of traits.
static RelNode	RelOptRule.convert(RelNode rel, RelTrait toTrait) Converts one trait of a relational expression, if it does not already have that trait.
static RelNode	RelOptRule.convert(RelNode rel, RelTraitSet toTraits) Converts a relation expression to a given set of traits, if it does not already have those traits.
RelNode	ConventionTraitDef.convert(RelOptPlanner planner, RelNode rel, Convention toConvention, boolean allowInfiniteCostConverters)
abstract RelNode	RelTraitDef.convert(RelOptPlanner planner, RelNode rel, T toTrait, boolean allowInfiniteCostConverters) Converts the given RelNode to the given RelTrait.
static RelNode	RelOptUtil.createCastRel(RelNode rel, RelDataType castRowType, boolean rename) Creates a projection which casts a rel's output to a desired row type.
static RelNode	RelOptUtil.createCastRel(RelNode rel, RelDataType castRowType, boolean rename, RelFactories.ProjectFactory projectFactory) Creates a projection which casts a rel's output to a desired row type.
static RelNode	RelOptUtil.createDistinctRel(RelNode rel) Deprecated. Use RelBuilder.distinct().
static RelNode	RelOptUtil.createExistsPlan(RelOptCluster cluster, RelNode seekRel, List<RexNode> conditions, RexLiteral extraExpr, String extraName) Deprecated.
static RelNode	RelOptUtil.createFilter(RelNode child, Iterable<? extends RexNode> conditions) Creates a filter, using the default filter factory, or returns the original relational expression if the condition is trivial.
static RelNode	RelOptUtil.createFilter(RelNode child, Iterable<? extends RexNode> conditions, RelFactories.FilterFactory filterFactory) Creates a filter using the default factory, or returns the original relational expression if the condition is trivial.
static RelNode	RelOptUtil.createFilter(RelNode child, RexNode condition) Deprecated.
static RelNode	RelOptUtil.createFilter(RelNode child, RexNode condition, RelFactories.FilterFactory filterFactory) Deprecated.
static RelNode	RelOptUtil.createNullFilter(RelNode rel, Integer[] fieldOrdinals) Deprecated.
static RelNode	RelOptUtil.createProject(RelFactories.ProjectFactory factory, RelNode child, List<Integer> posList) Creates a relational expression that projects the given fields of the input.
static RelNode	RelOptUtil.createProject(RelNode child, List<? extends RexNode> exprList, List<String> fieldNameList) Creates a relational expression which projects a list of expressions.
static RelNode	RelOptUtil.createProject(RelNode child, List<? extends RexNode> exprs, List<String> fieldNames, boolean optimize) Creates a relational expression which projects an array of expressions, and optionally optimizes.
static RelNode	RelOptUtil.createProject(RelNode child, List<? extends RexNode> exprs, List<String> fieldNames, boolean optimize, RelBuilder relBuilder) Creates a relational expression which projects an array of expressions, and optionally optimizes.
static RelNode	RelOptUtil.createProject(RelNode child, List<Integer> posList) Creates a relational expression that projects the given fields of the input.
static RelNode	RelOptUtil.createProject(RelNode child, List<Pair<RexNode,String>> projectList, boolean optimize) Creates a relational expression which projects a list of (expression, name) pairs.
static RelNode	RelOptUtil.createProject(RelNode child, Mappings.TargetMapping mapping) Creates a LogicalProject that projects particular fields of its input, according to a mapping.
static RelNode	RelOptUtil.createProject(RelNode child, Mappings.TargetMapping mapping, RelFactories.ProjectFactory projectFactory)
static RelNode	RelOptUtil.createProjectJoinRel(List<Integer> outputProj, RelNode joinRel) Deprecated.
static RelNode	RelOptUtil.createRename(RelNode rel, List<String> fieldNames) Deprecated.
static RelNode	RelOptUtil.createRenameRel(RelDataType outputType, RelNode rel) Deprecated.
static RelNode	RelOptUtil.createSingleValueAggRel(RelOptCluster cluster, RelNode rel) Creates a LogicalAggregate that removes all duplicates from the result of an underlying relational expression.
RelNode	RelOptPlanner.ensureRegistered(RelNode rel, RelNode equivRel) Registers a relational expression if it is not already registered.
RelNode	RelOptPlanner.findBestExp() Finds the most efficient expression to implement this query.
RelNode	RelOptListener.RelEvent.getRel()
RelNode[]	RelOptRuleCall.getRels() Deprecated. Use RelOptRuleCall.getRelList() or RelOptRuleCall.rel(int)
RelNode	RelOptPlanner.getRoot() Returns the root node of this query.
RelNode	SubstitutionVisitor.go0(RelNode replacement_)
RelNode	RelOptQuery.lookupCorrel(String name) Returns the relational expression which populates a correlating variable.
static RelNode	RelOptUtil.permute(RelNode rel, Permutation permutation, List<String> fieldNames) Creates a relational expression which permutes the output fields of a relational expression according to a permutation.
static RelNode	RelOptUtil.projectMapping(RelNode rel, Mapping mapping, List<String> fieldNames, RelFactories.ProjectFactory projectFactory) Deprecated.
static RelNode	RelOptUtil.pushDownJoinConditions(Join originalJoin) Deprecated.
static RelNode	RelOptUtil.pushDownJoinConditions(Join originalJoin, RelBuilder relBuilder) Pushes down expressions in "equal" join condition.
private static RelNode	RelOptUtil.pushDownJoinConditions(Join originalJoin, RelBuilderFactory relBuilderFactory)
static RelNode	RelOptUtil.pushDownJoinConditions(Join originalJoin, RelFactories.ProjectFactory projectFactory) Deprecated.
RelNode	RelOptPlanner.register(RelNode rel, RelNode equivRel) Registers a relational expression in the expression bank.
static RelNode	RelOptUtil.renameIfNecessary(RelNode rel, RelDataType desiredRowType) Deprecated.
static RelNode	RelOptUtil.replace(RelNode query, RelNode find, RelNode replace) Within a relational expression query, replaces occurrences of find with replace.
static RelNode	RelOptUtil.replaceInput(RelNode parent, int ordinal, RelNode newInput) Returns a shallow copy of a relational expression with a particular input replaced.
private static RelNode	RelOptUtil.replaceRecurse(RelNode query, RelNode find, RelNode replace) Helper for RelOptUtil.replace(org.apache.calcite.rel.RelNode, org.apache.calcite.rel.RelNode, org.apache.calcite.rel.RelNode).
RelNode	RelOptLattice.rewrite(RelNode node) Rewrites a relational expression to use a lattice.
static RelNode	RelOptMaterialization.toLeafJoinForm(RelNode rel) Converts a relational expression to a form where LogicalJoins are as close to leaves as possible.
RelNode	RelOptTable.toRel(RelOptTable.ToRelContext context) Converts this table into a relational expression.
RelNode	RelOptAbstractTable.toRel(RelOptTable.ToRelContext context)
static RelNode	RelOptMaterialization.tryUseStar(RelNode rel, RelOptTable starRelOptTable) Converts a relational expression to one that uses a StarTable.
RelNode	RelOptUtil.CorrelationCollector.visit(RelNode other)

Methods in org.apache.calcite.plan that return types with arguments of type RelNode

Modifier and Type	Method and Description
protected static List<RelNode>	RelOptRule.convertList(List<RelNode> rels, RelTrait trait) Converts a list of relational expressions.
List<RelNode>	RelOptRuleCall.getChildRels(RelNode rel) Returns the children of a given relational expression node matched in a rule.
Class<? extends RelNode>	RelOptRuleOperand.getMatchedClass()
List<RelNode>	RelOptRuleCall.getParents()
List<RelNode>	RelOptRuleCall.getRelList() Returns a list of matched relational expressions.
List<RelNode>	MaterializedViewSubstitutionVisitor.go(RelNode replacement_)
List<RelNode>	SubstitutionVisitor.go(RelNode replacement_) Returns a list of all possible rels that result from substituting the matched RelNode with the replacement RelNode within the query.
Iterable<Class<? extends RelNode>>	AbstractRelOptPlanner.subClasses(Class<? extends RelNode> clazz) Returns sub-classes of relational expression.
private static List<RelNode>	RelOptMaterializations.substitute(RelNode root, RelOptMaterialization materialization)
static List<Pair<RelNode,RelOptLattice>>	RelOptMaterializations.useLattices(RelNode rel, List<RelOptLattice> lattices) Returns a list of RelNode transformed from all possible lattice uses.
static List<Pair<RelNode,List<RelOptMaterialization>>>	RelOptMaterializations.useMaterializedViews(RelNode rel, List<RelOptMaterialization> materializations) Returns a list of RelNode transformed from all possible combination of materialized view uses.

Methods in org.apache.calcite.plan with parameters of type RelNode

Modifier and Type	Method and Description
boolean	RelTraitDef.canConvert(RelOptPlanner planner, T fromTrait, T toTrait, RelNode fromRel) Tests whether the given RelTrait can be converted to another RelTrait.
private RelNode	ConventionTraitDef.changeConvention(RelNode rel, Convention source, Convention target, com.google.common.collect.Multimap<Pair<Convention,Convention>,ConverterRule> mapArcToConverterRule) Tries to convert a relational expression to the target convention of an arc.
RelNode	RelOptPlanner.changeTraits(RelNode rel, RelTraitSet toTraits) Changes a relational expression to an equivalent one with a different set of traits.
static boolean	RelOptUtil.classifyFilters(RelNode joinRel, List<RexNode> filters, JoinRelType joinType, boolean pushInto, boolean pushLeft, boolean pushRight, List<RexNode> joinFilters, List<RexNode> leftFilters, List<RexNode> rightFilters) Classifies filters according to where they should be processed.
static boolean	RelOptUtil.contains(RelNode ancestor, RelNode target) Returns whether relational expression target occurs within a relational expression ancestor.
private static boolean	RelOptUtil.containsNullableFields(RelNode r) Determines whether any of the fields in a given relational expression may contain null values, taking into account constraints on the field types and also deduced predicates.
static RelNode	RelOptRule.convert(RelNode rel, RelTrait toTrait) Converts one trait of a relational expression, if it does not already have that trait.
static RelNode	RelOptRule.convert(RelNode rel, RelTraitSet toTraits) Converts a relation expression to a given set of traits, if it does not already have those traits.
RelNode	ConventionTraitDef.convert(RelOptPlanner planner, RelNode rel, Convention toConvention, boolean allowInfiniteCostConverters)
abstract RelNode	RelTraitDef.convert(RelOptPlanner planner, RelNode rel, T toTrait, boolean allowInfiniteCostConverters) Converts the given RelNode to the given RelTrait.
static ImmutableBitSet	RelOptUtil.correlationColumns(CorrelationId id, RelNode rel) Finds which columns of a correlation variable are used within a relational expression.
static int	RelOptUtil.countJoins(RelNode rootRel) Returns the number of Join nodes in a tree.
static RelNode	RelOptUtil.createCastRel(RelNode rel, RelDataType castRowType, boolean rename) Creates a projection which casts a rel's output to a desired row type.
static RelNode	RelOptUtil.createCastRel(RelNode rel, RelDataType castRowType, boolean rename, RelFactories.ProjectFactory projectFactory) Creates a projection which casts a rel's output to a desired row type.
static RelNode	RelOptUtil.createDistinctRel(RelNode rel) Deprecated. Use RelBuilder.distinct().
static RexNode	RelOptUtil.createEquiJoinCondition(RelNode left, List<Integer> leftKeys, RelNode right, List<Integer> rightKeys, RexBuilder rexBuilder) Builds an equi-join condition from a set of left and right keys.
static RelOptUtil.Exists	RelOptUtil.createExistsPlan(RelNode seekRel, RelOptUtil.SubQueryType subQueryType, RelOptUtil.Logic logic, boolean notIn) Creates a plan suitable for use in EXISTS or IN statements.
static RelNode	RelOptUtil.createExistsPlan(RelOptCluster cluster, RelNode seekRel, List<RexNode> conditions, RexLiteral extraExpr, String extraName) Deprecated.
static RelNode	RelOptUtil.createFilter(RelNode child, Iterable<? extends RexNode> conditions) Creates a filter, using the default filter factory, or returns the original relational expression if the condition is trivial.
static RelNode	RelOptUtil.createFilter(RelNode child, Iterable<? extends RexNode> conditions, RelFactories.FilterFactory filterFactory) Creates a filter using the default factory, or returns the original relational expression if the condition is trivial.
static RelNode	RelOptUtil.createFilter(RelNode child, RexNode condition) Deprecated.
static RelNode	RelOptUtil.createFilter(RelNode child, RexNode condition, RelFactories.FilterFactory filterFactory) Deprecated.
static RelNode	RelOptUtil.createNullFilter(RelNode rel, Integer[] fieldOrdinals) Deprecated.
static RelNode	RelOptUtil.createProject(RelFactories.ProjectFactory factory, RelNode child, List<Integer> posList) Creates a relational expression that projects the given fields of the input.
static RelNode	RelOptUtil.createProject(RelNode child, List<? extends RexNode> exprList, List<String> fieldNameList) Creates a relational expression which projects a list of expressions.
static RelNode	RelOptUtil.createProject(RelNode child, List<? extends RexNode> exprs, List<String> fieldNames, boolean optimize) Creates a relational expression which projects an array of expressions, and optionally optimizes.
static RelNode	RelOptUtil.createProject(RelNode child, List<? extends RexNode> exprs, List<String> fieldNames, boolean optimize, RelBuilder relBuilder) Creates a relational expression which projects an array of expressions, and optionally optimizes.
static RelNode	RelOptUtil.createProject(RelNode child, List<Integer> posList) Creates a relational expression that projects the given fields of the input.
static RelNode	RelOptUtil.createProject(RelNode child, List<Pair<RexNode,String>> projectList, boolean optimize) Creates a relational expression which projects a list of (expression, name) pairs.
static RelNode	RelOptUtil.createProject(RelNode child, Mappings.TargetMapping mapping) Creates a LogicalProject that projects particular fields of its input, according to a mapping.
static RelNode	RelOptUtil.createProject(RelNode child, Mappings.TargetMapping mapping, RelFactories.ProjectFactory projectFactory)
static RelNode	RelOptUtil.createProjectJoinRel(List<Integer> outputProj, RelNode joinRel) Deprecated.
static RelNode	RelOptUtil.createRename(RelNode rel, List<String> fieldNames) Deprecated.
static RelNode	RelOptUtil.createRenameRel(RelDataType outputType, RelNode rel) Deprecated.
static RelNode	RelOptUtil.createSingleValueAggRel(RelOptCluster cluster, RelNode rel) Creates a LogicalAggregate that removes all duplicates from the result of an underlying relational expression.
static List<RexNode>	RelOptUtil.createSwappedJoinExprs(RelNode newJoin, Join origJoin, boolean origOrder) Creates projection expressions reflecting the swapping of a join's input.
static String	RelOptUtil.dumpPlan(String header, RelNode rel, boolean asXml, SqlExplainLevel detailLevel) Deprecated.
static String	RelOptUtil.dumpPlan(String header, RelNode rel, SqlExplainFormat format, SqlExplainLevel detailLevel) Dumps a plan as a string.
RelNode	RelOptPlanner.ensureRegistered(RelNode rel, RelNode equivRel) Registers a relational expression if it is not already registered.
static boolean	RelOptUtil.equalType(String desc0, RelNode rel0, String desc1, RelNode rel1, Litmus litmus) Returns whether two relational expressions have the same row-type.
static List<String>	RelOptUtil.findAllTableQualifiedNames(RelNode rel) Returns a list of all table qualified names used by this expression or its children.
static List<RelOptTable>	RelOptUtil.findAllTables(RelNode rel) Returns a list of all tables used by this expression or its children
static Set<RelOptTable>	RelOptUtil.findTables(RelNode rel) Returns a set of tables used by this expression or its children
static List<RelOptMaterialization>	RelOptMaterializations.getApplicableMaterializations(RelNode rel, List<RelOptMaterialization> materializations) Returns a list of materializations that can potentially be used by the query.
List<RelNode>	RelOptRuleCall.getChildRels(RelNode rel) Returns the children of a given relational expression node matched in a rule.
RelOptCost	RelOptPlanner.getCost(RelNode rel) Deprecated. Use RelOptPlanner.getCost(RelNode, RelMetadataQuery) or, better, call RelMetadataQuery.getCumulativeCost(RelNode).
RelOptCost	AbstractRelOptPlanner.getCost(RelNode rel)
RelOptCost	RelOptPlanner.getCost(RelNode rel, RelMetadataQuery mq) Computes the cost of a RelNode.
RelOptCost	AbstractRelOptPlanner.getCost(RelNode rel, RelMetadataQuery mq)
long	RelOptPlanner.getRelMetadataTimestamp(RelNode rel) Gets a timestamp for a given rel's metadata.
long	AbstractRelOptPlanner.getRelMetadataTimestamp(RelNode rel)
static Set<CorrelationId>	RelOptUtil.getVariablesSet(RelNode rel) Returns a list of variables set by a relational expression or its descendants.
static List<CorrelationId>	RelOptUtil.getVariablesSetAndUsed(RelNode rel0, RelNode rel1) Deprecated.
static Set<CorrelationId>	RelOptUtil.getVariablesUsed(RelNode rel) Returns a set of variables used by a relational expression or its descendants.
List<RelNode>	MaterializedViewSubstitutionVisitor.go(RelNode replacement_)
List<RelNode>	SubstitutionVisitor.go(RelNode replacement_) Returns a list of all possible rels that result from substituting the matched RelNode with the replacement RelNode within the query.
static void	RelOptUtil.go(RelVisitor visitor, RelNode p) Sets a RelVisitor going on a given relational expression, and returns the result.
RelNode	SubstitutionVisitor.go0(RelNode replacement_)
static boolean	RelOptUtil.isEqui(RelNode left, RelNode right, RexNode condition) Deprecated.
static boolean	RelOptUtil.isLimit(RelNode rel) Whether this node contains a limit specification.
static boolean	RelOptUtil.isOrder(RelNode rel) Whether this node contains a sort specification.
static boolean	RelOptUtil.isPureLimit(RelNode rel) Whether this node is a limit without sort specification.
static boolean	RelOptUtil.isPureOrder(RelNode rel) Whether this node is a sort without limit specification.
boolean	RelOptPlanner.isRegistered(RelNode rel) Determines whether a relational expression has been registered.
void	RelOptQuery.mapCorrel(String name, RelNode rel) Maps a correlating variable to a RelNode.
boolean	RelOptRule.ConverterRelOptRuleOperand.matches(RelNode rel)
boolean	RelOptRuleOperand.matches(RelNode rel) Returns whether a relational expression matches this operand.
static boolean	RelOptUtil.notContainsCorrelation(RelNode r, CorrelationId correlationId, Litmus litmus) Returns true, and calls Litmus.succeed() if a given relational expression does not contain a given correlation.
protected void	AbstractRelOptPlanner.notifyChosen(RelNode rel) Takes care of tracing and listener notification when a rel is chosen as part of the final plan.
protected void	AbstractRelOptPlanner.notifyDiscard(RelNode rel) Takes care of tracing and listener notification when a rel is discarded
protected void	AbstractRelOptPlanner.notifyEquivalence(RelNode rel, Object equivalenceClass, boolean physical) Takes care of tracing and listener notification when a rel equivalence is detected.
protected void	AbstractRelOptPlanner.notifyTransformation(RelOptRuleCall ruleCall, RelNode newRel, boolean before) Takes care of tracing and listener notification when a rule's transformation is applied.
(package private) static RelOptMaterialization.ProjectFilterTable	RelOptMaterialization.ProjectFilterTable.of(RelNode node)
static DataContext	VisitorDataContext.of(RelNode targetRel, LogicalFilter queryRel)
private static RelOptMaterialization.ProjectFilterTable	RelOptMaterialization.ProjectFilterTable.of2(RexNode condition, RelNode node)
private static RelOptMaterialization.ProjectFilterTable	RelOptMaterialization.ProjectFilterTable.of3(RexNode condition, Mappings.TargetMapping mapping, RelNode node)
void	RelOptPlanner.onCopy(RelNode rel, RelNode newRel) Called when a relational expression is copied to a similar expression.
void	AbstractRelOptPlanner.onCopy(RelNode rel, RelNode newRel)
protected void	AbstractRelOptPlanner.onNewClass(RelNode node) Called when a new class of RelNode is seen.
static RelNode	RelOptUtil.permute(RelNode rel, Permutation permutation, List<String> fieldNames) Creates a relational expression which permutes the output fields of a relational expression according to a permutation.
static void	RelOptUtil.projectJoinInputs(RelNode[] inputRels, List<RexNode> leftJoinKeys, List<RexNode> rightJoinKeys, int systemColCount, List<Integer> leftKeys, List<Integer> rightKeys, List<Integer> outputProj) Deprecated.
static RelNode	RelOptUtil.projectMapping(RelNode rel, Mapping mapping, List<String> fieldNames, RelFactories.ProjectFactory projectFactory) Deprecated.
RelNode	RelOptPlanner.register(RelNode rel, RelNode equivRel) Registers a relational expression in the expression bank.
void	RelOptPlanner.registerClass(RelNode node) Registers a class of RelNode.
void	AbstractRelOptPlanner.registerClass(RelNode node)
static RelNode	RelOptUtil.renameIfNecessary(RelNode rel, RelDataType desiredRowType) Deprecated.
static RelNode	RelOptUtil.replace(RelNode query, RelNode find, RelNode replace) Within a relational expression query, replaces occurrences of find with replace.
static RelNode	RelOptUtil.replaceInput(RelNode parent, int ordinal, RelNode newInput) Returns a shallow copy of a relational expression with a particular input replaced.
private static RelNode	RelOptUtil.replaceRecurse(RelNode query, RelNode find, RelNode replace) Helper for RelOptUtil.replace(org.apache.calcite.rel.RelNode, org.apache.calcite.rel.RelNode, org.apache.calcite.rel.RelNode).
RelNode	RelOptLattice.rewrite(RelNode node) Rewrites a relational expression to use a lattice.
protected void	RelOptRuleCall.setChildRels(RelNode rel, List<RelNode> inputs) Assigns the input relational expressions of a given relational expression, as seen by this particular call.
void	RelOptPlanner.setImportance(RelNode rel, double importance) Sets the importance of a relational expression.
void	AbstractRelOptPlanner.setImportance(RelNode rel, double importance)
void	RelOptPlanner.setRoot(RelNode rel) Sets the root node of this query.
static JoinRelType	RelOptUtil.simplifyJoin(RelNode joinRel, com.google.common.collect.ImmutableList<RexNode> aboveFilters, JoinRelType joinType) Simplifies outer joins if filter above would reject nulls.
static RexNode	RelOptUtil.splitJoinCondition(List<RelDataTypeField> sysFieldList, RelNode leftRel, RelNode rightRel, RexNode condition, List<RexNode> leftJoinKeys, List<RexNode> rightJoinKeys, List<Integer> filterNulls, List<SqlOperator> rangeOp) Splits out the equi-join (and optionally, a single non-equi) components of a join condition, and returns what's left.
static RexNode	RelOptUtil.splitJoinCondition(RelNode left, RelNode right, RexNode condition, List<Integer> leftKeys, List<Integer> rightKeys, List<Boolean> filterNulls) Splits out the equi-join components of a join condition, and returns what's left.
private static List<RelNode>	RelOptMaterializations.substitute(RelNode root, RelOptMaterialization materialization)
static RelNode	RelOptMaterialization.toLeafJoinForm(RelNode rel) Converts a relational expression to a form where LogicalJoins are as close to leaves as possible.
static String	RelOptUtil.toString(RelNode rel) Converts a relational expression to a string, showing just basic attributes.
static String	RelOptUtil.toString(RelNode rel, SqlExplainLevel detailLevel) Converts a relational expression to a string.
void	RelOptRuleCall.transformTo(RelNode rel) Registers that a rule has produced an equivalent relational expression, but no other equivalences.
abstract void	RelOptRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv) Registers that a rule has produced an equivalent relational expression.
static RelNode	RelOptMaterialization.tryUseStar(RelNode rel, RelOptTable starRelOptTable) Converts a relational expression to one that uses a StarTable.
static List<Pair<RelNode,RelOptLattice>>	RelOptMaterializations.useLattices(RelNode rel, List<RelOptLattice> lattices) Returns a list of RelNode transformed from all possible lattice uses.
static List<Pair<RelNode,List<RelOptMaterialization>>>	RelOptMaterializations.useMaterializedViews(RelNode rel, List<RelOptMaterialization> materializations) Returns a list of RelNode transformed from all possible combination of materialized view uses.
static void	RelOptUtil.verifyTypeEquivalence(RelNode originalRel, RelNode newRel, Object equivalenceClass) Verifies that a row type being added to an equivalence class matches the existing type, raising an assertion if this is not the case.
RelNode	RelOptUtil.CorrelationCollector.visit(RelNode other)
void	TableAccessMap.TableRelVisitor.visit(RelNode p, int ordinal, RelNode parent)
void	RelTraitPropagationVisitor.visit(RelNode rel, int ordinal, RelNode parent)
void	RelOptUtil.VariableSetVisitor.visit(RelNode p, int ordinal, RelNode parent)

Method parameters in org.apache.calcite.plan with type arguments of type RelNode

Modifier and Type	Method and Description
protected static List<RelNode>	RelOptRule.convertList(List<RelNode> rels, RelTrait trait) Converts a list of relational expressions.
private static void	SubstitutionVisitor.reverseSubstitute(RelBuilder relBuilder, Holder query, List<List<SubstitutionVisitor.Replacement>> matches, List<RelNode> sub, int replaceCount, int maxCount)
protected void	RelOptRuleCall.setChildRels(RelNode rel, List<RelNode> inputs) Assigns the input relational expressions of a given relational expression, as seen by this particular call.
static RexNode	RelOptUtil.splitJoinCondition(List<RelDataTypeField> sysFieldList, List<RelNode> inputs, RexNode condition, List<List<RexNode>> joinKeys, List<Integer> filterNulls, List<SqlOperator> rangeOp) Splits out the equi-join (and optionally, a single non-equi) components of a join condition, and returns what's left.
private static void	RelOptUtil.splitJoinCondition(List<RelDataTypeField> sysFieldList, List<RelNode> inputs, RexNode condition, List<List<RexNode>> joinKeys, List<Integer> filterNulls, List<SqlOperator> rangeOp, List<RexNode> nonEquiList)
Iterable<Class<? extends RelNode>>	AbstractRelOptPlanner.subClasses(Class<? extends RelNode> clazz) Returns sub-classes of relational expression.
abstract void	RelOptRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv) Registers that a rule has produced an equivalent relational expression.
abstract void	RelOptRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv) Registers that a rule has produced an equivalent relational expression.

Constructors in org.apache.calcite.plan with parameters of type RelNode

Constructor and Description
Exists(RelNode r, boolean indicator, boolean outerJoin)
MaterializedViewSubstitutionVisitor(RelNode target_, RelNode query_)
MaterializedViewSubstitutionVisitor(RelNode target_, RelNode query_, RelBuilderFactory relBuilderFactory)
RelChosenEvent(Object eventSource, RelNode rel)
RelDiscardedEvent(Object eventSource, RelNode rel)
RelEquivalenceEvent(Object eventSource, RelNode rel, Object equivalenceClass, boolean isPhysical)
RelEvent(Object eventSource, RelNode rel)
RelOptMaterialization(RelNode tableRel, RelNode queryRel, RelOptTable starRelOptTable, List<String> qualifiedTableName) Creates a RelOptMaterialization.
RelOptRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs)
RelOptRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs, List<RelNode> parents) Creates a RelOptRuleCall.
RuleAttemptedEvent(Object eventSource, RelNode rel, RelOptRuleCall ruleCall, boolean before)
RuleEvent(Object eventSource, RelNode rel, RelOptRuleCall ruleCall)
RuleProductionEvent(Object eventSource, RelNode rel, RelOptRuleCall ruleCall, boolean before)
SubstitutionVisitor(RelNode target_, RelNode query_) Creates a SubstitutionVisitor with the default rule set.
SubstitutionVisitor(RelNode target_, RelNode query_, com.google.common.collect.ImmutableList<SubstitutionVisitor.UnifyRule> rules) Creates a SubstitutionVisitor with the default logical builder.
SubstitutionVisitor(RelNode target_, RelNode query_, com.google.common.collect.ImmutableList<SubstitutionVisitor.UnifyRule> rules, RelBuilderFactory relBuilderFactory)
TableAccessMap(RelNode rel) Constructs a TableAccessMap for all tables accessed by a RelNode and its descendants.

Constructor parameters in org.apache.calcite.plan with type arguments of type RelNode

Constructor and Description
Impl(String name, Class<? extends RelNode> relClass)
RelOptCluster(RelOptPlanner planner, RelDataTypeFactory typeFactory, RexBuilder rexBuilder, AtomicInteger nextCorrel, Map<String,RelNode> mapCorrelToRel) Creates a cluster.
RelOptQuery(RelOptPlanner planner, AtomicInteger nextCorrel, Map<String,RelNode> mapCorrelToRel) For use by RelOptCluster only.
RelOptRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs)
RelOptRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs)
RelOptRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs, List<RelNode> parents) Creates a RelOptRuleCall.
RelOptRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs, List<RelNode> parents) Creates a RelOptRuleCall.
RelOptRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs, List<RelNode> parents) Creates a RelOptRuleCall.

Uses of RelNode in org.apache.calcite.plan.hep

Classes in org.apache.calcite.plan.hep that implement RelNode

Modifier and Type	Class and Description
class	HepRelVertex HepRelVertex wraps a real RelNode as a vertex in a DAG representing the entire query expression.

Fields in org.apache.calcite.plan.hep declared as RelNode

Modifier and Type	Field and Description
private RelNode	HepRelVertex.currentRel Wrapped rel currently chosen for implementation of expression.

Fields in org.apache.calcite.plan.hep with type parameters of type RelNode

Modifier and Type	Field and Description
private Function2<RelNode,RelNode,Void>	HepPlanner.onCopyHook
private Function2<RelNode,RelNode,Void>	HepPlanner.onCopyHook
private List<RelNode>	HepRuleCall.results

Methods in org.apache.calcite.plan.hep that return RelNode

Modifier and Type	Method and Description
private RelNode	HepPlanner.buildFinalPlan(HepRelVertex vertex)
RelNode	HepPlanner.changeTraits(RelNode rel, RelTraitSet toTraits)
RelNode	HepRelVertex.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	HepPlanner.ensureRegistered(RelNode rel, RelNode equivRel)
RelNode	HepPlanner.findBestExp()
RelNode	HepRelVertex.getCurrentRel()
RelNode	HepPlanner.getRoot()
RelNode	HepPlanner.register(RelNode rel, RelNode equivRel)

Methods in org.apache.calcite.plan.hep that return types with arguments of type RelNode

Modifier and Type	Method and Description
(package private) List<RelNode>	HepRuleCall.getResults()

Methods in org.apache.calcite.plan.hep with parameters of type RelNode

Modifier and Type	Method and Description
private HepRelVertex	HepPlanner.addRelToGraph(RelNode rel)
RelNode	HepPlanner.changeTraits(RelNode rel, RelTraitSet toTraits)
RelNode	HepPlanner.ensureRegistered(RelNode rel, RelNode equivRel)
long	HepPlanner.getRelMetadataTimestamp(RelNode rel)
boolean	HepPlanner.isRegistered(RelNode rel)
private boolean	HepPlanner.matchOperands(RelOptRuleOperand operand, RelNode rel, List<RelNode> bindings, Map<RelNode,List<RelNode>> nodeChildren)
void	HepPlanner.onCopy(RelNode rel, RelNode newRel)
RelNode	HepPlanner.register(RelNode rel, RelNode equivRel)
(package private) void	HepRelVertex.replaceRel(RelNode newRel) Replaces the implementation for this expression with a new one.
void	HepPlanner.setRoot(RelNode rel)
void	HepRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv)
private void	HepPlanner.updateVertex(HepRelVertex vertex, RelNode rel)

Method parameters in org.apache.calcite.plan.hep with type arguments of type RelNode

Modifier and Type	Method and Description
<M extends Metadata> UnboundMetadata<M>	HepRelMetadataProvider.apply(Class<? extends RelNode> relClass, Class<? extends M> metadataClass)
RelNode	HepRelVertex.copy(RelTraitSet traitSet, List<RelNode> inputs)
private boolean	HepPlanner.matchOperands(RelOptRuleOperand operand, RelNode rel, List<RelNode> bindings, Map<RelNode,List<RelNode>> nodeChildren)
private boolean	HepPlanner.matchOperands(RelOptRuleOperand operand, RelNode rel, List<RelNode> bindings, Map<RelNode,List<RelNode>> nodeChildren)
private boolean	HepPlanner.matchOperands(RelOptRuleOperand operand, RelNode rel, List<RelNode> bindings, Map<RelNode,List<RelNode>> nodeChildren)
void	HepRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv)
void	HepRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv)

Constructors in org.apache.calcite.plan.hep with parameters of type RelNode

Constructor and Description
HepRelVertex(RelNode rel)
HepRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeChildren, List<RelNode> parents)

Constructor parameters in org.apache.calcite.plan.hep with type arguments of type RelNode

Constructor and Description
HepPlanner(HepProgram program, Context context, boolean noDAG, Function2<RelNode,RelNode,Void> onCopyHook, RelOptCostFactory costFactory) Creates a new HepPlanner with the option to keep the graph a tree(noDAG=true) or allow DAG(noDAG=false).
HepPlanner(HepProgram program, Context context, boolean noDAG, Function2<RelNode,RelNode,Void> onCopyHook, RelOptCostFactory costFactory) Creates a new HepPlanner with the option to keep the graph a tree(noDAG=true) or allow DAG(noDAG=false).
HepRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeChildren, List<RelNode> parents)
HepRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeChildren, List<RelNode> parents)
HepRuleCall(RelOptPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeChildren, List<RelNode> parents)

Uses of RelNode in org.apache.calcite.plan.volcano

Classes in org.apache.calcite.plan.volcano that implement RelNode

Modifier and Type	Class and Description
class	AbstractConverter Converts a relational expression to any given output convention.
class	RelSubset Subset of an equivalence class where all relational expressions have the same physical properties.

Fields in org.apache.calcite.plan.volcano declared as RelNode

Modifier and Type	Field and Description
(package private) RelNode	RelSubset.best best known plan
private RelNode	VolcanoPlanner.originalRoot
(package private) RelNode	RelSet.rel
(package private) RelNode	VolcanoPlanner.DirectProvenance.source

Fields in org.apache.calcite.plan.volcano with type parameters of type RelNode

Modifier and Type	Field and Description
private com.google.common.collect.Multimap<Class<? extends RelNode>,RelOptRuleOperand>	VolcanoPlanner.classOperands Operands that apply to a given class of RelNode.
private List<RelNode>	VolcanoRuleCall.generatedRelList List of RelNode generated by this call.
private Map<Pair<String,RelDataType>,RelNode>	VolcanoPlanner.mapDigestToRel Canonical map from digest to the unique relational expression with that digest.
private IdentityHashMap<RelNode,RelSubset>	VolcanoPlanner.mapRel2Subset Map each registered expression (RelNode) to its equivalence set (RelSubset).
(package private) List<RelNode>	RelSet.parents Relational expressions that have a subset in this set as a child.
(package private) Map<RelNode,VolcanoPlanner.Provenance>	VolcanoPlanner.provenanceMap
(package private) Map<RelNode,Double>	VolcanoPlanner.relImportances The importance of relational expressions.
(package private) com.google.common.collect.ImmutableList<RelNode>	VolcanoPlanner.RuleProvenance.rels
(package private) List<RelNode>	RelSet.rels

Methods in org.apache.calcite.plan.volcano that return RelNode

Modifier and Type	Method and Description
(package private) RelNode	RelSubset.buildCheapestPlan(VolcanoPlanner planner) Recursively builds a tree consisting of the cheapest plan at each node.
RelNode	VolcanoPlanner.changeTraits(RelNode rel, RelTraitSet toTraits)
(package private) RelNode	VolcanoPlanner.changeTraitsUsingConverters(RelNode rel, RelTraitSet toTraits)
private RelNode	VolcanoPlanner.changeTraitsUsingConverters(RelNode rel, RelTraitSet toTraits, boolean allowAbstractConverters)
private RelNode	VolcanoPlanner.completeConversion(RelNode rel, boolean allowInfiniteCostConverters, RelTraitSet toTraits, Expressions.FluentList<RelTraitDef> usedTraits) Converts traits using well-founded induction.
RelNode	RelSubset.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	AbstractConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	VolcanoPlanner.findBestExp() Finds the most efficient expression to implement the query given via RelOptPlanner.setRoot(org.apache.calcite.rel.RelNode).
RelNode	RelSubset.getBest()
RelNode	RelSubset.getOriginal()
RelNode	VolcanoPlanner.getRoot()
RelNode	RelSubset.CheapestPlanReplacer.visit(RelNode p, int ordinal, RelNode parent)

Methods in org.apache.calcite.plan.volcano that return types with arguments of type RelNode

Modifier and Type	Method and Description
Collection<RelNode>	RelSubset.getParentRels() Returns a list of relational expressions one of whose children is this subset.
List<RelNode>	RelSet.getParentRels() Returns all of the RelNodes which reference RelNodes in this set.
(package private) Set<RelNode>	RelSubset.getParents() Returns the collection of RelNodes one of whose inputs is in this subset.
List<RelNode>	RelSubset.getRelList() As RelSubset.getRels() but returns a list.
Iterable<RelNode>	RelSubset.getRels() Returns the rel nodes in this rel subset.
List<RelNode>	RelSet.getRelsFromAllSubsets()

Methods in org.apache.calcite.plan.volcano with parameters of type RelNode

Modifier and Type	Method and Description
(package private) void	RelSubset.add(RelNode rel) Adds expression rel to this subset.
RelSubset	RelSet.add(RelNode rel) Adds a relational expression to a set, with its results available under a particular calling convention.
(package private) void	RelSet.addInternal(RelNode rel) Adds an expression rel to this set, without creating a RelSubset.
private RelSubset	VolcanoPlanner.addRelToSet(RelNode rel, RelSet set)
RelNode	VolcanoPlanner.changeTraits(RelNode rel, RelTraitSet toTraits)
(package private) RelNode	VolcanoPlanner.changeTraitsUsingConverters(RelNode rel, RelTraitSet toTraits)
private RelNode	VolcanoPlanner.changeTraitsUsingConverters(RelNode rel, RelTraitSet toTraits, boolean allowAbstractConverters)
private void	RuleQueue.checkDuplicateSubsets(Deque<RelSubset> subsets, RelOptRuleOperand operand, RelNode[] rels) Recursively checks whether there are any duplicate subsets along any path from root of the operand tree to one of the leaves.
(package private) void	VolcanoPlanner.checkForSatisfiedConverters(RelSet set, RelNode rel)
private RelNode	VolcanoPlanner.completeConversion(RelNode rel, boolean allowInfiniteCostConverters, RelTraitSet toTraits, Expressions.FluentList<RelTraitDef> usedTraits) Converts traits using well-founded induction.
RelSubset	VolcanoPlanner.ensureRegistered(RelNode rel, RelNode equivRel)
void	VolcanoPlanner.ensureRegistered(RelNode rel, RelNode equivRel, VolcanoRuleCall ruleCall)
(package private) void	VolcanoPlanner.fireRules(RelNode rel, boolean deferred) Fires all rules matched by a relational expression.
private boolean	VolcanoPlanner.fixUpInputs(RelNode rel)
RelOptCost	VolcanoPlanner.getCost(RelNode rel, RelMetadataQuery mq)
long	VolcanoPlanner.getRelMetadataTimestamp(RelNode rel)
RelSet	VolcanoPlanner.getSet(RelNode rel) Finds an expression's equivalence set.
RelSubset	VolcanoPlanner.getSubset(RelNode rel) Returns the subset that a relational expression belongs to.
RelSubset	VolcanoPlanner.getSubset(RelNode rel, RelTraitSet traits)
RelSubset	VolcanoPlanner.getSubset(RelNode rel, RelTraitSet traits, boolean createIfMissing)
private static List<RelSubset>	RelSubset.inputSubsets(RelNode parent)
boolean	VolcanoPlanner.isRegistered(RelNode rel)
private static Pair<String,RelDataType>	VolcanoPlanner.key(RelNode rel) Computes the key for VolcanoPlanner.mapDigestToRel.
(package private) void	VolcanoRuleCall.match(RelNode rel) Applies this rule, with a given relational expression in the first slot.
(package private) void	RelSet.obliterateRelNode(RelNode rel) Removes all references to a specific RelNode in both the subsets and their parent relationships.
protected void	VolcanoPlanner.onNewClass(RelNode node)
private void	RelSet.postEquivalenceEvent(VolcanoPlanner planner, RelNode rel)
(package private) void	RelSubset.propagateCostImprovements(VolcanoPlanner planner, RelMetadataQuery mq, RelNode rel, Set<RelSubset> activeSet) Checks whether a relexp has made its subset cheaper, and if it so, recursively checks whether that subset's parents have gotten cheaper.
(package private) void	RelSubset.propagateCostImprovements0(VolcanoPlanner planner, RelMetadataQuery mq, RelNode rel, Set<RelSubset> activeSet)
private String	VolcanoPlanner.provenance(RelNode root) Returns a multi-line string describing the provenance of a tree of relational expressions.
private void	VolcanoPlanner.provenanceRecurse(PrintWriter pw, RelNode node, int i, Set<RelNode> visited) Helper for VolcanoPlanner.provenance(org.apache.calcite.rel.RelNode).
RelSubset	VolcanoPlanner.register(RelNode rel, RelNode equivRel)
private RelSubset	VolcanoPlanner.registerImpl(RelNode rel, RelSet set) Registers a new expression exp and queues up rule matches.
(package private) void	VolcanoPlanner.rename(RelNode rel) Re-computes the digest of a RelNode.
(package private) void	VolcanoPlanner.reregister(RelSet set, RelNode rel) Registers a RelNode, which has already been registered, in a new RelSet.
void	VolcanoPlanner.setImportance(RelNode rel, double importance)
void	VolcanoPlanner.setRoot(RelNode rel)
void	VolcanoRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv)
RelNode	RelSubset.CheapestPlanReplacer.visit(RelNode p, int ordinal, RelNode parent)

Method parameters in org.apache.calcite.plan.volcano with type arguments of type RelNode

Modifier and Type	Method and Description
<M extends Metadata> UnboundMetadata<M>	VolcanoRelMetadataProvider.apply(Class<? extends RelNode> relClass, Class<? extends M> metadataClass)
RelNode	RelSubset.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	AbstractConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
private void	VolcanoPlanner.provenanceRecurse(PrintWriter pw, RelNode node, int i, Set<RelNode> visited) Helper for VolcanoPlanner.provenance(org.apache.calcite.rel.RelNode).
void	VolcanoRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv)
void	VolcanoRuleCall.transformTo(RelNode rel, Map<RelNode,RelNode> equiv)

Constructors in org.apache.calcite.plan.volcano with parameters of type RelNode

Constructor and Description
DirectProvenance(RelNode source)
VolcanoRuleCall(VolcanoPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs) Creates a rule call, internal, with array to hold bindings.
VolcanoRuleMatch(VolcanoPlanner volcanoPlanner, RelOptRuleOperand operand0, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs) Creates a VolcanoRuleMatch.

Constructor parameters in org.apache.calcite.plan.volcano with type arguments of type RelNode

Constructor and Description
RuleProvenance(RelOptRule rule, com.google.common.collect.ImmutableList<RelNode> rels, int callId)
VolcanoRuleCall(VolcanoPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs) Creates a rule call, internal, with array to hold bindings.
VolcanoRuleCall(VolcanoPlanner planner, RelOptRuleOperand operand, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs) Creates a rule call, internal, with array to hold bindings.
VolcanoRuleMatch(VolcanoPlanner volcanoPlanner, RelOptRuleOperand operand0, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs) Creates a VolcanoRuleMatch.
VolcanoRuleMatch(VolcanoPlanner volcanoPlanner, RelOptRuleOperand operand0, RelNode[] rels, Map<RelNode,List<RelNode>> nodeInputs) Creates a VolcanoRuleMatch.

Uses of RelNode in org.apache.calcite.prepare

Fields in org.apache.calcite.prepare declared as RelNode

Modifier and Type	Field and Description
(package private) RelNode	Prepare.Materialization.queryRel Relational expression for the query to populate the table.
RelNode	CalciteMaterializer.Callback.rel
private RelNode	QueryableRelBuilder.rel
protected RelNode	Prepare.PreparedResultImpl.rootRel
(package private) RelNode	Prepare.Materialization.tableRel Relational expression for the table.

Methods in org.apache.calcite.prepare that return RelNode

Modifier and Type	Method and Description
RelNode	PlannerImpl.convert(SqlNode sql)
protected abstract RelNode	Prepare.decorrelate(SqlToRelConverter sqlToRelConverter, SqlNode query, RelNode rootRel)
protected RelNode	CalcitePrepareImpl.CalcitePreparingStmt.decorrelate(SqlToRelConverter sqlToRelConverter, SqlNode query, RelNode rootRel)
abstract RelNode	Prepare.flattenTypes(RelNode rootRel, boolean restructure)
RelNode	CalcitePrepareImpl.CalcitePreparingStmt.flattenTypes(RelNode rootRel, boolean restructure)
RelNode	Prepare.PreparedResultImpl.getRootRel()
(package private) RelNode	QueryableRelBuilder.toRel(Queryable<T> queryable)
RelNode	RelOptTableImpl.toRel(RelOptTable.ToRelContext context)
RelNode	PlannerImpl.transform(int ruleSetIndex, RelTraitSet requiredOutputTraits, RelNode rel)
RelNode	LixToRelTranslator.translate(Expression expression)
<T> RelNode	LixToRelTranslator.translate(Queryable<T> queryable)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalAggregate aggregate)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalCorrelate correlate)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalExchange exchange)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalFilter filter)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalIntersect intersect)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalJoin join)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalMatch match)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalMinus minus)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalProject project)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalSort sort)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalUnion union)
RelNode	CalciteMaterializer.RelNullShuttle.visit(LogicalValues values)
RelNode	CalciteMaterializer.RelNullShuttle.visit(RelNode other)
RelNode	CalciteMaterializer.RelNullShuttle.visit(TableFunctionScan scan)
RelNode	CalciteMaterializer.RelNullShuttle.visit(TableScan scan)

Methods in org.apache.calcite.prepare with parameters of type RelNode

Modifier and Type	Method and Description
protected abstract RelNode	Prepare.decorrelate(SqlToRelConverter sqlToRelConverter, SqlNode query, RelNode rootRel)
protected RelNode	CalcitePrepareImpl.CalcitePreparingStmt.decorrelate(SqlToRelConverter sqlToRelConverter, SqlNode query, RelNode rootRel)
abstract RelNode	Prepare.flattenTypes(RelNode rootRel, boolean restructure)
RelNode	CalcitePrepareImpl.CalcitePreparingStmt.flattenTypes(RelNode rootRel, boolean restructure)
void	Prepare.Materialization.materialize(RelNode queryRel, RelOptTable starRelOptTable)
Prepare.PreparedResult	CalcitePrepareImpl.CalcitePreparingStmt.prepareRel(RelNode rel)
private void	QueryableRelBuilder.setRel(RelNode rel) Sets the output of this event.
private boolean	Prepare.shouldTrim(RelNode rootRel)
(package private) RexNode	LixToRelTranslator.toRex(FunctionExpression expression, RelNode... inputs)
private List<RexNode>	LixToRelTranslator.toRex(RelNode child, FunctionExpression expression)
(package private) List<RexNode>	LixToRelTranslator.toRexList(FunctionExpression expression, RelNode... inputs)
RelNode	PlannerImpl.transform(int ruleSetIndex, RelTraitSet requiredOutputTraits, RelNode rel)
private Iterable<CalciteMaterializer.Callback>	CalciteMaterializer.useStar(CalciteSchema schema, RelNode queryRel) Converts a relational expression to use a StarTable defined in schema.
RelNode	CalciteMaterializer.RelNullShuttle.visit(RelNode other)

Method parameters in org.apache.calcite.prepare with type arguments of type RelNode

Modifier and Type	Method and Description
private Prepare.PreparedResult	CalcitePrepareImpl.CalcitePreparingStmt.prepare_(com.google.common.base.Supplier<RelNode> fn, RelDataType resultType)

Constructors in org.apache.calcite.prepare with parameters of type RelNode

Constructor and Description
Callback(RelNode rel, CalciteSchema.TableEntry starTable, RelOptTableImpl starRelOptTable)
PreparedResultImpl(RelDataType rowType, RelDataType parameterRowType, List<List<String>> fieldOrigins, List<RelCollation> collations, RelNode rootRel, TableModify.Operation tableModOp, boolean isDml)

Uses of RelNode in org.apache.calcite.rel

Classes in org.apache.calcite.rel that implement RelNode

Modifier and Type	Class and Description
class	AbstractRelNode Base class for every relational expression (RelNode).
class	BiRel Abstract base class for relational expressions with a two inputs.
class	SingleRel Abstract base class for relational expressions with a single input.

Fields in org.apache.calcite.rel declared as RelNode

Modifier and Type	Field and Description
protected RelNode	SingleRel.input
protected RelNode	BiRel.left
RelNode	RelRoot.rel
protected RelNode	BiRel.right
private RelNode	RelVisitor.root

Fields in org.apache.calcite.rel with type parameters of type RelNode

Modifier and Type	Field and Description
static Comparator<RelNode>	RelNodes.COMPARATOR Comparator that provides an arbitrary but stable ordering to RelNodes.
static com.google.common.collect.Ordering<RelNode>	RelNodes.ORDERING Ordering for RelNodes.
protected Deque<RelNode>	RelShuttleImpl.stack

Methods in org.apache.calcite.rel that return RelNode

Modifier and Type	Method and Description
RelNode	AbstractRelNode.accept(RelShuttle shuttle)
RelNode	RelNode.accept(RelShuttle shuttle) Accepts a visit from a shuttle.
RelNode	AbstractRelNode.accept(RexShuttle shuttle)
RelNode	RelNode.accept(RexShuttle shuttle) Accepts a visit from a shuttle.
RelNode	RelCollationTraitDef.convert(RelOptPlanner planner, RelNode rel, RelCollation toCollation, boolean allowInfiniteCostConverters)
RelNode	RelDistributionTraitDef.convert(RelOptPlanner planner, RelNode rel, RelDistribution toDistribution, boolean allowInfiniteCostConverters)
RelNode	AbstractRelNode.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	RelNode.copy(RelTraitSet traitSet, List<RelNode> inputs) Creates a copy of this relational expression, perhaps changing traits and inputs.
RelNode	RelInput.getInput() Returns the input relational expression.
RelNode	SingleRel.getInput()
RelNode	AbstractRelNode.getInput(int i)
RelNode	RelNode.getInput(int i) Returns the ith input relational expression.
RelNode	BiRel.getLeft()
RelNode	BiRel.getRight()
RelNode	RelVisitor.go(RelNode p) Starts an iteration.
RelNode	AbstractRelNode.onRegister(RelOptPlanner planner)
RelNode	RelNode.onRegister(RelOptPlanner planner) Receives notification that this expression is about to be registered.
RelNode	RelRoot.project() Returns the root relational expression, creating a LogicalProject if necessary to remove fields that are not needed.
RelNode	RelRoot.project(boolean force) Returns the root relational expression as a LogicalProject.
RelNode	RelHomogeneousShuttle.visit(LogicalAggregate aggregate)
RelNode	RelShuttleImpl.visit(LogicalAggregate aggregate)
RelNode	RelShuttle.visit(LogicalAggregate aggregate)
RelNode	RelHomogeneousShuttle.visit(LogicalCorrelate correlate)
RelNode	RelShuttleImpl.visit(LogicalCorrelate correlate)
RelNode	RelShuttle.visit(LogicalCorrelate correlate)
RelNode	RelHomogeneousShuttle.visit(LogicalExchange exchange)
RelNode	RelShuttleImpl.visit(LogicalExchange exchange)
RelNode	RelShuttle.visit(LogicalExchange exchange)
RelNode	RelHomogeneousShuttle.visit(LogicalFilter filter)
RelNode	RelShuttleImpl.visit(LogicalFilter filter)
RelNode	RelShuttle.visit(LogicalFilter filter)
RelNode	RelHomogeneousShuttle.visit(LogicalIntersect intersect)
RelNode	RelShuttleImpl.visit(LogicalIntersect intersect)
RelNode	RelShuttle.visit(LogicalIntersect intersect)
RelNode	RelHomogeneousShuttle.visit(LogicalJoin join)
RelNode	RelShuttleImpl.visit(LogicalJoin join)
RelNode	RelShuttle.visit(LogicalJoin join)
RelNode	RelHomogeneousShuttle.visit(LogicalMatch match)
RelNode	RelShuttleImpl.visit(LogicalMatch match)
RelNode	RelShuttle.visit(LogicalMatch match)
RelNode	RelHomogeneousShuttle.visit(LogicalMinus minus)
RelNode	RelShuttleImpl.visit(LogicalMinus minus)
RelNode	RelShuttle.visit(LogicalMinus minus)
RelNode	RelHomogeneousShuttle.visit(LogicalProject project)
RelNode	RelShuttleImpl.visit(LogicalProject project)
RelNode	RelShuttle.visit(LogicalProject project)
RelNode	RelHomogeneousShuttle.visit(LogicalSort sort)
RelNode	RelShuttleImpl.visit(LogicalSort sort)
RelNode	RelShuttle.visit(LogicalSort sort)
RelNode	RelHomogeneousShuttle.visit(LogicalUnion union)
RelNode	RelShuttleImpl.visit(LogicalUnion union)
RelNode	RelShuttle.visit(LogicalUnion union)
RelNode	RelHomogeneousShuttle.visit(LogicalValues values)
RelNode	RelShuttleImpl.visit(LogicalValues values)
RelNode	RelShuttle.visit(LogicalValues values)
RelNode	RelShuttleImpl.visit(RelNode other)
RelNode	RelShuttle.visit(RelNode other)
RelNode	RelHomogeneousShuttle.visit(TableFunctionScan scan)
RelNode	RelShuttleImpl.visit(TableFunctionScan scan)
RelNode	RelShuttle.visit(TableFunctionScan scan)
RelNode	RelHomogeneousShuttle.visit(TableScan scan)
RelNode	RelShuttleImpl.visit(TableScan scan)
RelNode	RelShuttle.visit(TableScan scan)
protected RelNode	RelShuttleImpl.visitChild(RelNode parent, int i, RelNode child) Visits a particular child of a parent.
protected RelNode	RelShuttleImpl.visitChildren(RelNode rel)

Methods in org.apache.calcite.rel that return types with arguments of type RelNode

Modifier and Type	Method and Description
List<RelNode>	AbstractRelNode.getInputs()
List<RelNode>	RelInput.getInputs()
List<RelNode>	RelNode.getInputs() Returns an array of this relational expression's inputs.
List<RelNode>	BiRel.getInputs()
List<RelNode>	SingleRel.getInputs()

Methods in org.apache.calcite.rel with parameters of type RelNode

Modifier and Type	Method and Description
boolean	RelCollationTraitDef.canConvert(RelOptPlanner planner, RelCollation fromTrait, RelCollation toTrait, RelNode fromRel)
int	RelNodes.RelNodeComparator.compare(RelNode o1, RelNode o2)
static int	RelNodes.compareRels(RelNode[] rels0, RelNode[] rels1) Compares arrays of RelNode.
static int	RelNodes.compareRels(RelNode[] rels0, RelNode[] rels1) Compares arrays of RelNode.
RelNode	RelCollationTraitDef.convert(RelOptPlanner planner, RelNode rel, RelCollation toCollation, boolean allowInfiniteCostConverters)
RelNode	RelDistributionTraitDef.convert(RelOptPlanner planner, RelNode rel, RelDistribution toDistribution, boolean allowInfiniteCostConverters)
RelWriter	RelWriter.done(RelNode node) Writes the completed explanation.
void	RelWriter.explain(RelNode rel, List<Pair<String,Object>> valueList) Prints an explanation of a node, with a list of (term, value) pairs.
RelNode	RelVisitor.go(RelNode p) Starts an iteration.
RelWriter	RelWriter.input(String term, RelNode input) Adds an input to the explanation of the current node.
static RelRoot	RelRoot.of(RelNode rel, RelDataType rowType, SqlKind kind) Creates a simple RelRoot.
static RelRoot	RelRoot.of(RelNode rel, SqlKind kind) Creates a simple RelRoot.
void	AbstractRelNode.replaceInput(int ordinalInParent, RelNode p)
void	RelNode.replaceInput(int ordinalInParent, RelNode p) Replaces the ordinalInParentth input.
void	BiRel.replaceInput(int ordinalInParent, RelNode p)
void	SingleRel.replaceInput(int ordinalInParent, RelNode rel)
void	RelVisitor.replaceRoot(RelNode node) Replaces the root node of this traversal.
RelNode	RelShuttleImpl.visit(RelNode other)
RelNode	RelShuttle.visit(RelNode other)
void	RelVisitor.visit(RelNode node, int ordinal, RelNode parent) Visits a node during a traversal.
protected RelNode	RelShuttleImpl.visitChild(RelNode parent, int i, RelNode child) Visits a particular child of a parent.
protected RelNode	RelShuttleImpl.visitChildren(RelNode rel)
RelRoot	RelRoot.withRel(RelNode rel) Creates a copy of this RelRoot, assigning a RelNode.

Method parameters in org.apache.calcite.rel with type arguments of type RelNode

Modifier and Type	Method and Description
RelNode	AbstractRelNode.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	RelNode.copy(RelTraitSet traitSet, List<RelNode> inputs) Creates a copy of this relational expression, perhaps changing traits and inputs.

Constructors in org.apache.calcite.rel with parameters of type RelNode

Constructor and Description
BiRel(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right)
RelRoot(RelNode rel, RelDataType validatedRowType, SqlKind kind, List<Pair<Integer,String>> fields, RelCollation collation) Creates a RelRoot.
SingleRel(RelOptCluster cluster, RelTraitSet traits, RelNode input) Creates a SingleRel.

Uses of RelNode in org.apache.calcite.rel.convert

Subinterfaces of RelNode in org.apache.calcite.rel.convert

Modifier and Type	Interface and Description
interface	Converter A relational expression implements the interface Converter to indicate that it converts a physical attribute, or trait, of a relational expression from one value to another.

Classes in org.apache.calcite.rel.convert that implement RelNode

Modifier and Type	Class and Description
class	ConverterImpl Abstract implementation of Converter.
class	NoneConverter NoneConverter converts a plan from inConvention to Convention.NONE.

Methods in org.apache.calcite.rel.convert that return RelNode

Modifier and Type	Method and Description
abstract RelNode	ConverterRule.convert(RelNode rel) Converts a relational expression to the target trait(s) of this rule.
RelNode	NoneConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Converter.getInput() Returns the sole input relational expression

Methods in org.apache.calcite.rel.convert with parameters of type RelNode

Modifier and Type	Method and Description
abstract RelNode	ConverterRule.convert(RelNode rel) Converts a relational expression to the target trait(s) of this rule.

Method parameters in org.apache.calcite.rel.convert with type arguments of type RelNode

Modifier and Type	Method and Description
RelNode	NoneConverter.copy(RelTraitSet traitSet, List<RelNode> inputs)

Constructors in org.apache.calcite.rel.convert with parameters of type RelNode

Constructor and Description
ConverterImpl(RelOptCluster cluster, RelTraitDef traitDef, RelTraitSet traits, RelNode child) Creates a ConverterImpl.
NoneConverter(RelOptCluster cluster, RelNode child)

Constructor parameters in org.apache.calcite.rel.convert with type arguments of type RelNode

Constructor and Description
ConverterRule(Class<? extends RelNode> clazz, RelTrait in, RelTrait out, String description) Creates a ConverterRule.

Uses of RelNode in org.apache.calcite.rel.core

Classes in org.apache.calcite.rel.core that implement RelNode

Modifier and Type	Class and Description
class	Aggregate Relational operator that eliminates duplicates and computes totals.
class	Calc Calc is an abstract base class for implementations of LogicalCalc.
class	Collect A relational expression that collapses multiple rows into one.
class	Correlate A relational operator that performs nested-loop joins.
class	EquiJoin Base class for any join whose condition is based on column equality.
class	Exchange Relational expression that imposes a particular distribution on its input without otherwise changing its content.
class	Filter Relational expression that iterates over its input and returns elements for which condition evaluates to true.
class	Intersect Relational expression that returns the intersection of the rows of its inputs.
class	Join Relational expression that combines two relational expressions according to some condition.
class	Match Relational expression that represent a MATCH_RECOGNIZE node.
class	Minus Relational expression that returns the rows of its first input minus any matching rows from its other inputs.
class	Project Relational expression that computes a set of 'select expressions' from its input relational expression.
class	Sample Relational expression that returns a sample of the rows from its input.
class	SemiJoin Relational expression that joins two relational expressions according to some condition, but outputs only columns from the left input, and eliminates duplicates.
class	SetOp SetOp is an abstract base for relational set operators such as UNION, MINUS (aka EXCEPT), and INTERSECT.
class	Sort Relational expression that imposes a particular sort order on its input without otherwise changing its content.
class	SortExchange Relational expression that performs Exchange and Sort simultaneously.
class	TableFunctionScan Relational expression that calls a table-valued function.
class	TableModify Relational expression that modifies a table.
class	TableScan Relational operator that returns the contents of a table.
class	Uncollect Relational expression that unnests its input's columns into a relation.
class	Union Relational expression that returns the union of the rows of its inputs, optionally eliminating duplicates.
class	Values Relational expression whose value is a sequence of zero or more literal row values.
class	Window A relational expression representing a set of window aggregates.

Fields in org.apache.calcite.rel.core with type parameters of type RelNode

Modifier and Type	Field and Description
protected com.google.common.collect.ImmutableList<RelNode>	SetOp.inputs
private com.google.common.collect.ImmutableList<RelNode>	TableFunctionScan.inputs

Methods in org.apache.calcite.rel.core that return RelNode

Modifier and Type	Method and Description
RelNode	TableScan.accept(RelShuttle shuttle)
RelNode	Filter.accept(RexShuttle shuttle)
RelNode	Project.accept(RexShuttle shuttle)
RelNode	Calc.accept(RexShuttle shuttle)
RelNode	TableFunctionScan.accept(RexShuttle shuttle)
RelNode	Sort.accept(RexShuttle shuttle)
RelNode	Join.accept(RexShuttle shuttle)
RelNode	Filter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Project.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Match.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Uncollect.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Aggregate.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Sample.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Collect.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Uncollect.copy(RelTraitSet traitSet, RelNode input)
RelNode	Collect.copy(RelTraitSet traitSet, RelNode input)
RelNode	RelFactories.AggregateFactory.createAggregate(RelNode input, boolean indicator, ImmutableBitSet groupSet, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates an aggregate.
RelNode	RelFactories.AggregateFactoryImpl.createAggregate(RelNode input, boolean indicator, ImmutableBitSet groupSet, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
RelNode	RelFactories.CorrelateFactory.createCorrelate(RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType) Creates a correlate.
RelNode	RelFactories.CorrelateFactoryImpl.createCorrelate(RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType)
RelNode	RelFactories.FilterFactory.createFilter(RelNode input, RexNode condition) Creates a filter.
RelNode	RelFactories.FilterFactoryImpl.createFilter(RelNode input, RexNode condition)
RelNode	RelFactories.JoinFactory.createJoin(RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped, boolean semiJoinDone) Deprecated.
RelNode	RelFactories.JoinFactoryImpl.createJoin(RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped, boolean semiJoinDone)
RelNode	RelFactories.JoinFactory.createJoin(RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType, boolean semiJoinDone) Creates a join.
RelNode	RelFactories.JoinFactoryImpl.createJoin(RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType, boolean semiJoinDone)
RelNode	RelFactories.MatchFactory.createMatch(RelNode input, RexNode pattern, RelDataType rowType, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval) Creates a Match.
RelNode	RelFactories.MatchFactoryImpl.createMatch(RelNode input, RexNode pattern, RelDataType rowType, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval)
RelNode	RelFactories.ProjectFactory.createProject(RelNode input, List<? extends RexNode> childExprs, List<String> fieldNames) Creates a project.
RelNode	RelFactories.ProjectFactoryImpl.createProject(RelNode input, List<? extends RexNode> childExprs, List<String> fieldNames)
RelNode	RelFactories.TableScanFactory.createScan(RelOptCluster cluster, RelOptTable table) Creates a TableScan.
RelNode	RelFactories.TableScanFactoryImpl.createScan(RelOptCluster cluster, RelOptTable table)
RelNode	RelFactories.SemiJoinFactory.createSemiJoin(RelNode left, RelNode right, RexNode condition) Creates a semi-join.
RelNode	RelFactories.SemiJoinFactoryImpl.createSemiJoin(RelNode left, RelNode right, RexNode condition)
RelNode	RelFactories.SetOpFactory.createSetOp(SqlKind kind, List<RelNode> inputs, boolean all) Creates a set operation.
RelNode	RelFactories.SetOpFactoryImpl.createSetOp(SqlKind kind, List<RelNode> inputs, boolean all)
RelNode	RelFactories.SortFactory.createSort(RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Creates a sort.
RelNode	RelFactories.SortFactoryImpl.createSort(RelNode input, RelCollation collation, RexNode offset, RexNode fetch)
RelNode	RelFactories.SortFactory.createSort(RelTraitSet traits, RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Deprecated.
RelNode	RelFactories.SortFactoryImpl.createSort(RelTraitSet traits, RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Deprecated.
RelNode	RelFactories.ValuesFactory.createValues(RelOptCluster cluster, RelDataType rowType, List<com.google.common.collect.ImmutableList<RexLiteral>> tuples) Creates a Values.
RelNode	RelFactories.ValuesFactoryImpl.createValues(RelOptCluster cluster, RelDataType rowType, List<com.google.common.collect.ImmutableList<RexLiteral>> tuples)
RelNode	TableScan.project(ImmutableBitSet fieldsUsed, Set<RelDataTypeField> extraFields, RelBuilder relBuilder) Projects a subset of the fields of the table, and also asks for "extra" fields that were not included in the table's official type.

Methods in org.apache.calcite.rel.core that return types with arguments of type RelNode

Modifier and Type	Method and Description
List<RelNode>	SetOp.getInputs()
List<RelNode>	TableFunctionScan.getInputs()

Methods in org.apache.calcite.rel.core with parameters of type RelNode

Modifier and Type	Method and Description
AggregateCall	AggregateCall.adaptTo(RelNode input, List<Integer> argList, int filterArg, int oldGroupKeyCount, int newGroupKeyCount) Creates equivalent AggregateCall that is adapted to a new input types and/or number of columns in GROUP BY.
abstract Match	Match.copy(RelNode input, RelDataType rowType, RexNode pattern, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval)
RelNode	Uncollect.copy(RelTraitSet traitSet, RelNode input)
RelNode	Collect.copy(RelTraitSet traitSet, RelNode input)
abstract Aggregate	Aggregate.copy(RelTraitSet traitSet, RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates a copy of this aggregate.
abstract Project	Project.copy(RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType) Copies a project.
Project	Project.copy(RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType, int flags) Deprecated.
Sort	Sort.copy(RelTraitSet traitSet, RelNode newInput, RelCollation newCollation)
abstract Sort	Sort.copy(RelTraitSet traitSet, RelNode newInput, RelCollation newCollation, RexNode offset, RexNode fetch)
abstract Exchange	Exchange.copy(RelTraitSet traitSet, RelNode newInput, RelDistribution newDistribution)
SortExchange	SortExchange.copy(RelTraitSet traitSet, RelNode newInput, RelDistribution newDistribution)
abstract SortExchange	SortExchange.copy(RelTraitSet traitSet, RelNode newInput, RelDistribution newDistribution, RelCollation newCollation)
abstract Correlate	Correlate.copy(RelTraitSet traitSet, RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType)
abstract Filter	Filter.copy(RelTraitSet traitSet, RelNode input, RexNode condition)
abstract Calc	Calc.copy(RelTraitSet traitSet, RelNode child, RexProgram program) Creates a copy of this Calc.
Calc	Calc.copy(RelTraitSet traitSet, RelNode child, RexProgram program, List<RelCollation> collationList) Deprecated.
SemiJoin	SemiJoin.copy(RelTraitSet traitSet, RexNode condition, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
abstract Join	Join.copy(RelTraitSet traitSet, RexNode conditionExpr, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone) Creates a copy of this join, overriding condition, system fields and inputs.
static SemiJoin	SemiJoin.create(RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys) Creates a SemiJoin.
static Uncollect	Uncollect.create(RelTraitSet traitSet, RelNode input, boolean withOrdinality) Creates an Uncollect.
static AggregateCall	AggregateCall.create(SqlAggFunction aggFunction, boolean distinct, boolean approximate, List<Integer> argList, int filterArg, int groupCount, RelNode input, RelDataType type, String name) Creates an AggregateCall, inferring its type if type is null.
static AggregateCall	AggregateCall.create(SqlAggFunction aggFunction, boolean distinct, List<Integer> argList, int filterArg, int groupCount, RelNode input, RelDataType type, String name) Deprecated.
static AggregateCall	AggregateCall.create(SqlAggFunction aggFunction, boolean distinct, List<Integer> argList, int groupCount, RelNode input, RelDataType type, String name) Deprecated.
RelNode	RelFactories.AggregateFactory.createAggregate(RelNode input, boolean indicator, ImmutableBitSet groupSet, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates an aggregate.
RelNode	RelFactories.AggregateFactoryImpl.createAggregate(RelNode input, boolean indicator, ImmutableBitSet groupSet, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
RelNode	RelFactories.CorrelateFactory.createCorrelate(RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType) Creates a correlate.
RelNode	RelFactories.CorrelateFactoryImpl.createCorrelate(RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType)
RelNode	RelFactories.FilterFactory.createFilter(RelNode input, RexNode condition) Creates a filter.
RelNode	RelFactories.FilterFactoryImpl.createFilter(RelNode input, RexNode condition)
RelNode	RelFactories.JoinFactory.createJoin(RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped, boolean semiJoinDone) Deprecated.
RelNode	RelFactories.JoinFactoryImpl.createJoin(RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped, boolean semiJoinDone)
RelNode	RelFactories.JoinFactory.createJoin(RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType, boolean semiJoinDone) Creates a join.
RelNode	RelFactories.JoinFactoryImpl.createJoin(RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType, boolean semiJoinDone)
RelNode	RelFactories.MatchFactory.createMatch(RelNode input, RexNode pattern, RelDataType rowType, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval) Creates a Match.
RelNode	RelFactories.MatchFactoryImpl.createMatch(RelNode input, RexNode pattern, RelDataType rowType, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval)
RelNode	RelFactories.ProjectFactory.createProject(RelNode input, List<? extends RexNode> childExprs, List<String> fieldNames) Creates a project.
RelNode	RelFactories.ProjectFactoryImpl.createProject(RelNode input, List<? extends RexNode> childExprs, List<String> fieldNames)
RelNode	RelFactories.SemiJoinFactory.createSemiJoin(RelNode left, RelNode right, RexNode condition) Creates a semi-join.
RelNode	RelFactories.SemiJoinFactoryImpl.createSemiJoin(RelNode left, RelNode right, RexNode condition)
RelNode	RelFactories.SortFactory.createSort(RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Creates a sort.
RelNode	RelFactories.SortFactoryImpl.createSort(RelNode input, RelCollation collation, RexNode offset, RexNode fetch)
RelNode	RelFactories.SortFactory.createSort(RelTraitSet traits, RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Deprecated.
RelNode	RelFactories.SortFactoryImpl.createSort(RelTraitSet traits, RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Deprecated.
static RelDataType	Uncollect.deriveUncollectRowType(RelNode rel, boolean withOrdinality) Returns the row type returned by applying the 'UNNEST' operation to a relational expression.
static double	Filter.estimateFilteredRows(RelNode child, RexNode condition) Deprecated.
static double	Filter.estimateFilteredRows(RelNode child, RexProgram program) Deprecated.
static double	Union.estimateRowCount(RelNode rel) Deprecated.
RexNode	JoinInfo.getEquiCondition(RelNode left, RelNode right, RexBuilder rexBuilder)
private boolean	Aggregate.isPredicate(RelNode input, int index)
static JoinInfo	JoinInfo.of(RelNode left, RelNode right, RexNode condition) Creates a JoinInfo by analyzing a condition.
void	SetOp.replaceInput(int ordinalInParent, RelNode p)
void	TableFunctionScan.replaceInput(int ordinalInParent, RelNode p)

Method parameters in org.apache.calcite.rel.core with type arguments of type RelNode

Modifier and Type	Method and Description
Exchange	Exchange.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Filter.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Project.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Match.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Uncollect.copy(RelTraitSet traitSet, List<RelNode> inputs)
Correlate	Correlate.copy(RelTraitSet traitSet, List<RelNode> inputs)
SetOp	SetOp.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Aggregate.copy(RelTraitSet traitSet, List<RelNode> inputs)
Calc	Calc.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Sample.copy(RelTraitSet traitSet, List<RelNode> inputs)
TableFunctionScan	TableFunctionScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	Collect.copy(RelTraitSet traitSet, List<RelNode> inputs)
Sort	Sort.copy(RelTraitSet traitSet, List<RelNode> inputs)
Join	Join.copy(RelTraitSet traitSet, List<RelNode> inputs)
abstract SetOp	SetOp.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
abstract TableFunctionScan	TableFunctionScan.copy(RelTraitSet traitSet, List<RelNode> inputs, RexNode rexCall, Type elementType, RelDataType rowType, Set<RelColumnMapping> columnMappings) Copies this relational expression, substituting traits and inputs.
RelNode	RelFactories.SetOpFactory.createSetOp(SqlKind kind, List<RelNode> inputs, boolean all) Creates a set operation.
RelNode	RelFactories.SetOpFactoryImpl.createSetOp(SqlKind kind, List<RelNode> inputs, boolean all)

Constructors in org.apache.calcite.rel.core with parameters of type RelNode

Constructor and Description
Aggregate(RelOptCluster cluster, RelTraitSet traits, RelNode child, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates an Aggregate.
Calc(RelOptCluster cluster, RelTraitSet traits, RelNode child, RexProgram program) Creates a Calc.
Calc(RelOptCluster cluster, RelTraitSet traits, RelNode child, RexProgram program, List<RelCollation> collationList) Deprecated.
Collect(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, String fieldName) Creates a Collect.
Correlate(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType) Creates a Correlate.
EquiJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
EquiJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates an EquiJoin.
Exchange(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelDistribution distribution) Creates an Exchange.
Filter(RelOptCluster cluster, RelTraitSet traits, RelNode child, RexNode condition) Creates a filter.
Join(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
Join(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates a Join.
Match(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelDataType rowType, RexNode pattern, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval) Creates a Match.
Project(RelOptCluster cluster, RelTraitSet traits, RelNode input, List<? extends RexNode> projects, RelDataType rowType) Creates a Project.
Project(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType, int flags) Deprecated.
Sample(RelOptCluster cluster, RelNode child, RelOptSamplingParameters params)
SemiJoin(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys) Creates a SemiJoin.
Sort(RelOptCluster cluster, RelTraitSet traits, RelNode child, RelCollation collation) Creates a Sort.
Sort(RelOptCluster cluster, RelTraitSet traits, RelNode child, RelCollation collation, RexNode offset, RexNode fetch) Creates a Sort.
SortExchange(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelDistribution distribution, RelCollation collation) Creates a SortExchange.
TableModify(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable table, Prepare.CatalogReader catalogReader, RelNode input, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened) Creates a TableModify.
Uncollect(RelOptCluster cluster, RelTraitSet traitSet, RelNode child) Deprecated.
Uncollect(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, boolean withOrdinality) Creates an Uncollect.
Window(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<RexLiteral> constants, RelDataType rowType, List<Window.Group> groups) Creates a window relational expression.

Constructor parameters in org.apache.calcite.rel.core with type arguments of type RelNode

Constructor and Description
Intersect(RelOptCluster cluster, RelTraitSet traits, List<RelNode> inputs, boolean all) Creates an Intersect.
Minus(RelOptCluster cluster, RelTraitSet traits, List<RelNode> inputs, boolean all)
SetOp(RelOptCluster cluster, RelTraitSet traits, List<RelNode> inputs, SqlKind kind, boolean all) Creates a SetOp.
TableFunctionScan(RelOptCluster cluster, RelTraitSet traits, List<RelNode> inputs, RexNode rexCall, Type elementType, RelDataType rowType, Set<RelColumnMapping> columnMappings) Creates a TableFunctionScan.
Union(RelOptCluster cluster, RelTraitSet traits, List<RelNode> inputs, boolean all)

Uses of RelNode in org.apache.calcite.rel.externalize

Fields in org.apache.calcite.rel.externalize declared as RelNode

Modifier and Type	Field and Description
private RelNode	RelJsonReader.lastRel

Fields in org.apache.calcite.rel.externalize with type parameters of type RelNode

Modifier and Type	Field and Description
private Map<RelNode,String>	RelJsonWriter.relIdMap
private Map<String,RelNode>	RelJsonReader.relMap

Methods in org.apache.calcite.rel.externalize that return RelNode

Modifier and Type	Method and Description
RelNode	RelJson.create(Map<String,Object> map)
private RelNode	RelJsonReader.lookupInput(String jsonInput)
RelNode	RelJsonReader.read(String s)

Methods in org.apache.calcite.rel.externalize with parameters of type RelNode

Modifier and Type	Method and Description
private boolean	RelWriterImpl.checkInputsPresentInExplain(RelNode node)
RelWriter	RelJsonWriter.done(RelNode node)
RelWriter	RelWriterImpl.done(RelNode node)
protected void	RelXmlWriter.explain_(RelNode rel, List<Pair<String,Object>> values)
protected void	RelJsonWriter.explain_(RelNode rel, List<Pair<String,Object>> values)
protected void	RelWriterImpl.explain_(RelNode rel, List<Pair<String,Object>> values)
void	RelJsonWriter.explain(RelNode rel, List<Pair<String,Object>> valueList)
void	RelWriterImpl.explain(RelNode rel, List<Pair<String,Object>> valueList)
private void	RelXmlWriter.explainGeneric(RelNode rel, List<Pair<String,Object>> values) Generates generic XML (sometimes called 'element-oriented XML').
private void	RelXmlWriter.explainSpecific(RelNode rel, List<Pair<String,Object>> values) Generates specific XML (sometimes called 'attribute-oriented XML').
RelWriter	RelJsonWriter.input(String term, RelNode input)
RelWriter	RelWriterImpl.input(String term, RelNode input)

Method parameters in org.apache.calcite.rel.externalize with type arguments of type RelNode

Modifier and Type	Method and Description
String	RelJson.classToTypeName(Class<? extends RelNode> class_) Inverse of RelJson.typeNameToClass(java.lang.String).
private List<Object>	RelJsonWriter.explainInputs(List<RelNode> inputs)
private void	RelWriterImpl.explainInputs(List<RelNode> inputs)

Uses of RelNode in org.apache.calcite.rel.logical

Classes in org.apache.calcite.rel.logical that implement RelNode

Modifier and Type	Class and Description
class	LogicalAggregate LogicalAggregate is a relational operator which eliminates duplicates and computes totals.
class	LogicalCalc A relational expression which computes project expressions and also filters.
class	LogicalCorrelate A relational operator that performs nested-loop joins.
class	LogicalExchange Sub-class of Exchange not targeted at any particular engine or calling convention.
class	LogicalFilter Sub-class of Filter not targeted at any particular engine or calling convention.
class	LogicalIntersect Sub-class of Intersect not targeted at any particular engine or calling convention.
class	LogicalJoin Sub-class of Join not targeted at any particular engine or calling convention.
class	LogicalMatch Sub-class of Match not targeted at any particular engine or calling convention.
class	LogicalMinus Sub-class of Minus not targeted at any particular engine or calling convention.
class	LogicalProject Sub-class of Project not targeted at any particular engine or calling convention.
class	LogicalSort Sub-class of Sort not targeted at any particular engine or calling convention.
class	LogicalTableFunctionScan Sub-class of TableFunctionScan not targeted at any particular engine or calling convention.
class	LogicalTableModify Sub-class of TableModify not targeted at any particular engine or calling convention.
class	LogicalTableScan A LogicalTableScan reads all the rows from a RelOptTable.
class	LogicalUnion Sub-class of Union not targeted at any particular engine or calling convention.
class	LogicalValues Sub-class of Values not targeted at any particular engine or calling convention.
class	LogicalWindow Sub-class of Window not targeted at any particular engine or calling convention.

Methods in org.apache.calcite.rel.logical that return RelNode

Modifier and Type	Method and Description
RelNode	LogicalMatch.accept(RelShuttle shuttle)
RelNode	LogicalAggregate.accept(RelShuttle shuttle)
RelNode	LogicalValues.accept(RelShuttle shuttle)
RelNode	LogicalProject.accept(RelShuttle shuttle)
RelNode	LogicalMinus.accept(RelShuttle shuttle)
RelNode	LogicalIntersect.accept(RelShuttle shuttle)
RelNode	LogicalUnion.accept(RelShuttle shuttle)
RelNode	LogicalFilter.accept(RelShuttle shuttle)
RelNode	LogicalCorrelate.accept(RelShuttle shuttle)
RelNode	LogicalExchange.accept(RelShuttle shuttle)
RelNode	LogicalSort.accept(RelShuttle shuttle)
RelNode	LogicalJoin.accept(RelShuttle shuttle)
RelNode	LogicalValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	LogicalTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
static RelNode	LogicalWindow.create(RelOptCluster cluster, RelTraitSet traitSet, RelBuilder relBuilder, RelNode child, RexProgram program) Creates a LogicalWindow by parsing a RexProgram.

Methods in org.apache.calcite.rel.logical with parameters of type RelNode

Modifier and Type	Method and Description
Match	LogicalMatch.copy(RelNode input, RelDataType rowType, RexNode pattern, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval)
LogicalAggregate	LogicalAggregate.copy(RelTraitSet traitSet, RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
LogicalProject	LogicalProject.copy(RelTraitSet traitSet, RelNode input, List<RexNode> projects, RelDataType rowType)
Sort	LogicalSort.copy(RelTraitSet traitSet, RelNode newInput, RelCollation newCollation, RexNode offset, RexNode fetch)
Exchange	LogicalExchange.copy(RelTraitSet traitSet, RelNode newInput, RelDistribution newDistribution)
LogicalCorrelate	LogicalCorrelate.copy(RelTraitSet traitSet, RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType)
LogicalFilter	LogicalFilter.copy(RelTraitSet traitSet, RelNode input, RexNode condition)
LogicalCalc	LogicalCalc.copy(RelTraitSet traitSet, RelNode child, RexProgram program)
LogicalJoin	LogicalJoin.copy(RelTraitSet traitSet, RexNode conditionExpr, RelNode left, RelNode right, JoinRelType joinType, boolean semiJoinDone)
private static LogicalAggregate	LogicalAggregate.create_(RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls)
static LogicalAggregate	LogicalAggregate.create(RelNode input, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Deprecated.
static LogicalAggregate	LogicalAggregate.create(RelNode input, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates a LogicalAggregate.
static LogicalProject	LogicalProject.create(RelNode input, List<? extends RexNode> projects, List<String> fieldNames) Creates a LogicalProject.
static LogicalProject	LogicalProject.create(RelNode input, List<? extends RexNode> projects, RelDataType rowType) Creates a LogicalProject, specifying row type rather than field names.
static LogicalSort	LogicalSort.create(RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Creates a LogicalSort.
static LogicalMatch	LogicalMatch.create(RelNode input, RelDataType rowType, RexNode pattern, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval) Creates a LogicalMatch.
static LogicalExchange	LogicalExchange.create(RelNode input, RelDistribution distribution) Creates a LogicalExchange.
static LogicalCorrelate	LogicalCorrelate.create(RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType) Creates a LogicalCorrelate.
static LogicalJoin	LogicalJoin.create(RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
static LogicalJoin	LogicalJoin.create(RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped, boolean semiJoinDone, com.google.common.collect.ImmutableList<RelDataTypeField> systemFieldList) Deprecated.
static LogicalJoin	LogicalJoin.create(RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType) Creates a LogicalJoin.
static LogicalJoin	LogicalJoin.create(RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType, boolean semiJoinDone, com.google.common.collect.ImmutableList<RelDataTypeField> systemFieldList) Creates a LogicalJoin, flagged with whether it has been translated to a semi-join.
static LogicalFilter	LogicalFilter.create(RelNode input, RexNode condition) Creates a LogicalFilter.
static LogicalFilter	LogicalFilter.create(RelNode input, RexNode condition, com.google.common.collect.ImmutableSet<CorrelationId> variablesSet) Creates a LogicalFilter.
static LogicalCalc	LogicalCalc.create(RelNode input, RexProgram program)
static RelNode	LogicalWindow.create(RelOptCluster cluster, RelTraitSet traitSet, RelBuilder relBuilder, RelNode child, RexProgram program) Creates a LogicalWindow by parsing a RexProgram.
static LogicalTableModify	LogicalTableModify.create(RelOptTable table, Prepare.CatalogReader schema, RelNode input, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened) Creates a LogicalTableModify.
static LogicalWindow	LogicalWindow.create(RelTraitSet traitSet, RelNode input, List<RexLiteral> constants, RelDataType rowType, List<Window.Group> groups) Creates a LogicalWindow.

Method parameters in org.apache.calcite.rel.logical with type arguments of type RelNode

Modifier and Type	Method and Description
LogicalWindow	LogicalWindow.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	LogicalValues.copy(RelTraitSet traitSet, List<RelNode> inputs)
LogicalTableModify	LogicalTableModify.copy(RelTraitSet traitSet, List<RelNode> inputs)
RelNode	LogicalTableScan.copy(RelTraitSet traitSet, List<RelNode> inputs)
LogicalMinus	LogicalMinus.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
LogicalIntersect	LogicalIntersect.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
LogicalUnion	LogicalUnion.copy(RelTraitSet traitSet, List<RelNode> inputs, boolean all)
LogicalTableFunctionScan	LogicalTableFunctionScan.copy(RelTraitSet traitSet, List<RelNode> inputs, RexNode rexCall, Type elementType, RelDataType rowType, Set<RelColumnMapping> columnMappings)
static LogicalMinus	LogicalMinus.create(List<RelNode> inputs, boolean all) Creates a LogicalMinus.
static LogicalIntersect	LogicalIntersect.create(List<RelNode> inputs, boolean all) Creates a LogicalIntersect.
static LogicalUnion	LogicalUnion.create(List<RelNode> inputs, boolean all) Creates a LogicalUnion.
static LogicalTableFunctionScan	LogicalTableFunctionScan.create(RelOptCluster cluster, List<RelNode> inputs, RexNode rexCall, Type elementType, RelDataType rowType, Set<RelColumnMapping> columnMappings) Creates a LogicalTableFunctionScan.

Constructors in org.apache.calcite.rel.logical with parameters of type RelNode

Constructor and Description
LogicalAggregate(RelOptCluster cluster, RelNode child, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Deprecated.
LogicalAggregate(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, boolean indicator, ImmutableBitSet groupSet, List<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates a LogicalAggregate.
LogicalCalc(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RexProgram program) Creates a LogicalCalc.
LogicalCalc(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RexProgram program, List<RelCollation> collationList) Deprecated.
LogicalCorrelate(RelOptCluster cluster, RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType) Deprecated.
LogicalCorrelate(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, CorrelationId correlationId, ImmutableBitSet requiredColumns, SemiJoinType joinType) Creates a LogicalCorrelate.
LogicalExchange(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelDistribution distribution)
LogicalFilter(RelOptCluster cluster, RelNode child, RexNode condition) Deprecated.
LogicalFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RexNode condition) Deprecated.
LogicalFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode child, RexNode condition, com.google.common.collect.ImmutableSet<CorrelationId> variablesSet) Creates a LogicalFilter.
LogicalJoin(RelOptCluster cluster, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
LogicalJoin(RelOptCluster cluster, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped, boolean semiJoinDone, com.google.common.collect.ImmutableList<RelDataTypeField> systemFieldList) Deprecated.
LogicalJoin(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, Set<String> variablesStopped, boolean semiJoinDone, com.google.common.collect.ImmutableList<RelDataTypeField> systemFieldList) Deprecated.
LogicalJoin(RelOptCluster cluster, RelTraitSet traitSet, RelNode left, RelNode right, RexNode condition, Set<CorrelationId> variablesSet, JoinRelType joinType, boolean semiJoinDone, com.google.common.collect.ImmutableList<RelDataTypeField> systemFieldList) Creates a LogicalJoin.
LogicalMatch(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelDataType rowType, RexNode pattern, boolean strictStart, boolean strictEnd, Map<String,RexNode> patternDefinitions, Map<String,RexNode> measures, RexNode after, Map<String,? extends SortedSet<String>> subsets, boolean allRows, List<RexNode> partitionKeys, RelCollation orderKeys, RexNode interval) Creates a LogicalMatch.
LogicalProject(RelOptCluster cluster, RelNode input, List<RexNode> projects, List<String> fieldNames, int flags) Deprecated.
LogicalProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType) Creates a LogicalProject.
LogicalProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<? extends RexNode> projects, RelDataType rowType, int flags) Deprecated.
LogicalSort(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RelCollation collation, RexNode offset, RexNode fetch)
LogicalTableModify(RelOptCluster cluster, RelOptTable table, Prepare.CatalogReader schema, RelNode input, TableModify.Operation operation, List<String> updateColumnList, boolean flattened) Deprecated.
LogicalTableModify(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable table, Prepare.CatalogReader schema, RelNode input, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened) Creates a LogicalTableModify.
LogicalWindow(RelOptCluster cluster, RelTraitSet traitSet, RelNode input, List<RexLiteral> constants, RelDataType rowType, List<Window.Group> groups) Creates a LogicalWindow.

Constructor parameters in org.apache.calcite.rel.logical with type arguments of type RelNode

Constructor and Description
LogicalIntersect(RelOptCluster cluster, List<RelNode> inputs, boolean all) Deprecated.
LogicalIntersect(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all) Creates a LogicalIntersect.
LogicalMinus(RelOptCluster cluster, List<RelNode> inputs, boolean all) Deprecated.
LogicalMinus(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all) Creates a LogicalMinus.
LogicalTableFunctionScan(RelOptCluster cluster, List<RelNode> inputs, RexNode rexCall, Type elementType, RelDataType rowType, Set<RelColumnMapping> columnMappings) Deprecated.
LogicalTableFunctionScan(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, RexNode rexCall, Type elementType, RelDataType rowType, Set<RelColumnMapping> columnMappings) Creates a LogicalTableFunctionScan.
LogicalUnion(RelOptCluster cluster, List<RelNode> inputs, boolean all) Deprecated.
LogicalUnion(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs, boolean all) Creates a LogicalUnion.

Uses of RelNode in org.apache.calcite.rel.metadata

Fields in org.apache.calcite.rel.metadata with type parameters of type RelNode

Modifier and Type	Field and Description
private static Set<Class<? extends RelNode>>	JaninoRelMetadataProvider.ALL_RELS
private com.google.common.cache.LoadingCache<Pair<Class<RelNode>,Class<Metadata>>,UnboundMetadata<Metadata>>	MetadataFactoryImpl.cache
(package private) Set<Class<RelNode>>	ReflectiveRelMetadataProvider.Space.classes
(package private) Map<Pair<Class<RelNode>,Method>,Method>	ReflectiveRelMetadataProvider.Space.handlerMap
private ConcurrentMap<Class<RelNode>,UnboundMetadata>	ReflectiveRelMetadataProvider.map
Class<? extends RelNode>	JaninoRelMetadataProvider.NoHandler.relClass
com.google.common.collect.ImmutableList<Class<? extends RelNode>>	JaninoRelMetadataProvider.Key.relClasses
private static com.google.common.base.Predicate<RelNode>	RelMdColumnUniqueness.SAFE_REL Aggregate and Calc are "safe" children of a RelSubset to delve into.

Methods in org.apache.calcite.rel.metadata that return RelNode

Modifier and Type	Method and Description
RelNode	Metadata.rel() Returns the relational expression that this metadata is about.

Methods in org.apache.calcite.rel.metadata that return types with arguments of type RelNode

Modifier and Type	Method and Description
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	BuiltInMetadata.NodeTypes.getNodeTypes() Returns a multimap from the class to the nodes instantiating that class.
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	BuiltInMetadata.NodeTypes.getNodeTypes() Returns a multimap from the class to the nodes instantiating that class.
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Aggregate rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Aggregate rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Calc rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Calc rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Filter rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Filter rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(HepRelVertex rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(HepRelVertex rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Intersect rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Intersect rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Join rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Join rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Minus rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Minus rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Project rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Project rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMetadataQuery.getNodeTypes(RelNode rel) Returns the BuiltInMetadata.NodeTypes.getNodeTypes() statistic.
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMetadataQuery.getNodeTypes(RelNode rel) Returns the BuiltInMetadata.NodeTypes.getNodeTypes() statistic.
private static com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelNode rel, Class<? extends RelNode> c, RelMetadataQuery mq)
private static com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelNode rel, Class<? extends RelNode> c, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.NodeTypes.getNodeTypes(), invoked using reflection.
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.NodeTypes.getNodeTypes(), invoked using reflection.
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	BuiltInMetadata.NodeTypes.Handler.getNodeTypes(RelNode r, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	BuiltInMetadata.NodeTypes.Handler.getNodeTypes(RelNode r, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelSubset rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelSubset rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(SemiJoin rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(SemiJoin rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Sort rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Sort rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(TableScan rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(TableScan rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Union rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Union rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Values rel, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(Values rel, RelMetadataQuery mq)
private static com.google.common.cache.CacheLoader<Pair<Class<RelNode>,Class<Metadata>>,UnboundMetadata<Metadata>>	MetadataFactoryImpl.loader(RelMetadataProvider provider)

Methods in org.apache.calcite.rel.metadata with parameters of type RelNode

Modifier and Type	Method and Description
static boolean	RelMdUtil.areColumnsDefinitelyUnique(RelMetadataQuery mq, RelNode rel, ImmutableBitSet colMask) Returns true if the columns represented in a bit mask are definitely known to form a unique column set.
static boolean	RelMdUtil.areColumnsDefinitelyUnique(RelMetadataQuery mq, RelNode rel, List<RexInputRef> columnRefs)
static boolean	RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(RelMetadataQuery mq, RelNode rel, ImmutableBitSet colMask) Returns true if the columns represented in a bit mask are definitely known to form a unique column set, when nulls have been filtered from the columns.
static boolean	RelMdUtil.areColumnsDefinitelyUniqueWhenNullsFiltered(RelMetadataQuery mq, RelNode rel, List<RexInputRef> columnRefs)
static Boolean	RelMdUtil.areColumnsUnique(RelMetadataQuery mq, RelNode rel, List<RexInputRef> columnRefs)
Boolean	RelMetadataQuery.areColumnsUnique(RelNode rel, ImmutableBitSet columns) Returns the BuiltInMetadata.ColumnUniqueness.areColumnsUnique(ImmutableBitSet, boolean) statistic.
Boolean	RelMetadataQuery.areColumnsUnique(RelNode rel, ImmutableBitSet columns, boolean ignoreNulls) Returns the BuiltInMetadata.ColumnUniqueness.areColumnsUnique(ImmutableBitSet, boolean) statistic.
Boolean	RelMdColumnUniqueness.areColumnsUnique(RelNode rel, RelMetadataQuery mq, ImmutableBitSet columns, boolean ignoreNulls) Catch-all implementation for BuiltInMetadata.ColumnUniqueness.areColumnsUnique(ImmutableBitSet, boolean), invoked using reflection, for any relational expression not handled by a more specific method.
Boolean	BuiltInMetadata.ColumnUniqueness.Handler.areColumnsUnique(RelNode r, RelMetadataQuery mq, ImmutableBitSet columns, boolean ignoreNulls)
static Boolean	RelMdUtil.areColumnsUniqueWhenNullsFiltered(RelMetadataQuery mq, RelNode rel, List<RexInputRef> columnRefs)
Boolean	RelMetadataQuery.areRowsUnique(RelNode rel) Returns whether the rows of a given relational expression are distinct.
List<Double>	RelMdSize.averageColumnSizes(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Size.averageColumnSizes(), invoked using reflection.
List<Double>	BuiltInMetadata.Size.Handler.averageColumnSizes(RelNode r, RelMetadataQuery mq)
Double	RelMdSize.averageRowSize(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Size.averageRowSize(), invoked using reflection.
Double	BuiltInMetadata.Size.Handler.averageRowSize(RelNode r, RelMetadataQuery mq)
M	UnboundMetadata.bind(RelNode rel, RelMetadataQuery mq)
static List<RelCollation>	RelMdCollation.calc(RelMetadataQuery mq, RelNode input, RexProgram program) Helper method to determine a Calc's collation.
static RelDistribution	RelMdDistribution.calc(RelMetadataQuery mq, RelNode input, RexProgram program) Helper method to determine a Calc's distribution.
static boolean	RelMdUtil.checkInputForCollationAndLimit(RelMetadataQuery mq, RelNode input, RelCollation collation, RexNode offset, RexNode fetch) Returns whether a relational expression is already sorted and has fewer rows than the sum of offset and limit.
com.google.common.collect.ImmutableList<RelCollation>	RelMetadataQuery.collations(RelNode rel) Returns the BuiltInMetadata.Collation.collations() statistic.
com.google.common.collect.ImmutableList<RelCollation>	RelMdCollation.collations(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Collation.collations(), invoked using reflection, for any relational expression not handled by a more specific method.
com.google.common.collect.ImmutableList<RelCollation>	BuiltInMetadata.Collation.Handler.collations(RelNode r, RelMetadataQuery mq)
static double	RelMdUtil.computeSemiJoinSelectivity(RelMetadataQuery mq, RelNode factRel, RelNode dimRel, List<Integer> factKeyList, List<Integer> dimKeyList) Computes the selectivity of a semijoin filter if it is applied on a fact table.
static double	RelMdUtil.computeSemiJoinSelectivity(RelMetadataQuery mq, RelNode factRel, RelNode dimRel, SemiJoin rel) Computes the selectivity of a semijoin filter if it is applied on a fact table.
Double	RelMetadataQuery.cumulativeMemoryWithinPhase(RelNode rel) Returns the BuiltInMetadata.Memory.cumulativeMemoryWithinPhase() statistic.
Double	RelMdMemory.cumulativeMemoryWithinPhase(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Memory.cumulativeMemoryWithinPhase(), invoked using reflection.
Double	BuiltInMetadata.Memory.Handler.cumulativeMemoryWithinPhase(RelNode r, RelMetadataQuery mq)
Double	RelMetadataQuery.cumulativeMemoryWithinPhaseSplit(RelNode rel) Returns the BuiltInMetadata.Memory.cumulativeMemoryWithinPhaseSplit() statistic.
Double	RelMdMemory.cumulativeMemoryWithinPhaseSplit(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Memory.cumulativeMemoryWithinPhaseSplit(), invoked using reflection.
Double	BuiltInMetadata.Memory.Handler.cumulativeMemoryWithinPhaseSplit(RelNode r, RelMetadataQuery mq)
RelDistribution	RelMetadataQuery.distribution(RelNode rel) Returns the BuiltInMetadata.Distribution.distribution() statistic.
RelDistribution	RelMdDistribution.distribution(RelNode rel, RelMetadataQuery mq) Fallback method to deduce distribution for any relational expression not handled by a more specific method.
RelDistribution	BuiltInMetadata.Distribution.Handler.distribution(RelNode r, RelMetadataQuery mq)
static double	RelMdUtil.estimateFilteredRows(RelNode child, RexNode condition, RelMetadataQuery mq)
static double	RelMdUtil.estimateFilteredRows(RelNode child, RexProgram program, RelMetadataQuery mq)
static List<RelCollation>	RelMdCollation.filter(RelMetadataQuery mq, RelNode input) Helper method to determine a Filter's collation.
static RelDistribution	RelMdDistribution.filter(RelMetadataQuery mq, RelNode input) Helper method to determine a Filter's distribution.
RelOptPredicateList	RelMetadataQuery.getAllPredicates(RelNode rel) Returns the BuiltInMetadata.AllPredicates.getAllPredicates() statistic.
RelOptPredicateList	RelMdAllPredicates.getAllPredicates(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.AllPredicates.getAllPredicates(), invoked using reflection.
RelOptPredicateList	BuiltInMetadata.AllPredicates.Handler.getAllPredicates(RelNode r, RelMetadataQuery mq)
List<Double>	RelMetadataQuery.getAverageColumnSizes(RelNode rel) Returns the BuiltInMetadata.Size.averageColumnSizes() statistic.
List<Double>	RelMetadataQuery.getAverageColumnSizesNotNull(RelNode rel) As RelMetadataQuery.getAverageColumnSizes(org.apache.calcite.rel.RelNode) but never returns a null list, only ever a list of nulls.
Double	RelMetadataQuery.getAverageRowSize(RelNode rel) Returns the BuiltInMetadata.Size.averageRowSize() statistic.
RelColumnOrigin	RelMetadataQuery.getColumnOrigin(RelNode rel, int column) Determines the origin of a column, provided the column maps to a single column that isn't derived.
Set<RelColumnOrigin>	RelMetadataQuery.getColumnOrigins(RelNode rel, int column) Returns the BuiltInMetadata.ColumnOrigin.getColumnOrigins(int) statistic.
Set<RelColumnOrigin>	RelMdColumnOrigins.getColumnOrigins(RelNode rel, RelMetadataQuery mq, int iOutputColumn)
Set<RelColumnOrigin>	BuiltInMetadata.ColumnOrigin.Handler.getColumnOrigins(RelNode r, RelMetadataQuery mq, int outputColumn)
RelOptCost	RelMetadataQuery.getCumulativeCost(RelNode rel) Returns the BuiltInMetadata.CumulativeCost.getCumulativeCost() statistic.
RelOptCost	RelMdPercentageOriginalRows.getCumulativeCost(RelNode rel, RelMetadataQuery mq)
RelOptCost	BuiltInMetadata.CumulativeCost.Handler.getCumulativeCost(RelNode r, RelMetadataQuery mq)
Double	RelMetadataQuery.getDistinctRowCount(RelNode rel, ImmutableBitSet groupKey, RexNode predicate) Returns the BuiltInMetadata.DistinctRowCount.getDistinctRowCount(ImmutableBitSet, RexNode) statistic.
Double	RelMdDistinctRowCount.getDistinctRowCount(RelNode rel, RelMetadataQuery mq, ImmutableBitSet groupKey, RexNode predicate) Catch-all implementation for BuiltInMetadata.DistinctRowCount.getDistinctRowCount(ImmutableBitSet, RexNode), invoked using reflection.
Double	BuiltInMetadata.DistinctRowCount.Handler.getDistinctRowCount(RelNode r, RelMetadataQuery mq, ImmutableBitSet groupKey, RexNode predicate)
RelDistribution	RelMetadataQuery.getDistribution(RelNode rel) Returns the BuiltInMetadata.Distribution.distribution() statistic.
Set<RexNode>	RelMdExpressionLineage.getExpressionLineage(RelNode rel, RelMetadataQuery mq, RexNode outputExpression)
Set<RexNode>	BuiltInMetadata.ExpressionLineage.Handler.getExpressionLineage(RelNode r, RelMetadataQuery mq, RexNode expression)
Set<RexNode>	RelMetadataQuery.getExpressionLineage(RelNode rel, RexNode expression) Determines the origin of a column.
static Double	RelMdUtil.getJoinDistinctRowCount(RelMetadataQuery mq, RelNode joinRel, JoinRelType joinType, ImmutableBitSet groupKey, RexNode predicate, boolean useMaxNdv) Computes the number of distinct rows for a set of keys returned from a join.
static Double	RelMdUtil.getJoinPopulationSize(RelMetadataQuery mq, RelNode joinRel, ImmutableBitSet groupKey) Computes the population size for a set of keys returned from a join
Double	RelMetadataQuery.getMaxRowCount(RelNode rel) Returns the BuiltInMetadata.MaxRowCount.getMaxRowCount() statistic.
Double	RelMdMaxRowCount.getMaxRowCount(RelNode rel, RelMetadataQuery mq)
Double	BuiltInMetadata.MaxRowCount.Handler.getMaxRowCount(RelNode r, RelMetadataQuery mq)
Double	RelMetadataQuery.getMinRowCount(RelNode rel) Returns the BuiltInMetadata.MinRowCount.getMinRowCount() statistic.
Double	RelMdMinRowCount.getMinRowCount(RelNode rel, RelMetadataQuery mq)
Double	BuiltInMetadata.MinRowCount.Handler.getMinRowCount(RelNode r, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMetadataQuery.getNodeTypes(RelNode rel) Returns the BuiltInMetadata.NodeTypes.getNodeTypes() statistic.
private static com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelNode rel, Class<? extends RelNode> c, RelMetadataQuery mq)
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.NodeTypes.getNodeTypes(), invoked using reflection.
com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	BuiltInMetadata.NodeTypes.Handler.getNodeTypes(RelNode r, RelMetadataQuery mq)
RelOptCost	RelMetadataQuery.getNonCumulativeCost(RelNode rel) Returns the BuiltInMetadata.NonCumulativeCost.getNonCumulativeCost() statistic.
RelOptCost	RelMdPercentageOriginalRows.getNonCumulativeCost(RelNode rel, RelMetadataQuery mq)
RelOptCost	BuiltInMetadata.NonCumulativeCost.Handler.getNonCumulativeCost(RelNode r, RelMetadataQuery mq)
Double	RelMetadataQuery.getPercentageOriginalRows(RelNode rel) Returns the BuiltInMetadata.PercentageOriginalRows.getPercentageOriginalRows() statistic.
Double	RelMdPercentageOriginalRows.getPercentageOriginalRows(RelNode rel, RelMetadataQuery mq)
Double	BuiltInMetadata.PercentageOriginalRows.Handler.getPercentageOriginalRows(RelNode r, RelMetadataQuery mq)
Double	RelMetadataQuery.getPopulationSize(RelNode rel, ImmutableBitSet groupKey) Returns the BuiltInMetadata.PopulationSize.getPopulationSize(ImmutableBitSet) statistic.
Double	RelMdPopulationSize.getPopulationSize(RelNode rel, RelMetadataQuery mq, ImmutableBitSet groupKey) Catch-all implementation for BuiltInMetadata.PopulationSize.getPopulationSize(ImmutableBitSet), invoked using reflection.
Double	BuiltInMetadata.PopulationSize.Handler.getPopulationSize(RelNode r, RelMetadataQuery mq, ImmutableBitSet groupKey)
RelOptPredicateList	RelMdPredicates.getPredicates(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Predicates.getPredicates(), invoked using reflection.
RelOptPredicateList	BuiltInMetadata.Predicates.Handler.getPredicates(RelNode r, RelMetadataQuery mq)
RelOptPredicateList	RelMetadataQuery.getPulledUpPredicates(RelNode rel) Returns the BuiltInMetadata.Predicates.getPredicates() statistic.
Double	RelMetadataQuery.getRowCount(RelNode rel) Returns the BuiltInMetadata.RowCount.getRowCount() statistic.
Double	RelMdRowCount.getRowCount(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.RowCount.getRowCount(), invoked using reflection.
Double	BuiltInMetadata.RowCount.Handler.getRowCount(RelNode r, RelMetadataQuery mq)
Double	RelMdSelectivity.getSelectivity(RelNode rel, RelMetadataQuery mq, RexNode predicate)
Double	BuiltInMetadata.Selectivity.Handler.getSelectivity(RelNode r, RelMetadataQuery mq, RexNode predicate)
Double	RelMetadataQuery.getSelectivity(RelNode rel, RexNode predicate) Returns the BuiltInMetadata.Selectivity.getSelectivity(RexNode) statistic.
static Double	RelMdUtil.getSemiJoinRowCount(RelMetadataQuery mq, RelNode left, RelNode right, JoinRelType joinType, RexNode condition) Returns an estimate of the number of rows returned by a SemiJoin.
RelOptTable	RelMetadataQuery.getTableOrigin(RelNode rel) Determines the origin of a RelNode, provided it maps to a single table, optionally with filtering and projection.
Set<RexTableInputRef.RelTableRef>	RelMetadataQuery.getTableReferences(RelNode rel) Determines the tables used by a plan.
Set<RexTableInputRef.RelTableRef>	RelMdTableReferences.getTableReferences(RelNode rel, RelMetadataQuery mq)
Set<RexTableInputRef.RelTableRef>	BuiltInMetadata.TableReferences.Handler.getTableReferences(RelNode r, RelMetadataQuery mq)
Set<ImmutableBitSet>	RelMetadataQuery.getUniqueKeys(RelNode rel) Returns the BuiltInMetadata.UniqueKeys.getUniqueKeys(boolean) statistic.
Set<ImmutableBitSet>	RelMetadataQuery.getUniqueKeys(RelNode rel, boolean ignoreNulls) Returns the BuiltInMetadata.UniqueKeys.getUniqueKeys(boolean) statistic.
Set<ImmutableBitSet>	RelMdUniqueKeys.getUniqueKeys(RelNode rel, RelMetadataQuery mq, boolean ignoreNulls)
Set<ImmutableBitSet>	BuiltInMetadata.UniqueKeys.Handler.getUniqueKeys(RelNode r, RelMetadataQuery mq, boolean ignoreNulls)
Boolean	RelMetadataQuery.isPhaseTransition(RelNode rel) Returns the BuiltInMetadata.Parallelism.isPhaseTransition() statistic.
Boolean	RelMdParallelism.isPhaseTransition(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Parallelism.isPhaseTransition(), invoked using reflection.
Boolean	BuiltInMetadata.Parallelism.Handler.isPhaseTransition(RelNode r, RelMetadataQuery mq)
Boolean	RelMdExplainVisibility.isVisibleInExplain(RelNode rel, RelMetadataQuery mq, SqlExplainLevel explainLevel) Catch-all implementation for BuiltInMetadata.ExplainVisibility.isVisibleInExplain(SqlExplainLevel), invoked using reflection.
Boolean	BuiltInMetadata.ExplainVisibility.Handler.isVisibleInExplain(RelNode r, RelMetadataQuery mq, SqlExplainLevel explainLevel)
boolean	RelMetadataQuery.isVisibleInExplain(RelNode rel, SqlExplainLevel explainLevel) Returns the BuiltInMetadata.ExplainVisibility.isVisibleInExplain(SqlExplainLevel) statistic.
static List<RelCollation>	RelMdCollation.limit(RelMetadataQuery mq, RelNode input) Helper method to determine a limit's collation.
static RelDistribution	RelMdDistribution.limit(RelMetadataQuery mq, RelNode input) Helper method to determine a limit's distribution.
Double	RelMetadataQuery.memory(RelNode rel) Returns the BuiltInMetadata.Memory.memory() statistic.
Double	RelMdMemory.memory(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Memory.memory(), invoked using reflection.
Double	BuiltInMetadata.Memory.Handler.memory(RelNode r, RelMetadataQuery mq)
static List<RelCollation>	RelMdCollation.mergeJoin(RelMetadataQuery mq, RelNode left, RelNode right, ImmutableIntList leftKeys, ImmutableIntList rightKeys) Helper method to determine a Join's collation assuming that it uses a merge-join algorithm.
static List<RelCollation>	RelMdCollation.project(RelMetadataQuery mq, RelNode input, List<? extends RexNode> projects) Helper method to determine a Project's collation.
static RelDistribution	RelMdDistribution.project(RelMetadataQuery mq, RelNode input, List<? extends RexNode> projects) Helper method to determine a Project's collation.
private RexNode	RelMdPredicates.projectPredicate(RexBuilder rexBuilder, RelNode input, RexNode r, ImmutableBitSet columnsMapped) Converts a predicate on a particular set of columns into a predicate on a subset of those columns, weakening if necessary.
<M extends Metadata> M	MetadataFactoryImpl.query(RelNode rel, RelMetadataQuery mq, Class<M> metadataClazz)
<M extends Metadata> M	MetadataFactory.query(RelNode rel, RelMetadataQuery mq, Class<M> metadataClazz) Returns a metadata interface to get a particular kind of metadata from a particular relational expression.
private boolean	RelMdColumnUniqueness.simplyProjects(RelNode rel, ImmutableBitSet columns)
static RelDistribution	RelMdDistribution.sort(RelMetadataQuery mq, RelNode input) Helper method to determine a Sort's distribution.
Integer	RelMetadataQuery.splitCount(RelNode rel) Returns the BuiltInMetadata.Parallelism.splitCount() statistic.
Integer	RelMdParallelism.splitCount(RelNode rel, RelMetadataQuery mq) Catch-all implementation for BuiltInMetadata.Parallelism.splitCount(), invoked using reflection.
Integer	BuiltInMetadata.Parallelism.Handler.splitCount(RelNode r, RelMetadataQuery mq)
static List<RelCollation>	RelMdCollation.window(RelMetadataQuery mq, RelNode input, com.google.common.collect.ImmutableList<Window.Group> groups) Helper method to determine a Window's collation.

Method parameters in org.apache.calcite.rel.metadata with type arguments of type RelNode

Modifier and Type	Method and Description
<M extends Metadata> UnboundMetadata<M>	ReflectiveRelMetadataProvider.apply(Class<? extends RelNode> relClass)
<M extends Metadata> UnboundMetadata<M>	CachingRelMetadataProvider.apply(Class<? extends RelNode> relClass, Class<? extends M> metadataClass)
<M extends Metadata> UnboundMetadata<M>	ReflectiveRelMetadataProvider.apply(Class<? extends RelNode> relClass, Class<? extends M> metadataClass)
<M extends Metadata> UnboundMetadata<M>	RelMetadataProvider.apply(Class<? extends RelNode> relClass, Class<? extends M> metadataClass) Retrieves metadata of a particular type and for a particular sub-class of relational expression.
<M extends Metadata> UnboundMetadata<M>	JaninoRelMetadataProvider.apply(Class<? extends RelNode> relClass, Class<? extends M> metadataClass)
<M extends Metadata> UnboundMetadata<M>	ChainedRelMetadataProvider.apply(Class<? extends RelNode> relClass, Class<? extends M> metadataClass)
(package private) Method	ReflectiveRelMetadataProvider.Space.find(Class<? extends RelNode> relNodeClass, Method method) Finds an implementation of a method for relNodeClass or its nearest base class.
private static com.google.common.collect.Multimap<Class<? extends RelNode>,RelNode>	RelMdNodeTypes.getNodeTypes(RelNode rel, Class<? extends RelNode> c, RelMetadataQuery mq)
private static <M extends Metadata> MetadataHandler<M>	JaninoRelMetadataProvider.load3(MetadataDef<M> def, com.google.common.collect.Multimap<Method,MetadataHandler<M>> map, com.google.common.collect.ImmutableList<Class<? extends RelNode>> relClasses)
void	JaninoRelMetadataProvider.register(Iterable<Class<? extends RelNode>> classes) Registers some classes.
protected <M extends Metadata,H extends MetadataHandler<M>> H	RelMetadataQuery.revise(Class<? extends RelNode> class_, MetadataDef<M> def) Re-generates the handler for a given kind of metadata, adding support for class_ if it is not already present.
(package private) <M extends Metadata,H extends MetadataHandler<M>> H	JaninoRelMetadataProvider.revise(Class<? extends RelNode> rClass, MetadataDef<M> def)

Constructor parameters in org.apache.calcite.rel.metadata with type arguments of type RelNode

Constructor and Description
Key(MetadataDef def, RelMetadataProvider provider, com.google.common.collect.ImmutableList<Class<? extends RelNode>> relClassList)
NoHandler(Class<? extends RelNode> relClass)
ReflectiveRelMetadataProvider(ConcurrentMap<Class<RelNode>,UnboundMetadata> map, Class<? extends Metadata> metadataClass0, com.google.common.collect.Multimap<Method,MetadataHandler> handlerMap) Creates a ReflectiveRelMetadataProvider.

Uses of RelNode in org.apache.calcite.rel.mutable

Fields in org.apache.calcite.rel.mutable declared as RelNode

Modifier and Type	Field and Description
protected RelNode	MutableLeafRel.rel

Methods in org.apache.calcite.rel.mutable that return RelNode

Modifier and Type	Method and Description
static RelNode	MutableRels.fromMutable(MutableRel node)
static RelNode	MutableRels.fromMutable(MutableRel node, RelBuilder relBuilder)

Methods in org.apache.calcite.rel.mutable that return types with arguments of type RelNode

Modifier and Type	Method and Description
private static List<RelNode>	MutableRels.fromMutables(List<MutableRel> nodes, RelBuilder relBuilder)

Methods in org.apache.calcite.rel.mutable with parameters of type RelNode

Modifier and Type	Method and Description
static MutableRel	MutableRels.toMutable(RelNode rel)

Method parameters in org.apache.calcite.rel.mutable with type arguments of type RelNode

Modifier and Type	Method and Description
private static List<MutableRel>	MutableRels.toMutables(List<RelNode> nodes)

Constructors in org.apache.calcite.rel.mutable with parameters of type RelNode

Constructor and Description
MutableLeafRel(MutableRelType type, RelNode rel)

Uses of RelNode in org.apache.calcite.rel.rel2sql

Fields in org.apache.calcite.rel.rel2sql declared as RelNode

Modifier and Type	Field and Description
private RelNode	RelToSqlConverter.Frame.r
private RelNode	SqlImplementor.Builder.rel

Methods in org.apache.calcite.rel.rel2sql with parameters of type RelNode

Modifier and Type	Method and Description
SqlImplementor.Builder	SqlImplementor.Result.builder(RelNode rel, SqlImplementor.Clause... clauses) Once you have a Result of implementing a child relational expression, call this method to create a Builder to implement the current relational expression by adding additional clauses to the SQL query.
protected SqlImplementor.Result	RelToSqlConverter.dispatch(RelNode e) Dispatches a call to the visit(Xxx e) method where Xxx most closely matches the runtime type of the argument.
private void	RelToSqlConverter.parseCorrelTable(RelNode relNode, SqlImplementor.Result x)
SqlImplementor.Result	SqlImplementor.result(SqlNode node, Collection<SqlImplementor.Clause> clauses, RelNode rel, Map<String,RelDataType> aliases) Creates a result based on a single relational expression.
SqlImplementor.Result	SqlImplementor.setOpToSql(SqlSetOperator operator, RelNode rel)
SqlImplementor.Result	RelToSqlConverter.visit(RelNode e)
SqlImplementor.Result	RelToSqlConverter.visitChild(int i, RelNode e)
abstract SqlImplementor.Result	SqlImplementor.visitChild(int i, RelNode e)

Constructors in org.apache.calcite.rel.rel2sql with parameters of type RelNode

Constructor and Description
Builder(RelNode rel, List<SqlImplementor.Clause> clauses, SqlSelect select, SqlImplementor.Context context, Map<String,RelDataType> aliases)
Frame(int ordinalInParent, RelNode r)

Uses of RelNode in org.apache.calcite.rel.rules

Classes in org.apache.calcite.rel.rules that implement RelNode

Modifier and Type	Class and Description
class	MultiJoin A MultiJoin represents a join of N inputs, whereas regular Joins represent strictly binary joins.

Fields in org.apache.calcite.rel.rules declared as RelNode

Modifier and Type	Field and Description
private RelNode	CalcRelSplitter.child
private RelNode	PushProjector.childRel
private RelNode[]	LoptSemiJoinOptimizer.chosenSemiJoins Semijoins corresponding to each join factor, if they are going to be filtered by semijoins.
private RelNode	LoptJoinTree.joinTree
(package private) RelNode	AggregateJoinTransposeRule.Side.newInput
private RelNode	AbstractMaterializedViewRule.ViewPartialRewriting.newView
private RelNode	AbstractMaterializedViewRule.ViewPartialRewriting.newViewNode
private RelNode	MultiJoinOptimizeBushyRule.LeafVertex.rel

Fields in org.apache.calcite.rel.rules with type parameters of type RelNode

Modifier and Type	Field and Description
private List<RelNode>	MultiJoin.inputs
private com.google.common.collect.ImmutableList<RelNode>	LoptMultiJoin.joinFactors Original inputs into the MultiJoin
private static com.google.common.base.Predicate<RelNode>	AggregateExtractProjectRule.PREDICATE Predicate that prevents matching against an Aggregate whose input is already a Project.

Methods in org.apache.calcite.rel.rules that return RelNode

Modifier and Type	Method and Description
RelNode	MultiJoin.accept(RexShuttle shuttle)
static RelNode	AggregateProjectMergeRule.apply(RelOptRuleCall call, Aggregate aggregate, Project project)
RelNode	PushProjector.convertProject(RexNode defaultExpr) Decomposes a projection to the input references referenced by a projection and a filter, either of which is optional.
RelNode	MultiJoin.copy(RelTraitSet traitSet, List<RelNode> inputs)
protected RelNode	ReduceExpressionsRule.CalcReduceExpressionsRule.createEmptyRelOrEquivalent(RelOptRuleCall call, Calc input) For static schema systems, a filter that is always false or null can be replaced by a values operator that produces no rows, as the schema information can just be taken from the input Rel.
protected RelNode	ReduceExpressionsRule.FilterReduceExpressionsRule.createEmptyRelOrEquivalent(RelOptRuleCall call, Filter input) For static schema systems, a filter that is always false or null can be replaced by a values operator that produces no rows, as the schema information can just be taken from the input Rel.
RelNode	PushProjector.createNewProject(RelNode projChild, int[] adjustments) Creates a new projection based on the original projection, adjusting all input refs using an adjustment array passed in.
private RelNode	LoptOptimizeJoinRule.createTopProject(RelBuilder relBuilder, LoptMultiJoin multiJoin, LoptJoinTree joinTree, List<String> fieldNames) Creates the topmost projection that will sit on top of the selected join ordering.
protected abstract RelNode	AbstractMaterializedViewRule.createUnion(RelBuilder relBuilder, RexBuilder rexBuilder, RelNode topProject, RelNode unionInputQuery, RelNode unionInputView) If the view will be used in a union rewriting, this method is responsible for generating the union and any other operator needed on top of it, e.g., a Project operator.
protected RelNode	AbstractMaterializedViewRule.MaterializedViewJoinRule.createUnion(RelBuilder relBuilder, RexBuilder rexBuilder, RelNode topProject, RelNode unionInputQuery, RelNode unionInputView)
protected RelNode	AbstractMaterializedViewRule.MaterializedViewAggregateRule.createUnion(RelBuilder relBuilder, RexBuilder rexBuilder, RelNode topProject, RelNode unionInputQuery, RelNode unionInputView)
(package private) RelNode	CalcRelSplitter.execute()
RelNode	LoptSemiJoinOptimizer.getChosenSemiJoin(int factIdx)
RelNode	LoptMultiJoin.getJoinFactor(int factIdx)
RelNode	LoptJoinTree.getJoinTree()
protected RelNode	MultiJoinProjectTransposeRule.getProjectChild(RelOptRuleCall call, LogicalProject project, boolean leftChild)
protected RelNode	JoinProjectTransposeRule.getProjectChild(RelOptRuleCall call, Project project, boolean leftChild) Returns the child of the project that will be used as input into the new LogicalJoin once the projects are pulled above the LogicalJoin.
protected RelNode	CalcRelSplitter.handle(RelNode rel) Opportunity to further refine the relational expression created for a given level.
protected RelNode	CalcRelSplitter.RelType.makeRel(RelOptCluster cluster, RelTraitSet traitSet, RelBuilder relBuilder, RelNode input, RexProgram program)
protected abstract RelNode	AbstractMaterializedViewRule.rewriteQuery(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, RexNode compensationColumnsEquiPred, RexNode otherCompensationPred, Project topProject, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> viewToQueryTableMapping, AbstractMaterializedViewRule.EquivalenceClasses viewEC, AbstractMaterializedViewRule.EquivalenceClasses queryEC) If the view will be used in a union rewriting, this method is responsible for rewriting the query branch of the union using the given compensation predicate.
protected RelNode	AbstractMaterializedViewRule.MaterializedViewJoinRule.rewriteQuery(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, RexNode compensationColumnsEquiPred, RexNode otherCompensationPred, Project topProject, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> viewToQueryTableMapping, AbstractMaterializedViewRule.EquivalenceClasses viewEC, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
protected RelNode	AbstractMaterializedViewRule.MaterializedViewAggregateRule.rewriteQuery(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, RexNode compensationColumnsEquiPred, RexNode otherCompensationPred, Project topProject, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses viewEC, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
protected abstract RelNode	AbstractMaterializedViewRule.rewriteView(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, AbstractMaterializedViewRule.MatchModality matchModality, boolean unionRewriting, RelNode input, Project topProject, RelNode node, Project topViewProject, RelNode viewNode, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses queryEC) This method is responsible for rewriting the query using the given view query.
protected RelNode	AbstractMaterializedViewRule.MaterializedViewJoinRule.rewriteView(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, AbstractMaterializedViewRule.MatchModality matchModality, boolean unionRewriting, RelNode input, Project topProject, RelNode node, Project topViewProject, RelNode viewNode, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
protected RelNode	AbstractMaterializedViewRule.MaterializedViewAggregateRule.rewriteView(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, AbstractMaterializedViewRule.MatchModality matchModality, boolean unionRewriting, RelNode input, Project topProject, RelNode node, Project topViewProject, RelNode viewNode, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
static RelNode	ProjectRemoveRule.strip(Project project) Returns the child of a project if the project is trivial, otherwise the project itself.
static RelNode	JoinCommuteRule.swap(Join join) Returns a relational expression with the inputs switched round.
static RelNode	JoinCommuteRule.swap(Join join, boolean swapOuterJoins) Returns a relational expression with the inputs switched round.

Methods in org.apache.calcite.rel.rules that return types with arguments of type RelNode

Modifier and Type	Method and Description
private List<RelNode>	JoinToMultiJoinRule.combineInputs(Join join, RelNode left, RelNode right, List<ImmutableBitSet> projFieldsList, List<int[]> joinFieldRefCountsList) Combines the inputs into a LogicalJoin into an array of inputs.
List<RelNode>	MultiJoin.getInputs()
protected abstract Pair<RelNode,RelNode>	AbstractMaterializedViewRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond) Once we create a compensation predicate, this method is responsible for pushing the resulting filter through the view nodes.
protected abstract Pair<RelNode,RelNode>	AbstractMaterializedViewRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond) Once we create a compensation predicate, this method is responsible for pushing the resulting filter through the view nodes.
Pair<RelNode,RelNode>	AbstractMaterializedViewRule.MaterializedViewJoinRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond)
Pair<RelNode,RelNode>	AbstractMaterializedViewRule.MaterializedViewJoinRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond)
Pair<RelNode,RelNode>	AbstractMaterializedViewRule.MaterializedViewAggregateRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond)
Pair<RelNode,RelNode>	AbstractMaterializedViewRule.MaterializedViewAggregateRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond)

Methods in org.apache.calcite.rel.rules with parameters of type RelNode

Modifier and Type	Method and Description
private static boolean	LoptOptimizeJoinRule.areSelfJoinKeysUnique(RelMetadataQuery mq, RelNode leftRel, RelNode rightRel, RexNode joinFilters) Determines if the equality portion of a self-join condition is between identical keys that are unique.
private boolean	JoinToMultiJoinRule.canCombine(RelNode input, boolean nullGenerating) Returns whether an input can be merged into a given relational expression without changing semantics.
private List<RelNode>	JoinToMultiJoinRule.combineInputs(Join join, RelNode left, RelNode right, List<ImmutableBitSet> projFieldsList, List<int[]> joinFieldRefCountsList) Combines the inputs into a LogicalJoin into an array of inputs.
private List<RexNode>	JoinToMultiJoinRule.combineJoinFilters(Join joinRel, RelNode left, RelNode right) Combines the join filters from the left and right inputs (if they are MultiJoinRels) with the join filter in the joinrel into a single AND'd join filter, unless the inputs correspond to null generating inputs in an outer join
private void	JoinToMultiJoinRule.combineOuterJoins(Join joinRel, List<RelNode> combinedInputs, RelNode left, RelNode right, List<Pair<JoinRelType,RexNode>> joinSpecs) Combines the outer join conditions and join types from the left and right join inputs.
private List<RexNode>	JoinToMultiJoinRule.combinePostJoinFilters(Join joinRel, RelNode left, RelNode right) Combines the post-join filters from the left and right inputs (if they are MultiJoinRels) into a single AND'd filter.
protected abstract AbstractMaterializedViewRule.ViewPartialRewriting	AbstractMaterializedViewRule.compensateViewPartial(RelBuilder relBuilder, RexBuilder rexBuilder, RelMetadataQuery mq, RelNode input, Project topProject, RelNode node, Set<RexTableInputRef.RelTableRef> queryTableRefs, AbstractMaterializedViewRule.EquivalenceClasses queryEC, Project topViewProject, RelNode viewNode, Set<RexTableInputRef.RelTableRef> viewTableRefs) It checks whether the query can be rewritten using the view even though the query uses additional tables.
protected AbstractMaterializedViewRule.ViewPartialRewriting	AbstractMaterializedViewRule.MaterializedViewJoinRule.compensateViewPartial(RelBuilder relBuilder, RexBuilder rexBuilder, RelMetadataQuery mq, RelNode input, Project topProject, RelNode node, Set<RexTableInputRef.RelTableRef> queryTableRefs, AbstractMaterializedViewRule.EquivalenceClasses queryEC, Project topViewProject, RelNode viewNode, Set<RexTableInputRef.RelTableRef> viewTableRefs)
protected AbstractMaterializedViewRule.ViewPartialRewriting	AbstractMaterializedViewRule.MaterializedViewAggregateRule.compensateViewPartial(RelBuilder relBuilder, RexBuilder rexBuilder, RelMetadataQuery mq, RelNode input, Project topProject, RelNode node, Set<RexTableInputRef.RelTableRef> queryTableRefs, AbstractMaterializedViewRule.EquivalenceClasses queryEC, Project topViewProject, RelNode viewNode, Set<RexTableInputRef.RelTableRef> viewTableRefs)
private double	LoptSemiJoinOptimizer.computeScore(RelNode factRel, RelNode dimRel, SemiJoin semiJoin) Computes a score relevant to applying a set of semijoins on a fact table.
RelNode	PushProjector.createNewProject(RelNode projChild, int[] adjustments) Creates a new projection based on the original projection, adjusting all input refs using an adjustment array passed in.
protected void	JoinProjectTransposeRule.createProjectExprs(Project projRel, RelNode joinChild, int adjustmentAmount, RexBuilder rexBuilder, List<RelDataTypeField> joinChildrenFields, List<Pair<RexNode,String>> projects) Creates projection expressions corresponding to one of the inputs into the join
Project	PushProjector.createProjectRefsAndExprs(RelNode projChild, boolean adjust, boolean rightSide) Creates a projection based on the inputs specified in a bitmap and the expressions that need to be preserved.
protected abstract RelNode	AbstractMaterializedViewRule.createUnion(RelBuilder relBuilder, RexBuilder rexBuilder, RelNode topProject, RelNode unionInputQuery, RelNode unionInputView) If the view will be used in a union rewriting, this method is responsible for generating the union and any other operator needed on top of it, e.g., a Project operator.
protected RelNode	AbstractMaterializedViewRule.MaterializedViewJoinRule.createUnion(RelBuilder relBuilder, RexBuilder rexBuilder, RelNode topProject, RelNode unionInputQuery, RelNode unionInputView)
protected RelNode	AbstractMaterializedViewRule.MaterializedViewAggregateRule.createUnion(RelBuilder relBuilder, RexBuilder rexBuilder, RelNode topProject, RelNode unionInputQuery, RelNode unionInputView)
private static List<RexNode>	AbstractMaterializedViewRule.extractReferences(RexBuilder rexBuilder, RelNode node) If the node is an Aggregate, it returns a list of references to the grouping columns.
LoptSemiJoinOptimizer.FemLocalIndex	LoptSemiJoinOptimizer.LcsIndexOptimizer.findSemiJoinIndexByCost(RelNode dimRel, List<Integer> actualLeftKeys, List<Integer> rightKeys, List<Integer> bestKeyOrder)
protected com.google.common.collect.Multimap<Integer,Integer>	AbstractMaterializedViewRule.MaterializedViewAggregateRule.generateMapping(RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, RelNode node, RelNode target, ImmutableBitSet positions, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, AbstractMaterializedViewRule.EquivalenceClasses sourceEC, List<RexNode> additionalExprs) Mapping from node expressions to target expressions.
private static AbstractMaterializedViewRule.NodeLineage	AbstractMaterializedViewRule.generateSwapColumnTableReferencesLineage(RexBuilder rexBuilder, RelMetadataQuery mq, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, AbstractMaterializedViewRule.EquivalenceClasses ec, List<RexNode> nodeExprs) It swaps the column references and then the table references of the input expressions using the equivalence classes and the table mapping.
private static AbstractMaterializedViewRule.NodeLineage	AbstractMaterializedViewRule.generateSwapTableColumnReferencesLineage(RexBuilder rexBuilder, RelMetadataQuery mq, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, AbstractMaterializedViewRule.EquivalenceClasses ec, List<RexNode> nodeExprs) It swaps the table references and then the column references of the input expressions using the table mapping and the equivalence classes.
private RelDataType	AggregateReduceFunctionsRule.getFieldType(RelNode relNode, int i)
protected RelNode	CalcRelSplitter.handle(RelNode rel) Opportunity to further refine the relational expression created for a given level.
private static boolean	PruneEmptyRules.isEmpty(RelNode node)
private boolean	LoptOptimizeJoinRule.isJoinTree(RelNode rel) Returns whether a RelNode corresponds to a Join that wasn't one of the original MultiJoin input factors.
protected abstract boolean	AbstractMaterializedViewRule.isValidPlan(Project topProject, RelNode node, RelMetadataQuery mq)
protected boolean	AbstractMaterializedViewRule.MaterializedViewJoinRule.isValidPlan(Project topProject, RelNode node, RelMetadataQuery mq)
protected boolean	AbstractMaterializedViewRule.MaterializedViewAggregateRule.isValidPlan(Project topProject, RelNode node, RelMetadataQuery mq)
private static boolean	AbstractMaterializedViewRule.isValidRelNodePlan(RelNode node, RelMetadataQuery mq) Currently we only support TableScan - Project - Filter - Join
protected RelNode	CalcRelSplitter.RelType.makeRel(RelOptCluster cluster, RelTraitSet traitSet, RelBuilder relBuilder, RelNode input, RexProgram program)
protected static AbstractMaterializedViewRule.ViewPartialRewriting	AbstractMaterializedViewRule.ViewPartialRewriting.of(RelNode newView, Project newTopViewProject, RelNode newViewNode)
protected void	SemiJoinRule.perform(RelOptRuleCall call, Project project, Join join, RelNode left, Aggregate aggregate)
protected void	AbstractMaterializedViewRule.perform(RelOptRuleCall call, Project topProject, RelNode node) Rewriting logic is based on "Optimizing Queries Using Materialized Views: A Practical, Scalable Solution" by Goldstein and Larson.
protected abstract Pair<RelNode,RelNode>	AbstractMaterializedViewRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond) Once we create a compensation predicate, this method is responsible for pushing the resulting filter through the view nodes.
Pair<RelNode,RelNode>	AbstractMaterializedViewRule.MaterializedViewJoinRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond)
Pair<RelNode,RelNode>	AbstractMaterializedViewRule.MaterializedViewAggregateRule.pushFilterToOriginalViewPlan(RelBuilder builder, RelNode topViewProject, RelNode viewNode, RexNode cond)
protected static boolean	ReduceExpressionsRule.reduceExpressions(RelNode rel, List<RexNode> expList, RelOptPredicateList predicates) Reduces a list of expressions.
protected static boolean	ReduceExpressionsRule.reduceExpressions(RelNode rel, List<RexNode> expList, RelOptPredicateList predicates, boolean unknownAsFalse) Deprecated.
protected static boolean	ReduceExpressionsRule.reduceExpressions(RelNode rel, List<RexNode> expList, RelOptPredicateList predicates, boolean unknownAsFalse, boolean matchNullability) Reduces a list of expressions.
protected static boolean	ReduceExpressionsRule.reduceExpressionsInternal(RelNode rel, RexSimplify simplify, List<RexNode> expList, RelOptPredicateList predicates)
void	MultiJoin.replaceInput(int ordinalInParent, RelNode p)
private static RexNode	AbstractMaterializedViewRule.replaceWithOriginalReferences(RexBuilder rexBuilder, RelNode node, AbstractMaterializedViewRule.NodeLineage nodeLineage, RexNode exprToRewrite) Given the input expression, it will replace (sub)expressions when possible using the content of the mapping.
private static RexNode	AbstractMaterializedViewRule.rewriteExpression(RexBuilder rexBuilder, RelMetadataQuery mq, RelNode targetNode, RelNode node, List<RexNode> nodeExprs, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, AbstractMaterializedViewRule.EquivalenceClasses ec, boolean swapTableColumn, RexNode exprToRewrite) First, the method takes the node expressions nodeExprs and swaps the table and column references using the table mapping and the equivalence classes.
private static List<RexNode>	AbstractMaterializedViewRule.rewriteExpressions(RexBuilder rexBuilder, RelMetadataQuery mq, RelNode targetNode, RelNode node, List<RexNode> nodeExprs, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> tableMapping, AbstractMaterializedViewRule.EquivalenceClasses ec, boolean swapTableColumn, List<RexNode> exprsToRewrite) First, the method takes the node expressions nodeExprs and swaps the table and column references using the table mapping and the equivalence classes.
protected abstract RelNode	AbstractMaterializedViewRule.rewriteQuery(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, RexNode compensationColumnsEquiPred, RexNode otherCompensationPred, Project topProject, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> viewToQueryTableMapping, AbstractMaterializedViewRule.EquivalenceClasses viewEC, AbstractMaterializedViewRule.EquivalenceClasses queryEC) If the view will be used in a union rewriting, this method is responsible for rewriting the query branch of the union using the given compensation predicate.
protected RelNode	AbstractMaterializedViewRule.MaterializedViewJoinRule.rewriteQuery(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, RexNode compensationColumnsEquiPred, RexNode otherCompensationPred, Project topProject, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> viewToQueryTableMapping, AbstractMaterializedViewRule.EquivalenceClasses viewEC, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
protected RelNode	AbstractMaterializedViewRule.MaterializedViewAggregateRule.rewriteQuery(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, RexNode compensationColumnsEquiPred, RexNode otherCompensationPred, Project topProject, RelNode node, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses viewEC, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
protected abstract RelNode	AbstractMaterializedViewRule.rewriteView(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, AbstractMaterializedViewRule.MatchModality matchModality, boolean unionRewriting, RelNode input, Project topProject, RelNode node, Project topViewProject, RelNode viewNode, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses queryEC) This method is responsible for rewriting the query using the given view query.
protected RelNode	AbstractMaterializedViewRule.MaterializedViewJoinRule.rewriteView(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, AbstractMaterializedViewRule.MatchModality matchModality, boolean unionRewriting, RelNode input, Project topProject, RelNode node, Project topViewProject, RelNode viewNode, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
protected RelNode	AbstractMaterializedViewRule.MaterializedViewAggregateRule.rewriteView(RelBuilder relBuilder, RexBuilder rexBuilder, RexSimplify simplify, RelMetadataQuery mq, AbstractMaterializedViewRule.MatchModality matchModality, boolean unionRewriting, RelNode input, Project topProject, RelNode node, Project topViewProject, RelNode viewNode, com.google.common.collect.BiMap<RexTableInputRef.RelTableRef,RexTableInputRef.RelTableRef> queryToViewTableMapping, AbstractMaterializedViewRule.EquivalenceClasses queryEC)
private int	LoptOptimizeJoinRule.rowWidthCost(RelNode tree) Computes a cost for a join tree based on the row widths of the inputs into the join.
private RexNode	JoinToMultiJoinRule.shiftRightFilter(Join joinRel, RelNode left, MultiJoin right, RexNode rightFilter) Shifts a filter originating from the right child of the LogicalJoin to the right, to reflect the filter now being applied on the resulting MultiJoin.
private static RexNode	AbstractMaterializedViewRule.shuttleReferences(RexBuilder rexBuilder, RexNode expr, com.google.common.collect.Multimap<String,Integer> exprsLineage, RelNode node, Mapping rewritingMapping) Replaces all the possible subexpressions by input references to the input node.
private List<AggregateCall>	AggregateUnionTransposeRule.transformAggCalls(RelNode input, int groupCount, List<AggregateCall> origCalls)
private LoptSemiJoinOptimizer.LcsTable	LoptSemiJoinOptimizer.validateKeys(RelNode factRel, List<Integer> leftKeys, List<Integer> rightKeys, List<Integer> actualLeftKeys) Validates the candidate semijoin keys corresponding to the fact table.

Method parameters in org.apache.calcite.rel.rules with type arguments of type RelNode

Modifier and Type	Method and Description
private com.google.common.collect.ImmutableMap<Integer,ImmutableIntList>	JoinToMultiJoinRule.addOnJoinFieldRefCounts(List<RelNode> multiJoinInputs, int nTotalFields, RexNode joinCondition, List<int[]> origJoinFieldRefCounts) Adds on to the existing join condition reference counts the references from the new join condition.
private void	JoinToMultiJoinRule.combineOuterJoins(Join joinRel, List<RelNode> combinedInputs, RelNode left, RelNode right, List<Pair<JoinRelType,RexNode>> joinSpecs) Combines the outer join conditions and join types from the left and right join inputs.
RelNode	MultiJoin.copy(RelTraitSet traitSet, List<RelNode> inputs)

Constructors in org.apache.calcite.rel.rules with parameters of type RelNode

Constructor and Description
EquiJoin(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, ImmutableIntList leftKeys, ImmutableIntList rightKeys, JoinRelType joinType, Set<String> variablesStopped) Deprecated.
LeafVertex(int id, RelNode rel, double cost, int fieldOffset)
LoptJoinTree(RelNode joinTree, int factorId) Creates a join-tree consisting of a single node.
LoptJoinTree(RelNode joinTree, LoptJoinTree.BinaryTree factorTree, boolean removableSelfJoin) Associates the factor ids with a join-tree.
LoptJoinTree(RelNode joinTree, LoptJoinTree.BinaryTree leftFactorTree, LoptJoinTree.BinaryTree rightFactorTree) Associates the factor ids with a join-tree given the factors corresponding to the left and right subtrees of the join.
LoptJoinTree(RelNode joinTree, LoptJoinTree.BinaryTree leftFactorTree, LoptJoinTree.BinaryTree rightFactorTree, boolean removableSelfJoin) Associates the factor ids with a join-tree given the factors corresponding to the left and right subtrees of the join.
PushProjector(Project origProj, RexNode origFilter, RelNode childRel, PushProjector.ExprCondition preserveExprCondition, RelBuilder relBuilder) Creates a PushProjector object for pushing projects past a RelNode.
ViewPartialRewriting(RelNode newView, Project newTopViewProject, RelNode newViewNode)

Constructor parameters in org.apache.calcite.rel.rules with type arguments of type RelNode

Constructor and Description
AggregateExtractProjectRule(Class<? extends Aggregate> aggregateClass, Class<? extends RelNode> inputClass, RelBuilderFactory relBuilderFactory) Creates an AggregateExtractProjectRule.
AggregateProjectPullUpConstantsRule(Class<? extends Aggregate> aggregateClass, Class<? extends RelNode> inputClass, RelBuilderFactory relBuilderFactory, String description) Creates an AggregateProjectPullUpConstantsRule.
AggregateUnionAggregateRule(Class<? extends Aggregate> aggregateClass, Class<? extends Union> unionClass, Class<? extends RelNode> firstUnionInputClass, Class<? extends RelNode> secondUnionInputClass, RelBuilderFactory relBuilderFactory, String desc) Creates a AggregateUnionAggregateRule.
AggregateUnionAggregateRule(Class<? extends Aggregate> aggregateClass, Class<? extends Union> unionClass, Class<? extends RelNode> firstUnionInputClass, Class<? extends RelNode> secondUnionInputClass, RelBuilderFactory relBuilderFactory, String desc) Creates a AggregateUnionAggregateRule.
CoerceInputsRule(Class<? extends RelNode> consumerRelClass, boolean coerceNames) Deprecated.
CoerceInputsRule(Class<? extends RelNode> consumerRelClass, boolean coerceNames, RelBuilderFactory relBuilderFactory) Creates a CoerceInputsRule.
MultiJoin(RelOptCluster cluster, List<RelNode> inputs, RexNode joinFilter, RelDataType rowType, boolean isFullOuterJoin, List<RexNode> outerJoinConditions, List<JoinRelType> joinTypes, List<ImmutableBitSet> projFields, com.google.common.collect.ImmutableMap<Integer,ImmutableIntList> joinFieldRefCountsMap, RexNode postJoinFilter) Constructs a MultiJoin.
ReduceExpressionsRule(Class<? extends RelNode> clazz, boolean matchNullability, RelBuilderFactory relBuilderFactory, String description) Creates a ReduceExpressionsRule.
ReduceExpressionsRule(Class<? extends RelNode> clazz, RelBuilderFactory relBuilderFactory, String description) Deprecated.

Uses of RelNode in org.apache.calcite.rel.stream

Classes in org.apache.calcite.rel.stream that implement RelNode

Modifier and Type	Class and Description
class	Chi Relational operator that converts a stream to a relation.
class	Delta Relational operator that converts a relation to a stream.
class	LogicalChi Sub-class of Chi not targeted at any particular engine or calling convention.
class	LogicalDelta Sub-class of Delta not targeted at any particular engine or calling convention.

Methods in org.apache.calcite.rel.stream that return RelNode

Modifier and Type	Method and Description
RelNode	LogicalDelta.copy(RelTraitSet traitSet, List<RelNode> inputs)

Methods in org.apache.calcite.rel.stream with parameters of type RelNode

Modifier and Type	Method and Description
static LogicalDelta	LogicalDelta.create(RelNode input) Creates a LogicalDelta.

Method parameters in org.apache.calcite.rel.stream with type arguments of type RelNode

Modifier and Type	Method and Description
RelNode	LogicalDelta.copy(RelTraitSet traitSet, List<RelNode> inputs)

Constructors in org.apache.calcite.rel.stream with parameters of type RelNode

Constructor and Description
Chi(RelOptCluster cluster, RelTraitSet traits, RelNode input)
Delta(RelOptCluster cluster, RelTraitSet traits, RelNode input)
LogicalChi(RelOptCluster cluster, RelTraitSet traits, RelNode input)
LogicalDelta(RelOptCluster cluster, RelTraitSet traits, RelNode input) Creates a LogicalDelta.

Uses of RelNode in org.apache.calcite.rex

Fields in org.apache.calcite.rex declared as RelNode

Modifier and Type	Field and Description
RelNode	RexSubQuery.rel

Methods in org.apache.calcite.rex with parameters of type RelNode

Modifier and Type	Method and Description
RexSubQuery	RexSubQuery.clone(RelNode rel)
static RexSubQuery	RexSubQuery.exists(RelNode rel) Creates an EXISTS sub-query.
private static com.google.common.collect.ImmutableList<RelDataTypeField>	RexPermuteInputsShuttle.fields(RelNode[] inputs)
static RexSubQuery	RexSubQuery.in(RelNode rel, com.google.common.collect.ImmutableList<RexNode> nodes) Creates an IN sub-query.
RexInputRef	RexBuilder.makeInputRef(RelNode input, int i) Creates a reference to a given field of the input relational expression.
RexNode	RexBuilder.makeRangeReference(RelNode input) Creates a reference to all the fields in the row.
static RexSubQuery	RexSubQuery.scalar(RelNode rel) Creates a scalar sub-query.
static RexSubQuery	RexSubQuery.some(RelNode rel, com.google.common.collect.ImmutableList<RexNode> nodes, SqlQuantifyOperator op) Creates a SOME sub-query.
(package private) static RelDataType	RexSubQuery.type(RelNode rel, com.google.common.collect.ImmutableList<RexNode> nodes)

Constructors in org.apache.calcite.rex with parameters of type RelNode

Constructor and Description
RexPermuteInputsShuttle(Mappings.TargetMapping mapping, RelNode... inputs) Creates a RexPermuteInputsShuttle.
RexSubQuery(RelDataType type, SqlOperator op, com.google.common.collect.ImmutableList<RexNode> operands, RelNode rel)

Uses of RelNode in org.apache.calcite.schema

Methods in org.apache.calcite.schema that return RelNode

Modifier and Type	Method and Description
RelNode	TranslatableTable.toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) Converts this table into a relational expression.

Methods in org.apache.calcite.schema with parameters of type RelNode

Modifier and Type	Method and Description
TableModify	ModifiableTable.toModificationRel(RelOptCluster cluster, RelOptTable table, Prepare.CatalogReader catalogReader, RelNode child, TableModify.Operation operation, List<String> updateColumnList, List<RexNode> sourceExpressionList, boolean flattened) Creates a relational expression that modifies this table.

Uses of RelNode in org.apache.calcite.schema.impl

Classes in org.apache.calcite.schema.impl that implement RelNode

Modifier and Type	Class and Description
static class	StarTable.StarTableScan Relational expression that scans a StarTable.

Methods in org.apache.calcite.schema.impl that return RelNode

Modifier and Type	Method and Description
RelNode	MaterializedViewTable.toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable)
RelNode	StarTable.toRel(RelOptTable.ToRelContext context, RelOptTable table)
RelNode	ViewTable.toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable)

Uses of RelNode in org.apache.calcite.sql2rel

Subinterfaces of RelNode in org.apache.calcite.sql2rel

Modifier and Type	Interface and Description
static interface	RelStructuredTypeFlattener.SelfFlatteningRel Mix-in interface for relational expressions that know how to flatten themselves.

Fields in org.apache.calcite.sql2rel declared as RelNode

Modifier and Type	Field and Description
private RelNode	RelDecorrelator.currentRel
private RelNode	RelDecorrelator.DecorrelateRexShuttle.currentRel
private RelNode	RelStructuredTypeFlattener.currentRel
(package private) RelNode	RelDecorrelator.Frame.r
private RelNode	SqlToRelConverter.CorrelationUse.r
RelNode	SqlToRelConverter.Blackboard.root

Fields in org.apache.calcite.sql2rel with type parameters of type RelNode

Modifier and Type	Field and Description
(package private) List<RelNode>	SqlToRelConverter.Blackboard.cursors
private ReflectiveVisitDispatcher<RelStructuredTypeFlattener,RelNode>	RelStructuredTypeFlattener.RewriteRelVisitor.dispatcher
private List<RelNode>	SqlToRelConverter.Blackboard.inputs
protected List<RelNode>	SqlToRelConverter.leaves
private Map<RelNode,RelDecorrelator.Frame>	RelDecorrelator.map Built during decorrelation, of rel to all the newly created correlated variables in its output, and to map old input positions to new input positions.
private Map<RelNode,RelDecorrelator.Frame>	RelDecorrelator.DecorrelateRexShuttle.map
private SortedMap<CorrelationId,RelNode>	RelDecorrelator.CorelMap.mapCorToCorRel
(package private) SortedMap<CorrelationId,RelNode>	RelDecorrelator.CorelMapBuilder.mapCorToCorRel
private com.google.common.collect.Multimap<RelNode,RelDecorrelator.CorRef>	RelDecorrelator.CorelMap.mapRefRelToCorRef
(package private) com.google.common.collect.SortedSetMultimap<RelNode,RelDecorrelator.CorRef>	RelDecorrelator.CorelMapBuilder.mapRefRelToCorRef
private Map<RelNode,Map<Integer,Integer>>	SqlToRelConverter.Blackboard.mapRootRelToFieldProjection Project the groupby expressions out of the root of this sub-select.
private Map<RelNode,RelNode>	RelStructuredTypeFlattener.oldToNewRelMap
private Map<RelNode,RelNode>	RelStructuredTypeFlattener.oldToNewRelMap
private List<Pair<RelNode,Integer>>	SqlToRelConverter.LookupContext.relOffsetList
(package private) Deque<RelNode>	RelDecorrelator.CorelMapBuilder.stack

Methods in org.apache.calcite.sql2rel that return RelNode

Modifier and Type	Method and Description
private RelNode	RelDecorrelator.aggregateCorrelatorOutput(Correlate correlate, LogicalProject project, Set<Integer> isCount) Pulls a Project above a Correlate from its RHS input.
protected RelNode	SqlToRelConverter.convertColumnList(SqlInsert call, RelNode source) Creates a source for an INSERT statement.
private RelNode	SqlToRelConverter.convertCursor(SqlToRelConverter.Blackboard bb, SqlToRelConverter.SubQuery subQuery)
private RelNode	SqlToRelConverter.convertDelete(SqlDelete call)
protected RelNode	SqlToRelConverter.convertInsert(SqlInsert call)
private RelNode	SqlToRelConverter.convertMerge(SqlMerge call)
private RelNode	SqlToRelConverter.convertMultisets(List<SqlNode> operands, SqlToRelConverter.Blackboard bb)
private RelNode	SqlToRelConverter.convertQueryOrInList(SqlToRelConverter.Blackboard bb, SqlNode seek, RelDataType targetRowType)
private RelNode	SqlToRelConverter.convertRowConstructor(SqlToRelConverter.Blackboard bb, SqlCall rowConstructor) Converts a row constructor into a relational expression.
private RelNode	SqlToRelConverter.convertRowValues(SqlToRelConverter.Blackboard bb, SqlNode rowList, Collection<SqlNode> rows, boolean allowLiteralsOnly, RelDataType targetRowType)
RelNode	SqlToRelConverter.convertSelect(SqlSelect select, boolean top) Converts a SELECT statement's parse tree into a relational expression.
protected RelNode	SqlToRelConverter.convertSetOp(SqlCall call) Converts a set operation (UNION, INTERSECT, MINUS) into relational expressions.
RelNode	SqlToRelConverter.convertToSingleValueSubq(SqlNode query, RelNode plan) Converts the RelNode tree for a select statement to a select that produces a single value.
private RelNode	SqlToRelConverter.convertUpdate(SqlUpdate call)
RelNode	SqlToRelConverter.convertValues(SqlCall values, RelDataType targetRowType) Converts a SELECT statement's parse tree into a relational expression.
protected RelNode	SqlToRelConverter.createAggregate(SqlToRelConverter.Blackboard bb, ImmutableBitSet groupSet, com.google.common.collect.ImmutableList<ImmutableBitSet> groupSets, List<AggregateCall> aggCalls) Creates an Aggregate.
protected RelNode	SqlToRelConverter.createJoin(SqlToRelConverter.Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType)
private RelNode	SqlToRelConverter.createModify(RelOptTable targetTable, RelNode source) Creates a relational expression to modify a table or modifiable view.
private RelNode	RelDecorrelator.createProjectWithAdditionalExprs(RelNode input, List<Pair<RexNode,String>> additionalExprs) Projects all input output fields plus the additional expressions.
private RelNode	SqlToRelConverter.createSource(RelOptTable targetTable, RelNode source, ModifiableView modifiableView, RelDataType delegateRowType) Wraps a relational expression in the projects and filters implied by a ModifiableView.
private RelNode	RelDecorrelator.createValueGenerator(Iterable<RelDecorrelator.CorRef> correlations, int valueGenFieldOffset, SortedMap<RelDecorrelator.CorDef,Integer> corDefOutputs) Create RelNode tree that produces a list of correlated variables.
private RelNode	RelDecorrelator.decorrelate(RelNode root)
RelNode	SqlToRelConverter.decorrelate(SqlNode query, RelNode rootRel) If sub-query is correlated and decorrelation is enabled, performs decorrelation.
static RelNode	RelDecorrelator.decorrelateQuery(RelNode rootRel) Decorrelates a query.
protected RelNode	SqlToRelConverter.decorrelateQuery(RelNode rootRel)
RelNode	SqlToRelConverter.flattenTypes(RelNode rootRel, boolean restructure)
private RelNode	RelDecorrelator.getCorRel(RelDecorrelator.CorRef corVar)
protected RelNode	RelStructuredTypeFlattener.getNewForOldRel(RelNode oldRel)
static RelNode	DeduplicateCorrelateVariables.go(RexBuilder builder, CorrelationId canonicalId, Iterable<? extends CorrelationId> alternateIds, RelNode r) Rewrites a relational expression, replacing alternate correlation variables with a canonical correlation variable.
private RelNode	RelDecorrelator.projectJoinOutputWithNullability(LogicalJoin join, LogicalProject project, int nullIndicatorPos) Pulls project above the join from its RHS input.
RelNode	RelDecorrelator.removeCorrelationViaRule(RelNode root)
RelNode	RelStructuredTypeFlattener.rewrite(RelNode root)
private static RelNode	RelDecorrelator.stripHep(RelNode rel)
RelNode	SqlToRelConverter.toRel(RelOptTable table)
RelNode	RelFieldTrimmer.trim(RelNode root) Trims unused fields from a relational expression.
RelNode	SqlToRelConverter.trimUnusedFields(boolean ordered, RelNode rootRel) Walks over a tree of relational expressions, replacing each RelNode with a 'slimmed down' relational expression that projects only the fields required by its consumer.
RelNode	RelDecorrelator.CorelMapBuilder.visit(LogicalCorrelate correlate)
RelNode	RelDecorrelator.CorelMapBuilder.visit(LogicalFilter filter)
RelNode	RelDecorrelator.CorelMapBuilder.visit(LogicalJoin join)
RelNode	RelDecorrelator.CorelMapBuilder.visit(LogicalProject project)
RelNode	DeduplicateCorrelateVariables.visit(RelNode other)
RelNode	CorrelationReferenceFinder.visit(RelNode other)
protected RelNode	RelDecorrelator.CorelMapBuilder.visitChild(RelNode parent, int i, RelNode input)
private RelNode	RelDecorrelator.CorelMapBuilder.visitJoin(BiRel join)

Methods in org.apache.calcite.sql2rel that return types with arguments of type RelNode

Modifier and Type	Method and Description
private Function2<RelNode,RelNode,Void>	RelDecorrelator.createCopyHook()
private Function2<RelNode,RelNode,Void>	RelDecorrelator.createCopyHook()
(package private) Pair<RelNode,Integer>	SqlToRelConverter.LookupContext.findRel(int offset) Returns the relational expression with a given offset, and the ordinal in the combined row of its first field.
(package private) com.google.common.collect.ImmutableList<RelNode>	SqlToRelConverter.Blackboard.retrieveCursors()

Methods in org.apache.calcite.sql2rel with parameters of type RelNode

Modifier and Type	Method and Description
(package private) RelDecorrelator.CorelMap	RelDecorrelator.CorelMapBuilder.build(RelNode... rels) Creates a CorelMap by iterating over a RelNode tree.
private void	SqlToRelConverter.checkConvertedType(SqlNode query, RelNode result)
protected RelNode	SqlToRelConverter.convertColumnList(SqlInsert call, RelNode source) Creates a source for an INSERT statement.
private RexNode	SqlToRelConverter.convertJoinCondition(SqlToRelConverter.Blackboard bb, SqlValidatorNamespace leftNamespace, SqlValidatorNamespace rightNamespace, SqlNode condition, JoinConditionType conditionType, RelNode leftRel, RelNode rightRel)
private boolean	SqlToRelConverter.convertNonCorrelatedSubQuery(SqlToRelConverter.SubQuery subQuery, SqlToRelConverter.Blackboard bb, RelNode converted, boolean isExists) Determines if a sub-query is non-correlated and if so, converts it to a constant.
RelNode	SqlToRelConverter.convertToSingleValueSubq(SqlNode query, RelNode plan) Converts the RelNode tree for a select statement to a select that produces a single value.
protected RelNode	SqlToRelConverter.createJoin(SqlToRelConverter.Blackboard bb, RelNode leftRel, RelNode rightRel, RexNode joinCond, JoinRelType joinType)
private RelNode	SqlToRelConverter.createModify(RelOptTable targetTable, RelNode source) Creates a relational expression to modify a table or modifiable view.
private RelNode	RelDecorrelator.createProjectWithAdditionalExprs(RelNode input, List<Pair<RexNode,String>> additionalExprs) Projects all input output fields plus the additional expressions.
private RelNode	SqlToRelConverter.createSource(RelOptTable targetTable, RelNode source, ModifiableView modifiableView, RelDataType delegateRowType) Wraps a relational expression in the projects and filters implied by a ModifiableView.
private RelNode	RelDecorrelator.decorrelate(RelNode root)
RelNode	SqlToRelConverter.decorrelate(SqlNode query, RelNode rootRel) If sub-query is correlated and decorrelation is enabled, performs decorrelation.
protected RexNode	RelDecorrelator.decorrelateExpr(RelNode currentRel, Map<RelNode,RelDecorrelator.Frame> map, RelDecorrelator.CorelMap cm, RexNode exp)
private RelDecorrelator.Frame	RelDecorrelator.decorrelateInputWithValueGenerator(RelNode rel, RelDecorrelator.Frame frame)
static RelNode	RelDecorrelator.decorrelateQuery(RelNode rootRel) Decorrelates a query.
protected RelNode	SqlToRelConverter.decorrelateQuery(RelNode rootRel)
RelDecorrelator.Frame	RelDecorrelator.decorrelateRel(RelNode rel) Fallback if none of the other decorrelateRel methods match.
protected RelFieldTrimmer.TrimResult	RelFieldTrimmer.dispatchTrimFields(RelNode rel, ImmutableBitSet fieldsUsed, Set<RelDataTypeField> extraFields) Invokes RelFieldTrimmer.trimFields(org.apache.calcite.rel.RelNode, org.apache.calcite.util.ImmutableBitSet, java.util.Set<org.apache.calcite.rel.type.RelDataTypeField>), or the appropriate method for the type of the rel parameter, using multi-method dispatch.
protected RelFieldTrimmer.TrimResult	RelFieldTrimmer.dummyProject(int fieldCount, RelNode input) Creates a project with a dummy column, to protect the parts of the system that cannot handle a relational expression with no columns.
RelNode	SqlToRelConverter.flattenTypes(RelNode rootRel, boolean restructure)
private SqlToRelConverter.CorrelationUse	SqlToRelConverter.getCorrelationUse(SqlToRelConverter.Blackboard bb, RelNode r0)
private RelDecorrelator.Frame	RelDecorrelator.getFrame(RelNode r, boolean safe)
RelDecorrelator.Frame	RelDecorrelator.getInvoke(RelNode r, RelNode parent)
private Mappings.TargetMapping	RelStructuredTypeFlattener.getNewForOldInputMapping(RelNode oldRel) Returns a mapping between old and new fields.
private static RexInputRef	RelDecorrelator.getNewForOldInputRef(RelNode currentRel, Map<RelNode,RelDecorrelator.Frame> map, RexInputRef oldInputRef)
protected RelNode	RelStructuredTypeFlattener.getNewForOldRel(RelNode oldRel)
static RelNode	DeduplicateCorrelateVariables.go(RexBuilder builder, CorrelationId canonicalId, Iterable<? extends CorrelationId> alternateIds, RelNode r) Rewrites a relational expression, replacing alternate correlation variables with a canonical correlation variable.
private boolean	SqlToRelConverter.isSubQueryNonCorrelated(RelNode subq, SqlToRelConverter.Blackboard bb) Determines whether a sub-query is non-correlated.
private RelDecorrelator.Frame	RelDecorrelator.maybeAddValueGenerator(RelNode rel, RelDecorrelator.Frame frame) Adds a value generator to satisfy the correlating variables used by a relational expression, if those variables are not already provided by its input.
private void	RelDecorrelator.AdjustProjectForCountAggregateRule.onMatch2(RelOptRuleCall call, LogicalCorrelate correlate, RelNode leftInput, LogicalProject aggOutputProject, LogicalAggregate aggregate)
private static RexLiteral	RelDecorrelator.projectedLiteral(RelNode rel, int i) Returns a literal output field, or null if it is not literal.
RexNode	SqlToRelConverter.Blackboard.register(RelNode rel, JoinRelType joinType)
RexNode	SqlToRelConverter.Blackboard.register(RelNode rel, JoinRelType joinType, List<RexNode> leftKeys) Registers a relational expression.
(package private) RelDecorrelator.Frame	RelDecorrelator.register(RelNode rel, RelNode newRel, Map<Integer,Integer> oldToNewOutputs, SortedMap<RelDecorrelator.CorDef,Integer> corDefOutputs) Registers a relational expression and the relational expression it became after decorrelation.
RelNode	RelDecorrelator.removeCorrelationViaRule(RelNode root)
private RelCollation	SqlToRelConverter.requiredCollation(RelNode r)
protected RelFieldTrimmer.TrimResult	RelFieldTrimmer.result(RelNode r, Mapping mapping)
RelNode	RelStructuredTypeFlattener.rewrite(RelNode root)
void	RelStructuredTypeFlattener.rewriteGeneric(RelNode rel)
private RexVisitorImpl<Void>	RelDecorrelator.CorelMapBuilder.rexVisitor(RelNode rel)
private void	RelDecorrelator.setCurrent(RelNode root, LogicalCorrelate corRel)
protected void	RelStructuredTypeFlattener.setNewForOldRel(RelNode oldRel, RelNode newRel)
private void	SqlToRelConverter.Blackboard.setRoot(List<RelNode> inputs, RelNode root, boolean hasSystemFields)
void	SqlToRelConverter.Blackboard.setRoot(RelNode root, boolean leaf) Sets a new root relational expression, as the translation process backs its way further up the tree.
private static RelNode	RelDecorrelator.stripHep(RelNode rel)
private RexNode	SqlToRelConverter.translateIn(RelOptUtil.Logic logic, RelNode root, RexNode rex)
RelNode	RelFieldTrimmer.trim(RelNode root) Trims unused fields from a relational expression.
protected RelFieldTrimmer.TrimResult	RelFieldTrimmer.trimChild(RelNode rel, RelNode input, ImmutableBitSet fieldsUsed, Set<RelDataTypeField> extraFields) Trims the fields of an input relational expression.
protected RelFieldTrimmer.TrimResult	RelFieldTrimmer.trimChildRestore(RelNode rel, RelNode input, ImmutableBitSet fieldsUsed, Set<RelDataTypeField> extraFields) Trims a child relational expression, then adds back a dummy project to restore the fields that were removed.
RelFieldTrimmer.TrimResult	RelFieldTrimmer.trimFields(RelNode rel, ImmutableBitSet fieldsUsed, Set<RelDataTypeField> extraFields) Visit method, per ReflectiveVisitor.
RelNode	SqlToRelConverter.trimUnusedFields(boolean ordered, RelNode rootRel) Walks over a tree of relational expressions, replacing each RelNode with a 'slimmed down' relational expression that projects only the fields required by its consumer.
RelNode	DeduplicateCorrelateVariables.visit(RelNode other)
RelNode	CorrelationReferenceFinder.visit(RelNode other)
void	RelStructuredTypeFlattener.RewriteRelVisitor.visit(RelNode p, int ordinal, RelNode parent)
protected RelNode	RelDecorrelator.CorelMapBuilder.visitChild(RelNode parent, int i, RelNode input)

Method parameters in org.apache.calcite.sql2rel with type arguments of type RelNode

Modifier and Type	Method and Description
protected RexNode	RelDecorrelator.decorrelateExpr(RelNode currentRel, Map<RelNode,RelDecorrelator.Frame> map, RelDecorrelator.CorelMap cm, RexNode exp)
void	SqlToRelConverter.Blackboard.flatten(List<RelNode> rels, int systemFieldCount, int[] start, List<Pair<RelNode,Integer>> relOffsetList)
void	SqlToRelConverter.Blackboard.flatten(List<RelNode> rels, int systemFieldCount, int[] start, List<Pair<RelNode,Integer>> relOffsetList)
private static RexInputRef	RelDecorrelator.getNewForOldInputRef(RelNode currentRel, Map<RelNode,RelDecorrelator.Frame> map, RexInputRef oldInputRef)
static RelDecorrelator.CorelMap	RelDecorrelator.CorelMap.of(com.google.common.collect.SortedSetMultimap<RelNode,RelDecorrelator.CorRef> mapRefRelToCorVar, SortedMap<CorrelationId,RelNode> mapCorToCorRel, Map<RexFieldAccess,RelDecorrelator.CorRef> mapFieldAccessToCorVar) Creates a CorelMap with given contents.
static RelDecorrelator.CorelMap	RelDecorrelator.CorelMap.of(com.google.common.collect.SortedSetMultimap<RelNode,RelDecorrelator.CorRef> mapRefRelToCorVar, SortedMap<CorrelationId,RelNode> mapCorToCorRel, Map<RexFieldAccess,RelDecorrelator.CorRef> mapFieldAccessToCorVar) Creates a CorelMap with given contents.
(package private) void	SqlToRelConverter.Blackboard.setRoot(List<RelNode> inputs)
private void	SqlToRelConverter.Blackboard.setRoot(List<RelNode> inputs, RelNode root, boolean hasSystemFields)
void	RelStructuredTypeFlattener.updateRelInMap(com.google.common.collect.SortedSetMultimap<RelNode,CorrelationId> mapRefRelToCorVar)

Constructors in org.apache.calcite.sql2rel with parameters of type RelNode

Constructor and Description
CorrelationUse(CorrelationId id, ImmutableBitSet requiredColumns, RelNode r)
DecorrelateRexShuttle(RelNode currentRel, Map<RelNode,RelDecorrelator.Frame> map, RelDecorrelator.CorelMap cm)
Frame(RelNode oldRel, RelNode r, SortedMap<RelDecorrelator.CorDef,Integer> corDefOutputs, Map<Integer,Integer> oldToNewOutputs)
TrimResult(RelNode left, Mapping right) Creates a TrimResult.

Constructor parameters in org.apache.calcite.sql2rel with type arguments of type RelNode

Constructor and Description
CorelMap(com.google.common.collect.Multimap<RelNode,RelDecorrelator.CorRef> mapRefRelToCorRef, SortedMap<CorrelationId,RelNode> mapCorToCorRel, Map<RexFieldAccess,RelDecorrelator.CorRef> mapFieldAccessToCorRef)
CorelMap(com.google.common.collect.Multimap<RelNode,RelDecorrelator.CorRef> mapRefRelToCorRef, SortedMap<CorrelationId,RelNode> mapCorToCorRel, Map<RexFieldAccess,RelDecorrelator.CorRef> mapFieldAccessToCorRef)
DecorrelateRexShuttle(RelNode currentRel, Map<RelNode,RelDecorrelator.Frame> map, RelDecorrelator.CorelMap cm)
LookupContext(SqlToRelConverter.Blackboard bb, List<RelNode> rels, int systemFieldCount) Creates a LookupContext with multiple input relational expressions.

Uses of RelNode in org.apache.calcite.tools

Fields in org.apache.calcite.tools declared as RelNode

Modifier and Type	Field and Description
private RelNode	RelBuilder.Shifter.left
(package private) RelNode	RelBuilder.Frame.rel
private RelNode	RelBuilder.Shifter.right

Methods in org.apache.calcite.tools that return RelNode

Modifier and Type	Method and Description
RelNode	RelBuilder.build() Returns the final relational expression.
RelNode	Planner.convert(SqlNode sql) Deprecated. Use Planner.rel(org.apache.calcite.sql.SqlNode).
RelNode	RelBuilder.peek() Returns the relational expression at the top of the stack, but does not remove it.
RelNode	RelBuilder.peek(int n) Returns the relational expression n positions from the top of the stack, but does not remove it.
RelNode	RelBuilder.peek(int inputCount, int inputOrdinal) Returns the relational expression n positions from the top of the stack, but does not remove it.
RelNode	Program.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.RuleSetProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.SequenceProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.DecorrelateProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.TrimFieldsProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Planner.transform(int ruleSetIndex, RelTraitSet requiredOutputTraits, RelNode rel) Converts one relational expression tree into another relational expression based on a particular rule set and requires set of traits.

Methods in org.apache.calcite.tools with parameters of type RelNode

Modifier and Type	Method and Description
private static String	RelBuilder.Frame.deriveAlias(RelNode rel)
PreparedStatement	RelRunner.prepare(RelNode rel) Runs a relational expression.
RelBuilder	RelBuilder.push(RelNode node) Adds a relational expression to be the input to the next relational expression constructed.
private void	RelBuilder.replaceTop(RelNode node) Adds a rel node to the top of the stack while preserving the field names and aliases.
static PreparedStatement	RelRunners.run(RelNode rel) Runs a relational expression by creating a JDBC connection.
RelNode	Program.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.RuleSetProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.SequenceProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.DecorrelateProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Programs.TrimFieldsProgram.run(RelOptPlanner planner, RelNode rel, RelTraitSet requiredOutputTraits, List<RelOptMaterialization> materializations, List<RelOptLattice> lattices)
RelNode	Planner.transform(int ruleSetIndex, RelTraitSet requiredOutputTraits, RelNode rel) Converts one relational expression tree into another relational expression based on a particular rule set and requires set of traits.

Method parameters in org.apache.calcite.tools with type arguments of type RelNode

Modifier and Type	Method and Description
RelBuilder	RelBuilder.pushAll(Iterable<? extends RelNode> nodes) Pushes a collection of relational expressions.

Constructors in org.apache.calcite.tools with parameters of type RelNode

Constructor and Description
Frame(RelNode rel)
Frame(RelNode rel, com.google.common.collect.ImmutableList<RelBuilder.Field> fields)
Shifter(RelNode left, CorrelationId id, RelNode right)