java.lang.Object
- org.apache.calcite.test.RelBuilderTest

```
public class RelBuilderTest
extends java.lang.Object
```
Unit test for RelBuilder.
Tasks:
1. Add RelBuilder.scan(List<String>)
2. Add RelBuilder.scan(Table)
3. Test that RelBuilder.filter(org.apache.calcite.rex.RexNode...) does not create a filter if the predicates optimize to true
4. Test that RelBuilder.filter(org.apache.calcite.rex.RexNode...) DOES create a filter if the predicates optimize to false. (Creating an empty Values seems too devious.)
5. Test that RelBuilder.scan(java.lang.Iterable<java.lang.String>) throws good error if table not found
6. Test that RelBuilder.scan(java.lang.Iterable<java.lang.String>) obeys case-sensitivity
7. Test that RelBuilder.join(JoinRelType, String...) obeys case-sensitivity
8. Test RelBuilder with alternative factories
9. Test that RelBuilder.field(String) obeys case-sensitivity
10. Test case-insensitive unique field names
11. Test that an alias created using RelBuilder.alias(RexNode, String) is removed if not a top-level project
12. RelBuilder.aggregate(org.apache.calcite.tools.RelBuilder.GroupKey, org.apache.calcite.tools.RelBuilder.AggCall...) with grouping sets
13. RelBuilder.aggregateCall(org.apache.calcite.sql.SqlAggFunction, boolean, org.apache.calcite.rex.RexNode, java.lang.String, org.apache.calcite.rex.RexNode...) with filter
14. Add call to create TableFunctionScan
15. Add call to create Window
16. Add call to create TableModify
17. Add call to create Exchange
18. Add call to create Correlate
19. Add call to create AggregateCall with filter

Constructor Summary

Constructors
Constructor Description

RelBuilderTest()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private void`	`checkExpandTable(org.apache.calcite.tools.RelBuilder builder, org.hamcrest.Matcher<org.apache.calcite.rel.RelNode> matcher)`
`static org.apache.calcite.tools.Frameworks.ConfigBuilder`	`config()`	Creates a config based on the "scott" schema.
`(package private) static org.apache.calcite.tools.Frameworks.ConfigBuilder`	`expandingConfig(java.sql.Connection connection)`	Creates a config builder that will contain a view, "MYVIEW", and also the SCOTT JDBC schema, whose tables implement `TranslatableTable`.
`void`	`testAggregate()`
`void`	`testAggregate2()`
`void`	`testAggregate3()`	Test case for [CALCITE-2192] RelBuilder wrongly skips creation of Aggregate that prunes columns if input is unique.
`void`	`testAggregate4()`	As `testAggregate3()` but with Filter.
`void`	`testAggregateFilter()`
`void`	`testAggregateFilterFails()`
`void`	`testAggregateFilterNullable()`
`void`	`testAggregateGrouping()`
`void`	`testAggregateGroupingKeyOutOfRangeFails()`
`void`	`testAggregateGroupingSetDuplicateIgnored()`
`void`	`testAggregateGroupingSetNotSubsetFails()`
`void`	`testAggregateGroupingWithDistinctFails()`
`void`	`testAggregateGroupingWithFilterFails()`
`void`	`testAggregateProjectWithAliases()`	Test case for [CALCITE-1980] RelBuilder gives NPE if groupKey contains alias.
`void`	`testAggregateProjectWithExpression()`
`void`	`testAlias()`
`void`	`testAlias2()`
`void`	`testAliasAggregate()`
`void`	`testAliasFilter()`	Tests that table aliases are propagated and are available to a filter, even when there is a project on top of a project.
`void`	`testAliasLimit()`
`void`	`testAliasPastTop()`	Test case for [CALCITE-1523] Add RelBuilder field() method to reference aliased relations not on top of stack, accessing tables aliased that are not accessible in the top RelNode.
`void`	`testAliasPastTop2()`	As `testAliasPastTop()`.
`void`	`testAliasProject()`	Test case for [CALCITE-1551] RelBuilder's project() doesn't preserve alias.
`void`	`testAliasProjectProject()`	Tests that table aliases are propagated even when there is a project on top of a project.
`void`	`testAliasSort()`
`void`	`testBadFieldName()`
`void`	`testBadFieldOrdinal()`
`void`	`testBadType()`
`void`	`testBadUnionArgsErrorMessage()`	Test case for [CALCITE-1522] Fix error message for SetOp with incompatible args.
`void`	`testConvert()`
`void`	`testConvertRename()`
`void`	`testCorrelationFails()`
`void`	`testCorrelationWithCondition()`
`void`	`testDistinct()`
`void`	`testDistinctAlready()`
`void`	`testDistinctEmpty()`
`void`	`testEmpty()`
`void`	`testExcept()`
`void`	`testExchange()`
`void`	`testExpandTable()`
`void`	`testExpandViewInRelBuilder()`	Ensures that relational algebra (`RelBuilder`) works with SQL views.
`void`	`testFilterCastAny()`
`void`	`testFilterCastNull()`
`void`	`testIntersect()`
`void`	`testIntersect3()`
`void`	`testJoin()`
`void`	`testJoin2()`
`void`	`testJoinCartesian()`
`void`	`testJoinUsing()`	Same as `testJoin()` using USING.
`void`	`testLimit()`
`void`	`testMatchRecognize()`
`void`	`testMultiLevelAlias()`
`void`	`testPermute()`
`void`	`testProject()`
`void`	`testProject2()`	Tests each method that creates a scalar expression.
`void`	`testProjectIdentity()`
`void`	`testProjectIdentityWithFieldsRename()`	Test case for [CALCITE-1297] RelBuilder does not translate identity projects even if they rename fields.
`void`	`testProjectIdentityWithFieldsRenameFilter()`	Variation on `testProjectIdentityWithFieldsRename()`: don't use a table alias, and make sure the field names propagate through a filter.
`void`	`testProjectJoin()`	Tests that a projection retains field names after a join.
`void`	`testProjectLeadingEdge()`
`void`	`testProjectProject()`	Tests that a projection after a projection.
`void`	`testRelBuilderToString()`
`void`	`testRename()`
`void`	`testRenameValues()`
`void`	`testRun()`	Tests `RelRunner` for a table scan + filter query.
`void`	`testRunValues()`	Tests `RelRunner` for a VALUES query.
`void`	`testScan()`
`void`	`testScanFilterAndFalse()`
`void`	`testScanFilterAndTrue()`
`void`	`testScanFilterDuplicateAnd()`	Test case for [CALCITE-2730] RelBuilder incorrectly simplifies a filter with duplicate conjunction to empty.
`void`	`testScanFilterEquals()`
`void`	`testScanFilterOr()`
`void`	`testScanFilterOr2()`
`void`	`testScanFilterTriviallyFalse()`
`void`	`testScanFilterTrue()`
`void`	`testScanInvalidQualifiedTable()`
`void`	`testScanInvalidSchema()`
`void`	`testScanInvalidTable()`
`void`	`testScanQualifiedTable()`
`void`	`testScanValidTableWrongCase()`
`void`	`testSort()`
`void`	`testSortByExpression()`
`void`	`testSortDuplicate()`
`void`	`testSortExchange()`
`void`	`testSortExpThenLimit()`	Tests that a sort on an expression followed by a limit gives the same effect as calling sortLimit.
`void`	`testSortLimit()`
`void`	`testSortLimit0()`
`void`	`testSortOverProjectSort()`	Test case for [CALCITE-1610] RelBuilder sort-combining optimization treats aliases incorrectly.
`void`	`testSortThenLimit()`	Tests that a sort on a field followed by a limit gives the same effect as calling sortLimit.
`void`	`testTrivialSort()`	Test case for [CALCITE-1015] OFFSET 0 causes AssertionError.
`void`	`testTypeInferenceValidation()`	Test case for [CALCITE-1595] RelBuilder.call throws NullPointerException if argument types are invalid.
`void`	`testUnion()`
`void`	`testUnion1()`
`void`	`testUnion3()`
`void`	`testUnionAlias()`
`void`	`testValues()`
`void`	`testValuesAllNull()`
`void`	`testValuesBadAllNull()`
`void`	`testValuesBadNoFields()`
`void`	`testValuesBadNoValues()`
`void`	`testValuesBadNullFieldNames()`
`void`	`testValuesBadOddMultiple()`
`void`	`testValuesNullable()`	Tests creating Values with some field names and some values null.

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

- Constructor Detail
  - RelBuilderTest
```
public RelBuilderTest()
```
- Method Detail
  - config
```
public static org.apache.calcite.tools.Frameworks.ConfigBuilder config()
```
    Creates a config based on the "scott" schema.
  - expandingConfig
```
static org.apache.calcite.tools.Frameworks.ConfigBuilder expandingConfig(java.sql.Connection connection)
                                                                  throws java.sql.SQLException
```
    Creates a config builder that will contain a view, "MYVIEW", and also the SCOTT JDBC schema, whose tables implement TranslatableTable.
    
    Throws:
    
    java.sql.SQLException
  - testScan
```
public void testScan()
```
  - testScanQualifiedTable
```
public void testScanQualifiedTable()
```
  - testScanInvalidTable
```
public void testScanInvalidTable()
```
  - testScanInvalidSchema
```
public void testScanInvalidSchema()
```
  - testScanInvalidQualifiedTable
```
public void testScanInvalidQualifiedTable()
```
  - testScanValidTableWrongCase
```
public void testScanValidTableWrongCase()
```
  - testScanFilterTrue
```
public void testScanFilterTrue()
```
  - testScanFilterTriviallyFalse
```
public void testScanFilterTriviallyFalse()
```
  - testScanFilterEquals
```
public void testScanFilterEquals()
```
  - testScanFilterOr
```
public void testScanFilterOr()
```
  - testScanFilterOr2
```
public void testScanFilterOr2()
```
  - testScanFilterAndFalse
```
public void testScanFilterAndFalse()
```
  - testScanFilterAndTrue
```
public void testScanFilterAndTrue()
```
  - testScanFilterDuplicateAnd
```
public void testScanFilterDuplicateAnd()
```
    Test case for [CALCITE-2730] RelBuilder incorrectly simplifies a filter with duplicate conjunction to empty.
  - testBadFieldName
```
public void testBadFieldName()
```
  - testBadFieldOrdinal
```
public void testBadFieldOrdinal()
```
  - testBadType
```
public void testBadType()
```
  - testProject
```
public void testProject()
```
  - testProject2
```
public void testProject2()
```
    Tests each method that creates a scalar expression.
  - testProjectIdentity
```
public void testProjectIdentity()
```
  - testProjectIdentityWithFieldsRename
```
public void testProjectIdentityWithFieldsRename()
```
    Test case for [CALCITE-1297] RelBuilder does not translate identity projects even if they rename fields.
  - testProjectIdentityWithFieldsRenameFilter
```
public void testProjectIdentityWithFieldsRenameFilter()
```
    Variation on testProjectIdentityWithFieldsRename(): don't use a table alias, and make sure the field names propagate through a filter.
  - testProjectLeadingEdge
```
public void testProjectLeadingEdge()
```
  - testRename
```
public void testRename()
```
  - testRenameValues
```
public void testRenameValues()
```
  - testPermute
```
public void testPermute()
```
  - testConvert
```
public void testConvert()
```
  - testConvertRename
```
public void testConvertRename()
```
  - testAggregate
```
public void testAggregate()
```
  - testAggregate2
```
public void testAggregate2()
```
  - testAggregate3
```
public void testAggregate3()
```
    Test case for [CALCITE-2192] RelBuilder wrongly skips creation of Aggregate that prunes columns if input is unique.
  - testAggregate4
```
public void testAggregate4()
```
    As testAggregate3() but with Filter.
  - testAggregateFilter
```
public void testAggregateFilter()
```
  - testAggregateFilterFails
```
public void testAggregateFilterFails()
```
  - testAggregateFilterNullable
```
public void testAggregateFilterNullable()
```
  - testAggregateProjectWithAliases
```
public void testAggregateProjectWithAliases()
```
    Test case for [CALCITE-1980] RelBuilder gives NPE if groupKey contains alias.
    Now, the alias does not cause a new expression to be added to the input, but causes the referenced fields to be renamed.
  - testAggregateProjectWithExpression
```
public void testAggregateProjectWithExpression()
```
  - testAggregateGroupingKeyOutOfRangeFails
```
public void testAggregateGroupingKeyOutOfRangeFails()
```
  - testAggregateGroupingSetNotSubsetFails
```
public void testAggregateGroupingSetNotSubsetFails()
```
  - testAggregateGroupingSetDuplicateIgnored
```
public void testAggregateGroupingSetDuplicateIgnored()
```
  - testAggregateGrouping
```
public void testAggregateGrouping()
```
  - testAggregateGroupingWithDistinctFails
```
public void testAggregateGroupingWithDistinctFails()
```
  - testAggregateGroupingWithFilterFails
```
public void testAggregateGroupingWithFilterFails()
```
  - testDistinct
```
public void testDistinct()
```
  - testDistinctAlready
```
public void testDistinctAlready()
```
  - testDistinctEmpty
```
public void testDistinctEmpty()
```
  - testUnion
```
public void testUnion()
```
  - testBadUnionArgsErrorMessage
```
public void testBadUnionArgsErrorMessage()
```
    Test case for [CALCITE-1522] Fix error message for SetOp with incompatible args.
  - testUnion3
```
public void testUnion3()
```
  - testUnion1
```
public void testUnion1()
```
  - testIntersect
```
public void testIntersect()
```
  - testIntersect3
```
public void testIntersect3()
```
  - testExcept
```
public void testExcept()
```
  - testJoin
```
public void testJoin()
```
  - testJoinUsing
```
public void testJoinUsing()
```
    Same as testJoin() using USING.
  - testJoin2
```
public void testJoin2()
```
  - testJoinCartesian
```
public void testJoinCartesian()
```
  - testCorrelationFails
```
public void testCorrelationFails()
```
  - testCorrelationWithCondition
```
public void testCorrelationWithCondition()
```
  - testAlias
```
public void testAlias()
```
  - testAlias2
```
public void testAlias2()
```
  - testAliasSort
```
public void testAliasSort()
```
  - testAliasLimit
```
public void testAliasLimit()
```
  - testAliasProject
```
public void testAliasProject()
```
    Test case for [CALCITE-1551] RelBuilder's project() doesn't preserve alias.
  - testAliasProjectProject
```
public void testAliasProjectProject()
```
    Tests that table aliases are propagated even when there is a project on top of a project. (Aliases tend to get lost when projects are merged).
  - testAliasFilter
```
public void testAliasFilter()
```
    Tests that table aliases are propagated and are available to a filter, even when there is a project on top of a project. (Aliases tend to get lost when projects are merged).
  - testAliasAggregate
```
public void testAliasAggregate()
```
  - testProjectJoin
```
public void testProjectJoin()
```
    Tests that a projection retains field names after a join.
  - testProjectProject
```
public void testProjectProject()
```
    Tests that a projection after a projection.
  - testMultiLevelAlias
```
public void testMultiLevelAlias()
```
  - testUnionAlias
```
public void testUnionAlias()
```
  - testAliasPastTop
```
public void testAliasPastTop()
```
    Test case for [CALCITE-1523] Add RelBuilder field() method to reference aliased relations not on top of stack, accessing tables aliased that are not accessible in the top RelNode.
  - testAliasPastTop2
```
public void testAliasPastTop2()
```
    As testAliasPastTop().
  - testEmpty
```
public void testEmpty()
```
  - testValues
```
public void testValues()
```
  - testValuesNullable
```
public void testValuesNullable()
```
    Tests creating Values with some field names and some values null.
  - testValuesBadNullFieldNames
```
public void testValuesBadNullFieldNames()
```
  - testValuesBadNoFields
```
public void testValuesBadNoFields()
```
  - testValuesBadNoValues
```
public void testValuesBadNoValues()
```
  - testValuesBadOddMultiple
```
public void testValuesBadOddMultiple()
```
  - testValuesBadAllNull
```
public void testValuesBadAllNull()
```
  - testValuesAllNull
```
public void testValuesAllNull()
```
  - testSort
```
public void testSort()
```
  - testTrivialSort
```
public void testTrivialSort()
```
    Test case for [CALCITE-1015] OFFSET 0 causes AssertionError.
  - testSortDuplicate
```
public void testSortDuplicate()
```
  - testSortByExpression
```
public void testSortByExpression()
```
  - testLimit
```
public void testLimit()
```
  - testSortLimit
```
public void testSortLimit()
```
  - testSortLimit0
```
public void testSortLimit0()
```
  - testSortOverProjectSort
```
public void testSortOverProjectSort()
```
    Test case for [CALCITE-1610] RelBuilder sort-combining optimization treats aliases incorrectly.
  - testSortThenLimit
```
public void testSortThenLimit()
```
    Tests that a sort on a field followed by a limit gives the same effect as calling sortLimit.
    In general a relational operator cannot rely on the order of its input, but it is reasonable to merge sort and limit if they were created by consecutive builder operations. And clients such as Piglet rely on it.
  - testSortExpThenLimit
```
public void testSortExpThenLimit()
```
    Tests that a sort on an expression followed by a limit gives the same effect as calling sortLimit.
  - testRunValues
```
public void testRunValues()
                   throws java.lang.Exception
```
    Tests RelRunner for a VALUES query.
    
    Throws:
    
    java.lang.Exception
  - testRun
```
public void testRun()
             throws java.lang.Exception
```
    Tests RelRunner for a table scan + filter query.
    
    Throws:
    
    java.lang.Exception
  - testTypeInferenceValidation
```
public void testTypeInferenceValidation()
```
    Test case for [CALCITE-1595] RelBuilder.call throws NullPointerException if argument types are invalid.
  - testMatchRecognize
```
public void testMatchRecognize()
```
  - testFilterCastAny
```
public void testFilterCastAny()
```
  - testFilterCastNull
```
public void testFilterCastNull()
```
  - testRelBuilderToString
```
public void testRelBuilderToString()
```
  - testExpandViewInRelBuilder
```
public void testExpandViewInRelBuilder()
                                throws java.sql.SQLException
```
    Ensures that relational algebra (RelBuilder) works with SQL views.
    This test currently fails (thus ignored).
    
    Throws:
    
    java.sql.SQLException
  - testExpandTable
```
public void testExpandTable()
                     throws java.sql.SQLException
```
    Throws:
    
    java.sql.SQLException
  - checkExpandTable
```
private void checkExpandTable(org.apache.calcite.tools.RelBuilder builder,
                              org.hamcrest.Matcher<org.apache.calcite.rel.RelNode> matcher)
```
  - testExchange
```
public void testExchange()
```
  - testSortExchange
```
public void testSortExchange()
```

Class RelBuilderTest

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RelBuilderTest

Method Detail

config

expandingConfig

testScan

testScanQualifiedTable

testScanInvalidTable

testScanInvalidSchema

testScanInvalidQualifiedTable

testScanValidTableWrongCase

testScanFilterTrue

testScanFilterTriviallyFalse

testScanFilterEquals

testScanFilterOr

testScanFilterOr2

testScanFilterAndFalse

testScanFilterAndTrue

testScanFilterDuplicateAnd

testBadFieldName

testBadFieldOrdinal

testBadType

testProject

testProject2

testProjectIdentity

testProjectIdentityWithFieldsRename

testProjectIdentityWithFieldsRenameFilter

testProjectLeadingEdge

testRename

testRenameValues

testPermute

testConvert

testConvertRename

testAggregate

testAggregate2

testAggregate3

testAggregate4

testAggregateFilter

testAggregateFilterFails

testAggregateFilterNullable

testAggregateProjectWithAliases

testAggregateProjectWithExpression

testAggregateGroupingKeyOutOfRangeFails

testAggregateGroupingSetNotSubsetFails

testAggregateGroupingSetDuplicateIgnored

testAggregateGrouping

testAggregateGroupingWithDistinctFails

testAggregateGroupingWithFilterFails

testDistinct

testDistinctAlready

testDistinctEmpty

testUnion

testBadUnionArgsErrorMessage

testUnion3

testUnion1

testIntersect

testIntersect3

testExcept

testJoin

testJoinUsing

testJoin2

testJoinCartesian

testCorrelationFails

testCorrelationWithCondition

testAlias

testAlias2

testAliasSort

testAliasLimit

testAliasProject

testAliasProjectProject

testAliasFilter

testAliasAggregate

testProjectJoin

testProjectProject

testMultiLevelAlias

testUnionAlias