diff --git a/README.md b/README.md index b20db27875..7288a20e30 100644 --- a/README.md +++ b/README.md @@ -169,7 +169,7 @@ Apple silicon like M1). Run the `docker compose` services using the `docker-compose.pain-build.yml` file. -```shell +```sh docs-hugo/toolchain/docker/amd64> docker compose -f docker-compose.plain-build.yml up --abort-on-container-exit ``` @@ -179,7 +179,7 @@ To make the documentation tooling not start a live server in watch mode but rather create a static build and exit, set the environment variable `ENV` to any value other than `local` before calling `docker compose ...`: -```shell +```sh export ENV=static # Bash set -xg ENV static # Fish $Env:ENV='static' # PowerShell @@ -215,7 +215,7 @@ The generators entry is a space-separated string. If `metrics` or `error-codes` is in the `generators` string, the following environment variable has to be exported: -```shell +```sh export ARANGODB_SRC_{VERSION}=path/to/arangodb/source ``` @@ -246,7 +246,7 @@ Apple silicon like M1). Run the `docker compose` services without specifying a file: -```shell +```sh docs-hugo/toolchain/docker/arm64> docker compose up --abort-on-container-exit ``` diff --git a/site/content/3.11/aql/execution-and-performance/caching-query-results.md b/site/content/3.11/aql/execution-and-performance/caching-query-results.md index 2013dd0947..8e76741ee5 100644 --- a/site/content/3.11/aql/execution-and-performance/caching-query-results.md +++ b/site/content/3.11/aql/execution-and-performance/caching-query-results.md @@ -21,48 +21,48 @@ are not part of a cluster setup. The cache can be operated in the following modes: -- `off`: the cache is disabled. No query results will be stored -- `on`: the cache will store the results of all AQL queries unless their `cache` - attribute flag is set to `false` -- `demand`: the cache will store the results of AQL queries that have their - `cache` attribute set to `true`, but will ignore all others +- `off`: The cache is disabled. No query results are stored. +- `on`: The cache stores the results of all AQL queries unless the `cache` + query option is set to `false`. +- `demand`: The cache stores the results of AQL queries that have the + `cache` query option set to `true` but ignores all others. -The mode can be set at server startup and later changed at runtime. +The mode can be set at server startup as well as at runtime, see +[Global configuration](#global-configuration). ## Query eligibility -The query results cache will consider two queries identical if they have exactly the +The query results cache considers two queries identical if they have exactly the same query string and the same bind variables. Any deviation in terms of whitespace, -capitalization etc. will be considered a difference. The query string will be hashed -and used as the cache lookup key. If a query uses bind parameters, these will also be hashed -and used as part of the cache lookup key. - -That means even if the query strings of two queries are identical, the query results -cache will treat them as different queries if they have different bind parameter -values. Other components that will become part of a query's cache key are the -`count`, `fullCount` and `optimizer` attributes. - -If the cache is turned on, the cache will check at the very start of execution -whether it has a result ready for this particular query. If that is the case, -the query result will be served directly from the cache, which is normally -very efficient. If the query cannot be found in the cache, it will be executed +capitalization etc. is considered a difference. The query string is hashed +and used as the cache lookup key. If a query uses bind parameters, these are also +hashed and used as part of the cache lookup key. + +Even if the query strings of two queries are identical, the query results cache +treats them as different queries if they have different bind parameter +values. Other components that become part of a query's cache key are the +`count`, `fullCount`, and `optimizer` attributes. + +If the cache is enabled, it is checked whether it has a result ready for a +particular query at the very start of processing the query request. If this is +the case, the query result is served directly from the cache, which is normally +very efficient. If the query cannot be found in the cache, it is executed as usual. -If the query is eligible for caching and the cache is turned on, the query -result will be stored in the query results cache so it can be used for subsequent +If the query is eligible for caching and the cache is enabled, the query +result is stored in the query results cache so it can be used for subsequent executions of the same query. A query is eligible for caching only if all of the following conditions are met: -- the server the query executes on is a single server (i.e. not part of a cluster) -- the query string is at least 8 characters long -- the query is a read-only query and does not modify data in any collection -- no warnings were produced while executing the query -- the query is deterministic and only uses deterministic functions whose results - are marked as cacheable -- the size of the query result does not exceed the cache's configured maximal - size for individual cache results or cumulated results -- the query is not executed using a streaming cursor +- The server the query executes on is a single server (i.e. not part of a cluster). +- The query is a read-only query and does not modify data in any collection. +- No warnings were produced while executing the query. +- The query is deterministic and only uses deterministic functions whose results + are marked as cacheable. +- The size of the query result does not exceed the cache's configured maximal + size for individual cache results or cumulated results. +- The query is not executed using a streaming cursor (`"stream": true` query option). The usage of non-deterministic functions leads to a query not being cacheable. This is intentional to avoid caching of function results which should rather @@ -85,8 +85,8 @@ remove, truncate operations as well as AQL data-modification queries). **Example** If the result of the following query is present in the query results cache, -then either modifying data in collection `users` or in collection `organizations` -will remove the already computed result from the cache: +then either modifying data in the `users` or `organizations` collection +removes the already computed result from the cache: ```aql FOR user IN users @@ -95,42 +95,42 @@ FOR user IN users RETURN { user: user, organization: organization } ``` -Modifying data in other collections than the named two will not lead to this +Modifying data in other unrelated collections does not lead to this query result being removed from the cache. ## Performance considerations The query results cache is organized as a hash table, so looking up whether a query result -is present in the cache is relatively fast. Still, the query string and the bind -parameter used in the query will need to be hashed. This is a slight overhead that -will not be present if the cache is turned off or a query is marked as not cacheable. +is present in the cache is fast. Still, the query string and the bind +parameter used in the query need to be hashed. This is a slight overhead that +is not present if the cache is disabled or a query is marked as not cacheable. Additionally, storing query results in the cache and fetching results from the -cache requires locking via an R/W lock. While many thread can read in parallel from +cache requires locking via a read/write lock. While many thread can read in parallel from the cache, there can only be a single modifying thread at any given time. Modifications of the query cache contents are required when a query result is stored in the cache or during cache invalidation after data-modification operations. Cache invalidation -will require time proportional to the number of cached items that need to be invalidated. +requires time proportional to the number of cached items that need to be invalidated. -There may be workloads in which enabling the query results cache will lead to a performance +There may be workloads in which enabling the query results cache leads to a performance degradation. It is not recommended to turn the query results cache on in workloads that only -modify data, or that modify data more often than reading it. Turning on the cache -will also provide no benefit if queries are very diverse and do not repeat often. -In read-only or read-mostly workloads, the cache will be beneficial if the same +modify data, or that modify data more often than reading it. Enabling the cache +also provides no benefit if queries are very diverse and do not repeat often. +In read-only or read-mostly workloads, the cache is beneficial if the same queries are repeated lots of times. -In general, the query results cache will provide the biggest improvements for queries with +In general, the query results cache provides the biggest improvements for queries with small result sets that take long to calculate. If query results are very big and most of the query time is spent on copying the result from the cache to the client, -then the cache will not provide much benefit. +then the cache does not provide much benefit. ## Global configuration -The query results cache can be configured at server start using the configuration parameter -`--query.cache-mode`. This will set the cache mode according to the descriptions -above. +The query results cache can be configured at server start with the +[`--query.cache-mode`](../../components/arangodb-server/options.md#--querycache-mode) +startup option. -After the server is started, the cache mode can be changed at runtime as follows: +The cache mode can also be changed at runtime using the JavaScript API as follows: ```js require("@arangodb/aql/cache").properties({ mode: "on" }); @@ -139,10 +139,10 @@ require("@arangodb/aql/cache").properties({ mode: "on" }); The maximum number of cached results in the cache for each database can be configured at server start using the following configuration parameters: -- `--query.cache-entries`: maximum number of results in query result cache per database -- `--query.cache-entries-max-size`: maximum cumulated size of results in query result cache per database -- `--query.cache-entry-max-size`: maximum size of an individual result entry in query result cache -- `--query.cache-include-system-collections`: whether or not to include system collection queries in the query result cache +- `--query.cache-entries`: The maximum number of results in the query results cache per database +- `--query.cache-entries-max-size`: The maximum cumulated size of results in the query results cache per database +- `--query.cache-entry-max-size`: The maximum size of an individual result entry in query results cache +- `--query.cache-include-system-collections`: Whether to include system collection queries in the query results cache These parameters can be used to put an upper bound on the number and size of query results in each database's query cache and thus restrict the cache's memory consumption. @@ -158,27 +158,32 @@ require("@arangodb/aql/cache").properties({ }); ``` -The above will limit the number of cached results in the query results cache to 200 -results per database, and to 8 MB cumulated query result size per database. The maximum -size of each query cache entry is restricted to 8MB. Queries that involve system +The above settings limit the number of cached results in the query results cache to 200 +results per database, and to 8 MiB cumulated query result size per database. The maximum +size of each query cache entry is restricted to 1 MiB. Queries that involve system collections are excluded from caching. +You can also change the configuration at runtime with the +[HTTP API](../../develop/http-api/queries/aql-query-results-cache.md). + ## Per-query configuration When a query is sent to the server for execution and the cache is set to `on` or `demand`, -the query executor will look into the query's `cache` attribute. If the query cache mode is -`on`, then not setting this attribute or setting it to anything but `false` will make the -query executor consult the query cache. If the query cache mode is `demand`, then setting -the `cache` attribute to `true` will make the executor look for the query in the query cache. -When the query cache mode is `off`, the executor will not look for the query in the cache. +the query executor checks the query's `cache` option. If the query cache mode is +`on`, then not setting this query option or setting it to anything but `false` makes the +query executor consult the query results cache. If the query cache mode is `demand`, then setting +the `cache` option to `true` makes the executor look for the query in the query results cache. +When the query cache mode is `off`, the executor does not look for the query in the cache. The `cache` attribute can be set as follows via the `db._createStatement()` function: ```js var stmt = db._createStatement({ query: "FOR doc IN users LIMIT 5 RETURN doc", - cache: true /* cache attribute set here */ -}); + options: { + cache: true + } +}); stmt.execute(); ``` @@ -186,16 +191,14 @@ stmt.execute(); When using the `db._query()` function, the `cache` attribute can be set as follows: ```js -db._query({ - query: "FOR doc IN users LIMIT 5 RETURN doc", - cache: true /* cache attribute set here */ -}); +db._query("FOR doc IN users LIMIT 5 RETURN doc", {}, { cache: true }); ``` -The `cache` attribute can be set via the HTTP REST API `POST /_api/cursor`, too. +You can also set the `cache` query option in the +[HTTP API](../../develop/http-api/queries/aql-queries.md#create-a-cursor). -Each query result returned will contain a `cached` attribute. This will be set to `true` -if the result was retrieved from the query cache, and `false` otherwise. Clients can use +Each query result returned contain a `cached` attribute. It is set to `true` +if the result was retrieved from the query results cache, and `false` otherwise. Clients can use this attribute to check if a specific query was served from the cache or not. ## Query results cache inspection @@ -207,7 +210,7 @@ The contents of the query results cache can be checked at runtime using the cach require("@arangodb/aql/cache").toArray(); ``` -This will return a list of all query results stored in the current database's query +This returns a list of all query results stored in the current database's query results cache. The query results cache for the current database can be cleared at runtime using the @@ -221,5 +224,5 @@ require("@arangodb/aql/cache").clear(); Query results that are returned from the query results cache may contain execution statistics stemming from the initial, uncached query execution. This means for a cached query results, -the *extra.stats* attribute may contain stale data, especially in terms of the *executionTime* -and *profile* attribute values. +the `extra.stats` attribute may contain stale data, especially in terms of the `executionTime` +and `profile` attribute values. diff --git a/site/content/3.11/aql/how-to-invoke-aql/with-arangosh.md b/site/content/3.11/aql/how-to-invoke-aql/with-arangosh.md index 1b31530288..20c0a0b70f 100644 --- a/site/content/3.11/aql/how-to-invoke-aql/with-arangosh.md +++ b/site/content/3.11/aql/how-to-invoke-aql/with-arangosh.md @@ -195,26 +195,6 @@ db._query( ).toArray(); // Each batch needs to be fetched within 5 seconds ``` -#### `cache` - -Whether the AQL query results cache shall be used. If set to `false`, then any -query cache lookup is skipped for the query. If set to `true`, it leads to the -query cache being checked for the query **if** the query cache mode is either -set to `on` or `demand`. - -```js ---- -name: 02_workWithAQL_cache -description: '' ---- -db._query( - 'FOR i IN 1..20 RETURN i', - {}, - { cache: true }, - {} -); // result may get taken from cache -``` - #### `memoryLimit` To set a memory limit for the query, pass `options` to the `_query()` method. @@ -274,12 +254,30 @@ don't need to set it on a per-query level. #### `cache` -If you set `cache` to `true`, this puts the query result into the query result cache -if the query result is eligible for caching and the query cache is running in demand -mode. If set to `false`, the query result is not inserted into the query result -cache. Note that query results are never inserted into the query result cache if -the query result cache is disabled, and that they are automatically inserted into -the query result cache if it is active in non-demand mode. +Whether the [AQL query results cache](../execution-and-performance/caching-query-results.md) +shall be used for adding as well as for retrieving results. + +If the query cache mode is set to `demand` and you set the `cache` query option +to `true` for a query, then its query result is cached if it's eligible for +caching. If the query cache mode is set to `on`, query results are automatically +cached if they are eligible for caching unless you set the `cache` option to `false`. + +If you set the `cache` option to `false`, then any query cache lookup is skipped +for the query. If you set it to `true`, the query cache is checked a cached result +**if** the query cache mode is either set to `on` or `demand`. + +```js +--- +name: 02_workWithAQL_cache +description: '' +--- +var resultCache = require("@arangodb/aql/cache"); +resultCache.properties({ mode: "demand" }); +~resultCache.clear(); +db._query("FOR i IN 1..5 RETURN i", {}, { cache: true }); // Adds result to cache +db._query("FOR i IN 1..5 RETURN i", {}, { cache: true }); // Retrieves result from cache +db._query("FOR i IN 1..5 RETURN i", {}, { cache: false }); // Bypasses the cache +``` #### `fillBlockCache` diff --git a/site/content/3.11/develop/http-api/queries/aql-queries.md b/site/content/3.11/develop/http-api/queries/aql-queries.md index 7a9049977c..f5457b8221 100644 --- a/site/content/3.11/develop/http-api/queries/aql-queries.md +++ b/site/content/3.11/develop/http-api/queries/aql-queries.md @@ -347,13 +347,6 @@ paths: of cursors that are not fully fetched by clients. If not set, a server-defined value will be used (default: 30 seconds). type: integer - cache: - description: | - flag to determine whether the AQL query results 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`. - type: boolean memoryLimit: description: | the maximum number of memory (measured in bytes) that the query is allowed to @@ -493,6 +486,20 @@ paths: All other resources are freed immediately (locks, RocksDB snapshots). The query will fail before it returns results in case of a conflict. type: boolean + cache: + description: | + Whether the [AQL query results cache](../../../aql/execution-and-performance/caching-query-results.md) + shall be used for adding as well as for retrieving results. + + If the query cache mode is set to `demand` and you set the `cache` query option + to `true` for a query, then its query result is cached if it's eligible for + caching. If the query cache mode is set to `on`, query results are automatically + cached if they are eligible for caching unless you set the `cache` option to `false`. + + If you set the `cache` option to `false`, then any query cache lookup is skipped + for the query. If you set it to `true`, the query cache is checked for a cached result + **if** the query cache mode is either set to `on` or `demand`. + type: boolean spillOverThresholdMemoryUsage: description: | This option allows queries to store intermediate and final results temporarily @@ -554,7 +561,7 @@ paths: description: | If set to `true` or `1`, then the additional query profiling information is returned in the `profile` sub-attribute of the `extra` return attribute, unless the query result - is served from the query cache. If set to `2`, the query includes execution stats + is served from the query results cache. If set to `2`, the query includes execution stats per query plan node in `stats.nodes` sub-attribute of the `extra` return attribute. Additionally, the query plan is returned in the `extra.plan` sub-attribute. type: integer @@ -964,9 +971,9 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean '400': description: | @@ -1692,9 +1699,9 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean '400': description: | @@ -2311,9 +2318,9 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean '400': description: | @@ -2967,10 +2974,47 @@ paths: type: boolean maxNumberOfPlans: description: | - an optional maximum number of plans that the optimizer is - allowed to generate. Setting this attribute to a low value allows to put a + The maximum number of plans that the optimizer is allowed to + generate. Setting this attribute to a low value allows to put a cap on the amount of work the optimizer does. type: integer + fullCount: + description: | + Whether to calculate the total number of documents matching the + filter conditions as if the query's final top-level `LIMIT` operation + were not applied. This option generally leads to different + execution plans. + type: boolean + profile: + description: | + Whether to include additional query profiling information. + If set to `2`, the response includes the time it took to process + each optimizer rule under `stats.rules`. + type: integer + maxNodesPerCallstack: + description: | + The number of execution nodes in the query plan after that stack splitting is + performed to avoid a potential stack overflow. Defaults to the configured value + of the startup option `--query.max-nodes-per-callstack`. + + This option is only useful for testing and debugging and normally does not need + any adjustment. + type: integer + maxWarningCount: + description: | + Limits the number of warnings a query can return. The maximum number of warnings + is `10` by default but you can increase or decrease the limit. + type: integer + failOnWarning: + description: | + If set to `true`, the query throws an exception and aborts instead of producing + a warning. You should use this option during development to catch potential issues + early. When the attribute is set to `false`, warnings are not propagated to + exceptions and are returned with the query result. + + You can use the `--query.fail-on-warning` startup option to adjust the + default value for `failOnWarning` so you don't need to set it on a per-query basis. + type: boolean optimizer: description: | Options related to the query optimizer. diff --git a/site/content/3.11/develop/http-api/queries/aql-query-results-cache.md b/site/content/3.11/develop/http-api/queries/aql-query-results-cache.md index 14873d57fa..670705ddbe 100644 --- a/site/content/3.11/develop/http-api/queries/aql-query-results-cache.md +++ b/site/content/3.11/develop/http-api/queries/aql-query-results-cache.md @@ -1,10 +1,18 @@ --- -title: HTTP interface for the query cache +title: HTTP interface for the query results cache menuTitle: AQL query results cache weight: 10 description: >- - The query cache HTTP API lets you control the cache for AQL query results + The query results cache HTTP API lets you control the cache for AQL query results --- +See [The AQL query results cache](../../../aql/execution-and-performance/caching-query-results.md) +for a description of the feature and the configuration options. + +{{< info >}} +The AQL query results cache is only available for single servers, i.e. servers that +are not part of a cluster setup. +{{< /info >}} + ## List the entries of the AQL query results cache ```openapi @@ -14,20 +22,7 @@ paths: operationId: listQueryCacheResults description: | Returns an array containing the AQL query results currently stored in the query results - cache of the selected database. Each result is a JSON object with the following attributes: - - - `hash`: the query result's hash - - `query`: the query string - - `bindVars`: the query's bind parameters. this attribute is only shown if tracking for - bind variables was enabled at server start - - `size`: the size of the query result and bind parameters, in bytes - - `results`: number of documents/rows in the query result - - `started`: the date and time when the query was stored in the cache - - `hits`: number of times the result was served from the cache (can be - `0` for queries that were only stored in the cache but were never accessed - again afterwards) - - `runTime`: the query's run time - - `dataSources`: an array of collections/Views the query was using + cache of the selected database. parameters: - name: database-name in: path @@ -40,14 +35,103 @@ paths: responses: '200': description: | - Is returned when the list of results can be retrieved successfully. + The list of cached query results. + content: + application/json: + schema: + description: | + The entries of the query results cache. + type: array + items: + description: | + The properties of a cache entry. + type: object + required: + - hash + - query + - size + - results + - hits + - runTime + - started + - dataSources + properties: + hash: + description: | + The hash value calculated from the the query string, + certain query options, and the bind variables. + type: string + query: + description: | + The query string. + type: string + bindVars: + description: | + The bind parameters. This attribute is omitted if the + `--query.tracking-with-bindvars` startup option is set + to `false`. + type: object + size: + description: | + The size of the query result and bind parameters (in bytes). + type: integer + results: + description: | + The number of documents/rows in the query result. + type: integer + started: + description: | + The date and time at which the query result has been added + to the cache (in ISO 8601 format). + type: string + format: date-time + hits: + description: | + How many times the result has been served from the cache so far. + type: integer + runTime: + description: | + The total duration of the query in seconds. + type: number + dataSources: + description: | + The collections and Views involved in the query. + type: array + items: + type: string '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpListQueryResultsCache +description: | + Retrieve the entries stored in the AQL query results cache of the current database: +--- +var resultsCache = require("@arangodb/aql/cache"); +resultsCache.properties({ mode: "demand" }); + +db._create("coll"); +for (let i = 0; i < 3; i++) { + db._query("FOR doc IN @@coll FILTER doc.attr == @val RETURN doc", { + "@coll": "coll", val: "foo" + }, { cache: true }); +} +db._query("RETURN 42", {}, { cache: true }); + +var url = "/_api/query-cache/entries"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.length >= 2); +logJsonResponse(response); + +db._drop("coll"); +``` + ## Clear the AQL query results cache ```openapi @@ -69,15 +153,44 @@ paths: responses: '200': description: | - The server will respond with *HTTP 200* when the cache was cleared - successfully. + The results cache has been cleared. + content: + application/json: + schema: + type: object + required: + - error + - code + properties: + error: + description: | + A flag indicating that no error occurred. + type: boolean + example: false + code: + description: | + The HTTP response status code. + type: integer + example: 200 '400': description: | - The server will respond with *HTTP 400* in case of a malformed request. + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpClearQueryResultsCache +description: | + Clear the AQL query results cache of the current database: +--- +var url = "/_api/query-cache"; +var response = logCurlRequest('DELETE', url); +assert(response.code === 200); +logJsonResponse(response); +``` + ## Get the AQL query results cache configuration ```openapi @@ -86,23 +199,7 @@ paths: get: operationId: getQueryCacheProperties description: | - Returns the global AQL query results cache configuration. The configuration is a - JSON object with the following properties: - - - `mode`: the mode the AQL query results cache operates in. The mode is one of the following - values: `off`, `on`, or `demand`. - - - `maxResults`: the maximum number of query results that will be stored per database-specific - cache. - - - `maxResultsSize`: the maximum cumulated size of query results that will be stored per - database-specific cache. - - - `maxEntrySize`: the maximum individual result size of queries that will be stored per - database-specific cache. - - - `includeSystem`: whether or not results of queries that involve system collections will be - stored in the query results cache. + Returns the global AQL query results cache configuration. parameters: - name: database-name in: path @@ -117,14 +214,62 @@ paths: responses: '200': description: | - Is returned if the properties can be retrieved successfully. + The result cache configuration is returned successfully. + content: + application/json: + schema: + description: | + The result cache configuration. + type: object + properties: + mode: + description: | + The mode the AQL query results cache operates in. + type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] + maxResults: + description: | + The maximum number of query results that are stored per + database-specific cache. + type: integer + maxResultsSize: + description: | + The maximum cumulated size of query results that are + stored per database-specific cache (in bytes). + type: integer + maxEntrySize: + description: | + The maximum individual result size of queries that are + stored per database-specific cache (in bytes). + includeSystem: + description: | + Whether results of queries that involve system collections + are stored in the query results cache. + type: boolean '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpGetQueryResultsCacheProperties +description: | + Retrieve the global configuration of the AQL query results cache: +--- +var resultsCache = require("@arangodb/aql/cache"); +resultsCache.properties({ mode: "demand" }); + +var url = "/_api/query-cache/properties"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.mode == "demand"); +logJsonResponse(response); +``` + ## Set the AQL query results cache configuration ```openapi @@ -135,14 +280,7 @@ paths: description: | Adjusts the global properties for the AQL query results cache. - After the properties have been changed, the current set of properties will - be returned in the HTTP response. - - Note: changing the properties may invalidate all results in the cache. - - The properties need to be passed in the `properties` attribute in the body - of the HTTP request. `properties` needs to be a JSON object with the following - properties: + Changing the properties may invalidate all results currently in the cache. parameters: - name: database-name in: path @@ -158,35 +296,90 @@ paths: content: application/json: schema: + description: | + The result cache configuration settings to change. type: object properties: mode: description: | - the mode the AQL query cache should operate in. Possible values are `off`, `on`, or `demand`. + The mode the AQL query cache shall operate in. type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] maxResults: description: | - the maximum number of query results that will be stored per database-specific cache. + The maximum number of query results that are stored per + database-specific cache. type: integer maxResultsSize: description: | - the maximum cumulated size of query results that will be stored per database-specific cache. + The maximum cumulated size of query results that are stored + per database-specific cache (in bytes). type: integer maxEntrySize: description: | - the maximum individual size of query results that will be stored per database-specific cache. + The maximum individual size of query results that are stored + per database-specific cache (in bytes). type: integer includeSystem: description: | - whether or not to store results of queries that involve system collections. + Whether to store results of queries that involve + system collections in the cache. type: boolean responses: '200': description: | - Is returned if the properties were changed successfully. + The result cache configuration has been changed successfully. + content: + application/json: + schema: + description: | + The result cache configuration. + type: object + properties: + mode: + description: | + The mode the AQL query results cache operates in. + type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] + maxResults: + description: | + The maximum number of query results that are stored per + database-specific cache. + type: integer + maxResultsSize: + description: | + The maximum cumulated size of query results that are + stored per database-specific cache (in bytes). + type: integer + maxEntrySize: + description: | + The maximum individual result size of queries that are + stored per database-specific cache (in bytes). + includeSystem: + description: | + Whether results of queries that involve system collections + are stored in the query results cache. + type: boolean '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` + +```curl +--- +name: HttpSetQueryResultsCacheProperties +description: | + Change some properties of the global configuration of the AQL query results cache: +--- +var url = "/_api/query-cache/properties"; +var body = { mode: "demand", maxResults: 32 }; +var response = logCurlRequest('PUT', url, body); +assert(response.code === 200); +assert(response.parsedBody.mode == "demand"); +assert(response.parsedBody.maxResults == 32); +logJsonResponse(response); +``` diff --git a/site/content/3.11/develop/javascript-api/_index.md b/site/content/3.11/develop/javascript-api/_index.md index 2a93b75754..ac10a520f7 100644 --- a/site/content/3.11/develop/javascript-api/_index.md +++ b/site/content/3.11/develop/javascript-api/_index.md @@ -156,7 +156,7 @@ You can use the following modules as an end-user: offers methods to track and kill AQL queries. - [**@arangodb/aql/cache**](../../aql/execution-and-performance/caching-query-results.md) - allows to control the AQL query caching feature. + allows to control the AQL query result caching feature. - [**@arangodb/aql/explainer**](../../aql/execution-and-performance/explaining-queries.md) provides methods to debug, explain and profile AQL queries. diff --git a/site/content/3.12/about-arangodb/features/community-edition.md b/site/content/3.12/about-arangodb/features/community-edition.md index 7cb9dd1e73..2af527c50f 100644 --- a/site/content/3.12/about-arangodb/features/community-edition.md +++ b/site/content/3.12/about-arangodb/features/community-edition.md @@ -219,6 +219,12 @@ see [arangodb.com/community-server/](https://www.arangodb.com/community-server/) collection scans. Inlining of certain subqueries to improve execution time. +{{% comment %}} Experimental feature in v3.12.4 +- [**Query plan caching**](../../aql/execution-and-performance/caching-query-plans.md) + Reduce the total time for processing queries by avoiding to parse, plan, and + optimize the same queries over and over again with an AQL execution plan cache. +{{% /comment %}} + - [**Parallel gather**](../../release-notes/version-3.11/whats-new-in-3-11.md#parallel-gather): Fast, memory-efficient processing of cluster queries by combining results in parallel. diff --git a/site/content/3.12/about-arangodb/features/highlights-by-version.md b/site/content/3.12/about-arangodb/features/highlights-by-version.md index 9e137de529..51e5a3579e 100644 --- a/site/content/3.12/about-arangodb/features/highlights-by-version.md +++ b/site/content/3.12/about-arangodb/features/highlights-by-version.md @@ -37,6 +37,12 @@ aliases: Speed up data transfers and reduce traffic with transparent compression of requests and responses between ArangoDB servers and client tools. +{{% comment %}} Experimental feature in v3.12.4 +- [**Query plan caching**](../../aql/execution-and-performance/caching-query-plans.md) + Reduce the total time for processing queries by avoiding to parse, plan, and + optimize the same queries over and over again with an AQL execution plan cache. +{{% /comment %}} + **Enterprise Edition** - [**ArangoSearch WAND optimization**](../../index-and-search/arangosearch/performance.md#wand-optimization): diff --git a/site/content/3.12/aql/execution-and-performance/caching-query-plans.md b/site/content/3.12/aql/execution-and-performance/caching-query-plans.md new file mode 100644 index 0000000000..792c381151 --- /dev/null +++ b/site/content/3.12/aql/execution-and-performance/caching-query-plans.md @@ -0,0 +1,224 @@ +--- +title: The execution plan cache for AQL queries +menuTitle: Caching query plans +weight: 29 +description: >- + AQL provides an optional cache for query plans to skip query planning and + optimization when running the same queries repeatedly +--- +Query plan caching can reduce the total time for processing queries by avoiding +to parse, plan, and optimize queries over and over again that effectively have +the same execution plan with at most some changes to bind parameter values. +It is especially useful for particular queries where a lot of time is spent on +the query planning and optimization passes in proportion to the actual execution. + +## Use plan caching for queries + +Query plans are not cached by default. You need to enable the query option for +plan caching on a per-query basis to utilize cached plans as well as to add +plans to the cache. Otherwise, the plan cache is bypassed. + +{{< tabs "interfaces" >}} + +{{< tab "Web interface" >}} +1. Click **Queries** in the main navigation. +2. Enter an AQL query and specify the values for bind variables if necessary. +3. Switch to the **Options** tab to access the query options. +4. Expand the **Advanced** panel. +5. Enable the **Use Plan Cache** option. +{{< /tab >}} + +{{< tab "arangosh" >}} +```js +--- +name: arangosh_cache_query_plan +description: '' +--- +~db._create("coll"); +var query = "FOR doc IN coll FILTER doc.attr == @val RETURN doc"; +var bindVars = { val: "foo" }; +db._query(query, bindVars, { usePlanCache: true }); // Adds plan to cache +db._query(query, bindVars, { usePlanCache: true }); // Uses cached plan +~db._drop("coll"); +``` + +See the [JavaScript API](../../develop/javascript-api/@arangodb/db-object.md#db_createcollection-name--properties--type--options) +for details. +{{< /tab >}} + +{{< tab "cURL" >}} +```sh +curl -d '{"query":"FOR doc IN coll FILTER doc.attr == @val RETURN doc","bindVars":{"val":"foo"},"options":{"usePlanCache":true}}' http://localhost:8529/_db/mydb/_api/cursor + +# The second time, the response includes a planCacheKey +curl -d '{"query":"FOR doc IN coll FILTER doc.attr == @val RETURN doc","bindVars":{"val":"foo"},"options":{"usePlanCache":true}}' http://localhost:8529/_db/mydb/_api/cursor +``` + +See the [HTTP API](../../develop/http-api/queries/aql-queries.md#create-a-cursor) +for details. +{{< /tab >}} + +{{< /tabs >}} + +## Cache eligibility + +If plan caching is enabled for a query, the eligibility for being cached is +checked first. An error is raised if a query doesn't meet the requirements. + +A query is not eligible for plan caching if it uses +**attribute name bind parameters** (e.g. `FILTER doc.@attributeName == ...`) +or when using **value bind parameters** in any of the following places: +- Specifying the depths for traversals or path queries + (e.g. `FOR v, e IN @min..@max OUTBOUND ...`) +- Referring to a named graph (e.g. `GRAPH @graphName`) +- Referring to edge collections used in traversals or path queries + (e.g. `FOR v, e IN 1..2 OUTBOUND 'v/0' @@edgeColl ...`) +- Specifying the offset or count for a `LIMIT` operation + (e.g. `LIMIT @offset, @count`) + +If a query produces any **warnings** during parsing or query plan optimization, +it is also not eligible for plan caching. + +Query plans are also not eligible for caching if they contain one of the +following execution node types in the plan: +- `SingleRemoteOperationNode` (cluster only) +- `MultipleRemoteModificationNode` (cluster only) +- `UpsertNode`, i.e. the AQL `UPSERT` operation + +Additionally, any queries that have any of the following **query options** set +are not eligible for plan caching: + +- `allPlans` +- `optimizer.rules` +- `explainRegisters` (internal) +- `inaccessibleCollections` (internal) +- `shardIds` (internal) + +If a query is eligible for plan caching, the plan cache is checked using +the exact same query string and set of collection bind parameter values. +A cached plan entry is only considered identical to the current query if the +query strings are identical byte for byte and the set of collection bind +parameters is exactly the same (bind parameter names and bind parameter +values). + +If no plan entry can be found in the plan cache, the query is planned and +optimized as usual, and the cached plan is inserted into the plan cache. +Repeated executions of the same query (same query string and using the same +set of collection bind parameters) then makes use of the cached plan +entry, potentially with different value bind parameters. + +The following query options are ignored when a cached plan is used: +- `joinStrategyType` +- `maxDNFConditionMembers` +- `maxNodesPerCallstack` + +Whenever a query uses a plan from the plan cache, the query +result includes a `planCacheKey` attribute at the top level when +executing, explaining, or profiling a query. The explain and profiling +outputs also indicate when a cached query plan was used, showing +`plan cache key: ...` at the top. + +## Cache invalidation and expiration + +The query plan cache is organized **per database**. It gets invalidated at the +following events: + +- An existing collection gets dropped or renamed, or the properties of an + existing collection are modified. +- An index is added to an existing collection or an index is dropped. +- An existing View gets dropped or renamed, or the properties of an existing + View are modified. +- A named graph is added, or an existing named graph is changed or gets dropped. + +These events typically remove all entries from the plan cache of the respective +database. In a single server deployment, only affected entries may get removed. + +Individual cache entries can expire if `--query.plan-cache-invalidation-time` +is set to a value greater than `0`. The configured duration for which cached +query plans are valid is relative to when they were added to the cache. Expired +entries are no longer used and eventually removed from the plan cache. + +## Configuration + +The memory usage of the query plan cache can be restricted using the following +startup options: + +- [`--query.plan-cache-max-entries`](../../components/arangodb-server/options.md#--queryplan-cache-max-entries) +- [`--query.plan-cache-max-memory-usage`](../../components/arangodb-server/options.md#--queryplan-cache-max-memory-usage) +- [`--query.plan-cache-max-entry-size`](../../components/arangodb-server/options.md#--queryplan-cache-max-entry-size) + +Note that each database has its own query plan cache, and that these options +are used for each individual plan cache. In a cluster, each Coordinator has its +own query plan cache. + +The expiration of cached plans can be configured with the following startup option: + +- [`--query.plan-cache-invalidation-time`](../../components/arangodb-server/options.md#--queryplan-cache-invalidation-time) + +## Interfaces + +### List the query plan cache entries + +Retrieve all entries in the query plan cache for the current database. + +This requires read privileges for the current database. In addition, only those +query plans are returned for which the current user has at least read permissions +on all collections and Views included in the query. + +{{< tabs "interfaces" >}} + +{{< tab "arangosh" >}} +```js +--- +name: arangosh_list_cached_query_plans +description: '' +--- +~db._create("coll"); +~db._query("RETURN 42", {}, { usePlanCache: true }); +~db._query("FOR doc IN coll FILTER doc.attr == @val RETURN doc", { val: "foo" }, { usePlanCache: true }); +var planCache = require("@arangodb/aql/plan-cache"); +planCache.toArray(); +~db._drop("coll"); +``` +{{< /tab >}} + +{{< tab "cURL" >}} +```sh +curl http://localhost:8529/_api/query-plan-cache +``` + +See the [HTTP API](../../develop/http-api/queries/aql-query-plan-cache.md#list-the-entries-of-the-aql-query-plan-cache) +for details. +{{< /tab >}} + +{{< /tabs >}} + +### Clear the query plan cache + +Delete all entries in the query plan cache for the current database. + +This requires write privileges for the current database. + +{{< tabs "interfaces" >}} + +{{< tab "arangosh" >}} +```js +--- +name: arangosh_clear_query_plan_cache +description: '' +--- +var planCache = require("@arangodb/aql/plan-cache"); +planCache.clear(); +``` +{{< /tab >}} + +{{< tab "cURL" >}} +```sh +curl -XDELETE http://localhost:8529/_api/query-plan-cache +``` + +See the [HTTP API](../../develop/http-api/queries/aql-query-plan-cache.md#clear-the-aql-query-plan-cache) +for details. +{{< /tab >}} + +{{< /tabs >}} diff --git a/site/content/3.12/aql/execution-and-performance/caching-query-results.md b/site/content/3.12/aql/execution-and-performance/caching-query-results.md index 2013dd0947..8e76741ee5 100644 --- a/site/content/3.12/aql/execution-and-performance/caching-query-results.md +++ b/site/content/3.12/aql/execution-and-performance/caching-query-results.md @@ -21,48 +21,48 @@ are not part of a cluster setup. The cache can be operated in the following modes: -- `off`: the cache is disabled. No query results will be stored -- `on`: the cache will store the results of all AQL queries unless their `cache` - attribute flag is set to `false` -- `demand`: the cache will store the results of AQL queries that have their - `cache` attribute set to `true`, but will ignore all others +- `off`: The cache is disabled. No query results are stored. +- `on`: The cache stores the results of all AQL queries unless the `cache` + query option is set to `false`. +- `demand`: The cache stores the results of AQL queries that have the + `cache` query option set to `true` but ignores all others. -The mode can be set at server startup and later changed at runtime. +The mode can be set at server startup as well as at runtime, see +[Global configuration](#global-configuration). ## Query eligibility -The query results cache will consider two queries identical if they have exactly the +The query results cache considers two queries identical if they have exactly the same query string and the same bind variables. Any deviation in terms of whitespace, -capitalization etc. will be considered a difference. The query string will be hashed -and used as the cache lookup key. If a query uses bind parameters, these will also be hashed -and used as part of the cache lookup key. - -That means even if the query strings of two queries are identical, the query results -cache will treat them as different queries if they have different bind parameter -values. Other components that will become part of a query's cache key are the -`count`, `fullCount` and `optimizer` attributes. - -If the cache is turned on, the cache will check at the very start of execution -whether it has a result ready for this particular query. If that is the case, -the query result will be served directly from the cache, which is normally -very efficient. If the query cannot be found in the cache, it will be executed +capitalization etc. is considered a difference. The query string is hashed +and used as the cache lookup key. If a query uses bind parameters, these are also +hashed and used as part of the cache lookup key. + +Even if the query strings of two queries are identical, the query results cache +treats them as different queries if they have different bind parameter +values. Other components that become part of a query's cache key are the +`count`, `fullCount`, and `optimizer` attributes. + +If the cache is enabled, it is checked whether it has a result ready for a +particular query at the very start of processing the query request. If this is +the case, the query result is served directly from the cache, which is normally +very efficient. If the query cannot be found in the cache, it is executed as usual. -If the query is eligible for caching and the cache is turned on, the query -result will be stored in the query results cache so it can be used for subsequent +If the query is eligible for caching and the cache is enabled, the query +result is stored in the query results cache so it can be used for subsequent executions of the same query. A query is eligible for caching only if all of the following conditions are met: -- the server the query executes on is a single server (i.e. not part of a cluster) -- the query string is at least 8 characters long -- the query is a read-only query and does not modify data in any collection -- no warnings were produced while executing the query -- the query is deterministic and only uses deterministic functions whose results - are marked as cacheable -- the size of the query result does not exceed the cache's configured maximal - size for individual cache results or cumulated results -- the query is not executed using a streaming cursor +- The server the query executes on is a single server (i.e. not part of a cluster). +- The query is a read-only query and does not modify data in any collection. +- No warnings were produced while executing the query. +- The query is deterministic and only uses deterministic functions whose results + are marked as cacheable. +- The size of the query result does not exceed the cache's configured maximal + size for individual cache results or cumulated results. +- The query is not executed using a streaming cursor (`"stream": true` query option). The usage of non-deterministic functions leads to a query not being cacheable. This is intentional to avoid caching of function results which should rather @@ -85,8 +85,8 @@ remove, truncate operations as well as AQL data-modification queries). **Example** If the result of the following query is present in the query results cache, -then either modifying data in collection `users` or in collection `organizations` -will remove the already computed result from the cache: +then either modifying data in the `users` or `organizations` collection +removes the already computed result from the cache: ```aql FOR user IN users @@ -95,42 +95,42 @@ FOR user IN users RETURN { user: user, organization: organization } ``` -Modifying data in other collections than the named two will not lead to this +Modifying data in other unrelated collections does not lead to this query result being removed from the cache. ## Performance considerations The query results cache is organized as a hash table, so looking up whether a query result -is present in the cache is relatively fast. Still, the query string and the bind -parameter used in the query will need to be hashed. This is a slight overhead that -will not be present if the cache is turned off or a query is marked as not cacheable. +is present in the cache is fast. Still, the query string and the bind +parameter used in the query need to be hashed. This is a slight overhead that +is not present if the cache is disabled or a query is marked as not cacheable. Additionally, storing query results in the cache and fetching results from the -cache requires locking via an R/W lock. While many thread can read in parallel from +cache requires locking via a read/write lock. While many thread can read in parallel from the cache, there can only be a single modifying thread at any given time. Modifications of the query cache contents are required when a query result is stored in the cache or during cache invalidation after data-modification operations. Cache invalidation -will require time proportional to the number of cached items that need to be invalidated. +requires time proportional to the number of cached items that need to be invalidated. -There may be workloads in which enabling the query results cache will lead to a performance +There may be workloads in which enabling the query results cache leads to a performance degradation. It is not recommended to turn the query results cache on in workloads that only -modify data, or that modify data more often than reading it. Turning on the cache -will also provide no benefit if queries are very diverse and do not repeat often. -In read-only or read-mostly workloads, the cache will be beneficial if the same +modify data, or that modify data more often than reading it. Enabling the cache +also provides no benefit if queries are very diverse and do not repeat often. +In read-only or read-mostly workloads, the cache is beneficial if the same queries are repeated lots of times. -In general, the query results cache will provide the biggest improvements for queries with +In general, the query results cache provides the biggest improvements for queries with small result sets that take long to calculate. If query results are very big and most of the query time is spent on copying the result from the cache to the client, -then the cache will not provide much benefit. +then the cache does not provide much benefit. ## Global configuration -The query results cache can be configured at server start using the configuration parameter -`--query.cache-mode`. This will set the cache mode according to the descriptions -above. +The query results cache can be configured at server start with the +[`--query.cache-mode`](../../components/arangodb-server/options.md#--querycache-mode) +startup option. -After the server is started, the cache mode can be changed at runtime as follows: +The cache mode can also be changed at runtime using the JavaScript API as follows: ```js require("@arangodb/aql/cache").properties({ mode: "on" }); @@ -139,10 +139,10 @@ require("@arangodb/aql/cache").properties({ mode: "on" }); The maximum number of cached results in the cache for each database can be configured at server start using the following configuration parameters: -- `--query.cache-entries`: maximum number of results in query result cache per database -- `--query.cache-entries-max-size`: maximum cumulated size of results in query result cache per database -- `--query.cache-entry-max-size`: maximum size of an individual result entry in query result cache -- `--query.cache-include-system-collections`: whether or not to include system collection queries in the query result cache +- `--query.cache-entries`: The maximum number of results in the query results cache per database +- `--query.cache-entries-max-size`: The maximum cumulated size of results in the query results cache per database +- `--query.cache-entry-max-size`: The maximum size of an individual result entry in query results cache +- `--query.cache-include-system-collections`: Whether to include system collection queries in the query results cache These parameters can be used to put an upper bound on the number and size of query results in each database's query cache and thus restrict the cache's memory consumption. @@ -158,27 +158,32 @@ require("@arangodb/aql/cache").properties({ }); ``` -The above will limit the number of cached results in the query results cache to 200 -results per database, and to 8 MB cumulated query result size per database. The maximum -size of each query cache entry is restricted to 8MB. Queries that involve system +The above settings limit the number of cached results in the query results cache to 200 +results per database, and to 8 MiB cumulated query result size per database. The maximum +size of each query cache entry is restricted to 1 MiB. Queries that involve system collections are excluded from caching. +You can also change the configuration at runtime with the +[HTTP API](../../develop/http-api/queries/aql-query-results-cache.md). + ## Per-query configuration When a query is sent to the server for execution and the cache is set to `on` or `demand`, -the query executor will look into the query's `cache` attribute. If the query cache mode is -`on`, then not setting this attribute or setting it to anything but `false` will make the -query executor consult the query cache. If the query cache mode is `demand`, then setting -the `cache` attribute to `true` will make the executor look for the query in the query cache. -When the query cache mode is `off`, the executor will not look for the query in the cache. +the query executor checks the query's `cache` option. If the query cache mode is +`on`, then not setting this query option or setting it to anything but `false` makes the +query executor consult the query results cache. If the query cache mode is `demand`, then setting +the `cache` option to `true` makes the executor look for the query in the query results cache. +When the query cache mode is `off`, the executor does not look for the query in the cache. The `cache` attribute can be set as follows via the `db._createStatement()` function: ```js var stmt = db._createStatement({ query: "FOR doc IN users LIMIT 5 RETURN doc", - cache: true /* cache attribute set here */ -}); + options: { + cache: true + } +}); stmt.execute(); ``` @@ -186,16 +191,14 @@ stmt.execute(); When using the `db._query()` function, the `cache` attribute can be set as follows: ```js -db._query({ - query: "FOR doc IN users LIMIT 5 RETURN doc", - cache: true /* cache attribute set here */ -}); +db._query("FOR doc IN users LIMIT 5 RETURN doc", {}, { cache: true }); ``` -The `cache` attribute can be set via the HTTP REST API `POST /_api/cursor`, too. +You can also set the `cache` query option in the +[HTTP API](../../develop/http-api/queries/aql-queries.md#create-a-cursor). -Each query result returned will contain a `cached` attribute. This will be set to `true` -if the result was retrieved from the query cache, and `false` otherwise. Clients can use +Each query result returned contain a `cached` attribute. It is set to `true` +if the result was retrieved from the query results cache, and `false` otherwise. Clients can use this attribute to check if a specific query was served from the cache or not. ## Query results cache inspection @@ -207,7 +210,7 @@ The contents of the query results cache can be checked at runtime using the cach require("@arangodb/aql/cache").toArray(); ``` -This will return a list of all query results stored in the current database's query +This returns a list of all query results stored in the current database's query results cache. The query results cache for the current database can be cleared at runtime using the @@ -221,5 +224,5 @@ require("@arangodb/aql/cache").clear(); Query results that are returned from the query results cache may contain execution statistics stemming from the initial, uncached query execution. This means for a cached query results, -the *extra.stats* attribute may contain stale data, especially in terms of the *executionTime* -and *profile* attribute values. +the `extra.stats` attribute may contain stale data, especially in terms of the `executionTime` +and `profile` attribute values. diff --git a/site/content/3.12/aql/how-to-invoke-aql/with-arangosh.md b/site/content/3.12/aql/how-to-invoke-aql/with-arangosh.md index 1b31530288..b91699876f 100644 --- a/site/content/3.12/aql/how-to-invoke-aql/with-arangosh.md +++ b/site/content/3.12/aql/how-to-invoke-aql/with-arangosh.md @@ -195,26 +195,6 @@ db._query( ).toArray(); // Each batch needs to be fetched within 5 seconds ``` -#### `cache` - -Whether the AQL query results cache shall be used. If set to `false`, then any -query cache lookup is skipped for the query. If set to `true`, it leads to the -query cache being checked for the query **if** the query cache mode is either -set to `on` or `demand`. - -```js ---- -name: 02_workWithAQL_cache -description: '' ---- -db._query( - 'FOR i IN 1..20 RETURN i', - {}, - { cache: true }, - {} -); // result may get taken from cache -``` - #### `memoryLimit` To set a memory limit for the query, pass `options` to the `_query()` method. @@ -274,12 +254,44 @@ don't need to set it on a per-query level. #### `cache` -If you set `cache` to `true`, this puts the query result into the query result cache -if the query result is eligible for caching and the query cache is running in demand -mode. If set to `false`, the query result is not inserted into the query result -cache. Note that query results are never inserted into the query result cache if -the query result cache is disabled, and that they are automatically inserted into -the query result cache if it is active in non-demand mode. +Whether the [AQL query results cache](../execution-and-performance/caching-query-results.md) +shall be used for adding as well as for retrieving results. + +If the query cache mode is set to `demand` and you set the `cache` query option +to `true` for a query, then its query result is cached if it's eligible for +caching. If the query cache mode is set to `on`, query results are automatically +cached if they are eligible for caching unless you set the `cache` option to `false`. + +If you set the `cache` option to `false`, then any query cache lookup is skipped +for the query. If you set it to `true`, the query cache is checked a cached result +**if** the query cache mode is either set to `on` or `demand`. + +```js +--- +name: 02_workWithAQL_cache +description: '' +--- +var resultCache = require("@arangodb/aql/cache"); +resultCache.properties({ mode: "demand" }); +~resultCache.clear(); +db._query("FOR i IN 1..5 RETURN i", {}, { cache: true }); // Adds result to cache +db._query("FOR i IN 1..5 RETURN i", {}, { cache: true }); // Retrieves result from cache +db._query("FOR i IN 1..5 RETURN i", {}, { cache: false }); // Bypasses the cache +``` + +#### `usePlanCache` + +Set this option to `true` to utilize a cached query plan or add the execution plan +of this query to the cache if it's not in the cache yet. Otherwise, the plan cache +is bypassed. + +Query plan caching can reduce the total time for processing queries by avoiding +to parse, plan, and optimize queries over and over again that effectively have +the same execution plan with at most some changes to bind parameter values. + +An error is raised if a query doesn't meet the requirements for plan caching. +See [Cache eligibility](../execution-and-performance/caching-query-plans.md#cache-eligibility) +for details. #### `fillBlockCache` diff --git a/site/content/3.12/develop/http-api/queries/aql-queries.md b/site/content/3.12/develop/http-api/queries/aql-queries.md index 4921fcb608..df17d2a27a 100644 --- a/site/content/3.12/develop/http-api/queries/aql-queries.md +++ b/site/content/3.12/develop/http-api/queries/aql-queries.md @@ -348,13 +348,6 @@ paths: value will be used (default: 30 seconds). The time-to-live is renewed upon every access to the cursor. type: integer - cache: - description: | - flag to determine whether the AQL query results 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`. - type: boolean memoryLimit: description: | the maximum number of memory (measured in bytes) that the query is allowed to @@ -494,6 +487,35 @@ paths: All other resources are freed immediately (locks, RocksDB snapshots). The query will fail before it returns results in case of a conflict. type: boolean + cache: + description: | + Whether the [AQL query results cache](../../../aql/execution-and-performance/caching-query-results.md) + shall be used for adding as well as for retrieving results. + + If the query cache mode is set to `demand` and you set the `cache` query option + to `true` for a query, then its query result is cached if it's eligible for + caching. If the query cache mode is set to `on`, query results are automatically + cached if they are eligible for caching unless you set the `cache` option to `false`. + + If you set the `cache` option to `false`, then any query cache lookup is skipped + for the query. If you set it to `true`, the query cache is checked for a cached result + **if** the query cache mode is either set to `on` or `demand`. + type: boolean + usePlanCache: + description: | + Set this option to `true` to utilize a cached query plan or add the execution plan + of this query to the cache if it's not in the cache yet. Otherwise, the plan cache + is bypassed (introduced in v3.12.4). + + Query plan caching can reduce the total time for processing queries by avoiding + to parse, plan, and optimize queries over and over again that effectively have + the same execution plan with at most some changes to bind parameter values. + + An error is raised if a query doesn't meet the requirements for plan caching. + See [Cache eligibility](../../../aql/execution-and-performance/caching-query-plans.md#cache-eligibility) + for details. + type: boolean + default: false spillOverThresholdMemoryUsage: description: | This option allows queries to store intermediate and final results temporarily @@ -555,7 +577,7 @@ paths: description: | If set to `true` or `1`, then the additional query profiling information is returned in the `profile` sub-attribute of the `extra` return attribute, unless the query result - is served from the query cache. If set to `2`, the query includes execution stats + is served from the query results cache. If set to `2`, the query includes execution stats per query plan node in `stats.nodes` sub-attribute of the `extra` return attribute. Additionally, the query plan is returned in the `extra.plan` sub-attribute. type: integer @@ -979,10 +1001,15 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean + planCacheKey: + description: | + The key of the plan cache entry. This attribute is only + present if a cached query execution plan has been used. + type: string '400': description: | is returned if the JSON representation is malformed, the query specification is @@ -1724,10 +1751,15 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean + planCacheKey: + description: | + The key of the plan cache entry. This attribute is only + present if a cached query execution plan has been used. + type: string '400': description: | If the cursor identifier is omitted, the server will respond with *HTTP 404*. @@ -2362,10 +2394,15 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean + planCacheKey: + description: | + The key of the plan cache entry. This attribute is only + present if a cached query execution plan has been used. + type: string '400': description: | If the cursor and the batch identifier are omitted, the server responds with @@ -3018,10 +3055,47 @@ paths: type: boolean maxNumberOfPlans: description: | - an optional maximum number of plans that the optimizer is - allowed to generate. Setting this attribute to a low value allows to put a + The maximum number of plans that the optimizer is allowed to + generate. Setting this attribute to a low value allows to put a cap on the amount of work the optimizer does. type: integer + fullCount: + description: | + Whether to calculate the total number of documents matching the + filter conditions as if the query's final top-level `LIMIT` operation + were not applied. This option generally leads to different + execution plans. + type: boolean + profile: + description: | + Whether to include additional query profiling information. + If set to `2`, the response includes the time it took to process + each optimizer rule under `stats.rules`. + type: integer + maxNodesPerCallstack: + description: | + The number of execution nodes in the query plan after that stack splitting is + performed to avoid a potential stack overflow. Defaults to the configured value + of the startup option `--query.max-nodes-per-callstack`. + + This option is only useful for testing and debugging and normally does not need + any adjustment. + type: integer + maxWarningCount: + description: | + Limits the number of warnings a query can return. The maximum number of warnings + is `10` by default but you can increase or decrease the limit. + type: integer + failOnWarning: + description: | + If set to `true`, the query throws an exception and aborts instead of producing + a warning. You should use this option during development to catch potential issues + early. When the attribute is set to `false`, warnings are not propagated to + exceptions and are returned with the query result. + + You can use the `--query.fail-on-warning` startup option to adjust the + default value for `failOnWarning` so you don't need to set it on a per-query basis. + type: boolean optimizer: description: | Options related to the query optimizer. @@ -3036,6 +3110,21 @@ paths: type: array items: type: string + usePlanCache: + description: | + Set this option to `true` to utilize a cached query plan or add the execution plan + of this query to the cache if it's not in the cache yet. Otherwise, the plan cache + is bypassed (introduced in v3.12.4). + + Query plan caching can reduce the total time for processing queries by avoiding + to parse, plan, and optimize queries over and over again that effectively have + the same execution plan with at most some changes to bind parameter values. + + An error is raised if a query doesn't meet the requirements for plan caching. + See [Cache eligibility](../../../aql/execution-and-performance/caching-query-plans.md#cache-eligibility) + for details. + type: boolean + default: false responses: '200': description: | diff --git a/site/content/3.12/develop/http-api/queries/aql-query-plan-cache.md b/site/content/3.12/develop/http-api/queries/aql-query-plan-cache.md new file mode 100644 index 0000000000..2a87026d91 --- /dev/null +++ b/site/content/3.12/develop/http-api/queries/aql-query-plan-cache.md @@ -0,0 +1,194 @@ +--- +title: HTTP interface for the query plan cache +menuTitle: AQL query plan cache +weight: 9 +description: >- + The query plan cache HTTP API lets you list the AQL execution plans that + are in the cache as well as clear the cache +--- +Introduced in: v3.12.4 + +To cache execution plans for AQL queries as well as to utilize cached plans, +set the `usePlanCache` query option to `true` when issuing a query. See +[HTTP interfaces for AQL queries](aql-queries.md#create-a-cursor) for details +and [The execution plan cache for AQL queries](../../../aql/execution-and-performance/caching-query-plans.md) +for general information about the feature. + +## List the entries of the AQL query plan cache + +```openapi +paths: + /_db/{database-name}/_api/query-plan-cache: + get: + operationId: listQueryCachePlans + description: | + Returns an array containing information about each AQL execution plan + currently stored in the cache of the selected database. + + This requires read privileges for the current database. In addition, only those + query plans are returned for which the current user has at least read permissions + on all collections and Views included in the query. + parameters: + - name: database-name + in: path + required: true + example: _system + description: | + The name of the database. + schema: + type: string + responses: + '200': + description: | + The list of cached query plans. + content: + application/json: + schema: + description: | + The entries of the query plan cache. + type: array + items: + description: | + The properties of a cache entry. + type: object + required: + - hash + - query + - queryHash + - bindVars + - fullCount + - dataSources + - created + - hits + - memoryUsage + properties: + hash: + description: | + The plan cache key. + type: string + query: + description: | + The query string. + type: string + queryHash: + description: | + The hash value of the query string. + type: integer + bindVars: + description: | + A subset of the original bind parameters with only the + collection bind parameters (e.g. `@@coll`). They need to + have the same names and values for utilizing a cached plan. + type: object + fullCount: + description: | + The value of the `fullCount` query option in the + original query. This option generally leads to different + execution plans. + type: boolean + dataSources: + description: | + The collections and Views involved in the query. + type: array + items: + type: string + created: + description: | + The date and time at which the query plan has been added + to the cache (in ISO 8601 format). + type: string + format: date-time + hits: + description: | + How many times the cached plan has been utilized so far. + type: integer + memoryUsage: + description: | + How much memory the plan cache entry takes up for the + execution plan, query string, and so on (in bytes). + type: integer + tags: + - Queries +``` + +```curl +--- +name: HttpListQueryPlanCache +description: | + Retrieve the entries stored in the AQL query plan cache of the current database: +--- +db._create("coll"); +for (let i = 0; i < 3; i++) { + db._query("FOR doc IN @@coll FILTER doc.attr == @val RETURN doc", { + "@coll": "coll", val: "foo" + }, { usePlanCache: true }); +} +db._query("RETURN 42", {}, { usePlanCache: true }); + +var url = "/_api/query-plan-cache"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.length >= 2); +logJsonResponse(response); + +db._drop("coll"); +``` + +## Clear the AQL query plan cache + +```openapi +paths: + /_db/{database-name}/_api/query-plan-cache: + delete: + operationId: deleteAqlQueryPlanCache + description: | + Clears all execution plans stored in the AQL query plan cache for the + current database. + + This requires write privileges for the current database. + parameters: + - name: database-name + in: path + required: true + example: _system + description: | + The name of the database. + schema: + type: string + responses: + '200': + description: | + The query plan cache has been cleared for the current database. + content: + application/json: + schema: + type: object + required: + - error + - code + properties: + error: + description: | + A flag indicating that no error occurred. + type: boolean + example: false + code: + description: | + The HTTP response status code. + type: integer + example: 200 + tags: + - Queries +``` + +```curl +--- +name: HttpClearQueryPlanCache +description: | + Clear the AQL query plan cache of the current database: +--- +var url = "/_api/query-plan-cache"; +var response = logCurlRequest('DELETE', url); +assert(response.code === 200); +logJsonResponse(response); +``` diff --git a/site/content/3.12/develop/http-api/queries/aql-query-results-cache.md b/site/content/3.12/develop/http-api/queries/aql-query-results-cache.md index 14873d57fa..77325280a4 100644 --- a/site/content/3.12/develop/http-api/queries/aql-query-results-cache.md +++ b/site/content/3.12/develop/http-api/queries/aql-query-results-cache.md @@ -1,10 +1,18 @@ --- -title: HTTP interface for the query cache +title: HTTP interface for the query results cache menuTitle: AQL query results cache weight: 10 description: >- - The query cache HTTP API lets you control the cache for AQL query results + The query results cache HTTP API lets you control the cache for AQL query results --- +See [The AQL query results cache](../../../aql/execution-and-performance/caching-query-results.md) +for a description of the feature and the configuration options. + +{{< info >}} +The AQL query results cache is only available for single servers, i.e. servers that +are not part of a cluster setup. +{{< /info >}} + ## List the entries of the AQL query results cache ```openapi @@ -14,20 +22,7 @@ paths: operationId: listQueryCacheResults description: | Returns an array containing the AQL query results currently stored in the query results - cache of the selected database. Each result is a JSON object with the following attributes: - - - `hash`: the query result's hash - - `query`: the query string - - `bindVars`: the query's bind parameters. this attribute is only shown if tracking for - bind variables was enabled at server start - - `size`: the size of the query result and bind parameters, in bytes - - `results`: number of documents/rows in the query result - - `started`: the date and time when the query was stored in the cache - - `hits`: number of times the result was served from the cache (can be - `0` for queries that were only stored in the cache but were never accessed - again afterwards) - - `runTime`: the query's run time - - `dataSources`: an array of collections/Views the query was using + cache of the selected database. parameters: - name: database-name in: path @@ -40,14 +35,103 @@ paths: responses: '200': description: | - Is returned when the list of results can be retrieved successfully. + The list of cached query results. + content: + application/json: + schema: + description: | + The entries of the query results cache. + type: array + items: + description: | + The properties of a cache entry. + type: object + required: + - hash + - query + - size + - results + - hits + - runTime + - started + - dataSources + properties: + hash: + description: | + The hash value calculated from the the query string, + certain query options, and the bind variables. + type: string + query: + description: | + The query string. + type: string + bindVars: + description: | + The bind parameters. This attribute is omitted if the + `--query.tracking-with-bindvars` startup option is set + to `false`. + type: object + size: + description: | + The size of the query result and bind parameters (in bytes). + type: integer + results: + description: | + The number of documents/rows in the query result. + type: integer + started: + description: | + The date and time at which the query result has been added + to the cache (in ISO 8601 format). + type: string + format: date-time + hits: + description: | + How many times the result has been served from the cache so far. + type: integer + runTime: + description: | + The total duration of the query in seconds. + type: number + dataSources: + description: | + The collections and Views involved in the query. + type: array + items: + type: string '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpListQueryResultsCache +description: | + Retrieve the entries stored in the AQL query results cache of the current database: +--- +var resultsCache = require("@arangodb/aql/cache"); +resultsCache.properties({ mode: "demand" }); + +db._create("coll"); +for (let i = 0; i < 3; i++) { + db._query("FOR doc IN @@coll FILTER doc.attr == @val RETURN doc", { + "@coll": "coll", val: "foo" + }, { cache: true, fullCount: true }); +} +db._query("RETURN 42", {}, { cache: true }); + +var url = "/_api/query-cache/entries"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.length >= 2); +logJsonResponse(response); + +db._drop("coll"); +``` + ## Clear the AQL query results cache ```openapi @@ -69,15 +153,44 @@ paths: responses: '200': description: | - The server will respond with *HTTP 200* when the cache was cleared - successfully. + The results cache has been cleared. + content: + application/json: + schema: + type: object + required: + - error + - code + properties: + error: + description: | + A flag indicating that no error occurred. + type: boolean + example: false + code: + description: | + The HTTP response status code. + type: integer + example: 200 '400': description: | - The server will respond with *HTTP 400* in case of a malformed request. + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpClearQueryResultsCache +description: | + Clear the AQL query results cache of the current database: +--- +var url = "/_api/query-cache"; +var response = logCurlRequest('DELETE', url); +assert(response.code === 200); +logJsonResponse(response); +``` + ## Get the AQL query results cache configuration ```openapi @@ -86,23 +199,7 @@ paths: get: operationId: getQueryCacheProperties description: | - Returns the global AQL query results cache configuration. The configuration is a - JSON object with the following properties: - - - `mode`: the mode the AQL query results cache operates in. The mode is one of the following - values: `off`, `on`, or `demand`. - - - `maxResults`: the maximum number of query results that will be stored per database-specific - cache. - - - `maxResultsSize`: the maximum cumulated size of query results that will be stored per - database-specific cache. - - - `maxEntrySize`: the maximum individual result size of queries that will be stored per - database-specific cache. - - - `includeSystem`: whether or not results of queries that involve system collections will be - stored in the query results cache. + Returns the global AQL query results cache configuration. parameters: - name: database-name in: path @@ -117,14 +214,62 @@ paths: responses: '200': description: | - Is returned if the properties can be retrieved successfully. + The result cache configuration is returned successfully. + content: + application/json: + schema: + description: | + The result cache configuration. + type: object + properties: + mode: + description: | + The mode the AQL query results cache operates in. + type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] + maxResults: + description: | + The maximum number of query results that are stored per + database-specific cache. + type: integer + maxResultsSize: + description: | + The maximum cumulated size of query results that are + stored per database-specific cache (in bytes). + type: integer + maxEntrySize: + description: | + The maximum individual result size of queries that are + stored per database-specific cache (in bytes). + includeSystem: + description: | + Whether results of queries that involve system collections + are stored in the query results cache. + type: boolean '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpGetQueryResultsCacheProperties +description: | + Retrieve the global configuration of the AQL query results cache: +--- +var resultsCache = require("@arangodb/aql/cache"); +resultsCache.properties({ mode: "demand" }); + +var url = "/_api/query-cache/properties"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.mode == "demand"); +logJsonResponse(response); +``` + ## Set the AQL query results cache configuration ```openapi @@ -135,14 +280,7 @@ paths: description: | Adjusts the global properties for the AQL query results cache. - After the properties have been changed, the current set of properties will - be returned in the HTTP response. - - Note: changing the properties may invalidate all results in the cache. - - The properties need to be passed in the `properties` attribute in the body - of the HTTP request. `properties` needs to be a JSON object with the following - properties: + Changing the properties may invalidate all results currently in the cache. parameters: - name: database-name in: path @@ -158,35 +296,90 @@ paths: content: application/json: schema: + description: | + The result cache configuration settings to change. type: object properties: mode: description: | - the mode the AQL query cache should operate in. Possible values are `off`, `on`, or `demand`. + The mode the AQL query cache shall operate in. type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] maxResults: description: | - the maximum number of query results that will be stored per database-specific cache. + The maximum number of query results that are stored per + database-specific cache. type: integer maxResultsSize: description: | - the maximum cumulated size of query results that will be stored per database-specific cache. + The maximum cumulated size of query results that are stored + per database-specific cache (in bytes). type: integer maxEntrySize: description: | - the maximum individual size of query results that will be stored per database-specific cache. + The maximum individual size of query results that are stored + per database-specific cache (in bytes). type: integer includeSystem: description: | - whether or not to store results of queries that involve system collections. + Whether to store results of queries that involve + system collections in the cache. type: boolean responses: '200': description: | - Is returned if the properties were changed successfully. + The result cache configuration has been changed successfully. + content: + application/json: + schema: + description: | + The result cache configuration. + type: object + properties: + mode: + description: | + The mode the AQL query results cache operates in. + type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] + maxResults: + description: | + The maximum number of query results that are stored per + database-specific cache. + type: integer + maxResultsSize: + description: | + The maximum cumulated size of query results that are + stored per database-specific cache (in bytes). + type: integer + maxEntrySize: + description: | + The maximum individual result size of queries that are + stored per database-specific cache (in bytes). + includeSystem: + description: | + Whether results of queries that involve system collections + are stored in the query results cache. + type: boolean '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` + +```curl +--- +name: HttpSetQueryResultsCacheProperties +description: | + Change some properties of the global configuration of the AQL query results cache: +--- +var url = "/_api/query-cache/properties"; +var body = { mode: "demand", maxResults: 32 }; +var response = logCurlRequest('PUT', url, body); +assert(response.code === 200); +assert(response.parsedBody.mode == "demand"); +assert(response.parsedBody.maxResults == 32); +logJsonResponse(response); +``` diff --git a/site/content/3.12/develop/javascript-api/_index.md b/site/content/3.12/develop/javascript-api/_index.md index 74f679b324..765edd61e0 100644 --- a/site/content/3.12/develop/javascript-api/_index.md +++ b/site/content/3.12/develop/javascript-api/_index.md @@ -155,8 +155,11 @@ You can use the following modules as an end-user: - [**@arangodb/aql/queries**](aql-queries.md) offers methods to track and kill AQL queries. + - [**@arangodb/aql/plan-cache**](../../aql/execution-and-performance/caching-query-plans.md) + lets you list and clear the entries of the AQL execution plan cache. + - [**@arangodb/aql/cache**](../../aql/execution-and-performance/caching-query-results.md) - allows to control the AQL query caching feature. + allows to control the AQL query result caching feature. - [**@arangodb/aql/explainer**](../../aql/execution-and-performance/explaining-queries.md) provides methods to debug, explain and profile AQL queries. diff --git a/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md b/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md index 6c808f9bf7..0cc2ad922f 100644 --- a/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md +++ b/site/content/3.12/release-notes/version-3.12/api-changes-in-3-12.md @@ -283,6 +283,19 @@ endpoint to restore the original log levels. See the [Log API](../../develop/http-api/monitoring/logs.md#reset-the-server-log-levels) for details. +#### Query plan cache API + +Introduced in: v3.12.4 + +Two endpoints have been added to let you list the entries and clear the cache +for AQL execution plans. Query plan caching works on a per-database basis. + +- `GET /_api/query-plan-cache` +- `DELETE /_api/query-plan-cache` + +See [HTTP interface for the query plan cache](../../develop/http-api/queries/aql-query-plan-cache.md) +for details. + ### Endpoints augmented #### View API @@ -341,6 +354,29 @@ Two new statistics are included in the response when you execute an AQL query: } ``` +#### Query plan cache attributes + +Introduced in: v3.12.4 + +The following endpoints related to AQL queries support a new `usePlanCache` +query option in the `options` object: + +- `POST /_api/cursor` +- `POST /_api/explain` + +An error is raised if `usePlanCache` is set to `true` but the query is not +eligible for plan caching (a new error code +`ERROR_QUERY_NOT_ELIGIBLE_FOR_PLAN_CACHING` with the number `1584`). See +[The execution plan cache for AQL queries](../../aql/execution-and-performance/caching-query-plans.md) +for details. + +If a cached query plan is utilized, the above endpoints include a new +`planCacheKey` attribute at the top-level of the response with the key of the +cached plan (string). + +See [HTTP interfaces for AQL queries](../../develop/http-api/queries/aql-queries.md#cursors) +for details. + #### Index API ##### `optimizeTopK` for inverted indexes @@ -692,3 +728,12 @@ The option defaults to `false` so that fast locking is tried. See the [JavaScript API](../../develop/transactions/stream-transactions.md#javascript-api) for details. +#### Query plan cache module + +Introduced in: v3.12.4 + +The new `@arangodb/aql/plan-cache` module lets you list the entries (`.toArray()`) +and clear (`.clear()`) the AQL execution plan cache in the JavaScript API. + +See [The execution plan cache for AQL queries](../../aql/execution-and-performance/caching-query-plans.md#interfaces) +for details. diff --git a/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md b/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md index 79e83eea3e..dbe6ca6bc4 100644 --- a/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md +++ b/site/content/3.12/release-notes/version-3.12/whats-new-in-3-12.md @@ -970,6 +970,77 @@ In addition, shortest path searches may finish earlier now due to some optimizations to disregard candidate paths for which better candidates have been found already. +### Cache for query execution plans (experimental) + +Introduced in: v3.12.4 + +An optional execution plan cache for AQL queries has been added to let you skip query +planning and optimization when running the same queries repeatedly. This can +significantly reduce the total time for running particular queries where a lot +of time is spent on the query planning and optimization passes in proportion to +the actual execution. + +Query plans are not cached by default. You need to set the new `usePlanCache` +query option to `true` to utilize cached plans as well as to add plans to the +cache. Otherwise, the plan cache is bypassed. + +```js +db._query("FOR doc IN coll FILTER doc.attr == @val RETURN doc", { val: "foo" }, { usePlanCache: true }); +``` + +Not all AQL queries are eligible for plan caching. You can generally not cache +plans of queries where bind variables affect the structure of the execution plan +or the index utilization. +See [Cache eligibility](../../aql/execution-and-performance/caching-query-plans.md#cache-eligibility) +for details. + +HTTP API endpoints and a JavaScript API module have been added for clearing the +contents of the query plan cache and for retrieving the current plan cache entries. +See [The execution plan cache for AQL queries](../../aql/execution-and-performance/caching-query-plans.md#interfaces) +for details. + +```js +require("@arangodb/aql/plan-cache").toArray(); +``` + +```json +[ + { + "hash" : "2757239675060883499", + "query" : "FOR doc IN coll FILTER doc.attr == @val RETURN doc", + "queryHash" : 11382508862770890000, + "bindVars" : { + }, + "fullCount" : false, + "dataSources" : [ + "coll" + ], + "created" : "2024-11-20T17:21:34Z", + "hits" : 0, + "memoryUsage" : 3070 + } +] +``` + +The following startup options have been added to let you configure the plan cache: + +- `--query.plan-cache-max-entries`: The maximum number of plans in the + query plan cache per database. The default value is `128`. +- `--query.plan-cache-max-memory-usage`: The maximum total memory usage for the + query plan cache in each database. The default value is `8MB`. +- `--query.plan-cache-max-entry-size`: The maximum size of an individual entry + in the query plan cache in each database. The default value is `2MB`. +- `--query.plan-cache-invalidation-time`: The time in seconds after which a + query plan is invalidated in the query plan cache. + +The following metrics have been added to monitor the query plan cache: + +| Label | Description | +|:------|:------------| +| `arangodb_aql_query_plan_cache_hits_total` | Total number of lookup hits in the AQL query plan cache. | +| `arangodb_aql_query_plan_cache_memory_usage` | Total memory usage of all query plan caches across all databases. | +| `arangodb_aql_query_plan_cache_misses_total` | Total number of lookup misses in the AQL query plan cache. | + ## Indexing ### Multi-dimensional indexes diff --git a/site/content/3.13/about-arangodb/features/community-edition.md b/site/content/3.13/about-arangodb/features/community-edition.md index 7cb9dd1e73..2af527c50f 100644 --- a/site/content/3.13/about-arangodb/features/community-edition.md +++ b/site/content/3.13/about-arangodb/features/community-edition.md @@ -219,6 +219,12 @@ see [arangodb.com/community-server/](https://www.arangodb.com/community-server/) collection scans. Inlining of certain subqueries to improve execution time. +{{% comment %}} Experimental feature in v3.12.4 +- [**Query plan caching**](../../aql/execution-and-performance/caching-query-plans.md) + Reduce the total time for processing queries by avoiding to parse, plan, and + optimize the same queries over and over again with an AQL execution plan cache. +{{% /comment %}} + - [**Parallel gather**](../../release-notes/version-3.11/whats-new-in-3-11.md#parallel-gather): Fast, memory-efficient processing of cluster queries by combining results in parallel. diff --git a/site/content/3.13/about-arangodb/features/highlights-by-version.md b/site/content/3.13/about-arangodb/features/highlights-by-version.md index 7428b978d5..b55db460c8 100644 --- a/site/content/3.13/about-arangodb/features/highlights-by-version.md +++ b/site/content/3.13/about-arangodb/features/highlights-by-version.md @@ -49,6 +49,12 @@ Also see [What's New in 3.13](../../release-notes/version-3.13/whats-new-in-3-13 Speed up data transfers and reduce traffic with transparent compression of requests and responses between ArangoDB servers and client tools. +{{% comment %}} Experimental feature in v3.12.4 +- [**Query plan caching**](../../aql/execution-and-performance/caching-query-plans.md) + Reduce the total time for processing queries by avoiding to parse, plan, and + optimize the same queries over and over again with an AQL execution plan cache. +{{% /comment %}} + **Enterprise Edition** - [**ArangoSearch WAND optimization**](../../index-and-search/arangosearch/performance.md#wand-optimization): diff --git a/site/content/3.13/aql/execution-and-performance/caching-query-plans.md b/site/content/3.13/aql/execution-and-performance/caching-query-plans.md new file mode 100644 index 0000000000..792c381151 --- /dev/null +++ b/site/content/3.13/aql/execution-and-performance/caching-query-plans.md @@ -0,0 +1,224 @@ +--- +title: The execution plan cache for AQL queries +menuTitle: Caching query plans +weight: 29 +description: >- + AQL provides an optional cache for query plans to skip query planning and + optimization when running the same queries repeatedly +--- +Query plan caching can reduce the total time for processing queries by avoiding +to parse, plan, and optimize queries over and over again that effectively have +the same execution plan with at most some changes to bind parameter values. +It is especially useful for particular queries where a lot of time is spent on +the query planning and optimization passes in proportion to the actual execution. + +## Use plan caching for queries + +Query plans are not cached by default. You need to enable the query option for +plan caching on a per-query basis to utilize cached plans as well as to add +plans to the cache. Otherwise, the plan cache is bypassed. + +{{< tabs "interfaces" >}} + +{{< tab "Web interface" >}} +1. Click **Queries** in the main navigation. +2. Enter an AQL query and specify the values for bind variables if necessary. +3. Switch to the **Options** tab to access the query options. +4. Expand the **Advanced** panel. +5. Enable the **Use Plan Cache** option. +{{< /tab >}} + +{{< tab "arangosh" >}} +```js +--- +name: arangosh_cache_query_plan +description: '' +--- +~db._create("coll"); +var query = "FOR doc IN coll FILTER doc.attr == @val RETURN doc"; +var bindVars = { val: "foo" }; +db._query(query, bindVars, { usePlanCache: true }); // Adds plan to cache +db._query(query, bindVars, { usePlanCache: true }); // Uses cached plan +~db._drop("coll"); +``` + +See the [JavaScript API](../../develop/javascript-api/@arangodb/db-object.md#db_createcollection-name--properties--type--options) +for details. +{{< /tab >}} + +{{< tab "cURL" >}} +```sh +curl -d '{"query":"FOR doc IN coll FILTER doc.attr == @val RETURN doc","bindVars":{"val":"foo"},"options":{"usePlanCache":true}}' http://localhost:8529/_db/mydb/_api/cursor + +# The second time, the response includes a planCacheKey +curl -d '{"query":"FOR doc IN coll FILTER doc.attr == @val RETURN doc","bindVars":{"val":"foo"},"options":{"usePlanCache":true}}' http://localhost:8529/_db/mydb/_api/cursor +``` + +See the [HTTP API](../../develop/http-api/queries/aql-queries.md#create-a-cursor) +for details. +{{< /tab >}} + +{{< /tabs >}} + +## Cache eligibility + +If plan caching is enabled for a query, the eligibility for being cached is +checked first. An error is raised if a query doesn't meet the requirements. + +A query is not eligible for plan caching if it uses +**attribute name bind parameters** (e.g. `FILTER doc.@attributeName == ...`) +or when using **value bind parameters** in any of the following places: +- Specifying the depths for traversals or path queries + (e.g. `FOR v, e IN @min..@max OUTBOUND ...`) +- Referring to a named graph (e.g. `GRAPH @graphName`) +- Referring to edge collections used in traversals or path queries + (e.g. `FOR v, e IN 1..2 OUTBOUND 'v/0' @@edgeColl ...`) +- Specifying the offset or count for a `LIMIT` operation + (e.g. `LIMIT @offset, @count`) + +If a query produces any **warnings** during parsing or query plan optimization, +it is also not eligible for plan caching. + +Query plans are also not eligible for caching if they contain one of the +following execution node types in the plan: +- `SingleRemoteOperationNode` (cluster only) +- `MultipleRemoteModificationNode` (cluster only) +- `UpsertNode`, i.e. the AQL `UPSERT` operation + +Additionally, any queries that have any of the following **query options** set +are not eligible for plan caching: + +- `allPlans` +- `optimizer.rules` +- `explainRegisters` (internal) +- `inaccessibleCollections` (internal) +- `shardIds` (internal) + +If a query is eligible for plan caching, the plan cache is checked using +the exact same query string and set of collection bind parameter values. +A cached plan entry is only considered identical to the current query if the +query strings are identical byte for byte and the set of collection bind +parameters is exactly the same (bind parameter names and bind parameter +values). + +If no plan entry can be found in the plan cache, the query is planned and +optimized as usual, and the cached plan is inserted into the plan cache. +Repeated executions of the same query (same query string and using the same +set of collection bind parameters) then makes use of the cached plan +entry, potentially with different value bind parameters. + +The following query options are ignored when a cached plan is used: +- `joinStrategyType` +- `maxDNFConditionMembers` +- `maxNodesPerCallstack` + +Whenever a query uses a plan from the plan cache, the query +result includes a `planCacheKey` attribute at the top level when +executing, explaining, or profiling a query. The explain and profiling +outputs also indicate when a cached query plan was used, showing +`plan cache key: ...` at the top. + +## Cache invalidation and expiration + +The query plan cache is organized **per database**. It gets invalidated at the +following events: + +- An existing collection gets dropped or renamed, or the properties of an + existing collection are modified. +- An index is added to an existing collection or an index is dropped. +- An existing View gets dropped or renamed, or the properties of an existing + View are modified. +- A named graph is added, or an existing named graph is changed or gets dropped. + +These events typically remove all entries from the plan cache of the respective +database. In a single server deployment, only affected entries may get removed. + +Individual cache entries can expire if `--query.plan-cache-invalidation-time` +is set to a value greater than `0`. The configured duration for which cached +query plans are valid is relative to when they were added to the cache. Expired +entries are no longer used and eventually removed from the plan cache. + +## Configuration + +The memory usage of the query plan cache can be restricted using the following +startup options: + +- [`--query.plan-cache-max-entries`](../../components/arangodb-server/options.md#--queryplan-cache-max-entries) +- [`--query.plan-cache-max-memory-usage`](../../components/arangodb-server/options.md#--queryplan-cache-max-memory-usage) +- [`--query.plan-cache-max-entry-size`](../../components/arangodb-server/options.md#--queryplan-cache-max-entry-size) + +Note that each database has its own query plan cache, and that these options +are used for each individual plan cache. In a cluster, each Coordinator has its +own query plan cache. + +The expiration of cached plans can be configured with the following startup option: + +- [`--query.plan-cache-invalidation-time`](../../components/arangodb-server/options.md#--queryplan-cache-invalidation-time) + +## Interfaces + +### List the query plan cache entries + +Retrieve all entries in the query plan cache for the current database. + +This requires read privileges for the current database. In addition, only those +query plans are returned for which the current user has at least read permissions +on all collections and Views included in the query. + +{{< tabs "interfaces" >}} + +{{< tab "arangosh" >}} +```js +--- +name: arangosh_list_cached_query_plans +description: '' +--- +~db._create("coll"); +~db._query("RETURN 42", {}, { usePlanCache: true }); +~db._query("FOR doc IN coll FILTER doc.attr == @val RETURN doc", { val: "foo" }, { usePlanCache: true }); +var planCache = require("@arangodb/aql/plan-cache"); +planCache.toArray(); +~db._drop("coll"); +``` +{{< /tab >}} + +{{< tab "cURL" >}} +```sh +curl http://localhost:8529/_api/query-plan-cache +``` + +See the [HTTP API](../../develop/http-api/queries/aql-query-plan-cache.md#list-the-entries-of-the-aql-query-plan-cache) +for details. +{{< /tab >}} + +{{< /tabs >}} + +### Clear the query plan cache + +Delete all entries in the query plan cache for the current database. + +This requires write privileges for the current database. + +{{< tabs "interfaces" >}} + +{{< tab "arangosh" >}} +```js +--- +name: arangosh_clear_query_plan_cache +description: '' +--- +var planCache = require("@arangodb/aql/plan-cache"); +planCache.clear(); +``` +{{< /tab >}} + +{{< tab "cURL" >}} +```sh +curl -XDELETE http://localhost:8529/_api/query-plan-cache +``` + +See the [HTTP API](../../develop/http-api/queries/aql-query-plan-cache.md#clear-the-aql-query-plan-cache) +for details. +{{< /tab >}} + +{{< /tabs >}} diff --git a/site/content/3.13/aql/execution-and-performance/caching-query-results.md b/site/content/3.13/aql/execution-and-performance/caching-query-results.md index 2013dd0947..8e76741ee5 100644 --- a/site/content/3.13/aql/execution-and-performance/caching-query-results.md +++ b/site/content/3.13/aql/execution-and-performance/caching-query-results.md @@ -21,48 +21,48 @@ are not part of a cluster setup. The cache can be operated in the following modes: -- `off`: the cache is disabled. No query results will be stored -- `on`: the cache will store the results of all AQL queries unless their `cache` - attribute flag is set to `false` -- `demand`: the cache will store the results of AQL queries that have their - `cache` attribute set to `true`, but will ignore all others +- `off`: The cache is disabled. No query results are stored. +- `on`: The cache stores the results of all AQL queries unless the `cache` + query option is set to `false`. +- `demand`: The cache stores the results of AQL queries that have the + `cache` query option set to `true` but ignores all others. -The mode can be set at server startup and later changed at runtime. +The mode can be set at server startup as well as at runtime, see +[Global configuration](#global-configuration). ## Query eligibility -The query results cache will consider two queries identical if they have exactly the +The query results cache considers two queries identical if they have exactly the same query string and the same bind variables. Any deviation in terms of whitespace, -capitalization etc. will be considered a difference. The query string will be hashed -and used as the cache lookup key. If a query uses bind parameters, these will also be hashed -and used as part of the cache lookup key. - -That means even if the query strings of two queries are identical, the query results -cache will treat them as different queries if they have different bind parameter -values. Other components that will become part of a query's cache key are the -`count`, `fullCount` and `optimizer` attributes. - -If the cache is turned on, the cache will check at the very start of execution -whether it has a result ready for this particular query. If that is the case, -the query result will be served directly from the cache, which is normally -very efficient. If the query cannot be found in the cache, it will be executed +capitalization etc. is considered a difference. The query string is hashed +and used as the cache lookup key. If a query uses bind parameters, these are also +hashed and used as part of the cache lookup key. + +Even if the query strings of two queries are identical, the query results cache +treats them as different queries if they have different bind parameter +values. Other components that become part of a query's cache key are the +`count`, `fullCount`, and `optimizer` attributes. + +If the cache is enabled, it is checked whether it has a result ready for a +particular query at the very start of processing the query request. If this is +the case, the query result is served directly from the cache, which is normally +very efficient. If the query cannot be found in the cache, it is executed as usual. -If the query is eligible for caching and the cache is turned on, the query -result will be stored in the query results cache so it can be used for subsequent +If the query is eligible for caching and the cache is enabled, the query +result is stored in the query results cache so it can be used for subsequent executions of the same query. A query is eligible for caching only if all of the following conditions are met: -- the server the query executes on is a single server (i.e. not part of a cluster) -- the query string is at least 8 characters long -- the query is a read-only query and does not modify data in any collection -- no warnings were produced while executing the query -- the query is deterministic and only uses deterministic functions whose results - are marked as cacheable -- the size of the query result does not exceed the cache's configured maximal - size for individual cache results or cumulated results -- the query is not executed using a streaming cursor +- The server the query executes on is a single server (i.e. not part of a cluster). +- The query is a read-only query and does not modify data in any collection. +- No warnings were produced while executing the query. +- The query is deterministic and only uses deterministic functions whose results + are marked as cacheable. +- The size of the query result does not exceed the cache's configured maximal + size for individual cache results or cumulated results. +- The query is not executed using a streaming cursor (`"stream": true` query option). The usage of non-deterministic functions leads to a query not being cacheable. This is intentional to avoid caching of function results which should rather @@ -85,8 +85,8 @@ remove, truncate operations as well as AQL data-modification queries). **Example** If the result of the following query is present in the query results cache, -then either modifying data in collection `users` or in collection `organizations` -will remove the already computed result from the cache: +then either modifying data in the `users` or `organizations` collection +removes the already computed result from the cache: ```aql FOR user IN users @@ -95,42 +95,42 @@ FOR user IN users RETURN { user: user, organization: organization } ``` -Modifying data in other collections than the named two will not lead to this +Modifying data in other unrelated collections does not lead to this query result being removed from the cache. ## Performance considerations The query results cache is organized as a hash table, so looking up whether a query result -is present in the cache is relatively fast. Still, the query string and the bind -parameter used in the query will need to be hashed. This is a slight overhead that -will not be present if the cache is turned off or a query is marked as not cacheable. +is present in the cache is fast. Still, the query string and the bind +parameter used in the query need to be hashed. This is a slight overhead that +is not present if the cache is disabled or a query is marked as not cacheable. Additionally, storing query results in the cache and fetching results from the -cache requires locking via an R/W lock. While many thread can read in parallel from +cache requires locking via a read/write lock. While many thread can read in parallel from the cache, there can only be a single modifying thread at any given time. Modifications of the query cache contents are required when a query result is stored in the cache or during cache invalidation after data-modification operations. Cache invalidation -will require time proportional to the number of cached items that need to be invalidated. +requires time proportional to the number of cached items that need to be invalidated. -There may be workloads in which enabling the query results cache will lead to a performance +There may be workloads in which enabling the query results cache leads to a performance degradation. It is not recommended to turn the query results cache on in workloads that only -modify data, or that modify data more often than reading it. Turning on the cache -will also provide no benefit if queries are very diverse and do not repeat often. -In read-only or read-mostly workloads, the cache will be beneficial if the same +modify data, or that modify data more often than reading it. Enabling the cache +also provides no benefit if queries are very diverse and do not repeat often. +In read-only or read-mostly workloads, the cache is beneficial if the same queries are repeated lots of times. -In general, the query results cache will provide the biggest improvements for queries with +In general, the query results cache provides the biggest improvements for queries with small result sets that take long to calculate. If query results are very big and most of the query time is spent on copying the result from the cache to the client, -then the cache will not provide much benefit. +then the cache does not provide much benefit. ## Global configuration -The query results cache can be configured at server start using the configuration parameter -`--query.cache-mode`. This will set the cache mode according to the descriptions -above. +The query results cache can be configured at server start with the +[`--query.cache-mode`](../../components/arangodb-server/options.md#--querycache-mode) +startup option. -After the server is started, the cache mode can be changed at runtime as follows: +The cache mode can also be changed at runtime using the JavaScript API as follows: ```js require("@arangodb/aql/cache").properties({ mode: "on" }); @@ -139,10 +139,10 @@ require("@arangodb/aql/cache").properties({ mode: "on" }); The maximum number of cached results in the cache for each database can be configured at server start using the following configuration parameters: -- `--query.cache-entries`: maximum number of results in query result cache per database -- `--query.cache-entries-max-size`: maximum cumulated size of results in query result cache per database -- `--query.cache-entry-max-size`: maximum size of an individual result entry in query result cache -- `--query.cache-include-system-collections`: whether or not to include system collection queries in the query result cache +- `--query.cache-entries`: The maximum number of results in the query results cache per database +- `--query.cache-entries-max-size`: The maximum cumulated size of results in the query results cache per database +- `--query.cache-entry-max-size`: The maximum size of an individual result entry in query results cache +- `--query.cache-include-system-collections`: Whether to include system collection queries in the query results cache These parameters can be used to put an upper bound on the number and size of query results in each database's query cache and thus restrict the cache's memory consumption. @@ -158,27 +158,32 @@ require("@arangodb/aql/cache").properties({ }); ``` -The above will limit the number of cached results in the query results cache to 200 -results per database, and to 8 MB cumulated query result size per database. The maximum -size of each query cache entry is restricted to 8MB. Queries that involve system +The above settings limit the number of cached results in the query results cache to 200 +results per database, and to 8 MiB cumulated query result size per database. The maximum +size of each query cache entry is restricted to 1 MiB. Queries that involve system collections are excluded from caching. +You can also change the configuration at runtime with the +[HTTP API](../../develop/http-api/queries/aql-query-results-cache.md). + ## Per-query configuration When a query is sent to the server for execution and the cache is set to `on` or `demand`, -the query executor will look into the query's `cache` attribute. If the query cache mode is -`on`, then not setting this attribute or setting it to anything but `false` will make the -query executor consult the query cache. If the query cache mode is `demand`, then setting -the `cache` attribute to `true` will make the executor look for the query in the query cache. -When the query cache mode is `off`, the executor will not look for the query in the cache. +the query executor checks the query's `cache` option. If the query cache mode is +`on`, then not setting this query option or setting it to anything but `false` makes the +query executor consult the query results cache. If the query cache mode is `demand`, then setting +the `cache` option to `true` makes the executor look for the query in the query results cache. +When the query cache mode is `off`, the executor does not look for the query in the cache. The `cache` attribute can be set as follows via the `db._createStatement()` function: ```js var stmt = db._createStatement({ query: "FOR doc IN users LIMIT 5 RETURN doc", - cache: true /* cache attribute set here */ -}); + options: { + cache: true + } +}); stmt.execute(); ``` @@ -186,16 +191,14 @@ stmt.execute(); When using the `db._query()` function, the `cache` attribute can be set as follows: ```js -db._query({ - query: "FOR doc IN users LIMIT 5 RETURN doc", - cache: true /* cache attribute set here */ -}); +db._query("FOR doc IN users LIMIT 5 RETURN doc", {}, { cache: true }); ``` -The `cache` attribute can be set via the HTTP REST API `POST /_api/cursor`, too. +You can also set the `cache` query option in the +[HTTP API](../../develop/http-api/queries/aql-queries.md#create-a-cursor). -Each query result returned will contain a `cached` attribute. This will be set to `true` -if the result was retrieved from the query cache, and `false` otherwise. Clients can use +Each query result returned contain a `cached` attribute. It is set to `true` +if the result was retrieved from the query results cache, and `false` otherwise. Clients can use this attribute to check if a specific query was served from the cache or not. ## Query results cache inspection @@ -207,7 +210,7 @@ The contents of the query results cache can be checked at runtime using the cach require("@arangodb/aql/cache").toArray(); ``` -This will return a list of all query results stored in the current database's query +This returns a list of all query results stored in the current database's query results cache. The query results cache for the current database can be cleared at runtime using the @@ -221,5 +224,5 @@ require("@arangodb/aql/cache").clear(); Query results that are returned from the query results cache may contain execution statistics stemming from the initial, uncached query execution. This means for a cached query results, -the *extra.stats* attribute may contain stale data, especially in terms of the *executionTime* -and *profile* attribute values. +the `extra.stats` attribute may contain stale data, especially in terms of the `executionTime` +and `profile` attribute values. diff --git a/site/content/3.13/aql/how-to-invoke-aql/with-arangosh.md b/site/content/3.13/aql/how-to-invoke-aql/with-arangosh.md index 1b31530288..b91699876f 100644 --- a/site/content/3.13/aql/how-to-invoke-aql/with-arangosh.md +++ b/site/content/3.13/aql/how-to-invoke-aql/with-arangosh.md @@ -195,26 +195,6 @@ db._query( ).toArray(); // Each batch needs to be fetched within 5 seconds ``` -#### `cache` - -Whether the AQL query results cache shall be used. If set to `false`, then any -query cache lookup is skipped for the query. If set to `true`, it leads to the -query cache being checked for the query **if** the query cache mode is either -set to `on` or `demand`. - -```js ---- -name: 02_workWithAQL_cache -description: '' ---- -db._query( - 'FOR i IN 1..20 RETURN i', - {}, - { cache: true }, - {} -); // result may get taken from cache -``` - #### `memoryLimit` To set a memory limit for the query, pass `options` to the `_query()` method. @@ -274,12 +254,44 @@ don't need to set it on a per-query level. #### `cache` -If you set `cache` to `true`, this puts the query result into the query result cache -if the query result is eligible for caching and the query cache is running in demand -mode. If set to `false`, the query result is not inserted into the query result -cache. Note that query results are never inserted into the query result cache if -the query result cache is disabled, and that they are automatically inserted into -the query result cache if it is active in non-demand mode. +Whether the [AQL query results cache](../execution-and-performance/caching-query-results.md) +shall be used for adding as well as for retrieving results. + +If the query cache mode is set to `demand` and you set the `cache` query option +to `true` for a query, then its query result is cached if it's eligible for +caching. If the query cache mode is set to `on`, query results are automatically +cached if they are eligible for caching unless you set the `cache` option to `false`. + +If you set the `cache` option to `false`, then any query cache lookup is skipped +for the query. If you set it to `true`, the query cache is checked a cached result +**if** the query cache mode is either set to `on` or `demand`. + +```js +--- +name: 02_workWithAQL_cache +description: '' +--- +var resultCache = require("@arangodb/aql/cache"); +resultCache.properties({ mode: "demand" }); +~resultCache.clear(); +db._query("FOR i IN 1..5 RETURN i", {}, { cache: true }); // Adds result to cache +db._query("FOR i IN 1..5 RETURN i", {}, { cache: true }); // Retrieves result from cache +db._query("FOR i IN 1..5 RETURN i", {}, { cache: false }); // Bypasses the cache +``` + +#### `usePlanCache` + +Set this option to `true` to utilize a cached query plan or add the execution plan +of this query to the cache if it's not in the cache yet. Otherwise, the plan cache +is bypassed. + +Query plan caching can reduce the total time for processing queries by avoiding +to parse, plan, and optimize queries over and over again that effectively have +the same execution plan with at most some changes to bind parameter values. + +An error is raised if a query doesn't meet the requirements for plan caching. +See [Cache eligibility](../execution-and-performance/caching-query-plans.md#cache-eligibility) +for details. #### `fillBlockCache` diff --git a/site/content/3.13/develop/http-api/queries/aql-queries.md b/site/content/3.13/develop/http-api/queries/aql-queries.md index 4921fcb608..df17d2a27a 100644 --- a/site/content/3.13/develop/http-api/queries/aql-queries.md +++ b/site/content/3.13/develop/http-api/queries/aql-queries.md @@ -348,13 +348,6 @@ paths: value will be used (default: 30 seconds). The time-to-live is renewed upon every access to the cursor. type: integer - cache: - description: | - flag to determine whether the AQL query results 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`. - type: boolean memoryLimit: description: | the maximum number of memory (measured in bytes) that the query is allowed to @@ -494,6 +487,35 @@ paths: All other resources are freed immediately (locks, RocksDB snapshots). The query will fail before it returns results in case of a conflict. type: boolean + cache: + description: | + Whether the [AQL query results cache](../../../aql/execution-and-performance/caching-query-results.md) + shall be used for adding as well as for retrieving results. + + If the query cache mode is set to `demand` and you set the `cache` query option + to `true` for a query, then its query result is cached if it's eligible for + caching. If the query cache mode is set to `on`, query results are automatically + cached if they are eligible for caching unless you set the `cache` option to `false`. + + If you set the `cache` option to `false`, then any query cache lookup is skipped + for the query. If you set it to `true`, the query cache is checked for a cached result + **if** the query cache mode is either set to `on` or `demand`. + type: boolean + usePlanCache: + description: | + Set this option to `true` to utilize a cached query plan or add the execution plan + of this query to the cache if it's not in the cache yet. Otherwise, the plan cache + is bypassed (introduced in v3.12.4). + + Query plan caching can reduce the total time for processing queries by avoiding + to parse, plan, and optimize queries over and over again that effectively have + the same execution plan with at most some changes to bind parameter values. + + An error is raised if a query doesn't meet the requirements for plan caching. + See [Cache eligibility](../../../aql/execution-and-performance/caching-query-plans.md#cache-eligibility) + for details. + type: boolean + default: false spillOverThresholdMemoryUsage: description: | This option allows queries to store intermediate and final results temporarily @@ -555,7 +577,7 @@ paths: description: | If set to `true` or `1`, then the additional query profiling information is returned in the `profile` sub-attribute of the `extra` return attribute, unless the query result - is served from the query cache. If set to `2`, the query includes execution stats + is served from the query results cache. If set to `2`, the query includes execution stats per query plan node in `stats.nodes` sub-attribute of the `extra` return attribute. Additionally, the query plan is returned in the `extra.plan` sub-attribute. type: integer @@ -979,10 +1001,15 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean + planCacheKey: + description: | + The key of the plan cache entry. This attribute is only + present if a cached query execution plan has been used. + type: string '400': description: | is returned if the JSON representation is malformed, the query specification is @@ -1724,10 +1751,15 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean + planCacheKey: + description: | + The key of the plan cache entry. This attribute is only + present if a cached query execution plan has been used. + type: string '400': description: | If the cursor identifier is omitted, the server will respond with *HTTP 404*. @@ -2362,10 +2394,15 @@ paths: cached: description: | A boolean flag indicating whether the query result was served - from the query cache or not. If the query result is served from the query - cache, the `extra` return attribute will not contain any `stats` sub-attribute - and no `profile` sub-attribute. + from the query results cache or not. If the query result is served from the query + cache, the `extra` attribute in the response does not contain the `stats` + and `profile` sub-attributes. type: boolean + planCacheKey: + description: | + The key of the plan cache entry. This attribute is only + present if a cached query execution plan has been used. + type: string '400': description: | If the cursor and the batch identifier are omitted, the server responds with @@ -3018,10 +3055,47 @@ paths: type: boolean maxNumberOfPlans: description: | - an optional maximum number of plans that the optimizer is - allowed to generate. Setting this attribute to a low value allows to put a + The maximum number of plans that the optimizer is allowed to + generate. Setting this attribute to a low value allows to put a cap on the amount of work the optimizer does. type: integer + fullCount: + description: | + Whether to calculate the total number of documents matching the + filter conditions as if the query's final top-level `LIMIT` operation + were not applied. This option generally leads to different + execution plans. + type: boolean + profile: + description: | + Whether to include additional query profiling information. + If set to `2`, the response includes the time it took to process + each optimizer rule under `stats.rules`. + type: integer + maxNodesPerCallstack: + description: | + The number of execution nodes in the query plan after that stack splitting is + performed to avoid a potential stack overflow. Defaults to the configured value + of the startup option `--query.max-nodes-per-callstack`. + + This option is only useful for testing and debugging and normally does not need + any adjustment. + type: integer + maxWarningCount: + description: | + Limits the number of warnings a query can return. The maximum number of warnings + is `10` by default but you can increase or decrease the limit. + type: integer + failOnWarning: + description: | + If set to `true`, the query throws an exception and aborts instead of producing + a warning. You should use this option during development to catch potential issues + early. When the attribute is set to `false`, warnings are not propagated to + exceptions and are returned with the query result. + + You can use the `--query.fail-on-warning` startup option to adjust the + default value for `failOnWarning` so you don't need to set it on a per-query basis. + type: boolean optimizer: description: | Options related to the query optimizer. @@ -3036,6 +3110,21 @@ paths: type: array items: type: string + usePlanCache: + description: | + Set this option to `true` to utilize a cached query plan or add the execution plan + of this query to the cache if it's not in the cache yet. Otherwise, the plan cache + is bypassed (introduced in v3.12.4). + + Query plan caching can reduce the total time for processing queries by avoiding + to parse, plan, and optimize queries over and over again that effectively have + the same execution plan with at most some changes to bind parameter values. + + An error is raised if a query doesn't meet the requirements for plan caching. + See [Cache eligibility](../../../aql/execution-and-performance/caching-query-plans.md#cache-eligibility) + for details. + type: boolean + default: false responses: '200': description: | diff --git a/site/content/3.13/develop/http-api/queries/aql-query-plan-cache.md b/site/content/3.13/develop/http-api/queries/aql-query-plan-cache.md new file mode 100644 index 0000000000..2a87026d91 --- /dev/null +++ b/site/content/3.13/develop/http-api/queries/aql-query-plan-cache.md @@ -0,0 +1,194 @@ +--- +title: HTTP interface for the query plan cache +menuTitle: AQL query plan cache +weight: 9 +description: >- + The query plan cache HTTP API lets you list the AQL execution plans that + are in the cache as well as clear the cache +--- +Introduced in: v3.12.4 + +To cache execution plans for AQL queries as well as to utilize cached plans, +set the `usePlanCache` query option to `true` when issuing a query. See +[HTTP interfaces for AQL queries](aql-queries.md#create-a-cursor) for details +and [The execution plan cache for AQL queries](../../../aql/execution-and-performance/caching-query-plans.md) +for general information about the feature. + +## List the entries of the AQL query plan cache + +```openapi +paths: + /_db/{database-name}/_api/query-plan-cache: + get: + operationId: listQueryCachePlans + description: | + Returns an array containing information about each AQL execution plan + currently stored in the cache of the selected database. + + This requires read privileges for the current database. In addition, only those + query plans are returned for which the current user has at least read permissions + on all collections and Views included in the query. + parameters: + - name: database-name + in: path + required: true + example: _system + description: | + The name of the database. + schema: + type: string + responses: + '200': + description: | + The list of cached query plans. + content: + application/json: + schema: + description: | + The entries of the query plan cache. + type: array + items: + description: | + The properties of a cache entry. + type: object + required: + - hash + - query + - queryHash + - bindVars + - fullCount + - dataSources + - created + - hits + - memoryUsage + properties: + hash: + description: | + The plan cache key. + type: string + query: + description: | + The query string. + type: string + queryHash: + description: | + The hash value of the query string. + type: integer + bindVars: + description: | + A subset of the original bind parameters with only the + collection bind parameters (e.g. `@@coll`). They need to + have the same names and values for utilizing a cached plan. + type: object + fullCount: + description: | + The value of the `fullCount` query option in the + original query. This option generally leads to different + execution plans. + type: boolean + dataSources: + description: | + The collections and Views involved in the query. + type: array + items: + type: string + created: + description: | + The date and time at which the query plan has been added + to the cache (in ISO 8601 format). + type: string + format: date-time + hits: + description: | + How many times the cached plan has been utilized so far. + type: integer + memoryUsage: + description: | + How much memory the plan cache entry takes up for the + execution plan, query string, and so on (in bytes). + type: integer + tags: + - Queries +``` + +```curl +--- +name: HttpListQueryPlanCache +description: | + Retrieve the entries stored in the AQL query plan cache of the current database: +--- +db._create("coll"); +for (let i = 0; i < 3; i++) { + db._query("FOR doc IN @@coll FILTER doc.attr == @val RETURN doc", { + "@coll": "coll", val: "foo" + }, { usePlanCache: true }); +} +db._query("RETURN 42", {}, { usePlanCache: true }); + +var url = "/_api/query-plan-cache"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.length >= 2); +logJsonResponse(response); + +db._drop("coll"); +``` + +## Clear the AQL query plan cache + +```openapi +paths: + /_db/{database-name}/_api/query-plan-cache: + delete: + operationId: deleteAqlQueryPlanCache + description: | + Clears all execution plans stored in the AQL query plan cache for the + current database. + + This requires write privileges for the current database. + parameters: + - name: database-name + in: path + required: true + example: _system + description: | + The name of the database. + schema: + type: string + responses: + '200': + description: | + The query plan cache has been cleared for the current database. + content: + application/json: + schema: + type: object + required: + - error + - code + properties: + error: + description: | + A flag indicating that no error occurred. + type: boolean + example: false + code: + description: | + The HTTP response status code. + type: integer + example: 200 + tags: + - Queries +``` + +```curl +--- +name: HttpClearQueryPlanCache +description: | + Clear the AQL query plan cache of the current database: +--- +var url = "/_api/query-plan-cache"; +var response = logCurlRequest('DELETE', url); +assert(response.code === 200); +logJsonResponse(response); +``` diff --git a/site/content/3.13/develop/http-api/queries/aql-query-results-cache.md b/site/content/3.13/develop/http-api/queries/aql-query-results-cache.md index 14873d57fa..77325280a4 100644 --- a/site/content/3.13/develop/http-api/queries/aql-query-results-cache.md +++ b/site/content/3.13/develop/http-api/queries/aql-query-results-cache.md @@ -1,10 +1,18 @@ --- -title: HTTP interface for the query cache +title: HTTP interface for the query results cache menuTitle: AQL query results cache weight: 10 description: >- - The query cache HTTP API lets you control the cache for AQL query results + The query results cache HTTP API lets you control the cache for AQL query results --- +See [The AQL query results cache](../../../aql/execution-and-performance/caching-query-results.md) +for a description of the feature and the configuration options. + +{{< info >}} +The AQL query results cache is only available for single servers, i.e. servers that +are not part of a cluster setup. +{{< /info >}} + ## List the entries of the AQL query results cache ```openapi @@ -14,20 +22,7 @@ paths: operationId: listQueryCacheResults description: | Returns an array containing the AQL query results currently stored in the query results - cache of the selected database. Each result is a JSON object with the following attributes: - - - `hash`: the query result's hash - - `query`: the query string - - `bindVars`: the query's bind parameters. this attribute is only shown if tracking for - bind variables was enabled at server start - - `size`: the size of the query result and bind parameters, in bytes - - `results`: number of documents/rows in the query result - - `started`: the date and time when the query was stored in the cache - - `hits`: number of times the result was served from the cache (can be - `0` for queries that were only stored in the cache but were never accessed - again afterwards) - - `runTime`: the query's run time - - `dataSources`: an array of collections/Views the query was using + cache of the selected database. parameters: - name: database-name in: path @@ -40,14 +35,103 @@ paths: responses: '200': description: | - Is returned when the list of results can be retrieved successfully. + The list of cached query results. + content: + application/json: + schema: + description: | + The entries of the query results cache. + type: array + items: + description: | + The properties of a cache entry. + type: object + required: + - hash + - query + - size + - results + - hits + - runTime + - started + - dataSources + properties: + hash: + description: | + The hash value calculated from the the query string, + certain query options, and the bind variables. + type: string + query: + description: | + The query string. + type: string + bindVars: + description: | + The bind parameters. This attribute is omitted if the + `--query.tracking-with-bindvars` startup option is set + to `false`. + type: object + size: + description: | + The size of the query result and bind parameters (in bytes). + type: integer + results: + description: | + The number of documents/rows in the query result. + type: integer + started: + description: | + The date and time at which the query result has been added + to the cache (in ISO 8601 format). + type: string + format: date-time + hits: + description: | + How many times the result has been served from the cache so far. + type: integer + runTime: + description: | + The total duration of the query in seconds. + type: number + dataSources: + description: | + The collections and Views involved in the query. + type: array + items: + type: string '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpListQueryResultsCache +description: | + Retrieve the entries stored in the AQL query results cache of the current database: +--- +var resultsCache = require("@arangodb/aql/cache"); +resultsCache.properties({ mode: "demand" }); + +db._create("coll"); +for (let i = 0; i < 3; i++) { + db._query("FOR doc IN @@coll FILTER doc.attr == @val RETURN doc", { + "@coll": "coll", val: "foo" + }, { cache: true, fullCount: true }); +} +db._query("RETURN 42", {}, { cache: true }); + +var url = "/_api/query-cache/entries"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.length >= 2); +logJsonResponse(response); + +db._drop("coll"); +``` + ## Clear the AQL query results cache ```openapi @@ -69,15 +153,44 @@ paths: responses: '200': description: | - The server will respond with *HTTP 200* when the cache was cleared - successfully. + The results cache has been cleared. + content: + application/json: + schema: + type: object + required: + - error + - code + properties: + error: + description: | + A flag indicating that no error occurred. + type: boolean + example: false + code: + description: | + The HTTP response status code. + type: integer + example: 200 '400': description: | - The server will respond with *HTTP 400* in case of a malformed request. + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpClearQueryResultsCache +description: | + Clear the AQL query results cache of the current database: +--- +var url = "/_api/query-cache"; +var response = logCurlRequest('DELETE', url); +assert(response.code === 200); +logJsonResponse(response); +``` + ## Get the AQL query results cache configuration ```openapi @@ -86,23 +199,7 @@ paths: get: operationId: getQueryCacheProperties description: | - Returns the global AQL query results cache configuration. The configuration is a - JSON object with the following properties: - - - `mode`: the mode the AQL query results cache operates in. The mode is one of the following - values: `off`, `on`, or `demand`. - - - `maxResults`: the maximum number of query results that will be stored per database-specific - cache. - - - `maxResultsSize`: the maximum cumulated size of query results that will be stored per - database-specific cache. - - - `maxEntrySize`: the maximum individual result size of queries that will be stored per - database-specific cache. - - - `includeSystem`: whether or not results of queries that involve system collections will be - stored in the query results cache. + Returns the global AQL query results cache configuration. parameters: - name: database-name in: path @@ -117,14 +214,62 @@ paths: responses: '200': description: | - Is returned if the properties can be retrieved successfully. + The result cache configuration is returned successfully. + content: + application/json: + schema: + description: | + The result cache configuration. + type: object + properties: + mode: + description: | + The mode the AQL query results cache operates in. + type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] + maxResults: + description: | + The maximum number of query results that are stored per + database-specific cache. + type: integer + maxResultsSize: + description: | + The maximum cumulated size of query results that are + stored per database-specific cache (in bytes). + type: integer + maxEntrySize: + description: | + The maximum individual result size of queries that are + stored per database-specific cache (in bytes). + includeSystem: + description: | + Whether results of queries that involve system collections + are stored in the query results cache. + type: boolean '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` +```curl +--- +name: HttpGetQueryResultsCacheProperties +description: | + Retrieve the global configuration of the AQL query results cache: +--- +var resultsCache = require("@arangodb/aql/cache"); +resultsCache.properties({ mode: "demand" }); + +var url = "/_api/query-cache/properties"; +var response = logCurlRequest('GET', url); +assert(response.code === 200); +assert(response.parsedBody.mode == "demand"); +logJsonResponse(response); +``` + ## Set the AQL query results cache configuration ```openapi @@ -135,14 +280,7 @@ paths: description: | Adjusts the global properties for the AQL query results cache. - After the properties have been changed, the current set of properties will - be returned in the HTTP response. - - Note: changing the properties may invalidate all results in the cache. - - The properties need to be passed in the `properties` attribute in the body - of the HTTP request. `properties` needs to be a JSON object with the following - properties: + Changing the properties may invalidate all results currently in the cache. parameters: - name: database-name in: path @@ -158,35 +296,90 @@ paths: content: application/json: schema: + description: | + The result cache configuration settings to change. type: object properties: mode: description: | - the mode the AQL query cache should operate in. Possible values are `off`, `on`, or `demand`. + The mode the AQL query cache shall operate in. type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] maxResults: description: | - the maximum number of query results that will be stored per database-specific cache. + The maximum number of query results that are stored per + database-specific cache. type: integer maxResultsSize: description: | - the maximum cumulated size of query results that will be stored per database-specific cache. + The maximum cumulated size of query results that are stored + per database-specific cache (in bytes). type: integer maxEntrySize: description: | - the maximum individual size of query results that will be stored per database-specific cache. + The maximum individual size of query results that are stored + per database-specific cache (in bytes). type: integer includeSystem: description: | - whether or not to store results of queries that involve system collections. + Whether to store results of queries that involve + system collections in the cache. type: boolean responses: '200': description: | - Is returned if the properties were changed successfully. + The result cache configuration has been changed successfully. + content: + application/json: + schema: + description: | + The result cache configuration. + type: object + properties: + mode: + description: | + The mode the AQL query results cache operates in. + type: string + # Unquoted on and off are booleans in YAML 1.1! + enum: ["off", "on", "demand"] + maxResults: + description: | + The maximum number of query results that are stored per + database-specific cache. + type: integer + maxResultsSize: + description: | + The maximum cumulated size of query results that are + stored per database-specific cache (in bytes). + type: integer + maxEntrySize: + description: | + The maximum individual result size of queries that are + stored per database-specific cache (in bytes). + includeSystem: + description: | + Whether results of queries that involve system collections + are stored in the query results cache. + type: boolean '400': description: | - The server will respond with *HTTP 400* in case of a malformed request, + The request is malformed. tags: - Queries ``` + +```curl +--- +name: HttpSetQueryResultsCacheProperties +description: | + Change some properties of the global configuration of the AQL query results cache: +--- +var url = "/_api/query-cache/properties"; +var body = { mode: "demand", maxResults: 32 }; +var response = logCurlRequest('PUT', url, body); +assert(response.code === 200); +assert(response.parsedBody.mode == "demand"); +assert(response.parsedBody.maxResults == 32); +logJsonResponse(response); +``` diff --git a/site/content/3.13/develop/javascript-api/_index.md b/site/content/3.13/develop/javascript-api/_index.md index 74f679b324..765edd61e0 100644 --- a/site/content/3.13/develop/javascript-api/_index.md +++ b/site/content/3.13/develop/javascript-api/_index.md @@ -155,8 +155,11 @@ You can use the following modules as an end-user: - [**@arangodb/aql/queries**](aql-queries.md) offers methods to track and kill AQL queries. + - [**@arangodb/aql/plan-cache**](../../aql/execution-and-performance/caching-query-plans.md) + lets you list and clear the entries of the AQL execution plan cache. + - [**@arangodb/aql/cache**](../../aql/execution-and-performance/caching-query-results.md) - allows to control the AQL query caching feature. + allows to control the AQL query result caching feature. - [**@arangodb/aql/explainer**](../../aql/execution-and-performance/explaining-queries.md) provides methods to debug, explain and profile AQL queries. diff --git a/site/content/3.13/release-notes/version-3.12/api-changes-in-3-12.md b/site/content/3.13/release-notes/version-3.12/api-changes-in-3-12.md index 6c808f9bf7..0cc2ad922f 100644 --- a/site/content/3.13/release-notes/version-3.12/api-changes-in-3-12.md +++ b/site/content/3.13/release-notes/version-3.12/api-changes-in-3-12.md @@ -283,6 +283,19 @@ endpoint to restore the original log levels. See the [Log API](../../develop/http-api/monitoring/logs.md#reset-the-server-log-levels) for details. +#### Query plan cache API + +Introduced in: v3.12.4 + +Two endpoints have been added to let you list the entries and clear the cache +for AQL execution plans. Query plan caching works on a per-database basis. + +- `GET /_api/query-plan-cache` +- `DELETE /_api/query-plan-cache` + +See [HTTP interface for the query plan cache](../../develop/http-api/queries/aql-query-plan-cache.md) +for details. + ### Endpoints augmented #### View API @@ -341,6 +354,29 @@ Two new statistics are included in the response when you execute an AQL query: } ``` +#### Query plan cache attributes + +Introduced in: v3.12.4 + +The following endpoints related to AQL queries support a new `usePlanCache` +query option in the `options` object: + +- `POST /_api/cursor` +- `POST /_api/explain` + +An error is raised if `usePlanCache` is set to `true` but the query is not +eligible for plan caching (a new error code +`ERROR_QUERY_NOT_ELIGIBLE_FOR_PLAN_CACHING` with the number `1584`). See +[The execution plan cache for AQL queries](../../aql/execution-and-performance/caching-query-plans.md) +for details. + +If a cached query plan is utilized, the above endpoints include a new +`planCacheKey` attribute at the top-level of the response with the key of the +cached plan (string). + +See [HTTP interfaces for AQL queries](../../develop/http-api/queries/aql-queries.md#cursors) +for details. + #### Index API ##### `optimizeTopK` for inverted indexes @@ -692,3 +728,12 @@ The option defaults to `false` so that fast locking is tried. See the [JavaScript API](../../develop/transactions/stream-transactions.md#javascript-api) for details. +#### Query plan cache module + +Introduced in: v3.12.4 + +The new `@arangodb/aql/plan-cache` module lets you list the entries (`.toArray()`) +and clear (`.clear()`) the AQL execution plan cache in the JavaScript API. + +See [The execution plan cache for AQL queries](../../aql/execution-and-performance/caching-query-plans.md#interfaces) +for details. diff --git a/site/content/3.13/release-notes/version-3.12/whats-new-in-3-12.md b/site/content/3.13/release-notes/version-3.12/whats-new-in-3-12.md index 79e83eea3e..dbe6ca6bc4 100644 --- a/site/content/3.13/release-notes/version-3.12/whats-new-in-3-12.md +++ b/site/content/3.13/release-notes/version-3.12/whats-new-in-3-12.md @@ -970,6 +970,77 @@ In addition, shortest path searches may finish earlier now due to some optimizations to disregard candidate paths for which better candidates have been found already. +### Cache for query execution plans (experimental) + +Introduced in: v3.12.4 + +An optional execution plan cache for AQL queries has been added to let you skip query +planning and optimization when running the same queries repeatedly. This can +significantly reduce the total time for running particular queries where a lot +of time is spent on the query planning and optimization passes in proportion to +the actual execution. + +Query plans are not cached by default. You need to set the new `usePlanCache` +query option to `true` to utilize cached plans as well as to add plans to the +cache. Otherwise, the plan cache is bypassed. + +```js +db._query("FOR doc IN coll FILTER doc.attr == @val RETURN doc", { val: "foo" }, { usePlanCache: true }); +``` + +Not all AQL queries are eligible for plan caching. You can generally not cache +plans of queries where bind variables affect the structure of the execution plan +or the index utilization. +See [Cache eligibility](../../aql/execution-and-performance/caching-query-plans.md#cache-eligibility) +for details. + +HTTP API endpoints and a JavaScript API module have been added for clearing the +contents of the query plan cache and for retrieving the current plan cache entries. +See [The execution plan cache for AQL queries](../../aql/execution-and-performance/caching-query-plans.md#interfaces) +for details. + +```js +require("@arangodb/aql/plan-cache").toArray(); +``` + +```json +[ + { + "hash" : "2757239675060883499", + "query" : "FOR doc IN coll FILTER doc.attr == @val RETURN doc", + "queryHash" : 11382508862770890000, + "bindVars" : { + }, + "fullCount" : false, + "dataSources" : [ + "coll" + ], + "created" : "2024-11-20T17:21:34Z", + "hits" : 0, + "memoryUsage" : 3070 + } +] +``` + +The following startup options have been added to let you configure the plan cache: + +- `--query.plan-cache-max-entries`: The maximum number of plans in the + query plan cache per database. The default value is `128`. +- `--query.plan-cache-max-memory-usage`: The maximum total memory usage for the + query plan cache in each database. The default value is `8MB`. +- `--query.plan-cache-max-entry-size`: The maximum size of an individual entry + in the query plan cache in each database. The default value is `2MB`. +- `--query.plan-cache-invalidation-time`: The time in seconds after which a + query plan is invalidated in the query plan cache. + +The following metrics have been added to monitor the query plan cache: + +| Label | Description | +|:------|:------------| +| `arangodb_aql_query_plan_cache_hits_total` | Total number of lookup hits in the AQL query plan cache. | +| `arangodb_aql_query_plan_cache_memory_usage` | Total memory usage of all query plan caches across all databases. | +| `arangodb_aql_query_plan_cache_misses_total` | Total number of lookup misses in the AQL query plan cache. | + ## Indexing ### Multi-dimensional indexes diff --git a/site/data/3.11/cache.json b/site/data/3.11/cache.json index 321ee840c4..7a9951deab 100644 --- a/site/data/3.11/cache.json +++ b/site/data/3.11/cache.json @@ -72,8 +72,8 @@ "response": "eyJpbnB1dCI6ImRiLl9xdWVyeSgnRk9SIGMgSU4gQEBjb2xsZWN0aW9uIEZJTFRFUiBjLl9rZXkgPT0gQGtleSBSRVRVUk4gYy5fa2V5Jywge1xuICAnQGNvbGxlY3Rpb24nOiAnbXljb2xsZWN0aW9uJywgXG4gICdrZXknOiAndGVzdEtleSdcbn0pLnRvQXJyYXkoKTsiLCJvdXRwdXQiOiJbIFxuICBcInRlc3RLZXlcIiBcbl0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiMDJfd29ya1dpdGhBUUxfYmluZFZhbHVlcyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "02_workWithAQL_cache_single": { - "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NhY2hlCmRlc2NyaXB0aW9uOiAnJwotLS0KZGIuX3F1ZXJ5KAogICdGT1IgaSBJTiAxLi4yMCBSRVRVUk4gaScsCiAge30sCiAgeyBjYWNoZTogdHJ1ZSB9LAogIHt9Cik7IC8vIHJlc3VsdCBtYXkgZ2V0IHRha2VuIGZyb20gY2FjaGU=", - "response": "eyJpbnB1dCI6ImRiLl9xdWVyeShcbiAgJ0ZPUiBpIElOIDEuLjIwIFJFVFVSTiBpJyxcbiAge30sXG4gIHsgY2FjaGU6IHRydWUgfSxcbiAge31cbik7IC8vIHJlc3VsdCBtYXkgZ2V0IHRha2VuIGZyb20gY2FjaGUiLCJvdXRwdXQiOiJbb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBjb3VudDogMjAsIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IHRydWVdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1LCBcbiAgNiwgXG4gIDcsIFxuICA4LCBcbiAgOSwgXG4gIDEwIFxuXVxuXG50eXBlICdtb3JlJyB0byBzaG93IG1vcmUgZG9jdW1lbnRzIiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6IjAyX3dvcmtXaXRoQVFMX2NhY2hlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NhY2hlCmRlc2NyaXB0aW9uOiAnJwotLS0KdmFyIHJlc3VsdENhY2hlID0gcmVxdWlyZSgiQGFyYW5nb2RiL2FxbC9jYWNoZSIpOwpyZXN1bHRDYWNoZS5wcm9wZXJ0aWVzKHsgbW9kZTogImRlbWFuZCIgfSk7Cn5yZXN1bHRDYWNoZS5jbGVhcigpOwpkYi5fcXVlcnkoIkZPUiBpIElOIDEuLjUgUkVUVVJOIGkiLCB7fSwgeyBjYWNoZTogdHJ1ZSB9KTsgLy8gQWRkcyByZXN1bHQgdG8gY2FjaGUKZGIuX3F1ZXJ5KCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpIiwge30sIHsgY2FjaGU6IHRydWUgfSk7IC8vIFJldHJpZXZlcyByZXN1bHQgZnJvbSBjYWNoZQpkYi5fcXVlcnkoIkZPUiBpIElOIDEuLjUgUkVUVVJOIGkiLCB7fSwgeyBjYWNoZTogZmFsc2UgfSk7IC8vIEJ5cGFzc2VzIHRoZSBjYWNoZQ==", + "response": "eyJpbnB1dCI6InZhciByZXN1bHRDYWNoZSA9IHJlcXVpcmUoXCJAYXJhbmdvZGIvYXFsL2NhY2hlXCIpO1xucmVzdWx0Q2FjaGUucHJvcGVydGllcyh7IG1vZGU6IFwiZGVtYW5kXCIgfSk7XG5kYi5fcXVlcnkoXCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpXCIsIHt9LCB7IGNhY2hlOiB0cnVlIH0pOyAvLyBBZGRzIHJlc3VsdCB0byBjYWNoZVxuZGIuX3F1ZXJ5KFwiRk9SIGkgSU4gMS4uNSBSRVRVUk4gaVwiLCB7fSwgeyBjYWNoZTogdHJ1ZSB9KTsgLy8gUmV0cmlldmVzIHJlc3VsdCBmcm9tIGNhY2hlXG5kYi5fcXVlcnkoXCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpXCIsIHt9LCB7IGNhY2hlOiBmYWxzZSB9KTsgLy8gQnlwYXNzZXMgdGhlIGNhY2hlIiwib3V0cHV0IjoieyBcbiAgXCJtb2RlXCIgOiBcImRlbWFuZFwiLCBcbiAgXCJtYXhSZXN1bHRzXCIgOiAxMjgsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufVxuW29iamVjdCBBcmFuZ29RdWVyeUN1cnNvciwgY291bnQ6IDUsIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IGZhbHNlXVxuXG5bIFxuICAxLCBcbiAgMiwgXG4gIDMsIFxuICA0LCBcbiAgNSBcbl1cblxuW29iamVjdCBBcmFuZ29RdWVyeUN1cnNvciwgY291bnQ6IDUsIGNhY2hlZDogdHJ1ZSwgaGFzTW9yZTogZmFsc2VdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1IFxuXVxuXG5bb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBjb3VudDogNSwgY2FjaGVkOiBmYWxzZSwgaGFzTW9yZTogZmFsc2VdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1IFxuXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiIwMl93b3JrV2l0aEFRTF9jYWNoZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "02_workWithAQL_count_single": { "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NvdW50CmRlc2NyaXB0aW9uOiAnJwotLS0KdmFyIGN1cnNvciA9IGRiLl9xdWVyeSgKICAnRk9SIGkgSU4gMS4uNDIgUkVUVVJOIGknLAogIHt9LAogIHsgY291bnQ6IHRydWUgfSwKICB7fQopOwpjdXJzb3IuY291bnQoKTsKY3Vyc29yLnRvQXJyYXkoKS5sZW5ndGg7", @@ -543,6 +543,14 @@ "request": "LS0tCm5hbWU6IEdSQVBIVFJBVl9yZW1vdmVWZXJ0ZXgzCmRlc2NyaXB0aW9uOiAnJwpkYXRhc2V0OiByb3V0ZXBsYW5uZXIKLS0tCkxFVCBlZGdlS2V5cyA9IChGT1IgdiwgZSBJTiAxLi4xIEFOWSAnZ2VybWFuQ2l0eS9CZXJsaW4nIEdSQVBIICdyb3V0ZXBsYW5uZXInIFJFVFVSTiBlLl9rZXkpCkxFVCByID0gKEZPUiBrZXkgSU4gZWRnZUtleXMgUkVNT1ZFIGtleSBJTiBpbnRlcm5hdGlvbmFsSGlnaHdheQogICAgICAgIE9QVElPTlMgeyBpZ25vcmVFcnJvcnM6IHRydWUgfSBSRU1PVkUga2V5IElOIGdlcm1hbkhpZ2h3YXkKICAgICAgICBPUFRJT05TIHsgaWdub3JlRXJyb3JzOiB0cnVlIH0gUkVNT1ZFIGtleSBJTiBmcmVuY2hIaWdod2F5CiAgICAgICAgT1BUSU9OUyB7IGlnbm9yZUVycm9yczogdHJ1ZSB9KSAKUkVNT1ZFICdCZXJsaW4nIElOIGdlcm1hbkNpdHk=", "response": "eyJpbnB1dCI6IkxFVCBlZGdlS2V5cyA9IChGT1IgdiwgZSBJTiAxLi4xIEFOWSAnZ2VybWFuQ2l0eS9CZXJsaW4nIEdSQVBIICdyb3V0ZXBsYW5uZXInIFJFVFVSTiBlLl9rZXkpXG5MRVQgciA9IChGT1Iga2V5IElOIGVkZ2VLZXlzIFJFTU9WRSBrZXkgSU4gaW50ZXJuYXRpb25hbEhpZ2h3YXlcbiAgICAgICAgT1BUSU9OUyB7IGlnbm9yZUVycm9yczogdHJ1ZSB9IFJFTU9WRSBrZXkgSU4gZ2VybWFuSGlnaHdheVxuICAgICAgICBPUFRJT05TIHsgaWdub3JlRXJyb3JzOiB0cnVlIH0gUkVNT1ZFIGtleSBJTiBmcmVuY2hIaWdod2F5XG4gICAgICAgIE9QVElPTlMgeyBpZ25vcmVFcnJvcnM6IHRydWUgfSkgXG5SRU1PVkUgJ0JlcmxpbicgSU4gZ2VybWFuQ2l0eSIsIm91dHB1dCI6IlsgXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJHUkFQSFRSQVZfcmVtb3ZlVmVydGV4MyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQiLCJkYXRhc2V0Ijoicm91dGVwbGFubmVyIn19Cg==" }, + "HttpClearQueryResultsCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBDbGVhclF1ZXJ5UmVzdWx0c0NhY2hlCmRlc2NyaXB0aW9uOiB8CiAgQ2xlYXIgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1jYWNoZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdERUxFVEUnLCB1cmwpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTs=", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtICdodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9xdWVyeS1jYWNoZSciLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDAgT0tcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDI2XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiQ2xlYXIgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOlxuIiwibmFtZSI6Ikh0dHBDbGVhclF1ZXJ5UmVzdWx0c0NhY2hlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, + "HttpGetQueryResultsCacheProperties_single": { + "request": "LS0tCm5hbWU6IEh0dHBHZXRRdWVyeVJlc3VsdHNDYWNoZVByb3BlcnRpZXMKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZ2xvYmFsIGNvbmZpZ3VyYXRpb24gb2YgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlOgotLS0KdmFyIHJlc3VsdHNDYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvY2FjaGUiKTsKcmVzdWx0c0NhY2hlLnByb3BlcnRpZXMoeyBtb2RlOiAiZGVtYW5kIiB9KTsgCgp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnR0VUJywgdXJsKTsKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMCk7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lm1vZGUgPT0gImRlbWFuZCIpOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMnIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAwIE9LXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMDdcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJtb2RlXCIgOiBcImRlbWFuZFwiLCBcbiAgXCJtYXhSZXN1bHRzXCIgOiAxMjgsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IlJldHJpZXZlIHRoZSBnbG9iYWwgY29uZmlndXJhdGlvbiBvZiB0aGUgQVFMIHF1ZXJ5IHJlc3VsdHMgY2FjaGU6XG4iLCJuYW1lIjoiSHR0cEdldFF1ZXJ5UmVzdWx0c0NhY2hlUHJvcGVydGllcyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + }, "HttpGharialAddEdgeCol_single": { "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZEVkZ2VDb2wKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZSI7CmJvZHkgPSB7CiAgY29sbGVjdGlvbjogIndvcmtzX2luIiwKICBmcm9tOiBbImZlbWFsZSIsICJtYWxlIl0sCiAgdG86IFsiY2l0eSJdCn07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQT1NUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", "response": "eyJpbnB1dCI6ImN1cmwgLVggUE9TVCAtLWhlYWRlciAnYWNjZXB0OiBhcHBsaWNhdGlvbi9qc29uJyAtLWRhdGEtYmluYXJ5IEAtIC0tZHVtcCAtICdodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9naGFyaWFsL3NvY2lhbC9lZGdlJyBcdTAwM2NcdTAwM2MnRU9GJ1xue1xuICBcImNvbGxlY3Rpb25cIjogXCJ3b3Jrc19pblwiLFxuICBcImZyb21cIjogW1xuICAgIFwiZmVtYWxlXCIsXG4gICAgXCJtYWxlXCJcbiAgXSxcbiAgXCJ0b1wiOiBbXG4gICAgXCJjaXR5XCJcbiAgXVxufVxuRU9GIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAyOTRcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaTJaaVFXLS0tX1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcImdyYXBoXCIgOiB7IFxuICAgIFwiX2tleVwiIDogXCJzb2NpYWxcIiwgXG4gICAgXCJlZGdlRGVmaW5pdGlvbnNcIiA6IFsgXG4gICAgICB7IFxuICAgICAgICBcImNvbGxlY3Rpb25cIiA6IFwicmVsYXRpb25cIiwgXG4gICAgICAgIFwiZnJvbVwiIDogWyBcbiAgICAgICAgICBcImZlbWFsZVwiLCBcbiAgICAgICAgICBcIm1hbGVcIiBcbiAgICAgICAgXSwgXG4gICAgICAgIFwidG9cIiA6IFsgXG4gICAgICAgICAgXCJmZW1hbGVcIiwgXG4gICAgICAgICAgXCJtYWxlXCIgXG4gICAgICAgIF0gXG4gICAgICB9LCBcbiAgICAgIHsgXG4gICAgICAgIFwiY29sbGVjdGlvblwiIDogXCJ3b3Jrc19pblwiLCBcbiAgICAgICAgXCJmcm9tXCIgOiBbIFxuICAgICAgICAgIFwiZmVtYWxlXCIsIFxuICAgICAgICAgIFwibWFsZVwiIFxuICAgICAgICBdLCBcbiAgICAgICAgXCJ0b1wiIDogWyBcbiAgICAgICAgICBcImNpdHlcIiBcbiAgICAgICAgXSBcbiAgICAgIH0gXG4gICAgXSwgXG4gICAgXCJvcnBoYW5Db2xsZWN0aW9uc1wiIDogWyBdLCBcbiAgICBcIl9yZXZcIiA6IFwiX2kyWmlRVy0tLV9cIiwgXG4gICAgXCJfaWRcIiA6IFwiX2dyYXBocy9zb2NpYWxcIiwgXG4gICAgXCJuYW1lXCIgOiBcInNvY2lhbFwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbEFkZEVkZ2VDb2wiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" @@ -651,6 +659,14 @@ "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CmJvZHkgPSB7CiAgbmFtZTogIkFsaWNlIENvb3BlciIsCiAgYWdlOiAyNgp9CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9mZW1hbGUvYWxpY2UnIFx1MDAzY1x1MDAzYydFT0YnXG57XG4gIFwibmFtZVwiOiBcIkFsaWNlIENvb3BlclwiLFxuICBcImFnZVwiOiAyNlxufVxuRU9GIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMThcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaTJaaVE3Ty0tX1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInZlcnRleFwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJmZW1hbGUvYWxpY2VcIiwgXG4gICAgXCJfa2V5XCIgOiBcImFsaWNlXCIsIFxuICAgIFwiX29sZFJldlwiIDogXCJfaTJaaVE3Ry0tLVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2kyWmlRN08tLV9cIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxSZXBsYWNlVmVydGV4IiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, + "HttpListQueryResultsCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBMaXN0UXVlcnlSZXN1bHRzQ2FjaGUKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZW50cmllcyBzdG9yZWQgaW4gdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHJlc3VsdHNDYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvY2FjaGUiKTsKcmVzdWx0c0NhY2hlLnByb3BlcnRpZXMoeyBtb2RlOiAiZGVtYW5kIiB9KTsgCgpkYi5fY3JlYXRlKCJjb2xsIik7CmZvciAobGV0IGkgPSAwOyBpIDwgMzsgaSsrKSB7CiAgZGIuX3F1ZXJ5KCJGT1IgZG9jIElOIEBAY29sbCBGSUxURVIgZG9jLmF0dHIgPT0gQHZhbCBSRVRVUk4gZG9jIiwgewogICAgIkBjb2xsIjogImNvbGwiLCB2YWw6ICJmb28iCiAgfSwgeyBjYWNoZTogdHJ1ZSB9KTsKfQpkYi5fcXVlcnkoIlJFVFVSTiA0MiIsIHt9LCB7IGNhY2hlOiB0cnVlIH0pOwoKdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1jYWNoZS9lbnRyaWVzIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7CmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDApOwphc3NlcnQocmVzcG9uc2UucGFyc2VkQm9keS5sZW5ndGggPj0gMik7CmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CgpkYi5fZHJvcCgiY29sbCIpOw==", + "response": "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" + }, + "HttpSetQueryResultsCacheProperties_single": { + "request": "LS0tCm5hbWU6IEh0dHBTZXRRdWVyeVJlc3VsdHNDYWNoZVByb3BlcnRpZXMKZGVzY3JpcHRpb246IHwKICBDaGFuZ2Ugc29tZSBwcm9wZXJ0aWVzIG9mIHRoZSBnbG9iYWwgY29uZmlndXJhdGlvbiBvZiB0aGUgQVFMIHF1ZXJ5IHJlc3VsdHMgY2FjaGU6Ci0tLQp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMiOwp2YXIgYm9keSA9IHsgbW9kZTogImRlbWFuZCIsIG1heFJlc3VsdHM6IDMyIH07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKYXNzZXJ0KHJlc3BvbnNlLnBhcnNlZEJvZHkubW9kZSA9PSAiZGVtYW5kIik7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lm1heFJlc3VsdHMgPT0gMzIpOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMnIFx1MDAzY1x1MDAzYydFT0YnXG57XG4gIFwibW9kZVwiOiBcImRlbWFuZFwiLFxuICBcIm1heFJlc3VsdHNcIjogMzJcbn1cbkVPRiIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTA2XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwibW9kZVwiIDogXCJkZW1hbmRcIiwgXG4gIFwibWF4UmVzdWx0c1wiIDogMzIsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IkNoYW5nZSBzb21lIHByb3BlcnRpZXMgb2YgdGhlIGdsb2JhbCBjb25maWd1cmF0aW9uIG9mIHRoZSBBUUwgcXVlcnkgcmVzdWx0cyBjYWNoZTpcbiIsIm5hbWUiOiJIdHRwU2V0UXVlcnlSZXN1bHRzQ2FjaGVQcm9wZXJ0aWVzIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, "IndexIdentifier_single": { "request": "LS0tCm5hbWU6IEluZGV4SWRlbnRpZmllcgpkZXNjcmlwdGlvbjogJycKLS0tCn5kYi5fY3JlYXRlKCJleGFtcGxlIik7CmRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiAicGVyc2lzdGVudCIsIGZpZWxkczogWyAiYSIsICJiIiBdIH0pOwp2YXIgaW5kZXhJbmZvID0gZGIuZXhhbXBsZS5pbmRleGVzKCkubWFwKGZ1bmN0aW9uKHgpIHsgcmV0dXJuIHguaWQ7IH0pOwppbmRleEluZm87CmRiLl9pbmRleChpbmRleEluZm9bMF0pCmRiLl9pbmRleChpbmRleEluZm9bMV0pCn5kYi5fZHJvcCgiZXhhbXBsZSIpOw==", "response": "eyJpbnB1dCI6ImRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiBcInBlcnNpc3RlbnRcIiwgZmllbGRzOiBbIFwiYVwiLCBcImJcIiBdIH0pO1xudmFyIGluZGV4SW5mbyA9IGRiLmV4YW1wbGUuaW5kZXhlcygpLm1hcChmdW5jdGlvbih4KSB7IHJldHVybiB4LmlkOyB9KTtcbmluZGV4SW5mbztcbmRiLl9pbmRleChpbmRleEluZm9bMF0pXG5kYi5faW5kZXgoaW5kZXhJbmZvWzFdKSIsIm91dHB1dCI6InsgXG4gIFwiY2FjaGVFbmFibGVkXCIgOiBmYWxzZSwgXG4gIFwiZGVkdXBsaWNhdGVcIiA6IHRydWUsIFxuICBcImVzdGltYXRlc1wiIDogdHJ1ZSwgXG4gIFwiZmllbGRzXCIgOiBbIFxuICAgIFwiYVwiLCBcbiAgICBcImJcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS84Mzc2OFwiLCBcbiAgXCJpc05ld2x5Q3JlYXRlZFwiIDogdHJ1ZSwgXG4gIFwibmFtZVwiIDogXCJpZHhfMTgxNDk3NDEzOTkyMzk1NTcxMlwiLCBcbiAgXCJzZWxlY3Rpdml0eUVzdGltYXRlXCIgOiAxLCBcbiAgXCJzcGFyc2VcIiA6IGZhbHNlLCBcbiAgXCJ0eXBlXCIgOiBcInBlcnNpc3RlbnRcIiwgXG4gIFwidW5pcXVlXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAxIFxufVxuWyBcbiAgXCJleGFtcGxlLzBcIiwgXG4gIFwiZXhhbXBsZS84Mzc2OFwiIFxuXVxuXG57IFxuICBcImZpZWxkc1wiIDogWyBcbiAgICBcIl9rZXlcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS8wXCIsIFxuICBcIm5hbWVcIiA6IFwicHJpbWFyeVwiLCBcbiAgXCJzZWxlY3Rpdml0eUVzdGltYXRlXCIgOiAxLCBcbiAgXCJzcGFyc2VcIiA6IGZhbHNlLCBcbiAgXCJ0eXBlXCIgOiBcInByaW1hcnlcIiwgXG4gIFwidW5pcXVlXCIgOiB0cnVlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59XG5cbnsgXG4gIFwiY2FjaGVFbmFibGVkXCIgOiBmYWxzZSwgXG4gIFwiZGVkdXBsaWNhdGVcIiA6IHRydWUsIFxuICBcImVzdGltYXRlc1wiIDogdHJ1ZSwgXG4gIFwiZmllbGRzXCIgOiBbIFxuICAgIFwiYVwiLCBcbiAgICBcImJcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS84Mzc2OFwiLCBcbiAgXCJuYW1lXCIgOiBcImlkeF8xODE0OTc0MTM5OTIzOTU1NzEyXCIsIFxuICBcInNlbGVjdGl2aXR5RXN0aW1hdGVcIiA6IDEsIFxuICBcInNwYXJzZVwiIDogZmFsc2UsIFxuICBcInR5cGVcIiA6IFwicGVyc2lzdGVudFwiLCBcbiAgXCJ1bmlxdWVcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6IkluZGV4SWRlbnRpZmllciIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" diff --git a/site/data/3.12/cache.json b/site/data/3.12/cache.json index cf5dd06848..ecc862e377 100644 --- a/site/data/3.12/cache.json +++ b/site/data/3.12/cache.json @@ -72,8 +72,8 @@ "response": "eyJpbnB1dCI6ImRiLl9xdWVyeSgnRk9SIGMgSU4gQEBjb2xsZWN0aW9uIEZJTFRFUiBjLl9rZXkgPT0gQGtleSBSRVRVUk4gYy5fa2V5Jywge1xuICAnQGNvbGxlY3Rpb24nOiAnbXljb2xsZWN0aW9uJywgXG4gICdrZXknOiAndGVzdEtleSdcbn0pLnRvQXJyYXkoKTsiLCJvdXRwdXQiOiJbIFxuICBcInRlc3RLZXlcIiBcbl0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiMDJfd29ya1dpdGhBUUxfYmluZFZhbHVlcyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "02_workWithAQL_cache_single": { - "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NhY2hlCmRlc2NyaXB0aW9uOiAnJwotLS0KZGIuX3F1ZXJ5KAogICdGT1IgaSBJTiAxLi4yMCBSRVRVUk4gaScsCiAge30sCiAgeyBjYWNoZTogdHJ1ZSB9LAogIHt9Cik7IC8vIHJlc3VsdCBtYXkgZ2V0IHRha2VuIGZyb20gY2FjaGU=", - "response": "eyJpbnB1dCI6ImRiLl9xdWVyeShcbiAgJ0ZPUiBpIElOIDEuLjIwIFJFVFVSTiBpJyxcbiAge30sXG4gIHsgY2FjaGU6IHRydWUgfSxcbiAge31cbik7IC8vIHJlc3VsdCBtYXkgZ2V0IHRha2VuIGZyb20gY2FjaGUiLCJvdXRwdXQiOiJbb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBjb3VudDogMjAsIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IHRydWVdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1LCBcbiAgNiwgXG4gIDcsIFxuICA4LCBcbiAgOSwgXG4gIDEwIFxuXVxuXG50eXBlICdtb3JlJyB0byBzaG93IG1vcmUgZG9jdW1lbnRzIiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6IjAyX3dvcmtXaXRoQVFMX2NhY2hlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NhY2hlCmRlc2NyaXB0aW9uOiAnJwotLS0KdmFyIHJlc3VsdENhY2hlID0gcmVxdWlyZSgiQGFyYW5nb2RiL2FxbC9jYWNoZSIpOwpyZXN1bHRDYWNoZS5wcm9wZXJ0aWVzKHsgbW9kZTogImRlbWFuZCIgfSk7Cn5yZXN1bHRDYWNoZS5jbGVhcigpOwpkYi5fcXVlcnkoIkZPUiBpIElOIDEuLjUgUkVUVVJOIGkiLCB7fSwgeyBjYWNoZTogdHJ1ZSB9KTsgLy8gQWRkcyByZXN1bHQgdG8gY2FjaGUKZGIuX3F1ZXJ5KCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpIiwge30sIHsgY2FjaGU6IHRydWUgfSk7IC8vIFJldHJpZXZlcyByZXN1bHQgZnJvbSBjYWNoZQpkYi5fcXVlcnkoIkZPUiBpIElOIDEuLjUgUkVUVVJOIGkiLCB7fSwgeyBjYWNoZTogZmFsc2UgfSk7IC8vIEJ5cGFzc2VzIHRoZSBjYWNoZQ==", + "response": "eyJpbnB1dCI6InZhciByZXN1bHRDYWNoZSA9IHJlcXVpcmUoXCJAYXJhbmdvZGIvYXFsL2NhY2hlXCIpO1xucmVzdWx0Q2FjaGUucHJvcGVydGllcyh7IG1vZGU6IFwiZGVtYW5kXCIgfSk7XG5kYi5fcXVlcnkoXCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpXCIsIHt9LCB7IGNhY2hlOiB0cnVlIH0pOyAvLyBBZGRzIHJlc3VsdCB0byBjYWNoZVxuZGIuX3F1ZXJ5KFwiRk9SIGkgSU4gMS4uNSBSRVRVUk4gaVwiLCB7fSwgeyBjYWNoZTogdHJ1ZSB9KTsgLy8gUmV0cmlldmVzIHJlc3VsdCBmcm9tIGNhY2hlXG5kYi5fcXVlcnkoXCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpXCIsIHt9LCB7IGNhY2hlOiBmYWxzZSB9KTsgLy8gQnlwYXNzZXMgdGhlIGNhY2hlIiwib3V0cHV0IjoieyBcbiAgXCJtb2RlXCIgOiBcImRlbWFuZFwiLCBcbiAgXCJtYXhSZXN1bHRzXCIgOiAxMjgsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufVxuW29iamVjdCBBcmFuZ29RdWVyeUN1cnNvciwgY291bnQ6IDUsIHJlc3VsdHMgY2FjaGVkOiBmYWxzZSwgaGFzTW9yZTogZmFsc2VdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1IFxuXVxuXG5bb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBjb3VudDogNSwgcmVzdWx0cyBjYWNoZWQ6IHRydWUsIGhhc01vcmU6IGZhbHNlXVxuXG5bIFxuICAxLCBcbiAgMiwgXG4gIDMsIFxuICA0LCBcbiAgNSBcbl1cblxuW29iamVjdCBBcmFuZ29RdWVyeUN1cnNvciwgY291bnQ6IDUsIHJlc3VsdHMgY2FjaGVkOiBmYWxzZSwgaGFzTW9yZTogZmFsc2VdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1IFxuXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiIwMl93b3JrV2l0aEFRTF9jYWNoZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "02_workWithAQL_count_single": { "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NvdW50CmRlc2NyaXB0aW9uOiAnJwotLS0KdmFyIGN1cnNvciA9IGRiLl9xdWVyeSgKICAnRk9SIGkgSU4gMS4uNDIgUkVUVVJOIGknLAogIHt9LAogIHsgY291bnQ6IHRydWUgfSwKICB7fQopOwpjdXJzb3IuY291bnQoKTsKY3Vyc29yLnRvQXJyYXkoKS5sZW5ndGg7", @@ -543,6 +543,18 @@ "request": "LS0tCm5hbWU6IEdSQVBIVFJBVl9yZW1vdmVWZXJ0ZXgzCmRlc2NyaXB0aW9uOiAnJwpkYXRhc2V0OiByb3V0ZXBsYW5uZXIKLS0tCkxFVCBlZGdlS2V5cyA9IChGT1IgdiwgZSBJTiAxLi4xIEFOWSAnZ2VybWFuQ2l0eS9CZXJsaW4nIEdSQVBIICdyb3V0ZXBsYW5uZXInIFJFVFVSTiBlLl9rZXkpCkxFVCByID0gKEZPUiBrZXkgSU4gZWRnZUtleXMgUkVNT1ZFIGtleSBJTiBpbnRlcm5hdGlvbmFsSGlnaHdheQogICAgICAgIE9QVElPTlMgeyBpZ25vcmVFcnJvcnM6IHRydWUgfSBSRU1PVkUga2V5IElOIGdlcm1hbkhpZ2h3YXkKICAgICAgICBPUFRJT05TIHsgaWdub3JlRXJyb3JzOiB0cnVlIH0gUkVNT1ZFIGtleSBJTiBmcmVuY2hIaWdod2F5CiAgICAgICAgT1BUSU9OUyB7IGlnbm9yZUVycm9yczogdHJ1ZSB9KSAKUkVNT1ZFICdCZXJsaW4nIElOIGdlcm1hbkNpdHk=", "response": "eyJpbnB1dCI6IkxFVCBlZGdlS2V5cyA9IChGT1IgdiwgZSBJTiAxLi4xIEFOWSAnZ2VybWFuQ2l0eS9CZXJsaW4nIEdSQVBIICdyb3V0ZXBsYW5uZXInIFJFVFVSTiBlLl9rZXkpXG5MRVQgciA9IChGT1Iga2V5IElOIGVkZ2VLZXlzIFJFTU9WRSBrZXkgSU4gaW50ZXJuYXRpb25hbEhpZ2h3YXlcbiAgICAgICAgT1BUSU9OUyB7IGlnbm9yZUVycm9yczogdHJ1ZSB9IFJFTU9WRSBrZXkgSU4gZ2VybWFuSGlnaHdheVxuICAgICAgICBPUFRJT05TIHsgaWdub3JlRXJyb3JzOiB0cnVlIH0gUkVNT1ZFIGtleSBJTiBmcmVuY2hIaWdod2F5XG4gICAgICAgIE9QVElPTlMgeyBpZ25vcmVFcnJvcnM6IHRydWUgfSkgXG5SRU1PVkUgJ0JlcmxpbicgSU4gZ2VybWFuQ2l0eSIsIm91dHB1dCI6IlsgXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJHUkFQSFRSQVZfcmVtb3ZlVmVydGV4MyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQiLCJkYXRhc2V0Ijoicm91dGVwbGFubmVyIn19Cg==" }, + "HttpClearQueryPlanCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBDbGVhclF1ZXJ5UGxhbkNhY2hlCmRlc2NyaXB0aW9uOiB8CiAgQ2xlYXIgdGhlIEFRTCBxdWVyeSBwbGFuIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1wbGFuLWNhY2hlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7CmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDApOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtICdodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9xdWVyeS1wbGFuLWNhY2hlJyIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMjZcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMCBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiJDbGVhciB0aGUgQVFMIHF1ZXJ5IHBsYW4gY2FjaGUgb2YgdGhlIGN1cnJlbnQgZGF0YWJhc2U6XG4iLCJuYW1lIjoiSHR0cENsZWFyUXVlcnlQbGFuQ2FjaGUiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + }, + "HttpClearQueryResultsCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBDbGVhclF1ZXJ5UmVzdWx0c0NhY2hlCmRlc2NyaXB0aW9uOiB8CiAgQ2xlYXIgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1jYWNoZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdERUxFVEUnLCB1cmwpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTs=", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtICdodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9xdWVyeS1jYWNoZSciLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDAgT0tcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDI2XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiQ2xlYXIgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOlxuIiwibmFtZSI6Ikh0dHBDbGVhclF1ZXJ5UmVzdWx0c0NhY2hlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, + "HttpGetQueryResultsCacheProperties_single": { + "request": "LS0tCm5hbWU6IEh0dHBHZXRRdWVyeVJlc3VsdHNDYWNoZVByb3BlcnRpZXMKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZ2xvYmFsIGNvbmZpZ3VyYXRpb24gb2YgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlOgotLS0KdmFyIHJlc3VsdHNDYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvY2FjaGUiKTsKcmVzdWx0c0NhY2hlLnByb3BlcnRpZXMoeyBtb2RlOiAiZGVtYW5kIiB9KTsgCgp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnR0VUJywgdXJsKTsKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMCk7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lm1vZGUgPT0gImRlbWFuZCIpOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMnIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAwIE9LXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMDdcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJtb2RlXCIgOiBcImRlbWFuZFwiLCBcbiAgXCJtYXhSZXN1bHRzXCIgOiAxMjgsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IlJldHJpZXZlIHRoZSBnbG9iYWwgY29uZmlndXJhdGlvbiBvZiB0aGUgQVFMIHF1ZXJ5IHJlc3VsdHMgY2FjaGU6XG4iLCJuYW1lIjoiSHR0cEdldFF1ZXJ5UmVzdWx0c0NhY2hlUHJvcGVydGllcyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + }, "HttpGharialAddEdgeCol_single": { "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZEVkZ2VDb2wKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZSI7CmJvZHkgPSB7CiAgY29sbGVjdGlvbjogIndvcmtzX2luIiwKICBmcm9tOiBbImZlbWFsZSIsICJtYWxlIl0sCiAgdG86IFsiY2l0eSJdCn07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQT1NUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", "response": "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" @@ -651,6 +663,18 @@ "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CmJvZHkgPSB7CiAgbmFtZTogIkFsaWNlIENvb3BlciIsCiAgYWdlOiAyNgp9CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL2doYXJpYWwvc29jaWFsL3ZlcnRleC9mZW1hbGUvYWxpY2UnIFx1MDAzY1x1MDAzYydFT0YnXG57XG4gIFwibmFtZVwiOiBcIkFsaWNlIENvb3BlclwiLFxuICBcImFnZVwiOiAyNlxufVxuRU9GIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAyIEFjY2VwdGVkXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMThcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5ldGFnOiBfaXI0Y2NodS0tQVxuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDIsIFxuICBcInZlcnRleFwiIDogeyBcbiAgICBcIl9pZFwiIDogXCJmZW1hbGUvYWxpY2VcIiwgXG4gICAgXCJfa2V5XCIgOiBcImFsaWNlXCIsIFxuICAgIFwiX29sZFJldlwiIDogXCJfaXI0Y2NobS0tLVwiLCBcbiAgICBcIl9yZXZcIiA6IFwiX2lyNGNjaHUtLUFcIiBcbiAgfSBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiSHR0cEdoYXJpYWxSZXBsYWNlVmVydGV4IiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" }, + "HttpListQueryPlanCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBMaXN0UXVlcnlQbGFuQ2FjaGUKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZW50cmllcyBzdG9yZWQgaW4gdGhlIEFRTCBxdWVyeSBwbGFuIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KZGIuX2NyZWF0ZSgiY29sbCIpOwpmb3IgKGxldCBpID0gMDsgaSA8IDM7IGkrKykgewogIGRiLl9xdWVyeSgiRk9SIGRvYyBJTiBAQGNvbGwgRklMVEVSIGRvYy5hdHRyID09IEB2YWwgUkVUVVJOIGRvYyIsIHsKICAgICJAY29sbCI6ICJjb2xsIiwgdmFsOiAiZm9vIgogIH0sIHsgdXNlUGxhbkNhY2hlOiB0cnVlIH0pOwp9CmRiLl9xdWVyeSgiUkVUVVJOIDQyIiwge30sIHsgdXNlUGxhbkNhY2hlOiB0cnVlIH0pOwoKdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1wbGFuLWNhY2hlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7CmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDApOwphc3NlcnQocmVzcG9uc2UucGFyc2VkQm9keS5sZW5ndGggPj0gMik7CmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CgpkYi5fZHJvcCgiY29sbCIpOw==", + "response": "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" + }, + "HttpListQueryResultsCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBMaXN0UXVlcnlSZXN1bHRzQ2FjaGUKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZW50cmllcyBzdG9yZWQgaW4gdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHJlc3VsdHNDYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvY2FjaGUiKTsKcmVzdWx0c0NhY2hlLnByb3BlcnRpZXMoeyBtb2RlOiAiZGVtYW5kIiB9KTsgCgpkYi5fY3JlYXRlKCJjb2xsIik7CmZvciAobGV0IGkgPSAwOyBpIDwgMzsgaSsrKSB7CiAgZGIuX3F1ZXJ5KCJGT1IgZG9jIElOIEBAY29sbCBGSUxURVIgZG9jLmF0dHIgPT0gQHZhbCBSRVRVUk4gZG9jIiwgewogICAgIkBjb2xsIjogImNvbGwiLCB2YWw6ICJmb28iCiAgfSwgeyBjYWNoZTogdHJ1ZSwgZnVsbENvdW50OiB0cnVlIH0pOwp9CmRiLl9xdWVyeSgiUkVUVVJOIDQyIiwge30sIHsgY2FjaGU6IHRydWUgfSk7Cgp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL2VudHJpZXMiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnR0VUJywgdXJsKTsKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMCk7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lmxlbmd0aCA+PSAyKTsKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKCmRiLl9kcm9wKCJjb2xsIik7", + "response": "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" + }, + "HttpSetQueryResultsCacheProperties_single": { + "request": "LS0tCm5hbWU6IEh0dHBTZXRRdWVyeVJlc3VsdHNDYWNoZVByb3BlcnRpZXMKZGVzY3JpcHRpb246IHwKICBDaGFuZ2Ugc29tZSBwcm9wZXJ0aWVzIG9mIHRoZSBnbG9iYWwgY29uZmlndXJhdGlvbiBvZiB0aGUgQVFMIHF1ZXJ5IHJlc3VsdHMgY2FjaGU6Ci0tLQp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMiOwp2YXIgYm9keSA9IHsgbW9kZTogImRlbWFuZCIsIG1heFJlc3VsdHM6IDMyIH07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKYXNzZXJ0KHJlc3BvbnNlLnBhcnNlZEJvZHkubW9kZSA9PSAiZGVtYW5kIik7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lm1heFJlc3VsdHMgPT0gMzIpOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMnIFx1MDAzY1x1MDAzYydFT0YnXG57XG4gIFwibW9kZVwiOiBcImRlbWFuZFwiLFxuICBcIm1heFJlc3VsdHNcIjogMzJcbn1cbkVPRiIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTA2XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwibW9kZVwiIDogXCJkZW1hbmRcIiwgXG4gIFwibWF4UmVzdWx0c1wiIDogMzIsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IkNoYW5nZSBzb21lIHByb3BlcnRpZXMgb2YgdGhlIGdsb2JhbCBjb25maWd1cmF0aW9uIG9mIHRoZSBBUUwgcXVlcnkgcmVzdWx0cyBjYWNoZTpcbiIsIm5hbWUiOiJIdHRwU2V0UXVlcnlSZXN1bHRzQ2FjaGVQcm9wZXJ0aWVzIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, "IndexIdentifier_single": { "request": "LS0tCm5hbWU6IEluZGV4SWRlbnRpZmllcgpkZXNjcmlwdGlvbjogJycKLS0tCn5kYi5fY3JlYXRlKCJleGFtcGxlIik7CmRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiAicGVyc2lzdGVudCIsIGZpZWxkczogWyAiYSIsICJiIiBdIH0pOwp2YXIgaW5kZXhJbmZvID0gZGIuZXhhbXBsZS5pbmRleGVzKCkubWFwKGZ1bmN0aW9uKHgpIHsgcmV0dXJuIHguaWQ7IH0pOwppbmRleEluZm87CmRiLl9pbmRleChpbmRleEluZm9bMF0pCmRiLl9pbmRleChpbmRleEluZm9bMV0pCn5kYi5fZHJvcCgiZXhhbXBsZSIpOw==", "response": "eyJpbnB1dCI6ImRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiBcInBlcnNpc3RlbnRcIiwgZmllbGRzOiBbIFwiYVwiLCBcImJcIiBdIH0pO1xudmFyIGluZGV4SW5mbyA9IGRiLmV4YW1wbGUuaW5kZXhlcygpLm1hcChmdW5jdGlvbih4KSB7IHJldHVybiB4LmlkOyB9KTtcbmluZGV4SW5mbztcbmRiLl9pbmRleChpbmRleEluZm9bMF0pXG5kYi5faW5kZXgoaW5kZXhJbmZvWzFdKSIsIm91dHB1dCI6InsgXG4gIFwiY2FjaGVFbmFibGVkXCIgOiBmYWxzZSwgXG4gIFwiZGVkdXBsaWNhdGVcIiA6IHRydWUsIFxuICBcImVzdGltYXRlc1wiIDogdHJ1ZSwgXG4gIFwiZmllbGRzXCIgOiBbIFxuICAgIFwiYVwiLCBcbiAgICBcImJcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS84NjE4NlwiLCBcbiAgXCJpc05ld2x5Q3JlYXRlZFwiIDogdHJ1ZSwgXG4gIFwibmFtZVwiIDogXCJpZHhfMTgxNDgxOTY3NzcxMDMxOTYxNlwiLCBcbiAgXCJzZWxlY3Rpdml0eUVzdGltYXRlXCIgOiAxLCBcbiAgXCJzcGFyc2VcIiA6IGZhbHNlLCBcbiAgXCJ0eXBlXCIgOiBcInBlcnNpc3RlbnRcIiwgXG4gIFwidW5pcXVlXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAxIFxufVxuWyBcbiAgXCJleGFtcGxlLzBcIiwgXG4gIFwiZXhhbXBsZS84NjE4NlwiIFxuXVxuXG57IFxuICBcImZpZWxkc1wiIDogWyBcbiAgICBcIl9rZXlcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS8wXCIsIFxuICBcIm5hbWVcIiA6IFwicHJpbWFyeVwiLCBcbiAgXCJzZWxlY3Rpdml0eUVzdGltYXRlXCIgOiAxLCBcbiAgXCJzcGFyc2VcIiA6IGZhbHNlLCBcbiAgXCJ0eXBlXCIgOiBcInByaW1hcnlcIiwgXG4gIFwidW5pcXVlXCIgOiB0cnVlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59XG5cbnsgXG4gIFwiY2FjaGVFbmFibGVkXCIgOiBmYWxzZSwgXG4gIFwiZGVkdXBsaWNhdGVcIiA6IHRydWUsIFxuICBcImVzdGltYXRlc1wiIDogdHJ1ZSwgXG4gIFwiZmllbGRzXCIgOiBbIFxuICAgIFwiYVwiLCBcbiAgICBcImJcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS84NjE4NlwiLCBcbiAgXCJuYW1lXCIgOiBcImlkeF8xODE0ODE5Njc3NzEwMzE5NjE2XCIsIFxuICBcInNlbGVjdGl2aXR5RXN0aW1hdGVcIiA6IDEsIFxuICBcInNwYXJzZVwiIDogZmFsc2UsIFxuICBcInR5cGVcIiA6IFwicGVyc2lzdGVudFwiLCBcbiAgXCJ1bmlxdWVcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6IkluZGV4SWRlbnRpZmllciIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" @@ -2879,6 +2903,18 @@ "request": "LS0tCm5hbWU6IGFxbFppcApkZXNjcmlwdGlvbjogJycKLS0tClJFVFVSTiBaSVAoIFsgIm5hbWUiLCAiYWN0aXZlIiwgImhvYmJpZXMiIF0sIFsgInNvbWUgdXNlciIsIHRydWUsIFsgInN3aW1taW5nIiwgInJpZGluZyIgXSBdICk=", "response": "eyJpbnB1dCI6IlJFVFVSTiBaSVAoIFsgXCJuYW1lXCIsIFwiYWN0aXZlXCIsIFwiaG9iYmllc1wiIF0sIFsgXCJzb21lIHVzZXJcIiwgdHJ1ZSwgWyBcInN3aW1taW5nXCIsIFwicmlkaW5nXCIgXSBdICkiLCJvdXRwdXQiOiJbIFxuICB7IFxuICAgIFwibmFtZVwiIDogXCJzb21lIHVzZXJcIiwgXG4gICAgXCJhY3RpdmVcIiA6IHRydWUsIFxuICAgIFwiaG9iYmllc1wiIDogWyBcbiAgICAgIFwic3dpbW1pbmdcIiwgXG4gICAgICBcInJpZGluZ1wiIFxuICAgIF0gXG4gIH0gXG5dIiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6ImFxbFppcCIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, + "arangosh_cache_query_plan_single": { + "request": "LS0tCm5hbWU6IGFyYW5nb3NoX2NhY2hlX3F1ZXJ5X3BsYW4KZGVzY3JpcHRpb246ICcnCi0tLQp+ZGIuX2NyZWF0ZSgiY29sbCIpOwp2YXIgcXVlcnkgPSAiRk9SIGRvYyBJTiBjb2xsIEZJTFRFUiBkb2MuYXR0ciA9PSBAdmFsIFJFVFVSTiBkb2MiOwp2YXIgYmluZFZhcnMgPSB7IHZhbDogImZvbyIgfTsKZGIuX3F1ZXJ5KHF1ZXJ5LCBiaW5kVmFycywgeyB1c2VQbGFuQ2FjaGU6IHRydWUgfSk7IC8vIEFkZHMgcGxhbiB0byBjYWNoZQpkYi5fcXVlcnkocXVlcnksIGJpbmRWYXJzLCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsgLy8gVXNlcyBjYWNoZWQgcGxhbgp+ZGIuX2Ryb3AoImNvbGwiKTs=", + "response": "eyJpbnB1dCI6InZhciBxdWVyeSA9IFwiRk9SIGRvYyBJTiBjb2xsIEZJTFRFUiBkb2MuYXR0ciA9PSBAdmFsIFJFVFVSTiBkb2NcIjtcbnZhciBiaW5kVmFycyA9IHsgdmFsOiBcImZvb1wiIH07XG5kYi5fcXVlcnkocXVlcnksIGJpbmRWYXJzLCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsgLy8gQWRkcyBwbGFuIHRvIGNhY2hlXG5kYi5fcXVlcnkocXVlcnksIGJpbmRWYXJzLCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsgLy8gVXNlcyBjYWNoZWQgcGxhbiIsIm91dHB1dCI6IltvYmplY3QgQXJhbmdvUXVlcnlDdXJzb3IsIGNvdW50OiAwLCByZXN1bHRzIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IGZhbHNlXVxuXG5bb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBwbGFuIGNhY2hlIGtleTogXCIyNzU3MjM5Njc1MDYwODgzNDk5XCIsIGNvdW50OiAwLCByZXN1bHRzIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IGZhbHNlXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJhcmFuZ29zaF9jYWNoZV9xdWVyeV9wbGFuIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, + "arangosh_clear_query_plan_cache_single": { + "request": "LS0tCm5hbWU6IGFyYW5nb3NoX2NsZWFyX3F1ZXJ5X3BsYW5fY2FjaGUKZGVzY3JpcHRpb246ICcnCi0tLQp2YXIgcGxhbkNhY2hlID0gcmVxdWlyZSgiQGFyYW5nb2RiL2FxbC9wbGFuLWNhY2hlIik7CnBsYW5DYWNoZS5jbGVhcigpOw==", + "response": "eyJpbnB1dCI6InZhciBwbGFuQ2FjaGUgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FxbC9wbGFuLWNhY2hlXCIpO1xucGxhbkNhY2hlLmNsZWFyKCk7Iiwib3V0cHV0IjoieyBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6ImFyYW5nb3NoX2NsZWFyX3F1ZXJ5X3BsYW5fY2FjaGUiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + }, + "arangosh_list_cached_query_plans_single": { + "request": "LS0tCm5hbWU6IGFyYW5nb3NoX2xpc3RfY2FjaGVkX3F1ZXJ5X3BsYW5zCmRlc2NyaXB0aW9uOiAnJwotLS0KfmRiLl9jcmVhdGUoImNvbGwiKTsKfmRiLl9xdWVyeSgiUkVUVVJOIDQyIiwge30sIHsgdXNlUGxhbkNhY2hlOiB0cnVlIH0pOwp+ZGIuX3F1ZXJ5KCJGT1IgZG9jIElOIGNvbGwgRklMVEVSIGRvYy5hdHRyID09IEB2YWwgUkVUVVJOIGRvYyIsIHsgdmFsOiAiZm9vIiB9LCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsKdmFyIHBsYW5DYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvcGxhbi1jYWNoZSIpOwpwbGFuQ2FjaGUudG9BcnJheSgpOwp+ZGIuX2Ryb3AoImNvbGwiKTs=", + "response": "eyJpbnB1dCI6InZhciBwbGFuQ2FjaGUgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FxbC9wbGFuLWNhY2hlXCIpO1xucGxhbkNhY2hlLnRvQXJyYXkoKTsiLCJvdXRwdXQiOiJbIFxuICB7IFxuICAgIFwiaGFzaFwiIDogXCIyNzU3MjM5Njc1MDYwODgzNDk5XCIsIFxuICAgIFwicXVlcnlcIiA6IFwiRk9SIGRvYyBJTiBjb2xsIEZJTFRFUiBkb2MuYXR0ciA9PSBAdmFsIFJFVFVSTiBkb2NcIiwgXG4gICAgXCJxdWVyeUhhc2hcIiA6IDExMzgyNTA4ODYyNzcwODkwMDAwLCBcbiAgICBcImJpbmRWYXJzXCIgOiB7IFxuICAgIH0sIFxuICAgIFwiZnVsbENvdW50XCIgOiBmYWxzZSwgXG4gICAgXCJkYXRhU291cmNlc1wiIDogWyBcbiAgICAgIFwiY29sbFwiIFxuICAgIF0sIFxuICAgIFwiY3JlYXRlZFwiIDogXCIyMDI1LTAxLTE1VDA5OjM4OjU2WlwiLCBcbiAgICBcImhpdHNcIiA6IDAsIFxuICAgIFwibWVtb3J5VXNhZ2VcIiA6IDMwODAgXG4gIH0sIFxuICB7IFxuICAgIFwiaGFzaFwiIDogXCIzNzg5NTY1OTgzMzg1Nzg3MDUyXCIsIFxuICAgIFwicXVlcnlcIiA6IFwiUkVUVVJOIDQyXCIsIFxuICAgIFwicXVlcnlIYXNoXCIgOiA5NjIxNjc5NDYzOTkwMDg2MDAwLCBcbiAgICBcImJpbmRWYXJzXCIgOiB7IFxuICAgIH0sIFxuICAgIFwiZnVsbENvdW50XCIgOiBmYWxzZSwgXG4gICAgXCJkYXRhU291cmNlc1wiIDogWyBdLCBcbiAgICBcImNyZWF0ZWRcIiA6IFwiMjAyNS0wMS0xNVQwOTozODo1NlpcIiwgXG4gICAgXCJoaXRzXCIgOiAwLCBcbiAgICBcIm1lbW9yeVVzYWdlXCIgOiAxOTcyIFxuICB9IFxuXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJhcmFuZ29zaF9saXN0X2NhY2hlZF9xdWVyeV9wbGFucyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + }, "col_dropIndex_single": { "request": "LS0tCm5hbWU6IGNvbF9kcm9wSW5kZXgKZGVzY3JpcHRpb246ICcnCi0tLQp+ZGIuX2NyZWF0ZSgiZXhhbXBsZSIpOwp2YXIgaWR4MSA9IGRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiAicGVyc2lzdGVudCIsIGZpZWxkczogWyJhIiwgImIiXSB9KTsKdmFyIGlkeDIgPSBkYi5leGFtcGxlLmVuc3VyZUluZGV4KHsgdHlwZTogInBlcnNpc3RlbnQiLCBmaWVsZHM6IFsiYyJdIH0pOwp2YXIgaW5kZXhJbmZvID0gZGIuZXhhbXBsZS5pbmRleGVzKCk7CmluZGV4SW5mbzsKZGIuZXhhbXBsZS5kcm9wSW5kZXgoaW5kZXhJbmZvWzFdKQpkYi5leGFtcGxlLmRyb3BJbmRleChpbmRleEluZm9bMl0uaWQpCmluZGV4SW5mbyA9IGRiLmV4YW1wbGUuaW5kZXhlcygpOwp+ZGIuX2Ryb3AoImV4YW1wbGUiKTs=", "response": "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" diff --git a/site/data/3.13/cache.json b/site/data/3.13/cache.json index 2baf7fde9e..ee37d4f74f 100644 --- a/site/data/3.13/cache.json +++ b/site/data/3.13/cache.json @@ -72,8 +72,8 @@ "response": "eyJpbnB1dCI6ImRiLl9xdWVyeSgnRk9SIGMgSU4gQEBjb2xsZWN0aW9uIEZJTFRFUiBjLl9rZXkgPT0gQGtleSBSRVRVUk4gYy5fa2V5Jywge1xuICAnQGNvbGxlY3Rpb24nOiAnbXljb2xsZWN0aW9uJywgXG4gICdrZXknOiAndGVzdEtleSdcbn0pLnRvQXJyYXkoKTsiLCJvdXRwdXQiOiJbIFxuICBcInRlc3RLZXlcIiBcbl0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiIiLCJuYW1lIjoiMDJfd29ya1dpdGhBUUxfYmluZFZhbHVlcyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "02_workWithAQL_cache_single": { - "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NhY2hlCmRlc2NyaXB0aW9uOiAnJwotLS0KZGIuX3F1ZXJ5KAogICdGT1IgaSBJTiAxLi4yMCBSRVRVUk4gaScsCiAge30sCiAgeyBjYWNoZTogdHJ1ZSB9LAogIHt9Cik7IC8vIHJlc3VsdCBtYXkgZ2V0IHRha2VuIGZyb20gY2FjaGU=", - "response": "eyJpbnB1dCI6ImRiLl9xdWVyeShcbiAgJ0ZPUiBpIElOIDEuLjIwIFJFVFVSTiBpJyxcbiAge30sXG4gIHsgY2FjaGU6IHRydWUgfSxcbiAge31cbik7IC8vIHJlc3VsdCBtYXkgZ2V0IHRha2VuIGZyb20gY2FjaGUiLCJvdXRwdXQiOiJbb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBjb3VudDogMjAsIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IHRydWVdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1LCBcbiAgNiwgXG4gIDcsIFxuICA4LCBcbiAgOSwgXG4gIDEwIFxuXVxuXG50eXBlICdtb3JlJyB0byBzaG93IG1vcmUgZG9jdW1lbnRzIiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6IjAyX3dvcmtXaXRoQVFMX2NhY2hlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NhY2hlCmRlc2NyaXB0aW9uOiAnJwotLS0KdmFyIHJlc3VsdENhY2hlID0gcmVxdWlyZSgiQGFyYW5nb2RiL2FxbC9jYWNoZSIpOwpyZXN1bHRDYWNoZS5wcm9wZXJ0aWVzKHsgbW9kZTogImRlbWFuZCIgfSk7Cn5yZXN1bHRDYWNoZS5jbGVhcigpOwpkYi5fcXVlcnkoIkZPUiBpIElOIDEuLjUgUkVUVVJOIGkiLCB7fSwgeyBjYWNoZTogdHJ1ZSB9KTsgLy8gQWRkcyByZXN1bHQgdG8gY2FjaGUKZGIuX3F1ZXJ5KCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpIiwge30sIHsgY2FjaGU6IHRydWUgfSk7IC8vIFJldHJpZXZlcyByZXN1bHQgZnJvbSBjYWNoZQpkYi5fcXVlcnkoIkZPUiBpIElOIDEuLjUgUkVUVVJOIGkiLCB7fSwgeyBjYWNoZTogZmFsc2UgfSk7IC8vIEJ5cGFzc2VzIHRoZSBjYWNoZQ==", + "response": "eyJpbnB1dCI6InZhciByZXN1bHRDYWNoZSA9IHJlcXVpcmUoXCJAYXJhbmdvZGIvYXFsL2NhY2hlXCIpO1xucmVzdWx0Q2FjaGUucHJvcGVydGllcyh7IG1vZGU6IFwiZGVtYW5kXCIgfSk7XG5kYi5fcXVlcnkoXCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpXCIsIHt9LCB7IGNhY2hlOiB0cnVlIH0pOyAvLyBBZGRzIHJlc3VsdCB0byBjYWNoZVxuZGIuX3F1ZXJ5KFwiRk9SIGkgSU4gMS4uNSBSRVRVUk4gaVwiLCB7fSwgeyBjYWNoZTogdHJ1ZSB9KTsgLy8gUmV0cmlldmVzIHJlc3VsdCBmcm9tIGNhY2hlXG5kYi5fcXVlcnkoXCJGT1IgaSBJTiAxLi41IFJFVFVSTiBpXCIsIHt9LCB7IGNhY2hlOiBmYWxzZSB9KTsgLy8gQnlwYXNzZXMgdGhlIGNhY2hlIiwib3V0cHV0IjoieyBcbiAgXCJtb2RlXCIgOiBcImRlbWFuZFwiLCBcbiAgXCJtYXhSZXN1bHRzXCIgOiAxMjgsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufVxuW29iamVjdCBBcmFuZ29RdWVyeUN1cnNvciwgY291bnQ6IDUsIHJlc3VsdHMgY2FjaGVkOiBmYWxzZSwgaGFzTW9yZTogZmFsc2VdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1IFxuXVxuXG5bb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBjb3VudDogNSwgcmVzdWx0cyBjYWNoZWQ6IHRydWUsIGhhc01vcmU6IGZhbHNlXVxuXG5bIFxuICAxLCBcbiAgMiwgXG4gIDMsIFxuICA0LCBcbiAgNSBcbl1cblxuW29iamVjdCBBcmFuZ29RdWVyeUN1cnNvciwgY291bnQ6IDUsIHJlc3VsdHMgY2FjaGVkOiBmYWxzZSwgaGFzTW9yZTogZmFsc2VdXG5cblsgXG4gIDEsIFxuICAyLCBcbiAgMywgXG4gIDQsIFxuICA1IFxuXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiIwMl93b3JrV2l0aEFRTF9jYWNoZSIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, "02_workWithAQL_count_single": { "request": "LS0tCm5hbWU6IDAyX3dvcmtXaXRoQVFMX2NvdW50CmRlc2NyaXB0aW9uOiAnJwotLS0KdmFyIGN1cnNvciA9IGRiLl9xdWVyeSgKICAnRk9SIGkgSU4gMS4uNDIgUkVUVVJOIGknLAogIHt9LAogIHsgY291bnQ6IHRydWUgfSwKICB7fQopOwpjdXJzb3IuY291bnQoKTsKY3Vyc29yLnRvQXJyYXkoKS5sZW5ndGg7", @@ -543,6 +543,18 @@ "request": "LS0tCm5hbWU6IEdSQVBIVFJBVl9yZW1vdmVWZXJ0ZXgzCmRlc2NyaXB0aW9uOiAnJwpkYXRhc2V0OiByb3V0ZXBsYW5uZXIKLS0tCkxFVCBlZGdlS2V5cyA9IChGT1IgdiwgZSBJTiAxLi4xIEFOWSAnZ2VybWFuQ2l0eS9CZXJsaW4nIEdSQVBIICdyb3V0ZXBsYW5uZXInIFJFVFVSTiBlLl9rZXkpCkxFVCByID0gKEZPUiBrZXkgSU4gZWRnZUtleXMgUkVNT1ZFIGtleSBJTiBpbnRlcm5hdGlvbmFsSGlnaHdheQogICAgICAgIE9QVElPTlMgeyBpZ25vcmVFcnJvcnM6IHRydWUgfSBSRU1PVkUga2V5IElOIGdlcm1hbkhpZ2h3YXkKICAgICAgICBPUFRJT05TIHsgaWdub3JlRXJyb3JzOiB0cnVlIH0gUkVNT1ZFIGtleSBJTiBmcmVuY2hIaWdod2F5CiAgICAgICAgT1BUSU9OUyB7IGlnbm9yZUVycm9yczogdHJ1ZSB9KSAKUkVNT1ZFICdCZXJsaW4nIElOIGdlcm1hbkNpdHk=", "response": "eyJpbnB1dCI6IkxFVCBlZGdlS2V5cyA9IChGT1IgdiwgZSBJTiAxLi4xIEFOWSAnZ2VybWFuQ2l0eS9CZXJsaW4nIEdSQVBIICdyb3V0ZXBsYW5uZXInIFJFVFVSTiBlLl9rZXkpXG5MRVQgciA9IChGT1Iga2V5IElOIGVkZ2VLZXlzIFJFTU9WRSBrZXkgSU4gaW50ZXJuYXRpb25hbEhpZ2h3YXlcbiAgICAgICAgT1BUSU9OUyB7IGlnbm9yZUVycm9yczogdHJ1ZSB9IFJFTU9WRSBrZXkgSU4gZ2VybWFuSGlnaHdheVxuICAgICAgICBPUFRJT05TIHsgaWdub3JlRXJyb3JzOiB0cnVlIH0gUkVNT1ZFIGtleSBJTiBmcmVuY2hIaWdod2F5XG4gICAgICAgIE9QVElPTlMgeyBpZ25vcmVFcnJvcnM6IHRydWUgfSkgXG5SRU1PVkUgJ0JlcmxpbicgSU4gZ2VybWFuQ2l0eSIsIm91dHB1dCI6IlsgXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJHUkFQSFRSQVZfcmVtb3ZlVmVydGV4MyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQiLCJkYXRhc2V0Ijoicm91dGVwbGFubmVyIn19Cg==" }, + "HttpClearQueryPlanCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBDbGVhclF1ZXJ5UGxhbkNhY2hlCmRlc2NyaXB0aW9uOiB8CiAgQ2xlYXIgdGhlIEFRTCBxdWVyeSBwbGFuIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1wbGFuLWNhY2hlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0RFTEVURScsIHVybCk7CmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDApOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtICdodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9xdWVyeS1wbGFuLWNhY2hlJyIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMjZcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMCBcbn0iLCJlcnJvciI6IiIsIm9wdGlvbnMiOnsiZGVzY3JpcHRpb24iOiJDbGVhciB0aGUgQVFMIHF1ZXJ5IHBsYW4gY2FjaGUgb2YgdGhlIGN1cnJlbnQgZGF0YWJhc2U6XG4iLCJuYW1lIjoiSHR0cENsZWFyUXVlcnlQbGFuQ2FjaGUiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + }, + "HttpClearQueryResultsCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBDbGVhclF1ZXJ5UmVzdWx0c0NhY2hlCmRlc2NyaXB0aW9uOiB8CiAgQ2xlYXIgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1jYWNoZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdERUxFVEUnLCB1cmwpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTs=", + "response": "eyJpbnB1dCI6ImN1cmwgLVggREVMRVRFIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZHVtcCAtICdodHRwOi8vbG9jYWxob3N0Ojg1MjkvX2FwaS9xdWVyeS1jYWNoZSciLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDAgT0tcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDI2XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwiZXJyb3JcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiQ2xlYXIgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOlxuIiwibmFtZSI6Ikh0dHBDbGVhclF1ZXJ5UmVzdWx0c0NhY2hlIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, + "HttpGetQueryResultsCacheProperties_single": { + "request": "LS0tCm5hbWU6IEh0dHBHZXRRdWVyeVJlc3VsdHNDYWNoZVByb3BlcnRpZXMKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZ2xvYmFsIGNvbmZpZ3VyYXRpb24gb2YgdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlOgotLS0KdmFyIHJlc3VsdHNDYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvY2FjaGUiKTsKcmVzdWx0c0NhY2hlLnByb3BlcnRpZXMoeyBtb2RlOiAiZGVtYW5kIiB9KTsgCgp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnR0VUJywgdXJsKTsKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMCk7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lm1vZGUgPT0gImRlbWFuZCIpOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLS1oZWFkZXIgJ2FjY2VwdDogYXBwbGljYXRpb24vanNvbicgLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMnIiwib3V0cHV0IjoiSFRUUC8xLjEgMjAwIE9LXG5jb250ZW50LXR5cGU6IGFwcGxpY2F0aW9uL2pzb25cbmNhY2hlLWNvbnRyb2w6IG5vLWNhY2hlLCBuby1zdG9yZSwgbXVzdC1yZXZhbGlkYXRlLCBwcmUtY2hlY2s9MCwgcG9zdC1jaGVjaz0wLCBtYXgtYWdlPTAsIHMtbWF4YWdlPTBcbmNvbm5lY3Rpb246IEtlZXAtQWxpdmVcbmNvbnRlbnQtbGVuZ3RoOiAxMDdcbmNvbnRlbnQtc2VjdXJpdHktcG9saWN5OiBmcmFtZS1hbmNlc3RvcnMgJ3NlbGYnOyBmb3JtLWFjdGlvbiAnc2VsZic7XG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJtb2RlXCIgOiBcImRlbWFuZFwiLCBcbiAgXCJtYXhSZXN1bHRzXCIgOiAxMjgsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IlJldHJpZXZlIHRoZSBnbG9iYWwgY29uZmlndXJhdGlvbiBvZiB0aGUgQVFMIHF1ZXJ5IHJlc3VsdHMgY2FjaGU6XG4iLCJuYW1lIjoiSHR0cEdldFF1ZXJ5UmVzdWx0c0NhY2hlUHJvcGVydGllcyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + }, "HttpGharialAddEdgeCol_single": { "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbEFkZEVkZ2VDb2wKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvZWRnZSI7CmJvZHkgPSB7CiAgY29sbGVjdGlvbjogIndvcmtzX2luIiwKICBmcm9tOiBbImZlbWFsZSIsICJtYWxlIl0sCiAgdG86IFsiY2l0eSJdCn07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQT1NUJywgdXJsLCBib2R5KTsKCmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDIpOwoKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKZXhhbXBsZXMuZHJvcEdyYXBoKCJzb2NpYWwiKTs=", "response": "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" @@ -651,6 +663,18 @@ "request": "LS0tCmRlc2NyaXB0aW9uOiAnJwpuYW1lOiBIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgKLS0tCnZhciBleGFtcGxlcyA9IHJlcXVpcmUoIkBhcmFuZ29kYi9ncmFwaC1leGFtcGxlcy9leGFtcGxlLWdyYXBoLmpzIik7CmV4YW1wbGVzLmxvYWRHcmFwaCgic29jaWFsIik7CmJvZHkgPSB7CiAgbmFtZTogIkFsaWNlIENvb3BlciIsCiAgYWdlOiAyNgp9CnZhciB1cmwgPSAiL19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZSI7CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwoKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMik7Cgpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOwpleGFtcGxlcy5kcm9wR3JhcGgoInNvY2lhbCIpOw==", "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gaHR0cDovL2xvY2FsaG9zdDo4NTI5L19hcGkvZ2hhcmlhbC9zb2NpYWwvdmVydGV4L2ZlbWFsZS9hbGljZVxue1xuICBcIm5hbWVcIjogXCJBbGljZSBDb29wZXJcIixcbiAgXCJhZ2VcIjogMjZcbn0iLCJvdXRwdXQiOiJIVFRQLzEuMSAyMDIgQWNjZXB0ZWRcbmNvbnRlbnQtdHlwZTogYXBwbGljYXRpb24vanNvblxuY2FjaGUtY29udHJvbDogbm8tY2FjaGUsIG5vLXN0b3JlLCBtdXN0LXJldmFsaWRhdGUsIHByZS1jaGVjaz0wLCBwb3N0LWNoZWNrPTAsIG1heC1hZ2U9MCwgcy1tYXhhZ2U9MFxuY29ubmVjdGlvbjogS2VlcC1BbGl2ZVxuY29udGVudC1sZW5ndGg6IDExOFxuY29udGVudC1zZWN1cml0eS1wb2xpY3k6IGZyYW1lLWFuY2VzdG9ycyAnc2VsZic7IGZvcm0tYWN0aW9uICdzZWxmJztcbmV0YWc6IF9oZzVrME4tLS1BXG5leHBpcmVzOiAwXG5wcmFnbWE6IG5vLWNhY2hlXG5zZXJ2ZXI6IEFyYW5nb0RCXG5zdHJpY3QtdHJhbnNwb3J0LXNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwIDsgaW5jbHVkZVN1YkRvbWFpbnNcbngtYXJhbmdvLXF1ZXVlLXRpbWUtc2Vjb25kczogMC4wMDAwMDBcbngtY29udGVudC10eXBlLW9wdGlvbnM6IG5vc25pZmZcblxueyBcbiAgXCJlcnJvclwiIDogZmFsc2UsIFxuICBcImNvZGVcIiA6IDIwMiwgXG4gIFwidmVydGV4XCIgOiB7IFxuICAgIFwiX2lkXCIgOiBcImZlbWFsZS9hbGljZVwiLCBcbiAgICBcIl9rZXlcIiA6IFwiYWxpY2VcIiwgXG4gICAgXCJfb2xkUmV2XCIgOiBcIl9oZzVrME1xLS0tXCIsIFxuICAgIFwiX3JldlwiIDogXCJfaGc1azBOLS0tQVwiIFxuICB9IFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJIdHRwR2hhcmlhbFJlcGxhY2VWZXJ0ZXgiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" }, + "HttpListQueryPlanCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBMaXN0UXVlcnlQbGFuQ2FjaGUKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZW50cmllcyBzdG9yZWQgaW4gdGhlIEFRTCBxdWVyeSBwbGFuIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KZGIuX2NyZWF0ZSgiY29sbCIpOwpmb3IgKGxldCBpID0gMDsgaSA8IDM7IGkrKykgewogIGRiLl9xdWVyeSgiRk9SIGRvYyBJTiBAQGNvbGwgRklMVEVSIGRvYy5hdHRyID09IEB2YWwgUkVUVVJOIGRvYyIsIHsKICAgICJAY29sbCI6ICJjb2xsIiwgdmFsOiAiZm9vIgogIH0sIHsgdXNlUGxhbkNhY2hlOiB0cnVlIH0pOwp9CmRiLl9xdWVyeSgiUkVUVVJOIDQyIiwge30sIHsgdXNlUGxhbkNhY2hlOiB0cnVlIH0pOwoKdmFyIHVybCA9ICIvX2FwaS9xdWVyeS1wbGFuLWNhY2hlIjsKdmFyIHJlc3BvbnNlID0gbG9nQ3VybFJlcXVlc3QoJ0dFVCcsIHVybCk7CmFzc2VydChyZXNwb25zZS5jb2RlID09PSAyMDApOwphc3NlcnQocmVzcG9uc2UucGFyc2VkQm9keS5sZW5ndGggPj0gMik7CmxvZ0pzb25SZXNwb25zZShyZXNwb25zZSk7CgpkYi5fZHJvcCgiY29sbCIpOw==", + "response": "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" + }, + "HttpListQueryResultsCache_single": { + "request": "LS0tCm5hbWU6IEh0dHBMaXN0UXVlcnlSZXN1bHRzQ2FjaGUKZGVzY3JpcHRpb246IHwKICBSZXRyaWV2ZSB0aGUgZW50cmllcyBzdG9yZWQgaW4gdGhlIEFRTCBxdWVyeSByZXN1bHRzIGNhY2hlIG9mIHRoZSBjdXJyZW50IGRhdGFiYXNlOgotLS0KdmFyIHJlc3VsdHNDYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvY2FjaGUiKTsKcmVzdWx0c0NhY2hlLnByb3BlcnRpZXMoeyBtb2RlOiAiZGVtYW5kIiB9KTsgCgpkYi5fY3JlYXRlKCJjb2xsIik7CmZvciAobGV0IGkgPSAwOyBpIDwgMzsgaSsrKSB7CiAgZGIuX3F1ZXJ5KCJGT1IgZG9jIElOIEBAY29sbCBGSUxURVIgZG9jLmF0dHIgPT0gQHZhbCBSRVRVUk4gZG9jIiwgewogICAgIkBjb2xsIjogImNvbGwiLCB2YWw6ICJmb28iCiAgfSwgeyBjYWNoZTogdHJ1ZSwgZnVsbENvdW50OiB0cnVlIH0pOwp9CmRiLl9xdWVyeSgiUkVUVVJOIDQyIiwge30sIHsgY2FjaGU6IHRydWUgfSk7Cgp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL2VudHJpZXMiOwp2YXIgcmVzcG9uc2UgPSBsb2dDdXJsUmVxdWVzdCgnR0VUJywgdXJsKTsKYXNzZXJ0KHJlc3BvbnNlLmNvZGUgPT09IDIwMCk7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lmxlbmd0aCA+PSAyKTsKbG9nSnNvblJlc3BvbnNlKHJlc3BvbnNlKTsKCmRiLl9kcm9wKCJjb2xsIik7", + "response": "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" + }, + "HttpSetQueryResultsCacheProperties_single": { + "request": "LS0tCm5hbWU6IEh0dHBTZXRRdWVyeVJlc3VsdHNDYWNoZVByb3BlcnRpZXMKZGVzY3JpcHRpb246IHwKICBDaGFuZ2Ugc29tZSBwcm9wZXJ0aWVzIG9mIHRoZSBnbG9iYWwgY29uZmlndXJhdGlvbiBvZiB0aGUgQVFMIHF1ZXJ5IHJlc3VsdHMgY2FjaGU6Ci0tLQp2YXIgdXJsID0gIi9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMiOwp2YXIgYm9keSA9IHsgbW9kZTogImRlbWFuZCIsIG1heFJlc3VsdHM6IDMyIH07CnZhciByZXNwb25zZSA9IGxvZ0N1cmxSZXF1ZXN0KCdQVVQnLCB1cmwsIGJvZHkpOwphc3NlcnQocmVzcG9uc2UuY29kZSA9PT0gMjAwKTsKYXNzZXJ0KHJlc3BvbnNlLnBhcnNlZEJvZHkubW9kZSA9PSAiZGVtYW5kIik7CmFzc2VydChyZXNwb25zZS5wYXJzZWRCb2R5Lm1heFJlc3VsdHMgPT0gMzIpOwpsb2dKc29uUmVzcG9uc2UocmVzcG9uc2UpOw==", + "response": "eyJpbnB1dCI6ImN1cmwgLVggUFVUIC0taGVhZGVyICdhY2NlcHQ6IGFwcGxpY2F0aW9uL2pzb24nIC0tZGF0YS1iaW5hcnkgQC0gLS1kdW1wIC0gJ2h0dHA6Ly9sb2NhbGhvc3Q6ODUyOS9fYXBpL3F1ZXJ5LWNhY2hlL3Byb3BlcnRpZXMnIFx1MDAzY1x1MDAzYydFT0YnXG57XG4gIFwibW9kZVwiOiBcImRlbWFuZFwiLFxuICBcIm1heFJlc3VsdHNcIjogMzJcbn1cbkVPRiIsIm91dHB1dCI6IkhUVFAvMS4xIDIwMCBPS1xuY29udGVudC10eXBlOiBhcHBsaWNhdGlvbi9qc29uXG5jYWNoZS1jb250cm9sOiBuby1jYWNoZSwgbm8tc3RvcmUsIG11c3QtcmV2YWxpZGF0ZSwgcHJlLWNoZWNrPTAsIHBvc3QtY2hlY2s9MCwgbWF4LWFnZT0wLCBzLW1heGFnZT0wXG5jb25uZWN0aW9uOiBLZWVwLUFsaXZlXG5jb250ZW50LWxlbmd0aDogMTA2XG5jb250ZW50LXNlY3VyaXR5LXBvbGljeTogZnJhbWUtYW5jZXN0b3JzICdzZWxmJzsgZm9ybS1hY3Rpb24gJ3NlbGYnO1xuZXhwaXJlczogMFxucHJhZ21hOiBuby1jYWNoZVxuc2VydmVyOiBBcmFuZ29EQlxuc3RyaWN0LXRyYW5zcG9ydC1zZWN1cml0eTogbWF4LWFnZT0zMTUzNjAwMCA7IGluY2x1ZGVTdWJEb21haW5zXG54LWFyYW5nby1xdWV1ZS10aW1lLXNlY29uZHM6IDAuMDAwMDAwXG54LWNvbnRlbnQtdHlwZS1vcHRpb25zOiBub3NuaWZmXG5cbnsgXG4gIFwibW9kZVwiIDogXCJkZW1hbmRcIiwgXG4gIFwibWF4UmVzdWx0c1wiIDogMzIsIFxuICBcIm1heFJlc3VsdHNTaXplXCIgOiAyNjg0MzU0NTYsIFxuICBcIm1heEVudHJ5U2l6ZVwiIDogMTY3NzcyMTYsIFxuICBcImluY2x1ZGVTeXN0ZW1cIiA6IGZhbHNlIFxufSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IkNoYW5nZSBzb21lIHByb3BlcnRpZXMgb2YgdGhlIGdsb2JhbCBjb25maWd1cmF0aW9uIG9mIHRoZSBBUUwgcXVlcnkgcmVzdWx0cyBjYWNoZTpcbiIsIm5hbWUiOiJIdHRwU2V0UXVlcnlSZXN1bHRzQ2FjaGVQcm9wZXJ0aWVzIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, "IndexIdentifier_single": { "request": "LS0tCm5hbWU6IEluZGV4SWRlbnRpZmllcgpkZXNjcmlwdGlvbjogJycKLS0tCn5kYi5fY3JlYXRlKCJleGFtcGxlIik7CmRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiAicGVyc2lzdGVudCIsIGZpZWxkczogWyAiYSIsICJiIiBdIH0pOwp2YXIgaW5kZXhJbmZvID0gZGIuZXhhbXBsZS5pbmRleGVzKCkubWFwKGZ1bmN0aW9uKHgpIHsgcmV0dXJuIHguaWQ7IH0pOwppbmRleEluZm87CmRiLl9pbmRleChpbmRleEluZm9bMF0pCmRiLl9pbmRleChpbmRleEluZm9bMV0pCn5kYi5fZHJvcCgiZXhhbXBsZSIpOw==", "response": "eyJpbnB1dCI6ImRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiBcInBlcnNpc3RlbnRcIiwgZmllbGRzOiBbIFwiYVwiLCBcImJcIiBdIH0pO1xudmFyIGluZGV4SW5mbyA9IGRiLmV4YW1wbGUuaW5kZXhlcygpLm1hcChmdW5jdGlvbih4KSB7IHJldHVybiB4LmlkOyB9KTtcbmluZGV4SW5mbztcbmRiLl9pbmRleChpbmRleEluZm9bMF0pXG5kYi5faW5kZXgoaW5kZXhJbmZvWzFdKSIsIm91dHB1dCI6InsgXG4gIFwiY2FjaGVFbmFibGVkXCIgOiBmYWxzZSwgXG4gIFwiZGVkdXBsaWNhdGVcIiA6IHRydWUsIFxuICBcImVzdGltYXRlc1wiIDogdHJ1ZSwgXG4gIFwiZmllbGRzXCIgOiBbIFxuICAgIFwiYVwiLCBcbiAgICBcImJcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS84NjE5MFwiLCBcbiAgXCJpc05ld2x5Q3JlYXRlZFwiIDogdHJ1ZSwgXG4gIFwibmFtZVwiIDogXCJpZHhfMTgxNDgxOTY3Nzk1OTg4MDcwNVwiLCBcbiAgXCJzZWxlY3Rpdml0eUVzdGltYXRlXCIgOiAxLCBcbiAgXCJzcGFyc2VcIiA6IGZhbHNlLCBcbiAgXCJ0eXBlXCIgOiBcInBlcnNpc3RlbnRcIiwgXG4gIFwidW5pcXVlXCIgOiBmYWxzZSwgXG4gIFwiY29kZVwiIDogMjAxIFxufVxuWyBcbiAgXCJleGFtcGxlLzBcIiwgXG4gIFwiZXhhbXBsZS84NjE5MFwiIFxuXVxuXG57IFxuICBcImZpZWxkc1wiIDogWyBcbiAgICBcIl9rZXlcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS8wXCIsIFxuICBcIm5hbWVcIiA6IFwicHJpbWFyeVwiLCBcbiAgXCJzZWxlY3Rpdml0eUVzdGltYXRlXCIgOiAxLCBcbiAgXCJzcGFyc2VcIiA6IGZhbHNlLCBcbiAgXCJ0eXBlXCIgOiBcInByaW1hcnlcIiwgXG4gIFwidW5pcXVlXCIgOiB0cnVlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59XG5cbnsgXG4gIFwiY2FjaGVFbmFibGVkXCIgOiBmYWxzZSwgXG4gIFwiZGVkdXBsaWNhdGVcIiA6IHRydWUsIFxuICBcImVzdGltYXRlc1wiIDogdHJ1ZSwgXG4gIFwiZmllbGRzXCIgOiBbIFxuICAgIFwiYVwiLCBcbiAgICBcImJcIiBcbiAgXSwgXG4gIFwiaWRcIiA6IFwiZXhhbXBsZS84NjE5MFwiLCBcbiAgXCJuYW1lXCIgOiBcImlkeF8xODE0ODE5Njc3OTU5ODgwNzA1XCIsIFxuICBcInNlbGVjdGl2aXR5RXN0aW1hdGVcIiA6IDEsIFxuICBcInNwYXJzZVwiIDogZmFsc2UsIFxuICBcInR5cGVcIiA6IFwicGVyc2lzdGVudFwiLCBcbiAgXCJ1bmlxdWVcIiA6IGZhbHNlLCBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6IkluZGV4SWRlbnRpZmllciIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" @@ -2887,6 +2911,18 @@ "request": "LS0tCm5hbWU6IGFxbFppcApkZXNjcmlwdGlvbjogJycKLS0tClJFVFVSTiBaSVAoIFsgIm5hbWUiLCAiYWN0aXZlIiwgImhvYmJpZXMiIF0sIFsgInNvbWUgdXNlciIsIHRydWUsIFsgInN3aW1taW5nIiwgInJpZGluZyIgXSBdICk=", "response": "eyJpbnB1dCI6IlJFVFVSTiBaSVAoIFsgXCJuYW1lXCIsIFwiYWN0aXZlXCIsIFwiaG9iYmllc1wiIF0sIFsgXCJzb21lIHVzZXJcIiwgdHJ1ZSwgWyBcInN3aW1taW5nXCIsIFwicmlkaW5nXCIgXSBdICkiLCJvdXRwdXQiOiJbIFxuICB7IFxuICAgIFwibmFtZVwiIDogXCJzb21lIHVzZXJcIiwgXG4gICAgXCJhY3RpdmVcIiA6IHRydWUsIFxuICAgIFwiaG9iYmllc1wiIDogWyBcbiAgICAgIFwic3dpbW1pbmdcIiwgXG4gICAgICBcInJpZGluZ1wiIFxuICAgIF0gXG4gIH0gXG5dIiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6ImFxbFppcCIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" }, + "arangosh_cache_query_plan_single": { + "request": "LS0tCm5hbWU6IGFyYW5nb3NoX2NhY2hlX3F1ZXJ5X3BsYW4KZGVzY3JpcHRpb246ICcnCi0tLQp+ZGIuX2NyZWF0ZSgiY29sbCIpOwp2YXIgcXVlcnkgPSAiRk9SIGRvYyBJTiBjb2xsIEZJTFRFUiBkb2MuYXR0ciA9PSBAdmFsIFJFVFVSTiBkb2MiOwp2YXIgYmluZFZhcnMgPSB7IHZhbDogImZvbyIgfTsKZGIuX3F1ZXJ5KHF1ZXJ5LCBiaW5kVmFycywgeyB1c2VQbGFuQ2FjaGU6IHRydWUgfSk7IC8vIEFkZHMgcGxhbiB0byBjYWNoZQpkYi5fcXVlcnkocXVlcnksIGJpbmRWYXJzLCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsgLy8gVXNlcyBjYWNoZWQgcGxhbgp+ZGIuX2Ryb3AoImNvbGwiKTs=", + "response": "eyJpbnB1dCI6InZhciBxdWVyeSA9IFwiRk9SIGRvYyBJTiBjb2xsIEZJTFRFUiBkb2MuYXR0ciA9PSBAdmFsIFJFVFVSTiBkb2NcIjtcbnZhciBiaW5kVmFycyA9IHsgdmFsOiBcImZvb1wiIH07XG5kYi5fcXVlcnkocXVlcnksIGJpbmRWYXJzLCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsgLy8gQWRkcyBwbGFuIHRvIGNhY2hlXG5kYi5fcXVlcnkocXVlcnksIGJpbmRWYXJzLCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsgLy8gVXNlcyBjYWNoZWQgcGxhbiIsIm91dHB1dCI6IltvYmplY3QgQXJhbmdvUXVlcnlDdXJzb3IsIGNvdW50OiAwLCByZXN1bHRzIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IGZhbHNlXVxuXG5bb2JqZWN0IEFyYW5nb1F1ZXJ5Q3Vyc29yLCBwbGFuIGNhY2hlIGtleTogXCIyNzU3MjM5Njc1MDYwODgzNDk5XCIsIGNvdW50OiAwLCByZXN1bHRzIGNhY2hlZDogZmFsc2UsIGhhc01vcmU6IGZhbHNlXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJhcmFuZ29zaF9jYWNoZV9xdWVyeV9wbGFuIiwidHlwZSI6InNpbmdsZSIsInJlbmRlciI6ImlucHV0L291dHB1dCJ9fQo=" + }, + "arangosh_clear_query_plan_cache_single": { + "request": "LS0tCm5hbWU6IGFyYW5nb3NoX2NsZWFyX3F1ZXJ5X3BsYW5fY2FjaGUKZGVzY3JpcHRpb246ICcnCi0tLQp2YXIgcGxhbkNhY2hlID0gcmVxdWlyZSgiQGFyYW5nb2RiL2FxbC9wbGFuLWNhY2hlIik7CnBsYW5DYWNoZS5jbGVhcigpOw==", + "response": "eyJpbnB1dCI6InZhciBwbGFuQ2FjaGUgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FxbC9wbGFuLWNhY2hlXCIpO1xucGxhbkNhY2hlLmNsZWFyKCk7Iiwib3V0cHV0IjoieyBcbiAgXCJjb2RlXCIgOiAyMDAgXG59IiwiZXJyb3IiOiIiLCJvcHRpb25zIjp7ImRlc2NyaXB0aW9uIjoiIiwibmFtZSI6ImFyYW5nb3NoX2NsZWFyX3F1ZXJ5X3BsYW5fY2FjaGUiLCJ0eXBlIjoic2luZ2xlIiwicmVuZGVyIjoiaW5wdXQvb3V0cHV0In19Cg==" + }, + "arangosh_list_cached_query_plans_single": { + "request": "LS0tCm5hbWU6IGFyYW5nb3NoX2xpc3RfY2FjaGVkX3F1ZXJ5X3BsYW5zCmRlc2NyaXB0aW9uOiAnJwotLS0KfmRiLl9jcmVhdGUoImNvbGwiKTsKfmRiLl9xdWVyeSgiUkVUVVJOIDQyIiwge30sIHsgdXNlUGxhbkNhY2hlOiB0cnVlIH0pOwp+ZGIuX3F1ZXJ5KCJGT1IgZG9jIElOIGNvbGwgRklMVEVSIGRvYy5hdHRyID09IEB2YWwgUkVUVVJOIGRvYyIsIHsgdmFsOiAiZm9vIiB9LCB7IHVzZVBsYW5DYWNoZTogdHJ1ZSB9KTsKdmFyIHBsYW5DYWNoZSA9IHJlcXVpcmUoIkBhcmFuZ29kYi9hcWwvcGxhbi1jYWNoZSIpOwpwbGFuQ2FjaGUudG9BcnJheSgpOwp+ZGIuX2Ryb3AoImNvbGwiKTs=", + "response": "eyJpbnB1dCI6InZhciBwbGFuQ2FjaGUgPSByZXF1aXJlKFwiQGFyYW5nb2RiL2FxbC9wbGFuLWNhY2hlXCIpO1xucGxhbkNhY2hlLnRvQXJyYXkoKTsiLCJvdXRwdXQiOiJbIFxuICB7IFxuICAgIFwiaGFzaFwiIDogXCIyNzU3MjM5Njc1MDYwODgzNDk5XCIsIFxuICAgIFwicXVlcnlcIiA6IFwiRk9SIGRvYyBJTiBjb2xsIEZJTFRFUiBkb2MuYXR0ciA9PSBAdmFsIFJFVFVSTiBkb2NcIiwgXG4gICAgXCJxdWVyeUhhc2hcIiA6IDExMzgyNTA4ODYyNzcwODkwMDAwLCBcbiAgICBcImJpbmRWYXJzXCIgOiB7IFxuICAgIH0sIFxuICAgIFwiZnVsbENvdW50XCIgOiBmYWxzZSwgXG4gICAgXCJkYXRhU291cmNlc1wiIDogWyBcbiAgICAgIFwiY29sbFwiIFxuICAgIF0sIFxuICAgIFwiY3JlYXRlZFwiIDogXCIyMDI1LTAxLTE1VDA5OjQwOjA2WlwiLCBcbiAgICBcImhpdHNcIiA6IDAsIFxuICAgIFwibWVtb3J5VXNhZ2VcIiA6IDMwODAgXG4gIH0sIFxuICB7IFxuICAgIFwiaGFzaFwiIDogXCIzNzg5NTY1OTgzMzg1Nzg3MDUyXCIsIFxuICAgIFwicXVlcnlcIiA6IFwiUkVUVVJOIDQyXCIsIFxuICAgIFwicXVlcnlIYXNoXCIgOiA5NjIxNjc5NDYzOTkwMDg2MDAwLCBcbiAgICBcImJpbmRWYXJzXCIgOiB7IFxuICAgIH0sIFxuICAgIFwiZnVsbENvdW50XCIgOiBmYWxzZSwgXG4gICAgXCJkYXRhU291cmNlc1wiIDogWyBdLCBcbiAgICBcImNyZWF0ZWRcIiA6IFwiMjAyNS0wMS0xNVQwOTo0MDowNlpcIiwgXG4gICAgXCJoaXRzXCIgOiAwLCBcbiAgICBcIm1lbW9yeVVzYWdlXCIgOiAxOTcyIFxuICB9IFxuXSIsImVycm9yIjoiIiwib3B0aW9ucyI6eyJkZXNjcmlwdGlvbiI6IiIsIm5hbWUiOiJhcmFuZ29zaF9saXN0X2NhY2hlZF9xdWVyeV9wbGFucyIsInR5cGUiOiJzaW5nbGUiLCJyZW5kZXIiOiJpbnB1dC9vdXRwdXQifX0K" + }, "col_dropIndex_single": { "request": "LS0tCm5hbWU6IGNvbF9kcm9wSW5kZXgKZGVzY3JpcHRpb246ICcnCi0tLQp+ZGIuX2NyZWF0ZSgiZXhhbXBsZSIpOwp2YXIgaWR4MSA9IGRiLmV4YW1wbGUuZW5zdXJlSW5kZXgoeyB0eXBlOiAicGVyc2lzdGVudCIsIGZpZWxkczogWyJhIiwgImIiXSB9KTsKdmFyIGlkeDIgPSBkYi5leGFtcGxlLmVuc3VyZUluZGV4KHsgdHlwZTogInBlcnNpc3RlbnQiLCBmaWVsZHM6IFsiYyJdIH0pOwp2YXIgaW5kZXhJbmZvID0gZGIuZXhhbXBsZS5pbmRleGVzKCk7CmluZGV4SW5mbzsKZGIuZXhhbXBsZS5kcm9wSW5kZXgoaW5kZXhJbmZvWzFdKQpkYi5leGFtcGxlLmRyb3BJbmRleChpbmRleEluZm9bMl0uaWQpCmluZGV4SW5mbyA9IGRiLmV4YW1wbGUuaW5kZXhlcygpOwp+ZGIuX2Ryb3AoImV4YW1wbGUiKTs=", "response": "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"