Comandos PPL suportados

As tabelas a seguir mostram quais comandos PPL o OpenSearch Dashboards suporta para consultar CloudWatch Logs, Amazon S3 ou Security Lake, e quais comandos o Logs Insights suporta. CloudWatch CloudWatch O Logs Insights usa a mesma sintaxe PPL dos OpenSearch painéis ao consultar CloudWatch registros, e as tabelas se referem a ambos como registros. CloudWatch

nota

Quando você analisa dados fora do OpenSearch Serviço, os comandos podem ser executados de forma diferente do que nos OpenSearch índices.

Comandos

Comando PPL	Descrição	CloudWatch Registros	Amazon S3	Security Lake	Exemplo de comando
comando fields	Exibe um conjunto de campos que precisam de projeção.	Suportado	Suportado	Suportado	fields field1, field2
onde comando	Filtra os dados com base nas condições que você especifica.	Suportado	Suportado	Suportado	where field1="success" | where field2 != "i -023fe0a90929d8822" | fields field3, col4, col5, col6 | head 1000
comando stats	Executa agregações e cálculos.	Suportado	Suportado	Suportado	stats count(), count(`field1`), min(`field1`), max(`field1`), avg(`field1`) by field2 | head 1000
comando parse	Extrai um padrão de expressão regular (regex) de uma string e exibe o padrão extraído. O padrão extraído pode ser usado posteriormente para criar novos campos ou filtrar dados.	Suportado	Suportado	Suportado	parse `field1` ".*/(?<field2>[^/]+$)" | where field2 = "requestId" | fields field2, `field2` | head 1000
comando de padrões	Extrai padrões de registro de um campo de texto e anexa os resultados ao resultado da pesquisa. O agrupamento de registros por seus padrões facilita a agregação de estatísticas de grandes volumes de dados de registro para análise e solução de problemas.	Não suportado	Suportado	Suportado	patterns new_field='no_numbers' pattern='[0-9]' message | fields message, no_numbers
comando de classificação	Classifique os resultados exibidos por um nome de campo. Use classificar - FieldNamepara classificar em ordem decrescente.	Suportado	Suportado	Suportado	stats count(), count(`field1`), min(`field1`) as field1Alias, max(`field1`), avg(`field1`) by field2 | sort -field1Alias | head 1000
comando eval	Modifica ou processa o valor de um campo e o armazena em um campo diferente. Isso é útil para modificar matematicamente uma coluna, aplicar funções de string a uma coluna ou aplicar funções de data a uma coluna.	Suportado	Suportado	Suportado	eval field2 = `field1` * 2 | fields field1, field2 | head 20
comando renomear	Renomeia um ou mais campos no resultado da pesquisa.	Suportado	Suportado	Suportado	rename field2 as field1 | fields field1
comando principal	Limita os resultados da consulta exibidos às primeiras N linhas.	Suportado	Suportado	Suportado	fields `@message` | head 20
comando grok	Analisa um campo de texto com um padrão grok baseado na expressão regular e anexa os resultados ao resultado da pesquisa.	Suportado	Suportado	Suportado	grok email '.+@%{HOSTNAME:host}' | fields email
comando superior	Encontra os valores mais frequentes para um campo.	Suportado	Suportado	Suportado	top 2 Field1 by Field2
comando dedup	Remove entradas duplicadas com base nos campos que você especifica.	Suportado	Suportado	Suportado	dedup field1 | fields field1, field2, field3
comando join	Une dois conjuntos de dados.	Não suportado	Suportado	Suportado	source=customer | join ON c_custkey = o_custkey orders | head 10
comando lookup	Enriquece seus dados de pesquisa adicionando ou substituindo dados de um índice de pesquisa (tabela de dimensões). Você pode estender os campos de um índice com valores de uma tabela de dimensões, acrescentar ou substituir valores quando a condição de pesquisa corresponder	Não suportado	Suportado	Suportado	where orderType = 'Cancelled' | lookup account_list, mkt_id AS mkt_code replace amount, account_name as name | stats count(mkt_code), avg(amount) by name
comando subquery	Executa consultas complexas e aninhadas em suas instruções Piped Processing Language (PPL).	Não suportado	Suportado	Suportado	where id in [ subquery source=users | where user in [ subquery source=actions | where action="login" | fields user ] | fields uid ]
comando raro	Encontra os valores menos frequentes de todos os campos na lista de campos.	Suportado	Suportado	Suportado	rare Field1 by Field2
comando de linha de tendência	Calcula as médias móveis dos campos.	Suportado	Suportado	Suportado	trendline sma(2, field1) as field1Alias
comando eventstats	Enriquece os dados do seu evento com estatísticas resumidas calculadas. Ele analisa campos especificados em seus eventos, calcula várias medidas estatísticas e, em seguida, anexa esses resultados a cada evento original como novos campos.	Compatível (excetocount())	Suportado	Suportado	eventstats sum(field1) by field2
comando flatten	Nivela um campo. O campo deve ser deste tipo: struct<?,?> or array<struct<?,?>>	Não suportado	Suportado	Suportado	source=table | flatten field1
resumo do campo	Calcula estatísticas básicas para cada campo (contagem, contagem distinta, min, max, avg, stddev e média).	Compatível (um campo por consulta)	Suportado	Suportado	where field1 != 200 | fieldsummary includefields=field1 nulls=true
comando fillnull	Preenche campos nulos com o valor que você fornece. Ele pode ser usado em um ou mais campos.	Não suportado	Suportado	Suportado	fields field1 | eval field2=field1 | fillnull value=0 field1
comando de expansão	Divide um campo contendo vários valores em linhas separadas, criando uma nova linha para cada valor no campo especificado.	Não suportado	Suportado	Suportado	expand employee | stats max(salary) as max by state, company
descrever o comando	Obtém informações detalhadas sobre a estrutura e os metadados de tabelas, esquemas e catálogos	Não suportado	Suportado	Suportado	describe schema.table

Funções

Função PPL	Descrição	CloudWatch Registros	Amazon S3	Security Lake	Exemplo de comando
funções de string PPL (CONCAT, CONCAT_WS, LENGTH, LOWER, LTRIM, POSITION, REVERSE, RIGHT, RTRIM, SUBSTRING, TRIM, UPPER)	Funções integradas no PPL que podem manipular e transformar dados de string e texto em consultas PPL. Por exemplo, converter maiúsculas e minúsculas, combinar sequências de caracteres, extrair partes e limpar texto.	Suportado	Suportado	Suportado	eval col1Len = LENGTH(col1) | fields col1Len
Funções de data e hora do PPL (DAY, DAYOFMONTH, DAY_OF_MONTH,DAYOFWEEK, DAY_OF_WEEK, DAYOFYEAR, DAY_OF_YEAR, DAYNAME, FROM_UNIXTIME, HOUR, HOUR_OF_DAY, LAST_DAY, LOCALTIMESTAMP, LOCALTIME, MAKE_DATE, MINUTE, MINUTE_OF_HOUR, MONTH, MONTHNAME, MONTH_OF_YEAR, NOW, QUARTER, SECOND, SECOND_OF_MINUTE, SUBDATE, SYSDATE, TIMESTAMP, UNIX_TIMESTAMP, WEEK, WEEKDAY, WEEK_OF_YEAR, DATE_ADD, DATE_SUB, TIMESTAMPADD, TIMESTAMPDIFF, UTC_TIMESTAMP, CURRENT_TIMEZONE)	Funções integradas para lidar e transformar dados de data e carimbo de data/hora em consultas PPL. Por exemplo, date_add, date_format, datediff e current_date.	Suportado	Suportado	Suportado	eval newDate = ADDDATE(DATE('2020-08-26'), 1) | fields newDate
Funções de condição PPL (EXISTS, IF, IFNULL, ISNOTNULL, ISNULL, NULLIF)	Funções integradas que realizam cálculos em várias linhas para produzir um único valor resumido. Por exemplo, soma, contagem, média, máxima e mínima.	Suportado	Suportado	Suportado	eval field2 = isnull(col1) | fields field2, col1, field3
Funções matemáticas PPL (ABS, ACOS, ASIN, ATAN, ATAN2, CEIL, CEILING, CONV, COS, COT, CRC32, DEGREES, E, EXP, FLOOR, LN, LOG, LOG2, LOG10, MOD, PI. POW, POWER, RADIANS, RAND, ROUND, SIGN, SIN, SQRT, CBRT)	Funções integradas para realizar cálculos e transformações matemáticas em consultas PPL. Por exemplo: abs (valor absoluto), round (arredonda números), sqrt (raiz quadrada), pow (cálculo de potência) e ceil (arredonda até o número inteiro mais próximo).	Suportado	Suportado	Suportado	eval field2 = ACOS(col1) | fields col1
Expressões PPL (Operadores aritméticos (+,,*)-, operadores de predicados (,) >. < IN)	Funções integradas para expressões, especialmente expressões de valor, retornam um valor escalar. As expressões têm diferentes tipos e formas.	Suportado	Suportado	Suportado	where age > (25 + 5) | fields age
Funções de endereço IP PPL (CIDRMATCH)	Funções integradas para lidar com endereços IP, como CIDR.	Não suportado	Suportado	Suportado	where cidrmatch(ip, '***********/24') | fields ip
Funções PPL JSON (ARRAY_LENGTH, ARRAY_LENGTH, JSON, JSON_ARRAY, JSON_EXTRACT, JSON_KEYS, JSON_OBJECT, JSON_VALID, TO_JSON_STRING)	Funções integradas para lidar com JSON, incluindo matrizes, extração e validação.	Não suportado	Suportado	Suportado	eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a')
Funções PPL Lambda (EXISTS, FILTER, REDUCE, TRANSFORM)	Funções integradas para lidar com JSON, incluindo matrizes, extração e validação.	Não suportado	Suportado	Suportado	eval array = json_array(1, -1, 2), result = filter(array, x -> x > 0) | fields result
Funções hash criptográficas PPL (MD5, SHA1, SHA2)	Funções integradas que permitem gerar impressões digitais exclusivas de dados, que podem ser usadas para verificação, comparação ou como parte de protocolos de segurança mais complexos.	Suportado	Suportado	Suportado	eval `MD5('hello')` = MD5('hello') | fields `MD5('hello')`

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

Embora o CloudWatch Logs Insights ofereça suporte à maioria dos comandos e funções do OpenSearch PPL, alguns comandos e funções não são compatíveis atualmente. Por exemplo, atualmente não oferece suporte a JOIN, Lookup ou subconsultas no PPL. Para obter uma lista completa dos comandos e funções de consulta compatíveis, consulte as colunas Amazon CloudWatch Logs nas tabelas acima.

Exemplos de consultas e cotas

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

Para obter informações sobre os limites que se aplicam ao consultar CloudWatch registros do OpenSearch serviço, consulte Cotas de CloudWatch registros no Guia do usuário do Amazon CloudWatch Logs. Os limites envolvem o número de grupos de CloudWatch registros que você pode consultar, o máximo de consultas simultâneas que você pode executar, o tempo máximo de execução da consulta e o número máximo de linhas retornadas nos resultados. Os limites são os mesmos, independentemente da linguagem usada para consultar CloudWatch registros (ou seja, OpenSearch PPL, SQL e Logs Insights QL).

Comandos PPL

Tópicos

• comment

• comando de correlação

• comando dedup

• descrever o comando

• comando eval

• comando eventstats

• comando de expansão

• explicar o comando

• comando fillnull

• comando fields

• comando flatten

• comando grok

• comando principal

• comando join

• comando lookup

• comando parse

• comando de padrões

• comando raro

• comando renomear

• comando de pesquisa

• comando de classificação

• comando stats

• comando subquery

• comando superior

• comando de linha de tendência

• onde comando

• resumo do campo

• comando de expansão

• Funções PPL

comment

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

O PPL suporta comentários em linha e comentários em bloco. O sistema não avalia o texto do 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        |
+----------+                     

Bloquear comentários

Os comentários em bloco começam com uma barra 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 de correlação

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Você pode correlacionar diferentes fontes de dados de acordo com dimensões e prazos comuns.

Essa correlação é crucial quando você lida com grandes quantidades de dados de vários setores que compartilham os mesmos períodos de tempo, 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 descobrir informações valiosas.

Exemplo

O domínio de observabilidade tem três fontes de dados distintas:

• Logs

• Métricas

• Rastreamentos

Essas fontes de dados podem compartilhar dimensões comuns. Para fazer 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 elementos compartilhados em registros, rastreamentos e métricas.

Exemplo: .

{
  "@timestamp": "2018-07-02T22:23:00.186Z",
  "aws": {
    "elb": {
      "backend": {
        "http": {
          "response": {
            "status_code": 500
          }
        },
        "ip": "********",
        "port": "80"
      },
      ...
     "target_port": [
        "10.0.0.1:80"
      ],
      "target_status_code": [
        "500"
      ],
      "traceId": "Root=1-58337262-36d228ad5d99923122bbe354",
      "type": "http"
    }
  },
  "cloud": {
    "provider": "aws"
  },
  "http": {
    "request": {
    ...
  },
  "communication": {
    "source": {
      "address": "**************",
      "ip": "**************",
      "port": 2817
    }
  },
  "traceId": "Root=1-58337262-36d228ad5d99923122bbe354"
} 

Este exemplo mostra um log do AWS ELB chegando de um serviço residente em. AWS Ele mostra uma resposta HTTP de back-end com um código de status 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 completa.

Embora você possa ficar tentado a consultar todos os dados relacionados ao período de tempo, essa abordagem pode ser complicada. Você pode acabar com muitas informações, gastando mais tempo filtrando dados irrelevantes do que identificando a causa raiz.

Em vez disso, você pode usar uma abordagem mais direcionada correlacionando dados de diferentes fontes. Você pode usar essas dimensões para correlação:

• IP - "ip": "10.0.0.1" | "ip": "**************"

• Porto - "port": 2817 | "target_port": "10.0.0.1:80"

Supondo que você tenha acesso a rastreamentos e índices de métricas adicionais e esteja familiarizado com a estrutura do esquema, você 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 cliente/servidor do http ip que podem ser correlacionados com os registros do elb para entender melhor o comportamento e a condição do sistema.

Novo comando de consulta de correlação

Aqui está o novo comando que permitiria esse tipo de investigação:

source alb_logs, traces | where alb_logs.ip="10.0.0.1" AND alb_logs.cloud.provider="aws"| 
correlate exact fields(traceId, ip) scope(@timestamp, 1D) mapping(alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId )  

Veja o que cada parte do comando faz:

1. source alb_logs, traces- Isso seleciona as fontes de dados que você deseja correlacionar.

2. where ip="10.0.0.1" AND cloud.provider="aws"- Isso restringe o escopo de sua busca.

3. correlate exact fields(traceId, ip)- Isso faz com que o sistema correlacione os dados com base nas correspondências exatas dos seguintes campos:

   • O ip campo tem uma condição de filtro explícita, portanto, será usado na correlação de todas as fontes de dados.

   • O traceId campo não tem filtro explícito, então ele corresponderá aos mesmos traceIDs em todas as fontes de dados.

Os nomes dos campos indicam o significado lógico da função no comando de correlação. A condição real de junção depende da instrução de mapeamento que você fornece.

O termo exact significa que as declarações de correlação exigirão que todos os campos correspondam para cumprir a instrução de consulta.

O termo approximate tentará corresponder no melhor cenário possível e não rejeitará linhas com correspondências parciais.

Abordando diferentes mapeamentos de campo

Nos casos em que o mesmo campo lógico (comoip) tem nomes diferentes em suas fontes de dados, você precisa fornecer o mapeamento explícito dos campos de caminho. Para resolver isso, você pode estender suas condições de correlação para combinar nomes de campos diferentes com significados lógicos semelhantes. Veja como você pode fazer isso:

alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId    

Para cada campo que participa da junçã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, há duas fontes: alb_logs, traces

Existem 2 campos: traceId, ip

Há duas declarações de mapeamento: alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId

Definindo 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 direciona explicitamente a consulta de junção no momento em que ela deve abranger essa pesquisa.

scope(@timestamp, 1D)i

Neste exemplo, o escopo da pesquisa se concentra diariamente, 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 pesquisas com base em suas necessidades.

Apoiando motoristas

O novo comando de correlação é, na verdade, um comando de junção “oculto”. Portanto, somente os drivers PPL a seguir oferecem suporte a esse comando. Nesses drivers, o comando de correlação será traduzido diretamente no plano lógico apropriado do Catalyst Join.

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 junção mais eficiente.

comando dedup

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o dedup comando 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>] 

int

• Opcional.

• <int>O dedup comando retém vários eventos para cada combinação quando você especifica. O número para <int>deve ser maior que 0. Se você não especificar um número, somente o primeiro evento ocorrido será mantido. Todas as outras duplicatas são removidas dos resultados.

• Padrão: 1

keepempty

• Opcional.

• Se verdadeiro, mantém documentos em que qualquer campo na lista de campos tem um valor NULL ou está AUSENTE.

• Padrão: False

consecutive

• Opcional.

• Se verdadeiro, remove somente eventos com combinações consecutivas de valores duplicados.

• Padrão: False

field-list

• Obrigatório.

• Uma lista de campos delimitada por vírgula. Pelo menos um campo é obrigatório.

Exemplo 1: Deduplicação por um campo

Este exemplo mostra como deduplicar 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 desduplicar documentos com o campo de gênero, mantendo duas duplicatas.

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 desduplicar o documento 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                | [e-mail]  |
| 6                | [e-mail]  |
| 13               | null                  |
| 18               | [e-mail]   |
+------------------+-----------------------+      

O exemplo mostra como desduplicar o documento ignorando 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                | [e-mail]  |
| 6                | [e-mail]  |
| 18               | [e-mail]   |
+------------------+-----------------------+      

Exemplo 4: Deduplicação em documentos consecutivos

O exemplo mostra como fazer a deduplicação em documentos consecutivos.

Consulta PPL:

os> source=accounts | dedup gender consecutive=true | fields account_number, gender;
fetched rows / total rows = 3/3
+------------------+----------+
| account_number   | gender   |
+------------------+----------+
| 1                | M        |
| 13               | F        |
| 18               | M        |
+------------------+----------+      

Exemplos adicionais

• source = table | dedup a | fields a,b,c

• source = table | dedup a,b | fields a,b,c

• source = table | dedup a keepempty=true | fields a,b,c

• source = table | dedup a,b keepempty=true | fields a,b,c

• source = table | dedup 1 a | fields a,b,c

• source = table | dedup 1 a,b | fields a,b,c

• source = table | dedup 1 a keepempty=true | fields a,b,c

• source = table | dedup 1 a,b keepempty=true | fields a,b,c

• source = table | dedup 2 a | fields a,b,c

• source = table | dedup 2 a,b | fields a,b,c

• source = table | dedup 2 a keepempty=true | fields a,b,c

• source = table | dedup 2 a,b keepempty=true | fields a,b,c

• source = table | dedup 1 a consecutive=true| fields a,b,c(a desduplicação consecutiva não é suportada)

Limitação

• Para | dedup 2 a, b keepempty=false

  DataFrameDropColumns('_row_number_)
  +- Filter ('_row_number_ <= 2) // allowed duplication = 2
     +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
         +- Filter (isnotnull('a) AND isnotnull('b)) // keepempty=false
            +- Project
               +- UnresolvedRelation        

• Para | dedup 2 a, b keepempty=true

  Union
  :- DataFrameDropColumns('_row_number_)
  :  +- Filter ('_row_number_ <= 2)
  :     +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
  :        +- Filter (isnotnull('a) AND isnotnull('b))
  :           +- Project
  :              +- UnresolvedRelation
  +- Filter (isnull('a) OR isnull('b))
     +- Project
        +- UnresolvedRelation        

descrever o comando

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o describe comando 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 describe comando.

Descrever

• describe tableEsse comando é igual ao comando DESCRIBE EXTENDED table SQL

• describe schema.table

• describe schema.`table`

• describe catalog.schema.table

• describe catalog.schema.`table`

• describe `catalog`.`schema`.`table`

comando eval

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

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

Sintaxe

Use a seguinte sintaxe:

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

• field: Obrigatório. Se o nome do campo não existir, um novo campo será adicionado. Se o nome do campo já existir, ele será substituído.

• expression: Obrigatório. Qualquer expressão suportada pelo sistema.

Exemplo 1: Criar o novo campo

Este exemplo mostra como criar um novo doubleAge campo para cada documento. A novidade 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: Crie o novo campo com o campo definido em eval

Este exemplo mostra como criar um novo ddAge campo com um campo definido no comando eval. O novo campo ddAge é o resultado da avaliação doubleAge multiplicado por 2, onde 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     |
+-------+-------------+---------+        

Suposições:a,b, c existem campos em table

Exemplos adicionais

• source = table | eval f = 1 | fields a,b,c,f

• source = table | eval f = 1(campos de saída a, b, c, f)

• source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t

• source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5

• source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h

• source = table | eval f = a * 2, h = f * 2 | fields a,f,h

• source = table | eval f = a * 2, h = b | stats avg(f) by h

• source = table | eval f = ispresent(a)

• source = table | eval r = coalesce(a, b, c) | fields r

• source = table | eval e = isempty(a) | fields e

• source = table | eval e = isblank(a) | fields e

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))

• source = table | eval f = a in ('foo', 'bar') | fields f

• source = table | eval f = a not in ('foo', 'bar') | fields f

Avaliação com exemplo de caso:

source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')      

Avaliação com outro exemplo de caso:

Suposições:a,b, c existem campos em table

Exemplos adicionais

• source = table | eval f = 1 | fields a,b,c,f

• source = table | eval f = 1(campos de saída a, b, c, f)

• source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t

• source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5

• source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h

• source = table | eval f = a * 2, h = f * 2 | fields a,f,h

• source = table | eval f = a * 2, h = b | stats avg(f) by h

• source = table | eval f = ispresent(a)

• source = table | eval r = coalesce(a, b, c) | fields r

• source = table | eval e = isempty(a) | fields e

• source = table | eval e = isblank(a) | fields e

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))

• source = table | eval f = a in ('foo', 'bar') | fields f

• source = table | eval f = a not in ('foo', 'bar') | fields f

Avaliação com exemplo de caso:

source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')      

Avaliação com outro exemplo de caso:

source = table |  where ispresent(a) |
eval status_category =
 case(a >= 200 AND a < 300, 'Success',
  a >= 300 AND a < 400, 'Redirection',
  a >= 400 AND a < 500, 'Client Error',
  a >= 500, 'Server Error'
  else 'Incorrect HTTP status code'
 )
 | stats count() by status_category      

Limitações

• A substituição de campos existentes não é suportada. As consultas que tentarem fazer isso gerarão exceções com a mensagem “A” é ambígua”.

  - `source = table | eval a = 10 | fields a,b,c`
  - `source = table | eval a = a * 2 | stats avg(a)`
  - `source = table | eval a = abs(a) | where a > 0`
  - `source = table | eval a = signum(a) | where a < 0`        

comando eventstats

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o eventstats comando para enriquecer os dados do evento com estatísticas resumidas calculadas. Ele opera analisando campos especificados em seus eventos, computando várias medidas estatísticas e anexando esses resultados como novos campos a cada evento original.

Principais aspectos das estatísticas de eventos

1. Ele executa cálculos em todo o conjunto de resultados ou em grupos definidos.

2. Os eventos originais permanecem intactos, com novos campos adicionados para conter os resultados estatísticos.

3. O comando é particularmente útil para análise comparativa, identificação de valores discrepantes ou fornecimento de contexto adicional a eventos individuais.

Diferença entre estatísticas e estatísticas de eventos

Os eventstats comandos stats e são usados para calcular estatísticas, mas eles têm algumas diferenças importantes na forma como operam e no que produzem.

Formato de saída

• stats: produz uma tabela resumida somente com as estatísticas calculadas.

• eventstats: adiciona as estatísticas calculadas como novos campos aos eventos existentes, preservando os dados originais.

Retenção de eventos

• stats: reduz o conjunto de resultados somente para o resumo estatístico, descartando eventos individuais.

• eventstats: retém todos os eventos originais e adiciona novos campos com as estatísticas calculadas.

Casos de uso

• stats: Ideal para criar relatórios resumidos ou painéis. Geralmente usado como um comando final para resumir os resultados.

• eventstats: útil quando você precisa enriquecer eventos com contexto estatístico para análise ou filtragem adicionais. Pode ser usado no meio da pesquisa para adicionar estatísticas que podem ser usadas em comandos subsequentes.

Sintaxe

Use a seguinte sintaxe:

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

agregação

• Obrigatório.

• Uma função de agregação.

• O argumento da agregação deve ser um campo.

cláusula acessória

• Opcional.

• Sintaxe: by [span-expression,] [field,]...

• A cláusula by pode incluir campos e expressões, como funções escalares e funções de agregação. Você também pode usar a cláusula span para dividir um campo específico em compartimentos de intervalos iguais. Em seguida, o comando eventstats executa a agregação com base nesses intervalos de extensão.

• Padrão: se você não especificar uma cláusula by, o comando eventstats agregará todo o conjunto de resultados.

expressão de extensão

• Opcional, no máximo um.

• Sintaxe: span(field_expr, interval_expr)

• A unidade da expressão de intervalo é a unidade natural por padrão. No entanto, para campos do tipo data e hora, você precisa especificar a unidade na expressão de intervalo ao usar unidades de data/hora.

  Por exemplo, para dividir o campo age em compartimentos por 10 anos, usespan(age, 10). Para campos baseados em tempo, você pode dividir um timestamp campo em intervalos de hora usando. span(timestamp, 1h)

Unidades de tempo disponíveis

Unidades de intervalo de amplitude
milissegundo (ms)
segundo (s)
minuto (m, diferencia maiúsculas de minúsculas)
hora (h)
dia (d)
semana (w)
mês (M, diferencia maiúsculas de minúsculas)
quarto (q)
ano (y)

Funções de agregação

COUNT

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

Para consultas de uso de CloudWatch registros, não COUNT é compatível.

Exemplo: .

os> source=accounts | eventstats count();
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| account_number | balance  | firstname | lastname | age | gender | address            | employer   | email                    | city   | state | count() |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | *** Any Lane       | AnyCorp    | [e-mail]      | Brogan | IL    | 4       |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street | AnyCompany | [e-mail] | Dante  | TN    | 4       |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street     | AnyOrg     |                          | Nogal  | VA    | 4       |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court  |            | [e-mail]    | 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    | [e-mail]      | Brogan | IL    | 101                |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | AnyCompany | [e-mail] | 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     |            | [e-mail]    | 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     | [e-mail]      | Brogan | IL    | 33.67              |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | [e-mail] | 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     |             | [e-mail]    | 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     | [e-mail]      | Brogan | IL    | 36        |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | [e-mail] | Dante  | TN    | 36        |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 36        |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | [e-mail]    | 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     | [e-mail]      | Brogan | IL    | 28        |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | [e-mail] | Dante  | TN    | 28        |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | *** Any Street        | AnyOrg      |                          | Nogal  | VA    | 28        |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | [e-mail]    | Orick  | MD    | 28        |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+        

STDDEV_SAMP

STDDEV_SAMP(expr)Retorne 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     | [e-mail]      | Brogan | IL    | 3.304037933599835      |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | [e-mail] | 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     |             | [e-mail]    | Orick  | MD    | 3.304037933599835      |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+        

STDDEV_POP

STDDEV_POP(expr)Retorne 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     | [e-mail]      | Brogan | IL    | 2.****************     |
| 6              | 5686     | Mary      | Major    | 36  | M      | *** Example Street    | Any Company | [e-mail] | Dante  | TN    | 2.****************     |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | *** Any Street        | AnyOrg      |                          | Nogal  | VA    | 2.****************     |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | [e-mail]    | Orick  | MD    | 2.****************     |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+        

PERCENTILE ou PERCENTILE_APPROX

PERCENTILE(expr, percent)ou PERCENTILE_APPROX(expr, percent) Retorne o valor aproximado do percentil de expr na porcentagem especificada.

percentual

• O número deve ser uma constante entre 0 e 100.

Exemplo

os> source=accounts | eventstats percentile(age, 90) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | percentile(age, 90) by gender  |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | *** Any Lane          | AnyCorp     | [e-mail]      | Brogan | IL    | 36                             |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | [e-mail] | Dante  | TN    | 36                             |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 28                             |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | [e-mail]    | Orick  | MD    | 36                             |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+        

Exemplo 1: Calcular a média, a soma e a contagem de um campo por grupo

O exemplo mostra 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     | [e-mail]      | Brogan | IL    | 33.666667 | 101       | 3     |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | [e-mail] | 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     |             | [e-mail]    | Orick  | MD    | 33.666667 | 101       | 3     |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+      

Exemplo 2: Calcular a contagem por um intervalo

O exemplo obtém a contagem da idade no 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     | [e-mail]      | Brogan | IL    | 3        |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | [e-mail] | Dante  | TN    | 3        |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 1        |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | [e-mail]    | Orick  | MD    | 3        |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+      

Exemplo 3: Calcular a contagem por sexo e extensão

O exemplo obtém a contagem da idade no intervalo de 5 anos e o grupo 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     | [e-mail]       | Brogan | IL    | 2   |
| 6              | 5686     | Mary      | Majo     | 36  | M      | 671 Example Street    | Any Company | [e-mail] | Dante  | TN    | 1   |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | *** Any Street        | AnyOrg      |                           | Nogal  | VA    | 1   |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | [e-mail]     | Orick  | MD    | 2   |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+      

Uso

• source = table | eventstats avg(a)

• source = table | where a < 50 | eventstats avg(c)

• source = table | eventstats max(c) by b

• source = table | eventstats count(c) by b | head 5

• source = table | eventstats distinct_count(c)

• source = table | eventstats stddev_samp(c)

• source = table | eventstats stddev_pop(c)

• source = table | eventstats percentile(c, 90)

• source = table | eventstats percentile_approx(c, 99)

Agregações com amplitude

• source = table | eventstats count(a) by span(a, 10) as a_span

• source = table | eventstats sum(age) by span(age, 5) as age_span | head 2

• source = table | eventstats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2

Agregações com intervalo de janela de tempo (função de janela giratória)

• source = table | eventstats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date

• source = table | eventstats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId

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

• source = table | eventstats avg(age) as avg_state_age by country, state | eventstats avg(avg_state_age) as avg_country_age by country

• source = table | eventstats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | eventstats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | eventstats avg(avg_state_age) as avg_adult_country_age by country

comando de expansão

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o expand comando para nivelar um campo do tipo:

• Array<Any>

• Map<Any>

Sintaxe

Use a seguinte sintaxe:

expand <field> [As alias]

Campo

• O campo a ser expandido (explodido). Deve ser de um tipo compatível.

alias

• Opcional. O nome a ser usado em vez do nome do campo original.

Uso

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

• Os elementos da matriz se tornam linhas individuais.

• Os pares de valores-chave do mapa são divididos em linhas separadas, com cada valor-chave representado como uma linha.

• Quando um alias é fornecido, os valores explodidos são representados sob o alias em vez do nome do campo original.

• Isso pode ser usado em combinação com outros comandos, como statseval, e parse para manipular ou extrair dados após a expansão.

Exemplos

• source = table | expand employee | stats max(salary) as max by state, company

• source = table | expand employee as worker | stats max(salary) as max by state, company

• source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus

• source = table | expand employee | parse description '(?<email>.+@.+)' | fields employee, email

• source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid

• source = table | expand multi_valueA as multiA | expand multi_valueB as multiB

explicar o comando

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

O explain comando ajuda você a entender os planos de execução de consultas, permitindo que você analise e otimize suas consultas para melhorar o desempenho. Esta introdução fornece uma visão geral concisa da finalidade do comando explain e de sua importância na otimização de consultas.

Comentário

• source=accounts | top gender // finds most common gender of all the accounts(comentário em linha)

• source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender(bloquear comentário)

Descrever

• describe tableEsse comando é igual ao comando DESCRIBE EXTENDED table SQL

• describe schema.table

• describe schema.`table`

• describe catalog.schema.table

• describe catalog.schema.`table`

• describe `catalog`.`schema`.`table`

Explicar

• explain simple | source = table | where a = 1 | fields a,b,c

• explain extended | source = table

• explain codegen | source = table | dedup a | fields a,b,c

• explain cost | source = table | sort a | fields a,b,c

• explain formatted | source = table | fields - a

• explain simple | describe table

Campos

• source = table

• source = table | fields a,b,c

• source = table | fields + a,b,c

• source = table | fields - b,c

• source = table | eval b1 = b | fields - b1,c

Resumo do campo

• source = t | fieldsummary includefields=status_code nulls=false

• source = t | fieldsummary includefields= id, status_code, request_path nulls=true

• source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true

Campo aninhado

• source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1

• source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield

• source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield

Filtros

• source = table | where a = 1 | fields a,b,c

• source = table | where a >= 1 | fields a,b,c

• source = table | where a < 1 | fields a,b,c

• source = table | where b != 'test' | fields a,b,c

• source = table | where c = 'test' | fields a,b,c | head 3

• source = table | where ispresent(b)

• source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3

• source = table | where isempty(a)

• source = table | where isblank(a)

• source = table | where case(length(a) > 6, 'True' else 'False') = 'True'

• source = table | where a not in (1, 2, 3) | fields a,b,c

• source = table | where a between 1 and 4- Nota: Isso retorna um >= 1 e um <= 4, ou seja, [1, 4]

• source = table | where b not between '2024-09-10' and '2025-09-10'- Nota: Isso retorna b >= '**********' e b <= '2025-09-10'

• source = table | where cidrmatch(ip, '***********/24')

• source = table | where cidrmatch(ipv6, '2003:db8::/32')

• source = table | trendline sma(2, temperature) as temp_trend

Consultas relacionadas ao IP

• source = table | where cidrmatch(ip, '**************')

• source = table | where isV6 = false and isValid = true and cidrmatch(ipAddress, '**************')

• source = table | where isV6 = true | eval inRange = case(cidrmatch(ipAddress, '2003:***::/32'), 'in' else 'out') | fields ip, inRange

Filtros complexos

source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
    a >= 300 AND a < 400, 'Redirection',
    a >= 400 AND a < 500, 'Client Error',
    a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
    a >= 300 AND a < 400, 'Redirection',
    a >= 400 AND a < 500, 'Client Error',
    a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'    

source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor    

Filtros com condições lógicas

• source = table | where c = 'test' AND a = 1 | fields a,b,c

• source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1

• source = table | where c = 'test' NOT a > 1 | fields a,b,c

Avaliação

Suposições:a,b, c existem campos em table

• source = table | eval f = 1 | fields a,b,c,f

• source = table | eval f = 1(campos de saída a, b, c, f)

• source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t

• source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5

• source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h

• source = table | eval f = a * 2, h = f * 2 | fields a,f,h

• source = table | eval f = a * 2, h = b | stats avg(f) by h

• source = table | eval f = ispresent(a)

• source = table | eval r = coalesce(a, b, c) | fields r

• source = table | eval e = isempty(a) | fields e

• source = table | eval e = isblank(a) | fields e

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')

• source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))

• source = table | eval digest = md5(fieldName) | fields digest

• source = table | eval digest = sha1(fieldName) | fields digest

• source = table | eval digest = sha2(fieldName,256) | fields digest

• source = table | eval digest = sha2(fieldName,512) | fields digest

comando fillnull

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Descrição

Use o fillnull comando para substituir valores nulos 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>]]

• substituição nula: obrigatória. O valor usado para substituir valores nulos.

• campo anulável: obrigatório. Referência de campo. Os valores nulos nesse campo serão substituídos pelo valor especificado em null-replacement.

Exemplo 1: preencha um campo nulo

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

O exemplo mostra fillnull com vários valores usados para substituir nulos.

• /errorem request_path campo

• 1970-01-01 00:00:00em timestamp campo

os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull using request_path = '/error', timestamp='1970-01-01 00:00:00';

| input_request_path | input_timestamp       | request_path | timestamp              |
|------------------------------------------------------------------------------------|
| /contact           | NULL                  | /contact     | 1970-01-01 00:00:00    |
| /home              | NULL                  | /home        | 1970-01-01 00:00:00    |
| /about             | 2023-10-01 10:30:00   | /about       | 2023-10-01 10:30:00    |
| /home              | 2023-10-01 10:15:00   | /home        | 2023-10-01 10:15:00    |
| NULL               | 2023-10-01 10:20:00   | /error       | 2023-10-01 10:20:00    |
| NULL               | 2023-10-01 11:05:00   | /error       | 2023-10-01 11:05:00    |
| /about             | NULL                  | /about       | 1970-01-01 00:00:00    |
| /home              | 2023-10-01 10:00:00   | /home        | 2023-10-01 10:00:00    |
| /contact           | NULL                  | /contact     | 1970-01-01 00:00:00    |
| NULL               | 2023-10-01 10:05:00   | /error       | 2023-10-01 10:05:00    |
| NULL               | 2023-10-01 10:50:00   | /error       | 2023-10-01 10:50:00    |
| /services          | NULL                  | /services    | 1970-01-01 00:00:00    |
| /home              | 2023-10-01 10:45:00   | /home        | 2023-10-01 10:45:00    |
| /services          | 2023-10-01 11:00:00   | /services    | 2023-10-01 11:00:00    |
| NULL               | 2023-10-01 10:35:00   | /error       | 2023-10-01 10:35:00    |

comando fields

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

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

Sintaxe

Use a seguinte sintaxe:

field [+|-] <field-list> 

• index: opcional.

  Se o sinal de adição (+) for usado, somente os campos especificados na lista de campos serão mantidos.

  Se o sinal de menos (-) for usado, todos os campos especificados na lista de campos serão removidos.

  Padrão: +

• field list: Obrigatório. Uma lista delimitada por vírgulas de campos a serem mantidos ou removidos.

Exemplo 1: Selecionar campos especificados do resultado

Este exemplo mostra como buscaraccount_number,firstname, e lastname campos 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 account_number campo dos resultados da pesquisa.

Consulta PPL:

os> source=accounts | fields account_number, firstname, lastname | fields - account_number ;
fetched rows / total rows = 4/4
+-------------+------------+
| firstname   | lastname   |
|-------------+------------|
| Jane        | Doe        |
| John        | Doe        |
| Jorge       | Souza      |
| Juan        | Li         |
+-------------+------------+        

Exemplos adicionais

• source = table

• source = table | fields a,b,c

• source = table | fields + a,b,c

• source = table | fields - b,c

• source = table | eval b1 = b | fields - b1,c

Exemplo de campos aninhados:

`source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
`source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields  int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
`source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields  int_col, struct_col.field1.subfield, struct_col2.field1.subfield`

comando flatten

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o comando flatten para expandir campos dos seguintes tipos:

• struct<?,?>

• array<struct<?,?>>

Sintaxe

Use a seguinte sintaxe:

flatten <field>

• campo: O campo a ser nivelado. O campo deve ser do tipo suportado.

Esquema

col_name	data_type
_hora	string
pontes	<length:bigint, name:string>matriz <estrutura>
city	string
cor	estrutura<alt:bigint, lat:double, long:double>
country	string

Dados

_hora	pontes	city	cor	country
2024-09-13T 12:00:00	[{801, Tower Bridge}, {928, Ponte de Londres}]	Londres	{35, 51,5074, -0,1278}	Inglaterra
2024-09-13T 12:00:00	[{232, Ponte Nova}, {160, Ponte Alexandre III}]	Paris	{35, 48,856, 2,352}	França
2024-09-13T 12:00:00	[{48, Ponte Rialto}, {11, Ponte dos Suspiros}]	Veneza	{2, 45,408, 12,315}	Itália
2024-09-13T 12:00:00	[{***, Ponte Carlos}, {343, Ponte da Legião}]	Praga	{200, 50,075, 14,4378}	República Tcheca
2024-09-13T 12:00:00	[{375, Ponte Chain}, {333, Ponte da Liberdade}]	Budapeste	{96, 47,4979, 19,0402}	Hungria
1990-09-13T 12:00:00	NULL	Varsóvia	NULL	Polônia

Exemplo 1: estrutura plana

Este exemplo mostra como nivelar um campo de estrutura.

Consulta PPL:

source=table | flatten coor

_hora	pontes	city	country	alt	lat	longo
2024-09-13T 12:00:00	[{801, Tower Bridge}, {928, Ponte de Londres}]	Londres	Inglaterra	35	51.5074	-0,1278
2024-09-13T 12:00:00	[{232, Ponte Nova}, {160, Ponte Alexandre III}]	Paris	França	35	48.856	2.352
2024-09-13T 12:00:00	[{48, Ponte Rialto}, {11, Ponte dos Suspiros}]	Veneza	Itália	2	45.4408	12.315
2024-09-13T 12:00:00	[{516, Ponte Carlos}, {343, Ponte da Legião}]	Praga	República Tcheca	200	50.075	14.4378
2024-09-13T 12:00:00	[{375, Ponte Chain}, {333, Ponte da Liberdade}]	Budapeste	Hungria	96	47.4979	19.04.02
1990-09-13T 12:00:00	NULL	Varsóvia	Polônia	NULL	NULL	NULL

Exemplo 2: nivelar matriz

O exemplo mostra como nivelar uma matriz de campos de estrutura.

Consulta PPL:

source=table | flatten bridges

_hora	city	cor	country	length	nome
2024-09-13T 12:00:00	Londres	{35, 51,5074, -0,1278}	Inglaterra	801	Tower Bridge
2024-09-13T 12:00:00	Londres	{35, 51,5074, -0,1278}	Inglaterra	928	Ponte de Londres
2024-09-13T 12:00:00	Paris	{35, 48,856, 2,352}	França	232	Pont Neuf
2024-09-13T 12:00:00	Paris	{35, 48,856, 2,352}	França	160	Ponte Alexandre III
2024-09-13T 12:00:00	Veneza	{2, 45,408, 12,315}	Itália	48	Ponte Rialto
2024-09-13T 12:00:00	Veneza	{2, 45,408, 12,315}	Itália	11	Ponte dos Suspiros
2024-09-13T 12:00:00	Praga	{200, 50,075, 14,4378}	República Tcheca	516	Ponte Carlos
2024-09-13T 12:00:00	Praga	{200, 50,075, 14,4378}	República Tcheca	343	Ponte da Legião
2024-09-13T 12:00:00	Budapeste	{96, 47,4979, 19,0402}	Hungria	375	Ponte Chain
2024-09-13T 12:00:00	Budapeste	{96, 47,4979, 19,0402}	Hungria	333	Ponte da Liberdade
1990-09-13T 12:00:00	Varsóvia	NULL	Polônia	NULL	NULL

Exemplo 3: nivelar matriz e estrutura

Este exemplo mostra como nivelar vários campos.

Consulta PPL:

source=table | flatten bridges | flatten coor

_hora	city	country	length	nome	alt	lat	longo
2024-09-13T 12:00:00	Londres	Inglaterra	801	Tower Bridge	35	51.5074	-0,1278
2024-09-13T 12:00:00	Londres	Inglaterra	928	Ponte de Londres	35	51.5074	-0,1278
2024-09-13T 12:00:00	Paris	França	232	Pont Neuf	35	48.856	2.352
2024-09-13T 12:00:00	Paris	França	160	Ponte Alexandre III	35	48.856	2.352
2024-09-13T 12:00:00	Veneza	Itália	48	Ponte Rialto	2	45.4408	12.315
2024-09-13T 12:00:00	Veneza	Itália	11	Ponte dos Suspiros	2	45.4408	12.315
2024-09-13T 12:00:00	Praga	República Tcheca	516	Ponte Carlos	200	50.075	14.4378
2024-09-13T 12:00:00	Praga	República Tcheca	343	Ponte da Legião	200	50.075	14.4378
2024-09-13T 12:00:00	Budapeste	Hungria	375	Ponte Chain	96	47.4979	19.04.02
2024-09-13T 12:00:00	Budapeste	Hungria	333	Ponte da Liberdade	96	47.4979	19.04.02
1990-09-13T 12:00:00	Varsóvia	Polônia	NULL	NULL	NULL	NULL	NULL

comando grok

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

O grok comando analisa um campo de texto com um padrão grok e anexa os resultados ao resultado da pesquisa.

Sintaxe

Use a seguinte sintaxe:

grok <field> <pattern>

Campo

• Obrigatório.

• O campo deve ser um campo de texto.

pattern

• Obrigatório.

• O padrão grok usado para extrair novos campos do campo de texto fornecido.

• Se um novo nome de campo já existir, ele substituirá o campo original.

Padrão grok

O padrão grok é usado para combinar o campo de texto de cada documento para extrair novos campos.

Exemplo 1: Criar o novo campo

Este exemplo mostra como criar um novo campo host para cada documento. hostserá o nome do host depois @ do email campo. 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        |
|-------------------------+-------------|
| [e-mail]    | example.com |
| [e-mail] | example.net |
| null                    |             |
| [e-mail]     | example.org |
+-------------------------+-------------+      

Exemplo 2: substituir o campo existente

Este exemplo mostra como substituir o address campo existente com o 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: Usando o grok para analisar registros

Este exemplo mostra como usar o grok para analisar registros 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 do comando parse.

comando principal

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o head comando para retornar o primeiro número N de resultados especificados após um deslocamento opcional na ordem de pesquisa.

Sintaxe

Use a seguinte sintaxe:

head [<size>] [from <offset>]

<size>

• Opcional inteiro.

•     o número máximo de resultados a serem retornados.

• Padrão: 10

<offset>

• Inteiro depois do opcionalfrom.

• O número de resultados a serem ignorados.

• Padrão: 0

Exemplo 1: obtenha 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: Obtenha os primeiros N 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: Obtenha os primeiros N resultados após o deslocamento M

Este exemplo mostra como recuperar os primeiros N resultados depois de ignorar M resultados do índice de contas.

Consulta PPL:

os> source=accounts | fields firstname, age | head 3 from 1;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname   | age   |
|-------------+-------|
| John        | 36    |
| Jorge       | 28    |
| Juan        | 33    |
+-------------+-------+      

comando join

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

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 dos índices:

otel-v1-apm-span-*

• traceID - Um identificador exclusivo para um rastreamento. Todos os intervalos do mesmo rastreamento compartilham o mesmo traceID.

• SpanId - Um identificador exclusivo para uma extensão dentro de um rastreamento, atribuído quando a extensão é criada.

• parentSpanId - O SpanID do intervalo principal desse período. Se for uma extensão raiz, esse campo deverá estar vazio.

• durationInNanos - A diferença em nanossegundos entre StartTime e EndTime. (isso está latency na interface do usuário)

• serviceName - O recurso do qual a extensão se origina.

• TraceGroup - O nome da extensão raiz do rastreamento.

otel-v1-apm-service-map

• serviceName - O nome do serviço que emitiu o intervalo.

• destination.domain - O serviceName do serviço que está sendo chamado por esse cliente.

• destination.resource - O nome do intervalo (API, operação etc.) que está sendo chamado por esse cliente.

• target.domain - O serviceName do serviço que está sendo chamado por um cliente.

• target.resource - O nome do intervalo (API, operação etc.) que está sendo chamado por um cliente.

• traceGroupName - O nome do intervalo de nível superior que iniciou a cadeia de solicitações.

Requisito

Support join para calcular o seguinte:

Para cada serviço, junte o índice de amplitude no índice do mapa de serviços para calcular métricas em diferentes tipos de filtros.

Esse exemplo de consulta calcula a latência quando filtrada por 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>      

Reescrevendo

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      

Tipo de junção

• Sintaxe: INNER | LEFT OUTER | CROSS

• Opcional

• O tipo de junção a ser realizada. O padrão é INNER se não for especificado.

Alias esquerdo

• Sintaxe: left = <leftAlias>

• Opcional

• O alias da subconsulta a ser usado com o lado esquerdo da junção, para evitar nomenclaturas ambíguas.

Critérios de adesão

• Sintaxe: <expression>

• Obrigatório

• A sintaxe começa comON. Pode ser qualquer expressão de comparação. Geralmente, os critérios de junção parecem assim<leftAlias>.<leftField>=<rightAlias>.<rightField>.

  Por exemplo: l.id = r.id. Se os critérios de junção contiverem várias condições, você poderá especificar AND um OR operador entre cada expressão de comparação. Por exemplo, .l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)

Mais exemplos de

Migração da 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 de junção PPL:

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: subpesquisas não são suportadas na junção do lado direito.

Se houver suporte para subpesquisas, você poderá reescrever a consulta PPL acima da seguinte forma:

SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
   ON c_custkey = o_custkey
   [
      SEARCH source=orders
      | WHERE o_comment NOT LIKE '%unusual%packages%'
      | FIELDS o_orderkey, o_custkey
   ]
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count      

comando lookup

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o lookup comando para enriquecer seus 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 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 lookup comando é mais adequado do que o Join comando para enriquecer os dados de origem 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>    

Índice de pesquisa

• Obrigatório.

• O nome do índice de pesquisa (tabela de dimensões).

lookupMappingField

• Obrigatório.

• Uma chave de mapeamento no índice de pesquisa, análoga a uma chave de junção da tabela à direita. Você pode especificar vários campos, separados por vírgulas.

sourceMappingField

• Opcional.

• Padrão: < lookupMappingField >.

• Uma chave de mapeamento da consulta de origem, análoga a uma chave de junção do lado esquerdo.

Campo de entrada

• Opcional.

• Padrão: todos os campos do índice de pesquisa em que os valores correspondentes são encontrados.

• Um campo no índice de pesquisa em que os valores correspondentes são aplicados à saída do resultado. Você pode especificar vários campos, separados por vírgulas.

Campo de saída

• Opcional.

• Padrão: <inputField>.

• Um campo na saída. Você pode especificar vários campos de saída. Se você especificar um nome de campo existente na consulta de origem, seus valores serão substituídos ou acrescentados por valores correspondentes de InputField. Se você especificar um novo nome de campo, ele será adicionado aos resultados.

SUBSTITUIR | ACRESCENTAR

• Opcional.

• Padrão: SUBSTITUIR

• Especifica como lidar com valores correspondentes. Se você especificar REPLACE, os valores correspondentes no <lookupIndex>campo substituirão os valores no resultado. Se você especificarAPPEND, os valores correspondentes no <lookupIndex>campo serão acrescentados somente aos valores ausentes no resultado.

Uso

• <lookupIndex>ID DE PESQUISA AS CID SUBSTITUIR e-mail COMO e-mail

• <lookupIndex>NOME DE PESQUISA SUBSTITUIR e-mail COMO e-mail

• <lookupIndex>ID DE PESQUISA AS CID, nome ANEXAR endereço, e-mail AS e-mail

• <lookupIndex>ID DE PESQUISA

Exemplo

Veja os exemplos de 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 parse comando analisa um campo de texto com uma expressão regular e acrescenta o resultado ao resultado da pesquisa.

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Sintaxe

Use a seguinte sintaxe:

parse <field> <pattern>    

field

• Obrigatório.

• O campo deve ser um campo de texto.

pattern

• Cadeia de caracteres obrigatória.

• Esse é o padrão de expressão regular usado para extrair novos campos do campo de texto fornecido.

• Se um novo nome de campo já existir, ele substituirá o campo original.

Expressão regular

O padrão de expressão regular é usado para combinar todo o campo de texto de cada documento com o mecanismo Java regex. Cada grupo de captura nomeado na expressão se tornará um novo STRING campo.

Exemplo 1: Criar um novo campo

O exemplo mostra como criar um novo campo host para cada documento. hostserá o nome do host depois @ do email campo. 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        |
|-----------------------+-------------|
| [e-mail]  | example.com |
| [e-mail]  | example.net |
| null                  |             |
| [e-mail]   | example.org |
+-----------------------+-------------+      

Exemplo 2: substituir um campo existente

O exemplo mostra como substituir o address campo existente com o 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 maiores que 500 no address campo.

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:

• Os campos definidos pela análise não podem ser analisados novamente.

  O comando a seguir não funcionará:

  source=accounts | parse address '\d+ (?<street>.+)' | parse street '\w+ (?<road>\w+)'

• Os campos definidos pelo parse não podem ser substituídos por outros comandos.

  wherenão corresponderá a nenhum documento, pois street não pode ser substituído:

  source=accounts | parse address '\d+ (?<street>.+)' | eval street='1' | where street='1' ;        

• O campo de texto usado pelo parse não pode ser substituído.

  streetnão será analisado com sucesso, pois foi address substituído:

  source=accounts | parse address '\d+ (?<street>.+)' | eval address='1' ;        

• Os campos definidos pelo parse não podem ser filtrados ou classificados após serem usados no comando. stats

  whereno comando a seguir não funcionará:

  source=accounts | parse email '.+@(?<host>.+)' | stats avg(age) by host | where host=pyrami.com ;        

comando de padrões

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

O patterns comando extrai padrões de log de um campo de texto e anexa os resultados ao resultado da pesquisa. O agrupamento de registros por seus padrões facilita a agregação de estatísticas de grandes volumes de dados de registro para análise e solução de problemas.

Sintaxe

Use a seguinte sintaxe:

patterns [new_field=<new-field-name>] [pattern=<pattern>] <field>    

new-field-name

• Cadeia de caracteres opcional.

• Esse é o nome do novo campo para padrões extraídos.

• O padrão é patterns_field.

• Se o nome já existir, ele substituirá o campo original.

pattern

• Cadeia de caracteres opcional.

• Esse é o padrão regex de caracteres que devem ser filtrados do campo de texto.

• Se ausente, o padrão padrão é de caracteres alfanuméricos ([a-zA-Z\d]).

Campo

• Obrigatório.

• O campo deve ser um campo de texto.

Exemplo 1: Criar o novo campo

O exemplo mostra como usar pontuações de extração em cada email 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   |
|-----------------------+------------------|
| [e-mail]  | @.               |
| [e-mail]  | @.               |
| null                  |                  |
| [e-mail]   | @.               |
+-----------------------+------------------+      

Exemplo 2: Extrair padrões de registro

O exemplo mostra como extrair pontuações de um campo de registro 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: Extraia padrões de log com padrão de regex personalizado

O exemplo mostra como extrair pontuações de um campo de registro bruto usando 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 do comando parse.

comando raro

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

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

nota

Um máximo de 10 resultados são retornados para cada tupla distinta de valores dos campos agrupados por.

Sintaxe

Use a seguinte sintaxe:

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

lista de campos

• Obrigatório.

• Uma lista delimitada por vírgula de nomes de campo.

cláusula acessória

• Opcional.

• Um ou mais campos para agrupar os resultados.

N

•     o número máximo de resultados a serem retornados.

• Padrão: 10

raro_aproximado

• A contagem aproximada dos campos raros (n) usando a cardinalidade estimada pelo HyperLogLog algoritmo ++.

Exemplo 1: Encontre os valores menos comuns em um campo

O exemplo encontra o sexo menos comum de todas as contas.

Consulta PPL:

os> source=accounts | rare gender;
os> source=accounts | rare_approx 10 gender;
os> source=accounts | rare_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender   |
|----------|
| F        |
| M        |
+----------+   

Exemplo 2: Encontre os valores menos comuns organizados por gênero

O exemplo mostra a idade 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 renomear

Use o rename comando para alterar os nomes de um ou mais campos no resultado da pesquisa.

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Sintaxe

Use a seguinte sintaxe:

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

campo de origem

• Obrigatório.

• Esse é o nome do campo que você deseja renomear.

campo-alvo

• Obrigatório.

• Esse é o nome para o qual você deseja renomear.

Exemplo 1: Renomear um campo

Este exemplo mostra como renomear um único campo.

Consulta PPL:

os> source=accounts | rename account_number as an | fields an;
fetched rows / total rows = 4/4
+------+
| an   |
|------|
| 1    |
| 6    |
| 13   |
| 18   |
+------+      

Exemplo 2: renomear vários campos

Este exemplo mostra como renomear vários campos.

Consulta PPL:

os> source=accounts | rename account_number as an, employer as emp | fields an, emp;
fetched rows / total rows = 4/4
+------+---------+
| an   | emp     |
|------+---------|
| 1    | Pyrami  |
| 6    | Netagy  |
| 13   | Quility |
| 18   | null    |
+------+---------+      

Limitações

• A substituição do campo existente não é suportada:

  source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address        

comando de pesquisa

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o search comando para recuperar documentos de um índice. O search comando só pode ser usado como o primeiro comando em uma consulta PPL.

Sintaxe

Use a seguinte sintaxe:

search source=[<remote-cluster>:]<index> [boolean-expression]    

pesquisar

• Opcional.

• Palavras-chave de pesquisa, que podem ser omitidas.

índice

• Obrigatório.

• O comando de pesquisa deve especificar de qual índice consultar.

• O nome do índice pode ser prefixado por <cluster name>: para pesquisas entre clusters.

expressão bool

• Opcional.

• Qualquer expressão que seja avaliada como um valor booleano.

Exemplo 1: Buscar todos os dados

O exemplo mostra buscar 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    | [e-mail]  | Souza      |
| 6                | John        | *** Example Street   | 5686      | M        | Dante  | AnyCorp        | TN      | 36    | [e-mail]  | Doe        |
| 13               | Jane        | *** Any Street       | *****     | F        | Nogal  | ExampleCompany | VA      | 28    | null                  | Doe        |
| 18               | Juan        | *** Example Court    | 4180      | M        | Orick  | null           | MD      | 33    | [e-mail]   | Li         |
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+      

Exemplo 2: Buscar dados com condição

O exemplo mostra buscar todo o documento do índice de contas com.

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    | [e-mail] | Souza      |
| 13               | Jane        | *** Any Street     | *****     | F        | Nogal  | ExampleCompany | VA      | 28    | null                    | Doe        |
+------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+      

comando de classificação

Use o sort comando para classificar o resultado da pesquisa por campos especificados.

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Sintaxe

Use a seguinte sintaxe:

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

[+|-]

• Opcional.

• O sinal de adição [+] significa ordem crescente com valores NULL/MISSING primeiro.

• O sinal de menos [-] representa a ordem decrescente com os valores NULL/MISSING por último.

• Padrão: ordem crescente com valores NULL/MISSING primeiro.

campo de classificação

• Obrigatório.

• O campo usado para classificação.

Exemplo 1: Classificar por um campo

O exemplo mostra como classificar o documento com o campo de idade em ordem crescente.

Consulta PPL:

os> source=accounts | sort age | fields account_number, age;
fetched rows / total rows = 4/4
+------------------+-------+
| account_number   | age   |
|------------------+-------|
| 13               | 28    |
| 1                | 32    |
| 18               | 33    |
| 6                | 36    |
+------------------+-------+      

Exemplo 2: Classifique por um campo e retorne 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 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 gênero 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 nula 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 stats comando para calcular a agregação a partir do resultado da pesquisa.

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Manipulação de valores NULOS/AUSENTES

Manipulação de valores NULOS/AUSENTES

Função	NULL	MISSING (AUSENTE)
CONTAGEM	Não contado	Não contado
SUM	Ignorar	Ignorar
AVG	Ignorar	Ignorar
MAX	Ignorar	Ignorar
MIN	Ignorar	Ignorar

Sintaxe

Use a seguinte sintaxe:

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

agregação

• Obrigatório.

• Uma função de agregação aplicada a um campo.

cláusula acessória

• Opcional.

• Sintaxe: by [span-expression,] [field,]...

• Especifica campos e expressões para agrupar os resultados da agregação. A cláusula secundária permite agrupar os resultados da agregação usando campos e expressões. Você pode usar funções escalares, funções de agregação e até mesmo expressões de amplitude para dividir campos específicos em compartimentos de intervalos iguais.

• Padrão: se não <by-clause> for especificado, o comando stats retornará uma única linha representando a agregação em todo o conjunto de resultados.

expressão de extensão

• Opcional, no máximo um.

• Sintaxe: span(field_expr, interval_expr)

• A unidade da expressão de intervalo é a unidade natural por padrão. Se o campo for do tipo data e hora e o intervalo estiver em unidades de data/hora, você especifica a unidade na expressão do intervalo.

• Por exemplo, parece que dividir o age campo em baldes por 10 anos. span(age, 10) Para dividir um campo de carimbo de data/hora em intervalos de hora em hora, use. span(timestamp, 1h)

Unidades de tempo disponíveis

Unidades de intervalo de amplitude
milissegundo (ms)
segundo (s)
minuto (m, diferencia maiúsculas de minúsculas)
hora (h)
dia (d)
semana (w)
mês (M, diferencia maiúsculas de minúsculas)
quarto (q)
ano (y)

Funções de agregação

COUNT

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

Exemplo: .

os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count()   |
|-----------|
| 4         |
+-----------+        

SUM

Use SUM(expr) para retornar a soma de expr.

Exemplo

os> source=accounts | stats sum(age) by gender;
fetched rows / total rows = 2/2
+------------+----------+
| sum(age)   | gender   |
|------------+----------|
| 28         | F        |
| 101        | M        |
+------------+----------+        

AVG

Use AVG(expr) para retornar o valor médio de expr.

Exemplo

os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age)           | gender   |
|--------------------+----------|
| 28.0               | F        |
| 33.666666666666664 | M        |
+--------------------+----------+        

MAX

Use MAX(expr) para retornar o valor máximo de expr.

Exemplo

os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age)   |
|------------|
| 36         |
+------------+        

MIN

Use MIN(expr) para retornar o valor mínimo de expr.

Exemplo

os> source=accounts | stats min(age);
fetched rows / total rows = 1/1
+------------+
| min(age)   |
|------------|
| 28         |
+------------+        

STDDEV_SAMP

Use STDDEV_SAMP(expr) para retornar o desvio padrão da amostra de expr.

Exemplo: .

os> source=accounts | stats stddev_samp(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_samp(age)   |
|--------------------|
| 3.304037933599835  |
+--------------------+        

STDDEV_POP

Use STDDEV_POP(expr) para retornar o desvio padrão da população de expr.

Exemplo: .

os> source=accounts | stats stddev_pop(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_pop(age)    |
|--------------------|
| 2.**************** |
+--------------------+        

PEGAR

Use TAKE(field [, size]) para retornar os valores originais de um campo. Não garante a ordem dos valores.

Campo

• Obrigatório.

• O campo deve ser um campo de texto.

size

• Opcional inteiro.

• O número de valores deve ser retornado.

• O padrão é 10.

Exemplo

os> source=accounts | stats take(firstname);
fetched rows / total rows = 1/1
+-----------------------------+
| take(firstname)             |
|-----------------------------|
| [Jane, Mary, Nikki, Juan    |
+-----------------------------+        

PERCENTILE ou PERCENTILE_APPROX

Use PERCENTILE(expr, percent) ou PERCENTILE_APPROX(expr, percent) para retornar o valor aproximado do percentil de expr na porcentagem especificada.

percentual

• O número deve ser uma constante entre 0 e 100.

Exemplo

os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90)   | gender   |
|-----------------------+----------|
| 28                    | F        |
| 36                    | M        |
+-----------------------+----------+        

Exemplo 1: Calcular a contagem de eventos

O exemplo mostra como calcular a contagem de eventos nas contas.

os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count()   |
|-----------|
| 4         |
+-----------+      

Exemplo 2: Calcular a média de um campo

O exemplo mostra como calcular a idade média de todas as contas.

os> source=accounts | stats avg(age);
fetched rows / total rows = 1/1
+------------+
| avg(age)   |
|------------|
| 32.25      |
+------------+      

Exemplo 3: Calcular a média de um campo por grupo

O exemplo mostra como calcular a idade média de todas as contas, agrupadas por sexo.

os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age)           | gender   |
|--------------------+----------|
| 28.0               | F        |
| 33.666666666666664 | M        |
+--------------------+----------+      

Exemplo 4: Calcular a média, a soma e a contagem de um campo por grupo

O exemplo mostra como calcular a idade média, a soma da idade e a contagem de eventos para 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 (ouDC) em vez deCOUNT. O exemplo calcula a contagem e o campo de contagem distinta de gênero de 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 intervalo

O exemplo obtém a contagem da idade no 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 sexo e extensão

Este exemplo conta registros agrupados por sexo e faixa etária 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: Calcule a contagem e obtenha a lista de e-mails por sexo e extensão

O exemplo obtém a contagem da idade no intervalo de 10 anos e o grupo por sexo. Além disso, para cada linha, obtenha uma lista de no máximo 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     | [[e-mail],[e-mail]] | 30         | M        |
| 1     | [[e-mail]]                        | 35         | M        |
+-------+----------------------------------------------------+------------+----------+      

Exemplo 11: Calcular o percentil de um campo

O exemplo mostra como calcular o 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 o percentil 90º de todas as contas agrupadas 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: Calcule o percentil por sexo e extensão

O exemplo obtém o percentil 90ª idade no intervalo de 10 anos e o grupo por sexo.

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 amplitude

- `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 intervalo de janela de tempo (função de janela giratória)

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

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

- `source = table | stats avg(age) as avg_state_age by country, state | stats avg(avg_state_age) as avg_country_age by country`
- `source = table | stats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | stats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | stats avg(avg_state_age) as avg_adult_country_age by country`     

comando subquery

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o subquery comando para realizar consultas complexas e aninhadas em suas 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 oferece suporte a vários níveis de aninhamento para análise complexa de dados.

Exemplo de subconsulta aninhada

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

InSubquery Uso

• source = outer | where a in [ source = inner | fields b ]

• source = outer | where (a) in [ source = inner | fields b ]

• source = outer | where (a,b,c) in [ source = inner | fields d,e,f ]

• source = outer | where a not in [ source = inner | fields b ]

• source = outer | where (a) not in [ source = inner | fields b ]

• source = outer | where (a,b,c) not in [ source = inner | fields d,e,f ]

• source = outer a in [ source = inner | fields b ](filtragem de pesquisa com subconsulta)

• source = outer a not in [ source = inner | fields b ](filtragem de pesquisa com subconsulta)

• source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ](aninhado)

• source = table1 | inner join left = l right = r on l.a = r.a AND r.a in [ source = inner | fields d ] | fields l.a, r.a, b, c(como filtro de junção)

Exemplos de migração de SQL com o In-subQuery PPL

TPC-H Q4 (em subconsulta com agregação)

select
  o_orderpriority,
  count(*) as order_count
from
  orders
where
  o_orderdate >= date '1993-07-01'
  and o_orderdate < date '1993-07-01' + interval '3' month
  and o_orderkey in (
    select
      l_orderkey
    from
      lineitem
    where l_commitdate < l_receiptdate
  )
group by
  o_orderpriority
order by
  o_orderpriority      

Reescrito pela consulta PPL: InSubquery

source = orders
| where o_orderdate >= "1993-07-01" and o_orderdate < "1993-10-01" and o_orderkey IN
  [ source = lineitem
    | where l_commitdate < l_receiptdate
    | fields l_orderkey
  ]
| stats count(1) as order_count by o_orderpriority
| sort o_orderpriority
| fields o_orderpriority, order_count      

TPC-H Q20 (aninhado na subconsulta)

select
  s_name,
  s_address
from
  supplier,
  nation
where
  s_suppkey in (
    select
      ps_suppkey
    from
      partsupp
    where
      ps_partkey in (
        select
          p_partkey
        from
          part
        where
          p_name like 'forest%'
      )
  )
  and s_nationkey = n_nationkey
  and n_name = 'CANADA'
order by
  s_name      

Reescrito pela consulta PPL: InSubquery

source = supplier
| where s_suppkey IN [
    source = partsupp
    | where ps_partkey IN [
        source = part
        | where like(p_name, "forest%")
        | fields p_partkey
      ]
    | fields ps_suppkey
  ]
| inner join left=l right=r on s_nationkey = n_nationkey and n_name = 'CANADA'
  nation
| sort s_name      

ExistsSubquery uso

Suposições:a, b são campos da tabela externa,c, d são campos da tabela interna,e, f são campos da tabela interna2.

• source = outer | where exists [ source = inner | where a = c ]

• source = outer | where not exists [ source = inner | where a = c ]

• source = outer | where exists [ source = inner | where a = c and b = d ]

• source = outer | where not exists [ source = inner | where a = c and b = d ]

• source = outer exists [ source = inner | where a = c ](filtragem de pesquisa com subconsulta)

• source = outer not exists [ source = inner | where a = c ](filtragem de pesquisa com subconsulta)

• source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ](o alias da tabela é útil na subconsulta exists)

• source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ](aninhado)

• source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ](aninhado)

• source = outer | where exists [ source = inner | where c > 10 ](não correlacionado existe)

• source = outer | where not exists [ source = inner | where c > 10 ](não correlacionado existe)

• source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l(existe um especial não correlacionado)

ScalarSubquery uso

Suposições:a, b são campos da tabela externa,c, d são campos da tabela interna,e, f são campos da tabela aninhados

Subconsulta escalar não correlacionada

Em Selecionar:

• source = outer | eval m = [ source = inner | stats max(c) ] | fields m, a

• source = outer | eval m = [ source = inner | stats max(c) ] + b | fields m, a

Em onde:

• source = outer | where a > [ source = inner | stats min(c) ] | fields a

No filtro de pesquisa:

• source = outer a > [ source = inner | stats min(c) ] | fields a

Subconsulta escalar correlacionada

Em Selecionar:

• source = outer | eval m = [ source = inner | where outer.b = inner.d | stats max(c) ] | fields m, a

• source = outer | eval m = [ source = inner | where b = d | stats max(c) ] | fields m, a

• source = outer | eval m = [ source = inner | where outer.b > inner.d | stats max(c) ] | fields m, a

Em onde:

• source = outer | where a = [ source = inner | where outer.b = inner.d | stats max(c) ]

• source = outer | where a = [ source = inner | where b = d | stats max(c) ]

• source = outer | where [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a

No filtro de pesquisa:

• source = outer a = [ source = inner | where b = d | stats max(c) ]

• source = outer [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a

Subconsulta escalar aninhada

• source = outer | where a = [ source = inner | stats max(c) | sort c ] OR b = [ source = inner | where c = 1 | stats min(d) | sort d ]

• source = outer | where a = [ source = inner | where c = [ source = nested | stats max(e) by f | sort f ] | stats max(d) by c | sort c | head 1 ]

Subconsulta (Relação)

InSubquery, ExistsSubquery e ScalarSubquery são todas expressões de subconsulta. Mas não RelationSubquery é uma expressão de subconsulta, é um plano de subconsulta que é comumente usado na cláusula Join ou From.

• source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ](subconsulta na junção do lado direito)

• source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1

Contexto adicional

InSubquery,ExistsSubquery, e ScalarSubquery são expressões de subconsulta comumente usadas em where cláusulas e filtros de pesquisa.

Onde comanda:

| 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=... ] é um<boolean expression>.

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

Subconsulta com diferentes tipos de junção

Exemplo usando um ScalarSubquery:

source=employees
| join source=sales on employees.employee_id = sales.employee_id
| where sales.sale_amount > [ source=targets | where target_met="true" | fields target_value ]      

Ao contrário de InSubquery ExistsSubquery,, e ScalarSubquery, a não RelationSubquery é uma expressão de subconsulta. Em vez disso, é 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 superior

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o top comando 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]

N

•     o número máximo de resultados a serem retornados.

• Padrão: 10

lista de campos

• Obrigatório.

• Uma lista delimitada por vírgula de nomes de campo.

cláusula acessória

• Opcional.

• Um ou mais campos para agrupar os resultados.

top_approx

• Uma contagem aproximada dos (n) principais campos usando a cardinalidade estimada pelo HyperLogLog algoritmo ++.

Exemplo 1: Encontre os valores mais comuns em um campo

O exemplo mostra o sexo mais comum em 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: Encontre os valores mais comuns em um campo (limitado a 1)

O exemplo encontra o sexo mais comum em todas as contas.

Consulta PPL:

os> source=accounts | top_approx 1 gender;
fetched rows / total rows = 1/1
+----------+
| gender   |
|----------|
| M        |
+----------+    

Exemplo 3: Encontre os valores mais comuns, agrupados por gênero

O exemplo encontra a idade mais comum para todas as contas, agrupadas por sexo.

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 de linha de tendência

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o trendline comando para calcular as médias móveis dos campos.

Sintaxe

Use a seguinte sintaxe

TRENDLINE [sort <[+|-] sort-field>] SMA(number-of-datapoints, field) [AS alias] [SMA(number-of-datapoints, field) [AS alias]]... 

[+|-]

• Opcional.

• O sinal de adição [+] significa ordem crescente com valores NULL/MISSING primeiro.

• O sinal de menos [-] representa a ordem decrescente com os valores NULL/MISSING por último.

• Padrão: ordem crescente com valores NULL/MISSING primeiro.

campo de classificação

• Obrigatório quando a classificação é usada.

• O campo usado para classificação.

number-of-datapoints

• Obrigatório.

• O número de pontos de dados que calculam a média móvel.

• Deve ser maior que zero.

Campo

• Obrigatório.

• O nome do campo para o qual a média móvel deve ser calculada.

alias

• Opcional.

• O nome da coluna resultante contendo a média móvel.

Somente o tipo Simple Moving Average (SMA) é suportado. É 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 sobre as 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: Calcule médias móveis simples para uma série temporal de temperaturas com classificação

O exemplo calcula duas médias móveis simples sobre as 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|
+-----------+---------+--------------------+------------+------------------+      

onde comando

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

O where comando 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>    

expressão bool

• Opcional.

• Qualquer expressão que possa ser avaliada como um valor booleano.

Exemplo 1: conjunto de resultados do filtro com condição

O exemplo mostra como buscar documentos do índice de contas que atendam a condições específicas.

Consulta PPL:

os> source=accounts | where account_number=1 or gender="F" | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number   | gender   |
|------------------+----------|
| 1                | M        |
| 13               | F        |
+------------------+----------+      

Exemplos adicionais

Filtros com condições lógicas

• source = table | where c = 'test' AND a = 1 | fields a,b,c

• source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1

• source = table | where c = 'test' NOT a > 1 | fields a,b,c

• source = table | where a = 1 | fields a,b,c

• source = table | where a >= 1 | fields a,b,c

• source = table | where a < 1 | fields a,b,c

• source = table | where b != 'test' | fields a,b,c

• source = table | where c = 'test' | fields a,b,c | head 3

• source = table | where ispresent(b)

• source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3

• source = table | where isempty(a)

• source = table | where isblank(a)

• source = table | where case(length(a) > 6, 'True' else 'False') = 'True'

• source = table | where a between 1 and 4- Nota: Isso retorna um >= 1 e um <= 4, ou seja, [1, 4]

• source = table | where b not between '2024-09-10' and '2025-09-10'- Nota: Isso retorna b >= '**********' e b <= '2025-09-10'

• source = table | where cidrmatch(ip, '***********/24')

• source = table | where cidrmatch(ipv6, '2003:db8::/32')

source = table | eval status_category =
    case(a >= 200 AND a < 300, 'Success',
    a >= 300 AND a < 400, 'Redirection',
    a >= 400 AND a < 500, 'Client Error',
    a >= 500, 'Server Error'
    else 'Incorrect HTTP status code')
    | where case(a >= 200 AND a < 300, 'Success',
    a >= 300 AND a < 400, 'Redirection',
    a >= 400 AND a < 500, 'Client Error',
    a >= 500, 'Server Error'
    else 'Incorrect HTTP status code'
    ) = 'Incorrect HTTP status code'        

source = table
    | eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
    | where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
    |  stats count() by factor        

resumo do campo

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a esse comando PPL, consulte. Comandos

Use o fieldsummary comando para calcular estatísticas básicas para cada campo (contagem, contagem distinta, min, max, avg, stddev, média) e determinar o tipo de dados de cada campo. Esse comando pode ser usado com qualquer canal anterior e os levará em consideração.

Sintaxe

Use a sintaxe a seguir. Para casos de uso de CloudWatch registros, somente um campo em uma consulta é compatível.

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

incluir campos

• Lista de todas as colunas a serem coletadas com estatísticas em um conjunto unificado de resultados.

Nulos

• Opcional.

• Se definido como verdadeiro, inclua valores nulos nos cálculos de agregação (substitua nulo por zero para valores numéricos).

Exemplo 1

Consulta PPL:

os> source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields           | COUNT       | COUNT_DISTINCT    |  MIN  |  MAX   |  AVG   |  MEAN   |        STDDEV       | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code"    |      2      |         2         | 301   |   403  |  352.0 |  352.0  |  72.12489168102785  |  0    | "int"  |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|

Exemplo 2

Consulta PPL:

os> source = t | fieldsummary includefields= id, status_code, request_path nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields           | COUNT       | COUNT_DISTINCT    |  MIN  |  MAX   |  AVG   |  MEAN   |        STDDEV       | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
|       "id"       |      6      |         6         | 1     |   6    |  3.5   |   3.5  |  1.8708286933869707  |  0    | "int"  |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code"    |      4      |         3         | 200   |   403  |  184.0 |  184.0  |  161.16699413961905 |  2    | "int"  |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "request_path"   |      2      |         2         | /about| /home  |  0.0    |  0.0     |      0            |  2    |"string"|
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|

comando de expansão

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

Use o expand comando para nivelar um campo do tipo Matriz <Any>ou Mapa<Any>, produzindo linhas individuais para cada elemento ou par de valores-chave.

Sintaxe

Use a seguinte sintaxe:

expand <field> [As alias]

Campo

• O campo a ser expandido (explodido).

• O campo deve ser de um tipo compatível.

alias

• Opcional.

• O nome a ser usado em vez do nome do campo original.

Diretrizes de uso

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

• Os elementos da matriz se tornam linhas individuais.

• Os pares de valores-chave do mapa são divididos em linhas separadas, com cada valor-chave representado como uma linha.

• Quando um alias é fornecido, os valores explodidos são representados sob o alias em vez do nome do campo original.

Você pode usar esse comando em combinação com outros comandos, como stats, eval e parse, para manipular ou extrair dados após a expansão.

Exemplos

• source = table | expand employee | stats max(salary) as max by state, company

• source = table | expand employee as worker | stats max(salary) as max by state, company

• source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus

• source = table | expand employee | parse description '(?<email>.+@.+)' | fields employee, email

• source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid

• source = table | expand multi_valueA as multiA | expand multi_valueB as multiB

Você pode usar o comando expand em combinação com outros comandos, como eval, stats e muito mais. O uso de vários comandos de expansão criará um produto cartesiano de todos os elementos internos em cada matriz ou mapa composto.

Consulta push down de SQL 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 as seguintes funcionalidades:

• É uma operação de coluna que retorna uma nova coluna.

• Ele cria uma nova linha para cada elemento na coluna explodida.

• Nulos internos são ignorados como parte do campo explodido (nenhuma linha é criada/explodida para nulo).

Funções PPL

Tópicos

• Funções de condição PPL

• Funções hash criptográficas PPL

• Funções de data e hora do PPL

• Expressões PPL

• Funções de endereço IP PPL

• Funções PPL JSON

• Funções PPL Lambda

• Funções matemáticas PPL

• funções de string PPL

• Funções de conversão do tipo PPL

Funções de condição PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

ISNULL

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

Tipo de argumento:

• Todos os tipos de dados compatíveis.

Tipo de devolução:

• BOOLEAN

Exemplo:

os> source=accounts | eval result = isnull(employer) | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------+-------------+-------------+
| result   | employer    | firstname   |
|----------+-------------+-------------|
| False    | AnyCompany  | Mary        |
| False    | ExampleCorp | Jane        |
| False    | ExampleOrg  | Nikki       |
| True     | null        | Juan        |
+----------+-------------+-------------+      

NÃO É NULO

Descrição: isnotnull(field) retorna verdadeiro se o campo não for nulo.

Tipo de argumento:

• Todos os tipos de dados compatíveis.

Tipo de devolução:

• BOOLEAN

Exemplo:

os> source=accounts | where not isnotnull(employer) | fields account_number, employer
fetched rows / total rows = 1/1
+------------------+------------+
| account_number   | employer   |
|------------------+------------|
| 18               | null       |
+------------------+------------+      

EXISTS

Exemplo:

os> source=accounts | where exists(email) | fields account_number, email
fetched rows / total rows = 1/1

INCOMPLETO

Descrição: ifnull(field1, field2) retorna field2 se field1 for nulo.

Tipo de argumento:

• Todos os tipos de dados compatíveis.

• Se os dois parâmetros tiverem tipos diferentes, a função falhará na verificação semântica.

Tipo de devolução:

• Any

Exemplo:

os> source=accounts | eval result = ifnull(employer, 'default') | fields result, employer, firstname
fetched rows / total rows = 4/4
+------------+------------+-------------+
| result     | employer   | firstname   |
|------------+------------+-------------|
| AnyCompany | AnyCompany | Mary        |
| ExampleCorp| ExampleCorp| Jane        |
| ExampleOrg | ExampleOrg | Nikki       |
| default    | null       | Juan        |
+------------+------------+-------------+      

NULLIF

Descrição: nullif(field1, field2) retorne null se dois parâmetros forem iguais, caso contrário, retorne field1.

Tipo de argumento:

• Todos os tipos de dados compatíveis.

• Se os dois parâmetros tiverem tipos diferentes, a função falhará na verificação semântica.

Tipo de devolução:

• Any

Exemplo:

os> source=accounts | eval result = nullif(employer, 'AnyCompany') | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------------+----------------+-------------+
| result         | employer       | firstname   |
|----------------+----------------+-------------|
| null           | AnyCompany     | Mary        |
| ExampleCorp    | ExampleCorp    | Jane        |
| ExampleOrg     | ExampleOrg     | Nikki       |
| null           | null           | Juan        |
+----------------+----------------+-------------+      

IF

Descrição: if(condition, expr1, expr2) retorna expr1 se a condição for verdadeira, caso contrário, ela retornaráexpr2.

Tipo de argumento:

• Todos os tipos de dados compatíveis.

• Se os dois parâmetros tiverem tipos diferentes, a função falhará na verificação semântica.

Tipo de devolução:

• Any

Exemplo:

os> source=accounts | eval result = if(true, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+----------+
| result   | firstname | lastname   |
|----------+-------------+----------|
| Jane     | Jane      | Doe        |
| Mary     | Mary      | Major      |
| Pat      | Pat       | Candella   |
| Dale     | Jorge     | Souza      |
+----------+-----------+------------+

os> source=accounts | eval result = if(false, firstname, lastname) | fields result, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| result   | firstname   | lastname   |
|----------+-------------+------------|
| Doe      | Jane        | Doe        |
| Major    | Mary        | Major      |
| Candella | Pat         | Candella   |
| Souza    | Jorge       | Souza      |
+----------+-------------+------------+

os> source=accounts | eval is_vip = if(age > 30 AND isnotnull(employer), true, false) | fields is_vip, firstname, lastname
fetched rows / total rows = 4/4
+----------+-------------+------------+
| is_vip   | firstname   | lastname   |
|----------+-------------+------------|
| True     | Jane        | Doe        |
| True     | Mary        | Major      |
| False    | Pat         | Candella   |
| False    | Jorge       | Souza      |
+----------+-------------+------------+

Funções hash criptográficas PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

MD5

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

Uso: md5('hello')

Tipo de argumento:

• STRING

Tipo de devolução:

• STRING

Exemplo:

os> source=people | eval `MD5('hello')` = MD5('hello') | fields `MD5('hello')`
fetched rows / total rows = 1/1
+----------------------------------+
| MD5('hello')                     |
|----------------------------------|
| <32 character hex string>        |
+----------------------------------+      

SHA1

SHA1 retorna o resultado da string hexadecimal de SHA-1.

Uso: sha1('hello')

Tipo de argumento:

• STRING

Tipo de devolução:

• STRING

Exemplo:

os> source=people | eval `SHA1('hello')` = SHA1('hello') | fields `SHA1('hello')`
fetched rows / total rows = 1/1
+------------------------------------------+
| SHA1('hello')                            |
|------------------------------------------|
| <40-character SHA-1 hash result>         |
+------------------------------------------+      

SHA2

SHA2 retorna o resultado da string hexadecimal da família SHA-2 de funções de hash (SHA-224, SHA-256, SHA-384 e SHA-512). O NumBits indica o tamanho de bits desejado do resultado, que deve ter um valor de 224, 256, 384, 512

Uso:

• sha2('hello',256)

• sha2('hello',512)

Tipo de argumento:

• STRING, NÚMERO INTEIRO

Tipo de devolução:

• STRING

Exemplo:

os> source=people | eval `SHA2('hello',256)` = SHA2('hello',256) | fields `SHA2('hello',256)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',256)                                                |
|------------------------------------------------------------------|
| <64-character SHA-256 hash result>                               |
+------------------------------------------------------------------+

os> source=people | eval `SHA2('hello',512)` = SHA2('hello',512) | fields `SHA2('hello',512)`
fetched rows / total rows = 1/1
+------------------------------------------------------------------+
| SHA2('hello',512)                                                |                                                                |
|------------------------------------------------------------------|
| <128-character SHA-512 hash result>                              |
+------------------------------------------------------------------+      

Funções de data e hora do PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

DAY

Uso: DAY(date) extrai o dia do mês para 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 para 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 para 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 para 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 para 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 para uma data, incluindo segunda, terça, quarta, quinta, sexta, 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 carimbo de data/hora ou cadeia de caracteres. Essa função executa uma conversão reversa da UNIX_TIMESTAMP função.

Se você fornecer um segundo argumento, FROM_UNIXTIME use-o para formatar o resultado de forma semelhante à DATE_FORMAT função.

Se o timestamp estiver fora do intervalo 1970-01-01 00:00:00 a 3001-01-18 23:59:59.999 999 (0 a 32536771199.999999 horário de época), a função retornará. NULL

Tipo de argumento: DOUBLE, STRING

Mapa do tipo de retorno:

DUPLO -> CARIMBO DE DATA/HORA

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 por hora.

Diferentemente de uma hora padrão do dia, o valor da hora nessa função pode ter um intervalo maior que 23. Como resultado, o valor de retorno de HOUR(TIME) pode ser maior 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 da hora do horário determinado.

Diferentemente de uma hora padrão do dia, o valor da hora nessa função pode ter um intervalo maior que 23. Como resultado, o valor de retorno de HOUR_OF_DAY(TIME) pode ser maior 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 de DATA para o argumento de data fornecido.

Tipo de argumento: DATE/STRING/TIMESTAMP/TIME

Tipo de devolução: DATA

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

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

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 (INTEIRO, INTEIRO, INTEIRO) -> DATA

Tipo de argumento: INTEGER, INTEGER, INTEGER

Tipo de devolução: DATA

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 do tempo determinado, 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 do tempo determinado, 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 especificada 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 especificada 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 especificada como um número inteiro, no intervalo de 1 a 12 (onde 1 representa janeiro e 12 representa dezembro).

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de retorno: INTEGER

Sinônimos: MONTH

Exemplo:

os> source=people | eval `MONTH_OF_YEAR(DATE('2020-08-26'))` =  MONTH_OF_YEAR(DATE('2020-08-26')) | fields `MONTH_OF_YEAR(DATE('2020-08-26'))`
fetched rows / total rows = 1/1
+-------------------------------------+
| MONTH_OF_YEAR(DATE('2020-08-26'))   |
|-------------------------------------|
| 8                                   |
+-------------------------------------+      

NOW

Uso: NOW retorna a data e a hora atuais como um TIMESTAMP valor no formato 'AAAA-MM-DD hh:mm:ss'. O valor é expresso no fuso horário do cluster.

nota

NOW()retorna uma hora constante que indica quando a instrução começou a ser executada. Isso difere deSYSDATE(), que retorna a hora exata da execução.

Tipo de devolução: 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 especificada 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 segundo componente do tempo determinado como um 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 segundo componente do tempo determinado como um 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 ouDAYS) da data fornecida.

Tipo de argumento: DATE/TIMESTAMP, LONG

Mapa do tipo de retorno: (DATE, LONG) -> DATE

Antônimos: ADDDATE

Exemplo:

os> source=people | eval `'2008-01-02' - 31d` = SUBDATE(DATE('2008-01-02'), 31), `'2020-08-26' - 1` = SUBDATE(DATE('2020-08-26'), 1), `ts '2020-08-26 01:01:01' - 1` = SUBDATE(TIMESTAMP('2020-08-26 01:01:01'), 1) | fields `'2008-01-02' - 31d`, `'2020-08-26' - 1`, `ts '2020-08-26 01:01:01' - 1`
fetched rows / total rows = 1/1
+----------------------+--------------------+--------------------------------+
| '2008-01-02' - 31d   | '2020-08-26' - 1   | ts '2020-08-26 01:01:01' - 1   |
|----------------------+--------------------+--------------------------------|
| 2007-12-02 00:00:00  | 2020-08-25         | 2020-08-25 01:01:01            |
+----------------------+--------------------+--------------------------------+      

SYSDATE

Uso: SYSDATE() retorna a data e a hora atuais como um TIMESTAMP valor no formato 'YYYY-MM-DD hh:mm:ss.nnnnnnn'.

SYSDATE()retorna a hora exata em que ele é executado. 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 segundos no valor de retorno.

Tipo de devolução: 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, ela será interpretada como um timestamp. Para argumentos que não sejam de string, a função converte em expr um timestamp usando o fuso horário UTC. Quando expr é um TIME valor, 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

Mapa do tipo de retorno:

(STRING/DATE/TIME/TIMESTAMP) -> CARIMBO DE DATA/HORA

(STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP) -> CARIMBO DE DATA/HORA

Exemplo:

os> source=people | eval `TIMESTAMP('2020-08-26 13:49:00')` = TIMESTAMP('2020-08-26 13:49:00'), `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))` = TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42')) | fields `TIMESTAMP('2020-08-26 13:49:00')`, `TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))`
fetched rows / total rows = 1/1
+------------------------------------+------------------------------------------------------+
| TIMESTAMP('2020-08-26 13:49:00')   | TIMESTAMP('2020-08-26 13:49:00', TIME('12:15:42'))   |
|------------------------------------+------------------------------------------------------|
| 2020-08-26 13:49:00                | 2020-08-27 02:04:42                                  |
+------------------------------------+------------------------------------------------------+      

UNIX_TIMESTAMP

Uso: UNIX_TIMESTAMP converte um determinado argumento de data em hora Unix (segundos desde a Época, que começou no início de 1970). Se nenhum argumento for fornecido, ele retornará a hora atual do Unix.

O argumento de data pode ser umDATE, uma TIMESTAMP string ou um número em um desses formatos:YYMMDD,YYMMDDhhmmss,YYYYMMDD, ouYYYYMMDDhhmmss. Se o argumento incluir um componente de tempo, ele poderá, opcionalmente, incluir segundos fracionários.

Se o argumento estiver em um formato inválido ou estiver fora do intervalo de 1970-01-01 00:00:00 a 3001-01-18 23:59:59.999 999 (0 a 32536771199.999999 no horário da época), a função retornará. NULL

A função aceita DATETIMESTAMP, ou DOUBLE como tipos de argumento, ou nenhum argumento. Ele sempre retorna um DOUBLE valor representando o carimbo de data/hora do Unix.

Para a conversão inversa, você pode usar a função FROM_UNIXTIME.

Tipo de argumento:<NONE>/DOUBLE/DATE/TIMESTAMP

Tipo de devolução: 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 determinada data.

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 para a data (0 = segunda-feira, 1 = terça-feira,..., 6 = domingo).

É semelhante à dayofweek função, 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 para a data especificada.

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 para a 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 especificada.

Tipo de argumento: DATA, INTERVALO

Tipo de devolução: DATA

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: DATA, INTERVALO

Tipo de devolução: DATA

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 TIMESTAMP valor após adicionar um intervalo de tempo especificado a uma determinada data.

Argumentos:

• intervalo: INTERVALO (SEGUNDO, MINUTO, HORA, DIA, SEMANA, MÊS, TRIMESTRE, ANO)

• inteiro: INTEGER

• data: DATA, TIMESTAMP ou STRING

Se você fornecer um STRING como argumento de data, formate-o como válidoTIMESTAMP. A função converte automaticamente um DATE argumento em a. 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 término em unidades de intervalo especificadas.

Argumentos:

• intervalo: INTERVALO (SEGUNDO, MINUTO, HORA, DIA, SEMANA, MÊS, TRIMESTRE, ANO)

• início: DATE, TIMESTAMP ou STRING

• fim: DATA, TIMESTAMP ou STRING

A função converte automaticamente os argumentos em TIMESTAMP quando apropriado. Formate STRING os argumentos como TIMESTAMP s válidos.

Exemplos:

os> source=people | eval `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')` = TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | eval `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))` = TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) | fields `TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00')`, `TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00'))`
fetched rows / total rows = 1/1
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+
| TIMESTAMPDIFF(YEAR, '1997-01-01 00:00:00', '2001-03-06 00:00:00') | TIMESTAMPDIFF(SECOND, timestamp('1997-01-01 00:00:23'), timestamp('1997-01-01 00:00:00')) |
|-------------------------------------------------------------------+-------------------------------------------------------------------------------------------|
| 4                                                                 | -23                                                                                       |
+-------------------------------------------------------------------+-------------------------------------------------------------------------------------------+     

UTC_TIMESTAMP

Uso: UTC_TIMESTAMP retorna o timestamp UTC atual como um valor em 'AAAA-MM-DD hh:mm:ss'.

Tipo de devolução: TIMESTAMP

Especificação: UTC_TIMESTAMP () -> TIMESTAMP

Exemplo:

> source=people | eval `UTC_TIMESTAMP()` = UTC_TIMESTAMP() | fields `UTC_TIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| UTC_TIMESTAMP()     |
|---------------------|
| 2022-10-03 17:54:28 |
+---------------------+      

CURRENT_TIMEZONE

Uso: CURRENT_TIMEZONE retorna o fuso horário local atual.

Tipo de retorno: STRING

Exemplo:

> source=people | eval `CURRENT_TIMEZONE()` = CURRENT_TIMEZONE() | fields `CURRENT_TIMEZONE()`
fetched rows / total rows = 1/1
+------------------------+
| CURRENT_TIMEZONE()     |
|------------------------|
| America/Chicago        |
+------------------------+      

Expressões PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

Expressões, especialmente expressões de valor, retornam um valor escalar. As expressões têm diferentes tipos e formas. Por exemplo, existem valores literais como expressões atômicas e expressões aritméticas, de predicados e de funções construídas sobre eles. Você pode usar expressões em cláusulas diferentes, como usar expressões aritméticas em comandos e. Filter Stats

Operadores

Uma expressão aritmética é uma expressão formada por literais numéricos e operadores aritméticos binários da seguinte forma:

1. +: Adicionar.

2. -: Subtrair.

3. *: Multiplique.

4. /: Divida (para números inteiros, o resultado é um número inteiro com a parte fracionária descartada)

5. %: Módulo (use somente com números inteiros; o resultado é o restante da divisão)

Precedência

Use parênteses para controlar a precedência dos operadores aritméticos. Caso contrário, os operadores de 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ção.

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 predicados

Um operador de predicado é uma expressão avaliada como verdadeira. A comparação de NULL valores MISSING e segue estas regras:

• Um MISSING valor só é igual a um MISSING valor e é menor do que outros valores.

• Um NULL valor é igual a um NULL valor, é maior que um MISSING valor, mas é menor que todos os outros valores.

Operadores

Operadores de predicados

Nome	Descrição
>	Maior que o operador
>=	Operador maior ou igual
<	Menos do que o operador
!=	Operador não igual
<=	Operador menor ou igual
=	Operador igual
LIKE	Combinação simples de padrões
IN	Teste de valor NULL
AND	Operador AND
OR	Operador OU
XOR	Operador XOR
NOT	Teste de valor NOT NULL

Você pode comparar datas e horas. Ao comparar diferentes tipos de data e hora (por exemplo DATE eTIME), ambos são convertidos DATETIME em. As seguintes regras se aplicam à conversão:

• TIMEaplica-se à data de hoje.

• DATEé interpretado à meia-noite.

Operador de predicado básico

Exemplo de operadores de comparação:

os> source=accounts | where age > 33 | fields age ;
fetched rows / total rows = 1/1
+-------+
| age   |
|-------|
| 36    |
+-------+

IN

Exemplo do campo de teste do IN operador 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 OR operador:

os> source=accounts | where age = 32 OR age = 33 | fields age ;
fetched rows / total rows = 2/2
+-------+
| age   |
|-------|
| 32    |
| 33    |
+-------+        

NOT

Exemplo do NOT operador:

os> source=accounts | where age not in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age   |
|-------|
| 36    |
| 28    |
+-------+     

Funções de endereço IP PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

CIDRMATCH

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

Tipo de argumento:

• CORDA, CORDA

• Tipo de retorno: BOOLEAN

Exemplo:

os> source=ips | where cidrmatch(ip, '***********/24') | fields ip
fetched rows / total rows = 1/1
+--------------+
| ip           |
|--------------|
| ***********  |
+--------------+

os> source=ipsv6 | where cidrmatch(ip, '2003:db8::/32') | fields ip
fetched rows / total rows = 1/1
+-----------------------------------------+
| ip                                      |
|-----------------------------------------|
| 2003:0db8:****:****:****:****:****:0000 |
+-----------------------------------------+    

nota

• ippode ser um IPv4 ou um IPv6 endereço.

• cidrpode ser um IPv4 ou um IPv6 bloco.

• ipe cidr deve ser ambos IPv4 ou ambos IPv6.

• ipe cidr devem ser válidos e não vazios/não nulos.

Funções PPL JSON

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

JSON

Uso: json(value) avalia se uma string pode ser analisada no formato JSON. A função retornará a string original se for um JSON válido ou null se for inválido.

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 de valores-chave.

Tipo de argumento:

• A <key>deve ser STRING.

• A <value>pode ser qualquer tipo de dados.

Tipo de retorno: JSON_OBJECT. Uma StructType expressão de um objeto JSON válido.

Exemplos:

os> source=people | eval result = json_object('key', 123.45) | fields result
fetched rows / total rows = 1/1
+------------------+
| result           |
+------------------+
| {"key":123.45}   |
+------------------+

os> source=people | eval result = json_object('outer', json_object('inner', 123.45)) | fields result
fetched rows / total rows = 1/1
+------------------------------+
| result                       |
+------------------------------+
| {"outer":{"inner":123.45}}   |
+------------------------------+       

JSON_ARRAY

Uso: json_array(<value>...) cria um JSON ARRAY usando uma lista de valores.

Tipo de argumento: A <value> pode ser qualquer tipo de valor, como string, número ou booleano.

Tipo de retorno: ARRAY. Uma matriz de qualquer tipo de dados 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 determinado valor de objeto json.

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

Uso: 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á null se a string JSON de entrada for inválida.

Tipo de argumento: STRING, STRING

Tipo de retorno: STRING

• Uma expressão STRING de um formato de objeto JSON válido.

• NULLé retornado no caso de um JSON inválido.

Exemplos:

os> source=people | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a')
fetched rows / total rows = 1/1
+----------------------------------+
| json_extract('{"a":"b"}', 'a')   |
+----------------------------------+
| b                                |
+----------------------------------+

os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[1].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[1].b')   |
+-----------------------------------------------------------+
| 2.0                                                       |
+-----------------------------------------------------------+

os> source=people | eval `json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')` = json_extract('{"a":[{"b":1},{"b":2}]}', '$.a[*].b')
fetched rows / total rows = 1/1
+-----------------------------------------------------------+
| json_extract('{"a":[{"b":1.0},{"b":2.0}]}', '$.a[*].b')   |
+-----------------------------------------------------------+
| [1.0,2.0]                                                 |
+-----------------------------------------------------------+

os> source=people | eval `invalid_json` = json_extract('{"invalid": "json"')
fetched rows / total rows = 1/1
+----------------+
| invalid_json   |
+----------------+
| null           |
+----------------+      

JSON_KEYS

Uso: json_keys(jsonStr) retorna todas as chaves do objeto JSON mais externo como uma matriz.

Tipo de argumento: STRING. Uma expressão STRING de um formato de objeto JSON válido.

Tipo de retorno: ARRAY [STRING]. A função retorna NULL para qualquer outra string JSON válida, uma string vazia ou um JSON inválido.

Exemplos:

os> source=people | eval `keys` = json_keys('{"f1":"abc","f2":{"f3":"a","f4":"b"}}')
fetched rows / total rows = 1/1
+------------+
| keus       |
+------------+
| [f1, f2]   |
+------------+

os> source=people | eval `keys` = json_keys('[1,2,3,{"f1":1,"f2":[5,6]},4]')
fetched rows / total rows = 1/1
+--------+
| keys   |
+--------+
| null   |
+--------+      

JSON_VALID

Uso: json_valid(jsonStr) avalia se uma string JSON usa uma sintaxe JSON válida e retorna VERDADEIRO ou FALSO.

Tipo de argumento: STRING

Tipo de retorno: BOOLEAN

Exemplos:

os> source=people | eval `valid_json` = json_valid('[1,2,3,4]'), `invalid_json` = json_valid('{"invalid": "json"') | feilds `valid_json`, `invalid_json`
fetched rows / total rows = 1/1
+--------------+----------------+
| valid_json   | invalid_json   |
+--------------+----------------+
| True         | False          |
+--------------+----------------+

os> source=accounts | where json_valid('[1,2,3,4]') and isnull(email) | fields account_number, email
fetched rows / total rows = 1/1
+------------------+---------+
| account_number   | email   |
|------------------+---------|
| 13               | null    |
+------------------+---------+      

Funções PPL Lambda

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

EXISTS

Uso: exists(array, lambda) avalia se um predicado Lambda é válido para um ou mais elementos na matriz.

Tipo de argumento: ARRAY, LAMBDA

Tipo de retorno: BOOLEAN. TRUECaso contrário, retorna se pelo menos um elemento na matriz satisfaz o predicado Lambda. 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 Lambda fornecida.

Tipo de argumento: ARRAY, LAMBDA

Tipo de retorno: ARRAY. Uma MATRIZ 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 de transformação Lambda. O segundo argumento implica o índice do elemento se estiver usando a função Lambda binária. Isso é semelhante ao map da programação funcional.

Tipo de argumento: ARRAY, LAMBDA

Tipo de retorno: ARRAY. Uma MATRIZ que contém o resultado da aplicação da função de transformação lambda 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 lambda. A função aplica o merge_lambda ao valor inicial e a todos os elementos da matriz e, em seguida, aplica o ao finish_lambda resultado.

Tipo de argumento: ARRAY, ANY, LAMBDA, LAMBDA

Tipo de devolução: QUALQUER. 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 matemáticas PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

ABS

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

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: INTEGER/LONG/FLOAT/DOUBLE

Exemplo:

os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)`
fetched rows / total rows = 1/1
+-----------+
| ABS(-1)   |
|-----------|
| 1         |
+-----------+    

ACOS

Uso: ACOS(x) calcula o arco cosseno de x. Ele retorna NULL se x não estiver no intervalo de -1 a 1.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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. Ele retorna NULL se x não estiver no intervalo de -1 a 1.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 de ambos os argumentos determinam o quadrante do resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 de ambos os argumentos determinam o quadrante do resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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

Uso: CBRT calcula a raiz cúbica de um número.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE:

INTEGER/LONG/FLOAT/DOUBLE-> DUPLO

Exemplo:

opensearchsql> source=location | eval `CBRT(8)` = CBRT(8), `CBRT(9.261)` = CBRT(9.261), `CBRT(-27)` = CBRT(-27) | fields `CBRT(8)`, `CBRT(9.261)`, `CBRT(-27)`;
fetched rows / total rows = 2/2
+-----------+---------------+-------------+
| CBRT(8)   | CBRT(9.261)   | CBRT(-27)   |
|-----------+---------------+-------------|
| 2.0       | 2.1           | -3.0        |
| 2.0       | 2.1           | -3.0        |
+-----------+---------------+-------------+  

CEIL

Uso: Um alias para a CEILING função. 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 devolução: LONGO

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 é dado em radianos.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)`
fetched rows / total rows = 1/1
+----------+
| COS(0)   |
|----------|
| 1.0      |
+----------+

COT

Uso: COT(x) calcula a cotangente de x. Ele retornará out-of-range um erro se x for igual a 0.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 devolução: LONGO

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 devolução: 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 devolução: 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 devolução: 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) ocupa 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 devolução: LONGO

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 devolução: 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 logaritmo base e do x. log (B, x) é equivalente a log (x) /log (B).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 alog(x)/log(2).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 alog(x)/log(10).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 restante 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 devolução: 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 NULL resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 NULL resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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 devolução: 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 a cada vez, produzindo uma sequência repetível de valores de coluna.

Tipo de argumento: INTEGER

Tipo de devolução: 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

Mapa do tipo de retorno:

• (INTEIRO/LONGO [, INTEIRO]) -> LONGO

• (FLOAT/DOUBLE [, INTEIRO]) -> LONGO

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 se o número é 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 é dado em radianos.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: 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

Mapa do tipo de retorno:

• (Não negativo) INTEGER/LONG/FLOAT/DOUBLE -> DUPLO

• (Negativo) INTEGER/LONG/FLOAT/DOUBLE -> NULL

Exemplo:

os> source=people | eval `SQRT(4)` = SQRT(4), `SQRT(4.41)` = SQRT(4.41) | fields `SQRT(4)`, `SQRT(4.41)`
fetched rows / total rows = 1/1
+-----------+--------------+
| SQRT(4)   | SQRT(4.41)   |
|-----------+--------------|
| 2.0       | 2.1          |
+-----------+--------------+

funções de string PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

CONCAT

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

Tipo de argumento:

• STRING, STRING,..., STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `CONCAT('hello', 'world')` = CONCAT('hello', 'world'), `CONCAT('hello ', 'whole ', 'world', '!')` = CONCAT('hello ', 'whole ', 'world', '!') | fields `CONCAT('hello', 'world')`, `CONCAT('hello ', 'whole ', 'world', '!')`
fetched rows / total rows = 1/1
+----------------------------+--------------------------------------------+
| CONCAT('hello', 'world')   | CONCAT('hello ', 'whole ', 'world', '!')   |
|----------------------------+--------------------------------------------|
| helloworld                 | hello whole world!                         |
+----------------------------+--------------------------------------------+      

CONCAT_WS

Uso: CONCAT_WS(sep, str1, str2) concatena duas ou mais strings usando um separador especificado entre elas.

Tipo de argumento:

• STRING, STRING,..., STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `CONCAT_WS(',', 'hello', 'world')` = CONCAT_WS(',', 'hello', 'world') | fields `CONCAT_WS(',', 'hello', 'world')`
fetched rows / total rows = 1/1
+------------------------------------+
| CONCAT_WS(',', 'hello', 'world')   |
|------------------------------------|
| hello,world                        |
+------------------------------------+      

LENGTH

Uso: length(str) retorna o comprimento da string de entrada medido em bytes.

Tipo de argumento:

• STRING

• Tipo de retorno: INTEGER

Exemplo:

os> source=people | eval `LENGTH('helloworld')` = LENGTH('helloworld') | fields `LENGTH('helloworld')`
fetched rows / total rows = 1/1
+------------------------+
| LENGTH('helloworld')   |
|------------------------|
| 10                     |
+------------------------+      

LOWER

Uso: lower(string) converte a string de entrada em minúsculas.

Tipo de argumento:

• STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `LOWER('helloworld')` = LOWER('helloworld'), `LOWER('HELLOWORLD')` = LOWER('HELLOWORLD') | fields `LOWER('helloworld')`, `LOWER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| LOWER('helloworld')   | LOWER('HELLOWORLD')   |
|-----------------------+-----------------------|
| helloworld            | helloworld            |
+-----------------------+-----------------------+      

LTRIM

Uso: ltrim(str) remove os caracteres de espaço iniciais da string de entrada.

Tipo de argumento:

• STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `LTRIM('   hello')` = LTRIM('   hello'), `LTRIM('hello   ')` = LTRIM('hello   ') | fields `LTRIM('   hello')`, `LTRIM('hello   ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| LTRIM('   hello')   | LTRIM('hello   ')   |
|---------------------+---------------------|
| hello               | hello               |
+---------------------+---------------------+      

POSITION

Uso: POSITION(substr IN str) retorna a posição da primeira ocorrência de substring na string. Ele retornará 0 se a substring não estiver na string. Ele retornará NULL se algum argumento for NULL.

Tipo de argumento:

• CORDA, CORDA

• Tipo de retorno INTEGER

Exemplo:

os> source=people | eval `POSITION('world' IN 'helloworld')` = POSITION('world' IN 'helloworld'), `POSITION('invalid' IN 'helloworld')`= POSITION('invalid' IN 'helloworld')  | fields `POSITION('world' IN 'helloworld')`, `POSITION('invalid' IN 'helloworld')`
fetched rows / total rows = 1/1
+-------------------------------------+---------------------------------------+
| POSITION('world' IN 'helloworld')   | POSITION('invalid' IN 'helloworld')   |
|-------------------------------------+---------------------------------------|
| 6                                   | 0                                     |
+-------------------------------------+---------------------------------------+      

REVERSE

Uso: REVERSE(str) retorna a string invertida da string de entrada.

Tipo de argumento:

• STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `REVERSE('abcde')` = REVERSE('abcde') | fields `REVERSE('abcde')`
fetched rows / total rows = 1/1
+--------------------+
| REVERSE('abcde')   |
|--------------------|
| edcba              |
+--------------------+      

RIGHT

Uso: right(str, len) retorna os caracteres mais à direita da string de entrada. Ele retornará 0 se a substring não estiver na string. Ele retornará NULL se algum argumento for NULL.

Tipo de argumento:

• STRING, NÚMERO INTEIRO

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `RIGHT('helloworld', 5)` = RIGHT('helloworld', 5), `RIGHT('HELLOWORLD', 0)` = RIGHT('HELLOWORLD', 0) | fields `RIGHT('helloworld', 5)`, `RIGHT('HELLOWORLD', 0)`
fetched rows / total rows = 1/1
+--------------------------+--------------------------+
| RIGHT('helloworld', 5)   | RIGHT('HELLOWORLD', 0)   |
|--------------------------+--------------------------|
| world                    |                          |
+--------------------------+--------------------------+      

RTRIM

Uso: rtrim(str) corta os caracteres de espaço à direita da string de entrada.

Tipo de argumento:

• STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `RTRIM('   hello')` = RTRIM('   hello'), `RTRIM('hello   ')` = RTRIM('hello   ') | fields `RTRIM('   hello')`, `RTRIM('hello   ')`
fetched rows / total rows = 1/1
+---------------------+---------------------+
| RTRIM('   hello')   | RTRIM('hello   ')   |
|---------------------+---------------------|
|    hello            | hello               |
+---------------------+---------------------+      

SUBSTRING

Uso: substring(str, start) ou substring(str, start, length) retorna uma substring da string de entrada. Sem comprimento especificado, ele retorna a string inteira da posição inicial.

Tipo de argumento:

• STRING, INTEIRO, INTEIRO

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `SUBSTRING('helloworld', 5)` = SUBSTRING('helloworld', 5), `SUBSTRING('helloworld', 5, 3)` = SUBSTRING('helloworld', 5, 3) | fields `SUBSTRING('helloworld', 5)`, `SUBSTRING('helloworld', 5, 3)`
fetched rows / total rows = 1/1
+------------------------------+---------------------------------+
| SUBSTRING('helloworld', 5)   | SUBSTRING('helloworld', 5, 3)   |
|------------------------------+---------------------------------|
| oworld                       | owo                             |
+------------------------------+---------------------------------+      

TRIM

Uso: trim(string) remove os espaços em branco à esquerda e à direita da string de entrada.

Tipo de argumento:

• STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `TRIM('   hello')` = TRIM('   hello'), `TRIM('hello   ')` = TRIM('hello   ') | fields `TRIM('   hello')`, `TRIM('hello   ')`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| TRIM('   hello')   | TRIM('hello   ')   |
|--------------------+--------------------|
| hello              | hello              |
+--------------------+--------------------+      

UPPER

Uso: upper(string) converte a string de entrada em maiúsculas.

Tipo de argumento:

• STRING

• Tipo de retorno: STRING

Exemplo:

os> source=people | eval `UPPER('helloworld')` = UPPER('helloworld'), `UPPER('HELLOWORLD')` = UPPER('HELLOWORLD') | fields `UPPER('helloworld')`, `UPPER('HELLOWORLD')`
fetched rows / total rows = 1/1
+-----------------------+-----------------------+
| UPPER('helloworld')   | UPPER('HELLOWORLD')   |
|-----------------------+-----------------------|
| HELLOWORLD            | HELLOWORLD            |
+-----------------------+-----------------------+      

Funções de conversão do tipo PPL

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa função PPL, consulte. Funções

TRIM

Uso: cast(expr as dateType) converte o expr para o dataType e retorna o valor dodataType.

As seguintes regras de conversão se aplicam:

Regras de conversão de tipos

Src/Target	STRING	NUMBER	BOOLEAN	TIMESTAMP	DATE	TIME
STRING		Nota 1	Nota 1	TIMESTAMP()	DATE()	TIME()
NUMBER	Nota 1		v! =0	N/D	N/D	N/D
BOOLEAN	Nota 1	v? 1:0		N/D	N/D	N/D
TIMESTAMP	Nota 1	N/D	N/D		DATE()	TIME()
DATE	Nota 1	N/D	N/D	N/D		N/D
TIME	Nota 1	N/D	N/D	N/D	N/D

Exemplo de conversão em string:

os> source=people | eval `cbool` = CAST(true as string), `cint` = CAST(1 as string), `cdate` = CAST(CAST('2012-08-07' as date) as string) | fields `cbool`, `cint`, `cdate`
fetched rows / total rows = 1/1
+---------+--------+------------+
| cbool   | cint   | cdate      |
|---------+--------+------------|
| true    | 1      | 2012-08-07 |
+---------+--------+------------+

Exemplo de conversão para números:

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 elenco atualizado:

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 elenco encadeado:

os> source=people | eval `cbool` = CAST(CAST(true as string) as boolean) | fields `cbool`
fetched rows / total rows = 1/1
+---------+
| cbool   |
|---------|
| True    |
+---------+