java.lang.Object
- com.arangodb.model.AqlQueryOptions

All Implemented Interfaces:

Cloneable
```
public final class AqlQueryOptions
extends Object
implements Cloneable
```
Author:

Mark Vollmary, Michele Rastelli

See Also:

API Documentation

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class AqlQueryOptions.Optimizer

static class AqlQueryOptions.Options

Constructor Summary

Constructors
Constructor Description

AqlQueryOptions()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`AqlQueryOptions`	`allowDirtyRead(Boolean allowDirtyRead)`
`AqlQueryOptions`	`allowRetry(Boolean allowRetry)`
`AqlQueryOptions`	`batchSize(Integer batchSize)`
`AqlQueryOptions`	`cache(Boolean cache)`
`AqlQueryOptions`	`clone()`
`AqlQueryOptions`	`count(Boolean count)`
`AqlQueryOptions`	`failOnWarning(Boolean failOnWarning)`
`AqlQueryOptions`	`fillBlockCache(Boolean fillBlockCache)`
`AqlQueryOptions`	`forceOneShardAttributeValue(String forceOneShardAttributeValue)`
`AqlQueryOptions`	`fullCount(Boolean fullCount)`
`Boolean`	`getAllowDirtyRead()`
`Boolean`	`getAllowRetry()`
`Integer`	`getBatchSize()`
`Map<String,Object>`	`getBindVars()`
`Boolean`	`getCache()`
`Boolean`	`getCount()`
`Boolean`	`getFailOnWarning()`
`Boolean`	`getFillBlockCache()`
`String`	`getForceOneShardAttributeValue()`
`Boolean`	`getFullCount()`
`Long`	`getIntermediateCommitCount()`
`Long`	`getIntermediateCommitSize()`
`Integer`	`getMaxPlans()`
`Long`	`getMaxTransactionSize()`
`Long`	`getMaxWarningCount()`
`Long`	`getMemoryLimit()`
`AqlQueryOptions.Options`	`getOptions()`
`Boolean`	`getProfile()`
`String`	`getQuery()`
`Collection<String>`	`getRules()`
`Double`	`getSatelliteSyncWait()`
`Collection<String>`	`getShardIds()`
`Boolean`	`getSkipInaccessibleCollections()`
`Boolean`	`getStream()`
`String`	`getStreamTransactionId()`
`Integer`	`getTtl()`
`AqlQueryOptions`	`intermediateCommitCount(Long intermediateCommitCount)`
`AqlQueryOptions`	`intermediateCommitSize(Long intermediateCommitSize)`
`AqlQueryOptions`	`maxPlans(Integer maxPlans)`
`AqlQueryOptions`	`maxRuntime(Double timeout)`
`AqlQueryOptions`	`maxTransactionSize(Long maxTransactionSize)`
`AqlQueryOptions`	`maxWarningCount(Long maxWarningCount)`
`AqlQueryOptions`	`memoryLimit(Long memoryLimit)`
`AqlQueryOptions`	`profile(Boolean profile)`
`AqlQueryOptions`	`query(String query)`
`AqlQueryOptions`	`rules(Collection<String> rules)`
`AqlQueryOptions`	`satelliteSyncWait(Double satelliteSyncWait)`
`AqlQueryOptions`	`shardIds(String... shardIds)`	Restrict query to shards by given ids.
`AqlQueryOptions`	`skipInaccessibleCollections(Boolean skipInaccessibleCollections)`
`AqlQueryOptions`	`stream(Boolean stream)`
`AqlQueryOptions`	`streamTransactionId(String streamTransactionId)`
`AqlQueryOptions`	`ttl(Integer ttl)`

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

- Constructor Detail
  - AqlQueryOptions
```
public AqlQueryOptions()
```
- Method Detail
  - getCount
```
public Boolean getCount()
```
  - count
```
public AqlQueryOptions count(Boolean count)
```
    Parameters:
    
    count - indicates whether the number of documents in the result set should be returned in the "count" attribute of the result. Calculating the "count" attribute might have a performance impact for some queries in the future so this option is turned off by default, and "count" is only returned when requested.
    
    Returns:
    
    options
  - getTtl
```
public Integer getTtl()
```
  - ttl
```
public AqlQueryOptions ttl(Integer ttl)
```
    Parameters:
    
    ttl - The time-to-live for the cursor (in seconds). The cursor will be removed on the server automatically after the specified amount of time. This is useful to ensure garbage collection of cursors that are not fully fetched by clients. If not set, a server-defined value will be used.
    
    Returns:
    
    options
  - getBatchSize
```
public Integer getBatchSize()
```
  - batchSize
```
public AqlQueryOptions batchSize(Integer batchSize)
```
    Parameters:
    
    batchSize - maximum number of result documents to be transferred from the server to the client in one roundtrip. If this attribute is not set, a server-controlled default value will be used. A batchSize value of 0 is disallowed.
    
    Returns:
    
    options
  - getMemoryLimit
```
public Long getMemoryLimit()
```
  - memoryLimit
```
public AqlQueryOptions memoryLimit(Long memoryLimit)
```
    Parameters:
    
    memoryLimit - the maximum number of memory (measured in bytes) that the query is allowed to use. If set, then the query will fail with error "resource limit exceeded" in case it allocates too much memory. A value of 0 indicates that there is no memory limit.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.1.0
  - getCache
```
public Boolean getCache()
```
  - cache
```
public AqlQueryOptions cache(Boolean cache)
```
    Parameters:
    
    cache - flag to determine whether the AQL query cache shall be used. If set to false, then any query cache lookup will be skipped for the query. If set to true, it will lead to the query cache being checked for the query if the query cache mode is either on or demand.
    
    Returns:
    
    options
  - getFillBlockCache
```
public Boolean getFillBlockCache()
```
  - fillBlockCache
```
public AqlQueryOptions fillBlockCache(Boolean fillBlockCache)
```
    Parameters:
    
    fillBlockCache - if set to true or not specified, this will make the query store the data it reads via the RocksDB storage engine in the RocksDB block cache. This is usually the desired behavior. The option can be set to false for queries that are known to either read a lot of data that would thrash the block cache, or for queries that read data known to be outside of the hot set. By setting the option to false, data read by the query will not make it into the RocksDB block cache if it is not already in there, thus leaving more room for the actual hot set.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.8.1
  - getBindVars
```
public Map<String,Object> getBindVars()
```
  - getQuery
```
public String getQuery()
```
  - query
```
public AqlQueryOptions query(String query)
```
    Parameters:
    
    query - the query which you want parse
    
    Returns:
    
    options
  - getFailOnWarning
```
public Boolean getFailOnWarning()
```
  - failOnWarning
```
public AqlQueryOptions failOnWarning(Boolean failOnWarning)
```
    Parameters:
    
    failOnWarning - When set to true, the query will throw an exception and abort instead of producing a warning. This option should be used during development to catch potential issues early. When the attribute is set to false, warnings will not be propagated to exceptions and will be returned with the query result. There is also a server configuration option --query.fail-on-warning for setting the default value for failOnWarning so it does not need to be set on a per-query level.
    
    Returns:
    
    options
  - maxRuntime
```
public AqlQueryOptions maxRuntime(Double timeout)
```
    Parameters:
    
    timeout - The query has to be executed within the given runtime or it will be killed. The value is specified in seconds. The default value is 0.0 (no timeout).
    
    Returns:
    
    options
  - getProfile
```
public Boolean getProfile()
```
    Returns:
    
    If set to true, then the additional query profiling information will be returned in the sub-attribute profile of the extra return attribute if the query result is not served from the query cache.
  - profile
```
public AqlQueryOptions profile(Boolean profile)
```
    Parameters:
    
    profile - If set to true, then the additional query profiling information will be returned in the sub-attribute profile of the extra return attribute if the query result is not served from the query cache.
    
    Returns:
    
    options
  - getMaxTransactionSize
```
public Long getMaxTransactionSize()
```
  - maxTransactionSize
```
public AqlQueryOptions maxTransactionSize(Long maxTransactionSize)
```
    Parameters:
    
    maxTransactionSize - Transaction size limit in bytes. Honored by the RocksDB storage engine only.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.2.0
  - getMaxWarningCount
```
public Long getMaxWarningCount()
```
  - maxWarningCount
```
public AqlQueryOptions maxWarningCount(Long maxWarningCount)
```
    Parameters:
    
    maxWarningCount - Limits the maximum number of warnings a query will return. The number of warnings a query will return is limited to 10 by default, but that number can be increased or decreased by setting this attribute.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.2.0
  - getIntermediateCommitCount
```
public Long getIntermediateCommitCount()
```
  - intermediateCommitCount
```
public AqlQueryOptions intermediateCommitCount(Long intermediateCommitCount)
```
    Parameters:
    
    intermediateCommitCount - Maximum number of operations after which an intermediate commit is performed automatically. Honored by the RocksDB storage engine only.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.2.0
  - getIntermediateCommitSize
```
public Long getIntermediateCommitSize()
```
  - intermediateCommitSize
```
public AqlQueryOptions intermediateCommitSize(Long intermediateCommitSize)
```
    Parameters:
    
    intermediateCommitSize - Maximum total size of operations after which an intermediate commit is performed automatically. Honored by the RocksDB storage engine only.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.2.0
  - getSatelliteSyncWait
```
public Double getSatelliteSyncWait()
```
  - satelliteSyncWait
```
public AqlQueryOptions satelliteSyncWait(Double satelliteSyncWait)
```
    Parameters:
    
    satelliteSyncWait - This enterprise parameter allows to configure how long a DBServer will have time to bring the satellite collections involved in the query into sync. The default value is 60.0 (seconds). When the max time has been reached the query will be stopped.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.2.0
  - getSkipInaccessibleCollections
```
public Boolean getSkipInaccessibleCollections()
```
  - skipInaccessibleCollections
```
public AqlQueryOptions skipInaccessibleCollections(Boolean skipInaccessibleCollections)
```
    Parameters:
    
    skipInaccessibleCollections - AQL queries (especially graph traversals) will treat collection to which a user has no access rights as if these collections were empty. Instead of returning a forbidden access error, your queries will execute normally. This is intended to help with certain use-cases: A graph contains several collections and different users execute AQL queries on that graph. You can now naturally limit the accessible results by changing the access rights of users on collections. This feature is only available in the Enterprise Edition.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.2.0
  - getFullCount
```
public Boolean getFullCount()
```
  - fullCount
```
public AqlQueryOptions fullCount(Boolean fullCount)
```
    Parameters:
    
    fullCount - if set to true and the query contains a LIMIT clause, then the result will have an extra attribute with the sub-attributes stats and fullCount, { ... , "extra": { "stats": { "fullCount": 123 } } }. The fullCount attribute will contain the number of documents in the result before the last LIMIT in the query was applied. It can be used to count the number of documents that match certain filter criteria, but only return a subset of them, in one go. It is thus similar to MySQL's SQL_CALC_FOUND_ROWS hint. Note that setting the option will disable a few LIMIT optimizations and may lead to more documents being processed, and thus make queries run longer. Note that the fullCount attribute will only be present in the result if the query has a LIMIT clause and the LIMIT clause is actually used in the query.
    
    Returns:
    
    options
  - getMaxPlans
```
public Integer getMaxPlans()
```
  - maxPlans
```
public AqlQueryOptions maxPlans(Integer maxPlans)
```
    Parameters:
    
    maxPlans - Limits the maximum number of plans that are created by the AQL query optimizer.
    
    Returns:
    
    options
  - getRules
```
public Collection<String> getRules()
```
  - rules
```
public AqlQueryOptions rules(Collection<String> rules)
```
    Parameters:
    
    rules - A list of to-be-included or to-be-excluded optimizer rules can be put into this attribute, telling the optimizer to include or exclude specific rules. To disable a rule, prefix its name with a -, to enable a rule, prefix it with a +. There is also a pseudo-rule all, which will match all optimizer rules
    
    Returns:
    
    options
  - getStream
```
public Boolean getStream()
```
  - stream
```
public AqlQueryOptions stream(Boolean stream)
```
    Parameters:
    
    stream - Specify true and the query will be executed in a streaming fashion. The query result is not stored on the server, but calculated on the fly. Beware: long-running queries will need to hold the collection locks for as long as the query cursor exists. When set to false a query will be executed right away in its entirety. In that case query results are either returned right away (if the resultset is small enough), or stored on the arangod instance and accessible via the cursor API (with respect to the ttl). It is advisable to only use this option on short-running queries or without exclusive locks (write-locks on MMFiles). Please note that the query options cache, count and fullCount will not work on streaming queries. Additionally query statistics, warnings and profiling data will only be available after the query is finished. The default value is false
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.4.0
  - getShardIds
```
public Collection<String> getShardIds()
```
  - shardIds
```
public AqlQueryOptions shardIds(String... shardIds)
```
    Restrict query to shards by given ids. This is an internal option. Use at your own risk.
    
    Parameters:
    
    shardIds -
    
    Returns:
    
    options
  - getForceOneShardAttributeValue
```
public String getForceOneShardAttributeValue()
```
  - forceOneShardAttributeValue
```
public AqlQueryOptions forceOneShardAttributeValue(String forceOneShardAttributeValue)
```
    Parameters:
    
    forceOneShardAttributeValue - This query option can be used in complex queries in case the query optimizer cannot automatically detect that the query can be limited to only a single server (e.g. in a disjoint smart graph case).
    If the option is set incorrectly, i.e. to a wrong shard key value, then the query may be shipped to a wrong DB server and may not return results (i.e. empty result set).
    Use at your own risk.
    
    Returns:
    
    options
  - getOptions
```
public AqlQueryOptions.Options getOptions()
```
  - allowDirtyRead
```
public AqlQueryOptions allowDirtyRead(Boolean allowDirtyRead)
```
    Parameters:
    
    allowDirtyRead - Set to true allows reading from followers in an active-failover setup.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.4.0
    
    See Also:
    
    API Documentation
  - getAllowDirtyRead
```
public Boolean getAllowDirtyRead()
```
  - getStreamTransactionId
```
public String getStreamTransactionId()
```
  - streamTransactionId
```
public AqlQueryOptions streamTransactionId(String streamTransactionId)
```
    Parameters:
    
    streamTransactionId - If set, the operation will be executed within the transaction.
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.5.0
  - getAllowRetry
```
public Boolean getAllowRetry()
```
  - allowRetry
```
public AqlQueryOptions allowRetry(Boolean allowRetry)
```
    Parameters:
    
    allowRetry - Set this option to true to make it possible to retry fetching the latest batch from a cursor.
    This makes possible to safely retry invoking ArangoCursor.next() in case of I/O exceptions (which are actually thrown as ArangoDBException with cause IOException)
    If set to false (default), then it is not safe to retry invoking ArangoCursor.next() in case of I/O exceptions, since the request to fetch the next batch is not idempotent (i.e. the cursor may advance multiple times on the server).
    Note: once you successfully received the last batch, you should call Closeable.close() so that the server does not unnecessary keep the batch until the cursor times out (ttl(Integer)).
    
    Returns:
    
    options
    
    Since:
    
    ArangoDB 3.11
  - clone
```
public AqlQueryOptions clone()
```
    Overrides:
    
    clone in class Object

Modifier and Type	Class	Description
`static class`	`AqlQueryOptions.Optimizer`
`static class`	`AqlQueryOptions.Options`

Class AqlQueryOptions

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AqlQueryOptions

Method Detail

getCount

count

getTtl

ttl

getBatchSize

batchSize

getMemoryLimit

memoryLimit

getCache

cache

getFillBlockCache

fillBlockCache

getBindVars

getQuery

query

getFailOnWarning

failOnWarning

maxRuntime

getProfile

profile

getMaxTransactionSize

maxTransactionSize

getMaxWarningCount

maxWarningCount

getIntermediateCommitCount

intermediateCommitCount

getIntermediateCommitSize

intermediateCommitSize

getSatelliteSyncWait

satelliteSyncWait

getSkipInaccessibleCollections

skipInaccessibleCollections

getFullCount

fullCount

getMaxPlans

maxPlans

getRules

rules

getStream

stream

getShardIds

shardIds

getForceOneShardAttributeValue

forceOneShardAttributeValue

getOptions

allowDirtyRead

getAllowDirtyRead

getStreamTransactionId

streamTransactionId

getAllowRetry

allowRetry

clone