Comandos compatibles PPL

En las siguientes tablas, se muestran qué comandos PPL son compatibles con OpenSearch Dashboards para consultar Registros de CloudWatch, Amazon S3 o Security Lake y qué comandos son compatibles con Información de registros de CloudWatch. Información de registros de CloudWatch utiliza la misma sintaxis de PPL que OpenSearch Dashboards al consultar Registros de CloudWatch y en las tablas se hace referencia a ambos como Registros de CloudWatch.

Comandos

 fields field1, field2

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

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

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

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

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

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

rename field2 as field1
| fields field1

 fields `@message`
| head 20

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

 top 2 Field1 by Field2

dedup field1
| fields field1, field2, field3

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

where orderType = 'Cancelled'
| lookup account_list, mkt_id AS mkt_code
  replace amount, account_name as name
| stats count(mkt_code), avg(amount)
  by name

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

 rare Field1 by Field2

 trendline sma(2, field1) as field1Alias

 eventstats sum(field1) by field2

 source=table | flatten field1

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

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

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

 describe schema.table

Funciones

eval col1Len = LENGTH(col1)
| fields col1Len

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

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

eval field2 = ACOS(col1)
| fields col1

where age > (25 + 5)
| fields age  

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

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

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

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

Información adicional para los usuarios de Información de registros de CloudWatch que utilizan OpenSearch PPL

Aunque Información de registros de CloudWatch admite la mayoría de los comandos y funciones PPL de OpenSearch, algunos comandos y funciones no son compatibles por el momento. Por ejemplo, actualmente no admite los comandos de búsqueda en PPL. A partir del 2 de junio de 2025, Información de registros de CloudWatch ahora admite las funciones JOIN, subconsultas, Flatten, Fillnull, Expand, Cidrmatch y JSON en PPL. Para obtener una lista completa de los comandos y funciones de consulta compatibles, consulte las columnas de Registros de Amazon CloudWatch en las tablas anteriores.

Consultas y cuotas de ejemplo

Lo siguiente se aplica tanto a los usuarios de Información de registros de CloudWatch como a los usuarios de OpenSearch que consultan datos de CloudWatch.

Para obtener información acerca de los límites que se aplican al consultar Registros de CloudWatch desde OpenSearch Service, consulte Cuotas de Registros de CloudWatch en la Guía del usuario de Registros de Amazon CloudWatch. Los límites se refieren al número de grupos de Registros de CloudWatch que se pueden consultar, el número máximo de consultas simultáneas que se pueden ejecutar, el tiempo máximo de ejecución de las consultas y el número máximo de filas devueltas en los resultados. Los límites son los mismos independientemente del idioma que utilice para consultar Registros de CloudWatch (es decir, OpenSearch PPL, SQL y Logs Insights QL).

Comandos PPL

comentario

PPL admite tanto los comentarios de línea como los comentarios bloqueados. El sistema no evalúa el texto de los comentarios.

Comentarios de línea

Los comentarios de línea comienzan con dos barras diagonales // y terminan con una línea nueva.

Ejemplo:

os> source=accounts | top gender // finds most common gender of all the accounts
fetched rows / total rows = 2/2
+----------+
| gender   |
|----------|
| M        |
| F        |
+----------+                     

Comentarios bloqueados

Los comentarios bloqueados comienzan con una barra seguida de un asterisco \* y terminan con un asterisco seguido de una barra */.

Ejemplo:

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 correlación

Puede correlacionar diferentes orígenes de datos según dimensiones y plazos comunes.

Esta correlación es crucial cuando se trata de grandes cantidades de datos de varios mercados verticales que comparten los mismos periodos de tiempo pero que no están sincronizados formalmente.

Al correlacionar estos diferentes orígenes de datos en función de plazos y dimensiones similares, puede enriquecer sus datos y descubrir información valiosa.

Ejemplo

El dominio de la observabilidad tiene tres orígenes de datos distintos:

Estas orígenes de datos pueden compartir dimensiones comunes. Para realizar la transición de un origen de datos a otro, debe correlacionarlos correctamente. Mediante las convenciones de nomenclatura semántica, puede identificar los elementos compartidos en los registros, los rastros y las métricas.

Ejemplo:

{
  "@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"
} 

En este ejemplo, se muestra un registro de AWS ELB que proviene de un servicio que reside en AWS. Muestra una respuesta backend de HTTP con un código de estado 500, lo que indica un error. Esto podría activar una alerta o formar parte de su proceso de supervisión habitual. El siguiente paso es recopilar datos relevantes sobre este suceso para llevar a cabo una investigación exhaustiva.

Si bien es posible que se sienta tentado a consultar todos los datos relacionados con el periodo de tiempo, este enfoque puede resultar abrumador. Podría terminar con demasiada información y dedicar más tiempo a filtrar los datos irrelevantes que a identificar la raíz del problema.

En su lugar, puede utilizar un enfoque más específico mediante la correlación de los datos de diferentes orígenes. Puede utilizar estas dimensiones para la correlación:

Si tiene acceso a índices de métricas y trazas adicionales y está familiarizado con la estructura de su esquema, puede crear una consulta de correlación más precisa.

Este es un ejemplo de un documento de índice de rastreo que contiene información HTTP que quizás quiera 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": {
         ...
        }
      }
    }
  }
}

En este enfoque, puede ver el traceId y la ip de cliente/servidor de http que se puede correlacionar con los registros de elb para comprender mejor el comportamiento y el estado del sistema.

Nuevo comando de consulta de correlación

Este es el nuevo comando que permitiría este tipo de investigación:

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 )  

A continuación, se muestra lo que hace cada parte del comando:

Los nombres de los campos indican el significado lógico de la función dentro del comando de correlación. La condición de unión real depende de la sentencia de asignación que proporcione.

El término exact significa que las declaraciones de correlación requerirán que todos los campos coincidan para cumplir con la declaración de consulta.

El término approximate intentará coincidir en el mejor de los casos y no rechazará las filas con coincidencias parciales.

Tratamiento de diferentes asignaciones de campos

En los casos en que el mismo campo lógico (por ejemplo ip) tenga nombres diferentes en los orígenes de datos, debe proporcionar la asignación explícita de los campos de ruta. Para solucionar este problema, puede ampliar las condiciones de correlación para que coincidan con distintos nombres de campo con significados lógicos similares. A continuación le explicamos cómo puede configurar esto:

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

Para cada campo que participe en la unión de correlación, debe proporcionar una sentencia de asignación relevante que incluya todas las tablas que se van a unir mediante este comando de correlación.

Ejemplo

En este ejemplo, hay dos orígenes: alb_logs, traces

Hay 2 campos: traceId, ip

Hay dos instrucciones de asignación: alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId

Delimitación de los plazos de correlación

Para simplificar el trabajo realizado por el motor de ejecución (controlador), puede agregar la sentencia de alcance. Esto indica explícitamente a la consulta de unión el momento en el que debe realizarse esta búsqueda.

scope(@timestamp, 1D) i

En este ejemplo, el ámbito de búsqueda se centra en el día a día, por lo que las correlaciones que aparecen el mismo día se agrupan. Este mecanismo de determinación del alcance simplifica y permite un mejor control de los resultados, lo que permite una resolución de búsqueda incremental en función de sus necesidades.

Controladores de apoyo

El nuevo comando de correlación es en realidad un comando de unión “oculto”. Por lo tanto, solo los siguientes controladores PPL admiten este comando. En estos controladores, el comando de correlación se traducirá directamente al plan lógico Catalyst Join correspondiente.

Ejemplo

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)

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

El motor catalizador optimiza esta consulta según el orden de unión más eficiente.

dedup command

Utilice el comando dedup para eliminar documentos idénticos de los resultados de la búsqueda en función de los campos especificados.

Sintaxis

Utilice la siguiente sintaxis:

dedup [int] <field-list> [keepempty=<bool>] [consecutive=<bool>] 

Ejemplo 1: Deduplicación por un campo

En este ejemplo se muestra cómo desdoblar documentos mediante el 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        |
+------------------+----------+

Ejemplo 2: Conserve 2 documentos duplicados

En el ejemplo se muestra cómo deduplicar los documentos con el campo de género, conservando dos duplicados.

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

Ejemplo 3: Mantener o ignorar el campo vacío de forma predeterminada

El ejemplo muestra cómo deduplicar el documento manteniendo el campo de valor nulo.

Consulta PPL:

os> source=accounts | dedup email keepempty=true | fields account_number, email;
fetched rows / total rows = 4/4
+------------------+-----------------------+
| account_number   | email                 |
+------------------+-----------------------+
| 1                | john_doe@example.com  |
| 6                | jane_doe@example.com  |
| 13               | null                  |
| 18               | juan_li@example.com   |
+------------------+-----------------------+      

El ejemplo muestra cómo deduplicar el documento ignorando el campo de valor vacío.

Consulta PPL:

os> source=accounts | dedup email | fields account_number, email;
fetched rows / total rows = 3/3
+------------------+-----------------------+
| account_number   | email                 |
+------------------+-----------------------+
| 1                | john_doe@example.com  |
| 6                | jane_doe@example.com  |
| 18               | juan_li@example.com   |
+------------------+-----------------------+      

Ejemplo 4: Deduplicación en documentos consecutivos

En el ejemplo se muestra cómo deduplicar en documentos consecutivos.

Consulta PPL:

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

Comando describe

Utilice el comando describe para obtener información detallada sobre la estructura y los metadatos de las tablas, los esquemas y los catálogos. A continuación, se muestran varios ejemplos y casos de uso del comando describe.

Comando eval

El comando eval evalúa la expresión y agrega el resultado al resultado de la búsqueda.

Sintaxis

Utilice la siguiente sintaxis:

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

Ejemplo 1: creación de un campo nuevo

En este ejemplo se muestra cómo crear un nuevo campo doubleAge para cada documento. El nuevo doubleAge es el resultado de la evaluación de la edad 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          |
+-------+-------------+        

Ejemplo 2: anular el campo existente

En este ejemplo, se muestra cómo anular el campo de edad existente por edad más 1.

Consulta PPL:

os> source=accounts | eval age = age + 1 | fields age ;
fetched rows / total rows = 4/4
+-------+
| age   |
|-------|
| 33    |
| 37    |
| 29    |
| 34    |
+-------+     

Ejemplo 3: cree el nuevo campo con el campo definido en eval

En este ejemplo se muestra cómo crear un nuevo campo ddAge con un campo definido en el comando eval. El nuevo campo ddAge es el resultado de la evaluación de doubleAge multiplicado por 2, donde doubleAge se define en el 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     |
+-------+-------------+---------+        

Supuestos: a, b y c son campos existentes en table

Evaluación con un ejemplo 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')      

Evaluación con otro ejemplo de caso:

Supuestos: a, b y c son campos existentes en table

Evaluación con un ejemplo 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')      

Evaluación con otro ejemplo de caso:

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

comando eventstats

Utilice el comando eventstats para enriquecer los datos del evento con estadísticas resumidas calculadas. Funciona mediante el análisis de campos específicos de los eventos, el cálculo de diversas medidas estadísticas y, a continuación, la adición de estos resultados como campos nuevos a cada evento original.

Diferencia entre stats y eventstats

Los comandos stats y eventstats se utilizan para calcular estadísticas, pero tienen algunas diferencias clave en su funcionamiento y en lo que producen.

Sintaxis

Utilice la siguiente sintaxis:

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

Funciones de agregación

COUNT

COUNT devuelve un recuento del número de expresiones en las filas recuperadas por una sentencia SELECT.

No se admiten consultas de uso COUNT en Registros de CloudWatch.

Ejemplo:

os> source=accounts | eventstats count();
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| account_number | balance  | firstname | lastname | age | gender | address            | employer   | email                    | city   | state | count() |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | *** Any Lane       | AnyCorp    | janedoe@anycorp.com      | Brogan | IL    | 4       |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street | AnyCompany | marymajor@anycompany.com | Dante  | TN    | 4       |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street     | AnyOrg     |                          | Nogal  | VA    | 4       |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court  |            | juanli@exampleorg.com    | Orick  | MD    | 4       |
+----------------+----------+-----------+----------+-----+--------+--------------------+------------+--------------------------+--------+-------+---------+        

SUM

SUM(expr) devuelve la suma de expr.

Ejemplo:

os> source=accounts | eventstats sum(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer   | email                    | city   | state | sum(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | 880 Any Lane          | AnyCorp    | janedoe@anycorp.com      | Brogan | IL    | 101                |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | AnyCompany | marymajor@anycompany.com | Dante  | TN    | 101                |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg     |                          | Nogal  | VA    | 28                 |
| 18             | 4180     | Juan      | Li       | 33  | M      | 467 Example Court     |            | juanli@exampleorg.com    | Orick  | MD    | 101                |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+--------------------------+--------+-------+--------------------+        

AVG

AVG(expr) devuelve el valor medio de expr.

Ejemplo:

os> source=accounts | eventstats avg(age) by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | avg(age) by gender |
+----------------+----------+-----------+----------+-----+--------+-----------------------+------------+---------------------------+--------+-------+--------------------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | 880 Any Lane          | AnyCorp     | janedoe@anycorp.com      | Brogan | IL    | 33.67              |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | marymajor@anycompany.com | Dante  | TN    | 33.67              |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 28.00              |
| 18             | 4180     | Juan      | Li       | 33  | M      | 467 Example Court     |             | juanli@exampleorg.com    | Orick  | MD    | 33.67              |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------+        

MAX

MAX(expr) devuelve el valor máximo de expr.

Ejemplo

os> source=accounts | eventstats max(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | max(age)  |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | 880 Any Lane          | AnyCorp     | janedoe@anycorp.com      | Brogan | IL    | 36        |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | marymajor@anycompany.com | Dante  | TN    | 36        |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 36        |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | juanli@exampleorg.com    | Orick  | MD    | 36        |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+        

MIN

MIN(expr) devuelve el valor mínimo de expr.

Ejemplo

os> source=accounts | eventstats min(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | min(age)  |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | 880 Any Lane          | AnyCorp     | janedoe@anycorp.com      | Brogan | IL    | 28        |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | marymajor@anycompany.com | Dante  | TN    | 28        |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | *** Any Street        | AnyOrg      |                          | Nogal  | VA    | 28        |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | juanli@exampleorg.com    | Orick  | MD    | 28        |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+        

STDDEV_SAMP

STDDEV_SAMP(expr) devuelve la desviación estándar muestral de expr.

Ejemplo

os> source=accounts | eventstats stddev_samp(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | stddev_samp(age)       |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | *** Any Lane          | AnyCorp     | janedoe@anycorp.com      | Brogan | IL    | 3.304037933599835      |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | marymajor@anycompany.com | Dante  | TN    | 3.304037933599835      |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 3.304037933599835      |
| 18             | 4180     | Juan      | Li       | 33  | M      | 467 Example Court     |             | juanli@exampleorg.com    | Orick  | MD    | 3.304037933599835      |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+        

STDDEV_POP

STDDEV_POP(expr) devuelve la desviación estándar poblacional de expr.

Ejemplo

os> source=accounts | eventstats stddev_pop(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | stddev_pop(age)        |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | 880 Any Lane          | AnyCorp     | janedoe@anycorp.com      | Brogan | IL    | 2.****************     |
| 6              | 5686     | Mary      | Major    | 36  | M      | *** Example Street    | Any Company | marymajor@anycompany.com | Dante  | TN    | 2.****************     |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | *** Any Street        | AnyOrg      |                          | Nogal  | VA    | 2.****************     |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | juanli@exampleorg.com    | Orick  | MD    | 2.****************     |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+        

PERCENTILE o PERCENTILE_APPROX

PERCENTILE(expr, percent) o PERCENTILE_APPROX(expr, percent) devuelve el valor percentil aproximado de expr en el porcentaje especificado.

Ejemplo

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

Ejemplo 1: calcular el promedio, la suma y el recuento de un campo por grupo

En el ejemplo se muestra cómo calcular la edad media, la edad sumada y el recuento de eventos de todas las cuentas agrupadas por género.

os> source=accounts | eventstats avg(age) as avg_age, sum(age) as sum_age, count() as count by gender;
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | avg_age   | sum_age   | count |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | *** Any Lane          | AnyCorp     | janedoe@anycorp.com      | Brogan | IL    | 33.666667 | 101       | 3     |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | marymajor@anycompany.com | Dante  | TN    | 33.666667 | 101       | 3     |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 28.000000 | 28        | 1     |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | juanli@exampleorg.com    | Orick  | MD    | 33.666667 | 101       | 3     |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+      

Ejemplo 2: Calcule el recuento en un intervalo

El ejemplo obtiene el recuento de la edad en un intervalo de 10 años.

os> source=accounts | eventstats count(age) by span(age, 10) as age_span
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                    | city   | state | age_span |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
| 1              | 39225    | Jane      | Doe      | 32  | M      | *** Any Lane          | AnyCorp     | janedoe@anycorp.com      | Brogan | IL    | 3        |
| 6              | 5686     | Mary      | Major    | 36  | M      | 671 Example Street    | Any Company | marymajor@anycompany.com | Dante  | TN    | 3        |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | 789 Any Street        | AnyOrg      |                          | Nogal  | VA    | 1        |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | juanli@exampleorg.com    | Orick  | MD    | 3        |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+      

Ejemplo 3: Calcule el recuento por género y rango

El ejemplo obtiene el recuento de la edad por un intervalo de 5 años y el grupo por género.

os> source=accounts | eventstats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| account_number | balance  | firstname | lastname | age | gender | address               | employer    | email                     | city   | state | cnt |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| 1              | 39225    | Jane      | Doe      | 32  | M      | *** Any Lane          | AnyCorp     | janedoe@anycorp.com       | Brogan | IL    | 2   |
| 6              | 5686     | Mary      | Majo     | 36  | M      | 671 Example Street    | Any Company | hattiebond@anycompany.com | Dante  | TN    | 1   |
| 13             | 32838    | Nikki     | Wolf     | 28  | F      | *** Any Street        | AnyOrg      |                           | Nogal  | VA    | 1   |
| 18             | 4180     | Juan      | Li       | 33  | M      | *** Example Court     |             | juanli@exampleorg.com     | Orick  | MD    | 2   |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+      

Agregaciones con span

Agregaciones con intervalo de ventana de tiempo (función de ventana invertida)

Las agregaciones se agrupan en varios niveles

Comando expand

Utilice el comando expand para aplanar un campo del tipo:

Sintaxis

Utilice la siguiente sintaxis:

expand <field> [As alias]

Uso

El comando expand genera una fila para cada elemento de la matriz o campo de mapa especificado, donde:

Comando explain

El comando explain lo ayuda a entender los planes de ejecución de las consultas, lo que le permite analizarlas y optimizarlas para obtener un mejor rendimiento. Esta introducción proporciona una descripción general y concisa del propósito del comando explain y de su importancia en la optimización de las consultas.

Filtros complejos

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

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

Eval

Supuestos: a, b, c son campos existentes en table

Comando fillnull

Descripción

Use el comando fillnull para reemplazar los valores nulos por un valor especificado en uno o más campos de los resultados de la búsqueda.

Sintaxis

Utilice la siguiente sintaxis:

fillnull [with <null-replacement> in <nullable-field>["," <nullable-field>]] | [using <source-field> = <null-replacement> [","<source-field> = <null-replacement>]]

Ejemplo 1: Fillnull en un campo

En el ejemplo se muestra cómo utilizar fillnull en un solo 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         |

Ejemplo 2: Fillnull aplicado a varios campos

El ejemplo muestra la aplicación fillnull a varios 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    |

Ejemplo 3: Se aplica fillnull a varios campos con varios valores de reemplazo nulos.

El ejemplo muestra fillnull con varios valores que se utilizan para reemplazar los valores nulos.

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

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

Comando fields

Utilice el comando fields para conservar o eliminar campos del resultado de la búsqueda.

Sintaxis

Utilice la siguiente sintaxis:

field [+|-] <field-list> 

Ejemplo 1: seleccionar campos específicos del resultado

En este ejemplo se muestra cómo obtener campos account_number, firstname y lastname de los resultados de la búsqueda.

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

Ejemplo 2: Eliminar los campos especificados del resultado

En este ejemplo se muestra cómo quitar el campo account_number de los resultados de búsqueda.

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

Ejemplo de campos anidados:

`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

Utilice el comando flatten para expandir los campos de los siguientes tipos:

Sintaxis

Utilice la siguiente sintaxis:

flatten <field>

Esquema

Datos

Ejemplo 1: estructura aplanada

En este ejemplo se muestra cómo aplanar un campo de estructura.

Consulta PPL:

source=table | flatten coor

Ejemplo 2: aplanar una matriz

En el ejemplo se muestra cómo aplanar una matriz de campos de estructura.

Consulta PPL:

source=table | flatten bridges

Ejemplo 3: aplanar una matriz y una estructura

En este ejemplo, se muestra cómo aplanar varios campos.

Consulta PPL:

source=table | flatten bridges | flatten coor

Comando grok

El comando grok analiza un campo de texto con un patrón grok y agrega los resultados al resultado de la búsqueda.

Sintaxis

Utilice la siguiente sintaxis:

grok <field> <pattern>

Patrón de Grok

El patrón grok se utiliza para hacer coincidir el campo de texto de cada documento y extraer nuevos campos.

Ejemplo 1: creación de un campo nuevo

En este ejemplo se muestra cómo crear un nuevo campo host para cada documento. host será el nombre de host que aparece después @ en el campo email. Si se analiza un campo nulo, se devuelve una cadena vacía.

os> source=accounts | grok email '.+@%{HOSTNAME:host}' | fields email, host ;
fetched rows / total rows = 4/4
+-------------------------+-------------+
| email                   | host        |
|-------------------------+-------------|
| jane_doe@example.com    | example.com |
| arnav_desai@example.net | example.net |
| null                    |             |
| juan_li@example.org     | example.org |
+-------------------------+-------------+      

Ejemplo 2: anular el campo existente

En este ejemplo se muestra cómo anular el campo address existente quitando el número de calle.

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

Ejemplo 3: Uso de grok para analizar registros

En este ejemplo, se muestra cómo utilizar grok para analizar registros sin procesar.

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

Limitaciones

El comando grok tiene las mismas limitaciones que el comando parse.

Comando head

Utilice el comando head para devolver el primer número N de resultados especificados después de un desplazamiento opcional en el orden de búsqueda.

Sintaxis

Utilice la siguiente sintaxis:

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

Ejemplo 1: Obtenga los primeros 10 resultados

En este ejemplo se muestra cómo recuperar un máximo de 10 resultados del índice de cuentas.

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

Ejemplo 2: Obtenga los primeros N resultados

El ejemplo muestra los primeros N resultados del índice de cuentas.

Consulta PPL:

os> source=accounts | fields firstname, age | head 3;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname   | age   |
|-------------+-------|
| Jane        | 32    |
| John        | 36    |
| Jorge       | 28    |
+-------------+-------+      

Ejemplo 3: Obtenga los primeros N resultados después de la compensación M

En este ejemplo se muestra cómo recuperar los primeros N resultados después de omitir M resultados del índice de cuentas.

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

El comando join le permite combinar datos de varios orígenes en función de campos comunes, lo que le permite realizar análisis complejos y obtener información más detallada a partir de sus conjuntos de datos distribuidos.

Esquema

Hay al menos dos índices: otel-v1-apm-span-* (grande) y otel-v1-apm-service-map (pequeño).

Campos relevantes de los índices:

Requisito

Admita join para calcular lo siguiente:

Para cada servicio, combine el índice span con el índice del mapa de servicios para calcular las métricas con distintos tipos de filtros.

Esta consulta de ejemplo calcula la latencia al filtrarla por grupo de rastreo client_cancel_order para el servicio 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`)    

Migración a PPL

Sintaxis del comando join

SEARCH source=<left-table>
| <other piped command>
| [joinType] JOIN
    [leftAlias]
    ON joinCriteria
    <right-table>
| <other piped command>      

Reescrituras

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      

Más ejemplos

Migración desde una 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 por PPL Join Query:

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      

Limitación: no se admiten subbúsquedas en el lado derecho de la unión.

Si se admiten las subbúsquedas, puedes reescribir la consulta PPL anterior de la siguiente manera:

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

Utilice el comando lookup para enriquecer los datos de búsqueda mediante la adición o sustitución de datos de un índice de búsqueda (tabla de dimensiones). Este comando le permite extender los campos de un índice con valores de una tabla de dimensiones. También se puede utilizar para agregar o reemplazar valores cuando se cumplen las condiciones de búsqueda. El comando lookup es más adecuado que el comando Join para enriquecer los datos de origen con un conjunto de datos estático.

Sintaxis

Utilice la siguiente sintaxis:

SEARCH source=<sourceIndex>
| <other piped command>
| LOOKUP <lookupIndex> (<lookupMappingField> [AS <sourceMappingField>])...
    [(REPLACE | APPEND) (<inputField> [AS <outputField>])...]
| <other piped command>    

Ejemplo

Vea los siguientes ejemplos.

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

El comando parse analiza un campo de texto con una expresión regular y agrega el resultado al resultado de la búsqueda.

Sintaxis

Utilice la siguiente sintaxis:

parse <field> <pattern>    

Expresión regular

El patrón de expresiones regulares se utiliza para hacer coincidir todo el campo de texto de cada documento con el motor de expresiones regulares de Java. Cada grupo de captura nombrado en la expresión se convertirá en un campo nuevo STRING.

Ejemplo 1: creación de un campo nuevo

En el ejemplo se muestra cómo crear un nuevo campo host para cada documento. host será el nombre del host que aparece después @ en el campo email. Si se analiza un campo nulo, se devuelve una cadena vacía.

Consulta PPL:

os> source=accounts | parse email '.+@(?<host>.+)' | fields email, host ;
fetched rows / total rows = 4/4
+-----------------------+-------------+
| email                 | host        |
|-----------------------+-------------|
| jane_doe@example.com  | example.com |
| john_doe@example.net  | example.net |
| null                  |             |
| juan_li@example.org   | example.org |
+-----------------------+-------------+      

Ejemplo 2: Anular un campo existente

El ejemplo muestra cómo anular el campo address existente quitando el número de calle.

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

Ejemplo 3: Filtrar y ordenar por campo analizado

En el ejemplo se muestra cómo ordenar los números de calle superiores a 500 en el campo address.

Consulta PPL:

os> source=accounts | parse address '(?<streetNumber>\d+) (?<street>.+)' | where cast(streetNumber as int) > 500 | sort num(streetNumber) | fields streetNumber, street ;
fetched rows / total rows = 3/3
+----------------+----------------+
| streetNumber   | street         |
|----------------+----------------|
| ***            | Example Street |
| ***            | Example Avenue |
| 880            | Example Lane   |
+----------------+----------------+      

Limitaciones

El comando parse presenta algunas limitaciones:

Comando patterns

El comando patterns extrae los patrones de registro de un campo de texto y agrega los resultados al resultado de la búsqueda. Al agrupar los registros por sus patrones, resulta más fácil agregar estadísticas de grandes volúmenes de datos de registro para analizarlos y solucionar problemas.

Sintaxis

Utilice la siguiente sintaxis:

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

Ejemplo 1: creación de un campo nuevo

En el ejemplo se muestra cómo utilizar los signos de puntuación extraídos en email cada documento. Si se analiza un campo nulo, se devuelve una cadena vacía.

Consulta PPL:

os> source=accounts | patterns email | fields email, patterns_field ;
fetched rows / total rows = 4/4
+-----------------------+------------------+
| email                 | patterns_field   |
|-----------------------+------------------|
| jane_doe@example.com  | @.               |
| john_doe@example.net  | @.               |
| null                  |                  |
| juan_li@example.org   | @.               |
+-----------------------+------------------+      

Ejemplo 2: Extraer patrones de registro

El ejemplo muestra cómo extraer signos de puntuación de un campo de registro sin procesar utilizando los patrones predeterminados.

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                                             | ... - - [//::: -] " / /."       |
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
      

Ejemplo 3: Extraiga patrones de registro con un patrón de expresiones regulares personalizado

El ejemplo muestra cómo extraer signos de puntuación de un campo de registro sin procesar utilizando patrones definidos por el usuario.

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/."                                            |
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+

Limitación

El comando patterns tiene las mismas limitaciones que el comando parse.

Comando rare

Utilice el comando rare para buscar la tupla de valores menos común de todos los campos de la lista de campos.

Sintaxis

Utilice la siguiente sintaxis:

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

Ejemplo 1: Encuentre los valores menos comunes en un campo

El ejemplo busca el género menos común de todas las cuentas.

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

Ejemplo 2: encuentra los valores menos comunes organizados por género

En el ejemplo, se busca la edad menos común de todas las cuentas agrupadas por género.

Consulta PPL:

os> source=accounts | rare 5 age by gender;
os> source=accounts | rare_approx 5 age by gender;
fetched rows / total rows = 4/4
+----------+-------+
| gender   | age   |
|----------+-------|
| F        | 28    |
| M        | 32    |
| M        | 33    |
| M        | 36    |
+----------+-------+     

Comando rename

Utilice el comando rename para cambiar los nombres de uno o más campos del resultado de la búsqueda.

Sintaxis

Utilice la siguiente sintaxis:

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

Ejemplo 1: cambiar el nombre de un campo

En este ejemplo, se muestra cómo renombrar un ú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   |
+------+      

Ejemplo 2: cambiar el nombre de varios campos

En este ejemplo, se muestra cómo renombrar varios campos.

Consulta PPL:

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

Comando search

Utilice el comando search para recuperar documentos de un índice. El comando search solo se puede usar como primer comando en una consulta PPL.

Sintaxis

Utilice la siguiente sintaxis:

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

Ejemplo 1: obtener todos los datos

El ejemplo muestra cómo recuperar todo el documento del índice de cuentas.

Consulta PPL:

os> source=accounts;
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
| account_number   | firstname   | address              | balance   | gender   | city   | employer       | state   | age   | email                 | lastname   |
|------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------|
| 1                | Jorge       | *** Any Lane         | 39225     | M        | Brogan | ExampleCorp    | IL      | 32    | jane_doe@example.com  | Souza      |
| 6                | John        | *** Example Street   | 5686      | M        | Dante  | AnyCorp        | TN      | 36    | john_doe@example.com  | Doe        |
| 13               | Jane        | *** Any Street       | *****     | F        | Nogal  | ExampleCompany | VA      | 28    | null                  | Doe        |
| 18               | Juan        | *** Example Court    | 4180      | M        | Orick  | null           | MD      | 33    | juan_li@example.org   | Li         |
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+      

Ejemplo 2: Obtener datos con una condición

El ejemplo muestra cómo recuperar todo el documento del índice de cuentas con .

Consulta PPL:

os> SEARCH source=accounts account_number=1 or gender="F";
+------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------+
| account_number   | firstname   | address            | balance   | gender   | city   | employer       | state   | age   | email                -  | lastname   |
|------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------|
| 1                | Jorge       | *** Any Lane       | *****     | M        | Brogan | ExampleCorp    | IL      | 32    | jorge_souza@example.com | Souza      |
| 13               | Jane        | *** Any Street     | *****     | F        | Nogal  | ExampleCompany | VA      | 28    | null                    | Doe        |
+------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+      

Comando sort

Utilice el comando sort para ordenar los resultados de la búsqueda por campos específicos.

Sintaxis

Utilice la siguiente sintaxis:

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

Ejemplo 1: Ordenar por un campo

El ejemplo muestra cómo ordenar el documento con el campo de edad en orden ascendente.

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

Ejemplo 2: ordenar por un campo y devolver todos los resultados

El ejemplo muestra cómo ordenar el documento con el campo de edad en orden ascendente.

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

Ejemplo 3: ordenar por un campo en orden descendente

El ejemplo muestra cómo ordenar el documento con el campo de edad en orden descendente.

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

Ejemplo 4: Ordenar por varios campos

El ejemplo muestra cómo ordenar el documento con el campo de género en orden ascendente y el campo de edad en orden descendente.

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

Ejemplo 5: Ordenar por campo e incluir un valor nulo

En el ejemplo se muestra cómo ordenar el campo del empleador por la opción predeterminada (en orden ascendente y con los valores nulo primero). El resultado muestra que el valor nulo está en la primera fila.

Consulta PPL:

os> source=accounts | sort employer | fields employer;
fetched rows / total rows = 4/4
+------------+
| employer   |
|------------|
| null       |
| AnyCompany |
| AnyCorp    |
| AnyOrgty   |
+------------+      

Comandos stats

Utilice el comando stats para calcular la agregación a partir del resultado de la búsqueda.

Manejo de valores NULL o MISSING

Sintaxis

Utilice la siguiente sintaxis:

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

span-expression

Funciones de agregación

COUNT

Devuelve un recuento del número de expr en las filas recuperadas por una sentencia SELECT.

Ejemplo:

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

SUM

Se utiliza SUM(expr) para devolver la suma de expr.

Ejemplo

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

AVG

Se utiliza AVG(expr) para devolver el valor medio de la expr.

Ejemplo

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

MAX

Se utiliza MAX(expr) para devolver el valor máximo de expr.

Ejemplo

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

MIN

Se utiliza MIN(expr) para devolver el valor mínimo de expr.

Ejemplo

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

STDDEV_SAMP

Se utiliza STDDEV_SAMP(expr) para devolver la desviación estándar muestral de expr.

Ejemplo:

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

STDDEV_POP

Se utiliza STDDEV_POP(expr) para devolver la desviación estándar poblacional de expr.

Ejemplo:

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

TAKE

Se utiliza TAKE(field [, size]) para devolver los valores originales de un campo. No garantiza el orden de los valores.

Ejemplo

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

PERCENTILE o PERCENTILE_APPROX

Utilice PERCENTILE(expr, percent) o PERCENTILE_APPROX(expr, percent) para devolver el valor percentil aproximado de expr en el porcentaje especificado.

Ejemplo

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

Ejemplo 1: Calcular el recuento de eventos

El ejemplo muestra cómo calcular el recuento de eventos en las cuentas.

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

Ejemplo 2: Calcular el promedio de un campo

En el ejemplo se muestra cómo calcular la edad media de todas las cuentas.

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

Ejemplo 3: Calcular el promedio de un campo por grupo

El ejemplo muestra cómo calcular la edad media de todas las cuentas, agrupadas por género.

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

Ejemplo 4: Calcular el promedio, la suma y el recuento de un campo por grupo

En el ejemplo se muestra cómo calcular la edad media, la edad sumada y el recuento de eventos de todas las cuentas, agrupadas por género.

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

Ejemplo 5: Calcular el máximo de un campo

El ejemplo calcula la edad máxima de todas las cuentas.

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

Ejemplo 6: Calcular el máximo y el mínimo de un campo por grupo

El ejemplo calcula los valores de edad máxima y mínima para todas las cuentas, agrupados por género.

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

Ejemplo 7: Calcular el recuento distinto de un campo

Para obtener el recuento de valores distintos de un campo, puede utilizar la función DISTINCT_COUNT (o DC) en lugar de COUNT. El ejemplo calcula tanto el recuento como el recuento distinto del campo de género de todas las cuentas.

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

Ejemplo 8: Calcular el recuento mediante un intervalo

El ejemplo obtiene el recuento de la edad en un intervalo de 10 años.

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

Ejemplo 9: Calcule el recuento por género y rango

Este ejemplo cuenta los registros agrupados por género y edad en intervalos de 5 años.

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

La expresión span siempre aparece como la primera clave de agrupamiento, independientemente del orden especificado en el 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        |
+-------+------------+----------+      

Ejemplo 10: Calcule el recuento y obtenga la lista de correo electrónico por género y rango

El ejemplo obtiene el recuento de edad por un intervalo de 10 años y el grupo por género. Además, para cada fila, obtiene una lista de 5 correos electrónicos como máximo.

os> source=accounts | stats count() as cnt, take(email, 5) by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+----------------------------------------------------+------------+----------+
| cnt   | take(email, 5)                                     | age_span   | gender   |
|-------+----------------------------------------------------+------------+----------|
| 1     | []                                                 | 25         | F        |
| 2     | [janedoe@anycompany.com,juanli@examplecompany.org] | 30         | M        |
| 1     | [marymajor@examplecorp.com]                        | 35         | M        |
+-------+----------------------------------------------------+------------+----------+      

Ejemplo 11: Calcular el percentil de un campo

El ejemplo muestra cómo calcular el percentil de 90 de edad de todas las cuentas.

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

Ejemplo 12: Calcular el percentil de un campo por grupo

En el ejemplo se muestra cómo calcular el percentil de 90 de edad de todas las cuentas agrupadas por género.

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

Ejemplo 13: Calcule el percentil por género y rango

El ejemplo obtiene el percentil de 90 años de edad con un intervalo de 10 años y el grupo por género.

os> source=accounts | stats percentile(age, 90) as p90 by span(age, 10) as age_span, gender
fetched rows / total rows = 2/2
+-------+------------+----------+
| p90   | age_span   | gender   |
|-------+------------+----------|
| 28    | 20         | F        |
| 36    | 30         | M        |
+-------+------------+----------+      

- `source = table | stats avg(a) `
- `source = table | where a < 50 | stats avg(c) `
- `source = table | stats max(c) by b`
- `source = table | stats count(c) by b | head 5`
- `source = table | stats distinct_count(c)`
- `source = table | stats stddev_samp(c)`
- `source = table | stats stddev_pop(c)`
- `source = table | stats percentile(c, 90)`
- `source = table | stats percentile_approx(c, 99)`    

Agregaciones con span

- `source = table  | stats count(a) by span(a, 10) as a_span`
- `source = table  | stats sum(age) by span(age, 5) as age_span | head 2`
- `source = table  | stats avg(age) by span(age, 20) as age_span, country  | sort - age_span |  head 2`      

Agregaciones con intervalo de tiempo (función de ventana invertida)

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

Las agregaciones se agrupan en varios niveles

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

Utilice el comando subquery para realizar consultas complejas y anidadas en sus sentencias del lenguaje de procesamiento canalizado (PPL).

source=logs | where field in [ subquery source=events | where condition | fields field ]

En este ejemplo, la búsqueda principal (source=logs) se filtra según los resultados de la subconsulta (source=events).

El comando subquery admite varios niveles de anidación para el análisis de datos complejos.

Ejemplo de subconsultas anidadas

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

Ejemplos de migración de SQL con PPL en la subconsulta

TPC-H Q4 (subconsulta interna con agregación)

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 por PPL en una consulta de subconsulta:

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 (anidado en la 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 por PPL en una consulta de subconsulta:

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

Uso de ExistsSubQuery

Supuestos :a, b son campos del exterior de la tabla c, d son campos del interior de la tabla e, f son campos del interior de la tabla2.

Uso de ScalarSubQuery

Supuestos: a b son campos del exterior de la tabla c, d son campos del interior de la tabla e, f son campos de la tabla anidados

Subconsulta escalar no correlacionada

Seleccione en:

En dónde:

Búsqueda filtrada en:

Subconsulta escalar correlacionada

Seleccione en:

En dónde:

Búsqueda filtrada en:

Subconsulta escalar anidada

(Relación) Subconsulta

InSubquery, ExistsSubquery y ScalarSubquery son todas expresiones de subconsulta. Pero RelationSubquery no es una expresión de subconsulta, es un plan de subconsulta que se usa comúnmente en las cláusulas Join o From.

Contexto adicional

InSubquery, ExistsSubquery y ScalarSubquery son expresiones de subconsulta que se utilizan habitualmente en cláusulas where y filtros de búsqueda.

Comando Where:

| where <boolean expression> | ...    

Filtro de búsqueda:

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

Se puede usar una expresión de subconsulta en una expresión booleana:

| where orders.order_id in [ source=returns | where return_reason="damaged" | field order_id ]    

El orders.order_id in [ source=... ] es un <boolean expression>.

En general, denominamos expresión InSubquery a este tipo de cláusula de subconsulta. Es una <boolean expression>.

Subconsulta con diferentes tipos de unión

Ejemplo en el que se utiliza : 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 ]      

A diferencia de InSubquery, ExistsSubQuery y ScalarSubQuery, una RelationSubQuery no es una expresión de subconsulta. En cambio, es un plan de subconsultas.

SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN left = c, right = o ON c.c_custkey = o.o_custkey
   [
      SEARCH source=orders
      | WHERE o_comment NOT LIKE '%unusual%packages%'
      | FIELDS o_orderkey, o_custkey
   ]
| STATS ...      

Comando top

Utilice el comando top para buscar la tupla de valores más común de todos los campos de la lista de campos.

Sintaxis

Utilice la siguiente sintaxis:

top [N] <field-list> [by-clause] top_approx [N] <field-list> [by-clause]

Ejemplo 1: Encuentre los valores más comunes en un campo

En el ejemplo, se busca el género más común en todas las cuentas.

Consulta PPL:

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

Ejemplo 2: busca los valores más comunes en un campo (limitado a 1)

En el ejemplo, se busca el género más común para todas las cuentas.

Consulta PPL:

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

Ejemplo 3: busca los valores más comunes agrupados por género

En el ejemplo, se busca la edad más común para todas las cuentas, agrupada por género.

Consulta PPL:

os> source=accounts | top 1 age by gender;
os> source=accounts | top_approx 1 age by gender;
fetched rows / total rows = 2/2
+----------+-------+
| gender   | age   |
|----------+-------|
| F        | 28    |
| M        | 32    |
+----------+-------+    

Comando trendline

Utilice el comando trendline para calcular los promedios móviles de los campos.

Sintaxis

Utilice la siguiente sintaxis.

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

Solo se admite el tipo de promedio móvil simple (Simple Moving Average, SMA). Se calcula de la siguiente manera:

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    

Ejemplo 1: Calcular el promedio móvil simple para una serie temporal de temperaturas

El ejemplo calcula el promedio móvil simple sobre las temperaturas utilizando dos puntos de datos.

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

Ejemplo 2: Calcular promedios móviles simples para una serie temporal de temperaturas mediante la clasificación

El ejemplo calcula dos promedios móviles simples sobre las temperaturas utilizando dos y tres puntos de datos ordenados de forma descendente por el identificador del dispositivo.

Consulta PPL:

os> source=t | trendline sort - device-id sma(2, temperature) as temp_trend_2 sma(3, temperature) as temp_trend_3;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+------------+------------------+
|temperature|device-id|           timestamp|temp_trend_2|      temp_trend_3|
+-----------+---------+--------------------+------------+------------------+
|         15|      258|2023-04-06 17:07:...|        NULL|              NULL|
|         14|      257|2023-04-06 17:07:...|        14.5|              NULL|
|         13|      256|2023-04-06 17:07:...|        13.5|              14.0|
|         12|     1492|2023-04-06 17:07:...|        12.5|              13.0|
|         12|     1492|2023-04-06 17:07:...|        12.0|12.333333333333334|
+-----------+---------+--------------------+------------+------------------+      

Comando where

El comando where utiliza una expresión booleana para filtrar el resultado de la búsqueda. Solo devuelve el resultado cuando la expresión booleana se evalúa como verdadera.

Sintaxis

Utilice la siguiente sintaxis:

where <boolean-expression>    

Ejemplo 1: filtrado de conjunto de resultados con condición

El ejemplo muestra cómo obtener documentos del índice de cuentas que cumplan condiciones 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        |
+------------------+----------+      

Ejemplos adicionales

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        

Resumen de campo

Use el comando fieldsummary para calcular las estadísticas básicas de cada campo (count, distinct count, min, max, avg, stddev, mean) y determine el tipo de datos de cada campo. Este comando se puede utilizar con cualquier barra vertical anterior y las tendrá en cuenta.

Sintaxis

Utilice la siguiente sintaxis. Para los casos de uso de Registros de CloudWatch, solo se admite un campo en una consulta.

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

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

Ejemplo 2

Consulta PPL:

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

Comando expand

Utilice el comando expand para aplanar un campo de tipo Array<Any> o Map<Any>, lo que genera filas individuales para cada elemento o par clave-valor.

Sintaxis

Utilice la siguiente sintaxis:

expand <field> [As alias]

Directrices de uso

El comando expand genera una fila para cada elemento de la matriz o campo de mapa especificado, donde:

Puede usar este comando en combinación con otros comandos, como stats, eval y parse, para manipular o extraer datos después de la expansión.

Puede usar el comando expand en combinación con otros comandos, como eval, stats y más. El uso de varios comandos de expansión creará un producto cartesiano de todos los elementos internos de cada matriz o mapa compuesto.

Consulta desplegable de SQL eficaz

El comando expand se traduce en una operación SQL equivalente mediante LATERAL VIEW explode, lo que permite la fragmentación eficiente de matrices o mapas a nivel de consulta SQL.

SELECT customer exploded_productId
FROM table
LATERAL VIEW explode(productId) AS exploded_productId

El comando explode ofrece las siguientes funciones:

Funciones PPL

Funciones de condiciones PPL

ISNULL

Descripción: isnull(field) devuelve el valor verdadero si el campo es nulo.

Ejemplo:

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

ISNOTNULL

Descripción: isnotnull(field) devuelve el valor verdadero si el campo no es nulo.

Ejemplo:

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

EXISTS

Ejemplo:

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

IFNULL

Descripción: ifnull(field1, field2) devuelve field2 si field1 es nulo.

Ejemplo:

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

Descripción: nullif(field1, field2) devuelve nulo si dos parámetros son iguales; de lo contrario, devuelve field1.

Ejemplo:

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

Descripción: if(condition, expr1, expr2) devuelve expr1 si la condición es verdadera; de lo contrario, devuelve expr2.

Ejemplo:

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

Funciones hash criptográficas PPL

MD5

MD5 calcula el resumen de MD5 y devuelve el valor en forma de cadena hexadecimal de 32 caracteres.

Uso: md5('hello')

Ejemplo:

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 devuelve el resultado de la cadena hexadecimal de SHA-1.

Uso: sha1('hello')

Ejemplo:

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 devuelve el resultado de la cadena hexadecimal de la familia de funciones hash SHA-2 (SHA-224, SHA-256, SHA-384 y SHA-512). NumBits indica la longitud de bits deseada del resultado, que debe tener un valor de 224, 256, 384, 512

Ejemplo:

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

Funciones de fecha y hora PPL

DAY

Uso: DAY(date) extrae el día del mes para una fecha, en el rango del 1 al 31.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: DAYOFMONTH, DAY_OF_MONTH

Ejemplo:

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) extrae el día del mes para una fecha, en el rango del 1 al 31.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: DAY, DAY_OF_MONTH

Ejemplo:

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) extrae el día del mes para una fecha, en el rango del 1 al 31.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: DAY, DAYOFMONTH

Ejemplo:

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) devuelve el índice de los días de la semana de una fecha (1 = domingo, 2 = lunes,..., 7 = sábado).

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: DAY_OF_WEEK

Ejemplo:

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) devuelve el índice de los días de la semana de una fecha (1 = domingo, 2 = lunes,..., 7 = sábado).

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: DAYOFWEEK

Ejemplo:

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) devuelve el día del año de una fecha, en el rango de 1 a 366.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: DAY_OF_YEAR

Ejemplo:

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) devuelve el día del año de una fecha, en el rango de 1 a 366.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: DAYOFYEAR

Ejemplo:

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) devuelve el nombre del día de la semana para una fecha, incluidos lunes, martes, miércoles, jueves, viernes, sábado y domingo.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: STRING

Ejemplo:

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 devuelve una representación del argumento dado como marca de tiempo o valor de cadena de caracteres. Esta función realiza una conversión inversa de la función UNIX_TIMESTAMP.

Si proporciona un segundo argumento, FROM_UNIXTIME lo utiliza para dar al resultado un formato similar al de la función DATE_FORMAT.

Si la marca de tiempo está fuera del intervalo 1970-01-01 00:00:00 a 3001-01-18 23:59:59.999999 (0 a 32536771199.999999 tiempo de época), la función devuelve NULL.

Tipo de argumento: DOUBLE, STRING

Mapa del tipo de devolución:

DOUBLE -> TIMESTAMP

DOUBLE, STRING -> STRING

Ejemplos:

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) extrae el valor hora del tiempo.

A diferencia de una hora del día estándar, el valor de hora de esta función puede tener un rango superior a 23. Como resultado, el valor devuelto de HOUR(TIME) puede ser superior a 23.

Tipo de argumento: STRING/TIME/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: HOUR_OF_DAY

Ejemplo:

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) extrae el valor de la hora del tiempo dado.

A diferencia de una hora del día estándar, el valor de hora de esta función puede tener un rango superior a 23. Como resultado, el valor devuelto de HOUR_OF_DAY(TIME) puede ser superior a 23.

Tipo de argumento: STRING/TIME/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: HOUR

Ejemplo:

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 devuelve el último día del mes como un valor de fecha para el argumento de fecha indicado.

Tipo de argumento: DATE/STRING/TIMESTAMP/TIME

Tipo de devolución: DATE

Ejemplo:

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() es un sinónimo de NOW().

Ejemplo:

> source=people | eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP() | fields `LOCALTIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIMESTAMP()    |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+      

LOCALTIME

Uso: LOCALTIME() es un sinónimo de NOW().

Ejemplo:

> 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 devuelve un valor de fecha basado en los valores de año, mes y día dados. Todos los argumentos se redondean a números enteros.

Especificaciones: 1. MAKE_DATE(INTEGER, INTEGER, INTEGER) -> DATE

Tipo de argumento: INTEGER, INTEGER, INTEGER

Tipo de devolución: DATE

Ejemplo:

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) devuelve el componente de minutos del tiempo dado, como un número entero en el rango de 0 a 59.

Tipo de argumento: STRING/TIME/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: MINUTE_OF_HOUR

Ejemplo:

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) devuelve el componente de minutos del tiempo dado, como un número entero en el rango de 0 a 59.

Tipo de argumento: STRING/TIME/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: MINUTE

Ejemplo:

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) devuelve el mes de la fecha dada como un entero, en el rango de 1 a 12 (donde 1 representa enero y 12 representa diciembre).

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: MONTH_OF_YEAR

Ejemplo:

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) devuelve el mes de la fecha dada como un entero, en el rango de 1 a 12 (donde 1 representa enero y 12 representa diciembre).

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: MONTH_OF_YEAR

Ejemplo:

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) devuelve el mes de la fecha dada como un entero, en el rango de 1 a 12 (donde 1 representa enero y 12 representa diciembre).

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: MONTH

Ejemplo:

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 devuelve la fecha y la hora actuales como un valor TIMESTAMP en el formato 'YYYY-MM-DD hh:mm:ss' . El valor se expresa en la zona horaria del clúster.

Tipo de devolución: TIMESTAMP

Especificación: NOW () -> TIMESTAMP

Ejemplo:

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) devuelve el trimestre del año de la fecha dada como un entero, en el rango de 1 a 4.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Ejemplo:

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) devuelve el segundo componente del tiempo dado como un entero, en el rango de 0 a 59.

Tipo de argumento: STRING/TIME/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: SECOND_OF_MINUTE

Ejemplo:

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) devuelve el segundo componente del tiempo dado como un entero, en el rango de 0 a 59.

Tipo de argumento: STRING/TIME/TIMESTAMP

Tipo de devolución: INTEGER

Sinónimos: SECOND

Ejemplo:

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) resta el segundo argumento (como DATE o DAYS) de la fecha dada.

Tipo de argumento: DATE/TIMESTAMP, LONG

Mapa de tipos de devolución: (DATE, LONG) -> DATE

Antónimos: ADDDATE

Ejemplo:

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() devuelve la fecha y la hora actuales como un valor TIMESTAMP en el formato 'YYYY-MM-DD hh:mm:ss.nnnnnn'.

SYSDATE() devuelve la hora exacta en la que se ejecuta. Esto difiere de NOW(), que devuelve un tiempo constante que indica cuándo comenzó a ejecutarse la sentencia.

Tipo de argumento opcional: INTEGER (0 a 6): especifica el número de dígitos para las fracciones de segundo del valor devuelto.

Tipo de devolución: TIMESTAMP

Ejemplo:

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) construye un tipo de marca de tiempo con la cadena expr de entrada como marca de tiempo.

Con un solo argumento, TIMESTAMP(expr) construye una marca de tiempo a partir de la entrada. Si expr es una cadena, se interpreta como una marca de tiempo. Para los argumentos que no son cadenas, la función convierte expr en una marca de tiempo utilizando la zona horaria UTC. Cuando expr es un valor TIME, la función aplica la fecha de hoy antes de la conversión.

Cuando se usa con dos argumentos, TIMESTAMP(expr1, expr2) agrega la expresión de hora (expr2) a la expresión de fecha o marca de tiempo (expr1) y devuelve el resultado como un valor de marca de tiempo.

Tipo de argumento: STRING/DATE/TIME/TIMESTAMP

Mapa del tipo de devolución:

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

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

Ejemplo:

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 convierte un argumento de fecha determinado a la hora de Unix (segundos desde la Época, que comenzó a principios de 1970). Si no se proporciona ningún argumento, devuelve la hora actual de Unix.

El argumento de fecha puede ser un DATE, una cadena TIMESTAMP o un número en uno de estos formatos: YYMMDD, YYMMDDhhmmss, YYYYMMDD, o YYYYMMDDhhmmss. Si el argumento incluye un componente de tiempo, puede incluir opcionalmente fracciones de segundo.

Si el formato del argumento no es válido o se encuentra fuera del intervalo comprendido entre 1970-01-01 00:00:00 a 3001-01-18 23:59:59.999999 (0 a 32536771199.999999 en tiempo de época), la función devuelve NULL.

La función acepta DATE, TIMESTAMP, o DOUBLE como tipos de argumentos o no acepta ningún argumento. Siempre devuelve un valor DOUBLE que representa la marca de tiempo de Unix.

Para la conversión inversa, puede utilizar la función FROM_UNIXTIME.

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

Tipo de devolución: DOUBLE

Ejemplo:

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) devuelve el número de semana de una fecha determinada.

Tipo de argumento: DATE/TIMESTAMP/STRING

Tipo de devolución: INTEGER

Sinónimos: WEEK_OF_YEAR

Ejemplo:

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) devuelve el índice del día de la semana correspondiente a la fecha (0 = lunes, 1 = martes,..., 6 = domingo).

Es similar a la función dayofweek, pero devuelve índices diferentes para cada día.

Tipo de argumento: STRING/DATE/TIME/TIMESTAMP

Tipo de devolución: INTEGER

Ejemplo:

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) devuelve el número de la semana de la fecha indicada.

Tipo de argumento: DATE/TIMESTAMP/STRING

Tipo de devolución: INTEGER

Sinónimos: WEEK

Ejemplo:

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) devuelve el año para la fecha, en el rango de 1000 a 9999, o 0 para la fecha “zero”.

Tipo de argumento: STRING/DATE/TIMESTAMP

Tipo de devolución: INTEGER

Ejemplo:

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) agrega el intervalo especificado a la fecha dada.

Tipo de argumento: DATE, INTERVAL

Tipo de devolución: DATE

Antónimos: DATE_SUB

Ejemplo:

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) resta el intervalo de expiración de la fecha.

Tipo de argumento: DATE, INTERVAL

Tipo de devolución: DATE

Antónimos: DATE_ADD

Ejemplo:

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: devuelve un valor TIMESTAMP después de agregar un intervalo de tiempo específico a una fecha determinada.

Argumentos:

Si proporciona un argumento de fecha STRING, formatéelo como válido TIMESTAMP. La función convierte automáticamente un argumento DATE en un TIMESTAMP.

Ejemplos:

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) devuelve la diferencia entre la fecha/hora de inicio y finalización en unidades de intervalo especificadas.

Argumentos:

La función convierte automáticamente los argumentos TIMESTAMP cuando sea apropiado. Formatee los argumentos STRING como válidos TIMESTAMP.

Ejemplos:

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 devuelve la marca de tiempo UTC actual como un valor en 'YYYY-MM-DD hh:mm:ss'.

Tipo de devolución: TIMESTAMP

Especificación: UTC_TIMESTAMP() -> TIMESTAMP

Ejemplo:

> 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 devuelve la zona horaria local actual.

Tipo de devolución: STRING

Ejemplo:

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

Expresiones PPL

Las expresiones, en particular las expresiones de valores, devuelven un valor escalar. Las expresiones tienen distintos tipos y formas. Por ejemplo, hay valores literales como expresiones atómicas y expresiones aritméticas, de predicados y de funciones construidas sobre ellos. Puede utilizar expresiones en distintas cláusulas, como las expresiones aritméticas en los comandos Filter y Stats.

Operadores

Una expresión aritmética es una expresión formada por literales numéricos y operadores aritméticos binarios, de la siguiente manera:

Prioridad

Use paréntesis para controlar la precedencia de los operadores aritméticos. De lo contrario, los operadores de mayor prioridad se ejecutan primero.

Conversión de tipos

La conversión de tipos implícita se realiza al buscar las firmas de los operadores. Por ejemplo, en un entero + un número real coincide con la firma +(double,double), lo que da como resultado un número real. Esta regla también se aplica a las llamadas de funciones.

Ejemplo de diferentes tipos de expresiones aritméticas:

os> source=accounts | where age > (25 + 5) | fields age ;
fetched rows / total rows = 3/3
+-------+
| age   |
|-------|
| 32    |
| 36    |
| 33    |
+-------+

Operadores de predicados

Un operador de predicado es una expresión que se evalúa como verdadera. La comparación entre el valor MISSING y el valor NULL sigue estas reglas:

Operadores

Puede comparar fechas y horas. Al comparar diferentes tipos de fecha y hora (por ejemplo, DATE y TIME), ambos se convierten en DATETIME. Las siguientes reglas se aplican para la conversión:

Operador de predicado básico

Ejemplo de operadores de comparación:

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

IN

Ejemplo del campo de prueba IN del operador en las listas de valores:

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

OR

Ejemplo del operador OR:

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

NOT

Ejemplo del operador NOT:

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

Funciones PPL de dirección IP

CIDRMATCH

Uso: CIDRMATCH(ip, cidr) comprueba si la dirección IP especificada está dentro del rango de cidr dado.

Tipo de argumento:

Ejemplo:

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

Nuevas funciones PPL JSON

JSON

Uso: json(value) evalúa si una cadena se puede analizar en formato JSON. La función devuelve la cadena original si es un JSON válido o nula si no es válido.

Tipo de argumento: STRING

Tipo de devolución: STRING/NULL. Una expresión STRING de un formato de objeto JSON válido.

Ejemplos:

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>]...) devuelve un objeto JSON de los miembros de pares clave-valor.

Tipo de argumento:

Tipo de devolución: JSON_OBJECT. Una expresión StructType de un objeto JSON válido.

Ejemplos:

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>...) crea una matriz JSON usando una lista de valores.

Tipo de argumento: un <value> puede ser cualquier tipo de valor, como una cadena, un número o un booleano.

Tipo de devolución: ARRAY. Una matriz de cualquier tipo de datos compatible para una matriz JSON válida.

Ejemplos:

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) devuelve una cadena JSON con un valor de objeto json determinado.

Tipo de argumento: JSON_OBJECT

Tipo de devolución: STRING

Ejemplos:

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) devuelve la cantidad de elementos en la matriz exterior.

Tipo de argumento: ARRAY. Un objeto ARRAY o JSON_ARRAY.

Tipo de devolución: INTEGER

Ejemplo:

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) extrae un objeto JSON de una cadena JSON en función de la ruta JSON especificada. La función devuelve un valor nulo si la cadena JSON de entrada no es válida.

Tipo de argumento: STRING, STRING

Tipo de devolución: STRING

Ejemplos:

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) devuelve todas las claves del objeto JSON más externo como una matriz.

Tipo de argumento: STRING. Una expresión STRING de un formato de objeto JSON válido.

Tipo de devolución: ARRAY[STRING]. La función devuelve NULL para cualquier otra cadena JSON válida, una cadena vacía o un JSON no válido.

Ejemplos:

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) evalúa si una cadena JSON usa una sintaxis JSON válida y devuelve TRUE o FALSE.

Tipo de argumento: STRING

Tipo de devolución: BOOLEAN

Ejemplos:

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

Funciones de Lambda PPL

EXISTS

Uso: exists(array, lambda) evalúa si un predicado de Lambda es válido para uno o más elementos de la matriz.

Tipo de argumento: ARRAY, LAMBDA

Tipo de devolución: BOOLEAN. Devuelve TRUE si al menos un elemento de la matriz satisface el predicado Lambda; en caso contrario FALSE.

Ejemplos:

 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 la matriz de entrada utilizando la función de Lambda dada.

Tipo de argumento: ARRAY, LAMBDA

Tipo de devolución: ARRAY. Un ARRAY que contiene todos los elementos de la matriz de entrada que satisfacen el predicado lambda.

Ejemplos:

 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 los elementos de una matriz mediante la función de transformación de Lambda. El segundo argumento implica el índice del elemento si se utiliza la función de Lambda binaria. Esto es similar a lo que ocurre a map en la programación funcional.

Tipo de argumento: ARRAY, LAMBDA

Tipo de devolución: ARRAY. Un ARRAY que contiene el resultado de aplicar la función de transformación de Lambda a cada elemento de la matriz de entrada.

Ejemplos:

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) reduce una matriz a un único valor mediante la aplicación de funciones de Lambda. La función aplica la combinación merge_lambda al valor inicial y a todos los elementos de la matriz y, a continuación, la aplica al resultado finish_lambda.

Tipo de argumento: ARRAY, ANY, LAMBDA, LAMBDA

Tipo de devolución: ANY. El resultado final de aplicar las funciones de Lambda al valor inicial y a la matriz de entrada.

Ejemplos:

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

Funciones matemáticas PPL

ABS

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

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: INTEGER/LONG/FLOAT/DOUBLE

Ejemplo:

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 el arco coseno de x. Retorna NULL si x no está en el rango de -1 a 1.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 el arco sinusoidal de x. Retorna NULL si x no está en el rango de -1 a 1.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 el arco tangente de x. atan(y, x) Calcula el arco tangente de y/x, excepto que los signos de ambos argumentos determinan el cuadrante del resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 el arco tangente de y/x, excepto que los signos de ambos argumentos determinan el cuadrante del resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 la raíz cuadrada de un número.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE:

INTEGER/LONG/FLOAT/DOUBLE -> DOUBLE

Ejemplo:

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: Un alias para la función CEILING. CEILING(T) toma el límite máximo del valor T.

Limitación: CEILING solo funciona según lo esperado cuando el tipo doble IEEE 754 muestra un decimal al guardarlo.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: LONG

Ejemplo:

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) convierte el número x de base a a una base b.

Tipo de argumento: x: STRING, a: INTEGER, b: INTEGER

Tipo de devolución: STRING

Ejemplo:

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 el coseno de x, donde x se expresa en radianes.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 la cotangente de x. Devuelve un error de fuera de intervalo si x es igual a 0.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 un valor de comprobación de redundancia cíclica y devuelve un valor sin signo de 32 bits.

Tipo de argumento: STRING

Tipo de devolución: LONG

Ejemplo:

os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')`
fetched rows / total rows = 1/1
+------------------+
| CRC32('MySQL')   |
|------------------|
| 3259397556       |
+------------------+ 

DEGREES

Uso: DEGREES(x) convierte x de radianes a grados.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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() devuelve el número de Euler.

Tipo de devolución: DOUBLE

Ejemplo:

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

EXP

Uso: EXP(x) devuelve e elevado a x.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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) toma el mínimo del valor T.

Limitación: FLOOR solo funciona según lo esperado cuando el tipo doble IEEE 754 muestra un decimal cuando se almacena.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: LONG

Ejemplo:

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) devuelve el logaritmo natural de x.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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) devuelve el logaritmo natural de x que es el logaritmo en base e de x. log(B, x) es equivalente a log(x)/log(B).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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) equivale a log(x)/log(2).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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) equivale a log(x)/log(10).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 el resto del número n dividido por m.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: Tipo más amplio entre los tipos de n y m si m es un valor distinto de cero. Si m es igual a 0, devuelve NULL.

Ejemplo:

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() devuelve la constante pi.

Tipo de devolución: DOUBLE

Ejemplo:

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

POW

Uso: POW(x, y) calcula el valor de x elevado a la potencia de y. Las entradas incorrectas devuelven un resultado NULL.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Sinónimos: POWER(_, _)

Ejemplo:

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 el valor de x elevado a la potencia de y. Las entradas incorrectas devuelven un resultado NULL.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Sinónimos: POW(_, _)

Ejemplo:

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) convierte x de grados a radianes.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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) devuelve un valor de punto flotante aleatorio en el rango 0 <= value < 1,0. Si especifica el entero N, la función inicializa la semilla antes de la ejecución. Una consecuencia de este comportamiento es que, con un argumento N idéntico, rand(N) devuelve el mismo valor cada vez, lo que produce una secuencia repetible de valores de columna.

Tipo de argumento: INTEGER

Tipo de devolución: FLOAT

Ejemplo:

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) redondea el argumento de x a d decimales. Si no especifica d, el valor predeterminado es 0.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Mapa del tipo de devolución:

Ejemplo:

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 devuelve el signo del argumento como -1, 0 o 1, dependiendo de si el número es negativo, cero o positivo.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: INTEGER

Ejemplo:

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 el seno de x, donde x se expresa en radianes.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolución: DOUBLE

Ejemplo:

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 la raíz cuadrada de un número no negativo.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Mapa del tipo de devolución:

Ejemplo:

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

Funciones de cadena PPL

CONCAT

Uso: CONCAT(str1, str2, ...., str_9) suma hasta 9 cadenas.

Tipo de argumento:

Ejemplo:

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 dos o más cadenas utilizando un separador específico entre ellas.

Tipo de argumento:

Ejemplo:

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) devuelve la longitud de la cadena de entrada medida en bytes.

Tipo de argumento:

Ejemplo:

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

LOWER

Uso: lower(string) convierte la cadena de caracteres en minúsculas.

Tipo de argumento:

Ejemplo:

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) elimina los espacios iniciales de la cadena de entrada.

Tipo de argumento:

Ejemplo:

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) devuelve la posición de la primera aparición de la subcadena en la cadena. Devuelve 0 si no se encuentra la subcadena dentro de la cadena. Devuelve un valor NULL si cualquier argumento de entrada es NULL.

Tipo de argumento:

Ejemplo:

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) devuelve la cadena invertida de la cadena de entrada.

Tipo de argumento:

Ejemplo:

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) devuelve los caracteres situados más a la derecha de la cadena de entrada. Devuelve 0 si no se encuentra la subcadena dentro de la cadena. Devuelve un valor NULL si cualquier argumento de entrada es NULL.

Tipo de argumento:

Ejemplo:

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) recorta los espacios finales de la cadena de entrada.

Tipo de argumento:

Ejemplo:

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) o substring(str, start, length) devuelve una subcadena de la cadena de entrada. Sin especificar la longitud, devuelve la cadena completa desde la posición inicial.

Tipo de argumento:

Ejemplo:

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) elimina los espacios en blanco iniciales y finales de la cadena de entrada.

Tipo de argumento:

Ejemplo:

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) convierte la cadena de entrada en mayúsculas.

Tipo de argumento:

Ejemplo:

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

Función de conversión de tipos PPL

TRIM

Uso: cast(expr as dateType) convierte el valor expr en dataType y devuelve el valor del dataType.

Se aplican las siguientes reglas de conversión:

Ejemplo de conversión a cadena:

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

Ejemplo de conversión a número:

os> source=people | eval `cbool` = CAST(true as int), `cstring` = CAST('1' as int) | fields `cbool`, `cstring`
fetched rows / total rows = 1/1
+---------+-----------+
| cbool   | cstring   |
|---------+-----------|
| 1       | 1         |
+---------+-----------+

Ejemplo de conversión a fecha:

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

Ejemplo de conversión a encadenado:

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