com.bigdata.rdf.sparql.ast.optimizers

Class ASTFastRangeCountOptimizer

java.lang.Object

com.bigdata.rdf.sparql.ast.optimizers.ASTFastRangeCountOptimizer

All Implemented Interfaces:

IASTOptimizer

public class ASTFastRangeCountOptimizer
extends Object
implements IASTOptimizer

Optimizes SELECT COUNT(*) { triple-pattern } using the fast range count mechanisms when that feature would produce exact results for the KB instance.

Cases handled by this optimizer

Basic combinations with identical semantics:

SELECT COUNT(DISTINCT *) {?s ?p ?o}

SELECT COUNT(REDUCED *) {?s ?p ?o}

SELECT COUNT(*) {?s ?p ?o}

Combinations using a constrained range-count.

SELECT COUNT(*) {:s ?p ?o}

SELECT COUNT(*) {?s :p ?o}

SELECT COUNT(*) {?s ?p :o}

SELECT COUNT(*) {:s ?p :o}

Combinations using a constrained range-count where the triple pattern is 1-unbound and the COUNT() references the unbound variable.

SELECT COUNT(?s) {?s :p :o}

SELECT COUNT(?p) {:s ?p :o}

SELECT COUNT(?o) {:s :p ?o}

Combinations using a constrained range-count with a QUADS mode access path.

SELECT COUNT(*) { GRAPH ?g {?s ?p ?o} }

SELECT COUNT(*) { GRAPH :g {:s ?p ?o} }

Combinations using a constrained range-count with a QUADS mode access path where the triple pattern is 1-unbound and the COUNT() references the unbound variable.

SELECT COUNT(?s) { GRAPH :g {?s :p :o} }

SELECT COUNT(?g) { GRAPH ?g {:s :p :o} }

Combinations using a sub-select with nothing projected in:

SELECT * { { SELECT COUNT(*) {?s ?p ?o} } }

SELECT * { { SELECT COUNT(*) {?s ?p ?o} } :s :p :o .}

Combinations using a sub-select with something projected in:

SELECT * { ?s a :b . { SELECT COUNT(*) {?s ?p ?o} .}

Correct rejection cases NOT handled by this optimizer

Combinations using DISTINCT/REDUCED and a constrained range-count, explicitly naming the variables, and having variables that are not in the COUNT() aggregate and not projected in are NOT handled here. These are covered by the ASTDistinctTermScanOptimizer instead:

SELECT COUNT(?p) {:s ?p ?o}

SELECT COUNT(DISTINCT ?p) {:s ?p ?o}

SELECT COUNT(REDUCED ?p) {:s ?p ?o}

Sub-select that would be handled as a distinct term scan with something projected in.

SELECT * { ?s a :b . { SELECT COUNT(?p) {?s ?p ?o} .}

Author:

Bryan Thompson

See Also:

Rewrite SELECT COUNT(...) (DISTINCT|REDUCED) {single-triple-pattern} as ESTCARD

Constructor Summary

Constructors

Constructor and Description
ASTFastRangeCountOptimizer()

Method Summary

Methods

Modifier and Type	Method and Description
protected boolean	markForFastRangeCount(AST2BOpContext context, StatementPatternNode sp, VarNode fastRangeCountVariable) Marks the triple pattern for fast range count, if supported.
QueryNodeWithBindingSet	optimize(AST2BOpContext context, QueryNodeWithBindingSet input) Optimize the AST.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ASTFastRangeCountOptimizer

public ASTFastRangeCountOptimizer()

Method Detail

optimize

public QueryNodeWithBindingSet optimize(AST2BOpContext context,
                               QueryNodeWithBindingSet input)

Description copied from interface: IASTOptimizer

Optimize the AST.

Specified by:

optimize in interface IASTOptimizer

Parameters:

context - The evaluation context.

input - The input to the optimizer, consisting of a queryNode and input binding set.

Returns:

An instance of type QueryNodeWithBindingSet.

markForFastRangeCount

protected boolean markForFastRangeCount(AST2BOpContext context,
                            StatementPatternNode sp,
                            VarNode fastRangeCountVariable)

Marks the triple pattern for fast range count, if supported. If fast range counts are supported (they're currently not yet on the GPU) and the triple pattern has been marked, the method returns true. Otherwise, it must return false (see ASTGPUFastRangeCountOptimizer override).

Parameters:

sp -

fastRangeCountVariable -