TestPipelinedHashJoin (Blazegraph Database Platform 2.1.5 API)

java.lang.Object
- junit.framework.Assert
- - junit.framework.TestCase
  - - junit.framework.TestCase2
    - - com.bigdata.bop.engine.AbstractQueryEngineTestCase
      - com.bigdata.rdf.sparql.ast.AbstractASTEvaluationTestCase
        
        com.bigdata.rdf.sparql.ast.eval.AbstractDataAndSPARQLTestCase
        
        com.bigdata.rdf.sparql.ast.eval.AbstractDataDrivenSPARQLTestCase
        
        com.bigdata.rdf.sparql.ast.eval.TestPipelinedHashJoin

All Implemented Interfaces:

junit.framework.Test
```
public class TestPipelinedHashJoin
extends AbstractDataDrivenSPARQLTestCase
```
Test suite for PipelinedHashIndexAndSolutionSetJoinOp, which implements a pipelined hash join.

Version:

$Id$

Author:

Michael Schmidt

Nested Class Summary
- Nested classes/interfaces inherited from class com.bigdata.rdf.sparql.ast.eval.AbstractDataDrivenSPARQLTestCase
  AbstractDataDrivenSPARQLTestCase.TestHelper, AbstractDataDrivenSPARQLTestCase.UpdateTestHelper
- Nested classes/interfaces inherited from class com.bigdata.rdf.sparql.ast.eval.AbstractDataAndSPARQLTestCase
  AbstractDataAndSPARQLTestCase.AbsHelper
- Nested classes/interfaces inherited from class junit.framework.TestCase2
  TestCase2.MyProperties, TestCase2.RandomType

Field Summary
- Fields inherited from class com.bigdata.rdf.sparql.ast.AbstractASTEvaluationTestCase
  baseURI, store, valueFactory
- Fields inherited from class junit.framework.TestCase2
  _randomType

Constructor Summary

Constructors
Constructor and Description

TestPipelinedHashJoin()

TestPipelinedHashJoin(String name)

Constructors
Constructor and Description
`TestPipelinedHashJoin()`
`TestPipelinedHashJoin(String name)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`assertPipelinedPlanOrNot(PipelineOp queryPlan, ASTContainer container, boolean assertPipelined, boolean analyticMode)` Asserts that a PipelinedHashIndexAndSolutionSetOp is contained in the query plan if contains equals `true`, otherwise that it is NOT contained.
`void`	`testPipelinedHashDisabledByQueryHintALP()` Combination of ALP and enablement by query hint.
`void`	`testPipelinedHashDisabledByQueryHintExists()` Combination of EXISTS and enablement by query hint.
`void`	`testPipelinedHashDisabledByQueryHintMinus()` Combination of MINUS and enablement by query hint.
`void`	`testPipelinedHashDisabledByQueryHintNotExists()` Combination of NOT EXISTS and enablement by query hint.
`void`	`testPipelinedHashDisabledByQueryHintOptional()` Combination of OPTIONAL and enablement by query hint.
`void`	`testPipelinedHashDisabledByQueryHintOptionalAnalyticMode()` Combination of OPTIONAL and enablement by query hint and analytic mode.
`void`	`testPipelinedHashDisabledByQueryHintSubquery()` Combination of subquery and enablement by query hint.
`void`	`testPipelinedHashDisabledByQueryHintValues()` Combination of VALUES and enablement by query hint.
`void`	`testPipelinedHashDistinctProjectionBufferThreshold()` Test query affected by PipelinedHashIndexAndSolutionSetOp.DISTINCT_PROJECTION_BUFFER_THRESHOLD
`void`	`testPipelinedHashDistinctProjectionBufferThresholdAnalyticMode()` Test query affected by PipelinedHashIndexAndSolutionSetOp.DISTINCT_PROJECTION_BUFFER_THRESHOLD
`void`	`testPipelinedHashEnabledByQueryHintALP()` Combination of ALP and enablement by query hint.
`void`	`testPipelinedHashEnabledByQueryHintExists()` Combination of EXISTS and enablement by query hint.
`void`	`testPipelinedHashEnabledByQueryHintMinus()` Combination of MINUS and enablement by query hint.
`void`	`testPipelinedHashEnabledByQueryHintNotExists()` Combination of NOT EXISTS and enablement by query hint.
`void`	`testPipelinedHashEnabledByQueryHintOptional()` Combination of OPTIONAL and enablement by query hint.
`void`	`testPipelinedHashEnabledByQueryHintOptionalAnalyticMode()` Combination of OPTIONAL and enablement by query hint and analytic mode.
`void`	`testPipelinedHashEnabledByQueryHintSubquery()` Combination of subquery and enablement by query hint.
`void`	`testPipelinedHashEnabledByQueryHintValues()` Combination of VALUES and enablement by query hint.
`void`	`testPipelinedHashIncomingBindingsBufferThreshold()` Test query affected by PipelinedHashIndexAndSolutionSetOp.INCOMING_BINDINGS_BUFFER_THRESHOLD.
`void`	`testPipelinedHashIncomingBindingsBufferThresholdAnalyticMode()` Test query affected by PipelinedHashIndexAndSolutionSetOp.INCOMING_BINDINGS_BUFFER_THRESHOLD.
`void`	`testPipelinedHashJoinDefaultUsedForALP01()` Do not use pipelined hash join for ALP "*" node if no LIMIT in query.
`void`	`testPipelinedHashJoinDefaultUsedForALP02()` Do not use pipelined hash join for ALP "+" node if no LIMIT in query.
`void`	`testPipelinedHashJoinDefaultUsedForExists()` Do not use pipelined hash join for EXISTS clause if no LIMIT in query.
`void`	`testPipelinedHashJoinDefaultUsedForMinus()` Use pipelined hash join for MINUS is not specified when no LIMIT is present in the query.
`void`	`testPipelinedHashJoinDefaultUsedForNotExists()` Do not use pipelined hash join for NOT EXISTS clause if no LIMIT in query.
`void`	`testPipelinedHashJoinDefaultUsedForSubquery()` Do not use pipelined hash join for SPARQL 1.1 subquery if no LIMIT in query.
`void`	`testPipelinedHashJoinDefaultUsedForValues()` Do not use pipelined hash join for VALUES clause if no LIMIT in query.
`void`	`testPipelinedHashJoinDefaultUsedOptional01()` Make sure the pipelined hash join operator is not used as a standard for non-LIMIT query.
`void`	`testPipelinedHashJoinDefaultUsedOptional01Analytic()` Make sure the pipelined hash join operator is not used as a standard for non-LIMIT query.
`void`	`testPipelinedHashJoinDefaultUsedOptionald02()` Make sure the pipelined hash join operator is not used as a standard for LIMIT+OFFSET queries.
`void`	`testPipelinedHashJoinDisabledMinusBug01aAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in analytic mode.
`void`	`testPipelinedHashJoinDisabledMinusBug01aNonAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in non-analytic mode.
`void`	`testPipelinedHashJoinDisabledMinusBug01bAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in analytic mode.
`void`	`testPipelinedHashJoinDisabledMinusBug01bNonAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in non-analytic mode.
`void`	`testPipelinedHashJoinDisabledMinusBug02AnalyticMode()` Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in analytic mode.
`void`	`testPipelinedHashJoinDisabledMinusBug02NonAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in non-analytic mode.
`void`	`testPipelinedHashJoinExistsMultiplicity()` Check correct multiplicity for EXISTS.
`void`	`testPipelinedHashJoinExistsMultiplicityAnalyticMode()` Check correct multiplicity for EXISTS in analytic mode.
`void`	`testPipelinedHashJoinMinusBug01aAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, test case for analytic mode.
`void`	`testPipelinedHashJoinMinusBug01aNonAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, test case for non-analytic mode.
`void`	`testPipelinedHashJoinMinusBug01bAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, test case for analytic mode.
`void`	`testPipelinedHashJoinMinusBug01bNonAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, test case for non-analytic mode.
`void`	`testPipelinedHashJoinMinusBug02AnalyticMode()` Bug reporting MINUS pipelined hash join being broken, test case for analytic mode.
`void`	`testPipelinedHashJoinMinusBug02NonAnalyticMode()` Bug reporting MINUS pipelined hash join being broken, test case for non-analytic mode.
`void`	`testPipelinedHashJoinNotExistsMultiplicity()` Check correct multiplicity for NOT EXISTS.
`void`	`testPipelinedHashJoinNotExistsMultiplicityAnalyticMode()` Check correct multiplicity for NOT EXISTS in analytic mode.
`void`	`testPipelinedHashJoinUsedForALP01()` Use pipelined hash join for ALP "*" node.
`void`	`testPipelinedHashJoinUsedForALP01AnalyticMode()` Use pipelined hash join for ALP "*" node and analytic mode.
`void`	`testPipelinedHashJoinUsedForALP02()` Use pipelined hash join for ALP "+" node.
`void`	`testPipelinedHashJoinUsedForALP02AnalyticMode()` Use pipelined hash join for ALP "+" node and analytic mode.
`void`	`testPipelinedHashJoinUsedForExists()` Do use pipelined hash join for EXISTS clause if LIMIT in query.
`void`	`testPipelinedHashJoinUsedForExistsAnalyticMode()` Do use pipelined hash join for EXISTS clause if LIMIT in query and analytic mode.
`void`	`testPipelinedHashJoinUsedForMinus()` Use pipelined hash join for MINUS when LIMIT specified.
`void`	`testPipelinedHashJoinUsedForMinusAnalyticMode()` Use pipelined hash join for MINUS when LIMIT specified and analytic mode.
`void`	`testPipelinedHashJoinUsedForNotExists()` Do use pipelined hash join for NOT EXISTS clause if LIMIT in query.
`void`	`testPipelinedHashJoinUsedForNotExistsAnalyticMode()` Do use pipelined hash join for NOT EXISTS clause if LIMIT in query and analytic mode.
`void`	`testPipelinedHashJoinUsedForOptional()` Use pipelined hash join for OPTIONAL when LIMIT specified.
`void`	`testPipelinedHashJoinUsedForOptionalAnalyticMode()` Use pipelined hash join for OPTIONAL when LIMIT specified and analytic mode.
`void`	`testPipelinedHashJoinUsedForSubquery()` Use pipelined hash join for SPARQL 1.1 subquery.
`void`	`testPipelinedHashJoinUsedForSubqueryAnalyticMode()` Use pipelined hash join for SPARQL 1.1 subquery and analytic mode.
`void`	`testPipelinedHashJoinUsedForValues()` Use pipelined hash join for inlined VALUES node.
`void`	`testPipelinedHashJoinUsedForValuesAnalyticMode()` Use pipelined hash join for inlined VALUES node and analytic mode.

Methods inherited from class com.bigdata.rdf.sparql.ast.AbstractASTEvaluationTestCase
assertSameAST, asSet, asSet, asSet, asSet, asSet, enableDeleteMarkersInIndes, getBOpContext, getProperties, getStore, makeIV, setUp, tearDown

Methods inherited from class com.bigdata.bop.engine.AbstractQueryEngineTestCase
assertSameSolutions, assertSameSolutions, assertSameSolutions, assertSameSolutionsAnyOrder, assertSameSolutionsAnyOrder, assertSameSolutionsAnyOrder, assertSameSolutionsAnyOrder, assertSameSolutionsAnyOrder, assertSameSolutionsAnyOrder, compareGraphs, compareTupleQueryResults, diff

Methods inherited from class junit.framework.TestCase2
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEqualsWithinUlps, assertSameArray, assertSameArray, assertSameBigDecimal, assertSameBigDecimal, assertSameBigInteger, assertSameBigInteger, assertSameIterator, assertSameIterator, assertSameIteratorAnyOrder, assertSameIteratorAnyOrder, assertSameValue, assertSameValue, assertZeroUlps, assertZeroUlps, fail, getInnerCause, getNormalInt, getProjectBuildPath, getRandomObject, getRandomObject, getRandomOrder, getRandomString, getTestInputStream, getTestResource, getTestResource, getUlps, getUlps, isDEBUG, isDEBUG, isINFO, isINFO, isInnerCause, logProperties

Methods inherited from class junit.framework.TestCase
assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, countTestCases, createResult, fail, fail, failNotEquals, failNotSame, failSame, format, getName, run, run, runBare, runTest, setName, toString

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

- Constructor Detail
  - TestPipelinedHashJoin
```
public TestPipelinedHashJoin()
```
  - TestPipelinedHashJoin
```
public TestPipelinedHashJoin(String name)
```
    Parameters:
    name -
- Method Detail
  - testPipelinedHashJoinUsedForOptional
```
public void testPipelinedHashJoinUsedForOptional()
                                          throws Exception
```
    Use pipelined hash join for OPTIONAL when LIMIT specified.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForMinus
```
public void testPipelinedHashJoinUsedForMinus()
                                       throws Exception
```
    Use pipelined hash join for MINUS when LIMIT specified.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForALP01
```
public void testPipelinedHashJoinUsedForALP01()
                                       throws Exception
```
    Use pipelined hash join for ALP "*" node.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForALP02
```
public void testPipelinedHashJoinUsedForALP02()
                                       throws Exception
```
    Use pipelined hash join for ALP "+" node.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForSubquery
```
public void testPipelinedHashJoinUsedForSubquery()
                                          throws Exception
```
    Use pipelined hash join for SPARQL 1.1 subquery.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForValues
```
public void testPipelinedHashJoinUsedForValues()
                                        throws Exception
```
    Use pipelined hash join for inlined VALUES node.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForExists
```
public void testPipelinedHashJoinUsedForExists()
                                        throws Exception
```
    Do use pipelined hash join for EXISTS clause if LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForNotExists
```
public void testPipelinedHashJoinUsedForNotExists()
                                           throws Exception
```
    Do use pipelined hash join for NOT EXISTS clause if LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForOptionalAnalyticMode
```
public void testPipelinedHashJoinUsedForOptionalAnalyticMode()
                                                      throws Exception
```
    Use pipelined hash join for OPTIONAL when LIMIT specified and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForMinusAnalyticMode
```
public void testPipelinedHashJoinUsedForMinusAnalyticMode()
                                                   throws Exception
```
    Use pipelined hash join for MINUS when LIMIT specified and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForALP01AnalyticMode
```
public void testPipelinedHashJoinUsedForALP01AnalyticMode()
                                                   throws Exception
```
    Use pipelined hash join for ALP "*" node and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForALP02AnalyticMode
```
public void testPipelinedHashJoinUsedForALP02AnalyticMode()
                                                   throws Exception
```
    Use pipelined hash join for ALP "+" node and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForSubqueryAnalyticMode
```
public void testPipelinedHashJoinUsedForSubqueryAnalyticMode()
                                                      throws Exception
```
    Use pipelined hash join for SPARQL 1.1 subquery and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForValuesAnalyticMode
```
public void testPipelinedHashJoinUsedForValuesAnalyticMode()
                                                    throws Exception
```
    Use pipelined hash join for inlined VALUES node and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForExistsAnalyticMode
```
public void testPipelinedHashJoinUsedForExistsAnalyticMode()
                                                    throws Exception
```
    Do use pipelined hash join for EXISTS clause if LIMIT in query and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinUsedForNotExistsAnalyticMode
```
public void testPipelinedHashJoinUsedForNotExistsAnalyticMode()
                                                       throws Exception
```
    Do use pipelined hash join for NOT EXISTS clause if LIMIT in query and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedOptional01
```
public void testPipelinedHashJoinDefaultUsedOptional01()
                                                throws Exception
```
    Make sure the pipelined hash join operator is not used as a standard for non-LIMIT query. Query body is the same as for testPipelinedHashJoinUsedForOptional(), but no LIMIT.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedOptionald02
```
public void testPipelinedHashJoinDefaultUsedOptionald02()
                                                 throws Exception
```
    Make sure the pipelined hash join operator is not used as a standard for LIMIT+OFFSET queries. Query body is the same as for testPipelinedHashJoinUsedForOptional(), but including LIMIT *and* ORDER BY.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedForMinus
```
public void testPipelinedHashJoinDefaultUsedForMinus()
                                              throws Exception
```
    Use pipelined hash join for MINUS is not specified when no LIMIT is present in the query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedForALP01
```
public void testPipelinedHashJoinDefaultUsedForALP01()
                                              throws Exception
```
    Do not use pipelined hash join for ALP "*" node if no LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedForALP02
```
public void testPipelinedHashJoinDefaultUsedForALP02()
                                              throws Exception
```
    Do not use pipelined hash join for ALP "+" node if no LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedForSubquery
```
public void testPipelinedHashJoinDefaultUsedForSubquery()
                                                 throws Exception
```
    Do *not* use pipelined hash join for SPARQL 1.1 subquery if no LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedForValues
```
public void testPipelinedHashJoinDefaultUsedForValues()
                                               throws Exception
```
    Do *not* use pipelined hash join for VALUES clause if no LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedForExists
```
public void testPipelinedHashJoinDefaultUsedForExists()
                                               throws Exception
```
    Do *not* use pipelined hash join for EXISTS clause if no LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedForNotExists
```
public void testPipelinedHashJoinDefaultUsedForNotExists()
                                                  throws Exception
```
    Do *not* use pipelined hash join for NOT EXISTS clause if no LIMIT in query.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDefaultUsedOptional01Analytic
```
public void testPipelinedHashJoinDefaultUsedOptional01Analytic()
                                                        throws Exception
```
    Make sure the pipelined hash join operator is not used as a standard for non-LIMIT query. Query body is the same as for testPipelinedHashJoinUsedForOptional(), but no LIMIT. Verifies exemplarily for analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintOptional
```
public void testPipelinedHashEnabledByQueryHintOptional()
                                                 throws Exception
```
    Combination of OPTIONAL and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintMinus
```
public void testPipelinedHashEnabledByQueryHintMinus()
                                              throws Exception
```
    Combination of MINUS and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintALP
```
public void testPipelinedHashEnabledByQueryHintALP()
                                            throws Exception
```
    Combination of ALP and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintSubquery
```
public void testPipelinedHashEnabledByQueryHintSubquery()
                                                 throws Exception
```
    Combination of subquery and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintValues
```
public void testPipelinedHashEnabledByQueryHintValues()
                                               throws Exception
```
    Combination of VALUES and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintExists
```
public void testPipelinedHashEnabledByQueryHintExists()
                                               throws Exception
```
    Combination of EXISTS and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintNotExists
```
public void testPipelinedHashEnabledByQueryHintNotExists()
                                                  throws Exception
```
    Combination of NOT EXISTS and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashEnabledByQueryHintOptionalAnalyticMode
```
public void testPipelinedHashEnabledByQueryHintOptionalAnalyticMode()
                                                             throws Exception
```
    Combination of OPTIONAL and enablement by query hint and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintOptional
```
public void testPipelinedHashDisabledByQueryHintOptional()
                                                  throws Exception
```
    Combination of OPTIONAL and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintMinus
```
public void testPipelinedHashDisabledByQueryHintMinus()
                                               throws Exception
```
    Combination of MINUS and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintALP
```
public void testPipelinedHashDisabledByQueryHintALP()
                                             throws Exception
```
    Combination of ALP and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintSubquery
```
public void testPipelinedHashDisabledByQueryHintSubquery()
                                                  throws Exception
```
    Combination of subquery and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintValues
```
public void testPipelinedHashDisabledByQueryHintValues()
                                                throws Exception
```
    Combination of VALUES and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintExists
```
public void testPipelinedHashDisabledByQueryHintExists()
                                                throws Exception
```
    Combination of EXISTS and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintNotExists
```
public void testPipelinedHashDisabledByQueryHintNotExists()
                                                   throws Exception
```
    Combination of NOT EXISTS and enablement by query hint.
    
    Throws:
    
    Exception
  - testPipelinedHashDisabledByQueryHintOptionalAnalyticMode
```
public void testPipelinedHashDisabledByQueryHintOptionalAnalyticMode()
                                                              throws Exception
```
    Combination of OPTIONAL and enablement by query hint and analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashIncomingBindingsBufferThreshold
```
public void testPipelinedHashIncomingBindingsBufferThreshold()
                                                      throws Exception
```
    Test query affected by PipelinedHashIndexAndSolutionSetOp.INCOMING_BINDINGS_BUFFER_THRESHOLD.
    
    Throws:
    
    Exception
  - testPipelinedHashDistinctProjectionBufferThreshold
```
public void testPipelinedHashDistinctProjectionBufferThreshold()
                                                        throws Exception
```
    Test query affected by PipelinedHashIndexAndSolutionSetOp.DISTINCT_PROJECTION_BUFFER_THRESHOLD
    
    Throws:
    
    Exception
  - testPipelinedHashIncomingBindingsBufferThresholdAnalyticMode
```
public void testPipelinedHashIncomingBindingsBufferThresholdAnalyticMode()
                                                                  throws Exception
```
    Test query affected by PipelinedHashIndexAndSolutionSetOp.INCOMING_BINDINGS_BUFFER_THRESHOLD.
    
    Throws:
    
    Exception
  - testPipelinedHashDistinctProjectionBufferThresholdAnalyticMode
```
public void testPipelinedHashDistinctProjectionBufferThresholdAnalyticMode()
                                                                    throws Exception
```
    Test query affected by PipelinedHashIndexAndSolutionSetOp.DISTINCT_PROJECTION_BUFFER_THRESHOLD
    
    Throws:
    
    Exception
  - testPipelinedHashJoinExistsMultiplicity
```
public void testPipelinedHashJoinExistsMultiplicity()
                                             throws Exception
```
    Check correct multiplicity for EXISTS.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinExistsMultiplicityAnalyticMode
```
public void testPipelinedHashJoinExistsMultiplicityAnalyticMode()
                                                         throws Exception
```
    Check correct multiplicity for EXISTS in analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinNotExistsMultiplicity
```
public void testPipelinedHashJoinNotExistsMultiplicity()
                                                throws Exception
```
    Check correct multiplicity for NOT EXISTS.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinNotExistsMultiplicityAnalyticMode
```
public void testPipelinedHashJoinNotExistsMultiplicityAnalyticMode()
                                                            throws Exception
```
    Check correct multiplicity for NOT EXISTS in analytic mode.
    
    Throws:
    
    Exception
  - testPipelinedHashJoinMinusBug01aAnalyticMode
```
public void testPipelinedHashJoinMinusBug01aAnalyticMode()
                                                  throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, test case for analytic mode. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinMinusBug01aNonAnalyticMode
```
public void testPipelinedHashJoinMinusBug01aNonAnalyticMode()
                                                     throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, test case for non-analytic mode. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDisabledMinusBug01aAnalyticMode
```
public void testPipelinedHashJoinDisabledMinusBug01aAnalyticMode()
                                                          throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in analytic mode. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDisabledMinusBug01aNonAnalyticMode
```
public void testPipelinedHashJoinDisabledMinusBug01aNonAnalyticMode()
                                                             throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in non-analytic mode. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinMinusBug01bAnalyticMode
```
public void testPipelinedHashJoinMinusBug01bAnalyticMode()
                                                  throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, test case for analytic mode. Variant of 01a that is a little more challenging, as it contains more solutions and duplicates. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinMinusBug01bNonAnalyticMode
```
public void testPipelinedHashJoinMinusBug01bNonAnalyticMode()
                                                     throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, test case for non-analytic mode. Variant of 01a that is a little more challenging, as it contains more solutions and duplicates. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDisabledMinusBug01bAnalyticMode
```
public void testPipelinedHashJoinDisabledMinusBug01bAnalyticMode()
                                                          throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in analytic mode. Variant of 01a that is a little more challenging, as it contains more solutions and duplicates. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDisabledMinusBug01bNonAnalyticMode
```
public void testPipelinedHashJoinDisabledMinusBug01bNonAnalyticMode()
                                                             throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in non-analytic mode. Variant of 01a that is a little more challenging, as it contains more solutions and duplicates. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinMinusBug02AnalyticMode
```
public void testPipelinedHashJoinMinusBug02AnalyticMode()
                                                 throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, test case for analytic mode. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinMinusBug02NonAnalyticMode
```
public void testPipelinedHashJoinMinusBug02NonAnalyticMode()
                                                    throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, test case for non-analytic mode. Variant of the 01* test cases, where we have a join inducing duplicates across chunks. This aims at testing code paths that skip subquery re-evaluation for binding sets that have been evaluated in previous passes. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDisabledMinusBug02AnalyticMode
```
public void testPipelinedHashJoinDisabledMinusBug02AnalyticMode()
                                                         throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in analytic mode. Variant of the 01* test cases, where we have a join inducing duplicates across chunks. This aims at testing code paths that skip subquery re-evaluation for binding sets that have been evaluated in previous passes. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - testPipelinedHashJoinDisabledMinusBug02NonAnalyticMode
```
public void testPipelinedHashJoinDisabledMinusBug02NonAnalyticMode()
                                                            throws Exception
```
    Bug reporting MINUS pipelined hash join being broken, just making sure that the non-pipelined version for the test case (i.e., query without LIMIT) is working as expected in non-analytic mode. Variant of the 01* test cases, where we have a join inducing duplicates across chunks. This aims at testing code paths that skip subquery re-evaluation for binding sets that have been evaluated in previous passes. See https://github.com/blazegraph/database/issues/107
    
    Throws:
    
    Exception
  - assertPipelinedPlanOrNot
```
protected void assertPipelinedPlanOrNot(PipelineOp queryPlan,
                            ASTContainer container,
                            boolean assertPipelined,
                            boolean analyticMode)
```
    Asserts that a PipelinedHashIndexAndSolutionSetOp is contained in the query plan if contains equals true, otherwise that it is NOT contained.

Class TestPipelinedHashJoin

Nested Class Summary

Nested classes/interfaces inherited from class com.bigdata.rdf.sparql.ast.eval.AbstractDataDrivenSPARQLTestCase

Nested classes/interfaces inherited from class com.bigdata.rdf.sparql.ast.eval.AbstractDataAndSPARQLTestCase

Nested classes/interfaces inherited from class junit.framework.TestCase2

Field Summary

Fields inherited from class com.bigdata.rdf.sparql.ast.AbstractASTEvaluationTestCase

Fields inherited from class junit.framework.TestCase2

Constructor Summary

Method Summary

Methods inherited from class com.bigdata.rdf.sparql.ast.AbstractASTEvaluationTestCase

Methods inherited from class com.bigdata.bop.engine.AbstractQueryEngineTestCase

Methods inherited from class junit.framework.TestCase2

Methods inherited from class junit.framework.TestCase

Methods inherited from class java.lang.Object

Constructor Detail

TestPipelinedHashJoin

TestPipelinedHashJoin

Method Detail

testPipelinedHashJoinUsedForOptional

testPipelinedHashJoinUsedForMinus

testPipelinedHashJoinUsedForALP01

testPipelinedHashJoinUsedForALP02

testPipelinedHashJoinUsedForSubquery

testPipelinedHashJoinUsedForValues

testPipelinedHashJoinUsedForExists

testPipelinedHashJoinUsedForNotExists

testPipelinedHashJoinUsedForOptionalAnalyticMode

testPipelinedHashJoinUsedForMinusAnalyticMode

testPipelinedHashJoinUsedForALP01AnalyticMode

testPipelinedHashJoinUsedForALP02AnalyticMode

testPipelinedHashJoinUsedForSubqueryAnalyticMode

testPipelinedHashJoinUsedForValuesAnalyticMode

testPipelinedHashJoinUsedForExistsAnalyticMode

testPipelinedHashJoinUsedForNotExistsAnalyticMode

testPipelinedHashJoinDefaultUsedOptional01

testPipelinedHashJoinDefaultUsedOptionald02

testPipelinedHashJoinDefaultUsedForMinus

testPipelinedHashJoinDefaultUsedForALP01

testPipelinedHashJoinDefaultUsedForALP02

testPipelinedHashJoinDefaultUsedForSubquery

testPipelinedHashJoinDefaultUsedForValues

testPipelinedHashJoinDefaultUsedForExists

testPipelinedHashJoinDefaultUsedForNotExists

testPipelinedHashJoinDefaultUsedOptional01Analytic

testPipelinedHashEnabledByQueryHintOptional

testPipelinedHashEnabledByQueryHintMinus

testPipelinedHashEnabledByQueryHintALP

testPipelinedHashEnabledByQueryHintSubquery

testPipelinedHashEnabledByQueryHintValues

testPipelinedHashEnabledByQueryHintExists

testPipelinedHashEnabledByQueryHintNotExists

testPipelinedHashEnabledByQueryHintOptionalAnalyticMode

testPipelinedHashDisabledByQueryHintOptional

testPipelinedHashDisabledByQueryHintMinus

testPipelinedHashDisabledByQueryHintALP

testPipelinedHashDisabledByQueryHintSubquery

testPipelinedHashDisabledByQueryHintValues

testPipelinedHashDisabledByQueryHintExists

testPipelinedHashDisabledByQueryHintNotExists

testPipelinedHashDisabledByQueryHintOptionalAnalyticMode

testPipelinedHashIncomingBindingsBufferThreshold

testPipelinedHashDistinctProjectionBufferThreshold

testPipelinedHashIncomingBindingsBufferThresholdAnalyticMode

testPipelinedHashDistinctProjectionBufferThresholdAnalyticMode

testPipelinedHashJoinExistsMultiplicity

testPipelinedHashJoinExistsMultiplicityAnalyticMode

testPipelinedHashJoinNotExistsMultiplicity

testPipelinedHashJoinNotExistsMultiplicityAnalyticMode

testPipelinedHashJoinMinusBug01aAnalyticMode

testPipelinedHashJoinMinusBug01aNonAnalyticMode

testPipelinedHashJoinDisabledMinusBug01aAnalyticMode

testPipelinedHashJoinDisabledMinusBug01aNonAnalyticMode

testPipelinedHashJoinMinusBug01bAnalyticMode

testPipelinedHashJoinMinusBug01bNonAnalyticMode

testPipelinedHashJoinDisabledMinusBug01bAnalyticMode

testPipelinedHashJoinDisabledMinusBug01bNonAnalyticMode

testPipelinedHashJoinMinusBug02AnalyticMode

testPipelinedHashJoinMinusBug02NonAnalyticMode

testPipelinedHashJoinDisabledMinusBug02AnalyticMode