QueryHints (Blazegraph Database Platform 2.1.5 API)

```
public interface QueryHints
```
Query hints are directives understood by the SPARQL end point. A query hint appears in the SPARQL query as a "virtual triple". A query hint is declared in a QueryHintScope, which specifies the parts of the SPARQL query to which it will be applied. A list of the common directives is declared by this interface. (Query hints declared elsewhere are generally for internal use only.) Note that not all query hints are permitted in all scopes.

Author:

Bryan Thompson

See Also:
QueryHintScope, QueryHintRegistry, Clean up query hints

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ACCESS_PATH_SAMPLE_LIMIT` The #of samples to take when comparing the cost of a SCAN with an IN filter to as-bound evaluation for each graph in the data set (default 100).
`static String`	`ACCESS_PATH_SCAN_AND_FILTER` For named and default graph access paths where access path cost estimation is disabled by setting the `ACCESS_PATH_SAMPLE_LIMIT` to ZERO (0), this query hint determines whether a SCAN + FILTER or PARALLEL SUBQUERY (aka as-bound data set join) approach.
`static String`	`ANALYTIC` When `true`, enables all query hints pertaining to analytic query patterns.
`static String`	`ANALYTIC_MAX_MEMORY_PER_QUERY` The maximum amount of native heap memory that may be allocated for a single query when using the analytic query mode -or- ZERO (0L) if no limit should be imposed.
`static String`	`AST_OPTIMIZER_CLASS` The name of the subclass derived from `ASTOptimizerList` that will be used to optimize SPARQL QUERY and UPDATE requests.
`static String`	`AT_ONCE` Query hint indicating whether or not a JOIN (including SERVICE, SUB-SELECT, etc) should be run as an "atOnce" operator.
`static boolean`	`CACHE_ENABLED` FIXME Hack enables the cache feature if the describe cache is enabled.
`static String`	`CHUNK_SIZE` Sets the target chunk size (aka vector size) for the output buffer of the operator.
`static String`	`CONSTRUCT_DISTINCT_SPO` Query hint for disabling the DISTINCT SPO behavior for a CONSTRUCT QUERY (default true).
`static String`	`CUTOFF_LIMIT` Used to mark a statement pattern with a cutoff limit for how many elements (maximum) should be read from its access path.
`static int`	`DEFAULT_ACCESS_PATH_SAMPLE_LIMIT` Note: Set to ZERO to disable AP sampling for default and named graphs.
`static boolean`	`DEFAULT_ACCESS_PATH_SCAN_AND_FILTER` Note: To ALWAYS use either SCAN + FILTER or PARALLEL subquery, set `DEFAULT_ACCESS_PATH_SAMPLE_LIMIT` to ZERO (0) and set this to the desired method for named graph and default graph evaluation.
`static boolean`	`DEFAULT_ANALYTIC`
`static long`	`DEFAULT_ANALYTIC_MAX_MEMORY_PER_QUERY`
`static String`	`DEFAULT_AST_OPTIMIZER_CLASS`
`static boolean`	`DEFAULT_CONSTRUCT_DISTINCT_SPO`
`static boolean`	`DEFAULT_DEFAULT_GRAPH_DISTINCT_FILTER`
`static boolean`	`DEFAULT_DESCRIBE_CACHE`
`static int`	`DEFAULT_DESCRIBE_ITERATION_LIMIT`
`static DescribeModeEnum`	`DEFAULT_DESCRIBE_MODE`
`static int`	`DEFAULT_DESCRIBE_STATEMENT_LIMIT`
`static boolean`	`DEFAULT_DISTINCT_TERM_SCAN_OPTIMIZER`
`static boolean`	`DEFAULT_FAST_RANGE_COUNT_OPTIMIZER`
`static FilterExistsModeEnum`	`DEFAULT_FILTER_EXISTS` Note: The historical behavior up through bigdata release 1.3.1 is `FilterExistsModeEnum.VectoredSubPlan`.
`static String`	`DEFAULT_GRAPH_DISTINCT_FILTER` By default, a DISTINCT filter is applied when evaluating access paths against the default graph, for correctness reasons.
`static boolean`	`DEFAULT_HASH_JOIN`
`static boolean`	`DEFAULT_MERGE_JOIN`
`static boolean`	`DEFAULT_NATIVE_DISTINCT_SOLUTIONS`
`static boolean`	`DEFAULT_NATIVE_DISTINCT_SPO`
`static long`	`DEFAULT_NATIVE_DISTINCT_SPO_THRESHOLD`
`static boolean`	`DEFAULT_NATIVE_HASH_JOINS`
`static boolean`	`DEFAULT_NORMALIZE_FILTER_EXPRESSIONS`
`static boolean`	`DEFAULT_OLD_JOIN_ORDER_OPTIMIZER`
`static double`	`DEFAULT_OPTIMISTIC`
`static QueryOptimizerEnum`	`DEFAULT_OPTIMIZER`
`static boolean`	`DEFAULT_PIPELINED_HASH_JOIN`
`static IChunkHandler`	`DEFAULT_QUERY_ENGINE_CHUNK_HANDLER`
`static boolean`	`DEFAULT_REGEX_MATCH_NON_STRING`
`static boolean`	`DEFAULT_REIFICATION_DONE_RIGHT`
`static boolean`	`DEFAULT_REMOTE_APS`
`static int`	`DEFAULT_RTO_LIMIT`
`static int`	`DEFAULT_RTO_NEDGES`
`static SampleIndex.SampleType`	`DEFAULT_RTO_SAMPLE_TYPE`
`static String`	`DESCRIBE_CACHE` When `true` a DESCRIBE cache will be maintained.
`static String`	`DESCRIBE_ITERATION_LIMIT` For iterative `DescribeModeEnum`s, this property places a limit on the number of iterative expansions that will be performed before the DESCRIBE query is cut off, providing that the limit on the maximum #of statements in the description is also satisfied (the cut off requires that both limits are reached).
`static String`	`DESCRIBE_MODE` Query hint controls the manner in which a DESCRIBE query is evaluated.
`static String`	`DESCRIBE_STATEMENT_LIMIT` For iterative `DescribeModeEnum`s, this property places a limit on the number of statements that will be accumulated before the DESCRIBE query is cut off, providing that the limit on the maximum #of iterations in the description is also satisfied (the cut off requires that both limits are reached).
`static String`	`DISTINCT_TERM_SCAN_OPTIMIZER` The name of an property that may be used to enable or disable the `ASTDistinctTermScanOptimizer`.
`static String`	`FAST_RANGE_COUNT_OPTIMIZER` The name of an property that may be used to enable or disable the `ASTFastRangeCountOptimizer`.
`static String`	`FILTER_EXISTS` Used to specify the query plan for FILTER (NOT) EXISTS.
`static String`	`GEARING` `https://jira.blazegraph.com/browse/BLZG-2089` Hint that allows to choose the gearing that is used for evaluating property paths.
`static String`	`GEARING_FORWARD`
`static String`	`GEARING_REVERSE`
`static String`	`HASH_JOIN` Query hint to use a hash join against the access path for a given predicate.
`static String`	`HISTORY` Used to mark a predicate for historical read.
`static String`	`MAX_PARALLEL` The maximum parallelism for the operator within the query.
`static String`	`MERGE_JOIN` When `true`, a merge-join pattern will be recognized if it appears in a join group.
`static String`	`NAMESPACE` The namespace for the bigdata query hints.
`static String`	`NATIVE_DISTINCT_SOLUTIONS` When `true`, will use the version of DISTINCT SOLUTIONS based on the `HTree` and the native (C process) heap.
`static String`	`NATIVE_DISTINCT_SPO` When `true` and the range count of the default graph access path exceeds the `NATIVE_DISTINCT_SPO_THRESHOLD`, will use the version of DISTINCT SPO for a hash join against a DEFAULT GRAPH access path based on the `HTree` and the native (C process) heap.
`static String`	`NATIVE_DISTINCT_SPO_THRESHOLD` The minimum range count for a default graph access path before the native DISTINCT SPO filter will be used.
`static String`	`NATIVE_HASH_JOINS` When `true`, use hash index operations based on the `HTree` and backed by the native (C process) heap.
`static String`	`NORMALIZE_FILTER_EXPRESSIONS` Switch to disable normalization/decomposition of FILTER expressions.
`static String`	`OLD_JOIN_ORDER_OPTIMIZER` Switch to re-enable old, `ASTJoinOrderByTypeOptimizer` (which was the predecessor of the `ASTJoinGroupOrderOptimizer`.
`static String`	`OPTIMISTIC` Query hint sets the optimistic threshold for the static join order optimizer.
`static String`	`OPTIMIZER` Specify the join order optimizer.
`static String`	`PIPELINED_HASH_JOIN` Prefer pipelined hash join over its normal, non-pipelined variant.
`static String`	`QUERY_ENGINE_CHUNK_HANDLER` Controls where the intermediate solutions output by operators will be stored.
`static String`	`QUERYID` The `UUID` to be assigned to the `IRunningQuery` (optional).
`static String`	`RANGE_SAFE` Used to mark a predicate as "range safe" - that is, we can safely apply the range bop to constrain the predicate.
`static String`	`REGEX_MATCH_NON_STRING` `https://jira.blazegraph.com/browse/BLZG-1200` `https://www.w3.org/TR/sparql11-query/#func-regex` `https://www.w3.org/TR/sparql11-query/#restrictString` By default, regex is only applied to Literal String values.
`static String`	`REIFICATION_DONE_RIGHT` Option controls whether or not the proposed SPARQL extension for reification done right is enabled.
`static String`	`REMOTE_APS` When `true`, force the use of REMOTE access paths in scale-out joins.
`static String`	`RTO_LIMIT` The limit for sampling a vertex and the initial limit for cutoff join evaluation (default 100).
`static String`	`RTO_NEDGES` The nedges edges of the join graph having the lowest cardinality will be used to generate the initial join paths (default ).
`static String`	`RTO_SAMPLE_TYPE` The sampling bias for the runtime query optimizer.
`static String`	`RUN_FIRST` This query hint may be applied to any `IJoinNode` and marks a particular join to be run first among in a particular group.
`static String`	`RUN_LAST` This query hint may be applied to any `IJoinNode` and marks a particular join to be run last among in a particular group.
`static String`	`RUN_ONCE` Query hint indicating whether or not a Sub-Select should be transformed into a named subquery, lifting its evaluation out of the main body of the query and replacing the subquery with an INCLUDE.

- Field Detail
  - NAMESPACE
```
static final String NAMESPACE
```
    The namespace for the bigdata query hints.
    
    See Also:
    Constant Field Values
  - OPTIMIZER
```
static final String OPTIMIZER
```
    Specify the join order optimizer. For example, you can disable the query optimizer within some join group using
```
 hint:Group hint:optimizer "None".
 
```
    Disabling the join order optimizer can be useful if you have a query for which the static optimizer is producing a inefficient join ordering. With the query optimizer disabled for that query, the joins will be run in the order given. This makes it possible for you to decide on the right join ordering for that query.
    See Also:
    QueryOptimizerEnum, Constant Field Values
  - DEFAULT_OPTIMIZER
```
static final QueryOptimizerEnum DEFAULT_OPTIMIZER
```
  - RTO_SAMPLE_TYPE
```
static final String RTO_SAMPLE_TYPE
```
    The sampling bias for the runtime query optimizer. Dense sampling maximizes index locality but reduces robustness to correlations that do not exist in the head of the access path key range. Random sampling maximizes robustness, but pays a heavy IO cost. Even sampling also increases robustness, but will visit every Nth tuple and pays a heavy IO cost as a result. Thus dense sampling should be much faster but random or even sampling should detect bias that might not otherwise be exposed to the runtime query optimizer.
    
    See Also:
    SampleIndex.SampleType, Constant Field Values
  - DEFAULT_RTO_SAMPLE_TYPE
```
static final SampleIndex.SampleType DEFAULT_RTO_SAMPLE_TYPE
```
  - RTO_LIMIT
```
static final String RTO_LIMIT
```
    The limit for sampling a vertex and the initial limit for cutoff join evaluation (default 100). A larger limit and a random sample will provide a more accurate estimate of the cost of the join paths but are increase the runtime overhead of the RTO optimizer. Smaller value can lead to underflow in the cardinality estimates of the cutoff joins resulting in a longer execution time for the RTO since more paths may be explored or the explored paths must be deepened in order to differentiate their costs. Values corresponding to up to the expected number of triples on an index page should have the same IO cost since there will be a single page read for the vertex and the output of the join will be cutoff once the desired number of join results has been produced.
    
    See Also:
    Constant Field Values
  - DEFAULT_RTO_LIMIT
```
static final int DEFAULT_RTO_LIMIT
```
    See Also:
    Constant Field Values
  - RTO_NEDGES
```
static final String RTO_NEDGES
```
    The nedges edges of the join graph having the lowest cardinality will be used to generate the initial join paths (default ). This must be a positive integer. The edges in the join graph are sorted in order of increasing cardinality and up to nedges of those edges having the lowest cardinality are used to form the initial set of join paths. For each edge selected to form a join path, the starting vertex will be the vertex of that edge having the lower cardinality. If ONE (1), then only those join paths that start with the two vertices having the lowest cardinality will be explored (this was the published behavior for ROX). When greater than ONE, a broader search of the join paths will be carried out.
    
    See Also:
    Constant Field Values
  - DEFAULT_RTO_NEDGES
```
static final int DEFAULT_RTO_NEDGES
```
    See Also:
    Constant Field Values
  - OPTIMISTIC
```
static final String OPTIMISTIC
```
    Query hint sets the optimistic threshold for the static join order optimizer.
    
    See Also:
    Constant Field Values
  - DEFAULT_OPTIMISTIC
```
static final double DEFAULT_OPTIMISTIC
```
  - ANALYTIC
```
static final String ANALYTIC
```
    When true, enables all query hints pertaining to analytic query patterns. When false, those features are disabled.
    Note: This query hint MUST be applied in the QueryHintScope.Query . Hash indices are often created by one operator and then consumed by another so the same kinds of hash indices MUST be used throughout the query.
```
 hint:Query hint:analytic "true".
 
```
    The default is false. The default may be overridden using the environment variable named
```
 com.bigdata.rdf.sparql.ast.QueryHints.analytic
 
```
    See Also:
    NATIVE_DISTINCT_SPO, NATIVE_DISTINCT_SOLUTIONS, NATIVE_HASH_JOINS, MERGE_JOIN, Add System property to enable analytic query mode. , Constant Field Values
  - DEFAULT_ANALYTIC
```
static final boolean DEFAULT_ANALYTIC
```
  - ANALYTIC_MAX_MEMORY_PER_QUERY
```
static final String ANALYTIC_MAX_MEMORY_PER_QUERY
```
    The maximum amount of native heap memory that may be allocated for a single query when using the analytic query mode -or- ZERO (0L) if no limit should be imposed. When non-zero, queries that exceed this limit will be broken with a memory allocation exception. Together with a limit on the number of concurrent queries, this may be used to limit the amount of native memory consumed by the query engine.
    The default is ZERO (0) which implies no limit. The default may be overridden using the environment variable named
```
 com.bigdata.rdf.sparql.ast.QueryHints.analyticMaxMemoryPerQuery
 
```
    Native memory allocations are made using a DirectBufferPool. The per-query limit will be rounded up to a multiple of buffers based on the configured buffer capacity. The default is a 1MB buffer, so the granularity of the limit is multiples of 1MB.
    See Also:
    DirectBufferPool, Per query memory limit for analytic query mode. , Constant Field Values
  - DEFAULT_ANALYTIC_MAX_MEMORY_PER_QUERY
```
static final long DEFAULT_ANALYTIC_MAX_MEMORY_PER_QUERY
```
  - QUERY_ENGINE_CHUNK_HANDLER
```
static final String QUERY_ENGINE_CHUNK_HANDLER
```
    Controls where the intermediate solutions output by operators will be stored. Options include the managed object heap, the native heap, or potentially some policy which stores things dynamically depending on the size of the chunk or the total memory burden on the query engine.
    The effective value of this property is determined by effective value of the system property "queryEngineChunkHandler".
    
    See Also:
    Vector query engine on native heap., Constant Field Values
  - DEFAULT_QUERY_ENGINE_CHUNK_HANDLER
```
static final IChunkHandler DEFAULT_QUERY_ENGINE_CHUNK_HANDLER
```
  - NATIVE_DISTINCT_SOLUTIONS
```
static final String NATIVE_DISTINCT_SOLUTIONS
```
    When true, will use the version of DISTINCT SOLUTIONS based on the HTree and the native (C process) heap. When false, use the version based on a JVM collection class. The JVM version does not scale-up as well, but it offers higher concurrency.
    
    See Also:
    Constant Field Values
  - DEFAULT_NATIVE_DISTINCT_SOLUTIONS
```
static final boolean DEFAULT_NATIVE_DISTINCT_SOLUTIONS
```
  - NATIVE_DISTINCT_SPO
```
static final String NATIVE_DISTINCT_SPO
```
    When true and the range count of the default graph access path exceeds the NATIVE_DISTINCT_SPO_THRESHOLD, will use the version of DISTINCT SPO for a hash join against a DEFAULT GRAPH access path based on the HTree and the native (C process) heap. When false, use the version based on a JVM collection class. The JVM version does not scale-up as well.
    
    See Also:
    Constant Field Values
  - DEFAULT_NATIVE_DISTINCT_SPO
```
static final boolean DEFAULT_NATIVE_DISTINCT_SPO
```
  - NATIVE_DISTINCT_SPO_THRESHOLD
```
static final String NATIVE_DISTINCT_SPO_THRESHOLD
```
    The minimum range count for a default graph access path before the native DISTINCT SPO filter will be used.
    
    See Also:
    NATIVE_DISTINCT_SPO, Constant Field Values
  - DEFAULT_NATIVE_DISTINCT_SPO_THRESHOLD
```
static final long DEFAULT_NATIVE_DISTINCT_SPO_THRESHOLD
```
    See Also:
    Constant Field Values
  - NATIVE_HASH_JOINS
```
static final String NATIVE_HASH_JOINS
```
    When true, use hash index operations based on the HTree and backed by the native (C process) heap. When false, use hash index operations based on the Java collection classes. The HTree is more scalable but has higher overhead for small cardinality hash joins.
    Note: This query hint MUST be applied in the QueryHintScope.Query . Hash indices are often created by one operator and then consumed by another so the same kinds of hash indices MUST be used throughout the query.
    
    See Also:
    Constant Field Values
  - DEFAULT_NATIVE_HASH_JOINS
```
static final boolean DEFAULT_NATIVE_HASH_JOINS
```
  - MERGE_JOIN
```
static final String MERGE_JOIN
```
    When true, a merge-join pattern will be recognized if it appears in a join group. When false, this can still be selectively enabled using a query hint.
    
    See Also:
    Constant Field Values
  - DEFAULT_MERGE_JOIN
```
static final boolean DEFAULT_MERGE_JOIN
```
    See Also:
    Constant Field Values
  - CONSTRUCT_DISTINCT_SPO
```
static final String CONSTRUCT_DISTINCT_SPO
```
    Query hint for disabling the DISTINCT SPO behavior for a CONSTRUCT QUERY (default true). When disabled, the CONSTRUCT will NOT eliminate duplicate triples from the constructed graph. Note that CONSTRUCT automatically avoids duplicate detection and removal for cases where a CONSTRUCT is already "obviously" distinct. Thus this query hint is only required if you have a very large graph and want to stream the graph out without imposing the distinct SPO filter. You can also use ANALYTIC query hint to use the native heap for the DISTINCT SPO filter. Thus this query hint is really only for very large graphs.
    
    See Also:
    (performance of dumping single graph), Constant Field Values
  - DEFAULT_CONSTRUCT_DISTINCT_SPO
```
static final boolean DEFAULT_CONSTRUCT_DISTINCT_SPO
```
    See Also:
    Constant Field Values
  - REMOTE_APS
```
static final String REMOTE_APS
```
    When true, force the use of REMOTE access paths in scale-out joins. This is intended as a tool when analyzing query patterns in scale-out. It should normally be false.
    
    See Also:
    Constant Field Values
  - DEFAULT_REMOTE_APS
```
static final boolean DEFAULT_REMOTE_APS
```
    See Also:
    https://sourceforge.net/apps/trac/bigdata/ticket/380#comment:4, Constant Field Values
  - ACCESS_PATH_SAMPLE_LIMIT
```
static final String ACCESS_PATH_SAMPLE_LIMIT
```
    The #of samples to take when comparing the cost of a SCAN with an IN filter to as-bound evaluation for each graph in the data set (default 100). The samples are taken from the data set. Each sample is a graph (aka context) in the data set. The range counts and estimated cost to visit the AP for each of the sampled contexts are combined to estimate the total cost of visiting all of the contexts in the NG or DG access path.
    When ZERO (0), no cost estimation will be performed and the named graph or default graph join will always use approach specified by the boolean ACCESS_PATH_SCAN_AND_FILTER.
    
    See Also:
    Constant Field Values
  - DEFAULT_ACCESS_PATH_SAMPLE_LIMIT
```
static final int DEFAULT_ACCESS_PATH_SAMPLE_LIMIT
```
    Note: Set to ZERO to disable AP sampling for default and named graphs.
    
    See Also:
    Constant Field Values
  - ACCESS_PATH_SCAN_AND_FILTER
```
static final String ACCESS_PATH_SCAN_AND_FILTER
```
    For named and default graph access paths where access path cost estimation is disabled by setting the ACCESS_PATH_SAMPLE_LIMIT to ZERO (0), this query hint determines whether a SCAN + FILTER or PARALLEL SUBQUERY (aka as-bound data set join) approach.
    
    See Also:
    Constant Field Values
  - DEFAULT_ACCESS_PATH_SCAN_AND_FILTER
```
static final boolean DEFAULT_ACCESS_PATH_SCAN_AND_FILTER
```
    Note: To ALWAYS use either SCAN + FILTER or PARALLEL subquery, set DEFAULT_ACCESS_PATH_SAMPLE_LIMIT to ZERO (0) and set this to the desired method for named graph and default graph evaluation. Note that you MAY still override this behavior within a given scope using a query hint.
    
    See Also:
    Constant Field Values
  - QUERYID
```
static final String QUERYID
```
    The UUID to be assigned to the IRunningQuery (optional). This query hint makes it possible for the application to assign the UUID under which the query will run. This can be used to locate the IRunningQuery using its UUID and gather metadata about the query during its evaluation. The IRunningQuery may be used to monitor the query or even cancel a query.
    The UUID of each query MUST be distinct. When using this query hint the application assumes responsibility for applying UUID.randomUUID() to generate a unique UUID for the query. The application may then discover the IRunningQuery using QueryEngineFactory#getQueryController(com.bigdata.journal.IIndexManager) and QueryEngine.getQuery(UUID).
    Note: The openrdf iteration interface has a close() method, but this can not be invoked until hasNext() has run and the first solution has been materialized. For queries which use an "at-once" operator, such as ORDER BY, the query will run to completion before hasNext() returns. This means that it is effectively impossible to interrupt a running query which uses an ORDER BY clause from the SAIL. However, applications MAY use this query hint to discovery the IRunningQuery interface and cancel the query.
```
 hint:Query hint:queryId "36cff615-aaea-418a-bb47-006699702e45"
 
```
    See Also:
    https://sourceforge.net/apps/trac/bigdata/ticket/283, Constant Field Values
  - RUN_FIRST
```
static final String RUN_FIRST
```
    This query hint may be applied to any IJoinNode and marks a particular join to be run first among in a particular group. Only one "run first" join is permitted in a given group. This query hint is not permitted on optional joins. This hint must be used with QueryHintScope.Prior.
    
    See Also:
    Constant Field Values
  - RUN_LAST
```
static final String RUN_LAST
```
    This query hint may be applied to any IJoinNode and marks a particular join to be run last among in a particular group. Only one "run last" join is permitted in a given group. This hint must be used with QueryHintScope.Prior.
    
    See Also:
    Constant Field Values
  - RUN_ONCE
```
static final String RUN_ONCE
```
    Query hint indicating whether or not a Sub-Select should be transformed into a named subquery, lifting its evaluation out of the main body of the query and replacing the subquery with an INCLUDE. This hint must be used with QueryHintScope.SubQuery.
    This is similar to 'atOnce' evaluation, but creates a different query plan by lifting out a named subquery. The RUN_ONCE query hint is only supported for QueryHintScope.SubQuery while AT_ONCE query hint can be applied to other things as well.
    When true, the subquery will be lifted out. When false, the subquery will not be lifted unless other semantics require that it be lifted out regardless.
    For example, the following may be used to lift out the sub-select in which it appears into a NamedSubqueryRoot. The lifted expression will be executed exactly once.
```
 hint:SubQuery hint:runOnce "true" .
 
```
    See Also:
    AT_ONCE, Constant Field Values
  - AT_ONCE
```
static final String AT_ONCE
```
    Query hint indicating whether or not a JOIN (including SERVICE, SUB-SELECT, etc) should be run as an "atOnce" operator. All solutions for an "atOnce" operator are materialized before the operator is evaluated. It is then evaluated against those materialized solutions exactly once.
    Note: "atOnce" evaluation is a general property of the query engine. This query hint does not change the structure of the query plan, but simply serves as a directive to the query engine that it should buffer all source solutions before running the operator. This is more general purpose than the RUN_ONCE query hint.
    This query hint is allowed in any scope. The hint is transferred as an annotation onto all query plan operators generated from the annotated scope.
    
    See Also:
    TODO "Blocked" evaluation. Blocked evaluation is similar to at-once evaluation but lacks the strong guarantee of that the operator will run exactly once. For blocked evaluation, the solutions to be fed to the operator are buffered up to a memory limit. If that memory limit is reached, then the buffered solutions are vectored through the operator. If all solutions can be buffered within the memory limit then "at-once" and "blocked" evaluation amount to the same thing., Constant Field Values
  - CHUNK_SIZE
```
static final String CHUNK_SIZE
```
    Sets the target chunk size (aka vector size) for the output buffer of the operator.
    This query hint does not change the structure of the query plan, but simply serves as a directive to the query engine that it should allocate an output buffer for the operator that will emit chunks of the indicated target capacity. This query hint is allowed in any scope, but is generally used to effect the behavior of a join group, a subquery, or the entire query.
    
    See Also:
    BufferAnnotations.CHUNK_CAPACITY, Constant Field Values
  - MAX_PARALLEL
```
static final String MAX_PARALLEL
```
    The maximum parallelism for the operator within the query.
    Note: "maxParallel" evaluation is a general property of the query engine. This query hint does not change the structure of the query plan, but simply serves as a directive to the query engine that it should not allow more than the indicated number of parallel instances of the operator to execute concurrently. This query hint is allowed in any scope. The hint is transferred as an annotation onto all query plan operators generated from the annotated scope.
    
    See Also:
    PipelineOp.Annotations#MAX_PARALLEL, Constant Field Values
  - HASH_JOIN
```
static final String HASH_JOIN
```
    Query hint to use a hash join against the access path for a given predicate. Hash joins should be enabled once it is recognized that the #of as-bound probes of the predicate will approach or exceed the range count of the predicate.
    Note: HashJoinAnnotations.JOIN_VARS MUST also be specified for the predicate. The join variable(s) are variables which are (a) bound by the predicate and (b) are known bound in the source solutions. The query planner has the necessary context to figure this out based on the structure of the query plan and the join evaluation order.
    
    See Also:
    Constant Field Values
  - DEFAULT_HASH_JOIN
```
static final boolean DEFAULT_HASH_JOIN
```
    See Also:
    Constant Field Values
  - DESCRIBE_CACHE
```
static final String DESCRIBE_CACHE
```
    When true a DESCRIBE cache will be maintained. This can accelerate DESCRIBE queries, linked data queries (which are mapped to a DESCRIBE query by the NSS), and potentially accelerate star-joins (if the query plan is rewritten to hit the DESCRIBE cache and obtain the materialized joins from it, but this is best done with a fully materialized and synchronously maintained DESCRIBE cache).
    
    See Also:
    DESCRIBE CACHE , Constant Field Values
  - DEFAULT_DESCRIBE_CACHE
```
static final boolean DEFAULT_DESCRIBE_CACHE
```
    See Also:
    Constant Field Values
  - CACHE_ENABLED
```
static final boolean CACHE_ENABLED
```
    FIXME Hack enables the cache feature if the describe cache is enabled.
    
    See Also:
    CacheConnectionFactory.getCacheConnection(QueryEngine), Constant Field Values
  - DESCRIBE_MODE
```
static final String DESCRIBE_MODE
```
    Query hint controls the manner in which a DESCRIBE query is evaluated.
    
    See Also:
    DescribeModeEnum, DEFAULT_DESCRIBE_MODE, Concise Bounded Description , Constant Field Values
  - DEFAULT_DESCRIBE_MODE
```
static final DescribeModeEnum DEFAULT_DESCRIBE_MODE
```
  - DESCRIBE_ITERATION_LIMIT
```
static final String DESCRIBE_ITERATION_LIMIT
```
    For iterative DescribeModeEnums, this property places a limit on the number of iterative expansions that will be performed before the DESCRIBE query is cut off, providing that the limit on the maximum #of statements in the description is also satisfied (the cut off requires that both limits are reached). May be ZERO (0) for NO limit.
    
    See Also:
    DESCRIBE_MODE, DESCRIBE_STATEMENT_LIMIT, Constant Field Values
  - DEFAULT_DESCRIBE_ITERATION_LIMIT
```
static final int DEFAULT_DESCRIBE_ITERATION_LIMIT
```
    See Also:
    Constant Field Values
  - DESCRIBE_STATEMENT_LIMIT
```
static final String DESCRIBE_STATEMENT_LIMIT
```
    For iterative DescribeModeEnums, this property places a limit on the number of statements that will be accumulated before the DESCRIBE query is cut off, providing that the limit on the maximum #of iterations in the description is also satisfied (the cut off requires that both limits are reached). May be ZERO (0) for NO limit.
    
    See Also:
    DESCRIBE_MODE, DESCRIBE_ITERATION_LIMIT, Constant Field Values
  - DEFAULT_DESCRIBE_STATEMENT_LIMIT
```
static final int DEFAULT_DESCRIBE_STATEMENT_LIMIT
```
    See Also:
    Constant Field Values
  - REIFICATION_DONE_RIGHT
```
static final String REIFICATION_DONE_RIGHT
```
    Option controls whether or not the proposed SPARQL extension for reification done right is enabled.
    
    See Also:
    Reification Done Right, Constant Field Values
  - DEFAULT_REIFICATION_DONE_RIGHT
```
static final boolean DEFAULT_REIFICATION_DONE_RIGHT
```
    See Also:
    Constant Field Values
  - RANGE_SAFE
```
static final String RANGE_SAFE
```
    Used to mark a predicate as "range safe" - that is, we can safely apply the range bop to constrain the predicate. This can only be used currently when there is a single datatype for attribute values.
    
    See Also:
    Constant Field Values
  - CUTOFF_LIMIT
```
static final String CUTOFF_LIMIT
```
    Used to mark a statement pattern with a cutoff limit for how many elements (maximum) should be read from its access path. This effectively limits the input into the join.
    
    See Also:
    JoinAnnotations.LIMIT, Constant Field Values
  - FILTER_EXISTS
```
static final String FILTER_EXISTS
```
    Used to specify the query plan for FILTER (NOT) EXISTS. There are two basic plans: vectored sub-plan and subquery with LIMIT ONE. Each plan has its advantages.
    
    See Also:
    FilterExistsModeEnum, bad performance for FILTER EXISTS , Constant Field Values
  - DEFAULT_FILTER_EXISTS
```
static final FilterExistsModeEnum DEFAULT_FILTER_EXISTS
```
    Note: The historical behavior up through bigdata release 1.3.1 is FilterExistsModeEnum.VectoredSubPlan.
  - FAST_RANGE_COUNT_OPTIMIZER
```
static final String FAST_RANGE_COUNT_OPTIMIZER
```
    The name of an property that may be used to enable or disable the ASTFastRangeCountOptimizer.
    
    See Also:
    Rewrite SELECT COUNT(...) (DISTINCT|REDUCED) {single-triple-pattern} as ESTCARD , Constant Field Values
  - DEFAULT_FAST_RANGE_COUNT_OPTIMIZER
```
static final boolean DEFAULT_FAST_RANGE_COUNT_OPTIMIZER
```
  - DISTINCT_TERM_SCAN_OPTIMIZER
```
static final String DISTINCT_TERM_SCAN_OPTIMIZER
```
    The name of an property that may be used to enable or disable the ASTDistinctTermScanOptimizer.
    
    See Also:
    DISTINCT PREDICATEs query is slow , Constant Field Values
  - DEFAULT_DISTINCT_TERM_SCAN_OPTIMIZER
```
static final boolean DEFAULT_DISTINCT_TERM_SCAN_OPTIMIZER
```
  - AST_OPTIMIZER_CLASS
```
static final String AST_OPTIMIZER_CLASS
```
    The name of the subclass derived from ASTOptimizerList that will be used to optimize SPARQL QUERY and UPDATE requests. This class MUST implement a public zero argument constructor.
    
    See Also:
    DEFAULT_AST_OPTIMIZER_CLASS, Hook to configure the ASTOptimizerList , Constant Field Values
  - DEFAULT_AST_OPTIMIZER_CLASS
```
static final String DEFAULT_AST_OPTIMIZER_CLASS
```
  - OLD_JOIN_ORDER_OPTIMIZER
```
static final String OLD_JOIN_ORDER_OPTIMIZER
```
    Switch to re-enable old, ASTJoinOrderByTypeOptimizer (which was the predecessor of the ASTJoinGroupOrderOptimizer. By default, the new strategy is enabled.
    
    See Also:
    OLD_JOIN_ORDER_OPTIMIZER, Constant Field Values
  - HISTORY
```
static final String HISTORY
```
    Used to mark a predicate for historical read. When history mode is enabled, statements are not actually deleted, they are just marked as history using StatementEnum.History. By default these historical SPOs are hidden from view during read.
    
    See Also:
    Constant Field Values
  - DEFAULT_OLD_JOIN_ORDER_OPTIMIZER
```
static final boolean DEFAULT_OLD_JOIN_ORDER_OPTIMIZER
```
  - NORMALIZE_FILTER_EXPRESSIONS
```
static final String NORMALIZE_FILTER_EXPRESSIONS
```
    Switch to disable normalization/decomposition of FILTER expressions. There might be two scenarios where decomposition of FILTER expressions comes with a significant overhead: (i) whenever large complex FILTERs are used or (ii) when there are unselective parts of FILTERs that are evaluated too early when decomposing FILTERs (cd. SP2B Q6).
    
    See Also:
    DEFAULT_NORMALIZE_FILTER_EXPRESSIONS, Constant Field Values
  - DEFAULT_NORMALIZE_FILTER_EXPRESSIONS
```
static final boolean DEFAULT_NORMALIZE_FILTER_EXPRESSIONS
```
  - PIPELINED_HASH_JOIN
```
static final String PIPELINED_HASH_JOIN
```
    Prefer pipelined hash join over its normal, non-pipelined variant. If set to true, this parameter can still be overridden by query hint. If set to false, the pipelined hash join will only be used in some exceptional cases (i.e., for LIMIT queries in which pipelining brings a clear benefit).
    
    See Also:
    Constant Field Values
  - DEFAULT_PIPELINED_HASH_JOIN
```
static final boolean DEFAULT_PIPELINED_HASH_JOIN
```
  - DEFAULT_GRAPH_DISTINCT_FILTER
```
static final String DEFAULT_GRAPH_DISTINCT_FILTER
```
    By default, a DISTINCT filter is applied when evaluating access paths against the default graph, for correctness reasons. The hint (or the respective system property) can be used to disabled the distinct filter, in order to accelerate default graph queries. This can be done whenever it is known that NO triple occurs in more than one named graph. BE CAREFUL: if this condition does not hold and the filter is disabled, wrong query results (caused by duplicates) will be the consequence. Note that this hint only takes effect in quads mode.
    
    See Also:
    Constant Field Values
  - DEFAULT_DEFAULT_GRAPH_DISTINCT_FILTER
```
static final boolean DEFAULT_DEFAULT_GRAPH_DISTINCT_FILTER
```
  - REGEX_MATCH_NON_STRING
```
static final String REGEX_MATCH_NON_STRING
```
    https://jira.blazegraph.com/browse/BLZG-1200 https://www.w3.org/TR/sparql11-query/#func-regex https://www.w3.org/TR/sparql11-query/#restrictString By default, regex is only applied to Literal String values. Enabling this query hint will attempt to autoconvert non-String literals into their string value. This is the equivalent of always using the str(...) function.
    
    See Also:
    Constant Field Values
  - DEFAULT_REGEX_MATCH_NON_STRING
```
static final boolean DEFAULT_REGEX_MATCH_NON_STRING
```
  - GEARING
```
static final String GEARING
```
    https://jira.blazegraph.com/browse/BLZG-2089 Hint that allows to choose the gearing that is used for evaluating property paths. Possible values are: - auto: let the optimizer choose (this is the default) - forward: choose forward gearing, i.e. start out with the subject - reverse: choose backward gearing, i.e. start out with the object
    
    See Also:
    Constant Field Values
  - GEARING_FORWARD
```
static final String GEARING_FORWARD
```
    See Also:
    Constant Field Values
  - GEARING_REVERSE
```
static final String GEARING_REVERSE
```
    See Also:
    Constant Field Values

Interface QueryHints

Field Summary

Field Detail

NAMESPACE

OPTIMIZER

DEFAULT_OPTIMIZER

RTO_SAMPLE_TYPE

DEFAULT_RTO_SAMPLE_TYPE

RTO_LIMIT

DEFAULT_RTO_LIMIT

RTO_NEDGES

DEFAULT_RTO_NEDGES

OPTIMISTIC

DEFAULT_OPTIMISTIC

ANALYTIC

DEFAULT_ANALYTIC

ANALYTIC_MAX_MEMORY_PER_QUERY

DEFAULT_ANALYTIC_MAX_MEMORY_PER_QUERY

QUERY_ENGINE_CHUNK_HANDLER

DEFAULT_QUERY_ENGINE_CHUNK_HANDLER

NATIVE_DISTINCT_SOLUTIONS

DEFAULT_NATIVE_DISTINCT_SOLUTIONS

NATIVE_DISTINCT_SPO

DEFAULT_NATIVE_DISTINCT_SPO

NATIVE_DISTINCT_SPO_THRESHOLD

DEFAULT_NATIVE_DISTINCT_SPO_THRESHOLD

NATIVE_HASH_JOINS

DEFAULT_NATIVE_HASH_JOINS

MERGE_JOIN

DEFAULT_MERGE_JOIN

CONSTRUCT_DISTINCT_SPO

DEFAULT_CONSTRUCT_DISTINCT_SPO

REMOTE_APS

DEFAULT_REMOTE_APS

ACCESS_PATH_SAMPLE_LIMIT

DEFAULT_ACCESS_PATH_SAMPLE_LIMIT

ACCESS_PATH_SCAN_AND_FILTER

DEFAULT_ACCESS_PATH_SCAN_AND_FILTER

QUERYID

RUN_FIRST

RUN_LAST

RUN_ONCE

AT_ONCE

CHUNK_SIZE

MAX_PARALLEL

HASH_JOIN

DEFAULT_HASH_JOIN

DESCRIBE_CACHE

DEFAULT_DESCRIBE_CACHE

CACHE_ENABLED

DESCRIBE_MODE

DEFAULT_DESCRIBE_MODE

DESCRIBE_ITERATION_LIMIT

DEFAULT_DESCRIBE_ITERATION_LIMIT

DESCRIBE_STATEMENT_LIMIT

DEFAULT_DESCRIBE_STATEMENT_LIMIT

REIFICATION_DONE_RIGHT

DEFAULT_REIFICATION_DONE_RIGHT

RANGE_SAFE

CUTOFF_LIMIT

FILTER_EXISTS

DEFAULT_FILTER_EXISTS

FAST_RANGE_COUNT_OPTIMIZER

DEFAULT_FAST_RANGE_COUNT_OPTIMIZER

DISTINCT_TERM_SCAN_OPTIMIZER

DEFAULT_DISTINCT_TERM_SCAN_OPTIMIZER

AST_OPTIMIZER_CLASS

DEFAULT_AST_OPTIMIZER_CLASS

OLD_JOIN_ORDER_OPTIMIZER

HISTORY

DEFAULT_OLD_JOIN_ORDER_OPTIMIZER

NORMALIZE_FILTER_EXPRESSIONS

DEFAULT_NORMALIZE_FILTER_EXPRESSIONS

PIPELINED_HASH_JOIN

DEFAULT_PIPELINED_HASH_JOIN

DEFAULT_GRAPH_DISTINCT_FILTER

DEFAULT_DEFAULT_GRAPH_DISTINCT_FILTER

REGEX_MATCH_NON_STRING

DEFAULT_REGEX_MATCH_NON_STRING

GEARING