Comandos PPL compatíveis

As tabelas de referência a seguir mostram os comandos PPL compatíveis com o OpenSearch Dashboards para consultar o CloudWatch Logs, o Amazon S3 ou o Security Lake, e os comandos compatíveis com o CloudWatch Logs Insights. O CloudWatch Logs Insights usa a mesma sintaxe PPL que o OpenSearch Dashboards ao consultar o CloudWatch Logs, e as tabelas se referem a ambos como CloudWatch Logs.

Comandos

 fields field1, field2

 where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000

stats count(),
      count(`field1`),
      min(`field1`),
      max(`field1`),
      avg(`field1`)
by field2
| head 1000

parse `field1` ".*/(?<field2>[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000

patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers

stats count(),
      count(`field1`),
      min(`field1`) as field1Alias,
      max(`field1`),
      avg(`field1`)
by field2
| sort -field1Alias
| head 1000

eval field2 = `field1` * 2
| fields field1, field2
| head 20

rename field2 as field1
| fields field1

 fields `@message`
| head 20

 grok email '.+@%{HOSTNAME:host}'
| fields email

 top 2 Field1 by Field2

dedup field1
| fields field1, field2, field3

source=customer
| join ON c_custkey = o_custkey orders
| head 10

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

where id in [
  subquery source=users
  | where user in [
    subquery source=actions
    | where action="login"
    | fields user
  ]
  | fields uid
]

 rare Field1 by Field2

 trendline sma(2, field1) as field1Alias

 eventstats sum(field1) by field2

 source=table | flatten field1

where field1 != 200
| fieldsummary includefields=field1 nulls=true

fields field1
| eval field2=field1
| fillnull value=0 field1

expand employee
| stats max(salary) as max
  by state, company

 describe schema.table

Funções

eval col1Len = LENGTH(col1)
| fields col1Len

eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate

eval field2 = isnull(col1)
| fields field2, col1, field3  

eval field2 = ACOS(col1)
| fields col1

where age > (25 + 5)
| fields age  

where cidrmatch(ip, '***********/24')
| fields ip 

eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a')

eval array = json_array(1, -1, 2),
     result = filter(array, x -> x > 0)
| fields result

eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')`

Informações adicionais para usuários do CloudWatch Logs Insights usando OpenSearch PPL

Embora o CloudWatch Logs Insights seja compatível com a maioria dos comandos e funções 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 passou a ser compatível com a s funções JOIN, subconsultas, Flatten, Fillnull, Expand, Cidrmatch e funções JSON em PPL. Para obter uma lista completa dos comandos e funções de consulta compatíveis, consulte as colunas do Amazon CloudWatch Logs nas tabelas acima.

Exemplos de consultas e cotas

O seguinte se aplica tanto aos usuários do CloudWatch Logs Insights quanto aos usuários do OpenSearch que consultam dados no CloudWatch.

Para obter informações sobre os limites que se aplicam ao consultar o CloudWatch Logs no OpenSearch Service, consulte Votas do CloudWatch Logs no Guia do usuário do Amazon CloudWatch Logs. Os limites envolvem o número de grupos de logs do CloudWatch que você pode consultar, o máximo de consultas simultâneas que 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 o CloudWatch Logs (ou seja, OpenSearch PPL, SQL e Logs Insights QL).

Comandos PPL

comment

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

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:

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 que reside na 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:

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 o traceId e o ip do cliente/servidor do http que podem ser correlacionados com os logs 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:

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á fornecer o mapeamento explícito dos campos de caminho. Para resolver isso, você pode estender 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, então 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

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] <field-list> [keepempty=<bool>] [consecutive=<bool>] 

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        |
+------------------+----------+      

Comando describe

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.

Comando eval

O comando eval avalia a expressão e acrescenta o resultado ao resultado da pesquisa.

Sintaxe

Use a seguinte sintaxe:

eval <field>=<expression> ["," <field>=<expression> ]...    

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

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

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      

Comando eventstats

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.

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.

Sintaxe

Use a seguinte sintaxe:

eventstats <aggregation>... [by-clause]    

Funções de agregação

COUNT

COUNT retorna uma contagem do número de expr nas linhas recuperadas por uma instrução SELECT.

COUNT não é compatível com consultas de uso do CloudWatch Logs.

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.

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   |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+      

Agregações com span

Agregações com span de janela de tempo (função de janela tumble)

Grupo de agregações por vários níveis

Comando expand

Use o comando expand para nivelar um campo do tipo:

Sintaxe

Use a seguinte sintaxe:

expand <field> [As alias]

Uso

O comando expand produz uma linha para cada elemento na matriz ou no campo de mapa especificado, onde:

Comando explain

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.

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    

Eval

Pressupostos: a, b, c são campos existentes em table

Comando fillnull

Descrição

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 <null-replacement> in <nullable-field>["," <nullable-field>]] | [using <source-field> = <null-replacement> [","<source-field> = <null-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.

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

Use o comando fields para manter ou remover campos do resultado da pesquisa.

Sintaxe

Use a seguinte sintaxe:

field [+|-] <field-list> 

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         |
+-------------+------------+        

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

Use o comando flatten para expandir campos dos seguintes tipos:

Sintaxe

Use a seguinte sintaxe:

flatten <field>

Schema

Dados

Exemplo 1: nivelar campo struct

Este exemplo mostra como nivelar um campo struct.

Consulta PPL:

source=table | flatten coor

Exemplo 2: nivelar matriz

O exemplo mostra como nivelar uma matriz de campos struct.

Consulta PPL:

source=table | flatten bridges

Exemplo 3: nivelar matriz e struct

Este exemplo mostra como nivelar vários campos.

Consulta PPL:

source=table | flatten bridges | flatten coor

Comando grok

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 <field> <pattern>

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

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 [<size>] [from <offset>]

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

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:

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=<left-table>
| <other piped command>
| [joinType] JOIN
    [leftAlias]
    ON joinCriteria
    <right-table>
| <other piped command>      

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      

Mais exemplos

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

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=<sourceIndex>
| <other piped command>
| LOOKUP <lookupIndex> (<lookupMappingField> [AS <sourceMappingField>])...
    [(REPLACE | APPEND) (<inputField> [AS <outputField>])...]
| <other piped command>    

Exemplo

Veja os exemplos a seguir.

SEARCH source=<sourceIndex>
| 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=<sourceIndex>
| DEDUP market_id
| EVAL category=replace(category, "-", ".")
| EVAL category=ltrim(category, "dvp.")
| LOOKUP bounce_category category AS category APPEND classification    

SEARCH source=<sourceIndex>
| 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.

Sintaxe

Use a seguinte sintaxe:

parse <field> <pattern>    

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 '.+@(?<host>.+)' | 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+ (?<address>.+)' | 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 '(?<streetNumber>\d+) (?<street>.+)' | 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:

Comando patterns

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=<new-field-name>] [pattern=<pattern>] <field>    

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

Use o comando rare para encontrar a tupla de valores menos comum de todos os campos na lista de campos.

Sintaxe

Use a seguinte sintaxe:

rare [N] <field-list> [by-clause] rare_approx [N] <field-list> [by-clause]

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.

Sintaxe

Use a seguinte sintaxe:

rename <source-field> AS <target-field>["," <source-field> AS <target-field>]...    

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    |
+------+---------+      

Comando search

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=[<remote-cluster>:]<index> [boolean-expression]    

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.

Sintaxe

Use a seguinte sintaxe:

sort <[+|-] sort-field>...

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.

Manipulação de valores NULL/MISSING

Sintaxe

Use a seguinte sintaxe:

stats <aggregation>... [by-clause]    

span-expression

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.

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.

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

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 ]  

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 In-Subquery:

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 In-Subquery:

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      

Uso de ExistsSubquery

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.

Uso de ScalarSubquery

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:

Em Where:

Em filtro Search:

Subconsulta escalar correlacionada

Em Select:

Em Where:

Em filtro Search:

Subconsulta escalar aninhada

(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.

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 <boolean expression> | ...    

Filtro de pesquisa:

search source=* <boolean expression> | ...    

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 <boolean expression>.

Em geral, chamamos esse tipo de cláusula de subconsulta é a expressão InSubquery. É uma <boolean expression>.

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 ]      

Diferentemente de InSubquery, ExistsSubquery e ScalarSubquery, RelationSubquery não é 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

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] <field-list> [by-clause] top_approx [N] <field-list> [by-clause]

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

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]]... 

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

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 <boolean-expression>    

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

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

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 do CloudWatch Logs, somente um campo em uma consulta é permitido.

... | fieldsummary <field-list> (nulls=true/false)

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

Use o comando expand para nivelar um campo do tipo Array <Any> ou Map<Any>, produzindo linhas individuais para cada elemento ou par chave-valor.

Sintaxe

Use a seguinte sintaxe:

expand <field> [As alias]

Diretrizes de uso

O comando expand produz uma linha para cada elemento na matriz ou no campo de mapa especificado, onde:

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.

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:

Funções PPL

Funções PPL de condição

ISNULL

Descrição: isnull(field) retornará verdadeiro se o campo for nulo.

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.

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.

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.

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.

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

MD5

O MD5 calcula o resumo MD5 e retorna o valor como uma string hexadecimal de 32 caracteres.

Uso: md5('hello')

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')

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

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

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 hora atuais como um valor TIMESTAMP no formato "YYYY-MM-DD hh:mm:ss". O valor é expresso no fuso horário do cluster.

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 hora atuais como um valor TIMESTAMP no formato "YYYY-MM-DD hh:mm:ss.nnnnnn".

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) -> TIMESTAMP

(STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP) -> TIMESTAMP

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: <NONE>/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:

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 as datas/horas de início e fim em unidades de intervalo especificadas.

Argumentos:

A função converte automaticamente argumentos em TIMESTAMP quando apropriado. Formate os argumentos STRING como TIMESTAMPs 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

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:

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:

Operadores

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:

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

CIDRMATCH

Uso: CIDRMATCH(ip, cidr) verifica se o endereço IP especificado está dentro do intervalo cidr fornecido.

Tipo de argumento:

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 |
+-----------------------------------------+    

Funções PPL de JSON

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(<key>, <value>[, <key>, <value>]...) retorna um objeto JSON de membros de pares chave-valor.

Tipo de argumento:

Tipo de retorno: JSON_OBJECT. Uma expressão StructType de um formato de 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(<value>...) cria um JSON ARRAY usando uma lista de valores.

Tipo de argumento: um <value> 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

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

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

ABS

Uso: ABS(x) calcula o valor absoluto de x.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de retorno: 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 -> DOUBLE

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. Retornará um erro de out-of-range 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:

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:

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

CONCAT

Uso: CONCAT(str1, str2, ...., str_9) soma até 9 strings.

Tipo de argumento:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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

TRIM

Uso: cast(expr as dateType) converte expr em dataType e retorna o valor de dataType.

As seguintes regras de conversão se aplicam:

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    |
+---------+