From 8d4b6eba46e59b338c049ae11f172854cf2c82d9 Mon Sep 17 00:00:00 2001 From: Liam Thompson Date: Mon, 25 Aug 2025 09:48:15 +0200 Subject: [PATCH] [DOCS] Move ESQL docs from docs-content repo (#133301) --- docs/reference/query-languages/esql.md | 49 +- .../esql/esql-cross-clusters.md | 507 ++++++++++++++++++ .../query-languages/esql/esql-examples.md | 92 +--- .../esql/esql-getting-started.md | 424 +++++++++++++++ .../query-languages/esql/esql-multi-index.md | 159 ++++++ .../query-languages/esql/esql-multi.md | 13 + .../query-languages/esql/esql-rest.md | 353 ++++++++++++ .../esql/esql-search-tutorial.md | 475 ++++++++++++++++ .../esql/esql-task-management.md | 57 ++ .../esql/esql-troubleshooting.md | 5 +- .../elasticsearch-reference-esql-enrich.png | Bin 0 -> 143426 bytes .../elasticsearch-reference-esql-limit.png | Bin 0 -> 18286 bytes ...lasticsearch-reference-esql-sort-limit.png | Bin 0 -> 29130 bytes .../elasticsearch-reference-esql-sort.png | Bin 0 -> 18686 bytes ...elasticsearch-reference-source-command.svg | 109 ++++ docs/reference/query-languages/toc.yml | 12 +- 16 files changed, 2153 insertions(+), 102 deletions(-) create mode 100644 docs/reference/query-languages/esql/esql-cross-clusters.md create mode 100644 docs/reference/query-languages/esql/esql-getting-started.md create mode 100644 docs/reference/query-languages/esql/esql-multi-index.md create mode 100644 docs/reference/query-languages/esql/esql-multi.md create mode 100644 docs/reference/query-languages/esql/esql-rest.md create mode 100644 docs/reference/query-languages/esql/esql-search-tutorial.md create mode 100644 docs/reference/query-languages/esql/esql-task-management.md create mode 100644 docs/reference/query-languages/images/elasticsearch-reference-esql-enrich.png create mode 100644 docs/reference/query-languages/images/elasticsearch-reference-esql-limit.png create mode 100644 docs/reference/query-languages/images/elasticsearch-reference-esql-sort-limit.png create mode 100644 docs/reference/query-languages/images/elasticsearch-reference-esql-sort.png create mode 100644 docs/reference/query-languages/images/elasticsearch-reference-source-command.svg diff --git a/docs/reference/query-languages/esql.md b/docs/reference/query-languages/esql.md index d66dceb1d36ff..df3a502bdd33f 100644 --- a/docs/reference/query-languages/esql.md +++ b/docs/reference/query-languages/esql.md @@ -2,23 +2,48 @@ navigation_title: "{{esql}}" mapped_pages: - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-language.html + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql.html + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-getting-started.html + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-using.html + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-examples.html +products: + - id: elasticsearch --- # {{esql}} reference [esql-language] -:::{note} -This section provides detailed **reference information** about the {{esql}} language, including syntax, functions, and operators. +**Elasticsearch Query Language ({{esql}})** is a piped query language for filtering, transforming, and analyzing data. -For overview, conceptual, and getting started information, refer to the [{{esql}} language overview](docs-content://explore-analyze/query-filter/languages/esql.md) in the **Explore and analyze** section. -::: +## What's {{esql}}? [_the_esql_compute_engine] -{{esql}} is a piped query language for exploring and analyzing data in {{es}}. It is designed to be easy to use and understand, while also being powerful enough to handle complex data processing. +You can author {{esql}} queries to find specific events, perform statistical analysis, and create visualizations. It supports a wide range of commands, functions, and operators to perform various data operations, such as filter, aggregation, time-series analysis, and more. It initially supported a subset of the features available in Query DSL, but it is rapidly evolving with every {{serverless-full}} and Stack release. -This reference section provides detailed technical information about {{esql}} features, syntax, and behavior: +{{esql}} is designed to be easy to read and write, making it accessible for users with varying levels of technical expertise. It is particularly useful for data analysts, security professionals, and developers who need to work with large datasets in Elasticsearch. + +## How does it work? [search-analyze-data-esql] + +{{esql}} uses pipes (`|`) to manipulate and transform data in a step-by-step fashion. This approach allows you to compose a series of operations, where the output of one operation becomes the input for the next, enabling complex data transformations and analysis. + +Here's a simple example of an {{esql}} query: + +```esql +FROM sample_data +| SORT @timestamp DESC +| LIMIT 3 +``` + +Note that each line in the query represents a step in the data processing pipeline: +- The `FROM` clause specifies the index or data stream to query +- The `SORT` clause sorts the data by the `@timestamp` field in descending order +- The `LIMIT` clause restricts the output to the top 3 results + +### User interfaces + +You can interact with {{esql}} in two ways: + +- **Programmatic access**: Use {{esql}} syntax with the {{es}} `_query` endpoint. + - Refer to [](esql/esql-rest.md) + +- **Interactive interfaces**: Work with {{esql}} through Elastic user interfaces including Kibana Discover, Dashboards, Dev Tools, and analysis tools in Elastic Security and Observability. + - Refer to [Using {{esql}} in {{kib}}](docs-content://explore-analyze/query-filter/languages/esql-kibana.md). -* [Syntax reference](esql/esql-syntax-reference.md): Learn the basic syntax of commands, functions, and operators -* [Advanced workflows](esql/esql-advanced.md): Learn how to handle more complex tasks with these guides, including how to extract, transform, and combine data from multiple indices -* [Types and fields](esql/esql-types-and-fields.md): Learn about how {{esql}} handles different data types and special fields -* [Limitations](esql/limitations.md): Learn about the current limitations of {{esql}} -* [Examples](esql/esql-examples.md): Explore some example queries -* [Troubleshooting](esql/esql-troubleshooting.md): Learn how to diagnose and resolve issues with {{esql}} diff --git a/docs/reference/query-languages/esql/esql-cross-clusters.md b/docs/reference/query-languages/esql/esql-cross-clusters.md new file mode 100644 index 0000000000000..762c6b2ab6ae9 --- /dev/null +++ b/docs/reference/query-languages/esql/esql-cross-clusters.md @@ -0,0 +1,507 @@ +--- +navigation_title: Query across clusters +mapped_pages: + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-cross-clusters.html +applies_to: + stack: preview 9.0, ga 9.1 + serverless: unavailable +products: + - id: elasticsearch +--- + + +# Use ES|QL across clusters [esql-cross-clusters] + +With {{esql}}, you can execute a single query across multiple clusters. + + +## Prerequisites [esql-ccs-prerequisites] + +* {{ccs-cap}} requires remote clusters. To set up remote clusters, see [*Remote clusters*](docs-content://deploy-manage/remote-clusters.md). + + To ensure your remote cluster configuration supports {{ccs}}, see [Supported {{ccs}} configurations](docs-content://solutions/search/cross-cluster-search.md#ccs-supported-configurations). + +* For full {{ccs}} capabilities, the local and remote cluster must be on the same [subscription level](https://www.elastic.co/subscriptions). +* The local coordinating node must have the [`remote_cluster_client`](docs-content://deploy-manage/distributed-architecture/clusters-nodes-shards/node-roles.md#remote-node) node role. +* If you use [sniff mode](docs-content:///deploy-manage/remote-clusters/remote-clusters-self-managed.md#sniff-mode), the local coordinating node must be able to connect to seed and gateway nodes on the remote cluster. + + We recommend using gateway nodes capable of serving as coordinating nodes. The seed nodes can be a subset of these gateway nodes. + +* If you use [proxy mode](docs-content:///deploy-manage/remote-clusters/remote-clusters-self-managed.md#proxy-mode), the local coordinating node must be able to connect to the configured `proxy_address`. The proxy at this address must be able to route connections to gateway and coordinating nodes on the remote cluster. +* {{ccs-cap}} requires different security privileges on the local cluster and remote cluster. See [Configure privileges for {{ccs}}](docs-content://deploy-manage/remote-clusters/remote-clusters-cert.md#remote-clusters-privileges-ccs) and [*Remote clusters*](docs-content://deploy-manage/remote-clusters.md). + + +## Security model [esql-ccs-security-model] + +{{es}} supports two security models for cross-cluster search (CCS): + +* [TLS certificate authentication](#esql-ccs-security-model-certificate) +* [API key authentication](#esql-ccs-security-model-api-key) + +::::{tip} +To check which security model is being used to connect your clusters, run `GET _remote/info`. If you’re using the API key authentication method, you’ll see the `"cluster_credentials"` key in the response. + +:::: + + + +### TLS certificate authentication [esql-ccs-security-model-certificate] + +::::{admonition} Deprecated in 9.0.0. +:class: warning + +Use [API key authentication](#esql-ccs-security-model-api-key) instead. +:::: + + +TLS certificate authentication secures remote clusters with mutual TLS. This could be the preferred model when a single administrator has full control over both clusters. We generally recommend that roles and their privileges be identical in both clusters. + +Refer to [TLS certificate authentication](docs-content://deploy-manage/remote-clusters/remote-clusters-cert.md) for prerequisites and detailed setup instructions. + + +### API key authentication [esql-ccs-security-model-api-key] + +The following information pertains to using {{esql}} across clusters with the [**API key based security model**](docs-content://deploy-manage/remote-clusters/remote-clusters-api-key.md). You’ll need to follow the steps on that page for the **full setup instructions**. This page only contains additional information specific to {{esql}}. + +API key based cross-cluster search (CCS) enables more granular control over allowed actions between clusters. This may be the preferred model when you have different administrators for different clusters and want more control over who can access what data. In this model, cluster administrators must explicitly define the access given to clusters and users. + +You will need to: + +* Create an API key on the **remote cluster** using the [Create cross-cluster API key](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-cross-cluster-api-key) API or using the [Kibana API keys UI](docs-content://deploy-manage/api-keys/elasticsearch-api-keys.md). +* Add the API key to the keystore on the **local cluster**, as part of the steps in [configuring the local cluster](docs-content://deploy-manage/remote-clusters/remote-clusters-api-key.md#remote-clusters-security-api-key-local-actions). All cross-cluster requests from the local cluster are bound by the API key’s privileges. + +Using {{esql}} with the API key based security model requires some additional permissions that may not be needed when using the traditional query DSL based search. The following example API call creates a role that can query remote indices using {{esql}} when using the API key based security model. The final privilege, `remote_cluster`, is required to allow remote enrich operations. + +```console +POST /_security/role/remote1 +{ + "cluster": ["cross_cluster_search"], <1> + "indices": [ + { + "names" : [""], <2> + "privileges": ["read"] + } + ], + "remote_indices": [ <3> + { + "names": [ "logs-*" ], + "privileges": [ "read","read_cross_cluster" ], <4> + "clusters" : ["my_remote_cluster"] <5> + } + ], + "remote_cluster": [ <6> + { + "privileges": [ + "monitor_enrich" + ], + "clusters": [ + "my_remote_cluster" + ] + } + ] +} +``` + +1. The `cross_cluster_search` cluster privilege is required for the *local* cluster. +2. Typically, users will have permissions to read both local and remote indices. However, for cases where the role is intended to ONLY search the remote cluster, the `read` permission is still required for the local cluster. To provide read access to the local cluster, but disallow reading any indices in the local cluster, the `names` field may be an empty string. +3. The indices allowed read access to the remote cluster. The configured [cross-cluster API key](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-cross-cluster-api-key) must also allow this index to be read. +4. The `read_cross_cluster` privilege is always required when using {{esql}} across clusters with the API key based security model. +5. The remote clusters to which these privileges apply. This remote cluster must be configured with a [cross-cluster API key](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-cross-cluster-api-key) and connected to the remote cluster before the remote index can be queried. Verify connection using the [Remote cluster info](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-remote-info) API. +6. Required to allow remote enrichment. Without this, the user cannot read from the `.enrich` indices on the remote cluster. The `remote_cluster` security privilege was introduced in version **8.15.0**. + + +You will then need a user or API key with the permissions you created above. The following example API call creates a user with the `remote1` role. + +```console +POST /_security/user/remote_user +{ + "password" : "", + "roles" : [ "remote1" ] +} +``` + +Remember that all cross-cluster requests from the local cluster are bound by the cross cluster API key’s privileges, which are controlled by the remote cluster’s administrator. + +::::{tip} +Cross cluster API keys created in versions prior to 8.15.0 will need to replaced or updated to add the new permissions required for {{esql}} with ENRICH. + +:::: + + + +## Remote cluster setup [ccq-remote-cluster-setup] + +Once the security model is configured, you can add remote clusters. + +The following [cluster update settings](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-settings) API request adds three remote clusters: `cluster_one`, `cluster_two`, and `cluster_three`. + +```console +PUT _cluster/settings +{ + "persistent": { + "cluster": { + "remote": { + "cluster_one": { + "seeds": [ + "35.238.149.1:9300" + ], + "skip_unavailable": true + }, + "cluster_two": { + "seeds": [ + "35.238.149.2:9300" + ], + "skip_unavailable": false + }, + "cluster_three": { <1> + "seeds": [ + "35.238.149.3:9300" + ] + } + } + } + } +} +``` + +1. Since `skip_unavailable` was not set on `cluster_three`, it uses the default of `true`. See the [Optional remote clusters](#ccq-skip-unavailable-clusters) section for details. + + + +## Query across multiple clusters [ccq-from] + +In the `FROM` command, specify data streams and indices on remote clusters using the format `:`. For instance, the following {{esql}} request queries the `my-index-000001` index on a single remote cluster named `cluster_one`: + +```esql +FROM cluster_one:my-index-000001 +| LIMIT 10 +``` + +Similarly, this {{esql}} request queries the `my-index-000001` index from three clusters: + +* The local ("querying") cluster +* Two remote clusters, `cluster_one` and `cluster_two` + +```esql +FROM my-index-000001,cluster_one:my-index-000001,cluster_two:my-index-000001 +| LIMIT 10 +``` + +Likewise, this {{esql}} request queries the `my-index-000001` index from all remote clusters (`cluster_one`, `cluster_two`, and `cluster_three`): + +```esql +FROM *:my-index-000001 +| LIMIT 10 +``` + + +## Cross-cluster metadata [ccq-cluster-details] + +Using the `"include_ccs_metadata": true` option, users can request that ES|QL {{ccs}} responses include metadata about the search on each cluster (when the response format is JSON). Here we show an example using the async search endpoint. {{ccs-cap}} metadata is also present in the synchronous search endpoint response when requested. If the search returns partial results and there are partial shard or remote cluster failures, `_clusters` metadata containing the failures will be included in the response regardless of the `include_ccs_metadata` parameter. + +```console +POST /_query/async?format=json +{ + "query": """ + FROM my-index-000001,cluster_one:my-index-000001,cluster_two:my-index* + | STATS COUNT(http.response.status_code) BY user.id + | LIMIT 2 + """, + "include_ccs_metadata": true +} +``` + +Which returns: + +```console-result +{ + "is_running": false, + "took": 42, <1> + "is_partial": false, <7> + "columns" : [ + { + "name" : "COUNT(http.response.status_code)", + "type" : "long" + }, + { + "name" : "user.id", + "type" : "keyword" + } + ], + "values" : [ + [4, "elkbee"], + [1, "kimchy"] + ], + "_clusters": { <2> + "total": 3, + "successful": 3, + "running": 0, + "skipped": 0, + "partial": 0, + "failed": 0, + "details": { <3> + "(local)": { <4> + "status": "successful", + "indices": "blogs", + "took": 41, <5> + "_shards": { <6> + "total": 13, + "successful": 13, + "skipped": 0, + "failed": 0 + } + }, + "cluster_one": { + "status": "successful", + "indices": "cluster_one:my-index-000001", + "took": 38, + "_shards": { + "total": 4, + "successful": 4, + "skipped": 0, + "failed": 0 + } + }, + "cluster_two": { + "status": "successful", + "indices": "cluster_two:my-index*", + "took": 40, + "_shards": { + "total": 18, + "successful": 18, + "skipped": 1, + "failed": 0 + } + } + } + } +} +``` + +1. How long the entire search (across all clusters) took, in milliseconds. +2. This section of counters shows all possible cluster search states and how many cluster searches are currently in that state. The clusters can have one of the following statuses: **running**, **successful** (searches on all shards were successful), **skipped** (the search failed on a cluster marked with `skip_unavailable`=`true`), **failed** (the search failed on a cluster marked with `skip_unavailable`=`false`) or **partial** (the search was [interrupted](https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-esql) before finishing or has partially failed). +3. The `_clusters/details` section shows metadata about the search on each cluster. +4. If you included indices from the local cluster you sent the request to in your {{ccs}}, it is identified as "(local)". +5. How long (in milliseconds) the search took on each cluster. This can be useful to determine which clusters have slower response times than others. +6. The shard details for the search on that cluster, including a count of shards that were skipped due to the can-match phase results. Shards are skipped when they cannot have any matching data and therefore are not included in the full ES|QL query. +7. The `is_partial` field is set to `true` if the search has partial results for any reason, for example due to partial shard failures, +failures in remote clusters, or if the async query was stopped by calling the [async query stop API](https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-esql). + +The cross-cluster metadata can be used to determine whether any data came back from a cluster. For instance, in the query below, the wildcard expression for `cluster-two` did not resolve to a concrete index (or indices). The cluster is, therefore, marked as *skipped* and the total number of shards searched is set to zero. + +```console +POST /_query/async?format=json +{ + "query": """ + FROM cluster_one:my-index*,cluster_two:logs* + | STATS COUNT(http.response.status_code) BY user.id + | LIMIT 2 + """, + "include_ccs_metadata": true +} +``` + +Which returns: + +```console-result +{ + "is_running": false, + "took": 55, + "is_partial": true, <3> + "columns": [ + ... + ], + "values": [ + ... + ], + "_clusters": { + "total": 2, + "successful": 1, + "running": 0, + "skipped": 1, <1> + "partial": 0, + "failed": 0, + "details": { + "cluster_one": { + "status": "successful", + "indices": "cluster_one:my-index*", + "took": 38, + "_shards": { + "total": 4, + "successful": 4, + "skipped": 0, + "failed": 0 + } + }, + "cluster_two": { + "status": "skipped", <1> + "indices": "cluster_two:logs*", + "took": 0, + "_shards": { + "total": 0, <2> + "successful": 0, + "skipped": 0, + "failed": 0 + } + } + } + } +} +``` + +1. This cluster is marked as *skipped*, since there were no matching indices on that cluster. +2. Indicates that no shards were searched (due to not having any matching indices). +3. Since one of the clusters is skipped, the search result is marked as partial. + + + +## Enrich across clusters [ccq-enrich] + +Enrich in {{esql}} across clusters operates similarly to [local enrich](commands/enrich.md). If the enrich policy and its enrich indices are consistent across all clusters, simply write the enrich command as you would without remote clusters. In this default mode, {{esql}} can execute the enrich command on either the local cluster or the remote clusters, aiming to minimize computation or inter-cluster data transfer. Ensuring that the policy exists with consistent data on both the local cluster and the remote clusters is critical for ES|QL to produce a consistent query result. + +::::{tip} +Enrich in {{esql}} across clusters using the API key based security model was introduced in version **8.15.0**. Cross cluster API keys created in versions prior to 8.15.0 will need to replaced or updated to use the new required permissions. Refer to the example in the [API key authentication](#esql-ccs-security-model-api-key) section. + +:::: + + +In the following example, the enrich with `hosts` policy can be executed on either the local cluster or the remote cluster `cluster_one`. + +```esql +FROM my-index-000001,cluster_one:my-index-000001 +| ENRICH hosts ON ip +| LIMIT 10 +``` + +Enrich with an {{esql}} query against remote clusters only can also happen on the local cluster. This means the below query requires the `hosts` enrich policy to exist on the local cluster as well. + +```esql +FROM cluster_one:my-index-000001,cluster_two:my-index-000001 +| LIMIT 10 +| ENRICH hosts ON ip +``` + + +### Enrich with coordinator mode [esql-enrich-coordinator] + +{{esql}} provides the enrich `_coordinator` mode to force {{esql}} to execute the enrich command on the local cluster. This mode should be used when the enrich policy is not available on the remote clusters or maintaining consistency of enrich indices across clusters is challenging. + +```esql +FROM my-index-000001,cluster_one:my-index-000001 +| ENRICH _coordinator:hosts ON ip +| SORT host_name +| LIMIT 10 +``` + +::::{important} +Enrich with the `_coordinator` mode usually increases inter-cluster data transfer and workload on the local cluster. + +:::: + + + +### Enrich with remote mode [esql-enrich-remote] + +{{esql}} also provides the enrich `_remote` mode to force {{esql}} to execute the enrich command independently on each remote cluster where the target indices reside. This mode is useful for managing different enrich data on each cluster, such as detailed information of hosts for each region where the target (main) indices contain log events from these hosts. + +In the below example, the `hosts` enrich policy is required to exist on all remote clusters: the `querying` cluster (as local indices are included), the remote cluster `cluster_one`, and `cluster_two`. + +```esql +FROM my-index-000001,cluster_one:my-index-000001,cluster_two:my-index-000001 +| ENRICH _remote:hosts ON ip +| SORT host_name +| LIMIT 10 +``` + +A `_remote` enrich cannot be executed after a [`STATS`](commands/stats-by.md) command. The following example would result in an error: + +```esql +FROM my-index-000001,cluster_one:my-index-000001,cluster_two:my-index-000001 +| STATS COUNT(*) BY ip +| ENRICH _remote:hosts ON ip +| SORT host_name +| LIMIT 10 +``` + + +### Multiple enrich commands [esql-multi-enrich] + +You can include multiple enrich commands in the same query with different modes. {{esql}} will attempt to execute them accordingly. For example, this query performs two enriches, first with the `hosts` policy on any cluster and then with the `vendors` policy on the local cluster. + +```esql +FROM my-index-000001,cluster_one:my-index-000001,cluster_two:my-index-000001 +| ENRICH hosts ON ip +| ENRICH _coordinator:vendors ON os +| LIMIT 10 +``` + +A `_remote` enrich command can’t be executed after a `_coordinator` enrich command. The following example would result in an error. + +```esql +FROM my-index-000001,cluster_one:my-index-000001,cluster_two:my-index-000001 +| ENRICH _coordinator:hosts ON ip +| ENRICH _remote:vendors ON os +| LIMIT 10 +``` + + +## Excluding clusters or indices from {{esql}} query [ccq-exclude] + +To exclude an entire cluster, prefix the cluster alias with a minus sign in the `FROM` command, for example: `-my_cluster:*`: + +```esql +FROM my-index-000001,cluster*:my-index-000001,-cluster_three:* +| LIMIT 10 +``` + +To exclude a specific remote index, prefix the index with a minus sign in the `FROM` command, such as `my_cluster:-my_index`: + +```esql +FROM my-index-000001,cluster*:my-index-*,cluster_three:-my-index-000001 +| LIMIT 10 +``` + + +## Skipping problematic remote clusters [ccq-skip-unavailable-clusters] + +{{ccs-cap}} for {{esql}} behavior when there are problems connecting to or running query on remote clusters differs between versions. + +::::{tab-set} + +:::{tab-item} 9.1 +Remote clusters are configured with the `skip_unavailable: true` setting by default. With this setting, clusters are marked as `skipped` or `partial` rather than causing queries to fail in the following scenarios: + +* The remote cluster is disconnected from the querying cluster, either before or during the query execution. +* The remote cluster does not have the requested index, or it is not accessible due to security settings. +* An error happened while processing the query on the remote cluster. + +The `partial` status means the remote query either has errors or was interrupted by an explicit user action, but some data may be returned. + +Queries will still fail when `skip_unavailable` is set `true`, if none of the specified indices exist. For example, the +following queries will fail: + +```esql +FROM cluster_one:missing-index | LIMIT 10 +FROM cluster_one:missing-index* | LIMIT 10 +FROM cluster_one:missing-index*,cluster_two:missing-index | LIMIT 10 +``` +::: + +:::{tab-item} 9.0 +If a remote cluster disconnects from the querying cluster, {{ccs}} for {{esql}} will set it to `skipped` +and continue the query with other clusters, unless the remote cluster's `skip_unavailable` setting is set to `false`, +in which case the query will fail. +::: + +:::: + +## Query across clusters during an upgrade [ccq-during-upgrade] + +You can still search a remote cluster while performing a rolling upgrade on the local cluster. However, the local coordinating node’s "upgrade from" and "upgrade to" version must be compatible with the remote cluster’s gateway node. + +::::{warning} +Running multiple versions of {{es}} in the same cluster beyond the duration of an upgrade is not supported. +:::: + + +For more information about upgrades, see [Upgrading {{es}}](docs-content://deploy-manage/upgrade/deployment-or-cluster.md). diff --git a/docs/reference/query-languages/esql/esql-examples.md b/docs/reference/query-languages/esql/esql-examples.md index 6f5fccde5d15b..ebcac3c1d5c5f 100644 --- a/docs/reference/query-languages/esql/esql-examples.md +++ b/docs/reference/query-languages/esql/esql-examples.md @@ -1,91 +1,11 @@ --- -navigation_title: "Examples" +navigation_title: "Tutorials" --- -# {{esql}} examples [esql-examples] +# {{esql}} tutorials [esql-examples] -## Aggregating and enriching windows event logs +Use these hands-on tutorials to explore practical use cases with {{esql}}: -```esql -FROM logs-* -| WHERE event.code IS NOT NULL -| STATS event_code_count = COUNT(event.code) BY event.code,host.name -| ENRICH win_events ON event.code WITH event_description -| WHERE event_description IS NOT NULL and host.name IS NOT NULL -| RENAME event_description AS event.description -| SORT event_code_count DESC -| KEEP event_code_count,event.code,host.name,event.description -``` - -* It starts by querying logs from indices that match the pattern "logs-*". -* Filters events where the "event.code" field is not null. -* Aggregates the count of events by "event.code" and "host.name." -* Enriches the events with additional information using the "EVENT_DESCRIPTION" field. -* Filters out events where "EVENT_DESCRIPTION" or "host.name" is null. -* Renames "EVENT_DESCRIPTION" as "event.description." -* Sorts the result by "event_code_count" in descending order. -* Keeps only selected fields: "event_code_count," "event.code," "host.name," and "event.description." - - -## Summing outbound traffic from a process `curl.exe` - -```esql -FROM logs-endpoint -| WHERE process.name == "curl.exe" -| STATS bytes = SUM(destination.bytes) BY destination.address -| EVAL kb = bytes/1024 -| SORT kb DESC -| LIMIT 10 -| KEEP kb,destination.address -``` - -* Queries logs from the "logs-endpoint" source. -* Filters events where the "process.name" field is "curl.exe." -* Calculates the sum of bytes sent to destination addresses and converts it to kilobytes (KB). -* Sorts the results by "kb" (kilobytes) in descending order. -* Limits the output to the top 10 results. -* Keeps only the "kb" and "destination.address" fields. - - - -## Manipulating DNS logs to find a high number of unique dns queries per registered domain - -```esql -FROM logs-* -| GROK dns.question.name "%{DATA}\\.%{GREEDYDATA:dns.question.registered_domain:string}" -| STATS unique_queries = COUNT_DISTINCT(dns.question.name) BY dns.question.registered_domain, process.name -| WHERE unique_queries > 10 -| SORT unique_queries DESC -| RENAME unique_queries AS `Unique Queries`, dns.question.registered_domain AS `Registered Domain`, process.name AS `Process` -``` - -* Queries logs from indices matching "logs-*." -* Uses the "grok" pattern to extract the registered domain from the "dns.question.name" field. -* Calculates the count of unique DNS queries per registered domain and process name. -* Filters results where "unique_queries" are greater than 10. -* Sorts the results by "unique_queries" in descending order. -* Renames fields for clarity: "unique_queries" to "Unique Queries," "dns.question.registered_domain" to "Registered Domain," and "process.name" to "Process." - - - -## Identifying high-numbers of outbound user connections - -```esql -FROM logs-* -| WHERE NOT CIDR_MATCH(destination.ip, "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16") -| STATS destcount = COUNT(destination.ip) BY user.name, host.name -| ENRICH ldap_lookup_new ON user.name -| WHERE group.name IS NOT NULL -| EVAL follow_up = CASE(destcount >= 100, "true","false") -| SORT destcount DESC -| KEEP destcount, host.name, user.name, group.name, follow_up -``` - -* Queries logs from indices matching "logs-*." -* Filters out events where the destination IP address falls within private IP address ranges (e.g., 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16). -* Calculates the count of unique destination IPs by "user.name" and "host.name." -* Enriches the "user.name" field with LDAP group information. -* Filters out results where "group.name" is not null. -* Uses a "CASE" statement to create a "follow_up" field, setting it to "true" when "destcount" is greater than or equal to 100 and "false" otherwise. -* Sorts the results by "destcount" in descending order. -* Keeps selected fields: "destcount," "host.name," "user.name," "group.name," and "follow_up." +- [](esql-getting-started.md): Learn the basic syntax of the language. +- [Search and filter with {{esql}}](esql-search-tutorial.md): Learn how to use {{esql}} to search and filter data. +- [Threat hunting with {{esql}}](docs-content://solutions/security/esql-for-security/esql-threat-hunting-tutorial.md): Learn how to use {{esql}} for advanced threat hunting techniques and security analysis. \ No newline at end of file diff --git a/docs/reference/query-languages/esql/esql-getting-started.md b/docs/reference/query-languages/esql/esql-getting-started.md new file mode 100644 index 0000000000000..22bd898b51245 --- /dev/null +++ b/docs/reference/query-languages/esql/esql-getting-started.md @@ -0,0 +1,424 @@ +--- +applies_to: + stack: ga + serverless: ga +navigation_title: Get started +--- + +# Get started with {{esql}} queries [esql-getting-started] + +This hands-on guide covers the basics of using {{esql}} to query and aggregate your data. + +::::{tip} +This getting started is also available as an [interactive Python notebook](https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/esql/esql-getting-started.ipynb) in the `elasticsearch-labs` GitHub repository. +:::: + +## Prerequisites [esql-getting-started-prerequisites] + +To follow along with the queries in this guide, you can either set up your own deployment, or use Elastic’s public {{esql}} demo environment. + +:::::::{tab-set} + +::::::{tab-item} Own deployment +First ingest some sample data. In {{kib}}, open the main menu and select **Dev Tools**. Run the following two requests: + +```console +PUT sample_data +{ + "mappings": { + "properties": { + "client_ip": { + "type": "ip" + }, + "message": { + "type": "keyword" + } + } + } +} + +PUT sample_data/_bulk +{"index": {}} +{"@timestamp": "2023-10-23T12:15:03.360Z", "client_ip": "172.21.2.162", "message": "Connected to 10.1.0.3", "event_duration": 3450233} +{"index": {}} +{"@timestamp": "2023-10-23T12:27:28.948Z", "client_ip": "172.21.2.113", "message": "Connected to 10.1.0.2", "event_duration": 2764889} +{"index": {}} +{"@timestamp": "2023-10-23T13:33:34.937Z", "client_ip": "172.21.0.5", "message": "Disconnected", "event_duration": 1232382} +{"index": {}} +{"@timestamp": "2023-10-23T13:51:54.732Z", "client_ip": "172.21.3.15", "message": "Connection error", "event_duration": 725448} +{"index": {}} +{"@timestamp": "2023-10-23T13:52:55.015Z", "client_ip": "172.21.3.15", "message": "Connection error", "event_duration": 8268153} +{"index": {}} +{"@timestamp": "2023-10-23T13:53:55.832Z", "client_ip": "172.21.3.15", "message": "Connection error", "event_duration": 5033755} +{"index": {}} +{"@timestamp": "2023-10-23T13:55:01.543Z", "client_ip": "172.21.3.15", "message": "Connected to 10.1.0.1", "event_duration": 1756467} +``` +:::::: + +::::::{tab-item} Demo environment +The data set used in this guide has been preloaded into the Elastic {{esql}} public demo environment. Visit [ela.st/ql](https://ela.st/ql) to start using it. +:::::: + +::::::: + +## Run an {{esql}} query [esql-getting-started-running-queries] + +In {{kib}}, you can use Console or Discover to run {{esql}} queries: + +:::::::{tab-set} + +::::::{tab-item} Console +To get started with {{esql}} in Console, open the main menu and select **Dev Tools**. + +The general structure of an [{{esql}} query API](https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-esql) request is: + +```txt +POST /_query?format=txt +{ + "query": """ + + """ +} +``` + +Enter the actual {{esql}} query between the two sets of triple quotes. For example: + +```txt +POST /_query?format=txt +{ + "query": """ +FROM kibana_sample_data_logs + """ +} +``` + +:::::: + +::::::{tab-item} Discover +To get started with {{esql}} in Discover, open the main menu and select **Discover**. Next, select **Try ES|QL** from the application menu bar. + +Adjust the time filter so it includes the timestamps in the sample data (October 23rd, 2023). + +After switching to {{esql}} mode, the query bar shows a sample query. You can replace this query with the queries in this getting started guide. + +You can adjust the editor’s height by dragging its bottom border to your liking. +:::::: + +::::::: + +## Your first {{esql}} query [esql-getting-started-first-query] + +Each {{esql}} query starts with a [source command](commands/source-commands.md). A source command produces a table, typically with data from {{es}}. + +:::{image} ../images/elasticsearch-reference-source-command.svg +:alt: A source command producing a table from {{es}} +::: + +The [`FROM`](commands/from.md) source command returns a table with documents from a data stream, index, or alias. Each row in the resulting table represents a document. This query returns up to 1000 documents from the `sample_data` index: + +```esql +FROM sample_data +``` + +Each column corresponds to a field, and can be accessed by the name of that field. + +::::{tip} +{{esql}} keywords are case-insensitive. The following query is identical to the previous one: + +```esql +from sample_data +``` + +:::: + + + +## Processing commands [esql-getting-started-limit] + +A source command can be followed by one or more [processing commands](commands/processing-commands.md), separated by a pipe character: `|`. Processing commands change an input table by adding, removing, or changing rows and columns. Processing commands can perform filtering, projection, aggregation, and more. + +:::{image} ../images/elasticsearch-reference-esql-limit.png +:alt: A processing command changing an input table +:width: 500px +::: + +For example, you can use the [`LIMIT`](commands/limit.md) command to limit the number of rows that are returned, up to a maximum of 10,000 rows: + +```esql +FROM sample_data +| LIMIT 3 +``` + +::::{tip} +For readability, you can put each command on a separate line. However, you don’t have to. The following query is identical to the previous one: + +```esql +FROM sample_data | LIMIT 3 +``` + +:::: + + + +### Sort a table [esql-getting-started-sort] + +:::{image} ../images/elasticsearch-reference-esql-sort.png +:alt: A processing command sorting an input table +:width: 500px +::: + +Another processing command is the [`SORT`](commands/sort.md) command. By default, the rows returned by `FROM` don’t have a defined sort order. Use the `SORT` command to sort rows on one or more columns: + +```esql +FROM sample_data +| SORT @timestamp DESC +``` + + +### Query the data [esql-getting-started-where] + +Use the [`WHERE`](commands/where.md) command to query the data. For example, to find all events with a duration longer than 5ms: + +```esql +FROM sample_data +| WHERE event_duration > 5000000 +``` + +`WHERE` supports several [operators](functions-operators/operators.md). For example, you can use [`LIKE`](functions-operators/operators.md#esql-like) to run a wildcard query against the `message` column: + +```esql +FROM sample_data +| WHERE message LIKE "Connected*" +``` + + +### More processing commands [esql-getting-started-more-commands] + +There are many other processing commands, like [`KEEP`](commands/keep.md) and [`DROP`](commands/drop.md) to keep or drop columns, [`ENRICH`](commands/enrich.md) to enrich a table with data from indices in {{es}}, and [`DISSECT`](commands/dissect.md) and [`GROK`](commands/grok.md) to process data. Refer to [Processing commands](commands/processing-commands.md) for an overview of all processing commands. + + +## Chain processing commands [esql-getting-started-chaining] + +You can chain processing commands, separated by a pipe character: `|`. Each processing command works on the output table of the previous command. The result of a query is the table produced by the final processing command. + +:::{image} ../images/elasticsearch-reference-esql-sort-limit.png +:alt: Processing commands can be chained +::: + +The following example first sorts the table on `@timestamp`, and next limits the result set to 3 rows: + +```esql +FROM sample_data +| SORT @timestamp DESC +| LIMIT 3 +``` + +::::{note} +The order of processing commands is important. First limiting the result set to 3 rows before sorting those 3 rows would most likely return a result that is different than this example, where the sorting comes before the limit. +:::: + + + +## Compute values [esql-getting-started-eval] + +Use the [`EVAL`](commands/eval.md) command to append columns to a table, with calculated values. For example, the following query appends a `duration_ms` column. The values in the column are computed by dividing `event_duration` by 1,000,000. In other words: `event_duration` converted from nanoseconds to milliseconds. + +```esql +FROM sample_data +| EVAL duration_ms = event_duration/1000000.0 +``` + +`EVAL` supports several [functions](commands/eval.md). For example, to round a number to the closest number with the specified number of digits, use the [`ROUND`](functions-operators/math-functions.md#esql-round) function: + +```esql +FROM sample_data +| EVAL duration_ms = ROUND(event_duration/1000000.0, 1) +``` + + +## Calculate statistics [esql-getting-started-stats] + +{{esql}} can not only be used to query your data, you can also use it to aggregate your data. Use the [`STATS`](commands/stats-by.md) command to calculate statistics. For example, the median duration: + +```esql +FROM sample_data +| STATS median_duration = MEDIAN(event_duration) +``` + +You can calculate multiple stats with one command: + +```esql +FROM sample_data +| STATS median_duration = MEDIAN(event_duration), max_duration = MAX(event_duration) +``` + +Use `BY` to group calculated stats by one or more columns. For example, to calculate the median duration per client IP: + +```esql +FROM sample_data +| STATS median_duration = MEDIAN(event_duration) BY client_ip +``` + + +## Access columns [esql-getting-started-access-columns] + +You can access columns by their name. If a name contains special characters, [it needs to be quoted](esql-syntax.md#esql-identifiers) with backticks (```). + +Assigning an explicit name to a column created by `EVAL` or `STATS` is optional. If you don’t provide a name, the new column name is equal to the function expression. For example: + +```esql +FROM sample_data +| EVAL event_duration/1000000.0 +``` + +In this query, `EVAL` adds a new column named `event_duration/1000000.0`. Because its name contains special characters, to access this column, quote it with backticks: + +```esql +FROM sample_data +| EVAL event_duration/1000000.0 +| STATS MEDIAN(`event_duration/1000000.0`) +``` + + +## Create a histogram [esql-getting-started-histogram] + +To track statistics over time, {{esql}} enables you to create histograms using the [`BUCKET`](functions-operators/grouping-functions.md#esql-bucket) function. `BUCKET` creates human-friendly bucket sizes and returns a value for each row that corresponds to the resulting bucket the row falls into. + +Combine `BUCKET` with [`STATS`](commands/stats-by.md) to create a histogram. For example, to count the number of events per hour: + +```esql +FROM sample_data +| STATS c = COUNT(*) BY bucket = BUCKET(@timestamp, 24, "2023-10-23T00:00:00Z", "2023-10-23T23:59:59Z") +``` + +Or the median duration per hour: + +```esql +FROM sample_data +| KEEP @timestamp, event_duration +| STATS median_duration = MEDIAN(event_duration) BY bucket = BUCKET(@timestamp, 24, "2023-10-23T00:00:00Z", "2023-10-23T23:59:59Z") +``` + + +## Enrich data [esql-getting-started-enrich] + +{{esql}} enables you to [enrich](esql-enrich-data.md) a table with data from indices in {{es}}, using the [`ENRICH`](commands/enrich.md) command. + +:::{image} ../images/elasticsearch-reference-esql-enrich.png +:alt: esql enrich +::: + +Before you can use `ENRICH`, you first need to [create](esql-enrich-data.md#esql-create-enrich-policy) and [execute](esql-enrich-data.md#esql-execute-enrich-policy) an [enrich policy](esql-enrich-data.md#esql-enrich-policy). + +:::::::{tab-set} + +::::::{tab-item} Own deployment +The following requests create and execute a policy called `clientip_policy`. The policy links an IP address to an environment ("Development", "QA", or "Production"): + +```console +PUT clientips +{ + "mappings": { + "properties": { + "client_ip": { + "type": "keyword" + }, + "env": { + "type": "keyword" + } + } + } +} + +PUT clientips/_bulk +{ "index" : {}} +{ "client_ip": "172.21.0.5", "env": "Development" } +{ "index" : {}} +{ "client_ip": "172.21.2.113", "env": "QA" } +{ "index" : {}} +{ "client_ip": "172.21.2.162", "env": "QA" } +{ "index" : {}} +{ "client_ip": "172.21.3.15", "env": "Production" } +{ "index" : {}} +{ "client_ip": "172.21.3.16", "env": "Production" } + +PUT /_enrich/policy/clientip_policy +{ + "match": { + "indices": "clientips", + "match_field": "client_ip", + "enrich_fields": ["env"] + } +} + +PUT /_enrich/policy/clientip_policy/_execute?wait_for_completion=false +``` +:::::: + +::::::{tab-item} Demo environment +On the demo environment at [ela.st/ql](https://ela.st/ql/), an enrich policy called `clientip_policy` has already been created an executed. The policy links an IP address to an environment ("Development", "QA", or "Production"). +:::::: + +::::::: +After creating and executing a policy, you can use it with the `ENRICH` command: + +```esql +FROM sample_data +| KEEP @timestamp, client_ip, event_duration +| EVAL client_ip = TO_STRING(client_ip) +| ENRICH clientip_policy ON client_ip WITH env +``` + +You can use the new `env` column that’s added by the `ENRICH` command in subsequent commands. For example, to calculate the median duration per environment: + +```esql +FROM sample_data +| KEEP @timestamp, client_ip, event_duration +| EVAL client_ip = TO_STRING(client_ip) +| ENRICH clientip_policy ON client_ip WITH env +| STATS median_duration = MEDIAN(event_duration) BY env +``` + +For more about data enrichment with {{esql}}, refer to [Data enrichment](esql-enrich-data.md). + + +## Process data [esql-getting-started-process-data] + +Your data may contain unstructured strings that you want to [structure](esql-process-data-with-dissect-grok.md) to make it easier to analyze the data. For example, the sample data contains log messages like: + +```txt +"Connected to 10.1.0.3" +``` + +By extracting the IP address from these messages, you can determine which IP has accepted the most client connections. + +To structure unstructured strings at query time, you can use the {{esql}} [`DISSECT`](commands/dissect.md) and [`GROK`](commands/grok.md) commands. `DISSECT` works by breaking up a string using a delimiter-based pattern. `GROK` works similarly, but uses regular expressions. This makes `GROK` more powerful, but generally also slower. + +In this case, no regular expressions are needed, as the `message` is straightforward: "Connected to ", followed by the server IP. To match this string, you can use the following `DISSECT` command: + +```esql +FROM sample_data +| DISSECT message "Connected to %{server_ip}" +``` + +This adds a `server_ip` column to those rows that have a `message` that matches this pattern. For other rows, the value of `server_ip` is `null`. + +You can use the new `server_ip` column that’s added by the `DISSECT` command in subsequent commands. For example, to determine how many connections each server has accepted: + +```esql +FROM sample_data +| WHERE STARTS_WITH(message, "Connected to") +| DISSECT message "Connected to %{server_ip}" +| STATS COUNT(*) BY server_ip +``` + +For more about data processing with {{esql}}, refer to [Data processing with DISSECT and GROK](esql-process-data-with-dissect-grok.md). + + +## Learn more [esql-getting-learn-more] + +- Explore the zero-setup, live [{{esql}} demo environment](http://esql.demo.elastic.co/). +- +- Follow along with our hands-on tutorials: + - [Search and filter with {{esql}}](docs-content://solutions/search/esql-search-tutorial.md): A hands-on tutorial that shows you how to use {{esql}} to search and filter data. + - [Threat hunting with {{esql}}](docs-content://solutions/security/esql-for-security/esql-threat-hunting-tutorial.md): A hands-on tutorial that shows you how to use {{esql}} for advanced threat hunting techniques and security analysis. \ No newline at end of file diff --git a/docs/reference/query-languages/esql/esql-multi-index.md b/docs/reference/query-languages/esql/esql-multi-index.md new file mode 100644 index 0000000000000..b35996329ed05 --- /dev/null +++ b/docs/reference/query-languages/esql/esql-multi-index.md @@ -0,0 +1,159 @@ +--- +navigation_title: Query multiple indices +mapped_pages: + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-multi-index.html +applies_to: + stack: ga + serverless: ga +products: + - id: elasticsearch +--- + +# Use ES|QL to query multiple indices [esql-multi-index] + +With {{esql}}, you can execute a single query across multiple indices, data streams, or aliases. To do so, use wildcards and date arithmetic. The following example uses a comma-separated list and a wildcard: + +```esql +FROM employees-00001,other-employees-* +``` + +Use the format `:` to [query data streams and indices on remote clusters](esql-cross-clusters.md): + +```esql +FROM cluster_one:employees-00001,cluster_two:other-employees-* +``` + + +## Field type mismatches [esql-multi-index-invalid-mapping] + +When querying multiple indices, data streams, or aliases, you might find that the same field is mapped to multiple different types. For example, consider the two indices with the following field mappings: + +**index: events_ip** + +``` +{ + "mappings": { + "properties": { + "@timestamp": { "type": "date" }, + "client_ip": { "type": "ip" }, + "event_duration": { "type": "long" }, + "message": { "type": "keyword" } + } + } +} +``` + +**index: events_keyword** + +``` +{ + "mappings": { + "properties": { + "@timestamp": { "type": "date" }, + "client_ip": { "type": "keyword" }, + "event_duration": { "type": "long" }, + "message": { "type": "keyword" } + } + } +} +``` + +When you query each of these individually with a simple query like `FROM events_ip`, the results are provided with type-specific columns: + +```esql +FROM events_ip +| SORT @timestamp DESC +``` + +| @timestamp:date | client_ip:ip | event_duration:long | message:keyword | +| --- | --- | --- | --- | +| 2023-10-23T13:55:01.543Z | 172.21.3.15 | 1756467 | Connected to 10.1.0.1 | +| 2023-10-23T13:53:55.832Z | 172.21.3.15 | 5033755 | Connection error | +| 2023-10-23T13:52:55.015Z | 172.21.3.15 | 8268153 | Connection error | + +Note how the `client_ip` column is correctly identified as type `ip`, and all values are displayed. However, if instead the query sources two conflicting indices with `FROM events_*`, the type of the `client_ip` column cannot be determined and is reported as `unsupported` with all values returned as `null`. + +$$$query-unsupported$$$ + +```esql +FROM events_* +| SORT @timestamp DESC +``` + +| @timestamp:date | client_ip:unsupported | event_duration:long | message:keyword | +| --- | --- | --- | --- | +| 2023-10-23T13:55:01.543Z | null | 1756467 | Connected to 10.1.0.1 | +| 2023-10-23T13:53:55.832Z | null | 5033755 | Connection error | +| 2023-10-23T13:52:55.015Z | null | 8268153 | Connection error | +| 2023-10-23T13:51:54.732Z | null | 725448 | Connection error | +| 2023-10-23T13:33:34.937Z | null | 1232382 | Disconnected | +| 2023-10-23T12:27:28.948Z | null | 2764889 | Connected to 10.1.0.2 | +| 2023-10-23T12:15:03.360Z | null | 3450233 | Connected to 10.1.0.3 | + +In addition, if the query refers to this unsupported field directly, the query fails: + +```esql +FROM events_* +| SORT client_ip DESC +``` + +```bash +Cannot use field [client_ip] due to ambiguities being mapped as +[2] incompatible types: + [ip] in [events_ip], + [keyword] in [events_keyword] +``` + + +## Union types [esql-multi-index-union-types] + +::::{warning} +This functionality is in technical preview and may be changed or removed in a future release. Elastic will work to fix any issues, but features in technical preview are not subject to the support SLA of official GA features. +:::: + + +{{esql}} has a way to handle [field type mismatches](#esql-multi-index-invalid-mapping). When the same field is mapped to multiple types in multiple indices, the type of the field is understood to be a *union* of the various types in the index mappings. As seen in the preceding examples, this *union type* cannot be used in the results, and cannot be referred to by the query — except in `KEEP`, `DROP` or when it’s passed to a type conversion function that accepts all the types in the *union* and converts the field to a single type. {{esql}} offers a suite of [type conversion functions](functions-operators/type-conversion-functions.md) to achieve this. + +In the above examples, the query can use a command like `EVAL client_ip = TO_IP(client_ip)` to resolve the union of `ip` and `keyword` to just `ip`. You can also use the type-conversion syntax `EVAL client_ip = client_ip::IP`. Alternatively, the query could use [`TO_STRING`](functions-operators/type-conversion-functions.md#esql-to_string) to convert all supported types into `KEYWORD`. + +For example, the [query](#query-unsupported) that returned `client_ip:unsupported` with `null` values can be improved using the `TO_IP` function or the equivalent `field::ip` syntax. These changes also resolve the error message. As long as the only reference to the original field is to pass it to a conversion function that resolves the type ambiguity, no error results. + +```esql +FROM events_* +| EVAL client_ip = TO_IP(client_ip) +| KEEP @timestamp, client_ip, event_duration, message +| SORT @timestamp DESC +``` + +| @timestamp:date | client_ip:ip | event_duration:long | message:keyword | +| --- | --- | --- | --- | +| 2023-10-23T13:55:01.543Z | 172.21.3.15 | 1756467 | Connected to 10.1.0.1 | +| 2023-10-23T13:53:55.832Z | 172.21.3.15 | 5033755 | Connection error | +| 2023-10-23T13:52:55.015Z | 172.21.3.15 | 8268153 | Connection error | +| 2023-10-23T13:51:54.732Z | 172.21.3.15 | 725448 | Connection error | +| 2023-10-23T13:33:34.937Z | 172.21.0.5 | 1232382 | Disconnected | +| 2023-10-23T12:27:28.948Z | 172.21.2.113 | 2764889 | Connected to 10.1.0.2 | +| 2023-10-23T12:15:03.360Z | 172.21.2.162 | 3450233 | Connected to 10.1.0.3 | + + +## Index metadata [esql-multi-index-index-metadata] + +It can be helpful to know the particular index from which each row is sourced. To get this information, use the [`METADATA`](esql-metadata-fields.md) option on the [`FROM`](commands/from.md) command. + +```esql +FROM events_* METADATA _index +| EVAL client_ip = TO_IP(client_ip) +| KEEP _index, @timestamp, client_ip, event_duration, message +| SORT @timestamp DESC +``` + +| _index:keyword | @timestamp:date | client_ip:ip | event_duration:long | message:keyword | +| --- | --- | --- | --- | --- | +| events_ip | 2023-10-23T13:55:01.543Z | 172.21.3.15 | 1756467 | Connected to 10.1.0.1 | +| events_ip | 2023-10-23T13:53:55.832Z | 172.21.3.15 | 5033755 | Connection error | +| events_ip | 2023-10-23T13:52:55.015Z | 172.21.3.15 | 8268153 | Connection error | +| events_keyword | 2023-10-23T13:51:54.732Z | 172.21.3.15 | 725448 | Connection error | +| events_keyword | 2023-10-23T13:33:34.937Z | 172.21.0.5 | 1232382 | Disconnected | +| events_keyword | 2023-10-23T12:27:28.948Z | 172.21.2.113 | 2764889 | Connected to 10.1.0.2 | +| events_keyword | 2023-10-23T12:15:03.360Z | 172.21.2.162 | 3450233 | Connected to 10.1.0.3 | + diff --git a/docs/reference/query-languages/esql/esql-multi.md b/docs/reference/query-languages/esql/esql-multi.md new file mode 100644 index 0000000000000..c419703ed72d8 --- /dev/null +++ b/docs/reference/query-languages/esql/esql-multi.md @@ -0,0 +1,13 @@ +--- +applies_to: + stack: ga + serverless: ga +navigation_title: Query multiple sources +--- + +# Query multiple indices or clusters with {{esql}} + +{{esql}} allows you to query across multiple indices or clusters. Learn more in the following sections: + +* [Query multiple indices](esql-multi-index.md) +* [Query across clusters](esql-cross-clusters.md) \ No newline at end of file diff --git a/docs/reference/query-languages/esql/esql-rest.md b/docs/reference/query-languages/esql/esql-rest.md new file mode 100644 index 0000000000000..85cffa101986c --- /dev/null +++ b/docs/reference/query-languages/esql/esql-rest.md @@ -0,0 +1,353 @@ +--- +navigation_title: "REST API" +mapped_pages: + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-rest.html +applies_to: + stack: ga + serverless: ga +products: + - id: elasticsearch +--- + +# Use the {{esql}} REST API [esql-rest] + +::::{tip} +The [Search and filter with {{esql}}](docs-content://solutions/search/esql-search-tutorial.md) tutorial provides a hands-on introduction to the {{esql}} `_query` API. +:::: + +## Overview [esql-rest-overview] + +The [`_query` API](https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-esql) accepts an {{esql}} query string in the `query` parameter, runs it, and returns the results. For example: + +```console +POST /_query?format=txt +{ + "query": "FROM library | KEEP author, name, page_count, release_date | SORT page_count DESC | LIMIT 5" +} +``` + +Which returns: + +```text + author | name | page_count | release_date +-----------------+--------------------+---------------+------------------------ +Peter F. Hamilton|Pandora's Star |768 |2004-03-02T00:00:00.000Z +Vernor Vinge |A Fire Upon the Deep|613 |1992-06-01T00:00:00.000Z +Frank Herbert |Dune |604 |1965-06-01T00:00:00.000Z +Alastair Reynolds|Revelation Space |585 |2000-03-15T00:00:00.000Z +James S.A. Corey |Leviathan Wakes |561 |2011-06-02T00:00:00.000Z +``` + + +### Run the {{esql}} query API in Console [esql-kibana-console] + +We recommend using [Console](docs-content://explore-analyze/query-filter/tools/console.md) to run the {{esql}} query API, because of its rich autocomplete features. + +When creating the query, using triple quotes (`"""`) allows you to use special characters like quotes (`"`) without having to escape them. They also make it easier to write multi-line requests. + +```console +POST /_query?format=txt +{ + "query": """ + FROM library + | KEEP author, name, page_count, release_date + | SORT page_count DESC + | LIMIT 5 + """ +} +``` + +### Response formats [esql-rest-format] + +{{esql}} can return the data in the following human readable and binary formats. You can set the format by specifying the `format` parameter in the URL or by setting the `Accept` or `Content-Type` HTTP header. + +For example: + +```console +POST /_query?format=yaml +``` + +::::{note} +The URL parameter takes precedence over the HTTP headers. If neither is specified then the response is returned in the same format as the request. +:::: + +#### Structured formats + +Complete responses with metadata. Useful for automatic parsing. + +| `format` | HTTP header | Description | +| --- | --- | --- | +| `json` | `application/json` | [JSON](https://www.json.org/) (JavaScript Object Notation) human-readable format | +| `yaml` | `application/yaml` | [YAML](https://en.wikipedia.org/wiki/YAML) (YAML Ain’t Markup Language) human-readable format | + +#### Tabular formats + +Query results only, without metadata. Useful for quick and manual data previews. + +| `format` | HTTP header | Description | +| --- | --- | --- | +| `csv` | `text/csv` | [Comma-separated values](https://en.wikipedia.org/wiki/Comma-separated_values) | +| `tsv` | `text/tab-separated-values` | [Tab-separated values](https://en.wikipedia.org/wiki/Tab-separated_values) | +| `txt` | `text/plain` | CLI-like representation | + +::::{tip} +The `csv` format accepts a formatting URL query attribute, `delimiter`, which indicates which character should be used to separate the CSV values. It defaults to comma (`,`) and cannot take any of the following values: double quote (`"`), carriage-return (`\r`) and new-line (`\n`). The tab (`\t`) can also not be used. Use the `tsv` format instead. +:::: + +#### Binary formats + +Compact binary encoding. To be used by applications. + +| `format` | HTTP header | Description | +| --- | --- | --- | +| `cbor` | `application/cbor` | [Concise Binary Object Representation](https://cbor.io/) | +| `smile` | `application/smile` | [Smile](https://en.wikipedia.org/wiki/Smile_(data_interchange_format)) binary data format similarto CBOR | +| `arrow` | `application/vnd.apache.arrow.stream` | **Experimental.** [Apache Arrow](https://arrow.apache.org/) dataframes, [IPC streaming format](https://arrow.apache.org/docs/format/Columnar.html#ipc-streaming-format) | + + +### Filtering using {{es}} Query DSL [esql-rest-filtering] + +Specify a Query DSL query in the `filter` parameter to filter the set of documents that an {{esql}} query runs on. + +```console +POST /_query?format=txt +{ + "query": """ + FROM library + | KEEP author, name, page_count, release_date + | SORT page_count DESC + | LIMIT 5 + """, + "filter": { + "range": { + "page_count": { + "gte": 100, + "lte": 200 + } + } + } +} +``` + +Which returns: + +```text + author | name | page_count | release_date +---------------+------------------------------------+---------------+------------------------ +Douglas Adams |The Hitchhiker's Guide to the Galaxy|180 |1979-10-12T00:00:00.000Z +``` + + +### Columnar results [esql-rest-columnar] + +By default, {{esql}} returns results as rows. For example, `FROM` returns each individual document as one row. For the `json`, `yaml`, `cbor` and `smile` [formats](#esql-rest-format), {{esql}} can return the results in a columnar fashion where one row represents all the values of a certain column in the results. + +```console +POST /_query?format=json +{ + "query": """ + FROM library + | KEEP author, name, page_count, release_date + | SORT page_count DESC + | LIMIT 5 + """, + "columnar": true +} +``` + +Which returns: + +```console-result +{ + "took": 28, + "is_partial": false, + "columns": [ + {"name": "author", "type": "text"}, + {"name": "name", "type": "text"}, + {"name": "page_count", "type": "integer"}, + {"name": "release_date", "type": "date"} + ], + "values": [ + ["Peter F. Hamilton", "Vernor Vinge", "Frank Herbert", "Alastair Reynolds", "James S.A. Corey"], + ["Pandora's Star", "A Fire Upon the Deep", "Dune", "Revelation Space", "Leviathan Wakes"], + [768, 613, 604, 585, 561], + ["2004-03-02T00:00:00.000Z", "1992-06-01T00:00:00.000Z", "1965-06-01T00:00:00.000Z", "2000-03-15T00:00:00.000Z", "2011-06-02T00:00:00.000Z"] + ] +} +``` + + +### Returning localized results [esql-locale-param] + +Use the `locale` parameter in the request body to return results (especially dates) formatted per the conventions of the locale. If `locale` is not specified, defaults to `en-US` (English). Refer to [JDK Supported Locales](https://www.oracle.com/java/technologies/javase/jdk17-suported-locales.html). + +Syntax: the `locale` parameter accepts language tags in the (case-insensitive) format `xy` and `xy-XY`. + +For example, to return a month name in French: + +```console +POST /_query +{ + "locale": "fr-FR", + "query": """ + ROW birth_date_string = "2023-01-15T00:00:00.000Z" + | EVAL birth_date = date_parse(birth_date_string) + | EVAL month_of_birth = DATE_FORMAT("MMMM",birth_date) + | LIMIT 5 + """ +} +``` + + +### Passing parameters to a query [esql-rest-params] + +Values, for example for a condition, can be passed to a query "inline", by integrating the value in the query string itself: + +```console +POST /_query +{ + "query": """ + FROM library + | EVAL year = DATE_EXTRACT("year", release_date) + | WHERE page_count > 300 AND author == "Frank Herbert" + | STATS count = COUNT(*) by year + | WHERE count > 0 + | LIMIT 5 + """ +} +``` + +To avoid any attempts of hacking or code injection, extract the values in a separate list of parameters. Use question mark placeholders (`?`) in the query string for each of the parameters: + +```console +POST /_query +{ + "query": """ + FROM library + | EVAL year = DATE_EXTRACT("year", release_date) + | WHERE page_count > ? AND author == ? + | STATS count = COUNT(*) by year + | WHERE count > ? + | LIMIT 5 + """, + "params": [300, "Frank Herbert", 0] +} +``` + +The parameters can be named parameters or positional parameters. + +Named parameters use question mark placeholders (`?`) followed by a string. + +```console +POST /_query +{ + "query": """ + FROM library + | EVAL year = DATE_EXTRACT("year", release_date) + | WHERE page_count > ?page_count AND author == ?author + | STATS count = COUNT(*) by year + | WHERE count > ?count + | LIMIT 5 + """, + "params": [{"page_count" : 300}, {"author" : "Frank Herbert"}, {"count" : 0}] +} +``` + +Positional parameters use question mark placeholders (`?`) followed by an integer. + +```console +POST /_query +{ + "query": """ + FROM library + | EVAL year = DATE_EXTRACT("year", release_date) + | WHERE page_count > ?1 AND author == ?2 + | STATS count = COUNT(*) by year + | WHERE count > ?3 + | LIMIT 5 + """, + "params": [300, "Frank Herbert", 0] +} +``` + + +### Running an async {{esql}} query [esql-rest-async-query] + +The [{{esql}} async query API](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query) lets you asynchronously execute a query request, monitor its progress, and retrieve results when they become available. + +Executing an {{esql}} query is commonly quite fast, however queries across large data sets or frozen data can take some time. To avoid long waits, run an async {{esql}} query. + +Queries initiated by the async query API may return results or not. The `wait_for_completion_timeout` property determines how long to wait for the results. If the results are not available by this time, a [query id](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query#esql-async-query-api-response-body-query-id) is returned which can be later used to retrieve the results. For example: + +```console +POST /_query/async +{ + "query": """ + FROM library + | EVAL year = DATE_TRUNC(1 YEARS, release_date) + | STATS MAX(page_count) BY year + | SORT year + | LIMIT 5 + """, + "wait_for_completion_timeout": "2s" +} +``` + +If the results are not available within the given timeout period, 2 seconds in this case, no results are returned but rather a response that includes: + +* A query ID +* An `is_running` value of *true*, indicating the query is ongoing + +The query continues to run in the background without blocking other requests. + +```console-result +{ + "id": "FmNJRUZ1YWZCU3dHY1BIOUhaenVSRkEaaXFlZ3h4c1RTWFNocDdnY2FSaERnUTozNDE=", + "is_running": true +} +``` + +To check the progress of an async query, use the [{{esql}} async query get API](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query-get) with the query ID. Specify how long you’d like to wait for complete results in the `wait_for_completion_timeout` parameter. + +```console +GET /_query/async/FmNJRUZ1YWZCU3dHY1BIOUhaenVSRkEaaXFlZ3h4c1RTWFNocDdnY2FSaERnUTozNDE=?wait_for_completion_timeout=30s +``` + +If the response’s `is_running` value is `false`, the query has finished and the results are returned, along with the `took` time for the query. + +```console-result +{ + "is_running": false, + "took": 48, + "columns": ... +} +``` + +To stop a running async query and return the results computed so far, use the [async stop API](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query-stop) with the query ID. + +```console +POST /_query/async/FmNJRUZ1YWZCU3dHY1BIOUhaenVSRkEaaXFlZ3h4c1RTWFNocDdnY2FSaERnUTozNDE=/stop +``` +The query will be stopped and the response will contain the results computed so far. The response format is the same as the `get` API. + +```console-result +{ + "is_running": false, + "took": 48, + "is_partial": true, + "columns": ... +} +``` +This API can be used to retrieve results even if the query has already completed, as long as it's within the `keep_alive` window. +The `is_partial` field indicates result completeness. A value of `true` means the results are potentially incomplete. + +Use the [{{esql}} async query delete API](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query-delete) to delete an async query before the `keep_alive` period ends. If the query is still running, {{es}} cancels it. + +```console +DELETE /_query/async/FmdMX2pIang3UWhLRU5QS0lqdlppYncaMUpYQ05oSkpTc3kwZ21EdC1tbFJXQToxOTI= +``` + +::::{note} +You will also receive the async ID and running status in the `X-Elasticsearch-Async-Id` and `X-Elasticsearch-Async-Is-Running` HTTP headers of the response, respectively. +Useful if you use a tabular text format like `txt`, `csv` or `tsv`, as you won't receive those fields in the body there. +:::: diff --git a/docs/reference/query-languages/esql/esql-search-tutorial.md b/docs/reference/query-languages/esql/esql-search-tutorial.md new file mode 100644 index 0000000000000..1386e09d4ca81 --- /dev/null +++ b/docs/reference/query-languages/esql/esql-search-tutorial.md @@ -0,0 +1,475 @@ +--- +applies_to: + stack: preview 9.0, ga 9.1 + serverless: ga +navigation_title: Search and filter with ES|QL +--- + +# Search and filter with {{esql}} + +This is a hands-on introduction to the basics of full-text search and semantic search, using {{esql}}. + +In this scenario, we're implementing search for a cooking blog. The blog contains recipes with various attributes including textual content, categorical data, and numerical ratings. + +## Requirements + +You need a running {{es}} cluster, together with {{kib}} to use the Dev Tools API Console. Refer to [choose your deployment type](docs-content://deploy-manage/deploy.md#choosing-your-deployment-type) for deployment options. + +Want to get started quickly? Run the following command in your terminal to set up a [single-node local cluster in Docker](docs-content://solutions/search/run-elasticsearch-locally.md): + +```sh +curl -fsSL https://elastic.co/start-local | sh +``` + +## Running {{esql}} queries + +In this tutorial, {{esql}} examples are displayed in the following format: + +```esql +FROM cooking_blog +| WHERE description:"fluffy pancakes" +| LIMIT 1000 +``` + +If you want to run these queries in the [Dev Tools Console](docs-content://explore-analyze/query-filter/languages/esql-rest.md#esql-kibana-console), you need to use the following syntax: + +```console +POST /_query?format=txt +{ + "query": """ + FROM cooking_blog + | WHERE description:"fluffy pancakes" + | LIMIT 1000 + """ +} +``` + +If you'd prefer to use your favorite programming language, refer to [Client libraries](docs-content://solutions/search/site-or-app/clients.md) for a list of official and community-supported clients. + +## Step 1: Create an index + +Create the `cooking_blog` index to get started: + +```console +PUT /cooking_blog +``` + +Now define the mappings for the index: + +```console +PUT /cooking_blog/_mapping +{ + "properties": { + "title": { + "type": "text", + "analyzer": "standard", <1> + "fields": { <2> + "keyword": { + "type": "keyword", + "ignore_above": 256 <3> + } + } + }, + "description": { + "type": "text", + "fields": { + "keyword": { + "type": "keyword" + } + } + }, + "author": { + "type": "text", + "fields": { + "keyword": { + "type": "keyword" + } + } + }, + "date": { + "type": "date", + "format": "yyyy-MM-dd" + }, + "category": { + "type": "text", + "fields": { + "keyword": { + "type": "keyword" + } + } + }, + "tags": { + "type": "text", + "fields": { + "keyword": { + "type": "keyword" + } + } + }, + "rating": { + "type": "float" + } + } +} +``` + +1. `analyzer`: Used for text analysis. If you don't specify it, the `standard` analyzer is used by default for `text` fields. It’s included here for demonstration purposes. To know more about analyzers, refer to [Anatomy of an analyzer](docs-content://manage-data/data-store/text-analysis/anatomy-of-an-analyzer.md). +2. `ignore_above`: Prevents indexing values longer than 256 characters in the `keyword` field. This is the default value and it’s included here for demonstration purposes. It helps to save disk space and avoid potential issues with Lucene’s term byte-length limit. For more information, refer [ignore_above parameter](/reference/elasticsearch/mapping-reference/ignore-above.md). +3. `description`: A field declared with both `text` and `keyword` [data types](/reference/elasticsearch/mapping-reference/field-data-types.md). Such fields are called [Multi-fields](/reference/elasticsearch/mapping-reference/multi-fields.md). This enables both full-text search and exact matching/filtering on the same field. If you use [dynamic mapping](docs-content://manage-data/data-store/mapping/dynamic-field-mapping.md), these multi-fields will be created automatically. Other fields in the mapping like `author`, `category`, `tags` are also declared as multi-fields. + +::::{tip} +Full-text search is powered by [text analysis](docs-content://solutions/search/full-text/text-analysis-during-search.md). Text analysis normalizes and standardizes text data so it can be efficiently stored in an inverted index and searched in near real-time. Analysis happens at both [index and search time](docs-content://manage-data/data-store/text-analysis/index-search-analysis.md). This tutorial won't cover analysis in detail, but it's important to understand how text is processed to create effective search queries. +:::: + +## Step 2: Add sample blog posts to your index [full-text-filter-tutorial-index-data] + +Next, you’ll need to index some example blog posts using the [Bulk API](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-put-settings). Note that `text` fields are analyzed and multi-fields are generated at index time. + +```console +POST /cooking_blog/_bulk?refresh=wait_for +{"index":{"_id":"1"}} +{"title":"Perfect Pancakes: A Fluffy Breakfast Delight","description":"Learn the secrets to making the fluffiest pancakes, so amazing you won't believe your tastebuds. This recipe uses buttermilk and a special folding technique to create light, airy pancakes that are perfect for lazy Sunday mornings.","author":"Maria Rodriguez","date":"2023-05-01","category":"Breakfast","tags":["pancakes","breakfast","easy recipes"],"rating":4.8} +{"index":{"_id":"2"}} +{"title":"Spicy Thai Green Curry: A Vegetarian Adventure","description":"Dive into the flavors of Thailand with this vibrant green curry. Packed with vegetables and aromatic herbs, this dish is both healthy and satisfying. Don't worry about the heat - you can easily adjust the spice level to your liking.","author":"Liam Chen","date":"2023-05-05","category":"Main Course","tags":["thai","vegetarian","curry","spicy"],"rating":4.6} +{"index":{"_id":"3"}} +{"title":"Classic Beef Stroganoff: A Creamy Comfort Food","description":"Indulge in this rich and creamy beef stroganoff. Tender strips of beef in a savory mushroom sauce, served over a bed of egg noodles. It's the ultimate comfort food for chilly evenings.","author":"Emma Watson","date":"2023-05-10","category":"Main Course","tags":["beef","pasta","comfort food"],"rating":4.7} +{"index":{"_id":"4"}} +{"title":"Vegan Chocolate Avocado Mousse","description":"Discover the magic of avocado in this rich, vegan chocolate mousse. Creamy, indulgent, and secretly healthy, it's the perfect guilt-free dessert for chocolate lovers.","author":"Alex Green","date":"2023-05-15","category":"Dessert","tags":["vegan","chocolate","avocado","healthy dessert"],"rating":4.5} +{"index":{"_id":"5"}} +{"title":"Crispy Oven-Fried Chicken","description":"Get that perfect crunch without the deep fryer! This oven-fried chicken recipe delivers crispy, juicy results every time. A healthier take on the classic comfort food.","author":"Maria Rodriguez","date":"2023-05-20","category":"Main Course","tags":["chicken","oven-fried","healthy"],"rating":4.9} +``` + +## Step 3: Basic search operations + +Full-text search involves executing text-based queries across one or more document fields. In this section, you'll start with simple text matching and build up to understanding how search results are ranked. + +{{esql}} provides multiple functions for full-text search, including `MATCH`, `MATCH_PHRASE`, and `QSTR`. For basic text matching, you can use either: + +1. Full [match function](/reference/query-languages/esql/functions-operators/search-functions.md#esql-match) syntax: `match(field, "search terms")` +2. Compact syntax using the [match operator `:`](/reference/query-languages/esql/functions-operators/operators.md#esql-match-operator): `field:"search terms"` + +Both are equivalent for basic matching and can be used interchangeably. The compact syntax is more concise, while the function syntax allows for more configuration options. We use the compact syntax in most examples for brevity. + +Refer to the [`MATCH` function](/reference/query-languages/esql/functions-operators/search-functions.md#esql-match) reference docs for advanced parameters available with the function syntax. + +### Perform your first search query + +Let's start with the simplest possible search - looking for documents that contain specific words: + +```esql +FROM cooking_blog +| WHERE description:"fluffy pancakes" +| LIMIT 1000 +``` + +This query searches the `description` field for documents containing either "fluffy" OR "pancakes" (or both). By default, {{esql}} uses OR logic between search terms, so it matches documents that contain any of the specified words. + +### Control which fields appear in results + +You can specify the exact fields to include in your results using the `KEEP` command: + +```esql +FROM cooking_blog +| WHERE description:"fluffy pancakes" +| KEEP title, description, rating +| LIMIT 1000 +``` + +This helps reduce the amount of data returned and focuses on the information you need. + +### Understand relevance scoring + +Search results can be ranked based on how well they match your query. To calculate and use relevance scores, you need to explicitly request the `_score` metadata: + +```esql +FROM cooking_blog METADATA _score +| WHERE description:"fluffy pancakes" +| KEEP title, description, _score +| SORT _score DESC +| LIMIT 1000 +``` + +Notice two important things: +1. `METADATA _score` tells {{esql}} to include relevance scores in the results +2. `SORT _score DESC` orders results by relevance (highest scores first) + +If you don't include `METADATA _score` in your query, you won't see relevance scores in your results. This means you won't be able to sort by relevance or filter based on relevance scores. + +Without explicit sorting, results aren't ordered by relevance even when scores are calculated. If you want the most relevant results first, you must sort by `_score`, by explicitly using `SORT _score DESC` or `SORT _score ASC`. + +:::{tip} +When you include `METADATA _score`, search functions included in `WHERE` conditions contribute to the relevance score. Filtering operations (like range conditions and exact matches) don't affect the score. +::: + +### Find exact matches + +Sometimes you need exact matches rather than full-text search. Use the `.keyword` field for case-sensitive exact matching: + +```esql +FROM cooking_blog +| WHERE category.keyword == "Breakfast" # Exact match (case-sensitive) +| KEEP title, category, rating +| SORT rating DESC +| LIMIT 1000 +``` + +This is fundamentally different from full-text search - it's a binary yes/no filter that doesn't affect relevance scoring. + +## Step 4: Search precision control + +Now that you understand basic searching, explore how to control the precision of your text matches. + +### Require all search terms (AND logic) + +By default, searches with match use OR logic between terms. To require ALL terms to match, use the function syntax with the `operator` parameter to specify AND logic: + +```esql +FROM cooking_blog +| WHERE match(description, "fluffy pancakes", {"operator": "AND"}) +| LIMIT 1000 +``` + +This stricter search returns *zero hits* on our sample data, as no document contains both "fluffy" and "pancakes" in the description. + +:::{note} +The `MATCH` function with AND logic doesn't require terms to be adjacent or in order. It only requires that all terms appear somewhere in the field. Use `MATCH_PHRASE` to [search for exact phrases](#search-for-exact-phrases). +::: + +### Set a minimum number of terms to match + +Sometimes requiring all terms is too strict, but the default OR behavior is too lenient. You can specify a minimum number of terms that must match: + +```esql +FROM cooking_blog +| WHERE match(title, "fluffy pancakes breakfast", {"minimum_should_match": 2}) +| LIMIT 1000 +``` + +This query searches the title field to match at least 2 of the 3 terms: "fluffy", "pancakes", or "breakfast". + +### Search for exact phrases + +When you need to find documents containing an exact sequence of words, use the `MATCH_PHRASE` function: + +```esql +FROM cooking_blog +| WHERE MATCH_PHRASE(description, "rich and creamy") +| KEEP title, description +| LIMIT 1000 +``` + +This query only matches documents where the words "rich and creamy" appear exactly in that order in the description field. + +## Step 5: Semantic search and hybrid search + +### Index semantic content + +{{es}} allows you to semantically search for documents based on the meaning of the text, rather than just the presence of specific keywords. This is useful when you want to find documents that are conceptually similar to a given query, even if they don't contain the exact search terms. + +ES|QL supports semantic search when your mappings include fields of the [`semantic_text`](/reference/elasticsearch/mapping-reference/semantic-text.md) type. This example mapping update adds a new field called `semantic_description` with the type `semantic_text`: + +```console +PUT /cooking_blog/_mapping +{ + "properties": { + "semantic_description": { + "type": "semantic_text" + } + } +} +``` + +Next, index a document with content into the new field: + +```console +POST /cooking_blog/_doc +{ + "title": "Mediterranean Quinoa Bowl", + "semantic_description": "A protein-rich bowl with quinoa, chickpeas, fresh vegetables, and herbs. This nutritious Mediterranean-inspired dish is easy to prepare and perfect for a quick, healthy dinner.", + "author": "Jamie Oliver", + "date": "2023-06-01", + "category": "Main Course", + "tags": ["vegetarian", "healthy", "mediterranean", "quinoa"], + "rating": 4.7 +} +``` + +### Perform semantic search + +Once the document has been processed by the underlying model running on the inference endpoint, you can perform semantic searches. Here's an example natural language query against the `semantic_description` field: + +```esql +FROM cooking_blog +| WHERE semantic_description:"What are some easy to prepare but nutritious plant-based meals?" +| LIMIT 5 +``` + +:::{tip} +If you'd like to test out the semantic search workflow against a large dataset, follow the [semantic-search-tutorial](docs-content://solutions/search/semantic-search/semantic-search-semantic-text.md). +::: + +### Perform hybrid search + +You can combine full-text and semantic queries. In this example we combine full-text and semantic search with custom weights: + +```esql +FROM cooking_blog METADATA _score +| WHERE match(semantic_description, "easy to prepare vegetarian meals", { "boost": 0.75 }) + OR match(tags, "vegetarian", { "boost": 0.25 }) +| SORT _score DESC +| LIMIT 5 +``` + +This query searches the `semantic_description` field for documents that are semantically similar to "easy to prepare vegetarian meals" with a higher weight, while also matching the `tags` field for "vegetarian" with a lower weight. The results are sorted by relevance score. + +Learn how to combine these with complex criteria in [Step 8](#step-8-complex-search-solutions). + +## Step 6: Advanced search features + +Once you're comfortable with basic search precision, use the following advanced features for powerful search capabilities. + +### Use query string for complex patterns + +The `QSTR` function enables powerful search patterns using a compact query language. It's ideal for when you need wildcards, fuzzy matching, and boolean logic in a single expression: + +```esql +FROM cooking_blog +| WHERE QSTR(description, "fluffy AND pancak* OR (creamy -vegan)") +| KEEP title, description +| LIMIT 1000 +``` + +Query string syntax lets you: +- Use boolean operators: `AND`, `OR`, `-` (NOT) +- Apply wildcards: `pancak*` matches "pancake" and "pancakes" +- Enable fuzzy matching: `pancake~1` for typo tolerance +- Group terms: `(thai AND curry) OR pasta` +- Search exact phrases: `"fluffy pancakes"` +- Search across fields: `QSTR("title,description", "pancake OR (creamy AND rich)")` + +### Search across multiple fields + +When users enter a search query, they often don't know (or care) whether their search terms appear in a specific field. You can search across multiple fields simultaneously: + +```esql +FROM cooking_blog +| WHERE title:"vegetarian curry" OR description:"vegetarian curry" OR tags:"vegetarian curry" +| LIMIT 1000 +``` + +This query searches for "vegetarian curry" across the title, description, and tags fields. Each field is treated with equal importance. + +### Weight different fields + +In many cases, matches in certain fields (like the title) might be more relevant than others. You can adjust the importance of each field using boost scoring: + +```esql +FROM cooking_blog METADATA _score +| WHERE match(title, "vegetarian curry", {"boost": 2.0}) # Title matches are twice as important + OR match(description, "vegetarian curry") + OR match(tags, "vegetarian curry") +| KEEP title, description, tags, _score +| SORT _score DESC +| LIMIT 1000 +``` + +## Step 7: Filtering and exact matching + +Filtering allows you to narrow down your search results based on exact criteria. Unlike full-text searches, filters are binary (yes/no) and do not affect the relevance score. Filters execute faster than queries because excluded results don't need to be scored. + +### Basic filtering by category + +```esql +FROM cooking_blog +| WHERE category.keyword == "Breakfast" # Exact match using keyword field +| KEEP title, author, rating, tags +| SORT rating DESC +| LIMIT 1000 +``` + +### Date range filtering + +Often users want to find content published within a specific time frame: + +```esql +FROM cooking_blog +| WHERE date >= "2023-05-01" AND date <= "2023-05-31" # Inclusive date range filter +| KEEP title, author, date, rating +| LIMIT 1000 +``` + +### Numerical range filtering + +Filter by ratings or other numerical values: + +```esql +FROM cooking_blog +| WHERE rating >= 4.5 # Only highly-rated recipes +| KEEP title, author, rating, tags +| SORT rating DESC +| LIMIT 1000 +``` + +### Exact author matching + +Find recipes by a specific author: + +```esql +FROM cooking_blog +| WHERE author.keyword == "Maria Rodriguez" # Exact match on author +| KEEP title, author, rating, tags +| SORT rating DESC +| LIMIT 1000 +``` + +## Step 8: Complex search solutions + +Real-world search often requires combining multiple types of criteria. This section shows how to build sophisticated search experiences. + +### Combine filters with full-text search + +Mix filters, full-text search, and custom scoring in a single query: + +```esql +FROM cooking_blog METADATA _score +| WHERE rating >= 4.5 # Numerical filter + AND NOT category.keyword == "Dessert" # Exclusion filter + AND (title:"curry spicy" OR description:"curry spicy") # Full-text search in multiple fields +| SORT _score DESC +| KEEP title, author, rating, tags, description +| LIMIT 1000 +``` + +### Advanced relevance scoring + +For complex relevance scoring with combined criteria, you can use the `EVAL` command to calculate custom scores: + +```esql +FROM cooking_blog METADATA _score +| WHERE NOT category.keyword == "Dessert" +| EVAL tags_concat = MV_CONCAT(tags.keyword, ",") # Convert multi-value field to string +| WHERE tags_concat LIKE "*vegetarian*" AND rating >= 4.5 # Wildcard pattern matching +| WHERE match(title, "curry spicy", {"boost": 2.0}) OR match(description, "curry spicy") +| EVAL category_boost = CASE(category.keyword == "Main Course", 1.0, 0.0) # Conditional boost +| EVAL date_boost = CASE(DATE_DIFF("month", date, NOW()) <= 1, 0.5, 0.0) # Boost recent content +| EVAL custom_score = _score + category_boost + date_boost # Combine scores +| WHERE custom_score > 0 # Filter based on custom score +| SORT custom_score DESC +| LIMIT 1000 +``` + +## Learn more + +### Documentation + +This tutorial introduced the basics of search and filtering in {{esql}}. Building a real-world search experience requires understanding many more advanced concepts and techniques. Here are some resources once you're ready to dive deeper: + +- [Search with {{esql}}](docs-content://solutions/search/esql-for-search.md): Learn about all the search capabilities in ES|QL, refer to Using ES|QL for search. {{esql}}. +- [{{esql}} search functions](/reference/query-languages/esql/functions-operators/search-functions.md): Explore the full list of search functions available in {{esql}}. +- [Semantic search](docs-content://solutions/search/semantic-search.md): Understand your various options for semantic search in Elasticsearch. + - [The `semantic_text` workflow](docs-content://solutions/search/semantic-search.md#_semantic_text_workflow): Learn how to use the `semantic_text` field type for semantic search. This is the recommended approach for most users looking to perform semantic search in {{es}}, because it abstracts away the complexity of setting up inference endpoints and models. + +### Related blog posts + +- [{{esql}}, you know for Search](https://www.elastic.co/search-labs/blog/esql-introducing-scoring-semantic-search): Introducing scoring and semantic search +- [Introducing full text filtering in {{esql}}](https://www.elastic.co/search-labs/blog/filtering-in-esql-full-text-search-match-qstr): Overview of {{esql}}'s text filtering capabilities diff --git a/docs/reference/query-languages/esql/esql-task-management.md b/docs/reference/query-languages/esql/esql-task-management.md new file mode 100644 index 0000000000000..a7351591719e3 --- /dev/null +++ b/docs/reference/query-languages/esql/esql-task-management.md @@ -0,0 +1,57 @@ +--- +navigation_title: List running queries +mapped_pages: + - https://www.elastic.co/guide/en/elasticsearch/reference/current/esql-task-management.html +applies_to: + stack: ga + serverless: ga +products: + - id: elasticsearch +--- + + + +# Find long-running {{esql}} queries [esql-task-management] + + +You can list running {{esql}} queries with the [task management APIs](https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks): + +$$$esql-task-management-get-all$$$ + +```console +GET /_tasks?pretty&detailed&group_by=parents&human&actions=*data/read/esql +``` + +Which returns a list of statuses like this: + +```js +{ + "node" : "2j8UKw1bRO283PMwDugNNg", + "id" : 5326, + "type" : "transport", + "action" : "indices:data/read/esql", + "description" : "FROM test | STATS MAX(d) by a, b", <1> + "start_time" : "2023-07-31T15:46:32.328Z", + "start_time_in_millis" : 1690818392328, + "running_time" : "41.7ms", <2> + "running_time_in_nanos" : 41770830, + "cancellable" : true, + "cancelled" : false, + "headers" : { } +} +``` + +1. The user submitted query. +2. Time the query has been running. + + +You can use this to find long running queries and, if you need to, cancel them with the [task cancellation API](https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks#task-cancellation): + +$$$esql-task-management-cancelEsqlQueryRequestTests$$$ + +```console +POST _tasks/2j8UKw1bRO283PMwDugNNg:5326/_cancel +``` + +It may take a few seconds for the query to be stopped. + diff --git a/docs/reference/query-languages/esql/esql-troubleshooting.md b/docs/reference/query-languages/esql/esql-troubleshooting.md index 43768a2facc99..696de0d42f5b2 100644 --- a/docs/reference/query-languages/esql/esql-troubleshooting.md +++ b/docs/reference/query-languages/esql/esql-troubleshooting.md @@ -4,6 +4,7 @@ navigation_title: "Troubleshooting" # Troubleshooting {{esql}} [esql-troubleshooting] -This section provides some useful resource for troubleshooting {{esql}} +This section provides some useful resource for troubleshooting {{esql}} issues: -* [Query log](esql-query-log.md): Learn how to log {{esql}} queries +- [Query log](esql-query-log.md): Learn how to log {{esql}} queries +- [Task management API](esql-task-management.md): Learn how to diagnose issues like long-running queries. diff --git a/docs/reference/query-languages/images/elasticsearch-reference-esql-enrich.png b/docs/reference/query-languages/images/elasticsearch-reference-esql-enrich.png new file mode 100644 index 0000000000000000000000000000000000000000..a710c5e54368816e406c40ab76e72ad832d8493f GIT binary patch literal 143426 zcmeFa2|Sc-8#j!UEm4XhON&&NsU*A6MiMF&5<^0gecxu1t&*iw$~H=+5~hT#lToRJ zM2vL|Wh`S0GZ-`Tp4YV9&z;fpJm2@e@Atmn-R~!3%ynJodF;pkIF8fBgU0%T{Nnr^ z92|lM`}Q2>;NYQfaB!1(7lC(@p#-#EPv>+j;osa@RfVKd$7Vq%ZjKnwtzh$Fb9Nw}AopZffUgZ|~}L+RfW=K|%s}gU@}Rg%<~h zs4VowX>fS`D0mj$>4>?vxzPa)J2w|4+f!~Q?Unpp+@bq$X!&b^moE0+wle-MXI;HC z{I%DzKA{0#LvO>@%CJ7-?X11l+~}apZZ}VRnH@@7l(wwZ;g^w-(egaypmBJQ-uKJF zPugowdwaWUz+irUeoB7IN^YKxu&wIq>aZ=_VB5ASf=?)V1-N?K`YXD6t^0P9ANSc~ z?`7xd2FkGJ;Pwa|lp{`7w}MTonH+5e(_&_`TasI7_|4l(Bd1RS?>Z$>+oyAesWER|Je51^?;G9o%Wa< z0pEehLI1dX!G9aSeFv{OSM%$^?x8t2bU6(6>^$PnN$%KrS#mP9kA}KS4UfrA*3)|1 zXZ00xakc2k!piQGHk_{7JC}X1zkKTHnsXN1qTKE`Pu)@2@>=2Q##=VK&2>f9)D*07 zZ(ghr-nn6i0`Do&iamK8Quw0vX8ztGPC1xR&5_M@pFYoKwpo43@p?3X@Oh-8pVZ&* z>F6YUa(XglCu8Osd^}Mku50Hx4o)s^USSzsb}zgScPZnLa-{CPOWA*jb$w_6r!4`- z^@sZj_hHUq2t=a4)4Y!bchtpGHQ6rf$BH!+WXOL0YS!X^daN*ozU0S6?DiYFM1Yqj zDHWTj$Br65?hqb=UGS&%r&n^}kWo=R_x?mUK(>)TvEd)G{Vt~eknJxT`H!^y(9NIP z{r?*!?X$weeaYtj(_a!Rr5U49qqUkN;p_Bc!-e3pAMWxA%WS#vV&GF&Ws-_Bu85Q- zQ9ktw7HJ48+y3}?{+Y*K_*?T>A6-eVGCrEc3)H~FOq>9$ROWN@STb=nH?P9d=iQg& zag)smxb$q|?1x3aE9kFx1o;kx;Olg5GpBmuqC#jCl|7%I0sCpL;69Y!9BJuVWIv`y zn9ok0-e>cu5=q%a9|dfe#Opphs9mWD_i#@HBAq{ct&7K$L3 zRfWyRxehKp5| z)Q?3iLo#|%7CS}}K|}e(8VvdJdP%HEn}0n{+h zB;U(;1#)xLapD0FDI9X)D^uyDSM(~vlov5Jh(hKY7C!u@hi9I9i|~V6GsogktF8Ts z5$%R$jG4j8=5k7YJG#XjtGoCu4oQD5lCrgSHy*9)R=PVan6%G-3eEHy-r0gsc*i(@ zg=e0SAXH=F{S7SEoNak3OKr^svh3b$<@bg0{5QA62}9-MXa-@l zjoOLu90iKBoAQu;H0zk+^ew@8cEG)1#myuPI^-~%_7d4yIg~qoB&kDm_frf(!TW7q zRRAwd_SK^yUowK}_`F|QD3Uz*HjWHiWshokGcQ}MxJ*ST(XN#v4KqIU&6oYsR$h&u zk9CQ+Y64og?ep(b}ETGBk&z6;&nI*xckzW(g3N5Y+<|DNM zL~4XzhYzt*2!6sdRY-f{pc=K^EAedMZHrK7@ea2Q)3m|jVVjPH6t1g+^I0;-CS~Q0 zmj(Jv0ktSPRq|&#Gq2|c%TmSBLBmDuLpyfJ3;!#j2U>>Ynf+)_lg}ZW5?|^4vP^$x zU?|_ha5^6`5@`;Jm>hCNw^lg)?zk`|!PD|GTW#B7&S{InWaRo1x2_kUeUfq3&;a|% zHF(zU6i)XvrmSVpf(IL9$Y$dbh#EJHK6IsDx1UU{-Tq1jF~ci*b#t0}ULP$7 zxsL4Tv&~wJEmPAGAhN~w-XfoYG$r8{tngq;)$&Msr9PZ@umCO$b94A|$-S>!6ZigI zLw7-r&QeN=#;RQQi~0cLw8bLE5BRD;M0oo?(Q;$09e*Vw&1^|zGF3;?!5Fa>b82cQiuMDIbw56(Eq0nt>IN}1D)Z#WRrsb7TBNwIwWv`@T{cwj9)j0S;Qn=1)goT4RBClPY=1?;&L> zN*M{E+{5(T5+mhqiJoe4nIh@T_%mpdW>%uZMKfQQnGrgbaL6FaG4^g}v4JjL`r|X_ z(k4i^#E;6skET>zi=g|oNiU9ytF1vyHASnwN9{r_pK&~v!#l$4YfH#juXY%3a_%f2 z+x2pU%8+TYH}}azp0Y))#TE-)8ozl5gX+qLN48kS?Y%@mQ3vI8vYBu1xX=naR_@4# z%MCZ=%i)mC8@eZd3(bDUXfvB+$W*VK7{pPCo;^+Wq8C{A9q-Jn1l+GhSo=yac5Aw! zQ930-Zfc{w#A#BSgK8wL@Ps4*QYe*V-lh%nD$AQ_uGlFL7o%9(7H(v#12*nlI7XMA zb=^WpkD3=8A5#D~UPj3?8E{17rL~`$3_7A)>!iG-Lsr*LH3{j%`Dw27Gx%Uez!*(Q z8)(FK!Q2S8YWe{IGyu(JcpihA>f^EPpzw6( z>jYM+*bcsu=%%(LbkGojZE5~Gu0c$FRP)=mF#(##o;3En-j5*d zHNLD}o6%#70=%gNCVJe#64og!RYpv*r_9l%Vgd*sXHmNt* zE>+j&$~g@7LZzzxLWr8xS5=A;Df&^BjJJhNgdHVY&rY=`*;_3sr&;6knSLJVoQ_xo zJ}zU7J$rQ1cY@vTY}Y|+0K0${v5Ot=bH^k6B^U`Wv|*Q=R#GKSn=AU%!&kt}h+s;|E{)H20`f%g~fihoAmUi-6gH7huH4ylR9wBwWv}7O*bb(qO`B_E@0^PSitFsn$XRnDzJO;%t z1848WgdgnH#pgzN_{&`c{&D2xXpfeLCvT852aZKf(bY_RM^Gwf zgSw~v-vE0UX*5`Okx)3c2k*AKBZ<8!Bmz@dnH->Kwi+^p(T<-IUIut8kO`&K{`ihd zsEM1Ocg$wk0r#txGL|hJTQ2zB?X1GO^<2adB8yenlcG{Ym=dKremqAFB86z(Be{#? zeda8^AU905WRkPAL_1?qe~FSFr9A!k1c#K>;Spg+UvA!O%Y`Y1yINeHKtjPddGkhj z^myMvJZfN471tYuTDtd9dnC&Hs&;Olvx_HRb?r&hcuJ%x2DlI zJ1h+{47t=O4EkEzN%l;u;OC``y` zl#}Zd2t3Xp!?eE{M(hG;p&!A;21SbO;pLT&&tc&Bdb5&I$oij&SCNzibZK6He0Vz! zsV*19exyViPX4pp?x=w>- z9oRSu&;)hr8vynx`IW@XqrBW3mI_nk4tXsGnq$n%OG66&)qVcW0UqWB;3oAgemQo7 zVe^GTq@O(Fo|@v>i{tL{jJq?gul_M<|CqEno%;U2@d2f z*PkX?6m5H-f;|2(q^;8c?-s<>B=Z?(Xi$ht`Wwx=Hs{{;qQleTrJ?kp%^LgO*D3wpEy z0sJxZBeI9JH(n$Gp!0RtUbc}vcOVR)G{~1VCv2c#P5Fggno4a(rY*b&ioi$v1e-5! zY9IsXEU&!Qn0>@B`Va(*s{ax!+U>_N5H|u+A!sj(*>*y0v`M;hn2r?yK-J!yoDk3d zJpVM`aIfJY2SQxbE?ZrAxkLk*&Cn<3UQ~LOnNI_5@4^ zVcgD`lJe*nDB={#$KC4I3KXR%UnM7iTu&-mBgl0&*}dWQcn{SD;GAuZg*$!_|7Vo^ z7vtOl>YhA^W6jsCabW-BSm2>_eBjBbT;@OJE%cLop7XdB~muQ$B?B_F>r zhaW7AYh`kx*afgKgw*DG6Tn$G`9kr zRf>fNt9i&Xcl0805yUd*r!3qox{Bv5(NYshRBlrokKt(Utze)B2@ zi)xE0N>r!TSFNF;!$zd|f~>Vy_Qs;Lu!Q&h@;GfXE2)AS>uW(LEF~i71)sAG*{aCO z8zB6D9MJ5W51}CWw~nbF0?=(Z-6Ll*O$7acP|$xT{uMn(JDi?l^m1?wTVpa|s*4{X zosht?K&02%)e6F-`brFXA-#r#R%KqK=Q|<`7VAF^38$ZG6lGtWSbQ89rHLsy>=a~_ z-Y#|4+6JlxIL3Y0V=Kx45H&1iILMIF;#H|aydSNq(9+qo$QG*@FgOo@E(XG3R+@_3`Mg7 zR~WfahYQA5PGq+50`y7PE{C}m%Dx7xQoAmDNNF!&fsW*WFI}azz2kKP0B|1QK0GP4 zmfSqpf0nIWb8<}s^)HXk&J>1h2|VIRl5|zT;`L-VfLOh8ts+oBUGYD6UU8L>#U;K- zjv@sFpF~|HEURL#_q+$Pfaqr@I8XaP;BleWMU%w1@jj=Yh*y2!cewr%p>Xo09Hs4Q zp%Qy$nFD5Fdac?%v6$s>{L3Cdp2akaMsx?=TrJpJX_;heK#(~=>1NBbL6O4pYZH4g zZm}WIf~HdEl2(>$K9H3Hs#E)MNYUQJp!XpY2L3~JBN2bm`_+C}FJC)+{+D-CA;~7; z^c|DgMr>KRG8XJR#iBXz9!uqmjRT*ufc^w)63{Y1+DNJG$4X~7a0jW4eC%x;Zr%bbUXLrGa%e&-!PqR zkjWIm@&K}d?vFQUi=wqG{L-D0gz@Q#jCUDq-Hjh<-BT*X)^+N_LF|F7%^%BRRk+%V z-*d4LQu`cRaq3b^rpFm;WwtA^nF0IhPqvV=_JHg}Vefy04v7II%1|A8N)n+Y zei_@%cA*@hN#J2gGEu%sE3bx}#EN9ZjsLH%!Ge0PhLA0MQ{k(huJE@PVJiT@syTB; zObT*8f=};f^nluQ(w^#6Jv@wb3O3IM&j1Bi!B$9p!+Qy#pjZs=hYH*6qU+dtk;TV= z+>`sVto$JssJuyvjRkaZUZ&_LZi`JxDEn=Jzbwon0Iq(TT@>UET`7m;`Me?m{|z=8BC=Yk(>9K{5M2tp%&<8DQa_BKZh=*YlqrZ#YQ9|km|EU zAr$XO>A10)=jVM>qm@E!K|4Vq-)8f|W4YFnO^+=^YPG5Dqpx7dtxyY&Eoc`r4N$b6 z@CMq{paRRi!4bLyyp$A=Oq`>*lddZxFlC}Wc?9%JiG|N{txM(;ez3v))e5ul!CWj- zXUa@7A%kzZz&Eg}o48{-!GF-Nu-olw(L_;?R{JIFGYd)0;uR>#OSNf_@=*i2>9Uqkj?g_^Iz?#SKwXeg{k@D1@WLG_pLK0f%T(ryb584Z;h)$M z3));QDG4)KjAo|niLoN(%4tVNiTg0ta#a%m3Y1|EFC6LbU8pq(x?G916lRy768)J= zVlDP2wog4@@XJskVF~jqjJeDjIsIjH5Wx&=8F%nt-j0&u&pMWU+!qdCe^5^s56d`( zmIYN$8j9QSY%87x&3_SN)57%PDOa4<*L@IIi8_fXK6+Da0!@($!$I5SKsn!0^X;t& zx4Xm1&m=f=`e`V$)j3xXu-tGup*2A_6!a5u*o}W>RavWd%g#7KrImfN4fgE( z%fXHDuky1k3q={TP0T?iZ*p_?rr9FtM)165M~kXk;dG7VCLys3!*Iq_PlV=hOP<^* zbSG8jAXE~(quOQnt>j?&hmr&TLgZ|Zbd;F2{~9W(8AU`1Av8w_B+%kF10s_dqpXxe z(Cs>(nCMKO@}D9`c?q?a26#OOZH!(hhjpP(fz!0uL{nVG%CJ9wY*J;_aF(*G;mDXl zEViw_p;!bj>Gon;J|8^qQv}a@vI>aXs%C?_&193!sx2Oxe#48g^dYyz)un-x1Mwke zpuSK;q{D*$;)yb}yGY7KdTCV}lQxU#ooM)qJY~5XEPOXcB<&a;E$oV`e2P8o-C(2| z0W}zw3>V9v@OZUC&W)lS`VoB2X|tx%a@Gdld~6+O#RZGm@hx8dptl4Pl!m{Y3C_R} z)W*!gyo8;{r>9=NnhbKmtQ`F51N5s9A+7{arb~DyIQ#rtEo#I3wW!b&p>DxF5=0=} z)?f2Vn3Xf`{T9ls21HP%emwHrQH)ZxBC8zbE6*U`08i0jPS-`DXFtpRm%DK9@M(?! zz0vM(>!gaw%*7-mWkR;idc)sRB7h!VPA=4aD(JYNh%q~ zcz$w{jF>8)X!n{_=u!v+0-=+NuuYN{eNy|1a zK8-_~ey&b4!y|6UO@kJY&!5KyM9X1(w4ud!<+Au`+N(|tR6`s#F+!JEL%KQG(5T0* z0pXx^`j&J)+Lxuy?WXwLrFoI2d^8mqWA{rqs;n)F%P8tHh?TE|=i0FveB-_}HP%8} zVfwO&w1VPgadr+D7=MIyO9RrD;|K842HriOlc07rKOr%k?z`w?!qEtN+Tv}K_E5uc z=KVS=7$_mvO*)+c5_awJ_#8;WM%clXAHwNhFQ^P}A~#>KsC)=IW`yO`_7Z7VG4Rm) zyY)a4vk%w&gw@Df<>`Ee#A^Ekm|{dTBY6Gn*vsakIGtN^tstA(lIOV>|BR7x|IHco zTns`WBVmpt^}%}Z#QW>Xjwrq2(I-%cAHlf8%NA?7PK45SOCNeJp;kBW=_3pwVdwqw z%aGVNP81Ek3OHbZM{6<+@MX;F?x0t$mT5A)Hx+-A&U03jI#M+7RiqAX`OMO}ErQp%(zR|y#oWVK=C-9$k>b#GAuDpZ{4+4k>H<3h_;)Mj!ad_nH- z&pxMXtDAhD)h{!SvMzSN^rQI_XJk4F`Wu^`|LM7)4T`EmJB%NDA6?WOAEJTkomgQz zJXIA@4{vj1rmFh(Hqda$;f-?zPAsW0+KESZl&P);i00Z{veJFfTKN2Q+x8I9q3V1b zhtwS37>rm(X?iA#a*pp$g`%GBbPMA1thVEYA}D~-g^(mPONrPB|v zquozUC`|H8!m%30>j7NVLPxX;Q##-3`HJfptoydKIodBy>jU}q(PA~oL<9l=Qio}B zU8#MCVqFB?)o4H7%~2|1#1O1zLI2xFIHbvCzb^%|VE4Hhb5$a*LX3}%qDM$az8gN4)KTL-oDoMF@&$0^bJ9R{ zf<{yRO$;LOls0K8Wzb_aRRLN8hjbSsZT$e58c9R*- z=tFNy1;9WlGsDf~%LPD;7^6QCqXL5+bxU=Cm6PQrP0BxzMQAOkzE~-%DZl&S^!n|= zbD%IE(tsQey5s8@n?6FVrq9Tg2SHcm)6I_=95T`K{^vK6z8yqPSgTWfJ=G{gX3 zSO4@O=%hd#dxwl>83D1PXOl)L`aG2k9M&hP!+0~T@b-p~;Bo0Rp%Ucyz$~$aV6N>= zkhFF9;*^k<^VI`~wBIE+N73$}1w;t7Z*4+!k^3!nM0BzPQ=vapRjAHw2%8x;9p?!_Sn6wNGbY6>&%AQ3_Dxq!)5|+vNU7wsep+{ z=Uu*r4-KT{n2JpW%-4@F@c#9Z`oF7Yx=twWToVxxbHSk>TB-F0ra+s*InZ7Av;DP56*L&1^4nlFW$v%Z zC`H5C3!_=;xc5&I_yhx=5qeJE3oA`MGQ9TyQO_2|AJr@S`@ScPAy#i8OY6++G%uuw zs)d!J%Dt%!v&sUwv^W}&daM9w7LF$P(ckvfMZjAoJ)02&GS+C|3vLRq_ih=xZLvay zm*2gz#vH;U&JpLR%Y@$G=3j6eNULWdQF_cCRZu)U%tLakM!U2DAdi@q1!jVtk0T(B z+xMsa-iEq++b?1RW^97XT88dEZPT0VUqhxkCFT6yer$7mA?v}&7O>SMH_%AvH^{vD zCuZW1IVPr{wsHSdYT}Pt*DsmX4S-}7$Qfv|&B)S$DtzReDm_A^(@fVjjC57gMF7BR z+RbCh0a(?X`7j1V8Bc5HO881417VKG28=YUDOrJ{-285o#H>GWCx8}K*lK5axG?DF z7Mjma-^QTnQ6vb74=(#v)C=)nOQzah%K5zk*rpYtRTU0NF-de_hC5My6hjpZnKdYX z9r8>~);KL?0LG;dbmt{}IYlH4eNx?)xm;I}{v5JWZu^2)X0D(_Z6&qlvNBQMHUs08 zq7%%=EfS!RuBaLqj^@nLr)5^zeQ6KqKy?`~j zJovEoI24tjFV)s1f?`}^#aPBkRw94$ZaAFP5(%F^b|`ANq~|48(&xDBt@`XoPZQoh zKC#NdIM=s)GfWR8Xe9IB>;Wg&BroJ1!|CLl`-8*CEu9_SAG2y*s}NP_C&tCd7SM0} z^so~}gwmjfF5M3qK-9MDBUQq}l&Tj`2eGW!l_{}5x~?1QDm5uDI|7m@vfFjz8MWzP z7ee5EJlgwe>>SYOK{O<5`|yPEcNOs=Cs7m6ySyAzr#^hVR9~1m8`xD->4A2dk~4{* ztK}Gj-to3oyMK!gDLTS7Kh6U96)A$=Q%4x(vKxI1!>I8`!)#qyCj*V*}wPIRI%Upz@vw1k6x`aQ*n`bE<|Rye6m}RSTB(?Z^Nyq0N~Y~NzVF0@DdSdW zwIf*h)~353XVq#m!ffF*YKGEmr%4ZCW6d5)3h!6dRNirW=@!&%?J)9ez4}w^rzHAN z(++7IGI^$Hjy~hjhY%-$N1WaIyvl*5~_Hsp}mzfN|1EUX_ zdtvF3ppGdnoO*r^8@U&^aKX5kWWgZrs&pf_5aqI~^FC33HBi`;PD3oMbGhg;~Fdl8-tQV>>^D#)ZA z2N$3TNFQbN_z?pJ{FTVfxBI{}?{7)ZBR;^i8;1Tw(bWv6dNO)t>gOl4 zm*`wq%TZF+_emeetEMW*%YOj`3Rp1*B6&>MWc_dBQuRb&-@e2;B9h`J_nM_dFvv}G z(Em}}Vc#Iu6d8iRD!m6qD=O)sDnISvtL!B) zX@Bd~9{DI@i#2TE-T5acIfg-(O_6WRw76u5b{>aQ?}(m#zl#AX_sDMeG1zfTK0OnM zq$!W`|4t~#5CJ;j+D0AGIdwYrh%Zk@eP^Me50IuUbvTxG?8~*7)$(LjoW__z1pQ+F zW=V6%D4Kan&Q#zSA5aT6lrkVQz_)NvTLFx{;TV1I@~{tQ^2`uIJe^uvtz%C zh?Rsvgbhz+0?(l8{FT=hYtYf{B?jH{)oG;XeokBFwLQLXL?Ha6uE(HU5t__A17p)w z4UjC{xea7epi0>xyxVdA(s2MK1$@f)gH#tGHYQWIjx6L!{sdz+g=;tnIzrQ)&L0#| z{I=NA>)OA&SKjTiEU@GLn?&tg3|7J9t296D?OT$V0{g`G-wBsQDAntlo@ZhZ>l_3# zmrw|#aK z1Han$8d%R%brxg(0ihr$;2Q`9((6s#?c@BkB845lOSka8%`8^m^;)U8fgHEKcGBEmE2%T;|41}F?Tf@S`AgG z_ND|`+rsA_H8)`0679Vt;}yVC_o$Zh(}v#PW~Bs0UQU9@r zi7i&|y|}R~x%r%0#U>UC%(q=~8yFtbUsfI~3$?GnZ&;dYLW4F&OGyCNuCsq~WsZ>P zFw54;rBrQ2fXI{bT;XX(RuKn7@Cb!v8s? z$t6&yJZZlb<^8+swxEQ+f2i$xDroUOfE)a~!2kn>Prm_BP*w3JtuN#7x}?`|Iqhj2 zz*qLR(yj4sRoHnV35}JMW*5|!YcaHzS61#63ps|P5mf$kZ+Io)nOi6iP~7>Si~ZhC zz1n$C3p&98r58vdzXpe%)W!OoZPOG09rQM1GhjG5?g(K8ltn$%`%vxk`$;F-yfgur z-_R{(+rii4mD*;Aa(6GsG;jdUstB>)dz-e{0AIi3l`V>>2H{YS%*)=y!PVMg|5gav zX8}^!v!YW}LVz8K;Q(qXN%6UJ#GcL_g@ zFW&10E4uJ{c6Kuu3r@WLl<;ltd9RX7hzN9y1hyR&Tr0^`Tg`CuBId&-`Ao_fdj4O# zB%;-zlU4v)qJ~Ol?1i5mld#3^4L1C}<^Vzhh`p!r%<65ZSj`!)j}Wj#?qrtiWxnr! z77XTLMw*yTP`sEi50`ID3*p)qh@3r9NUxZZMpuJYDa1R_T~F*qGc(-*NI9l&(axm% zx%I!7qXHm6+++@1mqibrC%QQ|XPgdt>K z;r+v6z_^jVSaA>N!Y`{URh!uX`iN_1<)}T8qF~@cvD-4~_mJfU0z}BI*P`g;uTM>e z>xKgrY6I(HP$I6a{>a(#Xi)HTHTq+r2h2NIjW&U~5p^4xCk~ghXDnIbO5#KkE40?}WuLDU=+&oDRXj4bi`g$;+NVA)w66F2G6sl^^ zQ`b!cz_sse2I{GI3Tk+Jzp$vn22iu@dtnOF<~8%A&H5&lNZ)#D+H+ZE?83s&@bBjh zorpUE^!CWdra2};4k|$VT1NSKV2V(e2<;V?2YD4t+K@`Nm*unMD5<=eBt{9+?(9`k zf?B`TKX0vFO{(t!=a(I4LZI}cznqPc1_oswSSHNDx04Wz8OAzKM$YvWQ@6AW8bLaR zZXNkrDMu+$kpvqIm~Vq|V1q;frs6}TcF+CzI=as@cA-D?nD3_q>D4KY9<=Ksv z(-!s}Vp^4s2IUkhke|L1CdCFMcu$pMo#H#He!vqsh#id2je;n&0K6~%W;0j95My)x-=0nmqJ0#6B@R!LWCySE+au95=QYRAcf^TQ--26NXfl{z)iP z$Z+dC<^`AWHRQsFZZ30x7HC%6&=OikOF1QziX-Qgt)VSPQTlK^X?nTYeOVa9`i5Fx zTdX8?KC>2pM*s&BPdEBRelqz|F;hz0WANdhDk?kibvf?Mph~Wa_ScCm8AP{=QF0=9G86_JJ+L)^7jsYe1w&97uxfc(T0NHVzl=`Sf^zRj z)9F7|tbdJ4*_5)57sC!6Y5#x&)q;iIhI2r3Y6bv#p4>==&5qZD5jrub-yvan@pv|d zkZN%%7uwsrJwRZZ^5+p-eqZ1xfX`jV*5`sLPF8nAVb90_7_wl&`bd@ z6U(Jj31zY;Kxf-jh$V28bI%)g5uh?b9Pa0Y7OYraI(Vj#PXP%$5#=;Z6UZaqe1^IX z$7lz0&Oj#N#21#R%gtrKN`cdW9;SrWIbtjw2tNcdmK>qp`};iC02!1bTw}n=W%H9T z1A~4wOD4ot_leZ)~zX6sffCw{!9O{P8d^#Q@sb8C>gVUo!(lv!ahMXjR3wIik0_-=Cc@ za0+Fd)KULz5Wp{%B7d}?pbE{r9Z0$#jq4R8eX;gy1Cd36oK46aMn-P<@$~iF&)c+` z6EJYEnM?8DY+P`*+ZSucX5fuFk}mwgPuN`oC;CcfLZvc+T5FLVDIv$8RAid@wyZ1m z>~f0cHeT58C!yMW05;VH99h{{w?7ZQuEV{%&alw6UHGX>!&hNoNjLq;lJbBmlfW>j zGJ*C7?^VCE&6L&dw2YD|?sr}cMm9Ou)U^hO40~RkQVcN%p;r@U42D?I``^@gvCdKR z3OVd{8R`N4D8S})9~m=N;i|~m$PM7kqEaKXIEKHq&yW=as5bA_dNU4=HCi1s84Vpy zlpAYNxeCI3#kW_Zci~}f_9k->-w4!a0dl_St39a7z^W5wqi{&iuhR?XiF^JhwAKD! z59xh+2+mxz^0R`bbrLZnU=rc6MVE5Klufb!g`1WiHv}^ z7om9`ipL?T9ez>Z z#BT4opG+GH^0Fnt%kn?(K{IDbl_ua^UeM6~yGaBCHmg{$x#|Msr96IGCdd9+J6rhH zDMX_D&!{mq3B#nKm{ejjmNB`EQj@G2W$9Mt!{*Vn<|PrVlc`hsprft9Ils+Uhjz>n zO3Qq>4D7K8I9VC~$|8bp$|1{mfP_1cJ!8>Mool-?F|21cEbh8{6d)wJ z#~H_fqv7}!hk&z`<0Lgj3tT(Ib!JB^WhW9(cpBi#LughsGz9=`lH{-37q`|K~w;$<{%~=+O<6JDNIB`hHOOvVKNVGc76lK;nd$zPv z*M|bBY8ga=k(0^<6P7&uY+L>=JLazP_t9XOxfAl7&s~I zjmy;BJ@y|Su=Xk81Jfv)Be?tYke{X>yZRQh5qX6UouchdpKKPR<0;}S3+8+zb@m8o z<7a%nAR8O}HFX`4h+@=51VNKGK;G|7Vr8@tr3W4E$DrvGCo`DZrK7|3 z?qD@ooR=f&O5gX%s?F_HLcg5sER)<}Tz!r!!YXl}|xC#QfcJ{Nl zY2tX14Puyo5%DKEJ!)JQg67KKJ<2S%|UBUy@ABS9Vx5kS|W&;MY))7p6U6Jg!>-^dr8YGkhh0@+)6)IlwTSzA<%0({0JegNM!kNe)o*9Zu)vI zJ3G7K1oZ6PlBw=!Lr=YwMRVMqgNrV2v*&_uJaJ zmXd>PRW)Vts!seJHb|wVWU&Ej>T72aGEc-uUPfkG;5+T{_sXsT0Y&Oo%&gpU@w2_q zbM~!ImqBnc3S8RSRhm!qxIQN?((9AEY9}|x!#KGEzwM+<@nv!un+J-Ko6BrYNY6=# zZ}L_uYqRh)e5O9Gv-P4QcuQAkq0Yo@p;r_NZw2zPfP4ay)By7$Vd?Ufe+Z+{0 zzG&R0H6KV^+_VtJqK$oD`6vSC?^(=umGujLinQ%!M)#Oqpv`8+%H?rcH!l%{%BPE7 zUI>9Nd}xr%O;g#lJ~8x{nEmaQE}Z`xy$cu2DJv;9*x?nuKsf%+s2|LG@Z{X8bU?a? z8vk5Bhpzp9oqjXMHa7qRt#Dky?2|0XjP(+aqI}r~p7d{vd*VZ0#aBw)@ zthr-HZ>*GdYoJw?9Aw=`?zPWpemu_8i_LBh?q(~oWx8ATBN|5Z#TL@|rv{6^$^TW6 zIqeM}WzgC-N9c#N|6L8z3%EQoCNjjb9!?Ev$zmbu=@a<11B@^Pk=~c7K=1Fr^U)vo zx@ZG8BO#qH+h7TsYbV!!^HP6PMet+euJn$L^uC3)wY9}%K~z1n=I;D&9D)5;962K! zf9e|2y&^0u%=k9r&6|CgN4|02XxH@L(Jn?e>ClXbh=}W%Gw+->Gc;h|?neIa?pDf? zF)_3(33663$GSw%)44p9w;N&5oQhGq-`B~Wr?2*=74n^@GqSbKVt*&sH*bHClT)w1 z5O#G{`cWA?LOpNb26F7GW{3ZYkfE5~2vZ8lRohMmA0e$)14Q0#7&3EHZ%SJLj%Aw$eaj81{wdAj)xoLLgf)wVSkEjUltFiUi1FYDJJel1wAz}45cDJCZ7 z=z#dRj)k(WyafhMuaxU(tgNzwAu`5!I(@HL(&>W^eYqi`8(d-ZzL4{D{IVcR1I$QN z=g*+2wYh>ZHT66hjrN-%l0Mwt9m1?MG3sp4F1dXD`t@T7AZOX60Byd)THFmP2>(sD9SG;+$q+PXI?og=)efQ!GQ(6ytr z)zQ|rBIfetXV#>#Q{LW<{X7ARLDXRvMto;*1^h?U_^$$XP#$pI&&(JQ%K($>Zrv~v zmAJbE-nT(NS19*VNX{mjz7V0rVL7TL^NSolPVrvhb#5B6ujZ#zg-DR)H)?|uF1)Ul z<4oyYcWtm2t~9FztCN-VqCt_vqPojwyPba#qI>K^=n3A!^gJ+lOfD%v=mw_n1)E;YT+4Rn_uRG?%S- z`pwc_@WXCzEvzWV1;<=ia^v>xHGW?|zwMHZ+r+K(yz6{ZXVQ#;s?q1NJz?GiRogvv zQA=q7W+{|8x%UA3Vq)T1a#GTO|Lr7?W7wdhn7XIdFBX5;FHF|Y>@v|f3=h06UWD~w zT4jIYpIkAV=&=S5Gds#lp*L3k5+ksfflT*fre6o6)<)FND&9Fea^`#piII~Q3i|Flf(m>TM8LeU+FCqn$ z3(XosxoLafIyfiVz>_Tt^>0CX)A5lqITj*GruuyGD)m1P1bsEZczeXZa{qfCk-ZQo zCMuwYqs9w^BHuz6JsFwx8a(d^pFC9PS4C+Wd}bnwLbk@#wl`=ze%vr7LN45YF>OLj;%fP>s2b8WS5^{OZ*!2k9Bpr85%8 zof7X5lAY?J=yQr?pFXrcq19?#8|36@S2m5SBy%Q_Y*14p<)j-7x>?PjcnPIrxK9%O zCOGD(M!XI7#3v}#5`tDpFxh$Lqcehs#%~WOh8NnRo;1~@a ztK?1|gSy)Z3)Hd{>oq>4TVX!l;gRVV^<@LqfF-^@6=ty&3;Qj3X z)iy69XD+75ZP<`Rba~F;Hwcs9#tlwt@eXDThBepQATkCsIG=qgM|PRg_^)N(BZP%~ zlGUQ=;tg_+FQ3(S`xxKqS%R{>FL%esv2Hswt7L{9(G%XW&ptX6M zAWy%6Bj<%$q>NnAyS=^@Yumt|1I(Yzx1Rj;nA5{>A{du%+E%}be$*_2L2T_mainB4 zAe^>eoIH3xoJb_9jFj9RK^v2Vb)?hgv?u3ugF^4-l@0ivzx>h7?Uq9p6h~&-zIQ>K zr?+qPasmqyd)*krO4=VPs&^>@mjpKXqDg7=lMYe$SZ-TPt58&TtC?XYCBw8){>U+D z4?{T6;D)2oHis@K%4r`reC|6#oFTX5Jt@%(quXQ}tM1t2oH=8Tl3Ek2G(>3-y)! zy)k!$KYn?y)T&4J=;LJPds}!1Q z7My{tludi)lK-%NtayoH>iO<2@vG#vvs)_RhZ@$eqkK_^!wIEGNy4VaW~aSwi!d{M zwQ?(6a?3S3;+LNAeZJv%W-`xt-}508H`n8ZYS*bL^{el3+k&ZGb2?Ff&TR-^5Cd+i z)DYI3#FzlWfbxWUsLXBPI=Q+KOf zgZ_kIGN+ffblH-q?m(A?Z(BvJm#>!(Zq5)L>V^1~q9 zcSpt=nU=&zs1C&Uo{ShHQsa-7j0#F6UDPGTpSoC%+I|w@^5i=}_BUszyN#0`8-Hl# z?c+@5dom+Ed1YDobm=ftn4Fk}1BPqB_NU>J#ha`mqc#1M4)rH2 z$|2fdJFd-mq(<%zl5Z3ov5TnmaA~%EiEQ`rIiC4Kb9J#FKP8OP+EKccEP`AdMLE_{ zNi)xvkdpE>G&HQa-w-)&L69I0cB#*awa_=d*a+y>0hY%@t3*+?3nxafXHLdg(Omr| zVok0IB|wk}Zh=?Uoz0K4LpOh&BZABFX0R zrka`>l@VUSf-0lTG?mh!DjS3!et_reDB5VBI5|`BQzeRIoxwO-(svc`AB%eI6;mKl zx&*5q6&cwMj8d49*4(L_?q!hJ*d5%DdB<8Ujq&A>>iA2Oq+JUnlsu~uv^yXpu{Ap> z?^s*cou#*E$65CUZi6{xImWNmZrTvejXg`UAqbU1Y4S*>j7tA?8|P7;>3D$u&v;sh zJeL!s^qimerSIK6{k$h=6?yPPU8-jD@U@n?!CnI2mi<_9*>B-&13dVnk#=zDLiI_a zL`SHlZ-KR3$WzbWLf1itTfQ%$#I7Wn-l%VxTRjnOgFW!cJ@)U$LzbV?VEjs2Fser{ zhB|(M-uECdr0&eAVq8#6PIIEQ{z#h9w&-2YTm~0$40^3SUZPNe^xn*H9pP?@5mcCy z`!ZdtGbXYomA0?~Zt-mRY$3r*-tm~_1Fsleq{+IQCdC^YrL}|Wl6Kq>LRJX6itn2z z{n(E|+_7PTz^|tMivc0nfMFceWP|E?9g}@%xCy<9w^n&|xL>QP+J+&!?fc>ca2YO< z`lZg6hY6#T=Aj`I!5^)u@84erf1nmIc&$gTI;sxgb3~db8@R+n)i<0w4=Z&dH2xQTGn0D*gOZN6?s;O|P&JNy;JeR43G#o=KgF>j6?>~N|l+%>~U zE2QokbQkV)BBa+mi>nvbG{8vfO||_a4Eg20gz1z#UI?~3Cd35!MVWZ?UJ%HabFK=LX%D0R)uNQ&k1(^zu3BH+ zlx>;H<)(PdU2+K}dlcKE+b7+jkeNr_)^F%r@fx!`jAIQ-JSKgvwRKC(?}DGh;;BP}+%6%9b^| z!JtBm>`NF!c4I3H%@}_7L+6~%=lFcSzjMwX$BS35=ed{bzOL(jzu(vOjK7@~`Mnna z|AO1(Y6lT7g8K+ifthh9%^Ajif1@e#>#V)q@~8KG#xjAtEO>o;P^@R~*|3mL^GwP3 znhk^uRMV*_DRq3C=I0>BifByM)zx(h3nYFgux7qty5_N?nPOlcdZb(4wLMVrw^?7| z7Md(}&W{unxE)qmOkwFUOU{+AGzgw8E9sZ2siq!SB(6H-^C<=iKx_{B}q{MX?Y`JMV1TEWZxO2(uB9^*Ucfj8=e z;qk>pf7y5b;k2{&pZS4HzU<8;%|j5C6k-`w?gt30I6JLC2dTZL&95fDWS`Kwd`<5P ziRpc*%d+1U#pRAFSFM>Sg#NKyJXPe(tmpz!s+*I@oSeYM_k65!9DI{AZ!b&Bo3?g| zGJBnX5d#AQMr%dU>}HK%%^r)QHV~?dwNs$b+ryAslxu?9TT|7;LVcz2s!AIhe7paA zb4J~uL(r!80k|+gtZbvClkkjScJ_Iq=}n18Mq*Zmca|*ooyv11r0CAge#s~3$DFsN z7*PiANpy3%Eu#SnoW}TTS`Dxt)_MLFX)#mJY^k1s`6;HHd3-4e*zIYhCfg{010Lz-lumY8dW8Dc`a^12sBO+|CxkIl+CG8^ zD=i13j${H%^RG6l9?=!Q-BvsOp(34g>ric5x6JX*>p_uJZ8Yocj$C>RhEnbB{=R45 z5OH_MTLx5)D9;!Tmg*+ToZCj3z(%+)V#-^rRi|l#M zrpw9EuiNiiSQTG(nF*mROpJPIcgr;;_xJ2}$&*(g3~)Wpz*%diQD=BF=r9ycob%T(Yk1|dz<(tw zEnt>!3S42QON1WeIJ6xQj6@AL-1UnxSK%5@y*kd$MB0Y(d6%RS60aa|+@tu8p0Ckw zBCBm%%5@n=2R%WbgJr+@Bue5{UVX*^kIGE0XqR;YP|x)}9Rq%X86!BX1%mM*8cF^5cEDa6N|_P*RR&$;vxwVyaY%D>+jdAPM9&1?2Lhr;mhlF)1L`v+xP$5L0NEWh&K-kRYAWgC|J?rKY9^){{(`P`fH?J#PR49HT;w)n5oFkKq08jnMrAajF3YK3`2eBw2a>L>}?9J4I(xUJ4i}NC=Vq`e=>y>#vAH zlsGfl2mUD^&>y=F87r=%MQMf?yV3zueC|bkE(xAMAO=x|dco!T-*0Dc9S4>ZhQopB7Wj zK%D8FSgG3Iy)@+U%Vl%vd;_2vI(Is=N~U65z2;z>xhwEDXBOxCs}N58NcP`9`!Y_M17SRixmyq)} z<_Vjt5dJp}nVt-8YBJ`Eh_uV=Y^$`+zhGOFb)dw|F#nWy<_4#y^KUpk={?|cr zVw%gwP)_`tp$vne$OmCgp@KJt;{9)ia_RsW3XeeAo;1geq5Sr5h7th{#okCd_|(Qw zp8u<%><2@M=V3qHsN4)@TmM@*SGUwuF)e70$JyaIZ+_ah zY32^jK^4gQW=~h4DMjHlJ)kuCm=Kn+45^?F^W%SpPwsUI(Eq`~9|b3#$a@9r=eE8a z{Ve}xQG=oV6}h?;6tKQCBZ=DoW>KTSqR#GCwpRM-9o7GvceGt%^$FeF-2%lASQz5g zi{;n(4{lWi9BuA%GoC2{*{3;xUGlXFns$f0*w~4_N7GzWOP9WsId77qK+a4|3y_Xu zPA5-KtPe*^!*QD)*VI_pV+U{tRlShv{9!$)JZs1?0(fmYbFQ0&XAOhETbs5rpRo&F z1w5O3#5k50J6~!YJUHO!l%|Rs5clnaR9|7B5SL(~^vG zCmNtZ+YY_Gnl4ScG$$(-RXu++3PLVNqU`uP@LYP`Q~jV2p?CD;1K+sx&XuG*o6Z*=hkq;&aD zGI&FWWe=X)t9*G=>09zW;KbEg@(Cpyf+{JF|B~md3$h;H#4c^Jc;JlggeXhym^Z=F z>mogk>|@P4YfxfFF?xWN@%v9r!Zq3I>!H2ZWH&YJx9ete`0!UCyO~sE&|;(4To3m| zJ=I>>t*w3xBj$Jh|MByQ%{Y`7Tt}`fdp^Ir6pzFjQKam? z6iKWbIFWbF8Bn}N+<1_L(Uub+Qu!wi;db^nxi{Ozx=Y-a+F%6|EWBWR=)BY=-kM+SI$K90uf^Ed8~N%82EzH zCPrBuOc&jX1;pX2SFcDa*E$cL(u$~QI}5aZmLPw8pfHWc(>G%{g!-y`<=AaZDR%)q zI|5$y3q31SgVJYxf2kWB&0-F#&4LF70n!zk*?hTeKDYvlbrZ|ihZ2iss%6#RygI!G#B}HP{gqVy{}}Z#Xw*hysLE3c@K=F(qV2|XYqf8uk)Cbp z;U+Ip08%mw`ln;1uz{3yRcU5PMsaIl90N5($e7fGnoP+bu>>j_REJQ;ZWU%nEVgIc#ERf3dSE|D zB=Ylw*KB_!($n)GzRtM#tt9Qf-IR?B9aullJW;-jlTnEBiKtj6c|wDURlN9;mCUJS z08F1hvHKrd)OYUY@#U5lqqKTERp0SD2~VH0+mMIv8c{UtQ}4wA6|*Hrc&O2A<nQY!-A16G_#W%WH!lc z);qZUEZK+(KpcwPzj)0CpG6Y1GB@`W7Z)dWj+KQQQG#4sP5D7k&)#2C<$9R#I1VkX zxNq%yjeKd1er1`9r7x5w$l_Z^55Mb z{0oDrnHixjTF3!057^kqm~N;0r~~RU)HA@hy7EoA6|O=Yq{){j1W{k!l&%t+M-zbM zev&x|y!c-+s{hM>RaSrf`dmm@*t)BEV8G5tdeu+J+q_1Swu{Ts-NvgiTYtKY@ceP4ewMzHRYR{u#m0zj=G4$^N5UT)%xp^5;M8z z5pM^1I;u?Js)OH5Us+WN-Da^pSsnB4-3b*nwelQp1_~<~XAu|EY9<=BP1yV1y?X@T z`h4bdrW=S}|GZ72Tz zF6q4o6%>ZZ;5$Y$x0M+1sb8C3L)opO;xNc=6Gbez#?7Gf?3Jel!iTKrijLIj&*xVD z#TF%2Lt4j#1gowF%vL4nXCYpkGVT)o7#;W~cnfo`4A|P}LOIXRkDt%P&?${29 z(GaQACjja4`fsGm{>b6Om+8X)TgF9TVdvz;y?pu7FM5|oa61reW?Ok=n_FA^;ryq) z<9qOJwURUgoy)T-&wJ&j!U!1qe$>V!s8FP(?N82{#B%#JoT*;nR6*8VTq?$t2e zNw>Es-<>;lcseyDMd#QoS!!3&hcZwTw*%cJ&xH^zHsJrG!)f0_M7@0^42nKfT$y77 zQ5#P3dy)ho<_y8lKtJ_YQtSU%-!BZKqoeUPR|+HV-sLXI%j2@H992qL=<=MS$K-$% z3^?c24^N2Y*;IVT;otRa&Xsb#>yiy{GyJ=1_Io0)Ceag;D;08gyQ>-QJM$`EmSVHdx2|t8d>% z0I8;Td?yy<6Fty!zPm~T#M+=gFxbAYO^A{$3`WzG!V(g0quxQNtA9kRwJaiD9MN-%bFx+_!!)u9vtWvh2)6MGYJmDKqvb~ zmiExCn5)Zd!I=8RAtBhyr^s}Ro>$d!rO#DBB;2nKCkRgFGhg@}Y@o9nW z+n?%AAP@-LlP6F7sK?Df>MdRC25W_~m-pcIZ?@RkFK(vd_zEYA)4F##^QG(SJzaUB2p^=o8^ZzLH?{RJnQz@6g@WX4}> zs_1Dq?ve=Iybw_`h%8 zAuQ|%)EK0AVL?If_|)GWf}U6zSY#8)ZqdNr6F`=I0_i+If}{eOHk1(BzUTi?AW?$~ za($-ok4>57a$jk_DgpH{1^C$$(GFaBP|^gesS52}B5D2TTLpe(cerGsOOA$w<{J!I;TGLhUvH9wYA?rT;sh zfJtKg)YOCnT>i_+dq$Lu((av@bHLJpZtcUN+(Z`geB7rr05M$I)mD4~%H+~sUR=8a zfP3bvX^VVf-MLQIWzv7Y164n&9v*(74qZBD!0fNzNaPwn1-u0_8Ry*?e6R*(T6Q4@ z+^y=0j9;zqqJ&y;3Ab3c$JIBf!OQ@rNr^en@b|pla61O%*d?W<-QRo}85#SaVAjxZ zT}V)HvQ$eQ0Eo)Ky^D7@G4_lYLFoPH6#$2SPG(6^fT(C**4I`~!O)+wl3e$JB=nWH z_o2Thp-_i5{TG8hg;y zzdi+vSZh&{ zYe4LB$6$R)+q6duRccTMcT|;*y0qv5Ilq5H$m|~B& zakE5&3-5J-<>h)U5h^HnS_{s`t+)%+iN5Wr1*XQ9(%23*cYkrtw$|#GO`$VBq@HGu zIpW&tQdhPU1N}(=f!sTlZ+i*+l(AAX*hL3(J&?>zSt6qG>cI=n(YbM_*DFBsVE)rR zBbuPb*fPOlgSCS1g8{uZ;jXyeVg2{m5&ElnYfx?rZg!`6cU^_MGeF;v!;N9lD8gds zqI{0G%J~}oLnJ#^8|^&XgPtEoS;)rWBY9L%i0%+DH&EjzYaKN5V5XP2N-kf_f{SGU z%Q!1Vew77&UOHWWLp%(w&!Bi}4eAK%Q%;Mw+4E>!S$_u(Z(BgqNVZN3D0&(Hbp%YZ z1oGil78YK>#muy47#rl8nVGSvyF^kX5J?wdX!}~l^CvLqu37$;(+Rn?(04*3#!CvzQ@@ zPXE|ToC*KTPyI%+Cwgs_hU_hNxBFR0B!hYWX7yOqHr2)*)xedGF)T=|R{d!7$QdeK zj$LgQ{!#58@C{9QM%CE(9AZ}kKnR)$w7LR7A^I|B3J@URGqX}gL_KC=!1u-TVYjj-~fiH z@120{Q(LFP_5fhSp=RG*&*!De3xON3fqkk%r*K0#uj(@HSmh~Okch5m-VETPcVnoUPn<0U7r!DI;uXJo z?AjBdUjGwQ%BG|8)w81CRi;zl4J>hveNH5$?u^kF^IW4X;ixk>d4ELeVC*IPOQ*m_ z0Pvz;2m_pTHg)%zfb*cZE>#nA^lB*K@-TBFuO@{MSt6>wp}zFH<4R3 zB$2zy8_)%os=ql@ZttWphXd*w>(?(Qa{V$O+3>XJ%TR-~=3`QfZ}x^_GOBQ_-}DEKwN zkhbbLKOm=3n?m9!2%!Sls#mXncX#3zJbL`I{A|iqq86YmWJ9Vn8qZ}; zEP)Odq6xyzpd8DVj(pe*vi1$+`qAsg9`$K?&}XgJOPS=HwocDAgL7!h7k zt%Cod5Bb`6$ck*Qk`;+EE6vW->kn4y%b7c-+!@#M!LdU=9=i*p2Duh{xUDXqm{Hdw zZpZQBr>R^4jmcCDyVj=OEl|xDX>m78f4%WBbI!&*xnFCcU|EHxRAREw7FY=#T zt9VOWCU(Zgm4nz7kETq1y(K@>4*RvVOM>joqbs!RBnMCq4lh7arWBM&(5s?_FFU*BHHEMlLti>ti3fviQ&ac{?#4@js#ln%)d*HzmyNe&`Bqw-kx#uC$ZEwc;@PPQj zi-Eee%ygL9S_det1rA|x?z4ft{~4)d{L$gG3!y`n=m{0{09iS8C{_-%TDd`8UBZi6 zH~uPKI?U$0P({C5FN!|uBeV-T%I5SG^c0ik99^2BZOWnrm*goB10^kb8m-0LO0oOF zvNu&;Rs{btRBp};y=azCAA4n39`J&%&4D#v2yH7i$itdub<m*IvC3s6z%1 z-_`pobqLm7F?=l}Ey=s-==^Of;Eh>Vh8XwywlUR%+>FM+H!M?4EOt-8jmEq6aj5iF zGt(%KD*4QQ%d@?C*pufZ!|Mp@$*Z9{v==6JTF@evfi?4fWixd$kH|JM916~V$>h5v z7`4*ShR9U28qC`XPQ4$40iN>ODs+gWgeSONO;#pXv6xmb)Hq$k?~3>TII!dHgx^iAD;*$#pQE_%y zL;UKjP!1OzYz5@XRId_Hm{)RfB})RROpuF!ae2>&16Lw*TT8tym=y-T&sep2x03c{ zH5%>_;loFH6|BlJYMnCiV{-!CS~I%plY80n*|e^R)v8xIYrkZ~!@xCTW5u%<%*FIe zfh1F+eb(#S_%=Ei1=_9iBl`gqssY`6IiZ^`P{s@yA3bT-fSW1}Wxix;J=HZrLR|_vp*$QG_45Dz*3>8O)kAv`?3Znjq zG*Ee$O@cfwCl~^vfM`}UAQ+sgK)UF+wksnbe_E-Q3&gfcV`7r%`OQA@%MDL%r#IO~9y56AJ+!1*SQp^9#6);I zzUbCzGQj{w8Id;My6AQi-7 z_sIrrZxHX3XkR*i90;z!AvmYn4RrdsR#%Xh^!0UfdcJPo?_pbzb83BSWdCz(XkvyJ z9~0Tja=ZK3XZZVN8oJaXmo-7Fgwswa0{b#TNo4WmfGz3!dFCJU?Js1(`u~p5#sP9$ zqU1soE3+@}4DX~_a`n?a^vvfBk~2ZEf#B-Fl?}3E>!8VlAV`vamK$u02n2%wg1_$lwN$`sx^!&{Wjd>Ds4hkb0Sqlv)|YB zI-Wx9B22pFs@NhzmvsXM9wt7>&|W^yLVhE-ishZ6=4vmqGlO3$frOr@?iQ?*{F$CL zGYzXbxLqiga6r&2S8T0Q)~wv|4l!^hgb$_C)i%>@=Zl|O=*Ui_2nKaIs(kAoOtr;T z{k00@3%K+ZlzE+d&(In{jiBt4-=78~Vh^^byZ(XbwxMQYrW?5_+Ra*dgL?wVvumkw zeh@$hXw|=Z4j{kGZTZ2P!v7VjskiMC(>mG6KO?G6yV502QM$QSJ-4l79-*voQ;X#& z^%v#(9m6m?t=)V$6NK2wQV_)|%f0JB6qChBGg5D9X-(@o&A4bowdR5;i$wDRr2Th) z74MFRoth>=5DatbZ@c%p`h$!-&O;-lwUIXUuDKuDOyojzWLrYg_19fTQ8n$+uEs=!pbt(~%_w-Ss^` z58wYnzzyj9o}Ce8K4%5TtS+=k9F7+3Ql!RTz~24wqmrpy_&uT;Yb)!_@`t1)c@4au znmZaA^bQayGvH(Fjc(Y-k3EfzjYB7@*M$p}+tV%ca_>?E^Ff^6>hPd6#>}}=&JEoXKcdNe4mO%eQ#;UROt>ODgsJ(j&r(~XR$uA{Ni)2 zAvZxTMkRHsYhIC!4lO84{)Lelr~nF~S=i6Dl01{_TCG(YlGY6 z+O}`??zRO!EVhs2hXU`}m5yGJUAV;SQ8^`FVfS%9$TO z3Nk$2iVZYHVs-y?HOTrHw+cx!BN zXCjTdW|J|o42Z6mGVcJU|4Z4$ZqPSDC2_Z*D;)!cNSQdP(ze_>|Ke8oU~g_PLZKNE z%ueN(;JW=)EAD&U?F^E?qQ|F!)Z1TOkA3{p1$PJlXb;6vM!&Hlr(_IYf|5wZ6}r6C zAtI#%7vJ{XjnE$D;md^lvh%VWO&kP?Q=k>jUxUPDdRC0m%aGQIzN-^tr4dbS&o7xl zt5?Fq*1A8;-|%SPafSMF20GPgUImQ5CeF-R;Qh89wSqr4q~RpABy+^jCRrLaH{MLs ze;P+tWjF#Yg2U-a_kA^0DwOUR@QVej?Ma}9IwUM+=!$u%fJYkO@XH?scoQWs zs6DA?r(cBGsvyT@CZdIoCCK@3_AhX&1ipXyvV6M%;~%!Vg^makk184X&wQxeJXyL1 z73Z>i^|0(l0ii_T1PDI?pj(AYrQAj(Y!pa}pft!B%7J zOYd1;*h-Y~N(O^|6CVHV-Cu+?W58VmN&IwcaC>?{V%E=wHn>QmWT8C3X>HZx%spvD zJtEKJVaG?tU&X%wcpG`?1v@3>S#d}WG#5;{q30p$48xr%v;A<^Q7yynCMtRW@!C0f z73Wd$CAz}RCywxi>Cd@hEFooFdByo%8}19mkjXRUK|nvUQZ49t+w-$%ueWxZ`bdxP ziC4>Irfotute9gl5bS$wjk>R19+57+J^>PPuQ~>RK-f3IPbW$*_!6CWNC%yI=z{wD z=VD7Ui7E=hAv{^EGxwASuvcb1eHN-5J?wtTPLgfGB2bIIpI6x!hz3`>PM&C@CE9x- z6iLNe_nVHj`O|?zUL~Cm0@7?RPwYB_z!e@s@B)nF9W?9 z_8!SRip$E%Dl~BP^vqj)DgnZZCdi+@cSI;`sNaDWAG8Dk-qR^^ou+}hMg#{o0c?AA zr{D9KzlaB~+o3s_Obhp%`?D=y z#nf^sB=^Dospt5%-n9UV%YVr?oiPq+*npwvi4L>1q3B|34jb(9 z#!{C0^1_XnlqHZc?C2jPpQk0Q9{YN8{pNp4JlSO`Dk>@gQ)O_<_=~)}{G-v8xTm0} z9nU_pcJeOhijlt6X`{CsT$bU3$W*LIRTsnH%0Mbz3E*loCi8ys)ANr(bA{5#_r1o# zL=vD!LS*}^w8Cj*&C32$c|^Bw^EANZLTUL;zTeaqSKo$2B^b{toWeJ_o-3JFOj&vo zk1zKd{RD;uDzPN{y6&$)EsX%+`XK(AtrBp$AJy-Y#+kroqS6m{t%F`+VG@|bOi1juB7$7>(D)-*eC#!?^kduQ$+15>~G_?Gp?+T2XefGguu!vG0n$>_}Zus`;!Juhto#|?z_4Ta2MldRr}6$QWeZ(`xJ+nx-`uS%A|00u}2ji`K8w};8?RDk|iPHv{G+LB!h@d=_FR{v6U|H)qM#LQuf zc2%Zn%eo*KRa?~LyTNzO3!<Dg{$&612Wv>kqQ9 zA+#EZ0(fPWx>htl#bw+z?MW4~T?Zd+=pi-&lxBg(nEedezRhI7mGu@l#kQsJKV_uq ziq2m)8>K>zTY@Z@;_c$9O!DqI4ZK7|R{{y1hvFJoVYJs6L>vo@b1D6U7O!!kvxV z)X0F#_R?4ElG@UFsGJNG9!m8b92}~l!bd#CTFUg)jS{qbCnd~%tq0W@Nb|w$y=MT& z`~LlVKYgpuhdWgDh*mYK0`~ak->`1Zqf>TzrwneYhCaF51MOF*_EsIPar=~6! znAW(FjAkvKFnk3439Pz!vxc}aYQPe^@-xr#ZiI(@+>&nVxwL`tH>T4ML2!0hcX?2{ z_z3yOG5J|*E(Y!#8;T?DjqnT?p+Bh;n%duVEMECJJ?ql!$~P|+;$zw81f5c%K@_MF zyK@dcm`DG%tgI|1O7gnCVCpNv#KeT7Sbv6n(JRjqV|Zp*AgMDudlXXP#Y`8D_te$b zC*WLwJfb9hTCCe_Idj0jE5|z9Z_pvjZVk$Kn?d)8s8}{Fz;nCW1Oz57o*#SZX4u^4 za@V0Vug_Kea!Rq^Ov}E{7Bz*RargANw`cmzq4b5O(n8lnG=d9%pl-yE7xf5=h#)It zdn%c(4w=l(g;=XdjWg11hf%aaCMlZvN$F=Mc@o$iDo_vwO6Mi1$cJ;jE5AYtD*D^K z0kE<=>xs~%wRnoIP{rlYWmIhYQqPOmC4TE+eK4}eFtcR6q)q}JA z+q`;ma>rYx`l7ETo?xV^2{3d_Dj;tF*j)T-%q_W^_GvG7sfaFp*z|VQ4+^fGIo7I7 z&-`)4_mCfXre3Xi9wE$J@e_&Pw;Q=XY)6Y$Xy=?jJV`IXgdkS|AIj+&3gXu+*)$Fkc%t|wxO=DRDiX@MAXsR)3a6a@O z%ptQey@S@yi~*-+8~w0TNye_@`Ft~J?s-P%n`geBPs6DLM;PV>YeXtX{deb5ZZdvR z6Qw-?>(y|!=Cva`^Y+CAGqGLU;Y2l-F>XdrC&l3TzQI(2Fk4mGD1W6r${S&XGm&`-N=?8DfVr;?Ez|X!Hup|sJ#!SIQ)Ax zLOK4swRS;~bKMrg5v~KK%%YbOlpUyCbN9)kSM9W%yLwc*a}svfqR~}^XyF#JdSwY; z6)E+4vYa-yGsLVnCDd1K%~>=vx+m7kSHzqBv&2k@9HswyuSAY}=Was@5V_P$?zw?X zjNa~r{O`R0prCRQ$~2@w-tl)ZQ!INObcoehy&Cgul^0#vE7j+uo!mvwx=38h<@9A= z60MjJuh0vz-bFc<4BXXTeqE+px`J-)KDZO0Bi=}&dVsRtZBmdg3sW^~X*S+TR8uZk z&h&8)$xdtH_Ljjp>#hgGrQ=0!tqXLEqS8DNYTj1%o(JPV)ZrNv^bHotaqBCaTy~aB zda>G)NA0xoaF2G4O)_5I6<3%&^rk?+L5EhvMt&2zmxdz`YPLJ!$m-Lto*XKS-EN)I z(<;tJPumNQ7NTR+a^q-?Lrltl+z$GmsfW|H!5Q2Ebj- zAvWW)PefWqJAH7h>oBU)F7u_kFfi+R+ z6gM;hTbpSbGq1aj&n45ZZzt$Qy~%cFgrySkGd0xSYm|^2RIGZTgTyn`*>hx>bMVx-)=jGwy+E+8Lza=9}Uno?U@CcMB@ zmk%87E~zDr|IlkvpHMx~dm}`+${ub!7aJY@ZhAXTPQQ6qFZ|-Ahjv=;4{%NHKYEi8 zOpHjIDk0x^>P@<|(8T+;vZS!U@kKKS%+j~*1Wrr8rB7-BvAm)&2Rd=onrIW)P7J1v<1ZLLM`XEG=yGQm{Jgl|uJY zt-_2$AK%J;I(#?$zBTvwY0O-MJ)PvIcIP1jC_MmRL+{+%;*2%$iQmqyRcAE;Rc6=b#gkDF4&M}{2FG2_kJ zY!C~hY@nBjtwWEHRBc!C6S{M`{->8iQ)r8*F2xlv_fra1a2%@p8k`^8Kov|u6}0%S zsNIHPV2X6p_Ih2o->zF1LeX7Ag{b{ zoorkR5Npy~!Y4H&@?mcjb0B|n`w$3W5!GH2yf7N8Z*OGcpq=9Mb*Dw4ZSRM4FOhcf z&oQ2Eb(wvGDfp~~JYL$v9#wzxO~>4C-ihe=iQcQE>mlq|pFXl8smI!<)xTC*6Len* zk#TXa?b@!XDF@DENo~DjP||Sa&dQ);v|%q^-G}odJ76Dx$HC?cLS3?suw&@KO@R&m z@+8a~lxqLyoP1obLDRht_ACwN5C97n^UOO`87+vw;ls#z^N;h*Ae0@k%cC)g zW#p3%;8HD57a7mG%qgllwNOELZnVtmuM`^S%Mz7FV5EA{IVoPz=SiB}^=5Yv?vDB{ z8wrkB7BVqdAR@6yxrv)PxMbSeQ{m_MIWkuMbe?Fa7U{|&&2PN<*<8l_E=(05f}6~} zp-aoIYjE(@G%7=K>t1?QaOnazWvuXbbNc|c$T&P-ot}ZsmvwPTQCFquaCzB)bn_K% z`k`nG$(X_?kry%#ZGDGwd?p#5q|BY37`9rBt5S?#28yJ{v6fr6*$735BS#x~s;(XT zo_V`_R`DaeU2cNp{9DdJHPZ8hgK?{>46kD6^f@(kr=qB4bBUu(NB2ItsZ}0J8LvA- z6iLVieNk_^prUmJ1>UKo@k1*r^+PeSF`fo$ z7i`C#X{jXdo8_jmK2~bePAg7Of3d8mV%8vT9=Fm+wj=Hlc~i8=JrzY1a#d{Hg0voea#({wfyS-Cel^vi& zSBU%I7X)CZpetTZID`WO=I5`J+;e(BF-_;F2cv!cNQ=$t@;(UkRB@*pko20+RW>c6 zVyzfgmvxo^0!3&}{rFY60J`%!%Oo3G54v(`)Mf}s35qLiY0&i85Y>-CnI+e_PS`9?Zte&l z9r!#EHEAFk$wKDXfp`UaQPc<#c&3C7GUS4|z2osH_itkBC=rcQYrxbdRMmgB=Cqvq zH43YS1y_1`^(4AtFehXVMWwBhPbUmk^)Id8M=dc1gRX%WD|!rgz4hL7m9{Lm*lD>e zi)?$@8(BL@iz^o97|3o`{~Qdyh?Pa8Uc-|uan{n}$qDBDYq{jc1A_T$3v!O>>1VW6jbN-i%?p(J7-2Vqf?T{4 z=t0od>M|UnIBcLcXPOVBNmf0vupkqQIQ4YSnKGYf96 zoei2L53YUX_XcpPp9s=3(D%rpCPmCnEQ zQkieNmmlI1QI$%RXpbGSzx0klQ5f%-+049Jdg*)Ro0$Z4|2p>z!t~4wH{eHZ8}Nup z7q%Y?Zod#YIcP-dLDWz{Pn?DJ^L#g5kNfAD*Sso@YO>1ZN6GApw&H7-KF(2VH=W{U z0v9QXctcXGK`C+>d{-GrOG`@_6M3rFr=<7haw3l0=78JRQ%vv4Fi1FHpWwVhxKOC_ z#vb5$C&elKlYA9=#DbcjIt!-W+F5x5`?FBc>@d7BKQ@X})W&Bk97l-~9_qiL%HgZ_cQ%g>*(KN4yM|RsG!EYk4yq+-#LP%gOw0`E_tatu#W@ur=F*6e7^K99w?GIR}^DE>P zLm?xCbwT*jTr~T%E>$eJ?oebqh%@(tfi_ps+1ew0B#k%Oet{}+Lzh z`XXTFs8&k72b$XJD3*CgvEr@1kZ6Anmx+7SR&$0#R*A**MOMRd6@(ezt67F6?F;SRv-oS^Dyj3gCLdnQaL zJ=)#f_2Wd^>#p)6w+1TtVbf}Bb}j-_ZrE`SR?9U1aLY-*^Rh+#@xt2Fs3vU{$ML$@ z(i2MT#Oh>}-{%9&3%8&=>lE)nM<~xK=Nh2qupQlYq8g-Mzt=3(wSnf~Kaba$8sJ#j z7*m5_>=^g8A!Hg}L8N4A16c8h>3ypPbCsHdV1-eHmS~7OL{%aBUiV53L&YeoyoO=v zcSp6Ef773JvEyOSxl&@rwB6n-N77B0&mYedefkI~ z_SDo=LikbbXMy`>7o|Uz0hDflbZ2YZQTjvlOhPI5(r$Bqxccb)WYTK4 zd&J{I$gIrVFvpxyaC>S@u-;EppQwX>OhONhgsP znR`q^SeN}8JD)e3tJuD9?{$?2Edo(-Mw0gxm3Vd|eT2SP1_U>?4w z^E|2pE%ozeS^CExg084ifk3KSQ>_>aKR&Q5Z|j@Fsl{bM?ffXP+M5Q%xd6x0x10Es zOP~r7g*vfm&FQqe0q!#@+jD@pcn>}6Y5p0KQB9f71%{ifdTp@gyN(I+O7xb~lc(Jo zrZZ!akLLImT;*exaT*fBxo*+H(w?1WDz{vD3#}rYRK_|<4qI;xXe9TH+3%{1$tx+I zpjjQ)YC#1>gD>cCO*v($(K+ZI*>)_Mjjn38yn4tGb`<2KzsJO**`Srt&nfX$fHDU= zyLdgZy-+sLIM5m&zGmof{QGf-i-!RmAnm!FCPAp;1s`TW&rL^vIpBXN;lzP$G8^y! zgysiB4PNfX|6}*T#k0I{FSfjFEQupKh&0jvia0b=^=-7obdDXP$-ms~pyfHAhK;QZ zP8|l)>0d;&oRGh|@XwEEKi`p7=7oBp8dTr&j3w+ciEySyH0n)x6>syol`f4ye1T)J z-Ko{8kkg(uzq9D@3@F`rxJkMJpkO^M%H1@D=T;D_fjP`_W&D`vO^rl7k)XZ)8eoCM zD&c9#-o=N`q7e>nAx-I10dt^pYt*vh9;>;(;w7E+=Z7-J9{|6j>$17=Axgk-;3vRH zWX?(&6tvPafg5S6psm+OKur+WpXJi+-#<1&wPR$is*L ziJ{Z+O%er}ZuGD?dT`=41!tA|Ro;yD;Ics=+UB=$*q_wrnM3B1wQeu zm*^XJS0AipI(C+UE ztG1#S4Vhv>t}e`bWHW1o%%#Sb=F6I0>zw1;07BPy_yS~i6rO(=8h(I%A#2U}%j8y7 ze6|~imG=er2<5blWeb2MR)$qYK}mL6#*dVb1HJNo@o~09V<^%7y{*Q-ovRh*DhR~J z(Yd7~)qd(vq0gU)J*oB`3OQ-(#YRN@#rPoIu2#x{f4rWjF%Qga{Abb2nC=#e;LEjI zG}YI(+_MFg12iKU*+UVBT=7EIKso*UBK{@~T*W!**P?U|u!u*@3vh5(5fN)+pjQP% z^B?WneinRLD+5KsKD)X%5Df?-k~?e$Qst~HT$~aqQ0bq7*x_#Xtm9kgtn9u$l2`V4 ze53cO5%sS#TelSHe>^jFy68?K84*x#v-Hyhg>lgjK-{u`E7(g8#L9tkiF8^z>mQ|WyQYWlv@}>o!#K9b6?~`P_U&SX>>29*i*g5TRDW}0Yn4nosmuPtLC>J! z#Otx3XEsSWOYK3VE9eS*T)dA#B4wpR^=s&)?cy%x``TOVwZu(eb+-o^7%{tGfwSJ# z;xaJTJz;sayn%=!W~#_Rr4!;)U9f&*+1e_mGw)lNsr$C3F5eYDNF(o5m|uO_jk+}_ znX}Bo12gjQSb4dKiYi%(mx_;cQxdv8DJhRxJ z&(sIcRKhHsyOlRfXY8$5i+Ud>g?hofce)dMvu{>3rf-f{Yzydy)Ln#)6)oGn@nGm3 z-`5|``EMScXN7)oE#Y(L@i1%f?lenitQ*6|h|opQZgbMpJLq~|yb9k&UlE`>aF-uc z(80TNSt`;jBSJYJ$3N#LyV1{PY_}(FO&tbbDUYKwUTNUEL!i9A7dWFL%CYc-K-v1+ z^)R>`v?h_UpMF^rRWNy{h$!Ilc6|}Mb9KwC^|ru^k#Kz&*PqW!1<#DH4#_;xy%Z*; zDrk?tSk0$(7#357em@mNJ#!hIdsNlEPRqw*N@LINEtmypaguhb{#C}X?Ss8PDfW|dTg!f~-+GGB4qe9j&U@Vd+*Yn}F=&;p-u&m2;DN>Yldv?(HiaPK z>$?MRiQR_#FfXjB6#*tOFhA`-wxI>sAl9pbdxt`}xDd>nYoPKYU2GOt`i(8MDE$GA zjy+Q$)$M%If7jq{fzy+h z3Z|pm@)PfZ)98k6M$+fJ3gEtV>GFuVNwa_H6&0H*QAFu6xIal=liZrf?8hk2aMk$F zHN)sY=kskkhmiGK(W(N3t@k#tjK75~<-i~FF<@>o`xe=a+Nr%>z6rv!Rf3Idep){#74lzSCeR=1KP% zG1APw*4+Zvj7cKOdR4SWY0uG|t@c_fwK{C@?*B*Gmxn{$e*c%HNR~m!lC4q+MM(CY zY$=hQLd4j2#!|NIqGTsY8-_3#Ms`BBVi-)>mqE6%jNx}r&+}Bz=eu0L??0}~b*cBg zoaJ@Sd7b-+FyCKpWWamycNqYMIqPKeP(kn8<`SbEWA!&ISM`KIc}_^w4j((lr7DK? z$S`Qm?e)Ie7$mckMlYN;KP*Nrx%dNqsh8@{rCd`5vNY-Xph=B26kg)sN*8*U`p5W* z&g6a`F#V~Lnh?AfS-*NW?O@8sZn?EqYOCS4$6QhHWsjj*f&-?^gWI}Z-X`vf~n^iZwJ7p&{tG^$G8d&_+0 zelTIk4!693@_CD4@{fmeUw@nKNk#bTN>@Z_EuUggI?sTQnbvg3SN=E~5qyC$h+bV9 zPt9;HI;64*f+rf-=EYt7=t{o4ZO%v1#eXDw>Zj?=mT>ZfP!ZCP%rcyN28?{E%z0X} z+YEDW;UYMj+5Lz|ZM$suy`h(p+(h?-n#TepDLU~VQUsMeJj{jjXbPTi%;+9meY&*F zQ{=*Ym~6)8l)(q&wLCpx~O;k zk-`aznu|D^dij8v6#^2!1@-;HiSEO3xl<8t%WQu4;=x6Jc*}RDG3Z3f(M1I`w~f+q ziU`O*Iz`^0qEK79_$G8)|8XKE{ko(}`f9+kP(f$qUa4x#F`r2JtyOiRL~7r@40Oo5 zN)L@#63JhJU80qTw95JH2}r2XI6wRF?bUZ>jrCt5t{_NSE$3M%dXA3)FHZZJ_r^tl z6Yl!mWT$w`)9YnzIl7t?5L_JT{$Q+WrX5jlOgY#E7J6UJ=(<`M@h03(nAuuhtj6pl z1n=>ke?5xvdAwOrPjl7YDOJh6!WXJ^*nkx-kJa4@O01;i2b(uZ_2zwu?v@j~a2{-F zFmBU`(D7Lgm5)$RXdY44-%*#ZvU%?-^wLLYNUA5Od#ujZ&!1A5?%kp_MC7L%F&V7}YDhnEDk9x!EVkR~)`AK(mUaW zt`&;SUh6rrez-^<6|aCESviiULcyAf&3=L*S|*S>m@Tq#KYB%d5*DBytYO}t3akNf z_sPf^WV_|wf(jo8G%^M*f?Px7JZ8CY+*+izCy4)g&PUldP-v|rlh7du-kHtIg=qmUF; z<{{*0K~KMrTe6F)Yq$0DcHA)npH+;)JJuUfxkAPJWBvuFhC_p`#=?r-8>$6y+;K9( zb7fu=GL5K&xD=74o<=py_r~dY?jB)=%_T9`Hq|OiG|J<2wwCq9<1E|(nz~0D!=cgv z7N?ImGaUYjYX4HTP-cMGZhh?6tgz0Xg#1^@wY3iJ>6E`DHj7=lw>M0K6`#~<-5t`A z0rqe3H4jeGQHBA(c#=Mh=wEfqF@QP>gD1}3KYER4xkuG=$)DkJ;L_tsn&!=My6yH& zSs^AV*)^fPWUBrpa zmW+_9bp&$c%(xK0XB%qDtL_kb%`2^6WT!mDxqd@0Y_=+Q$+c7U&Yd3eXE9%bm$A;( z2MA*Fno{lY=C7E+tFnVN^kqMkSwa|oX)8c7iIKpgsQHh;`&4;wj_jGrxpx3aZdrSI zg~~uNH>PoaPe8JJ{lN1xXW*jcE>#W;c*^C)eRC6Hn0O9=6EcT%H>n78iRmH`u>V8< z?0;LONgtxOd7nz`sR9EII)-lY%o#@@_s{I!D~p1no>QiZ8j{h5r_Hl6dkA&qXI5D>c6?kKz+jA&Q zISe)&F5-n|sOeQkbPC8Iy{k6#chi~8+yYWYdy)67rQ$}&j$&Nm|8NB@B>2!iAnxRJ znTqg?LY<0P55NcCS1DAXWz^+5XuYP%Vf)B^R7VLLWDCQ{fX@)WN%BM_v1}!`u0OT> zWki?kLy|92@iC&3HJ^{|0mQ_ttJ8Tm@!PQ?HyScCYx(lPtpO^O6z>@RCFLPEA~giR zr9yM+y(96;bSK@xifWDzoYz^sy0Qsz(b7RzE&E6WW$OL(@Z(LNoSR@+vP^xGZ@m$2 zFXDbJJ2wt!mRNi`$%D%A>lS|JBx7h-3)vD*!|d$^iZr0_e5hZ|8l_qGj#Eethe0+F zK|5M?T!cw2IZSk(GC2B6y#MG|f<6SllV#Ym{n}%W(k$GZK4ssm?I?E zsgL>Y@JaZCj`6O(?J3#un(-@po^pQz5gscLTbMGQPXJnC{M$B2%lCk$^NdGF>G6zC zV>Mqn!Ar8S2?+!-*P~=7Aodw>`D%Zeq}Zy-`t5Z~x|eA?c**W%FM9fBNg*;|3;7?y zvF}$w9C}|yO%XloVv$T%eovh8`OaHO$8e!bJbW!%~+jkYkvRDyta*3s? z5HW5u(SZ;5{e@UE{2Zqk<#ZShTQmnyyGhTOTVn-!kzNvtXrH@7c2jS_f<2em8?6oyr46GqFP}I`}O|Q9K zTs0e>FM1{3a9nS+zN=kwI)ai&TVw5zyd25CR~Eew+zR{UJy@QkBBUrN*lwvN59WGu zr?u0_h$9a7s@_L#(6+TrhXu16wE52R*T~gbhTY?|T9OMZi@Y@_oy0xEp2vcp1)8^nSt z6T%ceoPm?Jot_EMD`gq`;{hefbgZj2*~h&XHI3TM=c2}R?+ zkPEq6jyV8CGXur5W}Y+ypU38EGyeeOBy=??*6SInA2WLrX&>0CmYG{ij2lohJgs#V z?#!oeFa#A;Mk9!EV!lhVQif-6ZI5@$#4Nq3+w~t_ioNH%`!JSmg*@2r<6Yd9>Z@abM}to^E+cR_BHhagr}rRLzSdJeiu%0u!@z3<*Y zLq*AOX>eqGWfN>&#pfng%5gHYDQj?69$E6+_E4 zM_f0ES`sxr+M?IaVE4LBV<0Rx(ZY1ZjjW(xo2}ZENt(5|E0(Utn%5wGE%_lQHlY@p zf=j7cR1zBO!!XE}!(jyOC2C}Cqcl#uq%Rzgiwye{&5Otgp?BU)&;lXdUG4b8q|cNhfSOOu($C#rp{ml$27*_PQ@?Cq zu@zz+bKEIoG+*MQib3kW4Rx_mNaEAs8s|427e-2huZ~o&L{zz1wV|}$1Pp1j__$~z z$Mf}>@B&6cE7g-O3sro;HQA6HEeW~Ds;7p5oBz6gJnnkYNc^Yy z$?0ERCLy#~5N z1Ig-&hq4{jP~nWuI}U7`vVW=W@T%ZqyN#Q%&3S}2Sw0WW8xw}3v(~5M z9^@yDZEO|Gqt9esGBzVKh<+cYFceO#UaXf0#&>P)UZh{%_W0n_WCVb^v^6OPq4*Vp zc>e8jKfnHZ?NenUcs`;~09N_=6+*otV zVArB^m@m0Gb-nHdw9rhCL~qs;qt)llmqAjDR_4*J-0U9$$?yYYnzxcpGM3PCWO=59 z6O~u$?oA6>7ff?=;iai?WnFAO2?8qwXwUjeAyF z`D>#6u%d<9`4w|x&gU0}V=hh`D&}@JqM~*==(xm4NttuO_(q@Z?I)%CUIV%$iRAkQ z{qmRoQZr|@qQRJ<{H%I`d*1sq+fHU2C!=q?m8FcHRVaOAo;1Fc!BR49G5R842<4ms zUnxtHiu!;>TTji=EXTX&q$)xq3)6h;Co>-<+#dApR!HT|3D9Qe$a?1SJK=Vi${u9z z($%6pfYWixzlcM=OM)H2zNR9GuJSQmVysj_lIc2YZ_$d^UE&e0mtOrgS(Kv(E2iyw zF~+vwA1&ju8(?H(2{qPcF=gb$Tn9iMMYXPJy^oOWZV4t9_-)M|INJrS6_XNE#Hj#D znFn;s=r8ro6CnBYL5=d)1(zHDg{ivE4PGO}(04}+S#r(!v!^bSr?u-sUzHHyS_N5kMi8-Mrt`W7N-(%ZeL6Q11 z+IqNO#N65p+wU14@b*owPLud7g_dLWiVZL4sw#f7!s_dBx;>gz0 zuK-5g{Spp?szk4zTW%T6Z8;DPgAHYwWoF1Cbe6p|J4~gNTr_FlS*HU0jTi8Xj`+bmT>^IYfVCz2erEVSA;>7188(&oUxY ziEq;UH>~;HpwuKKKL0C|*e79~gLT-H5y-cAr^nefkyWg9vE?ia#$1Md`yp;3HLFjv zv0}<=X|bw0w(455U`Ur6`dcTfDE-||*92oHpZT5v`E2nrX?fwOT#@XFBJNWkcmZu`=*z;lI0%>K?^6fubHVM;jMe^8zm*SJ45n|jj6DEMZ5 z1);9;Jqu9v)Mn|8Q^_rPFExf($aGlon8woA-h4P#)w1XAAYJ?Yj=^~mWqAmu?k*6+^xvI8oW7~5F0g^W6n%HbRIfYxgn_|EtKKI zFXt|tb0JZR(f9{XCe<|K^PO)`(z3bsVvjTiRga$M`jzMPOd|z4Ic^9_G) zwzIg!F$y+A!T9sWDlv=9@1=sLFjruP;{!f6M{&%GK(1ewd zR5i%X*ayLP68)(!e$>q$J689#vcYT3%~ z$eSZPVqClUP-EiGMjZ(CjCVV2+*lq=IgmH~1`ulv0DCW? z#j8vgOgia2S6Qr-4I65xtmQi#L!p-a`n#gR>x1#TAZNe3=al_E)+s0qru70f31XOC z6SeN!jN6mk2X}0}o(_e>Ev43)k3s$$!+Gnc;gpyvx=?k#ejsq2e);~231w=lk`)D2 zm4`uPr>Nf96_LZgv;|mx2apsgJmW20*8|^g^1<6)EJZu<&urulI9C!a|gF_D%!&GmJ8%H`8ax$v;!nBTQIYKlgxANvt* zd?$W;Vg)vEHJ5bB-=yz1$*9P1&ly;$yv}`(fp6uhcZGT})v-%FJa`DK) z%ZZnx&ndx$mC%*}YgN^ts#o$D71UaRZG{G}mrIHJRQt>aeOBOGzw~5J)%A({+v7lN z`{CQ8vvT*rc*p@8UZ^_t72C$Di?vh)+oWzo;l>~dXWMBdv`CCor8@-w!L2jn-D8rv zt;Ij^S(BXhF-gVcF3WIjP>@+u_y#v!O*;1bfO%qpBCr*P8t5EYpW@4=_q=e4&)|mK z#<;ZI!OpP7o00B2;D8sS9Ni%gy&#RKakqNA)tesHgwIto{*xO%%$to=8NBrT=kuv_ zD}`=z0Z38s{bQILyUCa?CWU&k>>Q}Dt4f$wQxS%%o<60quD@6|{7Dtv(<W+jl?slssSu%Jae+3(peZ^@sEXgy_Q0W1Ho!ISRR@C+wii{CkCMglfc#68^_(Qgy(PSWfWl-P zTSO2)1Dz)QH5y^2&X9sq@_kz4oW6)0Qz!zXcBMjXfGA`n@ zL_mIc^vL}&-{VB6?lYzohxs4E>uU$j|xb3)$Q%Ce;}IA@!53>`(1WE{iXU|{RJS3 zCk2+ZYDL<0Va62SnKsYlIP%bO97PC+!BRDdL)z>^@<+-+iG+&KBG!G2uQBM9f6J^Y zS|r;cn-PLv@9oS+(1P{FV;zRuo@efWyv3VoUE$0m>l-6|~-quh}4? zMBIOG@9>xLzFnY%E{XQMBTGfF&U||vc!Cr2;hW{E=v2dXY3O&f+ikAUio*Dem;*Ox zZX*rG8!yv9JIX^w#$Zoz7#oP5B3fR$&wXIXKcd0^%WfT_82L$l@D(>l_n?K!ZYwBI z?8FR}r1|8_bEx#PBKDHEgv8u+qXaHpSm8=;U7gf(k_H==bR7LV)AM&pC10lz#V|q2 z+;_Yl+6AgtkEN7r`QrmBqjP`o*TzP_5D|# zUlE>$yy#^Ib@QP^vU%6Th!j`FN5QTS`zt-AB2c?tul*`vZF%E|bW!ushcE6?;~vY@ za}mGwf2`wQlsprJg7T09V5U$&VfSLoP)4%Gx|7u?Jvl?-FG|sG6LStoNnX?hQ|yzE zY6S#nVIv{+hIiV#j~XHxuzu#;HZUOr{eTq z;rei}hf^?L8~;Sm`d9MZ1PGMF<1tCZ}j+E(r&EFS*1dW1#HTlb6GW=2i_1jimQ87*o=fXaotM}1nXI-Px*PsQk)G;Lc z2H<9pWwJX1&eK0ve`fpv5-ws7jPeAzQlBhYiFut=r`13k6q{a2I@6CIS18YBj*@@ z!j2KOZzB5>B6lDBK4u#ggi^sSWU{Zh=b&1VA~P z>9$aAV-XSsys<02bAVR%6T60e7uR~0&cq?faneI6fT}$}aHWJp*a_ocqy0aelQ}r2 zI46d7)sU@tF6-)3JfcHNK!aFt2FHK~<%(0(@Zo4&n~8%m-bIeDqdo%j&Wu?G6_V%^ z;rE!BhS|v094L31A5sig3rSavn<0R{{zHZKNi<;BKSi#nb|6+?z^@C`kZIOiTbl`D_3+Lt@Ba8 z_dPSR!?EPQIg5~O15jL%|ERp*tk$jjy{ubcNb|OA zQem9HkMhfhBB*|c)uB8NFgoiO$hcoh5_)Yfkl6o1pJW`MP|EzOJGX_yF@iBnV@h>HHs=pV&?cdCKN3ySe z=H)Pj1=4@mDPVF#fnQ+d;Gq;@8*${Pfc-L-3RK{<7_MJ-U|_qK%Rm|W1hB+}C}f=a zw~gv|pPuC4Fn#`5kjg+CT-Dug%5Rm?++?pOFjRyS=tL6fZ<}y(5tw5Y<45rpRHx?_32t(Wmyu&Rs- z{L8`qlclDLJ=u^%OD0A2W4xs)CgaL@jn_LVzcrh{BX@ak@Pe-&vp#AN4(C4frtvg5 zfkwL5$E@WK-K5qe(X@oY*MESLP!dquyd;-mq@uUGrQeekFQi#|P#he)0r`YQRR|GpuP8I5wNPU^%T*jf5tehVtIROtn`BQ`G8r@*J zMi&?rCQt6ea{~g_6s>U7@DZGw>g@{~u%=MD_eZSd84MaaK=qZhrW2$xmD_rKy#t`f zoUh!H^p>@4m8&?1A3vx58MdciLYUkdHNAS|WWr8{WH&&3X=qR#Ozp^Xg>#)x+^XOw z*OdG%EaX3NEb|`>)hFM(dwRAQW8>n^2uul6TsRF(J})lhEd!pM=k{}ukXJ$*TdDVz z@a5gDtj49VxP6TvS(`d~xw~hVEe8n}b#ZzgnSKXPr0@*|p=B+OjW!0$#kc7xR+{M` z_=4aOtw*sRHtyX?4C0O(*&X@XNe+Fwx3<+a;`NyG3RXNOHJ$0a+?MNVtM~^{SR~q^ z*s8O!>@d;0DGz&^BH;BP8*(l$x8x6dPe}sERLuVe_WA}$iJ!UmavQ=6zmJcVVyEtO z_LX3Cn085N1bnR+PUn?&`Ldwo;kww%}|IxTN9KrHTP?)LUFz3s_d7CEi)Nq`I= zW0|GF+du81Z#bp`#`t#Q zZ@PxVh6|Rzeh*%|7<@V1$kndwWIdTk=d){uLC=ovVunSIu`9miI9(LFL zrm5}GY8mO}LQWg&5DNo_Pg+;)dl*e$gwqM!!r_NFF@eIT=xvh1Ic#{tFTUpam!1j& zagUw)uN-6$N&l}bb7@tD(M~``3(VEy`}8S(LI0QuIw#s28m&sV2QB0ZU^bipEm@T}cq?IUGv7g|xB4u%FZ3T`p9Y-E{YJav|97dMrK)NyU&__vtlUC+mp7tt4_UrT zsdQBy-m+Fv#N@~4gO)+RXZ5) zf@EBGXd8ogUO!Cc1ug$66W8<=a_>&*?p+#0aBdJt%(i}#To`xp9N zV*oZ#C`U=Q*e=rIAsW_X;KuHQ9AEiQ@pUSux9vhpY2c ze*g-o#mgImlB1jJ&!*xn1L)Ykj?FI%aN?9N1@+X;d}12FKl!7seuzSpWV55_e%frW zCkpK^RUllmb%GE1Y)P>;Ko4uD3^^M2FDZQ;S4WpT+k%fU;3FXyX5|`#q|DA&U?}h^ zFIM|BWW1Zcyq(LKVai|C@eslZJnk0eulDx2jili#zau<<@FNT6PDR(mLZ_j~E8*E5 zPXt7VxN@V1E};r5cJaZUT&NcEiT+>=Mx z4^B^r0!jJP;3psb?AN)bslZWUt8

>NrwYPR{e~B(NA6;vfGm{{E|v0Wi>wR4VEq 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≷s&X7QrrD`X~ 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 Op{c5;Qlb27$o~Ob0#^P2 literal 0 HcmV?d00001 diff --git a/docs/reference/query-languages/images/elasticsearch-reference-source-command.svg b/docs/reference/query-languages/images/elasticsearch-reference-source-command.svg new file mode 100644 index 0000000000000..ebdb6af6785d8 --- /dev/null +++ b/docs/reference/query-languages/images/elasticsearch-reference-source-command.svg @@ -0,0 +1,109 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/reference/query-languages/toc.yml b/docs/reference/query-languages/toc.yml index a7f933b46139f..ff9ea4a7ddafd 100644 --- a/docs/reference/query-languages/toc.yml +++ b/docs/reference/query-languages/toc.yml @@ -85,6 +85,8 @@ toc: - file: query-dsl/regexp-syntax.md - file: esql.md children: + - file: esql/esql-getting-started.md + - file: esql/esql-rest.md - file: esql/esql-syntax-reference.md children: - file: esql/esql-syntax.md @@ -128,6 +130,10 @@ toc: - file: esql/functions-operators/type-conversion-functions.md - file: esql/functions-operators/mv-functions.md - file: esql/functions-operators/operators.md + - file: esql/esql-multi.md + children: + - file: esql/esql-multi-index.md + - file: esql/esql-cross-clusters.md - file: esql/esql-advanced.md children: - file: esql/esql-process-data-with-dissect-grok.md @@ -139,12 +145,14 @@ toc: - file: esql/esql-time-spans.md - file: esql/esql-metadata-fields.md - file: esql/esql-multivalued-fields.md - - - file: esql/limitations.md - file: esql/esql-examples.md + children: + - file: esql/esql-search-tutorial.md - file: esql/esql-troubleshooting.md children: - file: esql/esql-query-log.md + - file: esql/esql-task-management.md + - file: esql/limitations.md - file: sql.md children: - file: sql/sql-spec.md