As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Comandos PPL compatíveis
As tabelas a seguir mostram quais comandos PPL o OpenSearch Dashboards suporta para consultar CloudWatch Logs, Amazon S3 ou Security Lake, e quais comandos o Logs Insights suporta. CloudWatch CloudWatch O Logs Insights usa a mesma sintaxe PPL dos OpenSearch painéis ao consultar CloudWatch registros, e as tabelas se referem a ambos como registros. CloudWatch
**nota**
Quando você analisa dados fora do OpenSearch Serviço, os comandos podem ser executados de forma diferente do que nos OpenSearch índices.
**Topics**
+ [Comandos](#supported-ppl-commands)
+ [Funções](#supported-ppl-functions)
+ [Informações adicionais para usuários do CloudWatch Logs Insights que usam OpenSearch PPL](#supported-ppl-for-cloudwatch-users)
## Comandos
| Comando PPL | Description | CloudWatch Registros | Amazon S3 | Lago de Segurança | Exemplo de comando da |
| --- | --- | --- | --- | --- | --- |
| [Comando fields](#supported-ppl-fields-command) | Exibe um conjunto de campos que precisa de projeção. |  compatível |  compatível |  compatível | fields field1, field2
|
| [Comando where](#supported-ppl-where-command) | Filtra os dados com base nas condições que você especifica. |  compatível |  compatível |  compatível | where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000
|
| [Comando stats](#supported-ppl-stats-command) | Executa agregações e cálculos. |  compatível |  compatível |  compatível | stats count(),
count(`field1`),
min(`field1`),
max(`field1`),
avg(`field1`)
by field2
| head 1000
|
| [comando parse](#supported-ppl-parse-command) | Extrai um padrão de expressão regular (regex) de uma string e exibe o padrão extraído. O padrão extraído pode ser usado posteriormente para criar novos campos ou filtrar dados. |  compatível |  compatível |  compatível | parse `field1` ".*/(?[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000
|
| [Comando patterns](#supported-ppl-patterns-command) | Extrai padrões de log de um campo de texto e acrescenta os resultados ao resultado da pesquisa. Agrupar os logs por seus padrões facilita a agregação de estatísticas de grandes volumes de dados de log para análise e solução de problemas. |  não compatível |  compatível |  compatível | patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers
|
| [Comando sort](#supported-ppl-sort-command) | Classifique os resultados exibidos por um nome de campo. Use **classificar - *FieldName***para classificar em ordem decrescente. |  compatível |  compatível |  compatível | stats count(),
count(`field1`),
min(`field1`) as field1Alias,
max(`field1`),
avg(`field1`)
by field2
| sort -field1Alias
| head 1000
|
| [Comando eval](#supported-ppl-eval-command) | Modifica ou processa o valor de um campo e o armazena em outro campo. Esse comando é útil para modificar matematicamente uma coluna, aplicar funções de string a uma coluna ou aplicar funções de data a uma coluna. |  compatível |  compatível |  compatível | eval field2 = `field1` * 2
| fields field1, field2
| head 20
|
| [Comando rename](#supported-ppl-rename-command) | Renomeia um ou mais campos no resultado da pesquisa. |  compatível |  compatível |  compatível | rename field2 as field1
| fields field1
|
| [Comando head](#supported-ppl-head-command) | Limita os resultados da consulta exibidos às primeiras N linhas. |  compatível |  compatível |  compatível | fields `@message`
| head 20
|
| [Comando grok](#supported-ppl-grok-command) | Analisa um campo de texto com um padrão grok baseado em expressão regular e acrescenta os resultados ao resultado da pesquisa. |  compatível |  compatível |  compatível | grok email '.+@%{HOSTNAME:host}'
| fields email |
| [Comando top](#supported-ppl-top-command) | Encontra os valores mais frequentes para um campo. |  compatível |  compatível |  compatível | top 2 Field1 by Field2
|
| [Comando dedup](#supported-ppl-dedup-command) | Remove entradas duplicadas com base nos campos que você especifica. |  compatível |  compatível |  compatível | dedup field1
| fields field1, field2, field3
|
| [Comando join](#supported-ppl-join-commands) | Une dois conjuntos de dados. |  compatível |  compatível |  compatível | source=customer
| join ON c_custkey = o_custkey orders
| head 10
|
| [Comando lookup](#supported-ppl-lookup-commands) | Enriquece seus dados de pesquisa adicionando ou substituindo dados de um índice de pesquisa (tabela de dimensões). Você pode estender os campos de um índice com valores de uma tabela de dimensões, acrescentar ou substituir valores quando a condição de pesquisa é atendida |  não compatível |  compatível |  compatível | where orderType = 'Cancelled'
| lookup account_list, mkt_id AS mkt_code
replace amount, account_name as name
| stats count(mkt_code), avg(amount)
by name
|
| [Comando subquery](#supported-ppl-subquery-commands) | Realiza consultas aninhadas complexas nas instruções Piped Processing Language (PPL). |  compatível |  compatível |  compatível | where id in [
subquery source=users
| where user in [
subquery source=actions
| where action="login"
| fields user
]
| fields uid
]
|
| [Comando rare](#supported-ppl-rare-command) | Encontra os valores menos frequentes de todos os campos na lista de campos. |  compatível |  compatível |  compatível | rare Field1 by Field2
|
| [Comando trendline](#supported-ppl-trendline-commands) | Calcula as médias móveis dos campos. |  compatível |  compatível |  compatível | trendline sma(2, field1) as field1Alias
|
| [Comando eventstats](#supported-ppl-eventstats-command) | Enriquece os dados de evento com estatísticas resumidas calculadas. Esse comando analisa campos especificados em seus eventos, calcula várias medidas estatísticas e, em seguida, anexa esses resultados a cada evento original como novos campos. | Compatível  com (exceto `count()`) |  compatível |  compatível | eventstats sum(field1) by field2
|
| [Comando flatten](#supported-ppl-flatten-command) | Nivela um campo. O campo deve ser deste tipo: `struct or array>` |  compatível |  compatível |  compatível | source=table | flatten field1
|
| [field summary](#supported-ppl-field-summary-command) | Calcula estatísticas básicas para cada campo (contagem, contagem distinta, mín, máx, méd., stddev e mediana). | Compatível com  (um campo por consulta) |  compatível |  compatível | where field1 != 200
| fieldsummary includefields=field1 nulls=true
|
| [Comando fillnull](#supported-ppl-fillnull-command) | Preenche campos nulo com o valor que você fornece. Pode ser usado em um ou mais campos. |  compatível |  compatível |  compatível | fields field1
| eval field2=field1
| fillnull value=0 field1
|
| [Comando expand](#supported-ppl-expand-command) | Divide um campo contendo vários valores em linhas separadas, criando uma nova linha para cada valor no campo especificado. |  compatível |  compatível |  compatível | expand employee
| stats max(salary) as max
by state, company
|
| [Comando describe](#supported-ppl-describe-command) | Obtém informações detalhadas sobre a estrutura e os metadados de tabelas, esquemas e catálogos |  não compatível |  compatível |  compatível | describe schema.table
|
## Funções
| Função PPL | Description | CloudWatch Registros | Amazon S3 | Lago de Segurança | Exemplo de comando da |
| --- | --- | --- | --- | --- | --- |
| [Funções PPL de string](#supported-ppl-string-functions)
(`CONCAT`, `CONCAT_WS`, `LENGTH`, `LOWER`, `LTRIM`, `POSITION`, `REVERSE`, `RIGHT`, `RTRIM`, `SUBSTRING`, `TRIM`, `UPPER`) | Funções integradas na PPL que podem manipular e transformar dados de string e texto em consultas PPL. Por exemplo, converter maiúsculas e minúsculas, combinar strings, extrair partes e apagar texto. |  compatível |  compatível |  compatível | eval col1Len = LENGTH(col1)
| fields col1Len
|
| [Funções PPL de data e hora](#supported-ppl-date-time-functions)
(`DAY`, `DAYOFMONTH`, `DAY_OF_MONTH`,`DAYOFWEEK`, `DAY_OF_WEEK`, `DAYOFYEAR`, `DAY_OF_YEAR`, `DAYNAME`, `FROM_UNIXTIME`, `HOUR`, `HOUR_OF_DAY`, `LAST_DAY`, `LOCALTIMESTAMP`, `LOCALTIME`, `MAKE_DATE`, `MINUTE`, `MINUTE_OF_HOUR`, `MONTH`, `MONTHNAME`, `MONTH_OF_YEAR`, `NOW`, `QUARTER`, `SECOND`, `SECOND_OF_MINUTE`, `SUBDATE`, `SYSDATE`, `TIMESTAMP`, `UNIX_TIMESTAMP`, `WEEK`, `WEEKDAY`, `WEEK_OF_YEAR`, `DATE_ADD`, `DATE_SUB`, `TIMESTAMPADD`, `TIMESTAMPDIFF`, `UTC_TIMESTAMP`, `CURRENT_TIMEZONE`) | Funções integradas para manipular e transformar dados de data e carimbo de data/hora em consultas PPL. Por exemplo, **date\_add**, **date\_format**, **datediff** e **current\_date**. |  compatível |  compatível |  compatível | eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate |
| [Funções PPL de condição](#supported-ppl-condition-functions)
(`EXISTS`, `IF`, `IFNULL`, `ISNOTNULL`, `ISNULL`, `NULLIF`) | Funções integradas que realizam cálculos em várias linhas para produzir um único valor resumido. Por exemplo: **sum**, **count**, **avg**, **max** e **min**. |  compatível |  compatível |  compatível | eval field2 = isnull(col1)
| fields field2, col1, field3
|
| [Funções PPL matemáticas](#supported-ppl-math-functions)
(`ABS`, `ACOS`, `ASIN`, `ATAN`, `ATAN2`, `CEIL`, `CEILING`, `CONV`, `COS`, `COT`, `CRC32`, `DEGREES`, `E`, `EXP`, `FLOOR`, `LN`, `LOG`, `LOG2`, `LOG10`, `MOD`, `PI`. `POW`, `POWER`, `RADIANS`, `RAND`, `ROUND`, `SIGN`, `SIN`, `SQRT`, `CBRT`) | Funções integradas para realizar cálculos matemáticos e transformações em consultas PPL. Por exemplo: **abs** (valor absoluto), **round** (arredonda números), **sqrt** (raiz quadrada), **pow** (cálculo de potência) e **ceil** (arredonda para o inteiro mais próximo). |  compatível |  compatível |  compatível | eval field2 = ACOS(col1)
| fields col1
|
| [Expressões PPL](#supported-ppl-expressions)
(Operadores aritméticos (`+`, `-`, `*`), operadores de predicados (`>. <`, `IN)`) | Funções integradas para expressões, especialmente expressões de valor, retornam um valor escalar. As expressões têm diferentes tipos e formatos. |  compatível |  compatível |  compatível | where age > (25 + 5)
| fields age
|
| [Funções PPL de endereço IP](#supported-ppl-ip-address-functions)
(`CIDRMATCH`) | Funções integradas para lidar com endereços IP, como CIDR. |  compatível |  compatível |  compatível | where cidrmatch(ip, '***********/24')
| fields ip
|
| [Funções PPL de JSON](#supported-ppl-json-functions)
(`ARRAY_LENGTH`, `ARRAY_LENGTH`, `JSON`, `JSON_ARRAY`, `JSON_EXTRACT`, `JSON_KEYS`, `JSON_OBJECT`, `JSON_VALID`, `TO_JSON_STRING`) | Funções integradas para lidar com JSON, incluindo matrizes, extração e validação. |  compatível |  compatível |  compatível | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a') |
| [Funções PPL do Lambda](#supported-ppl-lambda-functions)
(`EXISTS`, `FILTER`, `REDUCE`, `TRANSFORM`) | Funções integradas para lidar com JSON, incluindo matrizes, extração e validação. |  não compatível |  compatível |  compatível | eval array = json_array(1, -1, 2),
result = filter(array, x -> x > 0)
| fields result
|
| [Funções PPL de hash criptográfico](#supported-ppl-cryptographic-functions)
(`MD5`, `SHA1`, `SHA2`) | Funções integradas que permitem gerar impressões digitais exclusivas de dados, que podem ser usadas para verificação, comparação ou como parte de protocolos de segurança mais complexos. |  compatível |  compatível |  compatível | eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')` |
## Informações adicionais para usuários do CloudWatch Logs Insights que usam OpenSearch PPL
Embora o CloudWatch Logs Insights ofereça suporte à maioria dos comandos e funções do OpenSearch PPL, alguns comandos e funções não são compatíveis atualmente. Por exemplo, atualmente ele não é compatível com a comandos de pesquisa em PPL. A partir de 2 de junho de 2025, o CloudWatch Logs Insights agora oferece suporte às funções JOIN, subqueries, Flatten, Fillnull, Expand, Cidrmatch e JSON no PPL. Para obter uma lista completa dos comandos e funções de consulta compatíveis, consulte as colunas Amazon CloudWatch Logs nas tabelas acima.
### Exemplos de consultas e cotas
O seguinte se aplica tanto aos usuários do CloudWatch Logs Insights quanto OpenSearch aos usuários que consultam CloudWatch dados.
Para obter informações sobre os limites que se aplicam ao consultar CloudWatch registros do OpenSearch serviço, consulte [Cotas de CloudWatch registros no Guia](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) do usuário do Amazon CloudWatch Logs. Os limites envolvem o número de grupos de CloudWatch registros que você pode consultar, o máximo de consultas simultâneas que você pode executar, o tempo máximo de execução da consulta e o número máximo de linhas retornadas nos resultados. Os limites são os mesmos, independentemente da linguagem usada para consultar CloudWatch os registros (ou seja, OpenSearch PPL, SQL e Logs Insights QL).
### Comandos PPL
**Topics**
+ [comment](#supported-ppl-comment)
+ [Comando correlation](#supported-ppl-correlation-commands)
+ [Comando dedup](#supported-ppl-dedup-command)
+ [Comando describe](#supported-ppl-describe-command)
+ [Comando eval](#supported-ppl-eval-command)
+ [Comando eventstats](#supported-ppl-eventstats-command)
+ [Comando expand](#supported-ppl-expand-commands)
+ [Comando explain](#supported-ppl-explain-command)
+ [Comando fillnull](#supported-ppl-fillnull-command)
+ [Comando fields](#supported-ppl-fields-command)
+ [Comando flatten](#supported-ppl-flatten-command)
+ [Comando grok](#supported-ppl-grok-command)
+ [Comando head](#supported-ppl-head-command)
+ [Comando join](#supported-ppl-join-commands)
+ [Comando lookup](#supported-ppl-lookup-commands)
+ [comando parse](#supported-ppl-parse-command)
+ [Comando patterns](#supported-ppl-patterns-command)
+ [Comando rare](#supported-ppl-rare-command)
+ [Comando rename](#supported-ppl-rename-command)
+ [Comando search](#supported-ppl-search-command)
+ [Comando sort](#supported-ppl-sort-command)
+ [Comando stats](#supported-ppl-stats-command)
+ [Comando subquery](#supported-ppl-subquery-commands)
+ [Comando top](#supported-ppl-top-command)
+ [Comando trendline](#supported-ppl-trendline-commands)
+ [Comando where](#supported-ppl-where-command)
+ [field summary](#supported-ppl-field-summary-command)
+ [Comando expand](#supported-ppl-expand-command)
+ [Funções PPL](#supported-ppl-functions-details)
#### comment
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
O PPL é compatível com comentários em linha e comentários em bloco. O sistema não avalia texto de comentário.
**Comentários de linha**
Os comentários de linha começam com duas barras // e terminam com uma nova linha.
Exemplo:
```
os> source=accounts | top gender // finds most common gender of all the accounts
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Comentários de bloco**
Os comentários de bloco começam com uma barra invertida seguida por um asterisco \\\* e terminam com um asterisco seguido por uma barra \*/.
Exemplo:
```
os> source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 6 | M |
| 13 | F |
+------------------+----------+
```
#### Comando correlation
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Você pode correlacionar diferentes fontes de dados de acordo com dimensões e prazos em comum.
Essa correlação é crucial quando você lida com grandes quantidades de dados de vários setores que compartilham os mesmos períodos, mas não estão sincronizados formalmente.
Ao correlacionar essas diferentes fontes de dados com base em prazos e dimensões semelhantes, você pode enriquecer seus dados e revelar informações valiosas.
**Exemplo**
O domínio de observabilidade tem três fontes de dados distintas:
+ Logs
+ Metrics
+ Rastreamentos
Essas fontes de dados podem compartilhar dimensões comuns. Para a transição de uma fonte de dados para outra, você precisa correlacioná-las corretamente. Usando convenções de nomenclatura semântica, você pode identificar os elementos compartilhados entre logs, rastreamentos e métricas.
Exemplo:
```
{
"@timestamp": "2018-07-02T22:23:00.186Z",
"aws": {
"elb": {
"backend": {
"http": {
"response": {
"status_code": 500
}
},
"ip": "********",
"port": "80"
},
...
"target_port": [
"10.0.0.1:80"
],
"target_status_code": [
"500"
],
"traceId": "Root=1-58337262-36d228ad5d99923122bbe354",
"type": "http"
}
},
"cloud": {
"provider": "aws"
},
"http": {
"request": {
...
},
"communication": {
"source": {
"address": "**************",
"ip": "**************",
"port": 2817
}
},
"traceId": "Root=1-58337262-36d228ad5d99923122bbe354"
}
```
Este exemplo mostra um log do AWS ELB chegando de um serviço residente em. AWS Ele mostra uma resposta HTTP de backend com um código de status de 500, indicando um erro. Isso pode acionar um alerta ou fazer parte do seu processo regular de monitoramento. Sua próxima etapa é reunir dados relevantes sobre esse evento para uma investigação minuciosa.
Embora você possa ficar tentado a consultar todos os dados relacionados ao período, essa abordagem pode ser esmagadora. Você pode acabar com informações demais, gastando mais tempo filtrando dados irrelevantes do que identificando a causa raiz.
Em vez disso, você pode usar uma abordagem mais objetiva correlacionando dados de diferentes fontes. Você pode usar essas dimensões para correlação:
+ **IP**: `"ip": "10.0.0.1" | "ip": "**************"`
+ **Porto** - `"port": 2817 | "target_port": "10.0.0.1:80"`
Partindo do pressuposto de que você tem acesso a rastreamentos e índices de métricas adicionais e está familiarizado com a estrutura do esquema, pode criar uma consulta de correlação mais precisa.
Aqui está um exemplo de um documento de índice de rastreamento contendo informações HTTP que você talvez queira correlacionar:
```
{
"traceId": "c1d985bd02e1dbb85b444011f19a1ecc",
"spanId": "55a698828fe06a42",
"traceState": [],
"parentSpanId": "",
"name": "mysql",
"kind": "CLIENT",
"@timestamp": "2021-11-13T20:20:39+00:00",
"events": [
{
"@timestamp": "2021-03-25T17:21:03+00:00",
...
}
],
"links": [
{
"traceId": "c1d985bd02e1dbb85b444011f19a1ecc",
"spanId": "55a698828fe06a42w2",
},
"droppedAttributesCount": 0
}
],
"resource": {
"service@name": "database",
"telemetry@sdk@name": "opentelemetry",
"host@hostname": "ip-172-31-10-8.us-west-2.compute.internal"
},
"status": {
...
},
"attributes": {
"http": {
"user_agent": {
"original": "Mozilla/5.0"
},
"network": {
...
}
},
"request": {
...
}
},
"response": {
"status_code": "200",
"body": {
"size": 500
}
},
"client": {
"server": {
"socket": {
"address": "***********",
"domain": "example.com",
"port": 80
},
"address": "***********",
"port": 80
},
"resend_count": 0,
"url": {
"full": "http://example.com"
}
},
"server": {
"route": "/index",
"address": "***********",
"port": 8080,
"socket": {
...
},
"client": {
...
}
},
"url": {
...
}
}
}
}
}
```
Nessa abordagem, você pode ver os http `traceId` e os http client/server `ip` que podem ser correlacionados com os registros do elb para entender melhor o comportamento e a condição do sistema.
**Novo comando de consulta de correlação**
Aqui está o novo comando que permitiria esse tipo de investigação:
```
source alb_logs, traces | where alb_logs.ip="10.0.0.1" AND alb_logs.cloud.provider="aws"|
correlate exact fields(traceId, ip) scope(@timestamp, 1D) mapping(alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId )
```
Aqui está o que cada faz parte do comando:
1. `source alb_logs, traces`: seleciona as fontes de dados que você deseja correlacionar.
1. `where ip="10.0.0.1" AND cloud.provider="aws"`: restringe o escopo da pesquisa.
1. `correlate exact fields(traceId, ip)`: faz com que o sistema correlacione os dados com base em correspondências exatas dos seguintes campos:
+ O campo `ip` tem uma condição de filtro explícita, assim, será usado na correlação de todas as fontes de dados.
+ O campo `traceId` não tem filtro explícito, assim, fará a correspondência dos mesmos traceIDs em todas as fontes de dados.
Os nomes de campo indicam o significado lógico da função no comando de correlação. A condição real de união depende da instrução de mapeamento fornecida.
O termo `exact` significa que as instruções de correlação exigirão que todos os campos correspondam para atender à instrução de consulta.
O termo `approximate` tentará estabelecer a correspondência no melhor cenário possível e não rejeitará linhas com correspondências parciais.
**Lidar com diferentes mapeamentos de campos**
Nos casos em que o mesmo campo lógico (como `ip`) tem nomes diferentes nas diversas fontes de dados, você precisará informar o mapeamento explícito dos campos de caminho. Para resolver isso, você pode ampliar as condições de correlação para estabelecer a correspondência com nomes de campos diferentes com significados lógicos semelhantes. Veja como isso pode ser feito:
```
alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId
```
Para cada campo que participa da união de correlação, você deve fornecer uma instrução de mapeamento relevante que inclua todas as tabelas a serem unidas por esse comando de correlação.
**Exemplo**
Neste exemplo, existem duas fontes: `alb_logs, traces`
Existem dois campos: `traceId, ip`
Existem duas instruções de mapeamento: `alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId`
**Definir o escopo dos prazos de correlação**
Para simplificar o trabalho realizado pelo mecanismo de execução (driver), você pode adicionar a instrução scope. Isso instrui explicitamente a consulta de união sobre o tempo a que ela deve alocar a essa pesquisa.
`scope(@timestamp, 1D)` i
Neste exemplo, o foco do escopo da pesquisa é diário, portanto as correlações que aparecem no mesmo dia são agrupadas. Esse mecanismo de definição de escopo simplifica e permite um melhor controle sobre os resultados, permitindo uma resolução incremental de pesquisa de acordo com suas necessidades.
**Drivers compatíveis**
O novo comando de correlação é, na verdade, um comando de união “oculto”. Portanto, somente os drivers PPL a seguir são compatíveis com esse comando. Nesses drivers, o comando de correlação será traduzido diretamente para o plano lógico Catalyst Join apropriado.
**Exemplo**
`source alb_logs, traces, metrics | where ip="10.0.0.1" AND cloud.provider="aws"| correlate exact on (ip, port) scope(@timestamp, 2018-07-02T22:23:00, 1 D)`
**Plano lógico:**
```
'Project [*]
+- 'Join Inner, ('ip && 'port)
:- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [alb_logs]
+- 'Join Inner, ('ip & 'port)
:- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [traces]
+- 'Filter (('ip === "10.0.0.1" & 'cloud.provider === "aws") & inTimeScope('@timestamp, "2018-07-02T22:23:00", "1 D"))
+- 'UnresolvedRelation [metrics]
```
O mecanismo catalisador otimiza essa consulta de acordo com a ordem de união mais eficiente.
#### Comando dedup
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `dedup` para remover documentos idênticos dos resultados da pesquisa com base nos campos especificados.
**Sintaxe**
Use a seguinte sintaxe:
```
dedup [int] [keepempty=] [consecutive=]
```
**`int`**
+ Opcional.
+ O comando `dedup` retém vários eventos para cada combinação quando você especifica . O número para . deve ser maior que 0. Se você não especificar um número, somente o primeiro evento ocorrido será retido. Todas as outras duplicações são removidas dos resultados.
+ Padrão: 1
**`keepempty`**
+ Opcional.
+ Se verdadeiro, mantém documentos nos quais algum campo na field-list tenha um valor NULL ou esteja AUSENTE.
+ Padrão: Falso
**`consecutive`**
+ Opcional.
+ Se verdadeiro, remove somente eventos com combinações de valores consecutivas duplicadas.
+ Padrão: Falso
**`field-list`**
+ Obrigatório.
+ Uma lista de campos delimitada por vírgulas. Pelo menos um campo é obrigatório.
**Exemplo 1: Dedup por um campo**
Este exemplo mostra como remover duplicações de documentos usando o campo de gênero.
Consulta PPL:
```
os> source=accounts | dedup gender | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Exemplo 2: mantenha 2 documentos duplicados**
O exemplo mostra como remover duplicações de documentos com o campo de gênero, mantendo duas duplicações.
Consulta PPL:
```
os> source=accounts | dedup 2 gender | fields account_number, gender;
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 6 | M |
| 13 | F |
+------------------+----------+
```
**Exemplo 3: manter ou ignorar o campo vazio por padrão**
O exemplo mostra como remover duplicações de documentos mantendo o campo de valor nulo.
Consulta PPL:
```
os> source=accounts | dedup email keepempty=true | fields account_number, email;
fetched rows / total rows = 4/4
+------------------+-----------------------+
| account_number | email |
+------------------+-----------------------+
| 1 | john_doe@example.com |
| 6 | jane_doe@example.com |
| 13 | null |
| 18 | juan_li@example.com |
+------------------+-----------------------+
```
O exemplo mostra como remover duplicações de documentos igmorando o campo de valor vazio.
Consulta PPL:
```
os> source=accounts | dedup email | fields account_number, email;
fetched rows / total rows = 3/3
+------------------+-----------------------+
| account_number | email |
+------------------+-----------------------+
| 1 | john_doe@example.com |
| 6 | jane_doe@example.com |
| 18 | juan_li@example.com |
+------------------+-----------------------+
```
**Exemplo 4: remover duplicações em documentos consecutivos**
O exemplo mostra como remover duplicações em documentos consecutivos.
Consulta PPL:
```
os> source=accounts | dedup gender consecutive=true | fields account_number, gender;
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
+------------------+----------+
| 1 | M |
| 13 | F |
| 18 | M |
+------------------+----------+
```
**Exemplos adicionais**
+ `source = table | dedup a | fields a,b,c`
+ `source = table | dedup a,b | fields a,b,c`
+ `source = table | dedup a keepempty=true | fields a,b,c`
+ `source = table | dedup a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a | fields a,b,c`
+ `source = table | dedup 1 a,b | fields a,b,c`
+ `source = table | dedup 1 a keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a | fields a,b,c`
+ `source = table | dedup 2 a,b | fields a,b,c`
+ `source = table | dedup 2 a keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a consecutive=true| fields a,b,c` (a remoção de duplicação consecutiva não é compatível)
**Limitação**
+ Para `| dedup 2 a, b keepempty=false`
```
DataFrameDropColumns('_row_number_)
+- Filter ('_row_number_ <= 2) // allowed duplication = 2
+- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
+- Filter (isnotnull('a) AND isnotnull('b)) // keepempty=false
+- Project
+- UnresolvedRelation
```
+ Para `| dedup 2 a, b keepempty=true`
```
Union
:- DataFrameDropColumns('_row_number_)
: +- Filter ('_row_number_ <= 2)
: +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
: +- Filter (isnotnull('a) AND isnotnull('b))
: +- Project
: +- UnresolvedRelation
+- Filter (isnull('a) OR isnull('b))
+- Project
+- UnresolvedRelation
```
#### Comando describe
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `describe` para obter informações detalhadas sobre a estrutura e os metadados de tabelas, esquemas e catálogos. Aqui estão vários exemplos e casos de uso do comando `describe`.
**Descrever**
+ `describe table` Esse comando é igual ao comando SQL `DESCRIBE EXTENDED table`
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
#### Comando eval
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
O comando `eval` avalia a expressão e acrescenta o resultado ao resultado da pesquisa.
**Sintaxe**
Use a seguinte sintaxe:
```
eval = ["," = ]...
```
+ `field`: obrigatório. Se o nome do campo não existir, um novo campo será adicionado. Se o nome do campo já existir, ele será substituído.
+ `expression`: obrigatório. Qualquer expressão compatível com o sistema.
**Exemplo 1: criar o novo campo**
Este exemplo mostra como criar um novo campo `doubleAge` para cada documento. O novo `doubleAge` é o resultado da avaliação da idade multiplicado por 2.
Consulta PPL:
```
os> source=accounts | eval doubleAge = age * 2 | fields age, doubleAge ;
fetched rows / total rows = 4/4
+-------+-------------+
| age | doubleAge |
|-------+-------------|
| 32 | 64 |
| 36 | 72 |
| 28 | 56 |
| 33 | 66 |
+-------+-------------+
```
**Exemplo 2: substituir o campo existente**
Este exemplo mostra como substituir o campo de idade existente por idade mais 1.
Consulta PPL:
```
os> source=accounts | eval age = age + 1 | fields age ;
fetched rows / total rows = 4/4
+-------+
| age |
|-------|
| 33 |
| 37 |
| 29 |
| 34 |
+-------+
```
**Exemplo 3: criar o novo campo com o campo definido em eval**
Este exemplo mostra como criar um novo campo `ddAge` com um campo definido no comando eval. O novo campo `ddAge` é o resultado da avaliação de `doubleAge` multiplicado por 2, no qual `doubleAge` é definido no comando eval.
Consulta PPL:
```
os> source=accounts | eval doubleAge = age * 2, ddAge = doubleAge * 2 | fields age, doubleAge, ddAge ;
fetched rows / total rows = 4/4
+-------+-------------+---------+
| age | doubleAge | ddAge |
|-------+-------------+---------|
| 32 | 64 | 128 |
| 36 | 72 | 144 |
| 28 | 56 | 112 |
| 33 | 66 | 132 |
+-------+-------------+---------+
```
Pressupostos: `a`, `b`, `c` são campos existentes em `table`
**Exemplos adicionais**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1` (campos de saída a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**Avaliação com exemplo de caso:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Avaliação com outro exemplo de caso:**
Pressupostos: `a`, `b`, `c` são campos existentes em `table`
**Exemplos adicionais**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1` (campos de saída a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**Avaliação com exemplo de caso:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Avaliação com outro exemplo de caso:**
```
source = table | where ispresent(a) |
eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
)
| stats count() by status_category
```
**Limitações**
+ Não é possível substituir campos existentes. As consultas que tentarem fazer isso gerarão exceções com a mensagem “A referência ‘a’ é ambígua”.
```
- `source = table | eval a = 10 | fields a,b,c`
- `source = table | eval a = a * 2 | stats avg(a)`
- `source = table | eval a = abs(a) | where a > 0`
- `source = table | eval a = signum(a) | where a < 0`
```
#### Comando eventstats
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `eventstats` para enriquecer os dados do evento com estatísticas resumidas calculadas. Ele opera analisando os campos especificados nos eventos, calculando várias medições estatísticas e acrescentando esses resultados a cada evento original como novos campos.
**Principais aspectos de eventstats**
1. Ele realiza cálculos em todo o conjunto de resultados ou em todos os grupos definidos.
1. Os eventos originais permanecem intactos, com novos campos adicionados para conter os resultados estatísticos.
1. O comando é particularmente útil para análise comparativa, identificação de valores discrepantes ou fornecimento de contexto adicional a eventos individuais.
**Diferença entre stats e eventstats**
Os comandos `stats` e `eventstats` são usados para calcular estatísticas, mas eles têm algumas diferenças importantes em como operam e no que produzem.
**Formato de saída**
+ `stats`: produz uma tabela resumida somente com as estatísticas calculadas.
+ `eventstats`: adiciona as estatísticas calculadas como novos campos aos eventos existentes, preservando os dados originais.
**Retention de eventos**
+ `stats`: reduz o conjunto de resultados a apenas o resumo estatístico, descartando eventos individuais.
+ `eventstats`: retém todos os eventos originais e adiciona novos campos com as estatísticas calculadas.
**Casos de uso**
+ `stats`: Ideal para criar relatórios resumidos ou painéis. Geralmente usado como um comando final para resumir os resultados.
+ `eventstats`: útil quando você precisa enriquecer eventos com contexto estatístico para análise ou filtragem adicional. Pode ser usado no meio da pesquisa para adicionar estatísticas que podem ser usadas em comandos subsequentes.
**Sintaxe**
Use a seguinte sintaxe:
```
eventstats ... [by-clause]
```
**agregação**
+ Obrigatório.
+ Uma função de agregação.
+ O argumento da agregação deve ser um campo.
**by-clause**
+ Opcional.
+ Sintaxe: `by [span-expression,] [field,]...`
+ A cláusula by pode incluir campos e expressões, como funções escalares e funções de agregação. Você também pode usar a cláusula span para dividir um campo específico em buckets de intervalos iguais. Em seguida, o comando eventstats realiza a agregação com base nesses buckets de span.
+ Padrão: se você não especificar um by clause, o comando eventstats agregará todo o conjunto de resultados.
**span-expression**
+ Opcional, no máximo um.
+ Sintaxe: `span(field_expr, interval_expr)`
+ A unidade da expressão de intervalo é a unidade natural por padrão. No entanto, para campos do tipo data e hora, é necessário especificar a unidade na expressão de intervalo ao usar unidades de data/hora.
Por exemplo, para dividir o campo `age` em buckets por 10 anos, use `span(age, 10)`. Para campos baseados em hora, você pode dividir um campo `timestamp` em intervalos de hora usando `span(timestamp, 1h)`.
**Unidades de tempo disponíveis**
| Unidades de intervalo de span |
| --- |
| millisegundos (ms) |
| segundo (s) |
| minuto (m, diferencia maiúsculas de minúsculas) |
| hora (h) |
| dia (d) |
| semana (w) |
| mês (M, diferencia maiúsculas de minúsculas) |
| trimestre (q) |
| ano (y) |
**Funções de agregação**
**`COUNT`**
`COUNT` retorna uma contagem do número de expr nas linhas recuperadas por uma instrução SELECT.
Para consultas de uso de CloudWatch registros, não `COUNT` é compatível.
Exemplo:
```
os> source=accounts | eventstats count();
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | count() |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 4 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 4 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 4 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 4 |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
```
**`SUM`**
`SUM(expr)` retorna a soma de expr.
Exemplo:
```
os> source=accounts | eventstats sum(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | sum(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 101 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante | TN | 101 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 101 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
```
**`AVG`**
`AVG(expr)` retorna o valor médio de expr.
Exemplo:
```
os> source=accounts | eventstats avg(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.67 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.67 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.00 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 33.67 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------+
```
**MAX**
`MAX(expr)` retorna o valor máximo de expr.
Exemplo
```
os> source=accounts | eventstats max(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | max(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 36 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
```
**MIN**
`MIN(expr)` retorna o valor mínimo de expr.
Exemplo
```
os> source=accounts | eventstats min(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | min(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 28 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 28 |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 28 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
```
**STDDEV\_SAMP**
`STDDEV_SAMP(expr)` retorna o desvio padrão da amostra de expr.
Exemplo
```
os> source=accounts | eventstats stddev_samp(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_samp(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3.304037933599835 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3.304037933599835 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 3.304037933599835 |
| 18 | 4180 | Juan | Li | 33 | M | 467 Example Court | | juanli@exampleorg.com | Orick | MD | 3.304037933599835 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**STDDEV\_POP**
`STDDEV_POP(expr)` retorna o desvio padrão da população de expr.
Exemplo
```
os> source=accounts | eventstats stddev_pop(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_pop(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2.**************** |
| 6 | 5686 | Mary | Major | 36 | M | *** Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 2.**************** |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 2.**************** |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2.**************** |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**PERCENTILE ou PERCENTILE\_APPROX**
`PERCENTILE(expr, percent)` ou `PERCENTILE_APPROX(expr, percent)` retorna o percentil aproximado de expr na porcentagem especificada.
**percentual**
+ O número deve ser uma constante entre 0 e 100.
Exemplo
```
os> source=accounts | eventstats percentile(age, 90) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | percentile(age, 90) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 36 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 36 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 36 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
```
**Exemplo 1: calcular a média, a soma e a contagem de um campo por grupo**
O exemplo mostra como calcular a idade média, a soma da idade e a contagem de eventos de todas as contas agrupadas por sexo.
```
os> source=accounts | eventstats avg(age) as avg_age, sum(age) as sum_age, count() as count by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | avg_age | sum_age | count |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 33.666667 | 101 | 3 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 33.666667 | 101 | 3 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 28.000000 | 28 | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 33.666667 | 101 | 3 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
```
**Exemplo 2: calcular a contagem por um span**
O exemplo obtém a contagem de idade pelo intervalo de 10 anos.
```
os> source=accounts | eventstats count(age) by span(age, 10) as age_span
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | age_span |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 3 |
| 6 | 5686 | Mary | Major | 36 | M | 671 Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 3 |
| 13 | 32838 | Nikki | Wolf | 28 | F | 789 Any Street | AnyOrg | | Nogal | VA | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 3 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
```
**Exemplo 3: calcular a contagem por um sexo e span**
O exemplo obtém a contagem de idade pelo intervalo de 5 anos e agrupa por sexo.
```
os> source=accounts | eventstats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | cnt |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2 |
| 6 | 5686 | Mary | Majo | 36 | M | 671 Example Street | Any Company | hattiebond@anycompany.com | Dante | TN | 1 |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
```
**Usage**
+ `source = table | eventstats avg(a)`
+ `source = table | where a < 50 | eventstats avg(c)`
+ `source = table | eventstats max(c) by b`
+ `source = table | eventstats count(c) by b | head 5`
+ `source = table | eventstats distinct_count(c)`
+ `source = table | eventstats stddev_samp(c)`
+ `source = table | eventstats stddev_pop(c)`
+ `source = table | eventstats percentile(c, 90)`
+ `source = table | eventstats percentile_approx(c, 99)`
**Agregações com span**
+ `source = table | eventstats count(a) by span(a, 10) as a_span`
+ `source = table | eventstats sum(age) by span(age, 5) as age_span | head 2`
+ `source = table | eventstats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
**Agregações com span de janela de tempo (função de janela tumble)**
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
**Grupo de agregações por vários níveis**
+ `source = table | eventstats avg(age) as avg_state_age by country, state | eventstats avg(avg_state_age) as avg_country_age by country`
+ `source = table | eventstats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | eventstats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | eventstats avg(avg_state_age) as avg_adult_country_age by country`
#### Comando expand
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `expand` para nivelar um campo do tipo:
+ `Array`
+ `Map`
**Sintaxe**
Use a seguinte sintaxe:
```
expand [As alias]
```
**Campo**
+ O campo a ser expandido (explodido). Deve ser de um tipo compatível.
**alias**
+ Opcional. O nome a ser usado em vez do nome original do campo.
**Usage**
O comando `expand` produz uma linha para cada elemento na matriz ou no campo de mapa especificado, onde:
+ Os elementos da matriz se tornam linhas individuais.
+ Os pares de chave-valor do mapa são divididos em linhas separadas, com cada par chave-valor representado como uma linha.
+ Quando um alias é fornecido, os valores explodidos são representados sob o alias em vez do nome original do campo.
+ Isso pode ser usado em combinação com outros comandos, como `stats`, `eval` e `parse` para manipular ou extrair dados após a expansão.
**Exemplos**
+ `source = table | expand employee | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid`
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
#### Comando explain
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
O comando `explain` ajuda a entender os planos de execução de consultas, permitindo que você analise e otimize as consultas para melhorar a performance. Esta introdução fornece uma visão geral concisa da finalidade do comando explain e de sua importância na otimização de consultas.
**Comment**
+ `source=accounts | top gender // finds most common gender of all the accounts` (comentário de linha)
+ `source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender` (comentários de bloco)
**Descrever**
+ `describe table` Esse comando é igual ao comando SQL `DESCRIBE EXTENDED table`
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
**Explicar**
+ `explain simple | source = table | where a = 1 | fields a,b,c`
+ `explain extended | source = table`
+ `explain codegen | source = table | dedup a | fields a,b,c`
+ `explain cost | source = table | sort a | fields a,b,c`
+ `explain formatted | source = table | fields - a`
+ `explain simple | describe table`
**Campos**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
**Resumo de campo**
+ `source = t | fieldsummary includefields=status_code nulls=false`
+ `source = t | fieldsummary includefields= id, status_code, request_path nulls=true`
+ `source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true`
**Campo aninhado**
+ `source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
+ `source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
+ `source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
**Filtros**
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a not in (1, 2, 3) | fields a,b,c`
+ `source = table | where a between 1 and 4`: nota: isso retorna um >= 1 e um <= 4, ou seja, [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`: nota: isso retorna b >= “\*\*\*\*\*\*\*\*\*\*” e b <= “2025-09-10”
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
+ `source = table | trendline sma(2, temperature) as temp_trend`
**Consultas relacionadas a IP**
+ `source = table | where cidrmatch(ip, '**************')`
+ `source = table | where isV6 = false and isValid = true and cidrmatch(ipAddress, '**************')`
+ `source = table | where isV6 = true | eval inRange = case(cidrmatch(ipAddress, '2003:***::/32'), 'in' else 'out') | fields ip, inRange`
**Filtros complexos**
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
**Filtros com condições lógicas**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
**Eval**
Pressupostos: `a`, `b`, `c` são campos existentes em `table`
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1` (campos de saída a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval digest = md5(fieldName) | fields digest`
+ `source = table | eval digest = sha1(fieldName) | fields digest`
+ `source = table | eval digest = sha2(fieldName,256) | fields digest`
+ `source = table | eval digest = sha2(fieldName,512) | fields digest`
#### Comando fillnull
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Description**
Use o comando `fillnull` para substituir valores nulo por um valor especificado em um ou mais campos dos resultados da pesquisa.
**Sintaxe**
Use a seguinte sintaxe:
```
fillnull [with in ["," ]] | [using = ["," = ]]
```
+ null-replacement: obrigatório. O valor usado para substituir valores nulo.
+ nullable-field: obrigatório. Referência do campo. Os valores nulo nesse campo serão substituídos pelo valor especificado em nulo-replacement.
**Exemplo 1: fillnull em um campo**
O exemplo mostra como usar fillnull em um único campo:
```
os> source=logs | fields status_code | eval input=status_code | fillnull with 0 in status_code;
| input | status_code |
|-------|-------------|
| 403 | 403 |
| 403 | 403 |
| NULL | 0 |
| NULL | 0 |
| 200 | 200 |
| 404 | 404 |
| 500 | 500 |
| NULL | 0 |
| 500 | 500 |
| 404 | 404 |
| 200 | 200 |
| 500 | 500 |
| NULL | 0 |
| NULL | 0 |
| 404 | 404 |
```
**Exemplo 2: fillnull aplicado a vários campos**
O exemplo mostra fillnull aplicado a vários campos.
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull with '???' in request_path, timestamp;
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | ??? |
| /home | NULL | /home | ??? |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | ??? | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | ??? | 2023-10-01 11:05:00 |
| /about | NULL | /about | ??? |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | ??? |
| NULL | 2023-10-01 10:05:00 | ??? | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | ??? | 2023-10-01 10:50:00 |
| /services | NULL | /services | ??? |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | ??? | 2023-10-01 10:35:00 |
```
**Exemplo 3: fillnull aplicado a vários campos com vários valores de substituição de nulo.**
O exemplo mostra fillnull com vários valores usados para substituir nulos.
+ `/error` no campo `request_path`
+ `1970-01-01 00:00:00` no campo `timestamp`
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull using request_path = '/error', timestamp='1970-01-01 00:00:00';
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| /home | NULL | /home | 1970-01-01 00:00:00 |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | /error | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | /error | 2023-10-01 11:05:00 |
| /about | NULL | /about | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| NULL | 2023-10-01 10:05:00 | /error | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | /error | 2023-10-01 10:50:00 |
| /services | NULL | /services | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | /error | 2023-10-01 10:35:00 |
```
#### Comando fields
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `fields` para manter ou remover campos do resultado da pesquisa.
**Sintaxe**
Use a seguinte sintaxe:
```
field [+|-]
```
+ `index`: opcional.
Se o sinal de adição (\+) for usado, somente os campos especificados na lista de campos serão mantidos.
Se o sinal de subtração (\+) for usado, somente os campos especificados na lista de campos serão mantidos.
*Padrão*: \+
+ `field list`: obrigatório. Uma lista delimitada por vírgulas dos campos a manter ou remover.
**Exemplo 1: selecione campos especificados no resultado**
Este exemplo mostra como buscar os campos `account_number`, `firstname` e `lastname` dos resultados da pesquisa.
Consulta PPL:
```
os> source=accounts | fields account_number, firstname, lastname;
fetched rows / total rows = 4/4
+------------------+-------------+------------+
| account_number | firstname | lastname |
|------------------+-------------+------------|
| 1 | Jane | Doe |
| 6 | John | Doe |
| 13 | Jorge | Souza |
| 18 | Juan | Li |
+------------------+-------------+------------+
```
**Exemplo 2: remover campos especificados do resultado**
Este exemplo mostra como remover o campo `account_number` dos resultados da pesquisa.
Consulta PPL:
```
os> source=accounts | fields account_number, firstname, lastname | fields - account_number ;
fetched rows / total rows = 4/4
+-------------+------------+
| firstname | lastname |
|-------------+------------|
| Jane | Doe |
| John | Doe |
| Jorge | Souza |
| Juan | Li |
+-------------+------------+
```
**Exemplos adicionais**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
Exemplo de campos aninhados:
```
`source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
`source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
`source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
```
#### Comando flatten
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando flatten para expandir campos dos seguintes tipos:
+ `struct`
+ `array>`
**Sintaxe**
Use a seguinte sintaxe:
```
flatten
```
+ *campo*: o campo a ser nivelado. O campo deve ser de um tipo compatível.
**Esquema**
| col\_name | data\_type |
| --- | --- |
| \_time | string |
| pontes | array> |
| cidade | string |
| coor | struct |
| country | string |
**Dados**
| \_time | pontes | cidade | coor | país |
| --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | [{801, Tower Bridge}, {928, London Bridge}] | Londres | {35, 51,5074, -0,1278} | Inglaterra |
| 2024-09-13T12:00:00 | [{232, Pont Neuf}, {160, Pont Alexandre III}] | Paris | {35, 48,8566, 2,3522} | França |
| 2024-09-13T12:00:00 | [{48, Ponte Rialto}, {11, Ponte dos Suspiros}] | Veneza | {2, 45,4408, 12,3155} | Itália |
| 2024-09-13T12:00:00 | [{\*\*\*, Ponte Carlos}, {343, Ponte da Legião}] | Praga | {200, 50,0755, 14,4378} | República Tcheca |
| 2024-09-13T12:00:00 | [{375, Ponte Chain}, {333, Ponte da Liberdade}] | Budapeste | {96, 47,4979, 19,0402} | Hungria |
| 1990-09-13T 12:00:00 | NULL | Varsóvia | NULL | Polônia |
**Exemplo 1: nivelar campo struct**
Este exemplo mostra como nivelar um campo struct.
Consulta PPL:
```
source=table | flatten coor
```
| \_time | pontes | cidade | país | alt | lat | longo |
| --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | [{801, Tower Bridge}, {928, London Bridge}] | Londres | Inglaterra | 35 | 51.5074 | -0,1278 |
| 2024-09-13T12:00:00 | [{232, Pont Neuf}, {160, Pont Alexandre III}] | Paris | França | 35 | 48.856 | 2.352 |
| 2024-09-13T12:00:00 | [{48, Ponte Rialto}, {11, Ponte dos Suspiros}] | Veneza | Itália | 2 | 45.4408 | 12.315 |
| 2024-09-13T12:00:00 | [{516, Ponte Carlos}, {343, Ponte da Legião}] | Praga | República Tcheca | 200 | 50.075 | 14.4378 |
| 2024-09-13T12:00:00 | [{375, Ponte Chain}, {333, Ponte da Liberdade}] | Budapeste | Hungria | 96 | 47.4979 | 19.04.02 |
| 1990-09-13T 12:00:00 | NULL | Varsóvia | Polônia | NULL | NULL | NULL |
**Exemplo 2: nivelar matriz**
O exemplo mostra como nivelar uma matriz de campos struct.
Consulta PPL:
```
source=table | flatten bridges
```
| \_time | cidade | coor | país | length | name |
| --- | --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | Londres | {35, 51,5074, -0,1278} | Inglaterra | 801 | Ponte da Torre |
| 2024-09-13T12:00:00 | Londres | {35, 51,5074, -0,1278} | Inglaterra | 928 | Ponte de Londres |
| 2024-09-13T12:00:00 | Paris | {35, 48,8566, 2,3522} | França | 232 | Pont Neuf |
| 2024-09-13T12:00:00 | Paris | {35, 48,8566, 2,3522} | França | 160 | Ponte Alexandre III |
| 2024-09-13T12:00:00 | Veneza | {2, 45,4408, 12,3155} | Itália | 48 | Ponte de Rialto |
| 2024-09-13T12:00:00 | Veneza | {2, 45,4408, 12,3155} | Itália | 11 | Ponte dos Suspiros |
| 2024-09-13T12:00:00 | Praga | {200, 50,0755, 14,4378} | República Tcheca | 516 | Ponte Carlos |
| 2024-09-13T12:00:00 | Praga | {200, 50,0755, 14,4378} | República Tcheca | 343 | Ponte da Legião |
| 2024-09-13T12:00:00 | Budapeste | {96, 47,4979, 19,0402} | Hungria | 375 | Ponte das Correntes |
| 2024-09-13T12:00:00 | Budapeste | {96, 47,4979, 19,0402} | Hungria | 333 | Ponte da Liberdade |
| 1990-09-13T 12:00:00 | Varsóvia | NULL | Polônia | NULL | NULL |
**Exemplo 3: nivelar matriz e struct**
Este exemplo mostra como nivelar vários campos.
Consulta PPL:
```
source=table | flatten bridges | flatten coor
```
| \_time | cidade | país | length | name | alt | lat | longo |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | Londres | Inglaterra | 801 | Ponte da Torre | 35 | 51.5074 | -0,1278 |
| 2024-09-13T12:00:00 | Londres | Inglaterra | 928 | Ponte de Londres | 35 | 51.5074 | -0,1278 |
| 2024-09-13T12:00:00 | Paris | França | 232 | Pont Neuf | 35 | 48.856 | 2.352 |
| 2024-09-13T12:00:00 | Paris | França | 160 | Ponte Alexandre III | 35 | 48.856 | 2.352 |
| 2024-09-13T12:00:00 | Veneza | Itália | 48 | Ponte de Rialto | 2 | 45.4408 | 12.315 |
| 2024-09-13T12:00:00 | Veneza | Itália | 11 | Ponte dos Suspiros | 2 | 45.4408 | 12.315 |
| 2024-09-13T12:00:00 | Praga | República Tcheca | 516 | Ponte Carlos | 200 | 50.075 | 14.4378 |
| 2024-09-13T12:00:00 | Praga | República Tcheca | 343 | Ponte da Legião | 200 | 50.075 | 14.4378 |
| 2024-09-13T12:00:00 | Budapeste | Hungria | 375 | Ponte das Correntes | 96 | 47.4979 | 19.04.02 |
| 2024-09-13T12:00:00 | Budapeste | Hungria | 333 | Ponte da Liberdade | 96 | 47.4979 | 19.04.02 |
| 1990-09-13T 12:00:00 | Varsóvia | Polônia | NULL | NULL | NULL | NULL | NULL |
#### Comando grok
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
O comando `grok` analisa um campo de texto com um padrão grok e acrescenta os resultados ao resultado da pesquisa.
**Sintaxe**
Use a seguinte sintaxe:
```
grok
```
**Campo**
+ Obrigatório.
+ O campo deve ser um campo de texto.
**pattern**
+ Obrigatório.
+ O padrão grok usado para extrair novos campos do campo de texto fornecido.
+ Se um novo nome de campo já existir, ele substituirá o campo original.
**Padrão grok**
O padrão grok é usado para combinar o campo de texto de cada documento para extrair novos campos.
**Exemplo 1: criar o novo campo**
Este exemplo mostra como criar um novo campo `host` para cada documento. `host` será o nome do host depois de `@` no campo `email`. A análise de um campo nulo retornará uma string vazia.
```
os> source=accounts | grok email '.+@%{HOSTNAME:host}' | fields email, host ;
fetched rows / total rows = 4/4
+-------------------------+-------------+
| email | host |
|-------------------------+-------------|
| jane_doe@example.com | example.com |
| arnav_desai@example.net | example.net |
| null | |
| juan_li@example.org | example.org |
+-------------------------+-------------+
```
**Exemplo 2: substituir o campo existente**
Este exemplo mostra como substituir o campo `address` existente pelo número da rua removido.
```
os> source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Any Street |
| Main Street |
| Example Court |
+------------------+
```
**Exemplo 3: usar grok para analisar logs**
Este exemplo mostra como usar grok para analisar logs brutos.
```
os> source=apache | grok message '%{COMMONAPACHELOG}' | fields COMMONAPACHELOG, timestamp, response, bytes ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
| COMMONAPACHELOG | timestamp | response | bytes |
|-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | 28/Sep/2022:10:15:57 -0700 | 404 | 19927 |
| 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | 28/Sep/2022:10:15:57 -0700 | 100 | 28722 |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | 28/Sep/2022:10:15:57 -0700 | 401 | 27439 |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | 28/Sep/2022:10:15:57 -0700 | 301 | 9481 |
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
```
**Limitações**
O comando grok tem as mesmas limitações que o comando parse.
#### Comando head
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `head` para retornar o primeiro N número de resultados especificados após um deslocamento opcional na ordem de pesquisa.
**Sintaxe**
Use a seguinte sintaxe:
```
head [] [from ]
```
****
+ Opcional inteiro.
+ o número máximo de resultados a serem retornados.
+ Padrão: 10
****
+ Inteiro após `from` opcional.
+ O número de resultados a serem ignoradps.
+ Padrão: 0
**Exemplo 1: obter os 10 primeiros resultados**
Este exemplo mostra como recuperar no máximo 10 resultados do índice de contas.
Consulta PPL:
```
os> source=accounts | fields firstname, age | head;
fetched rows / total rows = 4/4
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
**Exemplo 2: obter os N primeiros resultados**
O exemplo mostra os primeiros N resultados do índice de contas.
Consulta PPL:
```
os> source=accounts | fields firstname, age | head 3;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
+-------------+-------+
```
**Exemplo 3: obter os primeiros N resultados após o deslocamento M**
Este exemplo mostra como recuperar os primeiros N resultados depois de ignorar M resultados do índice de contas.
Consulta PPL:
```
os> source=accounts | fields firstname, age | head 3 from 1;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
#### Comando join
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
O comando join permite combinar dados de várias fontes com base em campos comuns, permitindo que você realize análises complexas e obtenha insights mais profundos de seus conjuntos de dados distribuídos
**Schema**
Existem pelo menos dois índices, `otel-v1-apm-span-*` (grande) e `otel-v1-apm-service-map` (pequeno).
Campos relevantes de índices:
**`otel-v1-apm-span-*`**
+ traceId: um identificador exclusivo para um rastreamento. Todos os spans do mesmo rastreamento compartilham o mesmo traceid.
+ spanId: um identificador exclusivo para um span dentro de um rastreamento, atribuído quando o span é criado.
+ parentSpanId - O SpanID do intervalo principal desse período. Se for um span raiz, esse campo deverá ficar vazio.
+ durationInNanos - A diferença em nanossegundos entre StartTime e EndTime. (isso está `latency` na interface do usuário)
+ serviceName: o recurso do qual o span se origina.
+ traceGroup: o nome do span raiz do rastreamento.
**`otel-v1-apm-service-map`**
+ serviceName: o nome do serviço que emitiu o span.
+ destination.domain: o serviceName do serviço chamado por esse cliente.
+ destination.resource: o nome do span (API, operação etc.) chamado por esse cliente.
+ target.domain: o serviceName do serviço sendo chamado por um cliente.
+ target.resource: o nome do span (API, operação etc.) chamado por esse cliente.
+ traceGroupName - O nome do intervalo de nível superior que iniciou a cadeia de solicitações.
**Requisito**
Compatibilidade com **join** para calcular o seguinte:
Para cada serviço, junte o índice de span no índice de mapa do serviço para calcular métricas em diferentes tipos de filtro.
Esse exemplo de consulta calcula a latência quando filtrada pelo grupo de rastreamento `client_cancel_order` para o serviço `order`.
```
SELECT avg(durationInNanos)
FROM `otel-v1-apm-span-000001` t1
WHERE t1.serviceName = `order`
AND ((t1.name in
(SELECT target.resource
FROM `otel-v1-apm-service-map`
WHERE serviceName = `order`
AND traceGroupName = `client_cancel_order`)
AND t1.parentSpanId != NULL)
OR (t1.parentSpanId = NULL
AND t1.name = `client_cancel_order`))
AND t1.traceId in
(SELECT traceId
FROM `otel-v1-apm-span-000001`
WHERE serviceName = `order`)
```
**Migrar para PPL**
Sintaxe do comando join
```
SEARCH source=
|
| [joinType] JOIN
[leftAlias]
ON joinCriteria
|
```
**Reescrever**
```
SEARCH source=otel-v1-apm-span-000001
| WHERE serviceName = 'order'
| JOIN left=t1 right=t2
ON t1.traceId = t2.traceId AND t2.serviceName = 'order'
otel-v1-apm-span-000001 -- self inner join
| EVAL s_name = t1.name -- rename to avoid ambiguous
| EVAL s_parentSpanId = t1.parentSpanId -- RENAME command would be better when it is supported
| EVAL s_durationInNanos = t1.durationInNanos
| FIELDS s_name, s_parentSpanId, s_durationInNanos -- reduce colunms in join
| LEFT JOIN left=s1 right=t3
ON s_name = t3.target.resource AND t3.serviceName = 'order' AND t3.traceGroupName = 'client_cancel_order'
otel-v1-apm-service-map
| WHERE (s_parentSpanId IS NOT NULL OR (s_parentSpanId IS NULL AND s_name = 'client_cancel_order'))
| STATS avg(s_durationInNanos) -- no need to add alias if there is no ambiguous
```
**joinType**
+ Sintaxe: `INNER | LEFT OUTER | CROSS`
+ Opcional
+ O tipo de união a ser realizada. Se não especificada, o padrão será `INNER`.
**leftAlias**
+ Sintaxe: `left = `
+ Opcional
+ O alias da subconsulta a ser usado com o left join side, para evitar nomenclaturas ambíguas.
**joinCriteria**
+ Sintaxe: ``
+ Obrigatório
+ A sintaxe começa com `ON`. Pode ser qualquer expressão de comparação. Geralmente, o critério de união é assim: `.=.`.
Por exemplo: `l.id = r.id`. Se o critério de união contiver várias condições, você poderá especificar o operador `AND` e `OR` entre cada expressão de comparação. Por exemplo, .`l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)`
**Mais exemplos de**
Migração de consulta SQL (TPC-H Q13):
```
SELECT c_count, COUNT(*) AS custdist
FROM
( SELECT c_custkey, COUNT(o_orderkey) c_count
FROM customer LEFT OUTER JOIN orders ON c_custkey = o_custkey
AND o_comment NOT LIKE '%unusual%packages%'
GROUP BY c_custkey
) AS c_orders
GROUP BY c_count
ORDER BY custdist DESC, c_count DESC;
```
Reescrito pela consulta PPL join:
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey AND o_comment NOT LIKE '%unusual%packages%'
orders
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
Limitação: join right side não permite subpesquisas.
Se forem permitidas subpesquisas, você poderá reescrever a consulta PPL acima da seguinte forma:
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
#### Comando lookup
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `lookup` para enriquecer os dados de pesquisa adicionando ou substituindo dados de um índice de pesquisa (tabela de dimensões). Esse comando permite estender campos de um índice com os valores de uma tabela de dimensões. Você também pode usá-lo para acrescentar ou substituir valores quando as condições de pesquisa forem atendidas. O comando `lookup` é mais adequado do que o comando `Join` para enriquecer os dados da fonte com um conjunto de dados estático.
**Sintaxe**
Use a seguinte sintaxe:
```
SEARCH source=
|
| LOOKUP ( [AS ])...
[(REPLACE | APPEND) ( [AS ])...]
|
```
**lookupIndex**
+ Obrigatório.
+ O nome do índice de pesquisa (tabela de dimensões).
**lookupMappingField**
+ Obrigatório.
+ Uma chave de mapeamento no índice de pesquisa, análoga a uma chave de união da tabela da direita. É possível especificar vários campos separados por vírgulas.
**sourceMappingField**
+ Opcional.
+ Padrão: < lookupMappingField >.
+ Uma chave de mapeamento da consulta de origem, análoga a uma chave de união do lado esquerdo.
**inputField**
+ Opcional.
+ Padrão: todos os campos do índice de pesquisa nos quais valores correspondentes são encontrados.
+ Um campo no índice de pesquisa nos quais valores correspondentes são aplicados à saída do resultado. É possível especificar vários campos separados por vírgulas.
**outputField**
+ Opcional.
+ Padrão: ``.
+ Um campo na saída. Você pode especificar vários campos de saída. Se você especificar um nome de campo existente na consulta de origem, seus valores serão substituídos ou acrescidos dos valores correspondentes de inputField. Se você especificar um novo nome de campo, ele será adicionado aos resultados.
**REPLACE \| APPEND**
+ Opcional.
+ Padrão: REPLACE
+ Especifica como lidar com valores correspondentes. Se você especificar REPLACE, os valores correspondentes no campo substituirão os valores no resultado. Se você especificar `APPEND`, os valores correspondentes no campo serão acrescentados apenas aos valores que faltam no resultado.
**Usage**
+ LOOKUP id AS cid REPLACE mail AS email
+ LOOKUP name REPLACE mail AS email
+ LOOKUP id AS cid, name APPEND address, mail AS email
+ LOOKUP id
**Exemplo**
Veja os exemplos de a seguir.
```
SEARCH source=
| WHERE orderType = 'Cancelled'
| LOOKUP account_list, mkt_id AS mkt_code REPLACE amount, account_name AS name
| STATS count(mkt_code), avg(amount) BY name
```
```
SEARCH source=
| DEDUP market_id
| EVAL category=replace(category, "-", ".")
| EVAL category=ltrim(category, "dvp.")
| LOOKUP bounce_category category AS category APPEND classification
```
```
SEARCH source=
| LOOKUP bounce_category category
```
#### comando parse
O comando `parse` analisa um campo de texto com uma expressão regular e acrescenta o resultado ao resultado da pesquisa.
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Sintaxe**
Use a seguinte sintaxe:
```
parse
```
**`field`**
+ Obrigatório.
+ O campo deve ser um campo de texto.
**`pattern`**
+ String obrigatória.
+ Esse é um padrão de expressão regular usado para extrair novos campos do campo de texto fornecido.
+ Se um novo nome de campo já existir, ele substituirá o campo original.
**Expressão regular**
O padrão de expressão regular é usado para combinar todo o campo de texto de cada documento com o mecanismo Java regex. Cada grupo de captura nomeado na expressão se tornará um novo campo `STRING`.
**Exemplo 1: criar um novo campo**
O exemplo mostra como criar um novo campo `host` para cada documento. `host` será o nome do host depois de `@` no campo `email`. A análise de um campo nulo retornará uma string vazia.
Consulta PPL:
```
os> source=accounts | parse email '.+@(?.+)' | fields email, host ;
fetched rows / total rows = 4/4
+-----------------------+-------------+
| email | host |
|-----------------------+-------------|
| jane_doe@example.com | example.com |
| john_doe@example.net | example.net |
| null | |
| juan_li@example.org | example.org |
+-----------------------+-------------+
```
**Exemplo 2: substituir um campo existente**
O exemplo mostra como substituir o campo `address` existente pelo número da rua removido.
Consulta PPL:
```
os> source=accounts | parse address '\d+ (?.+)' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Example Street |
| Example Avenue |
| Example Court |
+------------------+
```
**Exemplo 3: filtrar e classificar por campo analisado convertido**
O exemplo mostra como classificar números de ruas acima de 500 no campo `address`.
Consulta PPL:
```
os> source=accounts | parse address '(?\d+) (?.+)' | where cast(streetNumber as int) > 500 | sort num(streetNumber) | fields streetNumber, street ;
fetched rows / total rows = 3/3
+----------------+----------------+
| streetNumber | street |
|----------------+----------------|
| *** | Example Street |
| *** | Example Avenue |
| 880 | Example Lane |
+----------------+----------------+
```
**Limitações**
Há algumas limitações com o comando parse:
+ Campos definidos por parse não podem ser analisados novamente.
O seguinte comando não funcionará:
```
source=accounts | parse address '\d+ (?.+)' | parse street '\w+ (?\w+)'
```
+ Os campos definidos por parse não podem ser substituídos por outros comandos.
`where` não corresponderá a nenhum documento, pois `street` não pode ser substituído:
```
source=accounts | parse address '\d+ (?.+)' | eval street='1' | where street='1' ;
```
+ O campo de texto usado por parse não pode ser substituído.
`street` não será analisado com sucesso, pois foi `address` substituído:
```
source=accounts | parse address '\d+ (?.+)' | eval address='1' ;
```
+ Os campos definidos por parse não podem ser filtrados nem classificados após serem usados no comando `stats`.
`where` no seguinte comando não funcionará:
```
source=accounts | parse email '.+@(?.+)' | stats avg(age) by host | where host=pyrami.com ;
```
#### Comando patterns
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
O comando `patterns` extrai padrões de log de um campo de texto e acrescenta os resultados ao resultado da pesquisa. Agrupar os logs por seus padrões facilita a agregação de estatísticas de grandes volumes de dados de log para análise e solução de problemas.
**Sintaxe**
Use a seguinte sintaxe:
```
patterns [new_field=] [pattern=]
```
**new-field-name**
+ String opcional.
+ Esse é o nome do novo campo para padrões extraídos.
+ O padrão é `patterns_field`.
+ Se o nome já existir, ele substituirá o campo original.
**pattern**
+ String opcional.
+ Esse é o padrão regex de caracteres que devem ser filtrados para serem excluídos do campo de texto.
+ Se ausente, o padrão são os caracteres alfanuméricos (`[a-zA-Z\d]`).
**Campo**
+ Obrigatório.
+ O campo deve ser um campo de texto.
**Exemplo 1: criar o novo campo**
O exemplo mostra como usar pontuações de extração em `email` para cada documento. A análise de um campo nulo retornará uma string vazia.
Consulta PPL:
```
os> source=accounts | patterns email | fields email, patterns_field ;
fetched rows / total rows = 4/4
+-----------------------+------------------+
| email | patterns_field |
|-----------------------+------------------|
| jane_doe@example.com | @. |
| john_doe@example.net | @. |
| null | |
| juan_li@example.org | @. |
+-----------------------+------------------+
```
**Exemplo 2: extrair padrões de log**
O exemplo mostra como extrair pontuações de um campo de log bruto usando os padrões padrão.
Consulta PPL:
```
os> source=apache | patterns message | fields message, patterns_field ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
| message | patterns_field |
|-----------------------------------------------------------------------------------------------------------------------------+---------------------------------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - [//::: -] " /-/ /." |
| ************ - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - [//::: -] " //// /." |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [//::: -] " //--- /." |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [//::: -] " / /." |
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
```
**Exemplo 3: extrair padrões de log com padrão regex personalizado**
O exemplo mostra como extrair pontuações de um campo de log bruto usando os padrões definidos pelo usuário.
Consulta PPL:
```
os> source=apache | patterns new_field='no_numbers' pattern='[0-9]' message | fields message, no_numbers ;
fetched rows / total rows = 4/4
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
| message | no_numbers |
|-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------|
| 177.95.8.74 - upton5450 [28/Sep/2022:10:15:57 -0700] "HEAD /e-business/mindshare HTTP/1.0" 404 19927 | ... - upton [/Sep/::: -] "HEAD /e-business/mindshare HTTP/." |
| 127.45.152.6 - pouros8756 [28/Sep/2022:10:15:57 -0700] "GET /architectures/convergence/niches/mindshare HTTP/1.0" 100 28722 | ... - pouros [/Sep/::: -] "GET /architectures/convergence/niches/mindshare HTTP/." |
| *************** - - [28/Sep/2022:10:15:57 -0700] "PATCH /strategize/out-of-the-box HTTP/1.0" 401 27439 | ... - - [/Sep/::: -] "PATCH /strategize/out-of-the-box HTTP/." |
| ************** - - [28/Sep/2022:10:15:57 -0700] "POST /users HTTP/1.1" 301 9481 | ... - - [/Sep/::: -] "POST /users HTTP/." |
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
```
**Limitação**
O comando patterns tem as mesmas limitações que o comando parse.
#### Comando rare
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `rare` para encontrar a tupla de valores menos comum de todos os campos na lista de campos.
**nota**
Um máximo de 10 resultados é retornado para cada tupla distinta de valores dos campos group-by.
**Sintaxe**
Use a seguinte sintaxe:
```
rare [N] [by-clause] rare_approx [N] [by-clause]
```
**field-list**
+ Obrigatório.
+ Uma lista de nomes de campos delimitada por vírgulas.
**by-clause**
+ Opcional.
+ Um ou mais campos pelos quais agrupar os resultados.
**N**
+ o número máximo de resultados a serem retornados.
+ Padrão: 10
**rare\_approx**
+ A contagem aproximada dos campos raros (n) usando a [cardinalidade estimada pelo HyperLogLog](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html) algoritmo \+\+.
**Exemplo 1: encontre os valores menos comuns em um campo**
O exemplo encontra o sexo menos comum de todas as contas.
Consulta PPL:
```
os> source=accounts | rare gender;
os> source=accounts | rare_approx 10 gender;
os> source=accounts | rare_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| F |
| M |
+----------+
```
**Exemplo 2: encontre os valores menos comuns organizados por sexo**
O exemplo encontra o sexo menos comum de todas as contas agrupadas por sexo.
Consulta PPL:
```
os> source=accounts | rare 5 age by gender;
os> source=accounts | rare_approx 5 age by gender;
fetched rows / total rows = 4/4
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
| M | 33 |
| M | 36 |
+----------+-------+
```
#### Comando rename
Use o comando `rename` para alterar os nomes de um ou mais campos no resultado da pesquisa.
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Sintaxe**
Use a seguinte sintaxe:
```
rename AS ["," AS ]...
```
**source-field**
+ Obrigatório.
+ Esse é o nome do campo que você deseja renomear.
**target-field**
+ Obrigatório.
+ Esse é o nome com o qual você deseja renomear o campo.
**Exemplo 1: renomear um campo**
Este exemplo mostra como renomear um único campo.
Consulta PPL:
```
os> source=accounts | rename account_number as an | fields an;
fetched rows / total rows = 4/4
+------+
| an |
|------|
| 1 |
| 6 |
| 13 |
| 18 |
+------+
```
**Exemplo 2: renomear vários campos**
Este exemplo mostra como renomear vários campos.
Consulta PPL:
```
os> source=accounts | rename account_number as an, employer as emp | fields an, emp;
fetched rows / total rows = 4/4
+------+---------+
| an | emp |
|------+---------|
| 1 | Pyrami |
| 6 | Netagy |
| 13 | Quility |
| 18 | null |
+------+---------+
```
**Limitações**
+ Não é possível substituir campo existente:
```
source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address
```
#### Comando search
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `search` para recuperar documentos de um índice. O comando `search` apenas pode ser usado como o primeiro comando em uma consulta PPL.
**Sintaxe**
Use a seguinte sintaxe:
```
search source=[:] [boolean-expression]
```
**pesquisar**
+ Opcional.
+ Palavras-chave de pesquisa, que podem ser omitidas.
**índice**
+ Obrigatório.
+ O comando search deve especificar em qual índice consultar.
+ O nome do índice pode ser prefixado por `:` para pesquisas entre clusters.
**bool-expression**
+ Opcional.
+ Qualquer expressão que seja avaliada como um valor booleano.
**Exemplo 1: buscar todos os dados**
O exemplo mostra a busca de todo o documento do índice de contas.
Consulta PPL:
```
os> source=accounts;
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
| account_number | firstname | address | balance | gender | city | employer | state | age | email | lastname |
|------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------|
| 1 | Jorge | *** Any Lane | 39225 | M | Brogan | ExampleCorp | IL | 32 | jane_doe@example.com | Souza |
| 6 | John | *** Example Street | 5686 | M | Dante | AnyCorp | TN | 36 | john_doe@example.com | Doe |
| 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe |
| 18 | Juan | *** Example Court | 4180 | M | Orick | null | MD | 33 | juan_li@example.org | Li |
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
```
**Exemplo 2: buscar dados com condição**
O exemplo mostra a busca de todo o documento do índice de contas com uma condição.
Consulta PPL:
```
os> SEARCH source=accounts account_number=1 or gender="F";
+------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------+
| account_number | firstname | address | balance | gender | city | employer | state | age | email - | lastname |
|------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------|
| 1 | Jorge | *** Any Lane | ***** | M | Brogan | ExampleCorp | IL | 32 | jorge_souza@example.com | Souza |
| 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe |
+------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+
```
#### Comando sort
Use o comando `sort` para classificar o resultado da pesquisa por campos especificados.
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Sintaxe**
Use a seguinte sintaxe:
```
sort <[+|-] sort-field>...
```
**[\+\|-]**
+ Opcional.
+ O sinal de mais [\+] significa ordem crescente com NULL/MISSING os valores primeiro.
+ O sinal de menos [-] representa a ordem decrescente com NULL/MISSING os valores por último.
+ Padrão: ordem crescente com NULL/MISSING os valores primeiro.
**sort-field**
+ Obrigatório.
+ O campo usado para classificação.
**Exemplo 1: classificar por um campo**
O exemplo mostra como classificar o documento com o campo de idade em ordem crescente.
Consulta PPL:
```
os> source=accounts | sort age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 13 | 28 |
| 1 | 32 |
| 18 | 33 |
| 6 | 36 |
+------------------+-------+
```
**Exemplo 2: classificar por um único campo e retornar todos os resultados**
O exemplo mostra como classificar o documento com o campo de idade em ordem crescente.
Consulta PPL:
```
os> source=accounts | sort age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 13 | 28 |
| 1 | 32 |
| 18 | 33 |
| 6 | 36 |
+------------------+-------+
```
**Exemplo 3: classificar por um único campo em ordem decrescente**
O exemplo mostra como classificar o documento com o campo de idade em ordem decrescente.
Consulta PPL:
```
os> source=accounts | sort - age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number | age |
|------------------+-------|
| 6 | 36 |
| 18 | 33 |
| 1 | 32 |
| 13 | 28 |
+------------------+-------+
```
**Exemplo 4: classificar por vários campos**
O exemplo mostra como classificar o documento com o campo de sexo em ordem crescente e o campo de idade em ordem decrescente.
Consulta PPL:
```
os> source=accounts | sort + gender, - age | fields account_number, gender, age;
fetched rows / total rows = 4/4
+------------------+----------+-------+
| account_number | gender | age |
|------------------+----------+-------|
| 13 | F | 28 |
| 6 | M | 36 |
| 18 | M | 33 |
| 1 | M | 32 |
+------------------+----------+-------+
```
**Exemplo 5: classificar por campo e incluir valor nulo**
O exemplo mostra como classificar o campo do empregador pela opção padrão (ordem crescente e nulo primeiro). O resultado mostra que o valor nulo está na primeira linha.
Consulta PPL:
```
os> source=accounts | sort employer | fields employer;
fetched rows / total rows = 4/4
+------------+
| employer |
|------------|
| null |
| AnyCompany |
| AnyCorp |
| AnyOrgty |
+------------+
```
#### Comando stats
Use o comando `stats` para calcular a agregação a partir do resultado da pesquisa.
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Manipulação de valores NULL/MISSING**
**Manipulação de valores NULL/MISSING**
| Função | NULL | MISSING (AUSENTE) |
| --- | --- | --- |
| CONTAGEM | Não contado | Não contado |
| SUM | Ignorar | Ignorar |
| AVG | Ignorar | Ignorar |
| MAX | Ignorar | Ignorar |
| MIN | Ignorar | Ignorar |
**Sintaxe**
Use a seguinte sintaxe:
```
stats ... [by-clause]
```
**agregação**
+ Obrigatório.
+ Uma função de agregação aplicada a um campo.
**by-clause**
+ Opcional.
+ Sintaxe: `by [span-expression,] [field,]...`
+ Especifica campos e expressões para agrupar os resultados da agregação. A by-clause permite agrupar os resultados da agregação usando campos e expressões. Você pode usar funções escalares, funções de agregação e até mesmo expressões de span para dividir campos específicos em buckets de intervalos iguais.
+ Padrão: se `` não for especificado, o comando stats retornará uma única linha representando a agregação para todo o conjunto de resultados.
**span-expression**
+ Opcional, no máximo um.
+ Sintaxe: `span(field_expr, interval_expr)`
+ A unidade da expressão de intervalo é a unidade natural por padrão. Se o campo for do tipo data e hora e o intervalo estiver em date/time unidades, você especifica a unidade na expressão do intervalo.
+ Por exemplo, a divisão do campo `age` em buckets por 10 anos, fica assim `span(age, 10)`. Para dividir um campo de timestamp em intervalos de uma hora, use `span(timestamp, 1h)`.
**Unidades de tempo disponíveis**
| Unidades de intervalo de span |
| --- |
| millisegundos (ms) |
| segundo (s) |
| minuto (m, diferencia maiúsculas de minúsculas) |
| hora (h) |
| dia (d) |
| semana (w) |
| mês (M, diferencia maiúsculas de minúsculas) |
| trimestre (q) |
| ano (y) |
**Funções de agregação**
**`COUNT`**
Retorna uma contagem do número de expr nas linhas recuperadas por uma instrução SELECT.
Exemplo:
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**`SUM`**
Use `SUM(expr)` para retornar a soma de expr.
Exemplo
```
os> source=accounts | stats sum(age) by gender;
fetched rows / total rows = 2/2
+------------+----------+
| sum(age) | gender |
|------------+----------|
| 28 | F |
| 101 | M |
+------------+----------+
```
**`AVG`**
Use `AVG(expr)` para retornar o valor médio de expr.
Exemplo
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**`MAX`**
Use `MAX(expr)` para retornar o valor máximo de expr.
Exemplo
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**`MIN`**
Use `MIN(expr)` para retornar o valor mínimo de expr.
Exemplo
```
os> source=accounts | stats min(age);
fetched rows / total rows = 1/1
+------------+
| min(age) |
|------------|
| 28 |
+------------+
```
**`STDDEV_SAMP`**
Use `STDDEV_SAMP(expr)` para retornar o desvio padrão da amostra de expr.
Exemplo:
```
os> source=accounts | stats stddev_samp(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_samp(age) |
|--------------------|
| 3.304037933599835 |
+--------------------+
```
**STDDEV\_POP**
Use `STDDEV_POP(expr)` para retornar o desvio padrão da população de expr.
Exemplo:
```
os> source=accounts | stats stddev_pop(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_pop(age) |
|--------------------|
| 2.**************** |
+--------------------+
```
**TAKE**
Use `TAKE(field [, size])` para retornar os valores originais de um campo. Não garante a ordem dos valores.
**Campo**
+ Obrigatório.
+ O campo deve ser um campo de texto.
**size**
+ Opcional inteiro.
+ O número de valores deve ser retornado.
+ O padrão é 10.
**Exemplo**
```
os> source=accounts | stats take(firstname);
fetched rows / total rows = 1/1
+-----------------------------+
| take(firstname) |
|-----------------------------|
| [Jane, Mary, Nikki, Juan |
+-----------------------------+
```
**PERCENTILE ou PERCENTILE\_APPROX**
Use `PERCENTILE(expr, percent)` ou `PERCENTILE_APPROX(expr, percent)` para retornar o percentil aproximado de expr na porcentagem especificada.
**percentual**
+ O número deve ser uma constante entre 0 e 100.
**Exemplo**
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Exemplo 1: calcular a contagem de eventos**
O exemplo mostra como calcular a contagem de eventos nas contas.
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**Exemplo 2: calcular a média de um campo**
O exemplo mostra como calcular a idade média de todas as contas.
```
os> source=accounts | stats avg(age);
fetched rows / total rows = 1/1
+------------+
| avg(age) |
|------------|
| 32.25 |
+------------+
```
**Exemplo 3: calcular a média de um campo por grupo**
O exemplo mostra como calcular a idade média de todas as contas, agrupadas por sexo.
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**Exemplo 4: calcular a média, a soma e a contagem de um campo por grupo**
O exemplo mostra como calcular a idade média, a soma da idade e a contagem de eventos de todas as contas agrupadas por sexo.
```
os> source=accounts | stats avg(age), sum(age), count() by gender;
fetched rows / total rows = 2/2
+--------------------+------------+-----------+----------+
| avg(age) | sum(age) | count() | gender |
|--------------------+------------+-----------+----------|
| 28.0 | 28 | 1 | F |
| 33.666666666666664 | 101 | 3 | M |
+--------------------+------------+-----------+----------+
```
**Exemplo 5: calcular o máximo de um campo**
O exemplo calcula a idade máxima para todas as contas.
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**Exemplo 6: calcular o máximo e o mínimo de um campo por grupo**
O exemplo calcula os valores de idade máxima e mínima para todas as contas, agrupados por sexo.
```
os> source=accounts | stats max(age), min(age) by gender;
fetched rows / total rows = 2/2
+------------+------------+----------+
| max(age) | min(age) | gender |
|------------+------------+----------|
| 28 | 28 | F |
| 36 | 32 | M |
+------------+------------+----------+
```
**Exemplo 7: calcular a contagem distinta de um campo**
Para obter a contagem de valores distintos de um campo, você pode usar a função `DISTINCT_COUNT` (ou `DC`) em vez de `COUNT`. O exemplo calcula a contagem e a contagem distinta do campo sexode todas as contas.
```
os> source=accounts | stats count(gender), distinct_count(gender);
fetched rows / total rows = 1/1
+-----------------+--------------------------+
| count(gender) | distinct_count(gender) |
|-----------------+--------------------------|
| 4 | 2 |
+-----------------+--------------------------+
```
**Exemplo 8: calcular a contagem por um span**
O exemplo obtém a contagem de idade pelo intervalo de 10 anos.
```
os> source=accounts | stats count(age) by span(age, 10) as age_span
fetched rows / total rows = 2/2
+--------------+------------+
| count(age) | age_span |
|--------------+------------|
| 1 | 20 |
| 3 | 30 |
+--------------+------------+
```
**Exemplo 9: calcular a contagem por um sexo e span**
Este exemplo conta registros agrupados por sexo e spans de idade de 5 anos.
```
os> source=accounts | stats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+------------+----------+
| cnt | age_span | gender |
|-------+------------+----------|
| 1 | 25 | F |
| 2 | 30 | M |
| 1 | 35 | M |
+-------+------------+----------+
```
A expressão span sempre aparece como a primeira chave de agrupamento, independentemente da ordem especificada no comando.
```
os> source=accounts | stats count() as cnt by gender, span(age, 5) as age_span
fetched rows / total rows = 3/3
+-------+------------+----------+
| cnt | age_span | gender |
|-------+------------+----------|
| 1 | 25 | F |
| 2 | 30 | M |
| 1 | 35 | M |
+-------+------------+----------+
```
**Exemplo 10: calcular a contagem e receber lista de e-mail por um sexo e span**
O exemplo obtém a contagem da idade pelo intervalo de 10 anos e agrupa por sexo. Além disso, para cada linha, obtém uma lista de até 5 e-mails.
```
os> source=accounts | stats count() as cnt, take(email, 5) by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+----------------------------------------------------+------------+----------+
| cnt | take(email, 5) | age_span | gender |
|-------+----------------------------------------------------+------------+----------|
| 1 | [] | 25 | F |
| 2 | [janedoe@anycompany.com,juanli@examplecompany.org] | 30 | M |
| 1 | [marymajor@examplecorp.com] | 35 | M |
+-------+----------------------------------------------------+------------+----------+
```
**Exemplo 11: calcular o percentil de um campo**
O exemplo mostra como calcular a idade do percentil 90 de todas as contas.
```
os> source=accounts | stats percentile(age, 90);
fetched rows / total rows = 1/1
+-----------------------+
| percentile(age, 90) |
|-----------------------|
| 36 |
+-----------------------+
```
**Exemplo 12: calcular o percentil de um campo por grupo**
O exemplo mostra como calcular a idade do percentil 90 de todas as contas por sexo.
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Exemplo 13: calcular o percentil por um sexo e span**
O exemplo obtém a idade do percentil 90 pelo intervalo de 10 anos e agrupa por gênero.
```
os> source=accounts | stats percentile(age, 90) as p90 by span(age, 10) as age_span, gender
fetched rows / total rows = 2/2
+-------+------------+----------+
| p90 | age_span | gender |
|-------+------------+----------|
| 28 | 20 | F |
| 36 | 30 | M |
+-------+------------+----------+
```
```
- `source = table | stats avg(a) `
- `source = table | where a < 50 | stats avg(c) `
- `source = table | stats max(c) by b`
- `source = table | stats count(c) by b | head 5`
- `source = table | stats distinct_count(c)`
- `source = table | stats stddev_samp(c)`
- `source = table | stats stddev_pop(c)`
- `source = table | stats percentile(c, 90)`
- `source = table | stats percentile_approx(c, 99)`
```
**Agregações com span**
```
- `source = table | stats count(a) by span(a, 10) as a_span`
- `source = table | stats sum(age) by span(age, 5) as age_span | head 2`
- `source = table | stats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
```
**Agregações com span de janela de tempo (função de janela tumble)**
```
- `source = table | stats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
- `source = table | stats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
```
**Grupo de agregações por vários níveis**
```
- `source = table | stats avg(age) as avg_state_age by country, state | stats avg(avg_state_age) as avg_country_age by country`
- `source = table | stats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | stats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | stats avg(avg_state_age) as avg_adult_country_age by country`
```
#### Comando subquery
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `subquery` para realizar consultas complexas e aninhadas em instruções Piped Processing Language (PPL).
```
source=logs | where field in [ subquery source=events | where condition | fields field ]
```
Neste exemplo, a pesquisa primária (`source=logs`) é filtrada pelos resultados da subconsulta (`source=events`).
O comando subquery é compatível com a vários níveis de aninhamento para análise de dados complexos.
**Exemplo de subconsulta aninhada**
```
source=logs | where id in [ subquery source=users | where user in [ subquery source=actions | where action="login" | fields user] | fields uid ]
```
**InSubquery Uso**
+ `source = outer | where a in [ source = inner | fields b ]`
+ `source = outer | where (a) in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) in [ source = inner | fields d,e,f ]`
+ `source = outer | where a not in [ source = inner | fields b ]`
+ `source = outer | where (a) not in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) not in [ source = inner | fields d,e,f ]`
+ `source = outer a in [ source = inner | fields b ]` (filtragem de pesquisa com subconsulta)
+ `source = outer a not in [ source = inner | fields b ]` (filtragem de pesquisa com subconsulta)
+ `source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ]` (aninhada)
+ `source = table1 | inner join left = l right = r on l.a = r.a AND r.a in [ source = inner | fields d ] | fields l.a, r.a, b, c` (como filtro join)
**Exemplos de migração de SQL com PPL IN-Subquery**
TPC-H Q4 (in-subquery com agregação)
```
select
o_orderpriority,
count(*) as order_count
from
orders
where
o_orderdate >= date '1993-07-01'
and o_orderdate < date '1993-07-01' + interval '3' month
and o_orderkey in (
select
l_orderkey
from
lineitem
where l_commitdate < l_receiptdate
)
group by
o_orderpriority
order by
o_orderpriority
```
Reescrito pela consulta PPL: InSubquery
```
source = orders
| where o_orderdate >= "1993-07-01" and o_orderdate < "1993-10-01" and o_orderkey IN
[ source = lineitem
| where l_commitdate < l_receiptdate
| fields l_orderkey
]
| stats count(1) as order_count by o_orderpriority
| sort o_orderpriority
| fields o_orderpriority, order_count
```
TPC-H Q20 (aninhado em subconsulta)
```
select
s_name,
s_address
from
supplier,
nation
where
s_suppkey in (
select
ps_suppkey
from
partsupp
where
ps_partkey in (
select
p_partkey
from
part
where
p_name like 'forest%'
)
)
and s_nationkey = n_nationkey
and n_name = 'CANADA'
order by
s_name
```
Reescrito pela consulta PPL: InSubquery
```
source = supplier
| where s_suppkey IN [
source = partsupp
| where ps_partkey IN [
source = part
| where like(p_name, "forest%")
| fields p_partkey
]
| fields ps_suppkey
]
| inner join left=l right=r on s_nationkey = n_nationkey and n_name = 'CANADA'
nation
| sort s_name
```
**ExistsSubquery uso**
Pressupostos: `a`, `b` são campos de tabela externa; `c`, `d` são campos de tabela interna e `e`, `f` são campos da tabela interna2.
+ `source = outer | where exists [ source = inner | where a = c ]`
+ `source = outer | where not exists [ source = inner | where a = c ]`
+ `source = outer | where exists [ source = inner | where a = c and b = d ]`
+ `source = outer | where not exists [ source = inner | where a = c and b = d ]`
+ `source = outer exists [ source = inner | where a = c ]` (filtragem de pesquisa com subconsulta)
+ `source = outer not exists [ source = inner | where a = c ]` (filtragem de pesquisa com subconsulta)
+ `source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ]` (alias de tabela é útil em subconsulta exists)
+ `source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ]` (aninhada)
+ `source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ]` (aninhada)
+ `source = outer | where exists [ source = inner | where c > 10 ]` (existe não correlacionado)
+ `source = outer | where not exists [ source = inner | where c > 10 ]` (existe não correlacionado)
+ `source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l` (existe não correlacionado especial)
**ScalarSubquery uso**
Pressupostos: `a`, `b` são campos de tabela externa; `c`, `d` são campos de tabela interna e `e`, `f` são campos da tabela aninhada
**Subconsulta escalar não correlacionada**
Em Select:
+ `source = outer | eval m = [ source = inner | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | stats max(c) ] + b | fields m, a`
Em Where:
+ `source = outer | where a > [ source = inner | stats min(c) ] | fields a`
Em filtro Search:
+ `source = outer a > [ source = inner | stats min(c) ] | fields a`
**Subconsulta escalar correlacionada**
Em Select:
+ `source = outer | eval m = [ source = inner | where outer.b = inner.d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where b = d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where outer.b > inner.d | stats max(c) ] | fields m, a`
Em Where:
+ `source = outer | where a = [ source = inner | where outer.b = inner.d | stats max(c) ]`
+ `source = outer | where a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer | where [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
Em filtro Search:
+ `source = outer a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
**Subconsulta escalar aninhada**
+ `source = outer | where a = [ source = inner | stats max(c) | sort c ] OR b = [ source = inner | where c = 1 | stats min(d) | sort d ]`
+ `source = outer | where a = [ source = inner | where c = [ source = nested | stats max(e) by f | sort f ] | stats max(d) by c | sort c | head 1 ]`
**(Relação) Subconsulta**
`InSubquery`, `ExistsSubquery` e `ScalarSubquery` são expressões de subconsulta. Mas `RelationSubquery` não é uma expressão de subconsulta, é um plano de subconsulta que é comumente usado na cláusula Join ou From.
+ `source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ]` (subconsulta em join right side)
+ `source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1`
**Contexto adicional**
`InSubquery`, `ExistsSubquery` e `ScalarSubquery` são expressões de subconsulta usadas frequentemente em cláusulas e filtros de pesquisa `where`.
Comando Where:
```
| where | ...
```
Filtro de pesquisa:
```
search source=* | ...
```
Uma expressão de subconsulta pode ser usada em uma expressão booleana:
```
| where orders.order_id in [ source=returns | where return_reason="damaged" | field order_id ]
```
O `orders.order_id in [ source=... ]` é uma ``.
Em geral, chamamos esse tipo de cláusula de subconsulta é a expressão `InSubquery`. É uma ``.
**Subconsulta com diferentes tipos join**
Exemplo usando um `ScalarSubquery`:
```
source=employees
| join source=sales on employees.employee_id = sales.employee_id
| where sales.sale_amount > [ source=targets | where target_met="true" | fields target_value ]
```
Ao contrário de InSubquery ExistsSubquery,, e ScalarSubquery, a não RelationSubquery é uma expressão de subconsulta. É um plano de subconsulta.
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN left = c, right = o ON c.c_custkey = o.o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS ...
```
#### Comando top
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `top` para encontrar a tupla de valores mais comum de todos os campos na lista de campos.
**Sintaxe**
Use a seguinte sintaxe:
```
top [N] [by-clause] top_approx [N] [by-clause]
```
**N**
+ o número máximo de resultados a serem retornados.
+ Padrão: 10
**field-list**
+ Obrigatório.
+ Uma lista de nomes de campos delimitada por vírgulas.
**by-clause**
+ Opcional.
+ Um ou mais campos pelos quais agrupar os resultados.
**top\_approx**
+ Uma contagem aproximada dos (n) principais campos usando a [cardinalidade estimada pelo HyperLogLog](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html) algoritmo \+\+.
**Exemplo 1: encontrar os valores mais comuns em um campo**
O exemplo encontra o sexo mais comum para todas as contas.
Consulta PPL:
```
os> source=accounts | top gender;
os> source=accounts | top_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Exemplo 2: encontrar os valores mais comuns em um campo (limitado a 1)**
O exemplo encontra o sexo mais comum de todos para todas as contas.
Consulta PPL:
```
os> source=accounts | top_approx 1 gender;
fetched rows / total rows = 1/1
+----------+
| gender |
|----------|
| M |
+----------+
```
**Exemplo 3: encontrar os valores mais comuns, agrupados por gênero**
O exemplo encontra a idade mais comum para todas as contas, agrupadas por gênero.
Consulta PPL:
```
os> source=accounts | top 1 age by gender;
os> source=accounts | top_approx 1 age by gender;
fetched rows / total rows = 2/2
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
+----------+-------+
```
#### Comando trendline
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `trendline` para calcular as médias móveis dos campos.
**Sintaxe**
Use a sintaxe a seguir
```
TRENDLINE [sort <[+|-] sort-field>] SMA(number-of-datapoints, field) [AS alias] [SMA(number-of-datapoints, field) [AS alias]]...
```
**[\+\|-]**
+ Opcional.
+ O sinal de mais [\+] significa ordem crescente com NULL/MISSING os valores primeiro.
+ O sinal de menos [-] representa a ordem decrescente com NULL/MISSING os valores por último.
+ Padrão: ordem crescente com NULL/MISSING os valores primeiro.
**sort-field**
+ Obrigatório quando a classificação é usada.
+ O campo usado para classificação.
**number-of-datapoints**
+ Obrigatório.
+ O número de pontos de dados que calculam a média móvel.
+ Deve ser maior do que zero.
**Campo**
+ Obrigatório.
+ O nome do campo para o qual a média móvel deve ser calculada.
**alias**
+ Opcional.
+ O nome da coluna resultante que contém a média móvel.
Somente o tipo Simple Moving Average (SMA) é compatível. É calculado assim:
```
f[i]: The value of field 'f' in the i-th data-point
n: The number of data-points in the moving window (period)
t: The current time index
SMA(t) = (1/n) * Σ(f[i]), where i = t-n+1 to t
```
**Exemplo 1: calcular a média móvel simples para uma série temporal de temperaturas**
O exemplo calcula a média móvel simples de temperaturas usando dois pontos de dados.
Consulta PPL:
```
os> source=t | trendline sma(2, temperature) as temp_trend;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+----------+
|temperature|device-id| timestamp|temp_trend|
+-----------+---------+--------------------+----------+
| 12| 1492|2023-04-06 17:07:...| NULL|
| 12| 1492|2023-04-06 17:07:...| 12.0|
| 13| 256|2023-04-06 17:07:...| 12.5|
| 14| 257|2023-04-06 17:07:...| 13.5|
| 15| 258|2023-04-06 17:07:...| 14.5|
+-----------+---------+--------------------+----------+
```
**Exemplo 2: calcular as médias móveis simples para uma série temporal de temperaturas com classificação**
O exemplo calcula duas médias móveis simples das temperaturas usando dois e três pontos de dados classificados em ordem decrescente por device-id.
Consulta PPL:
```
os> source=t | trendline sort - device-id sma(2, temperature) as temp_trend_2 sma(3, temperature) as temp_trend_3;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+------------+------------------+
|temperature|device-id| timestamp|temp_trend_2| temp_trend_3|
+-----------+---------+--------------------+------------+------------------+
| 15| 258|2023-04-06 17:07:...| NULL| NULL|
| 14| 257|2023-04-06 17:07:...| 14.5| NULL|
| 13| 256|2023-04-06 17:07:...| 13.5| 14.0|
| 12| 1492|2023-04-06 17:07:...| 12.5| 13.0|
| 12| 1492|2023-04-06 17:07:...| 12.0|12.333333333333334|
+-----------+---------+--------------------+------------+------------------+
```
#### Comando where
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
O comando `where` usa uma expressão bool para filtrar o resultado da pesquisa. Ele só retorna o resultado quando a expressão bool é avaliada como verdadeira.
**Sintaxe**
Use a seguinte sintaxe:
```
where
```
**bool-expression**
+ Opcional.
+ Qualquer expressão que possa ser avaliada como um valor booleano.
**Exemplo 1: filtrar conjunto de resultados com condição**
O exemplo mostra como buscar documentos do índice de contas que atendam a condições específicas.
Consulta PPL:
```
os> source=accounts | where account_number=1 or gender="F" | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Exemplos adicionais**
**Filtros com condições lógicas**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a between 1 and 4`: nota: isso retorna um >= 1 e um <= 4, ou seja, [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`: nota: isso retorna b >= “\*\*\*\*\*\*\*\*\*\*” e b <= “2025-09-10”
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
#### field summary
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. [Comandos](#supported-ppl-commands)
Use o comando `fieldsummary` para calcular estatísticas básicas para cada campo (count, distinct count, min, max, avg, stddev, mean) e determinar o tipo de dados de cada campo. Esse comando pode ser usado com qualquer barra anterior e a levará em consideração.
**Sintaxe**
Use a sintaxe a seguir. Para casos de uso de CloudWatch registros, somente um campo em uma consulta é compatível.
```
... | fieldsummary (nulls=true/false)
```
**includefields**
+ Lista de todas as colunas a serem coletadas com estatísticas em um conjunto unificado de resultados.
**Nulos**
+ Opcional.
+ Se definido como verdadeiro, inclui valores nulos nos cálculos de agregação (substitua nulo por zero para valores numéricos).
**Exemplo 1**
Consulta PPL:
```
os> source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code" | 2 | 2 | 301 | 403 | 352.0 | 352.0 | 72.12489168102785 | 0 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
**Exemplo 2**
Consulta PPL:
```
os> source = t | fieldsummary includefields= id, status_code, request_path nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "id" | 6 | 6 | 1 | 6 | 3.5 | 3.5 | 1.8708286933869707 | 0 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code" | 4 | 3 | 200 | 403 | 184.0 | 184.0 | 161.16699413961905 | 2 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "request_path" | 2 | 2 | /about| /home | 0.0 | 0.0 | 0 | 2 |"string"|
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
#### Comando expand
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
Use o comando `expand` para nivelar um campo do tipo Array ou Map, produzindo linhas individuais para cada elemento ou par chave-valor.
**Sintaxe**
Use a seguinte sintaxe:
```
expand [As alias]
```
**Campo**
+ O campo a ser expandido (explodido).
+ O campo deve ser de um tipo compatível.
**alias**
+ Opcional.
+ O nome a ser usado em vez do nome original do campo.
**Diretrizes de uso**
O comando expand produz uma linha para cada elemento na matriz ou no campo de mapa especificado, onde:
+ Os elementos da matriz se tornam linhas individuais.
+ Os pares de chave-valor do mapa são divididos em linhas separadas, com cada par chave-valor representado como uma linha.
+ Quando um alias é fornecido, os valores explodidos são representados sob o alias em vez do nome original do campo.
Você pode usar esse comando em combinação com outros, como stats, eval e parse, para manipular ou extrair dados após a expansão.
**Exemplos**
+ `source = table | expand employee | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid `
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
Você pode usar o comando expand em combinação com outros, como eval, stats etc. O uso de vários comandos expand criará um produto cartesiano de todos os elementos internos em cada matriz ou mapa composto.
**Consulta SQL push-down eficaz**
O comando expand é traduzido em uma operação SQL equivalente usando LATERAL VIEW explode, permitindo a explosão eficiente de matrizes ou mapas no nível da consulta SQL.
```
SELECT customer exploded_productId
FROM table
LATERAL VIEW explode(productId) AS exploded_productId
```
O comando explode oferece a seguinte funcionalidade:
+ É uma operação de coluna que retorna uma nova coluna.
+ Cria uma nova linha para cada elemento da coluna explodida.
+ Nulos internos são ignorados como parte do campo explodido (nenhuma linha é created/exploded para nulos).
#### Funções PPL
**Topics**
+ [Funções PPL de condição](#supported-ppl-condition-functions)
+ [Funções PPL de hash criptográfico](#supported-ppl-cryptographic-functions)
+ [Funções PPL de data e hora](#supported-ppl-date-time-functions)
+ [Expressões PPL](#supported-ppl-expressions)
+ [Funções PPL de endereço IP](#supported-ppl-ip-address-functions)
+ [Funções PPL de JSON](#supported-ppl-json-functions)
+ [Funções PPL do Lambda](#supported-ppl-lambda-functions)
+ [Funções PPL matemáticas](#supported-ppl-math-functions)
+ [Funções PPL de string](#supported-ppl-string-functions)
+ [Funções PPL de conversão de tipo](#supported-ppl-type-conversion-functions)
##### Funções PPL de condição
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### ISNULL
**Descrição**: `isnull(field)` retornará verdadeiro se o campo for nulo.
**Tipo de argumento:**
+ Todos os tipos de dados compatíveis.
**Tipo de retorno:**
+ BOOLEAN
**Exemplo:**
```
os> source=accounts | eval result = isnull(employer) | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------+-------------+-------------+
| result | employer | firstname |
|----------+-------------+-------------|
| False | AnyCompany | Mary |
| False | ExampleCorp | Jane |
| False | ExampleOrg | Nikki |
| True | null | Juan |
+----------+-------------+-------------+
```
##### ISNOTNULL
**Descrição**: `isnotnull(field)` retornará verdadeiro se o campo não for nulo.
**Tipo de argumento:**
+ Todos os tipos de dados compatíveis.
**Tipo de retorno:**
+ BOOLEAN
**Exemplo:**
```
os> source=accounts | where not isnotnull(employer) | fields account_number, employer
fetched rows / total rows = 1/1
+------------------+------------+
| account_number | employer |
|------------------+------------|
| 18 | null |
+------------------+------------+
```
##### EXISTS
**Exemplo:**
```
os> source=accounts | where exists(email) | fields account_number, email
fetched rows / total rows = 1/1
```
##### IFNULL
**Descrição**: `ifnull(field1, field2)` retornará `field2` se `field1` for nulo.
**Tipo de argumento:**
+ Todos os tipos de dados compatíveis.
+ Se os dois parâmetros tiverem tipos diferentes, a função não passará na verificação semântica.
**Tipo de retorno:**
+ Any
**Exemplo:**
```
os> source=accounts | eval result = ifnull(employer, 'default') | fields result, employer, firstname
fetched rows / total rows = 4/4
+------------+------------+-------------+
| result | employer | firstname |
|------------+------------+-------------|
| AnyCompany | AnyCompany | Mary |
| ExampleCorp| ExampleCorp| Jane |
| ExampleOrg | ExampleOrg | Nikki |
| default | null | Juan |
+------------+------------+-------------+
```
##### NULLIF
**Descrição**: `nullif(field1, field2)` retornará nulo se dois parâmetros forem iguais, caso contrário, retornará field1.
**Tipo de argumento:**
+ Todos os tipos de dados compatíveis.
+ Se os dois parâmetros tiverem tipos diferentes, a função não passará na verificação semântica.
**Tipo de retorno:**
+ Any
**Exemplo:**
```
os> source=accounts | eval result = nullif(employer, 'AnyCompany') | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------------+----------------+-------------+
| result | employer | firstname |
|----------------+----------------+-------------|
| null | AnyCompany | Mary |
| ExampleCorp | ExampleCorp | Jane |
| ExampleOrg | ExampleOrg | Nikki |
| null | null | Juan |
+----------------+----------------+-------------+
```
##### IF
**Descrição**: `if(condition, expr1, expr2)` retornará `expr1` se a condição for verdadeiro, caso contrário, retornará `expr2`.
**Tipo de argumento:**
+ Todos os tipos de dados compatíveis.
+ Se os dois parâmetros tiverem tipos diferentes, a função não passará na verificação semântica.
**Tipo de retorno:**
+ Any
**Exemplo:**
```
os> source=accounts | eval result = if(true, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+----------+
| result | firstname | lastname |
|----------+-------------+----------|
| Jane | Jane | Doe |
| Mary | Mary | Major |
| Pat | Pat | Candella |
| Dale | Jorge | Souza |
+----------+-----------+------------+
os> source=accounts | eval result = if(false, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| result | firstname | lastname |
|----------+-------------+------------|
| Doe | Jane | Doe |
| Major | Mary | Major |
| Candella | Pat | Candella |
| Souza | Jorge | Souza |
+----------+-------------+------------+
os> source=accounts | eval is_vip = if(age > 30 AND isnotnull(employer), true, false) | fields is_vip, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| is_vip | firstname | lastname |
|----------+-------------+------------|
| True | Jane | Doe |
| True | Mary | Major |
| False | Pat | Candella |
| False | Jorge | Souza |
+----------+-------------+------------+
```
##### Funções PPL de hash criptográfico
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### MD5
MD5 calcula o MD5 resumo e retorna o valor como uma string hexadecimal de 32 caracteres.
**Uso**: `md5('hello')`
**Tipo de argumento:**
+ STRING
**Tipo de retorno:**
+ STRING
**Exemplo:**
```
os> source=people | eval `MD5('hello')` = MD5('hello') | fields `MD5('hello')`
fetched rows / total rows = 1/1
+----------------------------------+
| MD5('hello') |
|----------------------------------|
| <32 character hex string> |
+----------------------------------+
```
##### SHA1
SHA1 retorna o resultado da string hexadecimal de SHA-1.
**Uso**: `sha1('hello')`
**Tipo de argumento:**
+ STRING
**Tipo de retorno:**
+ STRING
**Exemplo:**
```
os> source=people | eval `SHA1('hello')` = SHA1('hello') | fields `SHA1('hello')`
fetched rows / total rows = 1/1
+------------------------------------------+
| SHA1('hello') |
|------------------------------------------|
| <40-character SHA-1 hash result> |
+------------------------------------------+
```
##### SHA2
SHA2 retorna o resultado da string hexadecimal da família SHA-2 de funções de hash (SHA-224, SHA-256, SHA-384 e SHA-512). O numBits indica o tamanho em bits desejado do resultado, que deve ter um valor de 224, 256, 384, 512
**Uso:**
+ `sha2('hello',256)`
+ `sha2('hello',512)`
**Tipo de argumento:**
+ STRING, INTEGER
**Tipo de retorno:**
+ STRING
**Exemplo:**
```
os> source=people | eval `SHA2('hello',256)` = SHA2('hello',256) | fields `SHA2('hello',256)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',256) |
|------------------------------------------------------------------|
| <64-character SHA-256 hash result> |
+------------------------------------------------------------------+
os> source=people | eval `SHA2('hello',512)` = SHA2('hello',512) | fields `SHA2('hello',512)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',512) | |
|------------------------------------------------------------------|
| <128-character SHA-512 hash result> |
+------------------------------------------------------------------+
```
##### Funções PPL de data e hora
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### `DAY`
**Uso**: `DAY(date)` extrai o dia do mês de uma data, no intervalo de 1 a 31.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `DAYOFMONTH`, `DAY_OF_MONTH`
**Exemplo:**
```
os> source=people | eval `DAY(DATE('2020-08-26'))` = DAY(DATE('2020-08-26')) | fields `DAY(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------+
| DAY(DATE('2020-08-26')) |
|---------------------------|
| 26 |
+---------------------------+
```
##### `DAYOFMONTH`
**Uso**: `DAYOFMONTH(date)` extrai o dia do mês de uma data, no intervalo de 1 a 31.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `DAY`, `DAY_OF_MONTH`
**Exemplo:**
```
os> source=people | eval `DAYOFMONTH(DATE('2020-08-26'))` = DAYOFMONTH(DATE('2020-08-26')) | fields `DAYOFMONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+----------------------------------+
| DAYOFMONTH(DATE('2020-08-26')) |
|----------------------------------|
| 26 |
+----------------------------------+
```
##### `DAY_OF_MONTH`
**Uso**: `DAY_OF_MONTH(DATE)` extrai o dia do mês de uma data, no intervalo de 1 a 31.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `DAY`, `DAYOFMONTH`
**Exemplo:**
```
os> source=people | eval `DAY_OF_MONTH(DATE('2020-08-26'))` = DAY_OF_MONTH(DATE('2020-08-26')) | fields `DAY_OF_MONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+------------------------------------+
| DAY_OF_MONTH(DATE('2020-08-26')) |
|------------------------------------|
| 26 |
+------------------------------------+
```
##### `DAYOFWEEK`
**Uso**: `DAYOFWEEK(DATE)` retorna o índice do dia da semana para uma data (1 = domingo, 2 = segunda-feira,..., 7 = sábado).
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `DAY_OF_WEEK`
**Exemplo:**
```
os> source=people | eval `DAYOFWEEK(DATE('2020-08-26'))` = DAYOFWEEK(DATE('2020-08-26')) | fields `DAYOFWEEK(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| DAYOFWEEK(DATE('2020-08-26')) |
|---------------------------------|
| 4 |
+---------------------------------+
```
##### `DAY_OF_WEEK`
**Uso**: `DAY_OF_WEEK(DATE)` retorna o índice do dia da semana para uma data (1 = domingo, 2 = segunda-feira,..., 7 = sábado).
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `DAYOFWEEK`
**Exemplo:**
```
os> source=people | eval `DAY_OF_WEEK(DATE('2020-08-26'))` = DAY_OF_WEEK(DATE('2020-08-26')) | fields `DAY_OF_WEEK(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------------+
| DAY_OF_WEEK(DATE('2020-08-26')) |
|-----------------------------------|
| 4 |
+-----------------------------------+
```
##### `DAYOFYEAR`
**Uso**: `DAYOFYEAR(DATE)` retorna o dia do ano de uma data, no intervalo de 1 a 366.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `DAY_OF_YEAR`
**Exemplo:**
```
os> source=people | eval `DAYOFYEAR(DATE('2020-08-26'))` = DAYOFYEAR(DATE('2020-08-26')) | fields `DAYOFYEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| DAYOFYEAR(DATE('2020-08-26')) |
|---------------------------------|
| 239 |
+---------------------------------+
```
##### `DAY_OF_YEAR`
**Uso**: `DAY_OF_YEAR(DATE)` retorna o dia do ano de uma data, no intervalo de 1 a 366.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `DAYOFYEAR`
**Exemplo:**
```
os> source=people | eval `DAY_OF_YEAR(DATE('2020-08-26'))` = DAY_OF_YEAR(DATE('2020-08-26')) | fields `DAY_OF_YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------------+
| DAY_OF_YEAR(DATE('2020-08-26')) |
|-----------------------------------|
| 239 |
+-----------------------------------+
```
##### `DAYNAME`
**Uso**: `DAYNAME(DATE)` retorna o nome do dia da semana de uma data, incluindo segunda-feira, terça-feira, quarta-feira, quinta-feira, sexta-feira, sábado e domingo.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: STRING
**Exemplo:**
```
os> source=people | eval `DAYNAME(DATE('2020-08-26'))` = DAYNAME(DATE('2020-08-26')) | fields `DAYNAME(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------+
| DAYNAME(DATE('2020-08-26')) |
|-------------------------------|
| Wednesday |
+-------------------------------+
```
##### `FROM_UNIXTIME`
**Uso**: `FROM_UNIXTIME` retorna uma representação do argumento fornecido como um valor de timestamp ou string de caracteres. Essa função realiza uma conversão inversa da função `UNIX_TIMESTAMP`.
Se você fornecer um segundo argumento, `FROM_UNIXTIME` o use para formatar o resultado semelhante à função `DATE_FORMAT`.
Se o timestamp estiver fora do intervalo 1970-01-01 00:00:00 a 3001-01-18 23:59:59.999999 (0 a 32536771199.999999 hora epoch), a função retornará. `NULL`
**Tipo de argumento**: DOUBLE, STRING
**Retorno tipo mapa**:
DOUBLE -> TIMESTAMP
DUPLO, STRING -> STRING
**Exemplos:**
```
os> source=people | eval `FROM_UNIXTIME(1220249547)` = FROM_UNIXTIME(1220249547) | fields `FROM_UNIXTIME(1220249547)`
fetched rows / total rows = 1/1
+-----------------------------+
| FROM_UNIXTIME(1220249547) |
|-----------------------------|
| 2008-09-01 06:12:27 |
+-----------------------------+
os> source=people | eval `FROM_UNIXTIME(1220249547, 'HH:mm:ss')` = FROM_UNIXTIME(1220249547, 'HH:mm:ss') | fields `FROM_UNIXTIME(1220249547, 'HH:mm:ss')`
fetched rows / total rows = 1/1
+-----------------------------------------+
| FROM_UNIXTIME(1220249547, 'HH:mm:ss') |
|-----------------------------------------|
| 06:12:27 |
+-----------------------------------------+
```
##### `HOUR`
**Uso**: `HOUR(TIME)` extrai o valor da hora.
Ao contrário de uma hora do dia padrão, o valor de hora nessa função pode ter um intervalo maior do que 23. Como resultado, o valor de retorno de `HOUR(TIME)` pode ser maior do que 23.
**Tipo de argumento**: STRING/TIME/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `HOUR_OF_DAY`
**Exemplo:**
```
os> source=people | eval `HOUR(TIME('01:02:03'))` = HOUR(TIME('01:02:03')) | fields `HOUR(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+--------------------------+
| HOUR(TIME('01:02:03')) |
|--------------------------|
| 1 |
+--------------------------+
```
##### `HOUR_OF_DAY`
**Uso**: `HOUR_OF_DAY(TIME)` extrai o valor de hora da hora fornecida.
Ao contrário de uma hora do dia padrão, o valor de hora nessa função pode ter um intervalo maior do que 23. Como resultado, o valor de retorno de `HOUR_OF_DAY(TIME)` pode ser maior do que 23.
**Tipo de argumento**: STRING/TIME/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `HOUR`
**Exemplo:**
```
os> source=people | eval `HOUR_OF_DAY(TIME('01:02:03'))` = HOUR_OF_DAY(TIME('01:02:03')) | fields `HOUR_OF_DAY(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+---------------------------------+
| HOUR_OF_DAY(TIME('01:02:03')) |
|---------------------------------|
| 1 |
+---------------------------------+
```
##### `LAST_DAY`
**Uso**: `LAST_DAY` retorna o último dia do mês como um valor DATE para o argumento de data fornecido.
**Tipo de argumento**: DATE/STRING/TIMESTAMP/TIME
**Tipo de retorno**: DATE
**Exemplo:**
```
os> source=people | eval `last_day('2023-02-06')` = last_day('2023-02-06') | fields `last_day('2023-02-06')`
fetched rows / total rows = 1/1
+--------------------------+
| last_day('2023-02-06') |
|--------------------------|
| 2023-02-28 |
+--------------------------+
```
##### `LOCALTIMESTAMP`
**Uso**: `LOCALTIMESTAMP()` é sinônimo de `NOW()`.
**Exemplo:**
```
> source=people | eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP() | fields `LOCALTIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIMESTAMP() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `LOCALTIME`
**Uso**: `LOCALTIME()` é sinônimo de `NOW()`.
**Exemplo:**
```
> source=people | eval `LOCALTIME()` = LOCALTIME() | fields `LOCALTIME()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIME() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `MAKE_DATE`
**Uso**: `MAKE_DATE` retorna um valor de data com base nos valores de ano, mês e dia fornecidos. Todos os argumentos são arredondados para números inteiros.
**Especificações**: 1. MAKE\_DATE(INTEGER, INTEGER, INTEGER) -> DATE
**Tipo de argumento**: INTEGER, INTEGER, INTEGER
**Tipo de retorno**: DATE
**Exemplo:**
```
os> source=people | eval `MAKE_DATE(1945, 5, 9)` = MAKEDATE(1945, 5, 9) | fields `MAKEDATE(1945, 5, 9)`
fetched rows / total rows = 1/1
+------------------------+
| MAKEDATE(1945, 5, 9) |
|------------------------|
| 1945-05-09 |
+------------------------+
```
##### `MINUTE`
**Uso**: `MINUTE(TIME)` retorna o componente minuto da hora fornecida, como um número inteiro no intervalo de 0 a 59.
**Tipo de argumento**: STRING/TIME/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `MINUTE_OF_HOUR`
**Exemplo:**
```
os> source=people | eval `MINUTE(TIME('01:02:03'))` = MINUTE(TIME('01:02:03')) | fields `MINUTE(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+----------------------------+
| MINUTE(TIME('01:02:03')) |
|----------------------------|
| 2 |
+----------------------------+
```
##### `MINUTE_OF_HOUR`
**Uso**: `MINUTE_OF_HOUR(TIME)` retorna o componente minuto da hora fornecida, como um número inteiro no intervalo de 0 a 59.
**Tipo de argumento**: STRING/TIME/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `MINUTE`
**Exemplo:**
```
os> source=people | eval `MINUTE_OF_HOUR(TIME('01:02:03'))` = MINUTE_OF_HOUR(TIME('01:02:03')) | fields `MINUTE_OF_HOUR(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+------------------------------------+
| MINUTE_OF_HOUR(TIME('01:02:03')) |
|------------------------------------|
| 2 |
+------------------------------------+
```
##### `MONTH`
**Uso**: `MONTH(DATE)` retorna o mês da data fornecida como um número inteiro, no intervalo de 1 a 12 (onde 1 representa janeiro e 12 representa dezembro).
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `MONTH_OF_YEAR`
**Exemplo:**
```
os> source=people | eval `MONTH(DATE('2020-08-26'))` = MONTH(DATE('2020-08-26')) | fields `MONTH(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-----------------------------+
| MONTH(DATE('2020-08-26')) |
|-----------------------------|
| 8 |
+-----------------------------+
```
##### `MONTHNAME`
**Uso**: `MONTHNAME(DATE)` retorna o mês da data fornecida como um número inteiro, no intervalo de 1 a 12 (onde 1 representa janeiro e 12 representa dezembro).
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `MONTH_OF_YEAR`
**Exemplo:**
```
os> source=people | eval `MONTHNAME(DATE('2020-08-26'))` = MONTHNAME(DATE('2020-08-26')) | fields `MONTHNAME(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+---------------------------------+
| MONTHNAME(DATE('2020-08-26')) |
|---------------------------------|
| August |
+---------------------------------+
```
##### `MONTH_OF_YEAR`
**Uso**: `MONTH_OF_YEAR(DATE)` retorna o mês da data fornecida como um número inteiro, no intervalo de 1 a 12 (onde 1 representa janeiro e 12 representa dezembro).
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `MONTH`
**Exemplo:**
```
os> source=people | eval `MONTH_OF_YEAR(DATE('2020-08-26'))` = MONTH_OF_YEAR(DATE('2020-08-26')) | fields `MONTH_OF_YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------------+
| MONTH_OF_YEAR(DATE('2020-08-26')) |
|-------------------------------------|
| 8 |
+-------------------------------------+
```
##### `NOW`
**Uso**: `NOW` retorna a data e a hora atuais como um `TIMESTAMP` valor no formato YYYY-MM-DD 'hh:mm:ss'. O valor é expresso no fuso horário do cluster.
**nota**
`NOW()` retorna uma hora constante que indica quando a instrução começou a ser executada. Isso difere de `SYSDATE()`, que retorna a hora exata da execução.
**Tipo de retorno**: TIMESTAMP
**Especificação**: NOW() -> TIMESTAMP
**Exemplo:**
```
os> source=people | eval `value_1` = NOW(), `value_2` = NOW() | fields `value_1`, `value_2`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| value_1 | value_2 |
|---------------------+---------------------|
| 2022-08-02 15:39:05 | 2022-08-02 15:39:05 |
+---------------------+---------------------+
```
##### `QUARTER`
**Uso**: `QUARTER(DATE)` retorna o trimestre do ano para a data fornecida como um número inteiro, no intervalo de 1 a 4.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Exemplo:**
```
os> source=people | eval `QUARTER(DATE('2020-08-26'))` = QUARTER(DATE('2020-08-26')) | fields `QUARTER(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------+
| QUARTER(DATE('2020-08-26')) |
|-------------------------------|
| 3 |
+-------------------------------+
```
##### `SECOND`
**Uso**: `SECOND(TIME)` retorna o componente segundo da hora fornecida, como um número inteiro no intervalo de 0 a 59.
**Tipo de argumento**: STRING/TIME/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `SECOND_OF_MINUTE`
**Exemplo:**
```
os> source=people | eval `SECOND(TIME('01:02:03'))` = SECOND(TIME('01:02:03')) | fields `SECOND(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+----------------------------+
| SECOND(TIME('01:02:03')) |
|----------------------------|
| 3 |
+----------------------------+
```
##### `SECOND_OF_MINUTE`
**Uso**: `SECOND_OF_MINUTE(TIME)` retorna o componente segundo da hora fornecida, como um número inteiro no intervalo de 0 a 59.
**Tipo de argumento**: STRING/TIME/TIMESTAMP
**Tipo de retorno**: INTEGER
**Sinônimos**: `SECOND`
**Exemplo:**
```
os> source=people | eval `SECOND_OF_MINUTE(TIME('01:02:03'))` = SECOND_OF_MINUTE(TIME('01:02:03')) | fields `SECOND_OF_MINUTE(TIME('01:02:03'))`
fetched rows / total rows = 1/1
+--------------------------------------+
| SECOND_OF_MINUTE(TIME('01:02:03')) |
|--------------------------------------|
| 3 |
+--------------------------------------+
```
##### `SUBDATE`
**Uso**: `SUBDATE(DATE, DAYS)` subtrai o segundo argumento (como `DATE` ou `DAYS`) da data fornecida.
**Tipo de argumento**: DATE/TIMESTAMP, LONG
**Mapa do tipo de retorno**: (DATE, LONG) -> DATE
**Antônimos**: `ADDDATE`
**Exemplo:**
```
os> source=people | eval `'2008-01-02' - 31d` = SUBDATE(DATE('2008-01-02'), 31), `'2020-08-26' - 1` = SUBDATE(DATE('2020-08-26'), 1), `ts '2020-08-26 01:01:01' - 1` = SUBDATE(TIMESTAMP('2020-08-26 01:01:01'), 1) | fields `'2008-01-02' - 31d`, `'2020-08-26' - 1`, `ts '2020-08-26 01:01:01' - 1`
fetched rows / total rows = 1/1
+----------------------+--------------------+--------------------------------+
| '2008-01-02' - 31d | '2020-08-26' - 1 | ts '2020-08-26 01:01:01' - 1 |
|----------------------+--------------------+--------------------------------|
| 2007-12-02 00:00:00 | 2020-08-25 | 2020-08-25 01:01:01 |
+----------------------+--------------------+--------------------------------+
```
##### `SYSDATE`
**Uso**: `SYSDATE()` retorna a data e a hora atuais como um `TIMESTAMP` valor no formato 'YYYY-MM-DD hh:mm:ss.nnnnnnn'.
`SYSDATE()` retorna a hora exata em que é executada. Isso difere de NOW (), que retorna uma hora constante indicando quando a instrução começou a ser executada.
**Tipo de argumento opcional**: INTEGER (0 a 6): especifica o número de dígitos para frações de segundo no valor de retorno.
**Tipo de retorno**: TIMESTAMP
**Exemplo:**
```
os> source=people | eval `SYSDATE()` = SYSDATE() | fields `SYSDATE()`
fetched rows / total rows = 1/1
+----------------------------+
| SYSDATE() |
|----------------------------|
| 2022-08-02 15:39:05.123456 |
+----------------------------+
```
##### `TIMESTAMP`
**Uso**: `TIMESTAMP(EXPR)` constrói um tipo de timestamp com a string de entrada `expr` como timestamp.
Com um único argumento, `TIMESTAMP(expr)` constrói um timestamp a partir da entrada. Se `expr` for uma string, será interpretada como um timestamp. Para argumentos não string, a função converte `expr` em um timestamp usando o fuso horário UTC. Quando `expr` é um valor `TIME`, a função aplica a data de hoje antes da conversão.
Quando usado com dois argumentos, `TIMESTAMP(expr1, expr2)` adiciona a expressão de hora (`expr2`) à expressão de data ou timestamp (`expr1`) e retorna o resultado como um valor de timestamp.
**Tipo de argumento**: STRING/DATE/TIME/TIMESTAMP
**Retorno tipo mapa:**
(STRING/DATE/TIME/TIMESTAMP) -> CARIMBO DE DATA/HORA
(STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP) -> CARIMBO DE DATA/HORA
**Exemplo:**
```
os> source=people | eval `TIMESTAMP('2020-08-26 13:49:00')` = TIMESTAMP('2020-08-26 13:49:00'), `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))` = TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) | fields `TIMESTAMP('2020-08-26 13:49:00')`, `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))`
fetched rows / total rows = 1/1
+------------------------------------+------------------------------------------------------+
| TIMESTAMP('2020-08-26 13:49:00') | TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) |
|------------------------------------+------------------------------------------------------|
| 2020-08-26 13:49:00 | 2020-08-27 02:04:42 |
+------------------------------------+------------------------------------------------------+
```
##### `UNIX_TIMESTAMP`
**Uso**: `UNIX_TIMESTAMP` converte um argumento de data fornecido em hora Unix (segundos desde Epoch, que começou no início de 1970). Se nenhum argumento for fornecido, retornará a hora atual Unix.
O argumento de data pode ser uma `DATE`, uma string `TIMESTAMP` ou um número em um desses formatos: `YYMMDD`, `YYMMDDhhmmss`, `YYYYMMDD` ou `YYYYMMDDhhmmss`. Se o argumento incluir um componente de hora, poderá, opcionalmente, incluir segundos fracionários.
Se o argumento estiver em um formato inválido ou fora do intervalo 1970-01-01 00:00:00 a 3001-01-18 23:59:59.999999 (0 a 32536771199.999999 no horário epoch), a função retornará `NULL`.
A função aceita `DATE`, `TIMESTAMP` ou `DOUBLE` como tipos de argumento, ou nenhum argumento. Ela sempre retorna um valor `DOUBLE` representando o timestamp Unix.
Para a conversão inversa, você pode usar a função FROM\_UNIXTIME.
**Tipo de argumento**:/DOUBLE/DATE/TIMESTAMP
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `UNIX_TIMESTAMP(double)` = UNIX_TIMESTAMP(20771122143845), `UNIX_TIMESTAMP(timestamp)` = UNIX_TIMESTAMP(TIMESTAMP('1996-11-15 17:05:42')) | fields `UNIX_TIMESTAMP(double)`, `UNIX_TIMESTAMP(timestamp)`
fetched rows / total rows = 1/1
+--------------------------+-----------------------------+
| UNIX_TIMESTAMP(double) | UNIX_TIMESTAMP(timestamp) |
|--------------------------+-----------------------------|
| 3404817525.0 | 848077542.0 |
+--------------------------+-----------------------------+
```
##### `WEEK`
**Uso**: `WEEK(DATE)` retorna o número da semana de uma data fornecida.
**Tipo de argumento**: DATE/TIMESTAMP/STRING
**Tipo de retorno**: INTEGER
**Sinônimos**: `WEEK_OF_YEAR`
**Exemplo:**
```
os> source=people | eval `WEEK(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20')) | fields `WEEK(DATE('2008-02-20'))`
fetched rows / total rows = 1/1
+----------------------------+
| WEEK(DATE('2008-02-20')) |
|----------------------------|
| 8 |
+----------------------------+
```
##### `WEEKDAY`
**Uso**: `WEEKDAY(DATE)` retorna o índice do dia da semana da data (0 = segunda-feira, 1 = terça-feira,..., 6 = domingo).
É semelhante à função `dayofweek`, mas retorna índices diferentes para cada dia.
**Tipo de argumento**: STRING/DATE/TIME/TIMESTAMP
**Tipo de retorno**: INTEGER
**Exemplo:**
```
os> source=people | eval `weekday(DATE('2020-08-26'))` = weekday(DATE('2020-08-26')) | eval `weekday(DATE('2020-08-27'))` = weekday(DATE('2020-08-27')) | fields `weekday(DATE('2020-08-26'))`, `weekday(DATE('2020-08-27'))`
fetched rows / total rows = 1/1
+-------------------------------+-------------------------------+
| weekday(DATE('2020-08-26')) | weekday(DATE('2020-08-27')) |
|-------------------------------+-------------------------------|
| 2 | 3 |
+-------------------------------+-------------------------------+
```
##### `WEEK_OF_YEAR`
**Uso**: `WEEK_OF_YEAR(DATE)` retorna o número da semana da data fornecida.
**Tipo de argumento**: DATE/TIMESTAMP/STRING
**Tipo de retorno**: INTEGER
**Sinônimos**: `WEEK`
**Exemplo:**
```
os> source=people | eval `WEEK_OF_YEAR(DATE('2008-02-20'))` = WEEK(DATE('2008-02-20'))| fields `WEEK_OF_YEAR(DATE('2008-02-20'))`
fetched rows / total rows = 1/1
+------------------------------------+
| WEEK_OF_YEAR(DATE('2008-02-20')) |
|------------------------------------|
| 8 |
+------------------------------------+
```
##### `YEAR`
**Uso**: `YEAR(DATE)` retorna o ano da data, no intervalo de 1000 a 9999, ou 0 para a data “zero”.
**Tipo de argumento**: STRING/DATE/TIMESTAMP
**Tipo de retorno**: INTEGER
**Exemplo:**
```
os> source=people | eval `YEAR(DATE('2020-08-26'))` = YEAR(DATE('2020-08-26')) | fields `YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+----------------------------+
| YEAR(DATE('2020-08-26')) |
|----------------------------|
| 2020 |
+----------------------------+
```
##### `DATE_ADD`
**Uso**: `DATE_ADD(date, INTERVAL expr unit)` adiciona o intervalo especificado à data fornecida.
**Tipo de argumento**: DATE, INTERVAL
**Tipo de retorno**: DATE
**Antônimos**: `DATE_SUB`
**Exemplo:**
```
os> source=people | eval `'2020-08-26' + 1d` = DATE_ADD(DATE('2020-08-26'), INTERVAL 1 DAY) | fields `'2020-08-26' + 1d`
fetched rows / total rows = 1/1
+---------------------+
| '2020-08-26' + 1d |
|---------------------|
| 2020-08-27 |
+---------------------+
```
##### `DATE_SUB`
**Uso**: `DATE_SUB(date, INTERVAL expr unit)` subtrai o intervalo expr da data.
**Tipo de argumento**: DATE, INTERVAL
**Tipo de retorno**: DATE
**Antônimos**: `DATE_ADD`
**Exemplo:**
```
os> source=people | eval `'2008-01-02' - 31d` = DATE_SUB(DATE('2008-01-02'), INTERVAL 31 DAY) | fields `'2008-01-02' - 31d`
fetched rows / total rows = 1/1
+---------------------+
| '2008-01-02' - 31d |
|---------------------|
| 2007-12-02 |
+---------------------+
```
##### `TIMESTAMPADD`
**Uso**: retorna um valor `TIMESTAMP` após adicionar um intervalo de tempo especificado a uma data fornecida.
**Argumentos**:
+ intervalo: INTERVAL (SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR)
+ inteiro: INTEGER
+ data: DATA, TIMESTAMP ou STRING
Se você fornecer uma `STRING` como argumento de data, formate-a como `TIMESTAMP` válido. A função converte automaticamente um argumento `DATE` em um `TIMESTAMP`.
**Exemplos:**
```
os> source=people | eval `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')` = TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | eval `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')` = TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') | fields `TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00')`, `TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00')`
fetched rows / total rows = 1/1
+----------------------------------------------+--------------------------------------------------+
| TIMESTAMPADD(DAY, 17, '2000-01-01 00:00:00') | TIMESTAMPADD(QUARTER, -1, '2000-01-01 00:00:00') |
|----------------------------------------------+--------------------------------------------------|
| 2000-01-18 00:00:00 | 1999-10-01 00:00:00 |
+----------------------------------------------+--------------------------------------------------+
```
##### `TIMESTAMPDIFF`
**Uso**: `TIMESTAMPDIFF(interval, start, end)` retorna a diferença entre o início e o fim date/times em unidades de intervalo especificadas.
**Argumentos**:
+ intervalo: INTERVAL (SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR)
+ início: DATE, TIMESTAMP ou STRING
+ fim: DATE, TIMESTAMP ou STRING
A função converte automaticamente argumentos em `TIMESTAMP` quando apropriado. Formate os argumentos `STRING` como `TIMESTAMP`s válidos.
**Exemplos:**
```
os> source=people | eval `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')` = TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | eval `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))` = TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) | fields `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')`, `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))`
fetched rows / total rows = 1/1
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+
| TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) |
|-------------------------------------------------------------------+-------------------------------------------------------------------------------------------|
| 4 | -23 |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+
```
##### `UTC_TIMESTAMP`
**Uso**: `UTC_TIMESTAMP` retorna o timestamp UTC atual como um valor no formato “YYYY-MM-DD hh:mm:ss”.
**Tipo de retorno**: TIMESTAMP
**Especificação**: UTC\_TIMESTAMP () -> TIMESTAMP
**Exemplo:**
```
> source=people | eval `UTC_TIMESTAMP()` = UTC_TIMESTAMP() | fields `UTC_TIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| UTC_TIMESTAMP() |
|---------------------|
| 2022-10-03 17:54:28 |
+---------------------+
```
##### `CURRENT_TIMEZONE`
**Uso**: `CURRENT_TIMEZONE` retorna o fuso horário local atual.
**Tipo de retorno**: STRING
**Exemplo:**
```
> source=people | eval `CURRENT_TIMEZONE()` = CURRENT_TIMEZONE() | fields `CURRENT_TIMEZONE()`
fetched rows / total rows = 1/1
+------------------------+
| CURRENT_TIMEZONE() |
|------------------------|
| America/Chicago |
+------------------------+
```
##### Expressões PPL
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
Expressões, especialmente expressões de valor, retornam um valor escalar. As expressões têm diferentes tipos e formatos. Por exemplo, há valores literais como expressões atômicas, além de expressões aritméticas, predicativas e de função definidas a partir deles. Você pode usar expressões em cláusulas diferentes, como usar expressões aritméticas nos comandos `Filter` e `Stats`.
**Operadores**
Uma expressão aritmética é uma expressão formada por literais numéricos e operadores aritméticos binários da seguinte forma:
1. `+`: adicionar.
1. `-`: subtrair.
1. `*`: multiplicar.
1. `/`: dividir (para números inteiros, o resultado é um número inteiro com a parte fracionária descartada)
1. `%`: módulo (use somente com números inteiros; o resultado é o resto da divisão)
**Precedência**
Use parênteses para controlar a precedência dos operadores aritméticos. Caso contrário, os operadores com maior precedência serão executados primeiro.
**Conversão de tipo**
A conversão de tipo implícita é realizada ao pesquisar assinaturas de operadores. Por exemplo, um número inteiro `+` um número real corresponde à assinatura `+(double,double)`, o que resulta em um número real. Essa regra também se aplica às chamadas de funções.
Exemplo de diferentes tipos de expressões aritméticas:
```
os> source=accounts | where age > (25 + 5) | fields age ;
fetched rows / total rows = 3/3
+-------+
| age |
|-------|
| 32 |
| 36 |
| 33 |
+-------+
```
**Operadores de predicado**
Um operador de predicado é uma expressão que deve ser avaliada como sendo verdadeira. A comparação de valores `MISSING` e `NULL` segue estas regras:
+ Um valor `MISSING` só é igual a um valor `MISSING` e é menor do que outros valores.
+ Um valor `NULL` é igual a um valor `NULL`, é maior que um valor `MISSING`, mas é menor que todos os outros valores.
**Operadores**
**Operadores de predicado**
| Name (Nome) | Description |
| --- | --- |
| > | Operador maior que |
| >= | Operador maior que ou igual a |
| < | Operador menor que |
| \!= | Operador não igual a |
| <= | Operador menor que ou igual a |
| = | Operador igual a |
| LIKE | Correspondência a padrão simples |
| IN | Teste de valor NULL |
| AND | Operador AND |
| OR | Operador OU |
| XOR | Operador XOR |
| NOT | Teste de valor NOT NULL |
Você pode comparar datas e horas. Ao comparar diferentes tipos de data e hora (por exemplo `DATE` e `TIME`), ambos são convertidos em `DATETIME`. As seguintes regras se aplicam à conversão:
+ `TIME` aplica-se até a data de hoje.
+ `DATE` é interpretado à meia-noite.
**Operador de predicado básico**
Exemplo de operadores de comparação:
```
os> source=accounts | where age > 33 | fields age ;
fetched rows / total rows = 1/1
+-------+
| age |
|-------|
| 36 |
+-------+
```
**`IN`**
Exemplo do campo de teste do operador `IN` em listas de valores:
```
os> source=accounts | where age in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`OR`**
Exemplo do operador `OR`:
```
os> source=accounts | where age = 32 OR age = 33 | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`NOT`**
Exemplo do operador `NOT`:
```
os> source=accounts | where age not in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 36 |
| 28 |
+-------+
```
##### Funções PPL de endereço IP
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### `CIDRMATCH`
**Uso**: `CIDRMATCH(ip, cidr)` verifica se o endereço IP especificado está dentro do intervalo cidr fornecido.
**Tipo de argumento:**
+ STRING, STRING
+ Tipo de retorno: BOOLEAN
**Exemplo:**
```
os> source=ips | where cidrmatch(ip, '***********/24') | fields ip
fetched rows / total rows = 1/1
+--------------+
| ip |
|--------------|
| *********** |
+--------------+
os> source=ipsv6 | where cidrmatch(ip, '2003:db8::/32') | fields ip
fetched rows / total rows = 1/1
+-----------------------------------------+
| ip |
|-----------------------------------------|
| 2003:0db8:****:****:****:****:****:0000 |
+-----------------------------------------+
```
**nota**
`ip`pode ser um IPv4 ou um IPv6 endereço.
`cidr`pode ser um IPv4 ou um IPv6 bloco.
`ip`e `cidr` deve ser ambos IPv4 ou ambos IPv6.
`ip` e `cidr` devem ser válidos e não vazios/não nulos.
##### Funções PPL de JSON
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### `JSON`
**Uso**: `json(value)` avalia se uma string pode ser analisada como formato JSON. A função retornará a string original se for JSON válido ou retornará nulo se for inválida.
**Tipo de argumento**: STRING
**Tipo de retorno**: STRING/NULL. Uma expressão STRING de um formato de objeto JSON válido.
**Exemplos:**
```
os> source=people | eval `valid_json()` = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') | fields valid_json
fetched rows / total rows = 1/1
+---------------------------------+
| valid_json |
+---------------------------------+
| [1,2,3,{"f1":1,"f2":[5,6]},4] |
+---------------------------------+
os> source=people | eval `invalid_json()` = json('{"invalid": "json"') | fields invalid_json
fetched rows / total rows = 1/1
+----------------+
| invalid_json |
+----------------+
| null |
+----------------+
```
##### `JSON_OBJECT`
**Uso**: `json_object(, [, , ]...)` retorna um objeto JSON de membros de pares chave-valor.
**Tipo de argumento:**
+ Uma deve ser STRING.
+ Um pode ser qualquer tipo de dados.
**Tipo de retorno**: JSON\_OBJECT. Uma StructType expressão de um objeto JSON válido.
**Exemplos:**
```
os> source=people | eval result = json_object('key', 123.45) | fields result
fetched rows / total rows = 1/1
+------------------+
| result |
+------------------+
| {"key":123.45} |
+------------------+
os> source=people | eval result = json_object('outer', json_object('inner', 123.45)) | fields result
fetched rows / total rows = 1/1
+------------------------------+
| result |
+------------------------------+
| {"outer":{"inner":123.45}} |
+------------------------------+
```
##### `JSON_ARRAY`
**Uso**: `json_array(...)` cria um JSON ARRAY usando uma lista de valores.
**Tipo de argumento**: um `` pode ser qualquer tipo de valor, como string, número ou booleano.
**Tipo de retorno**: ARRAY. Uma matriz de qualquer tipo de dado compatível com uma matriz JSON válida.
**Exemplos:**
```
os> source=people | eval `json_array` = json_array(1, 2, 0, -1, 1.1, -0.11)
fetched rows / total rows = 1/1
+------------------------------+
| json_array |
+------------------------------+
| [1.0,2.0,0.0,-1.0,1.1,-0.11] |
+------------------------------+
os> source=people | eval `json_array_object` = json_object("array", json_array(1, 2, 0, -1, 1.1, -0.11))
fetched rows / total rows = 1/1
+----------------------------------------+
| json_array_object |
+----------------------------------------+
| {"array":[1.0,2.0,0.0,-1.0,1.1,-0.11]} |
+----------------------------------------+
```
##### `TO_JSON_STRING`
**Uso**: `to_json_string(jsonObject)` retorna uma string JSON com um valor de objeto json fornecido.
**Tipo de argumento**: JSON\_OBJECT
**Tipo de retorno**: STRING
**Exemplos:**
```
os> source=people | eval `json_string` = to_json_string(json_array(1, 2, 0, -1, 1.1, -0.11)) | fields json_string
fetched rows / total rows = 1/1
+--------------------------------+
| json_string |
+--------------------------------+
| [1.0,2.0,0.0,-1.0,1.1,-0.11] |
+--------------------------------+
os> source=people | eval `json_string` = to_json_string(json_object('key', 123.45)) | fields json_string
fetched rows / total rows = 1/1
+-----------------+
| json_string |
+-----------------+
| {'key', 123.45} |
+-----------------+
```
##### `ARRAY_LENGTH`
**Usage**: `array_length(jsonArray)` retorna o número de elementos na matriz mais externa.
**Tipo de argumento**: ARRAY. Um objeto ARRAY ou JSON\_ARRAY.
**Tipo de retorno**: INTEGER
**Exemplo:**
```
os> source=people | eval `json_array` = json_array_length(json_array(1,2,3,4)), `empty_array` = json_array_length(json_array())
fetched rows / total rows = 1/1
+--------------+---------------+
| json_array | empty_array |
+--------------+---------------+
| 4 | 0 |
+--------------+---------------+
```
##### `JSON_EXTRACT`
**Uso**: `json_extract(jsonStr, path)` extrai um objeto JSON de uma string JSON com base no caminho JSON especificado. A função retornará nulo se a string JSON de entrada for inválida.
**Tipo de argumento**: STRING, STRING
**Tipo de retorno**: STRING
+ Uma expressão STRING de um formato de objeto JSON válido.
+ `NULL` é retornado no caso de um JSON inválido.
**Exemplos:**
```
os> source=people | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a')
fetched rows / total rows = 1/1
+----------------------------------+
| json_extract('{"a":"b"}', 'a') |
+----------------------------------+
| b |
+----------------------------------+
os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[1].b') |
+-----------------------------------------------------------+
| 2.0 |
+-----------------------------------------------------------+
os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[*].b') |
+-----------------------------------------------------------+
| [1.0,2.0] |
+-----------------------------------------------------------+
os> source=people | eval `invalid_json` = json_extract('{"invalid": "json"')
fetched rows / total rows = 1/1
+----------------+
| invalid_json |
+----------------+
| null |
+----------------+
```
##### `JSON_KEYS`
**Uso**: `json_keys(jsonStr)` retorna todas as chaves do objeto JSON mais externo como uma matriz.
**Tipo de argumento**: STRING. Uma expressão STRING de um formato de objeto JSON válido.
**Tipo de retorno**: ARRAY[STRING]. A função retorna `NULL` para qualquer outra string JSON válida, uma string vazia ou um JSON inválido.
**Exemplos:**
```
os> source=people | eval `keys` = json_keys('{"f1":"abc","f2":{"f3":"a","f4":"b"}}')
fetched rows / total rows = 1/1
+------------+
| keus |
+------------+
| [f1, f2] |
+------------+
os> source=people | eval `keys` = json_keys('[1,2,3,{"f1":1,"f2":[5,6]},4]')
fetched rows / total rows = 1/1
+--------+
| keys |
+--------+
| null |
+--------+
```
##### `JSON_VALID`
**Uso**: `json_valid(jsonStr)` avalia se uma string JSON usa uma sintaxe JSON válida e retorna VERDADEIRO ou FALSO.
**Tipo de argumento**: STRING
**Tipo de retorno**: BOOLEAN
**Exemplos:**
```
os> source=people | eval `valid_json` = json_valid('[1,2,3,4]'), `invalid_json` = json_valid('{"invalid": "json"') | feilds `valid_json`, `invalid_json`
fetched rows / total rows = 1/1
+--------------+----------------+
| valid_json | invalid_json |
+--------------+----------------+
| True | False |
+--------------+----------------+
os> source=accounts | where json_valid('[1,2,3,4]') and isnull(email) | fields account_number, email
fetched rows / total rows = 1/1
+------------------+---------+
| account_number | email |
|------------------+---------|
| 13 | null |
+------------------+---------+
```
##### Funções PPL do Lambda
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### `EXISTS`
**Uso**: `exists(array, lambda)` avalia se um predicado Lambda contém um ou mais elementos da matriz.
**Tipo de argumento**: ARRAY, LAMBDA
**Tipo de retorno**: BOOLEAN. Retornará `TRUE` se pelo menos um elemento na matriz satisfizer o predicado Lambda, do contrário `FALSE`.
**Exemplos:**
```
os> source=people | eval array = json_array(1, -1, 2), result = exists(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| true |
+-----------+
os> source=people | eval array = json_array(-1, -3, -2), result = exists(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| false |
+-----------+
```
##### `FILTER`
**Uso**: `filter(array, lambda)` filtra a matriz de entrada usando a função do Lambda fornecida.
**Tipo de argumento**: ARRAY, LAMBDA
**Tipo de retorno**: ARRAY. Uma ARRAY que contém todos os elementos na matriz de entrada que satisfazem o predicado lambda.
**Exemplos:**
```
os> source=people | eval array = json_array(1, -1, 2), result = filter(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| [1, 2] |
+-----------+
os> source=people | eval array = json_array(-1, -3, -2), result = filter(array, x -> x > 0) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| [] |
+-----------+
```
##### `TRANSFORM`
**Uso**: `transform(array, lambda)` transforma elementos em uma matriz usando a função do Lambda transform. O segundo argumento implica o índice do elemento se estiver usando a função do Lambda binary. Isso é semelhante a um `map` em programação funcional.
**Tipo de argumento**: ARRAY, LAMBDA
**Tipo de retorno**: ARRAY. Uma ARRAY que contém o resultado da aplicação da função do lambda transform a cada elemento na matriz de entrada.
**Exemplos:**
```
os> source=people | eval array = json_array(1, 2, 3), result = transform(array, x -> x + 1) | fields result
fetched rows / total rows = 1/1
+--------------+
| result |
+--------------+
| [2, 3, 4] |
+--------------+
os> source=people | eval array = json_array(1, 2, 3), result = transform(array, (x, i) -> x + i) | fields result
fetched rows / total rows = 1/1
+--------------+
| result |
+--------------+
| [1, 3, 5] |
+--------------+
```
##### `REDUCE`
**Uso**: `reduce(array, start, merge_lambda, finish_lambda)` reduz uma matriz a um único valor aplicando funções do lambda. A função aplica merge\_lambda ao valor inicial e a todos os elementos da matriz e, em seguida, aplica `finish_lambda` ao resultado.
**Tipo de argumento**: ARRAY, ANY, LAMBDA, LAMBDA
**Tipo de retorno**: ANY. O resultado final da aplicação das funções Lambda ao valor inicial e à matriz de entrada.
**Exemplos:**
```
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 6 |
+-----------+
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 10, (acc, x) -> acc + x) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 16 |
+-----------+
os> source=people | eval array = json_array(1, 2, 3), result = reduce(array, 0, (acc, x) -> acc + x, acc -> acc * 10) | fields result
fetched rows / total rows = 1/1
+-----------+
| result |
+-----------+
| 60 |
+-----------+
```
##### Funções PPL matemáticas
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### `ABS`
**Uso**: `ABS(x) ` calcula o valor absoluto de x.
**Tipo de argumento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo de devolução:** INTEGER/LONG/FLOAT/DOUBLE
**Exemplo:**
```
os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)`
fetched rows / total rows = 1/1
+-----------+
| ABS(-1) |
|-----------|
| 1 |
+-----------+
```
##### `ACOS`
**Uso**: `ACOS(x)` calcula o arco cosseno de x. Retornará `NULL` se x não estiver no intervalo de -1 a 1.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `ACOS(0)` = ACOS(0) | fields `ACOS(0)`
fetched rows / total rows = 1/1
+--------------------+
| ACOS(0) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `ASIN`
**Uso**: `asin(x)` calcula o arco seno de x. Retornará `NULL` se x não estiver no intervalo de -1 a 1.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `ASIN(0)` = ASIN(0) | fields `ASIN(0)`
fetched rows / total rows = 1/1
+-----------+
| ASIN(0) |
|-----------|
| 0.0 |
+-----------+
```
##### `ATAN`
**Uso**: `ATAN(x)` calcula o arco tangente de x. `atan(y, x)` calcula o arco tangente de y/x, exceto que os sinais dos argumentos determinam o quadrante do resultado.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `ATAN(2)` = ATAN(2), `ATAN(2, 3)` = ATAN(2, 3) | fields `ATAN(2)`, `ATAN(2, 3)`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| ATAN(2) | ATAN(2, 3) |
|--------------------+--------------------|
| 1.1071487177940904 | 0.5880026035475675 |
+--------------------+--------------------+
```
##### `ATAN2`
**Uso**: `ATAN2(y, x)` calcula o arco tangente de y/x, exceto que os sinais dos argumentos determinam o quadrante do resultado.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `ATAN2(2, 3)` = ATAN2(2, 3) | fields `ATAN2(2, 3)`
fetched rows / total rows = 1/1
+--------------------+
| ATAN2(2, 3) |
|--------------------|
| 0.5880026035475675 |
+--------------------+
```
##### `CBRT`
**Usage**: `CBRT` calcula a raiz cúbica de um número.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE:
INTEGER/LONG/FLOAT/DOUBLE-> DUPLO
**Exemplo:**
```
opensearchsql> source=location | eval `CBRT(8)` = CBRT(8), `CBRT(9.261)` = CBRT(9.261), `CBRT(-27)` = CBRT(-27) | fields `CBRT(8)`, `CBRT(9.261)`, `CBRT(-27)`;
fetched rows / total rows = 2/2
+-----------+---------------+-------------+
| CBRT(8) | CBRT(9.261) | CBRT(-27) |
|-----------+---------------+-------------|
| 2.0 | 2.1 | -3.0 |
| 2.0 | 2.1 | -3.0 |
+-----------+---------------+-------------+
```
##### `CEIL`
**Uso**: um alias da função `CEILING`. `CEILING(T)` assume o teto do valor T.
**Limitação**: `CEILING` só funciona conforme o esperado quando o tipo duplo IEEE 754 exibe um decimal quando armazenado.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: LONG
**Exemplo:**
```
os> source=people | eval `CEILING(0)` = CEILING(0), `CEILING(50.00005)` = CEILING(50.00005), `CEILING(-50.00005)` = CEILING(-50.00005) | fields `CEILING(0)`, `CEILING(50.00005)`, `CEILING(-50.00005)`
fetched rows / total rows = 1/1
+--------------+---------------------+----------------------+
| CEILING(0) | CEILING(50.00005) | CEILING(-50.00005) |
|--------------+---------------------+----------------------|
| 0 | 51 | -50 |
+--------------+---------------------+----------------------+
os> source=people | eval `CEILING(3147483647.12345)` = CEILING(3147483647.12345), `CEILING(113147483647.12345)` = CEILING(113147483647.12345), `CEILING(3147483647.00001)` = CEILING(3147483647.00001) | fields `CEILING(3147483647.12345)`, `CEILING(113147483647.12345)`, `CEILING(3147483647.00001)`
fetched rows / total rows = 1/1
+-----------------------------+-------------------------------+-----------------------------+
| CEILING(3147483647.12345) | CEILING(113147483647.12345) | CEILING(3147483647.00001) |
|-----------------------------+-------------------------------+-----------------------------|
| 3147483648 | 113147483648 | 3147483648 |
+-----------------------------+-------------------------------+-----------------------------+
```
##### `CONV`
**Uso**: `CONV(x, a, b)` converte o número x de uma base para a base b.
**Tipo de argumento**: x: STRING, a: INTEGER, b: INTEGER
**Tipo de retorno**: STRING
**Exemplo:**
```
os> source=people | eval `CONV('12', 10, 16)` = CONV('12', 10, 16), `CONV('2C', 16, 10)` = CONV('2C', 16, 10), `CONV(12, 10, 2)` = CONV(12, 10, 2), `CONV(1111, 2, 10)` = CONV(1111, 2, 10) | fields `CONV('12', 10, 16)`, `CONV('2C', 16, 10)`, `CONV(12, 10, 2)`, `CONV(1111, 2, 10)`
fetched rows / total rows = 1/1
+----------------------+----------------------+-------------------+---------------------+
| CONV('12', 10, 16) | CONV('2C', 16, 10) | CONV(12, 10, 2) | CONV(1111, 2, 10) |
|----------------------+----------------------+-------------------+---------------------|
| c | 44 | 1100 | 15 |
+----------------------+----------------------+-------------------+---------------------+
```
##### `COS`
**Uso**: `COS(x)` calcula o cosseno de x, onde x é fornecido em radianos.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)`
fetched rows / total rows = 1/1
+----------+
| COS(0) |
|----------|
| 1.0 |
+----------+
```
##### `COT`
**Uso**: `COT(x)` calcula a cotangente de x. Ele retornará out-of-range um erro se x for igual a 0.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `COT(1)` = COT(1) | fields `COT(1)`
fetched rows / total rows = 1/1
+--------------------+
| COT(1) |
|--------------------|
| 0.6420926159343306 |
+--------------------+
```
##### `CRC32`
**Uso**: `CRC32` calcula um valor de verificação de redundância cíclica e retorna um valor não assinado de 32 bits.
**Tipo de argumento**: STRING
**Tipo de retorno**: LONG
**Exemplo:**
```
os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')`
fetched rows / total rows = 1/1
+------------------+
| CRC32('MySQL') |
|------------------|
| 3259397556 |
+------------------+
```
##### `DEGREES`
**Uso**: `DEGREES(x)` converte x de radianos em graus.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `DEGREES(1.57)` = DEGREES(1.57) | fields `DEGREES(1.57)`
fetched rows / total rows = 1/1
+-------------------+
| DEGREES(1.57) |
|-------------------|
| 89.95437383553924 |
+-------------------+
```
##### `E`
**Uso**: `E()` retorna o número de Euler.
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `E()` = E() | fields `E()`
fetched rows / total rows = 1/1
+-------------------+
| E() |
|-------------------|
| 2.718281828459045 |
+-------------------+
```
##### `EXP`
**Uso**: `EXP(x)` retorna e elevado à potência de x.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `EXP(2)` = EXP(2) | fields `EXP(2)`
fetched rows / total rows = 1/1
+------------------+
| EXP(2) |
|------------------|
| 7.38905609893065 |
+------------------+
```
##### `FLOOR`
**Uso**: `FLOOR(T)` assume o piso do valor T.
**Limitação**: `FLOOR` só funciona conforme o esperado quando o tipo duplo IEEE 754 exibe um decimal quando armazenado.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: LONG
**Exemplo:**
```
os> source=people | eval `FLOOR(0)` = FLOOR(0), `FLOOR(50.00005)` = FLOOR(50.00005), `FLOOR(-50.00005)` = FLOOR(-50.00005) | fields `FLOOR(0)`, `FLOOR(50.00005)`, `FLOOR(-50.00005)`
fetched rows / total rows = 1/1
+------------+-------------------+--------------------+
| FLOOR(0) | FLOOR(50.00005) | FLOOR(-50.00005) |
|------------+-------------------+--------------------|
| 0 | 50 | -51 |
+------------+-------------------+--------------------+
os> source=people | eval `FLOOR(3147483647.12345)` = FLOOR(3147483647.12345), `FLOOR(113147483647.12345)` = FLOOR(113147483647.12345), `FLOOR(3147483647.00001)` = FLOOR(3147483647.00001) | fields `FLOOR(3147483647.12345)`, `FLOOR(113147483647.12345)`, `FLOOR(3147483647.00001)`
fetched rows / total rows = 1/1
+---------------------------+-----------------------------+---------------------------+
| FLOOR(3147483647.12345) | FLOOR(113147483647.12345) | FLOOR(3147483647.00001) |
|---------------------------+-----------------------------+---------------------------|
| 3147483647 | 113147483647 | 3147483647 |
+---------------------------+-----------------------------+---------------------------+
os> source=people | eval `FLOOR(282474973688888.022)` = FLOOR(282474973688888.022), `FLOOR(9223372036854775807.022)` = FLOOR(9223372036854775807.022), `FLOOR(9223372036854775807.0000001)` = FLOOR(9223372036854775807.0000001) | fields `FLOOR(282474973688888.022)`, `FLOOR(9223372036854775807.022)`, `FLOOR(9223372036854775807.0000001)`
fetched rows / total rows = 1/1
+------------------------------+----------------------------------+--------------------------------------+
| FLOOR(282474973688888.022) | FLOOR(9223372036854775807.022) | FLOOR(9223372036854775807.0000001) |
|------------------------------+----------------------------------+--------------------------------------|
| 282474973688888 | 9223372036854775807 | 9223372036854775807 |
+------------------------------+----------------------------------+--------------------------------------+
```
##### `LN`
**Uso**: `LN(x)` retorna o logaritmo natural de x.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `LN(2)` = LN(2) | fields `LN(2)`
fetched rows / total rows = 1/1
+--------------------+
| LN(2) |
|--------------------|
| 0.6931471805599453 |
+--------------------+
```
##### `LOG`
**Uso**: `LOG(x)` retorna o logaritmo natural de x que é o algoritmo de base e de x. log(B, x) é equivalente a log(x)/log(B).
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `LOG(2)` = LOG(2), `LOG(2, 8)` = LOG(2, 8) | fields `LOG(2)`, `LOG(2, 8)`
fetched rows / total rows = 1/1
+--------------------+-------------+
| LOG(2) | LOG(2, 8) |
|--------------------+-------------|
| 0.6931471805599453 | 3.0 |
+--------------------+-------------+
```
##### `LOG2`
**Uso**: `LOG2(x)` é equivalente a `log(x)`/`log(2)`.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `LOG2(8)` = LOG2(8) | fields `LOG2(8)`
fetched rows / total rows = 1/1
+-----------+
| LOG2(8) |
|-----------|
| 3.0 |
+-----------+
```
##### `LOG10`
**Uso**: `LOG10(x)` é equivalente a `log(x)`/`log(10)`.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `LOG10(100)` = LOG10(100) | fields `LOG10(100)`
fetched rows / total rows = 1/1
+--------------+
| LOG10(100) |
|--------------|
| 2.0 |
+--------------+
```
##### `MOD`
**Uso**: `MOD(n, m)` calcula o resto do número n dividido por m.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: tipo mais amplo entre os tipos de n e m se m for um valor diferente de zero. Se m for igual a 0, retornará NULL.
**Exemplo:**
```
os> source=people | eval `MOD(3, 2)` = MOD(3, 2), `MOD(3.1, 2)` = MOD(3.1, 2) | fields `MOD(3, 2)`, `MOD(3.1, 2)`
fetched rows / total rows = 1/1
+-------------+---------------+
| MOD(3, 2) | MOD(3.1, 2) |
|-------------+---------------|
| 1 | 1.1 |
+-------------+---------------+
```
##### `PI`
**Uso**: `PI() ` retorna a constante pi.
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `PI()` = PI() | fields `PI()`
fetched rows / total rows = 1/1
+-------------------+
| PI() |
|-------------------|
| 3.141592653589793 |
+-------------------+
```
##### `POW`
**Uso**: `POW(x, y)` calcula o valor de x elevado à potência de y. Entradas incorretas retornam um resultado `NULL`.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Sinônimos**: `POWER(_, _)`
**Exemplo:**
```
os> source=people | eval `POW(3, 2)` = POW(3, 2), `POW(-3, 2)` = POW(-3, 2), `POW(3, -2)` = POW(3, -2) | fields `POW(3, 2)`, `POW(-3, 2)`, `POW(3, -2)`
fetched rows / total rows = 1/1
+-------------+--------------+--------------------+
| POW(3, 2) | POW(-3, 2) | POW(3, -2) |
|-------------+--------------+--------------------|
| 9.0 | 9.0 | 0.1111111111111111 |
+-------------+--------------+--------------------+
```
##### POWER
**Uso**: `POWER(x, y)` calcula o valor de x elevado à potência de y. Entradas incorretas retornam um resultado `NULL`.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Sinônimos**: `POW(_, _)`
**Exemplo:**
```
os> source=people | eval `POWER(3, 2)` = POWER(3, 2), `POWER(-3, 2)` = POWER(-3, 2), `POWER(3, -2)` = POWER(3, -2) | fields `POWER(3, 2)`, `POWER(-3, 2)`, `POWER(3, -2)`
fetched rows / total rows = 1/1
+---------------+----------------+--------------------+
| POWER(3, 2) | POWER(-3, 2) | POWER(3, -2) |
|---------------+----------------+--------------------|
| 9.0 | 9.0 | 0.1111111111111111 |
+---------------+----------------+--------------------+
```
##### `RADIANS`
**Uso**: `RADIANS(x)` converte x de graus em radianos.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `RADIANS(90)` = RADIANS(90) | fields `RADIANS(90)`
fetched rows / total rows = 1/1
+--------------------+
| RADIANS(90) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `RAND`
**Uso**: `RAND()`/`RAND(N)` retorna um valor de ponto flutuante aleatório no intervalo 0 <= valor < 1,0. Se você especificar o inteiro N, a função inicializará a semente antes da execução. Uma implicação desse comportamento é que, com um argumento N idêntico, `rand(N)` retorna o mesmo valor toda vez, produzindo uma sequência repetível de valores de coluna.
**Tipo de argumento**: INTEGER
**Tipo de retorno**: FLOAT
**Exemplo:**
```
os> source=people | eval `RAND(3)` = RAND(3) | fields `RAND(3)`
fetched rows / total rows = 1/1
+------------+
| RAND(3) |
|------------|
| 0.73105735 |
+------------+
```
##### `ROUND`
**Uso**: `ROUND(x, d)` arredonda o argumento x para d casas decimais. Se você não especificar d, o padrão será 0.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Retorno tipo mapa**:
+ (INTEGER/LONG [,INTEGER]) -> LONG
+ (FLOAT/DOUBLE [,INTEGER]) -> LONG
**Exemplo:**
```
os> source=people | eval `ROUND(12.34)` = ROUND(12.34), `ROUND(12.34, 1)` = ROUND(12.34, 1), `ROUND(12.34, -1)` = ROUND(12.34, -1), `ROUND(12, 1)` = ROUND(12, 1) | fields `ROUND(12.34)`, `ROUND(12.34, 1)`, `ROUND(12.34, -1)`, `ROUND(12, 1)`
fetched rows / total rows = 1/1
+----------------+-------------------+--------------------+----------------+
| ROUND(12.34) | ROUND(12.34, 1) | ROUND(12.34, -1) | ROUND(12, 1) |
|----------------+-------------------+--------------------+----------------|
| 12.0 | 12.3 | 10.0 | 12 |
+----------------+-------------------+--------------------+----------------+
```
##### `SIGN`
**Uso**: `SIGN` retorna o sinal do argumento como -1, 0 ou 1, dependendo de o número ser negativo, zero ou positivo.
**Tipo de argumento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: INTEGER
**Exemplo:**
```
os> source=people | eval `SIGN(1)` = SIGN(1), `SIGN(0)` = SIGN(0), `SIGN(-1.1)` = SIGN(-1.1) | fields `SIGN(1)`, `SIGN(0)`, `SIGN(-1.1)`
fetched rows / total rows = 1/1
+-----------+-----------+--------------+
| SIGN(1) | SIGN(0) | SIGN(-1.1) |
|-----------+-----------+--------------|
| 1 | 0 | -1 |
+-----------+-----------+--------------+
```
##### `SIN`
**Uso**: `sin(x)` calcula o seno de x, onde x é fornecido em radianos.
**Tipo de argumento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo de retorno**: DOUBLE
**Exemplo:**
```
os> source=people | eval `SIN(0)` = SIN(0) | fields `SIN(0)`
fetched rows / total rows = 1/1
+----------+
| SIN(0) |
|----------|
| 0.0 |
+----------+
```
##### `SQRT`
**Uso**: `SQRT` calcula a raiz quadrada de um número não negativo.
**Tipo de argumento:** INTEGER/LONG/FLOAT/DOUBLE
**Retorno tipo mapa:**
+ (Não negativo) INTEGER/LONG/FLOAT/DOUBLE -> DUPLO
+ (Negativo) INTEGER/LONG/FLOAT/DOUBLE -> NULL
**Exemplo:**
```
os> source=people | eval `SQRT(4)` = SQRT(4), `SQRT(4.41)` = SQRT(4.41) | fields `SQRT(4)`, `SQRT(4.41)`
fetched rows / total rows = 1/1
+-----------+--------------+
| SQRT(4) | SQRT(4.41) |
|-----------+--------------|
| 2.0 | 2.1 |
+-----------+--------------+
```
##### Funções PPL de string
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### `CONCAT`
**Uso**: `CONCAT(str1, str2, ...., str_9)` soma até 9 strings.
**Tipo de argumento:**
+ STRING, STRING, ...., STRING
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `CONCAT('hello', 'world')` = CONCAT('hello', 'world'), `CONCAT('hello ', 'whole ', 'world', '!')` = CONCAT('hello ', 'whole ', 'world', '!') | fields `CONCAT('hello', 'world')`, `CONCAT('hello ', 'whole ', 'world', '!')`
fetched rows / total rows = 1/1
+----------------------------+--------------------------------------------+
| CONCAT('hello', 'world') | CONCAT('hello ', 'whole ', 'world', '!') |
|----------------------------+--------------------------------------------|
| helloworld | hello whole world! |
+----------------------------+--------------------------------------------+
```
##### `CONCAT_WS`
**Uso**: `CONCAT_WS(sep, str1, str2)` concatena duas ou mais strings usando um separador especificado entre elas.
**Tipo de argumento:**
+ STRING, STRING, ...., STRING
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `CONCAT_WS(',', 'hello', 'world')` = CONCAT_WS(',', 'hello', 'world') | fields `CONCAT_WS(',', 'hello', 'world')`
fetched rows / total rows = 1/1
+------------------------------------+
| CONCAT_WS(',', 'hello', 'world') |
|------------------------------------|
| hello,world |
+------------------------------------+
```
##### `LENGTH`
**Uso**: `length(str)` retorna o comprimento da string de entrada medido em bytes.
**Tipo de argumento:**
+ STRING
+ Tipo de retorno: INTEGER
**Exemplo:**
```
os> source=people | eval `LENGTH('helloworld')` = LENGTH('helloworld') | fields `LENGTH('helloworld')`
fetched rows / total rows = 1/1
+------------------------+
| LENGTH('helloworld') |
|------------------------|
| 10 |
+------------------------+
```
##### `LOWER`
**Uso**: `lower(string)` converte a string de entrada para minúsculas.
**Tipo de argumento:**
+ STRING
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `LOWER('helloworld')` = LOWER('helloworld'), `LOWER('HELLOWORLD')` = LOWER('HELLOWORLD') | fields `LOWER('helloworld')`, `LOWER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| LOWER('helloworld') | LOWER('HELLOWORLD') |
|-----------------------+-----------------------|
| helloworld | helloworld |
+-----------------------+-----------------------+
```
##### `LTRIM`
**Uso**: `ltrim(str)` remove os caracteres de espaço antes da string de entrada.
**Tipo de argumento:**
+ STRING
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `LTRIM(' hello')` = LTRIM(' hello'), `LTRIM('hello ')` = LTRIM('hello ') | fields `LTRIM(' hello')`, `LTRIM('hello ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| LTRIM(' hello') | LTRIM('hello ') |
|---------------------+---------------------|
| hello | hello |
+---------------------+---------------------+
```
##### `POSITION`
**Uso**: `POSITION(substr IN str)` retorna a posição da primeira ocorrência de substring na string. Retornará 0 se a substring não estiver na string. Retornará NULL se qualquer argumento de entrada for NULL.
**Tipo de argumento:**
+ STRING, STRING
+ Tipo de retorno: INTEGER
**Exemplo:**
```
os> source=people | eval `POSITION('world' IN 'helloworld')` = POSITION('world' IN 'helloworld'), `POSITION('invalid' IN 'helloworld')`= POSITION('invalid' IN 'helloworld') | fields `POSITION('world' IN 'helloworld')`, `POSITION('invalid' IN 'helloworld')`
fetched rows / total rows = 1/1
+-------------------------------------+---------------------------------------+
| POSITION('world' IN 'helloworld') | POSITION('invalid' IN 'helloworld') |
|-------------------------------------+---------------------------------------|
| 6 | 0 |
+-------------------------------------+---------------------------------------+
```
##### `REVERSE`
**Uso**: `REVERSE(str)` retorna a string inversa da string de entrada.
**Tipo de argumento:**
+ STRING
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `REVERSE('abcde')` = REVERSE('abcde') | fields `REVERSE('abcde')`
fetched rows / total rows = 1/1
+--------------------+
| REVERSE('abcde') |
|--------------------|
| edcba |
+--------------------+
```
##### `RIGHT`
**Uso**: `right(str, len)` retorna os caracteres mais à direita da string de entrada. Retornará 0 se a substring não estiver na string. Retornará NULL se qualquer argumento de entrada for NULL.
**Tipo de argumento:**
+ STRING, INTEGER
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `RIGHT('helloworld', 5)` = RIGHT('helloworld', 5), `RIGHT('HELLOWORLD', 0)` = RIGHT('HELLOWORLD', 0) | fields `RIGHT('helloworld', 5)`, `RIGHT('HELLOWORLD', 0)`
fetched rows / total rows = 1/1
+--------------------------+--------------------------+
| RIGHT('helloworld', 5) | RIGHT('HELLOWORLD', 0) |
|--------------------------+--------------------------|
| world | |
+--------------------------+--------------------------+
```
##### `RTRIM`
**Uso**: `rtrim(str)` corta os caracteres de espaço depois da string de entrada.
**Tipo de argumento:**
+ STRING
+ **Tipo de retorno**: STRING
**Exemplo:**
```
os> source=people | eval `RTRIM(' hello')` = RTRIM(' hello'), `RTRIM('hello ')` = RTRIM('hello ') | fields `RTRIM(' hello')`, `RTRIM('hello ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| RTRIM(' hello') | RTRIM('hello ') |
|---------------------+---------------------|
| hello | hello |
+---------------------+---------------------+
```
##### `SUBSTRING`
**Uso**: `substring(str, start)` ou `substring(str, start, length)` retorna uma substring da string de entrada. Sem comprimento especificado, retorna a string inteira a partir da posição inicial.
**Tipo de argumento:**
+ STRING, INTEIRO, INTEIRO
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `SUBSTRING('helloworld', 5)` = SUBSTRING('helloworld', 5), `SUBSTRING('helloworld', 5, 3)` = SUBSTRING('helloworld', 5, 3) | fields `SUBSTRING('helloworld', 5)`, `SUBSTRING('helloworld', 5, 3)`
fetched rows / total rows = 1/1
+------------------------------+---------------------------------+
| SUBSTRING('helloworld', 5) | SUBSTRING('helloworld', 5, 3) |
|------------------------------+---------------------------------|
| oworld | owo |
+------------------------------+---------------------------------+
```
##### `TRIM`
**Uso**: `trim(string)` remove os espaços em branco antes e depois da string de entrada.
**Tipo de argumento:**
+ STRING
+ **Tipo de retorno**: STRING
**Exemplo:**
```
os> source=people | eval `TRIM(' hello')` = TRIM(' hello'), `TRIM('hello ')` = TRIM('hello ') | fields `TRIM(' hello')`, `TRIM('hello ')`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| TRIM(' hello') | TRIM('hello ') |
|--------------------+--------------------|
| hello | hello |
+--------------------+--------------------+
```
##### `UPPER`
**Uso**: `upper(string)` converte a string de entrada para maiúsculas.
**Tipo de argumento:**
+ STRING
+ Tipo de retorno: STRING
**Exemplo:**
```
os> source=people | eval `UPPER('helloworld')` = UPPER('helloworld'), `UPPER('HELLOWORLD')` = UPPER('HELLOWORLD') | fields `UPPER('helloworld')`, `UPPER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| UPPER('helloworld') | UPPER('HELLOWORLD') |
|-----------------------+-----------------------|
| HELLOWORLD | HELLOWORLD |
+-----------------------+-----------------------+
```
##### Funções PPL de conversão de tipo
**nota**
Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. [Funções](#supported-ppl-functions)
##### `TRIM`
**Uso**: `cast(expr as dateType)` converte `expr` em `dataType` e retorna o valor de `dataType`.
As seguintes regras de conversão se aplicam:
**Regras de conversão de tipo**
| Src/Target | STRING | NUMBER | BOOLEAN | TIMESTAMP | DATE | TIME |
| --- | --- | --- | --- | --- | --- | --- |
| STRING | | Note1 | Note1 | TIMESTAMP() | DATE() | TIME() |
| NUMBER | Note1 | | v\!=0 | N/D | N/D | N/D |
| BOOLEAN | Note1 | v?1:0 | | N/D | N/D | N/D |
| TIMESTAMP | Note1 | N/D | N/D | | DATE() | TIME() |
| DATE | Note1 | N/D | N/D | N/D | | N/D |
| TIME | Note1 | N/D | N/D | N/D | N/D | |
**Exemplo de conversão em string:**
```
os> source=people | eval `cbool` = CAST(true as string), `cint` = CAST(1 as string), `cdate` = CAST(CAST('2012-08-07' as date) as string) | fields `cbool`, `cint`, `cdate`
fetched rows / total rows = 1/1
+---------+--------+------------+
| cbool | cint | cdate |
|---------+--------+------------|
| true | 1 | 2012-08-07 |
+---------+--------+------------+
```
**Exemplo de conversão em número:**
```
os> source=people | eval `cbool` = CAST(true as int), `cstring` = CAST('1' as int) | fields `cbool`, `cstring`
fetched rows / total rows = 1/1
+---------+-----------+
| cbool | cstring |
|---------+-----------|
| 1 | 1 |
+---------+-----------+
```
**Exemplo de conversão em data:**
```
os> source=people | eval `cdate` = CAST('2012-08-07' as date), `ctime` = CAST('01:01:01' as time), `ctimestamp` = CAST('2012-08-07 01:01:01' as timestamp) | fields `cdate`, `ctime`, `ctimestamp`
fetched rows / total rows = 1/1
+------------+----------+---------------------+
| cdate | ctime | ctimestamp |
|------------+----------+---------------------|
| 2012-08-07 | 01:01:01 | 2012-08-07 01:01:01 |
+------------+----------+---------------------+
```
**Exemplo de conversão encadeada:**
```
os> source=people | eval `cbool` = CAST(CAST(true as string) as boolean) | fields `cbool`
fetched rows / total rows = 1/1
+---------+
| cbool |
|---------|
| True |
+---------+
```