TestLateralJoinCorrectness (Drill : 1.19.0 API)

java.lang.Object
- org.apache.drill.test.BaseTest
- - org.apache.drill.test.DrillTest
  - - org.apache.drill.test.SubOperatorTest
    - - org.apache.drill.exec.physical.impl.join.TestLateralJoinCorrectness

public class TestLateralJoinCorrectness
extends SubOperatorTest

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.drill.test.DrillTest
  DrillTest.MemWatcher

Field Summary
- Fields inherited from class org.apache.drill.test.SubOperatorTest
  dirTestWatcher, fixture
- Fields inherited from class org.apache.drill.test.DrillTest
  logOutcome, objectMapper, REPEAT_RULE, thrownException, TIMEOUT

Constructor Summary

Constructors
Constructor and Description

TestLateralJoinCorrectness()

Constructors
Constructor and Description
`TestLateralJoinCorrectness()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`afterTest()`
`void`	`beforeTest()`
`static void`	`setUpBeforeClass()`
`static void`	`tearDownAfterClass()`
`void`	`test_OK_NEW_SCHEMAFromLeft_EmitFromRight_PostBuildSchema()` Test to verify if OK_NEW_SCHEMA is received from left side of LATERAL post build schema phase and EMIT is received from right side of LATERAL for each row on left side, then Lateral sends OK_NEW_SCHEMA downstream with the output batch.
`void`	`test1RecordLeftBatchTo1RightRecordBatch()` Test to show correct IterOutcome produced by LATERAL when one record in left batch produces only 1 right batch with EMIT outcome.
`void`	`test1RecordLeftBatchTo2RightRecordBatch()` Test to show correct IterOutcome & output produced by LATERAL when one record in left batch produces 2 right batches with OK and EMIT outcome respectively.
`void`	`test1RecordLeftBatchToEmptyRightBatch()` Test to show that if the result of cross join between left batch and empty right batch is an empty batch and next batch on left side result in NONE outcome, then there is no output produced and result returned to downstream is NONE.
`void`	`testBasicLeftLateralJoin()` Test to check basic left lateral join is working correctly or not.
`void`	`testBuildSchemaEmptyLNonEmptyRBatch()` This case should never happen since With empty left there cannot be non-empty right batch, the `LateralJoinBatch.buildSchema()` phase should fail() with `IllegalStateException`
`void`	`testBuildSchemaEmptyLRBatch()` With both left and right batch being empty, the `LateralJoinBatch.buildSchema()` phase should still build the output container schema and return empty batch
`void`	`testBuildSchemaNonEmptyLEmptyRBatch()` With non-empty left and empty right batch, the `LateralJoinBatch.buildSchema()` phase should still build the output container schema and return empty batch
`void`	`testBuildSchemaNonEmptyLRBatch()` With both left and right batch being non-empty, the `LateralJoinBatch.buildSchema()` phase will fail with `IllegalStateException` since it expects first batch from right branch of LATERAL to be always empty
`void`	`testBuildSchemaWithEMITOutcome()` Test for receiving unexpected EMIT outcome during build phase on left side.
`void`	`testFillingUpOutputBatch_With2ExcludedColumns()`
`void`	`testFillingUpOutputBatch_WithExcludedColumns()`
`void`	`testFillingUpOutputBatch()` Test to show LATERAL tries to pack the output batch until it's full or all the data is consumed from left and right side.
`void`	`testHandlingEMITFromLeft()` When multiple left batch is received with same schema but with OK_NEW_SCHEMA, then LATERAL detects that correctly and suppresses schema change operation by producing output in same batch created with initial schema.
`void`	`testHandlingEmptyEMITAfterOK()` Test for the case when LATERAL received a left batch with OK outcome and then populate the Join output in the outgoing batch.
`void`	`testHandlingNoneAfterOK()` Test for the case where LATERAL received a left batch with OK outcome and then populate the Join output in the outgoing batch.
`void`	`testHandlingNonEmpty_EMITAfterOK_WithMultipleOutput()` Temporary test to validate LATERAL handling output batch getting filled without consuming full output from left and right batch join.
`void`	`testHandlingNonEmptyEMITAfterOK()` Test for the case when LATERAL received a left batch with OK outcome and then populate the Join output in the outgoing batch.
`void`	`testHandlingSchemaChangeForNonUnnestField()` When multiple left batches are received with different schema, then LATERAL produces output for each schema type separately (even though output batch is not filled completely) and handles the schema change in left batch.
`void`	`testHandlingSchemaChangeForUnnestField()` When multiple left and right batches are received with different schema, then LATERAL produces output for each schema type separately (even though output batch is not filled completely) and handles the schema change correctly.
`void`	`testHandlingUnexpectedSchemaChangeForUnnestField()` Verify if there is no schema change on left side and LATERAL still sees an unexpected schema change on right side then it handles it correctly.
`void`	`testLateral_SchemaChange_Left_EmptyRightBatchForFirst()` Test to verify that for first left incoming if there is no right side incoming batch and then second left incoming comes with schema change, then the schema change with empty output batch for first incoming is handled properly.
`void`	`testLeftLateralJoin_WithAndWithoutMatching_MultipleBatch()` Test to see if there are multiple rows in left batch and for some rows right side produces batch with records and for other rows right side produces empty batches then based on left join type we are populating the output batch correctly.
`void`	`testLeftLateralJoin_WithAndWithoutMatching()` Test to see if there are multiple rows in left batch and for some rows right side produces batch with records and for other rows right side produces empty batches then based on left join type we are populating the output batch correctly.
`void`	`testLeftLateralJoin_WithMatchingAndEmptyBatch()` Test to see if there are multiple rows in left batch and for some rows right side produces multiple batches such that some are with records and some are empty then we are not duplicating those left side records based on left join type.
`void`	`testMultiLevelLateral_MultipleOutput()` This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL.
`void`	`testMultiLevelLateral_SchemaChange_LeftRightUnnest_NonEmptyBatch()` Test to verify in case of Multilevel lateral when a non-empty OK_NEW_SCHEMA batch post build schema phase is received from right most UNNEST of lower LATERAL then pipeline works fine.
`void`	`testMultiLevelLateral_SchemaChange_LeftRightUnnest()` This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL.
`void`	`testMultiLevelLateral_SchemaChange_LeftUnnest()` This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL.
`void`	`testMultiLevelLateral_SchemaChange_RightUnnest()` This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL.
`void`	`testMultiLevelLateral()` This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL.
`void`	`testMultipleUnnestAtSameLevel()` This test generates an operator tree for multiple UNNEST at same level by stacking 2 LATERAL and UNNEST pair on top of each other.
`void`	`testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForNonUnnestField()` When multiple left batch is received with same schema but with OK_NEW_SCHEMA, then LATERAL rebuilds the schema each time and sends output in multiple output batches The schema change was only for columns which are not produced by the UNNEST or right branch.
`void`	`testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForUnnestField()` When multiple left batch is received with same schema but with OK_NEW_SCHEMA, then LATERAL correctly handles it by re-creating the schema and producing multiple batches of final output The schema change is for columns common on both left and right side.
`void`	`testPostBuildSchema_OK_NEW_SCHEMA_NonEmptyRightBatch()` Verifies that if a non-empty batch with OK_NEW_SCHEMA is received from right side post buildSchema phase then it is handled correctly by sending an empty batch with OK_NEW_SCHEMA and later consuming it to produce actual output batch with some data
`void`	`testUnsupportedSelectionVector()` Test unsupported incoming batch to LATERAL with SelectionVector

Methods inherited from class org.apache.drill.test.SubOperatorTest
classSetup, classTeardown

Methods inherited from class org.apache.drill.test.DrillTest
escapeJsonString, finishDrillTest, initDrillTest

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

- Constructor Detail
  - TestLateralJoinCorrectness
```
public TestLateralJoinCorrectness()
```
- Method Detail
  - setUpBeforeClass
```
public static void setUpBeforeClass()
                             throws Exception
```
    Throws:
    
    Exception
  - tearDownAfterClass
```
public static void tearDownAfterClass()
                               throws Exception
```
    Throws:
    
    Exception
  - beforeTest
```
public void beforeTest()
                throws Exception
```
    Throws:
    
    Exception
  - afterTest
```
public void afterTest()
               throws Exception
```
    Throws:
    
    Exception
  - testBuildSchemaEmptyLRBatch
```
public void testBuildSchemaEmptyLRBatch()
                                 throws Exception
```
    With both left and right batch being empty, the LateralJoinBatch.buildSchema() phase should still build the output container schema and return empty batch
    
    Throws:
    
    Exception
  - testBuildSchemaNonEmptyLRBatch
```
public void testBuildSchemaNonEmptyLRBatch()
                                    throws Exception
```
    With both left and right batch being non-empty, the LateralJoinBatch.buildSchema() phase will fail with IllegalStateException since it expects first batch from right branch of LATERAL to be always empty
    
    Throws:
    
    Exception
  - testBuildSchemaNonEmptyLEmptyRBatch
```
public void testBuildSchemaNonEmptyLEmptyRBatch()
                                         throws Exception
```
    With non-empty left and empty right batch, the LateralJoinBatch.buildSchema() phase should still build the output container schema and return empty batch
    
    Throws:
    
    Exception
  - testBuildSchemaEmptyLNonEmptyRBatch
```
public void testBuildSchemaEmptyLNonEmptyRBatch()
                                         throws Exception
```
    This case should never happen since With empty left there cannot be non-empty right batch, the LateralJoinBatch.buildSchema() phase should fail() with IllegalStateException
    
    Throws:
    
    Exception
  - testBuildSchemaWithEMITOutcome
```
public void testBuildSchemaWithEMITOutcome()
                                    throws Exception
```
    Test for receiving unexpected EMIT outcome during build phase on left side.
    
    Throws:
    
    Exception
  - test1RecordLeftBatchTo1RightRecordBatch
```
public void test1RecordLeftBatchTo1RightRecordBatch()
                                             throws Exception
```
    Test to show correct IterOutcome produced by LATERAL when one record in left batch produces only 1 right batch with EMIT outcome. Then output of LATERAL should be produced by OK outcome after the join. It verifies the number of records in the output batch based on left and right input batches.
    
    Throws:
    
    Exception
  - test1RecordLeftBatchTo2RightRecordBatch
```
public void test1RecordLeftBatchTo2RightRecordBatch()
                                             throws Exception
```
    Test to show correct IterOutcome & output produced by LATERAL when one record in left batch produces 2 right batches with OK and EMIT outcome respectively. Then output of LATERAL should be produced with OK outcome after the join is done using both right batch with the left batch. It verifies the number of records in the output batch based on left and right input batches.
    
    Throws:
    
    Exception
  - test1RecordLeftBatchToEmptyRightBatch
```
public void test1RecordLeftBatchToEmptyRightBatch()
                                           throws Exception
```
    Test to show that if the result of cross join between left batch and empty right batch is an empty batch and next batch on left side result in NONE outcome, then there is no output produced and result returned to downstream is NONE.
    
    Throws:
    
    Exception
  - testFillingUpOutputBatch
```
public void testFillingUpOutputBatch()
                              throws Exception
```
    Test to show LATERAL tries to pack the output batch until it's full or all the data is consumed from left and right side. We have multiple left and right batches which fits after join inside the same output batch, hence LATERAL only generates one output batch.
    
    Throws:
    
    Exception
  - testHandlingSchemaChangeForNonUnnestField
```
public void testHandlingSchemaChangeForNonUnnestField()
                                               throws Exception
```
    When multiple left batches are received with different schema, then LATERAL produces output for each schema type separately (even though output batch is not filled completely) and handles the schema change in left batch. Moreover in this case the schema change was only for columns which are not produced by the UNNEST or right branch.
    
    Throws:
    
    Exception
  - testHandlingSchemaChangeForUnnestField
```
public void testHandlingSchemaChangeForUnnestField()
                                            throws Exception
```
    When multiple left and right batches are received with different schema, then LATERAL produces output for each schema type separately (even though output batch is not filled completely) and handles the schema change correctly. Moreover in this case the schema change was for both left and right branch (produced by UNNEST with empty batch).
    
    Throws:
    
    Exception
  - testHandlingUnexpectedSchemaChangeForUnnestField
```
public void testHandlingUnexpectedSchemaChangeForUnnestField()
                                                      throws Exception
```
    Verify if there is no schema change on left side and LATERAL still sees an unexpected schema change on right side then it handles it correctly. handle it corr
    
    Throws:
    
    Exception
  - testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForNonUnnestField
```
public void testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForNonUnnestField()
                                                                  throws Exception
```
    When multiple left batch is received with same schema but with OK_NEW_SCHEMA, then LATERAL rebuilds the schema each time and sends output in multiple output batches The schema change was only for columns which are not produced by the UNNEST or right branch.
    
    Throws:
    
    Exception
  - testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForUnnestField
```
public void testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForUnnestField()
                                                               throws Exception
```
    When multiple left batch is received with same schema but with OK_NEW_SCHEMA, then LATERAL correctly handles it by re-creating the schema and producing multiple batches of final output The schema change is for columns common on both left and right side.
    
    Throws:
    
    Exception
  - testHandlingEMITFromLeft
```
public void testHandlingEMITFromLeft()
                              throws Exception
```
    When multiple left batch is received with same schema but with OK_NEW_SCHEMA, then LATERAL detects that correctly and suppresses schema change operation by producing output in same batch created with initial schema. The schema change was only for columns which are not produced by the UNNEST or right branch.
    
    Throws:
    
    Exception
  - testHandlingNoneAfterOK
```
public void testHandlingNoneAfterOK()
                             throws Exception
```
    Test for the case where LATERAL received a left batch with OK outcome and then populate the Join output in the outgoing batch. There is still some space left in output batch so LATERAL call's next() on left side and receive NONE outcome from left side. Then in this case LATERAL should produce the previous output batch with OK outcome and then handle NONE outcome in future next() call.
    
    Throws:
    
    Exception
  - testHandlingEmptyEMITAfterOK
```
public void testHandlingEmptyEMITAfterOK()
                                  throws Exception
```
    Test for the case when LATERAL received a left batch with OK outcome and then populate the Join output in the outgoing batch. There is still some space left in output batch so LATERAL call's next() on left side and receive EMIT outcome from left side with empty batch. Then in this case LATERAL should produce the previous output batch with EMIT outcome.
    
    Throws:
    
    Exception
  - testHandlingNonEmptyEMITAfterOK
```
public void testHandlingNonEmptyEMITAfterOK()
                                     throws Exception
```
    Test for the case when LATERAL received a left batch with OK outcome and then populate the Join output in the outgoing batch. There is still some space left in output batch so LATERAL call's next() on left side and receive EMIT outcome from left side with non-empty batch. Then in this case LATERAL should produce the output batch with EMIT outcome if second left and right batches are also consumed entirely in same output batch.
    
    Throws:
    
    Exception
  - testHandlingNonEmpty_EMITAfterOK_WithMultipleOutput
```
public void testHandlingNonEmpty_EMITAfterOK_WithMultipleOutput()
                                                         throws Exception
```
    Temporary test to validate LATERAL handling output batch getting filled without consuming full output from left and right batch join.
    For this test we are updating RecordBatch.MAX_BATCH_ROW_COUNT by making it public, which might not expected after including the BatchSizing logic TODO: Update the test after incorporating the BatchSizing change.
    
    Throws:
    
    Exception
  - testBasicLeftLateralJoin
```
public void testBasicLeftLateralJoin()
                              throws Exception
```
    Test to check basic left lateral join is working correctly or not. We create a left batch with one and corresponding right batch with zero rows and check if output still get's populated with left side of data or not. Expectation is since it's a left join and even though right batch is empty the left row will be pushed to output batch.
    
    Throws:
    
    Exception
  - testLeftLateralJoin_WithMatchingAndEmptyBatch
```
public void testLeftLateralJoin_WithMatchingAndEmptyBatch()
                                                   throws Exception
```
    Test to see if there are multiple rows in left batch and for some rows right side produces multiple batches such that some are with records and some are empty then we are not duplicating those left side records based on left join type. In this case all the output will be produces only in 1 record batch.
    
    Throws:
    
    Exception
  - testLeftLateralJoin_WithAndWithoutMatching
```
public void testLeftLateralJoin_WithAndWithoutMatching()
                                                throws Exception
```
    Test to see if there are multiple rows in left batch and for some rows right side produces batch with records and for other rows right side produces empty batches then based on left join type we are populating the output batch correctly. Expectation is that for left rows if we find corresponding right rows then we will output both using cross-join but for left rows for which there is empty right side we will produce only left row in output batch. In this case all the output will be produces only in 1 record batch.
    
    Throws:
    
    Exception
  - testLeftLateralJoin_WithAndWithoutMatching_MultipleBatch
```
public void testLeftLateralJoin_WithAndWithoutMatching_MultipleBatch()
                                                              throws Exception
```
    Test to see if there are multiple rows in left batch and for some rows right side produces batch with records and for other rows right side produces empty batches then based on left join type we are populating the output batch correctly. Expectation is that for left rows if we find corresponding right rows then we will output both using cross-join but for left rows for which there is empty right side we will produce only left row in output batch. But in this test we have made the Batch size very small so that output will be returned in multiple output batches. This test verifies even in this case indexes are manipulated correctly and outputs are produced correctly. TODO: Update the test case based on Batch Sizing project since then the variable might not be available.
    
    Throws:
    
    Exception
  - testMultipleUnnestAtSameLevel
```
public void testMultipleUnnestAtSameLevel()
                                   throws Exception
```
    This test generates an operator tree for multiple UNNEST at same level by stacking 2 LATERAL and UNNEST pair on top of each other. Then we call next() on top level LATERAL to simulate the operator tree and compare the outcome and record count generated with expected values.
    
    Throws:
    
    Exception
  - testMultiLevelLateral
```
public void testMultiLevelLateral()
                           throws Exception
```
    This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL. Then we call next() on top level LATERAL to simulate the operator tree and compare the outcome and record count generated with expected values.
    
    Throws:
    
    Exception
  - testMultiLevelLateral_MultipleOutput
```
public void testMultiLevelLateral_MultipleOutput()
                                          throws Exception
```
    This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL. Then we call next() on top level LATERAL to simulate the operator tree and compare the outcome and record count generated with expected values. This test also changes the MAX_BATCH_ROW_COUNT to simulate the output being produced in multiple batches.
    
    Throws:
    
    Exception
  - testMultiLevelLateral_SchemaChange_LeftUnnest
```
public void testMultiLevelLateral_SchemaChange_LeftUnnest()
                                                   throws Exception
```
    This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL. In this setup the test try to simulate the SchemaChange happening at upper level LATERAL left incoming second batch, which also results into the SchemaChange of left UNNEST of lower level LATERAL. This test validates that the schema change is handled correctly by both upper and lower level LATERAL.
    
    Throws:
    
    Exception
  - testMultiLevelLateral_SchemaChange_RightUnnest
```
public void testMultiLevelLateral_SchemaChange_RightUnnest()
                                                    throws Exception
```
    This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL. In this setup the test try to simulate the SchemaChange happening at upper level LATERAL left incoming second batch, which also results into the SchemaChange of right UNNEST of lower level LATERAL. This test validates that the schema change is handled correctly by both upper and lower level LATERAL.
    
    Throws:
    
    Exception
  - testMultiLevelLateral_SchemaChange_LeftRightUnnest
```
public void testMultiLevelLateral_SchemaChange_LeftRightUnnest()
                                                        throws Exception
```
    This test generates an operator tree for multi level LATERAL by stacking 2 LATERAL and finally an UNNEST pair (using MockRecord Batch) as left and right child of lower level LATERAL. In this setup the test try to simulate the SchemaChange happening at upper level LATERAL left incoming second batch, which also results into the SchemaChange of both left&right UNNEST of lower level LATERAL. This test validates that the schema change is handled correctly by both upper and lower level LATERAL.
    
    Throws:
    
    Exception
  - testUnsupportedSelectionVector
```
public void testUnsupportedSelectionVector()
                                    throws Exception
```
    Test unsupported incoming batch to LATERAL with SelectionVector
    
    Throws:
    
    Exception
  - test_OK_NEW_SCHEMAFromLeft_EmitFromRight_PostBuildSchema
```
public void test_OK_NEW_SCHEMAFromLeft_EmitFromRight_PostBuildSchema()
                                                              throws Exception
```
    Test to verify if OK_NEW_SCHEMA is received from left side of LATERAL post build schema phase and EMIT is received from right side of LATERAL for each row on left side, then Lateral sends OK_NEW_SCHEMA downstream with the output batch. LATERAL shouldn't send any batch with EMIT outcome to the downstream operator as it is the consumer of all the EMIT outcomes. It will work fine in case of Multilevel LATERAL too since there the lower LATERAL only sends EMIT after it receives it from left UNNEST.
    
    Throws:
    
    Exception
  - testPostBuildSchema_OK_NEW_SCHEMA_NonEmptyRightBatch
```
public void testPostBuildSchema_OK_NEW_SCHEMA_NonEmptyRightBatch()
                                                          throws Exception
```
    Verifies that if a non-empty batch with OK_NEW_SCHEMA is received from right side post buildSchema phase then it is handled correctly by sending an empty batch with OK_NEW_SCHEMA and later consuming it to produce actual output batch with some data
    
    Throws:
    
    Exception
  - testMultiLevelLateral_SchemaChange_LeftRightUnnest_NonEmptyBatch
```
public void testMultiLevelLateral_SchemaChange_LeftRightUnnest_NonEmptyBatch()
                                                                      throws Exception
```
    Test to verify in case of Multilevel lateral when a non-empty OK_NEW_SCHEMA batch post build schema phase is received from right most UNNEST of lower LATERAL then pipeline works fine.
    
    Throws:
    
    Exception
  - testLateral_SchemaChange_Left_EmptyRightBatchForFirst
```
public void testLateral_SchemaChange_Left_EmptyRightBatchForFirst()
                                                           throws Exception
```
    Test to verify that for first left incoming if there is no right side incoming batch and then second left incoming comes with schema change, then the schema change with empty output batch for first incoming is handled properly.
    
    Throws:
    
    Exception
  - testFillingUpOutputBatch_WithExcludedColumns
```
public void testFillingUpOutputBatch_WithExcludedColumns()
                                                  throws Exception
```
    Throws:
    
    Exception
  - testFillingUpOutputBatch_With2ExcludedColumns
```
public void testFillingUpOutputBatch_With2ExcludedColumns()
                                                   throws Exception
```
    Throws:
    
    Exception

Class TestLateralJoinCorrectness

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.drill.test.DrillTest

Field Summary

Fields inherited from class org.apache.drill.test.SubOperatorTest

Fields inherited from class org.apache.drill.test.DrillTest

Constructor Summary

Method Summary

Methods inherited from class org.apache.drill.test.SubOperatorTest

Methods inherited from class org.apache.drill.test.DrillTest

Methods inherited from class java.lang.Object

Constructor Detail

TestLateralJoinCorrectness

Method Detail

setUpBeforeClass

tearDownAfterClass

beforeTest

afterTest

testBuildSchemaEmptyLRBatch

testBuildSchemaNonEmptyLRBatch

testBuildSchemaNonEmptyLEmptyRBatch

testBuildSchemaEmptyLNonEmptyRBatch

testBuildSchemaWithEMITOutcome

test1RecordLeftBatchTo1RightRecordBatch

test1RecordLeftBatchTo2RightRecordBatch

test1RecordLeftBatchToEmptyRightBatch

testFillingUpOutputBatch

testHandlingSchemaChangeForNonUnnestField

testHandlingSchemaChangeForUnnestField

testHandlingUnexpectedSchemaChangeForUnnestField

testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForNonUnnestField

testOK_NEW_SCHEMA_WithNoActualSchemaChange_ForUnnestField

testHandlingEMITFromLeft

testHandlingNoneAfterOK

testHandlingEmptyEMITAfterOK

testHandlingNonEmptyEMITAfterOK

testHandlingNonEmpty_EMITAfterOK_WithMultipleOutput

testBasicLeftLateralJoin

testLeftLateralJoin_WithMatchingAndEmptyBatch

testLeftLateralJoin_WithAndWithoutMatching

testLeftLateralJoin_WithAndWithoutMatching_MultipleBatch

testMultipleUnnestAtSameLevel

testMultiLevelLateral

testMultiLevelLateral_MultipleOutput

testMultiLevelLateral_SchemaChange_LeftUnnest

testMultiLevelLateral_SchemaChange_RightUnnest

testMultiLevelLateral_SchemaChange_LeftRightUnnest

testUnsupportedSelectionVector

test_OK_NEW_SCHEMAFromLeft_EmitFromRight_PostBuildSchema

testPostBuildSchema_OK_NEW_SCHEMA_NonEmptyRightBatch

testMultiLevelLateral_SchemaChange_LeftRightUnnest_NonEmptyBatch

testLateral_SchemaChange_Left_EmptyRightBatchForFirst

testFillingUpOutputBatch_WithExcludedColumns

testFillingUpOutputBatch_With2ExcludedColumns