Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Comandos compatibles PPL
Las siguientes tablas muestran qué comandos de PPL admite OpenSearch Dashboards para consultar CloudWatch Logs, Amazon S3 o Security Lake, y qué comandos admite CloudWatch Logs Insights. CloudWatch Logs Insights utiliza la misma sintaxis de PPL que los OpenSearch paneles cuando consulta los CloudWatch registros, y en las tablas se hace referencia a ambos como registros. CloudWatch
**nota**
Al analizar datos fuera del OpenSearch Servicio, es posible que los comandos se ejecuten de forma diferente a como lo hacen en los índices. OpenSearch
**Topics**
+ [Comandos](#supported-ppl-commands)
+ [Funciones](#supported-ppl-functions)
+ [Información adicional para CloudWatch los usuarios de Logs Insights que utilizan OpenSearch PPL](#supported-ppl-for-cloudwatch-users)
## Comandos
| Comando PPL | Description (Descripción) | CloudWatch Registros | Amazon S3 | Security Lake | Comando de ejemplo: |
| --- | --- | --- | --- | --- | --- |
| [Comando fields](#supported-ppl-fields-command) | Muestra un conjunto de campos que necesitan ser proyectados. |  compatible |  compatible |  compatible | fields field1, field2
|
| [Comando where](#supported-ppl-where-command) | Filtra los datos en función de las condiciones que especifique. |  compatible |  compatible |  compatible | where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000
|
| [Comandos stats](#supported-ppl-stats-command) | Realiza agregaciones y cálculos. |  compatible |  compatible |  compatible | stats count(),
count(`field1`),
min(`field1`),
max(`field1`),
avg(`field1`)
by field2
| head 1000
|
| [Comando parse](#supported-ppl-parse-command) | Extrae un patrón de expresión regular (regex) de una cadena y muestra el patrón extraído. El patrón extraído se puede utilizar además para crear nuevos campos o filtrar datos. |  compatible |  compatible |  compatible | parse `field1` ".*/(?[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000
|
| [Comando patterns](#supported-ppl-patterns-command) | 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. |  no compatible |  compatible |  compatible | patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers
|
| [Comando sort](#supported-ppl-sort-command) | Ordena los resultados mostrados por un nombre de campo. Use **ordenar: *FieldName***para ordenar en orden descendente. |  compatible |  compatible |  compatible | stats count(),
count(`field1`),
min(`field1`) as field1Alias,
max(`field1`),
avg(`field1`)
by field2
| sort -field1Alias
| head 1000
|
| [Comando eval](#supported-ppl-eval-command) | Modifica o procesa el valor de un campo y lo almacena en un campo diferente. Esto resulta útil para modificar matemáticamente una columna, aplicar funciones de cadena a una columna o aplicar funciones de fecha a una columna. |  compatible |  compatible |  compatible | eval field2 = `field1` * 2
| fields field1, field2
| head 20
|
| [Comando rename](#supported-ppl-rename-command) | Cambia el nombre de uno o más campos del resultado de la búsqueda. |  compatible |  compatible |  compatible | rename field2 as field1
| fields field1
|
| [Comando head](#supported-ppl-head-command) | Limita los resultados de la consulta a las N primeras filas. |  compatible |  compatible |  compatible | fields `@message`
| head 20
|
| [Comando grok](#supported-ppl-grok-command) | Analiza un campo de texto con un patrón grok basado en una expresión regular y agrega los resultados al resultado de la búsqueda. |  compatible |  compatible |  compatible | grok email '.+@%{HOSTNAME:host}'
| fields email |
| [Comando top](#supported-ppl-top-command) | Busca los valores más frecuentes de un campo. |  compatible |  compatible |  compatible | top 2 Field1 by Field2
|
| [dedup command](#supported-ppl-dedup-command) | Elimina entradas duplicadas en función de los campos que especifique. |  compatible |  compatible |  compatible | dedup field1
| fields field1, field2, field3
|
| [Comando join](#supported-ppl-join-commands) | Une dos conjuntos de datos. |  compatible |  compatible |  compatible | source=customer
| join ON c_custkey = o_custkey orders
| head 10
|
| [Comando lookup](#supported-ppl-lookup-commands) | Enriquece los datos de búsqueda mediante la adición o sustitución de datos de un índice de búsqueda (tabla de dimensiones). Puede ampliar los campos de un índice con valores de una tabla de dimensiones, agregar o reemplazar valores cuando se cumpla la condición de búsqueda. |  no compatible |  compatible |  compatible | where orderType = 'Cancelled'
| lookup account_list, mkt_id AS mkt_code
replace amount, account_name as name
| stats count(mkt_code), avg(amount)
by name
|
| [Comando subquery](#supported-ppl-subquery-commands) | Realiza consultas anidadas y complejas en sus instrucciones de lenguaje de procesamiento de canalizaciones (PPL). |  compatible |  compatible |  compatible | where id in [
subquery source=users
| where user in [
subquery source=actions
| where action="login"
| fields user
]
| fields uid
]
|
| [Comando rare](#supported-ppl-rare-command) | Busca los valores menos frecuentes de todos los campos de la lista de campos. |  compatible |  compatible |  compatible | rare Field1 by Field2
|
| [Comando trendline](#supported-ppl-trendline-commands) | Calcula los promedios móviles de los campos. |  compatible |  compatible |  compatible | trendline sma(2, field1) as field1Alias
|
| [comando eventstats](#supported-ppl-eventstats-command) | Enriquece los datos del evento con estadísticas resumidas calculadas. Analiza los campos específicos de sus eventos, calcula varias medidas estadísticas y, a continuación, agrega estos resultados a cada evento original como campos nuevos. |  compatible (excepto `count()`) |  compatible |  compatible | eventstats sum(field1) by field2
|
| [Comando flatten](#supported-ppl-flatten-command) | Aplana un campo. El campo debe ser de este tipo: `struct or array>` |  compatible |  compatible |  compatible | source=table | flatten field1
|
| [Resumen de campo](#supported-ppl-field-summary-command) | Calcula las estadísticas básicas de cada campo (recuento, recuento distinto, mínimo, máximo, promedio, stddev y media). |  Compatible (un campo por consulta) |  compatible |  compatible | where field1 != 200
| fieldsummary includefields=field1 nulls=true
|
| [Comando fillnull](#supported-ppl-fillnull-command) | Rellena los campos nulos con el valor que proporcione. Se puede usar en uno o más campos. |  compatible |  compatible |  compatible | fields field1
| eval field2=field1
| fillnull value=0 field1
|
| [Comando expand](#supported-ppl-expand-command) | Divide un campo que contiene varios valores en filas independientes, creando una nueva fila para cada valor del campo especificado. |  compatible |  compatible |  compatible | expand employee
| stats max(salary) as max
by state, company
|
| [Comando describe](#supported-ppl-describe-command) | Obtiene información detallada sobre la estructura y los metadatos de las tablas, los esquemas y los catálogos |  no compatible |  compatible |  compatible | describe schema.table
|
## Funciones
| Función PPL | Description (Descripción) | CloudWatch Registros | Amazon S3 | Security Lake | Comando de ejemplo: |
| --- | --- | --- | --- | --- | --- |
| [Funciones de cadena PPL](#supported-ppl-string-functions)
(`CONCAT`, `CONCAT_WS`, `LENGTH`, `LOWER`, `LTRIM`, `POSITION`, `REVERSE`, `RIGHT`, `RTRIM`, `SUBSTRING`, `TRIM`, `UPPER`) | Funciones integradas en PPL que pueden manipular y transformar datos de texto y cadenas de texto dentro de las consultas de PPL. Por ejemplo, convertir mayúsculas y minúsculas, combinar cadenas, extraer partes y limpiar el texto. |  compatible |  compatible |  compatible | eval col1Len = LENGTH(col1)
| fields col1Len
|
| [Funciones de fecha y hora PPL](#supported-ppl-date-time-functions)
(`DAY`, `DAYOFMONTH`, `DAY_OF_MONTH`,`DAYOFWEEK`, `DAY_OF_WEEK`, `DAYOFYEAR`, `DAY_OF_YEAR`, `DAYNAME`, `FROM_UNIXTIME`, `HOUR`, `HOUR_OF_DAY`, `LAST_DAY`, `LOCALTIMESTAMP`, `LOCALTIME`, `MAKE_DATE`, `MINUTE`, `MINUTE_OF_HOUR`, `MONTH`, `MONTHNAME`, `MONTH_OF_YEAR`, `NOW`, `QUARTER`, `SECOND`, `SECOND_OF_MINUTE`, `SUBDATE`, `SYSDATE`, `TIMESTAMP`, `UNIX_TIMESTAMP`, `WEEK`, `WEEKDAY`, `WEEK_OF_YEAR`, `DATE_ADD`, `DATE_SUB`, `TIMESTAMPADD`, `TIMESTAMPDIFF`, `UTC_TIMESTAMP`, `CURRENT_TIMEZONE`) | Funciones integradas para administrar y transformar los datos de fecha y hora en las consultas PPL. Por ejemplo, **date\_add**, **date\_format**, **datediff** y **current\_date**. |  compatible |  compatible |  compatible | eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate |
| [Funciones de condiciones PPL](#supported-ppl-condition-functions)
(`EXISTS`, `IF`, `IFNULL`, `ISNOTNULL`, `ISNULL`, `NULLIF`) | Funciones integradas que realizan cálculos en varias filas para generar un único valor resumido. Por ejemplo, **sum**, **count**, **avg**, **max** y **min**. |  compatible |  compatible |  compatible | eval field2 = isnull(col1)
| fields field2, col1, field3
|
| [Funciones matemáticas PPL](#supported-ppl-math-functions)
(`ABS`, `ACOS`, `ASIN`, `ATAN`, `ATAN2`, `CEIL`, `CEILING`, `CONV`, `COS`, `COT`, `CRC32`, `DEGREES`, `E`, `EXP`, `FLOOR`, `LN`, `LOG`, `LOG2`, `LOG10`, `MOD`, `PI`. `POW`, `POWER`, `RADIANS`, `RAND`, `ROUND`, `SIGN`, `SIN`, `SQRT`, `CBRT`) | Funciones integradas para realizar cálculos matemáticos y transformaciones en consultas PPL. Por ejemplo: **abs** (valor absoluto), **round** (redondea números), **sqrt** (raíz cuadrada), **pow** (cálculo de potencia) y **ceil** (redondea al entero más cercano). |  compatible |  compatible |  compatible | eval field2 = ACOS(col1)
| fields col1
|
| [Expresiones PPL](#supported-ppl-expressions)
(Operadores aritméticos (`+`, `-`, `*`), operadores de predicados (`>. <`, `IN)`) | Las funciones integradas para las expresiones, en particular las expresiones de valores, devuelven un valor escalar. Las expresiones tienen distintos tipos y formas. |  compatible |  compatible |  compatible | where age > (25 + 5)
| fields age
|
| [Funciones PPL de dirección IP](#supported-ppl-ip-address-functions)
(`CIDRMATCH`) | Funciones integradas para administrar direcciones IP, como el CIDR. |  compatible |  compatible |  compatible | where cidrmatch(ip, '***********/24')
| fields ip
|
| [Nuevas funciones PPL JSON](#supported-ppl-json-functions)
(`ARRAY_LENGTH`, `ARRAY_LENGTH`, `JSON`, `JSON_ARRAY`, `JSON_EXTRACT`, `JSON_KEYS`, `JSON_OBJECT`, `JSON_VALID`, `TO_JSON_STRING`) | Funciones integradas para el manejo de JSON, incluidas las matrices, la extracción y la validación. |  compatible |  compatible |  compatible | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a') |
| [Funciones de Lambda PPL](#supported-ppl-lambda-functions)
(`EXISTS`, `FILTER`, `REDUCE`, `TRANSFORM`) | Funciones integradas para el manejo de JSON, incluidas las matrices, la extracción y la validación. |  no compatible |  compatible |  compatible | eval array = json_array(1, -1, 2),
result = filter(array, x -> x > 0)
| fields result
|
| [Funciones hash criptográficas PPL](#supported-ppl-cryptographic-functions)
(`MD5`, `SHA1`, `SHA2`) | Funciones integradas que le permiten generar huellas dactilares únicas de los datos, que se pueden utilizar para la verificación, la comparación o como parte de protocolos de seguridad más complejos. |  compatible |  compatible |  compatible | eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')` |
## Información adicional para CloudWatch los usuarios de Logs Insights que utilizan OpenSearch PPL
Aunque CloudWatch Logs Insights admite la mayoría de los comandos y funciones de OpenSearch PPL, algunos comandos y funciones no lo son actualmente. Por ejemplo, actualmente no admite los comandos de búsqueda en PPL. A partir del 2 de junio de 2025, CloudWatch Logs Insights ahora admite las funciones JOIN, subqueries, Flatten, Fillnull, Expand, Cidrmatch y JSON en PPL. Para obtener una lista completa de los comandos y funciones de consulta compatibles, consulta las columnas de Amazon CloudWatch Logs en las tablas anteriores.
### Consultas y cuotas de ejemplo
Lo siguiente se aplica tanto a los usuarios de CloudWatch Logs Insights como a los OpenSearch usuarios que consultan CloudWatch datos.
Para obtener información sobre los límites que se aplican al consultar CloudWatch los registros del OpenSearch servicio, consulte [las cuotas de CloudWatch registros](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) en la Guía del usuario de Amazon CloudWatch Logs. Los límites se refieren al número de grupos de CloudWatch registros 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 CloudWatch los registros (es decir, OpenSearch PPL, SQL y Logs Insights QL).
### Comandos PPL
**Topics**
+ [comentario](#supported-ppl-comment)
+ [Comando de correlación](#supported-ppl-correlation-commands)
+ [dedup command](#supported-ppl-dedup-command)
+ [Comando describe](#supported-ppl-describe-command)
+ [Comando eval](#supported-ppl-eval-command)
+ [comando eventstats](#supported-ppl-eventstats-command)
+ [Comando expand](#supported-ppl-expand-commands)
+ [Comando explain](#supported-ppl-explain-command)
+ [Comando fillnull](#supported-ppl-fillnull-command)
+ [Comando fields](#supported-ppl-fields-command)
+ [Comando flatten](#supported-ppl-flatten-command)
+ [Comando grok](#supported-ppl-grok-command)
+ [Comando head](#supported-ppl-head-command)
+ [Comando join](#supported-ppl-join-commands)
+ [Comando lookup](#supported-ppl-lookup-commands)
+ [Comando parse](#supported-ppl-parse-command)
+ [Comando patterns](#supported-ppl-patterns-command)
+ [Comando rare](#supported-ppl-rare-command)
+ [Comando rename](#supported-ppl-rename-command)
+ [Comando search](#supported-ppl-search-command)
+ [Comando sort](#supported-ppl-sort-command)
+ [Comandos stats](#supported-ppl-stats-command)
+ [Comando subquery](#supported-ppl-subquery-commands)
+ [Comando top](#supported-ppl-top-command)
+ [Comando trendline](#supported-ppl-trendline-commands)
+ [Comando where](#supported-ppl-where-command)
+ [Resumen de campo](#supported-ppl-field-summary-command)
+ [Comando expand](#supported-ppl-expand-command)
+ [Funciones PPL](#supported-ppl-functions-details)
#### comentario
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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:
+ Registros
+ Métricas
+ Rastros
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:
+ **IP**: `"ip": "10.0.0.1" | "ip": "**************"`
+ **Puerto**: `"port": 2817 | "target_port": "10.0.0.1:80"`
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 los puntos `traceId` y los http client/server `ip` que se pueden correlacionar con los registros del 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:
1. `source alb_logs, traces`: esto selecciona los orígenes de datos que desea correlacionar.
1. `where ip="10.0.0.1" AND cloud.provider="aws"`: esto reduce el alcance de la búsqueda.
1. `correlate exact fields(traceId, ip)`: esto le indica al sistema que correlacione los datos en función de las coincidencias exactas de los siguientes campos:
+ El campo `ip` tiene una condición de filtro explícita, por lo que se utilizará en la correlación de todas los orígenes de datos.
+ El campo `traceId` no tiene un filtro explícito, por lo que coincidirá con los mismos traceId en todas las orígenes de datos.
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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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] [keepempty=] [consecutive=]
```
**`int`**
+ Opcional.
+ El comando `dedup` conserva varios eventos para cada combinación cuando se especifica . El número para debe ser mayor que 0. Si no especifica un número, solo se conservara el primer evento que se produzca. Todos los demás duplicados se eliminan de los resultados.
+ Valor predeterminado: 1
**`keepempty`**
+ Opcional.
+ Si es verdadero, mantiene los documentos en los que algún campo de la lista de campos tenga un valor NULL o MISSING.
+ Predeterminado: false
**`consecutive`**
+ Opcional.
+ Si es verdadero, elimina solo los eventos con combinaciones de valores duplicados consecutivas.
+ Predeterminado: false
**`field-list`**
+ Obligatorio.
+ Una lista de campos delimitada por comas. Se requiere como mínimo un campo de metadatos.
**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 |
+------------------+----------+
```
**Ejemplos adicionales**
+ `source = table | dedup a | fields a,b,c`
+ `source = table | dedup a,b | fields a,b,c`
+ `source = table | dedup a keepempty=true | fields a,b,c`
+ `source = table | dedup a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a | fields a,b,c`
+ `source = table | dedup 1 a,b | fields a,b,c`
+ `source = table | dedup 1 a keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a | fields a,b,c`
+ `source = table | dedup 2 a,b | fields a,b,c`
+ `source = table | dedup 2 a keepempty=true | fields a,b,c`
+ `source = table | dedup 2 a,b keepempty=true | fields a,b,c`
+ `source = table | dedup 1 a consecutive=true| fields a,b,c` (no se admite la deduplicación consecutiva)
**Limitación**
+ En `| dedup 2 a, b keepempty=false`
```
DataFrameDropColumns('_row_number_)
+- Filter ('_row_number_ <= 2) // allowed duplication = 2
+- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
+- Filter (isnotnull('a) AND isnotnull('b)) // keepempty=false
+- Project
+- UnresolvedRelation
```
+ En `| dedup 2 a, b keepempty=true`
```
Union
:- DataFrameDropColumns('_row_number_)
: +- Filter ('_row_number_ <= 2)
: +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
: +- Filter (isnotnull('a) AND isnotnull('b))
: +- Project
: +- UnresolvedRelation
+- Filter (isnull('a) OR isnull('b))
+- Project
+- UnresolvedRelation
```
#### Comando describe
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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`.
**Describir**
+ `describe table` Este comando es igual al comando `DESCRIBE EXTENDED table` de SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
#### Comando eval
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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`: obligatorio. Si el nombre de campo no existe, se agrega un campo nuevo. Si el nombre de campo ya existe, se sobrescribirá.
+ `expression`: obligatorio. Cualquier expresión admitida por el sistema.
**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`
**Ejemplos adicionales**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1` (campos de salida a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**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`
**Ejemplos adicionales**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1` (campos de salida a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval f = a in ('foo', 'bar') | fields f`
+ `source = table | eval f = a not in ('foo', 'bar') | fields f`
**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
```
**Limitaciones**
+ No se admite el anular los campos existentes. Las consultas que lo intenten generarán excepciones con el mensaje “La referencia 'a' es ambigua”.
```
- `source = table | eval a = 10 | fields a,b,c`
- `source = table | eval a = a * 2 | stats avg(a)`
- `source = table | eval a = abs(a) | where a > 0`
- `source = table | eval a = signum(a) | where a < 0`
```
#### comando eventstats
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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.
**Aspectos clave de eventstats**
1. Realiza cálculos en todo el conjunto de resultados o dentro de grupos definidos.
1. Los eventos originales permanecen intactos y se agregan nuevos campos para contener los resultados estadísticos.
1. El comando es particularmente útil para realizar análisis comparativos, identificar valores atípicos o proporcionar contexto adicional a eventos individuales.
**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.
**Formato de salida**
+ `stats`: produce una tabla de resumen con solo las estadísticas calculadas.
+ `eventstats`: agrega las estadísticas calculadas como campos nuevos a los eventos existentes y conserva los datos originales.
**Retención de eventos**
+ `stats`: reduce el conjunto de resultados a solo un resumen estadístico y descarta los eventos individuales.
+ `eventstats`: retiene todos los eventos originales y agrega nuevos campos con las estadísticas calculadas.
**Casos de uso**
+ `stats`: ideal para crear paneles o informes resumidos. Suele utilizarse como comando final para resumir los resultados.
+ `eventstats`: útil cuando se necesita enriquecer los eventos con un contexto estadístico para su posterior análisis o filtrado. Se puede utilizar en mitad de una búsqueda para agregar estadísticas que se pueden utilizar en comandos posteriores.
**Sintaxis**
Utilice la siguiente sintaxis:
```
eventstats ... [by-clause]
```
**agregación**
+ Obligatorio.
+ Una función de agregación.
+ El argumento de agregación debe ser un campo.
**by-clause**
+ Opcional.
+ Sintaxis: `by [span-expression,] [field,]...`
+ La cláusula by puede incluir campos y expresiones, como funciones escalares y funciones de agregación. También puede usar la cláusula span para dividir un campo específico en grupos de intervalos iguales. A continuación, el comando eventstats realiza la agregación en función de estos buckets de intervalo.
+ Predeterminado: si no especificas una cláusula by, el comando eventstats agrega todo el conjunto de resultados.
**span-expression**
+ Opcional, como máximo uno.
+ Sintaxis: `span(field_expr, interval_expr)`
+ La unidad de la expresión de intervalo es la unidad natural por defecto. Sin embargo, para los campos de tipo fecha y hora, debe especificar la unidad en la expresión de intervalo cuando utilice unidades de fecha y hora.
Por ejemplo, para dividir el campo `age` en buckets por 10 años, utilice `span(age, 10)`. Para los campos basados en el tiempo, puede dividir un campo `timestamp` en intervalos de una hora si utiliza `span(timestamp, 1h)`.
**Unidades de tiempo disponibles**
| Unidades de intervalo |
| --- |
| milisegundo (ms) |
| segundo (s) |
| minuto (m, distingue entre mayúsculas y minúsculas) |
| hora (h) |
| día (d) |
| semana (s) |
| mes (M, distingue entre mayúsculas y minúsculas) |
| trimestre (q) |
| año (y) |
**Funciones de agregación**
**`COUNT`**
`COUNT` devuelve un recuento del número de expresiones en las filas recuperadas por una sentencia SELECT.
En el CloudWatch caso de los registros, no `COUNT` se admiten consultas.
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.
**porcentaje**
+ El número debe ser una constante entre 0 y 100.
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
```
**De uso**
+ `source = table | eventstats avg(a)`
+ `source = table | where a < 50 | eventstats avg(c)`
+ `source = table | eventstats max(c) by b`
+ `source = table | eventstats count(c) by b | head 5`
+ `source = table | eventstats distinct_count(c)`
+ `source = table | eventstats stddev_samp(c)`
+ `source = table | eventstats stddev_pop(c)`
+ `source = table | eventstats percentile(c, 90)`
+ `source = table | eventstats percentile_approx(c, 99)`
**Agregaciones con span**
+ `source = table | eventstats count(a) by span(a, 10) as a_span`
+ `source = table | eventstats sum(age) by span(age, 5) as age_span | head 2`
+ `source = table | eventstats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
**Agregaciones con intervalo de ventana de tiempo (función de ventana invertida)**
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
+ `source = table | eventstats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
**Las agregaciones se agrupan en varios niveles**
+ `source = table | eventstats avg(age) as avg_state_age by country, state | eventstats avg(avg_state_age) as avg_country_age by country`
+ `source = table | eventstats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | eventstats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | eventstats avg(avg_state_age) as avg_adult_country_age by country`
#### Comando expand
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
Utilice el comando `expand` para aplanar un campo del tipo:
+ `Array`
+ `Map`
**Sintaxis**
Utilice la siguiente sintaxis:
```
expand [As alias]
```
**campo**
+ El campo que se va a expandir (explotar). Debe ser de un tipo compatible.
**alias**
+ Opcional. El nombre que se va a utilizar en lugar del nombre del campo original.
**De uso**
El comando `expand` genera una fila para cada elemento de la matriz o campo de mapa especificado, donde:
+ Los elementos de la matriz se convierten en filas individuales.
+ Los pares clave-valor de la asignación se dividen en filas independientes y cada valor clave se representa como una fila.
+ Cuando se proporciona un alias, los valores desglosados se representan con el alias en lugar del nombre de campo original.
+ Esto se puede usar en combinación con otros comandos, como `stats`, `eval` y `parse` para manipular o extraer datos después de la expansión.
**Ejemplos**
+ `source = table | expand employee | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid`
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
#### Comando explain
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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.
**Comment**
+ `source=accounts | top gender // finds most common gender of all the accounts` (comentario de línea)
+ `source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender` (comentario bloqueado)
**Describir**
+ `describe table` Este comando es igual al comando `DESCRIBE EXTENDED table` de SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
**Explain**
+ `explain simple | source = table | where a = 1 | fields a,b,c`
+ `explain extended | source = table`
+ `explain codegen | source = table | dedup a | fields a,b,c`
+ `explain cost | source = table | sort a | fields a,b,c`
+ `explain formatted | source = table | fields - a`
+ `explain simple | describe table`
**Campos**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
**Resumen de campo**
+ `source = t | fieldsummary includefields=status_code nulls=false`
+ `source = t | fieldsummary includefields= id, status_code, request_path nulls=true`
+ `source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true`
**Campo anidado**
+ `source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
+ `source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
+ `source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
**Filtros**
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a not in (1, 2, 3) | fields a,b,c`
+ `source = table | where a between 1 and 4`, Nota: Esto devuelve un >= 1 y un <= 4, es decir, [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`, Nota: Esto devuelve b >= '\*\*\*\*\*\*\*\*\*\*' y b <= '2025-09-10'
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
+ `source = table | trendline sma(2, temperature) as temp_trend`
**Consultas relacionadas con la IP**
+ `source = table | where cidrmatch(ip, '**************')`
+ `source = table | where isV6 = false and isValid = true and cidrmatch(ipAddress, '**************')`
+ `source = table | where isV6 = true | eval inRange = case(cidrmatch(ipAddress, '2003:***::/32'), 'in' else 'out') | fields ip, inRange`
**Filtros 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
```
**Filtros con condiciones lógicas**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
**Eval**
Supuestos: `a`, `b`, `c` son campos existentes en `table`
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1` (campos de salida a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval digest = md5(fieldName) | fields digest`
+ `source = table | eval digest = sha1(fieldName) | fields digest`
+ `source = table | eval digest = sha2(fieldName,256) | fields digest`
+ `source = table | eval digest = sha2(fieldName,512) | fields digest`
#### Comando fillnull
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Description (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 in ["," ]] | [using = ["," = ]]
```
+ null-replacement: obligatorio. El valor utilizado para reemplazar los valores nulos.
+ nullable-field: obligatorio. Referencia de campos. Los valores nulos de este campo se sustituirán por el valor especificado en la sustitución de valores nulos.
**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.
+ `/error` en el campo `request_path`
+ `1970-01-01 00:00:00` en el campo `timestamp`
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull using request_path = '/error', timestamp='1970-01-01 00:00:00';
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| /home | NULL | /home | 1970-01-01 00:00:00 |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | /error | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | /error | 2023-10-01 11:05:00 |
| /about | NULL | /about | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| NULL | 2023-10-01 10:05:00 | /error | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | /error | 2023-10-01 10:50:00 |
| /services | NULL | /services | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | /error | 2023-10-01 10:35:00 |
```
#### Comando fields
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
Utilice el comando `fields` para conservar o eliminar campos del resultado de la búsqueda.
**Sintaxis**
Utilice la siguiente sintaxis:
```
field [+|-]
```
+ `index`: opcional.
Si se utiliza el signo más (\+), solo se conservarán los campos especificados en la lista de campos.
Si se utiliza el signo menos (-), se eliminarán todos los campos especificados en la lista de campos.
*Predeterminado*: \+
+ `field list`: obligatorio. Una lista delimitada por comas de campos para conservar o eliminar.
**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 |
+-------------+------------+
```
**Ejemplos adicionales**
+ `source = table`
+ `source = table | fields a,b,c`
+ `source = table | fields + a,b,c`
+ `source = table | fields - b,c`
+ `source = table | eval b1 = b | fields - b1,c`
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
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
Utilice el comando flatten para expandir los campos de los siguientes tipos:
+ `struct`
+ `array>`
**Sintaxis**
Utilice la siguiente sintaxis:
```
flatten
```
+ *campo*: el campo que se va a aplanar. El campo debe ser de un tipo compatible.
**Esquema**
| col\_name | data\_type |
| --- | --- |
| \_time | cadena |
| puentes | array> |
| ciudad | cadena |
| coor | struct |
| país | cadena |
**Datos**
| \_time | puentes | ciudad | coor | país |
| --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | [{801, Puente de la Torre}, {928, Puente de Londres}] | Londres | {35, 51.5074, -0.1278} | Inglaterra |
| 2024-09-13T12:00:00 | [{232, Puente Nuevo}, {160, Puente Alejandro III}] | Paris | {35, 48.8566, 2.3522} | Francia |
| 2024-09-13T12:00:00 | [{48, Puente de Rialto}, {11, Puente de los Suspiros}] | Venecia | {2, 45.4408, 12.3155} | Italia |
| 2024-09-13T12:00:00 | [{\*\*\*, Puente de Carlos}, {343, Puente de la Legión}] | Praga | {200, 50.0755, 14.4378} | República Checa |
| 2024-09-13T12:00:00 | [{375, Puente de las Cadenas}, {333, Puente de la Libertad}] | Budapest | {96, 47.4979, 19.0402} | Hungría |
| 1990-09-13T 12:00:00 | NULL | Varsovia | NULL | Polonia |
**Ejemplo 1: estructura aplanada**
En este ejemplo se muestra cómo aplanar un campo de estructura.
Consulta PPL:
```
source=table | flatten coor
```
| \_time | puentes | ciudad | país | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | [{801, Puente de la Torre}, {928, Puente de Londres}] | Londres | Inglaterra | 35 | 51.5074 | -0,1278 |
| 2024-09-13T12:00:00 | [{232, Puente Nuevo}, {160, Puente Alejandro III}] | Paris | Francia | 35 | 48,8566 | 2.3522 |
| 2024-09-13T12:00:00 | [{48, Puente de Rialto}, {11, Puente de los Suspiros}] | Venecia | Italia | 2 | 45,4408 | 12,3155 |
| 2024-09-13T12:00:00 | [{516, Puente de Carlos}, {343, Puente de la Legión}] | Praga | República Checa | 200 | 50,0755 | 14,4378 |
| 2024-09-13T12:00:00 | [{375, Puente de las Cadenas}, {333, Puente de la Libertad}] | Budapest | Hungría | 96 | 47,4979 | 19,0402 |
| 1990-09-13T 12:00:00 | NULL | Varsovia | Polonia | NULL | NULL | NULL |
**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
```
| \_time | ciudad | coor | país | length | name |
| --- | --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | Londres | {35, 51.5074, -0.1278} | Inglaterra | 801 | Puente de la Torre |
| 2024-09-13T12:00:00 | Londres | {35, 51.5074, -0.1278} | Inglaterra | 928 | Puente de Londres |
| 2024-09-13T12:00:00 | Paris | {35, 48.8566, 2.3522} | Francia | 232 | Puente Nuevo |
| 2024-09-13T12:00:00 | Paris | {35, 48.8566, 2.3522} | Francia | 160 | Puente Alejandro III |
| 2024-09-13T12:00:00 | Venecia | {2, 45.4408, 12.3155} | Italia | 48 | Puente de Rialto |
| 2024-09-13T12:00:00 | Venecia | {2, 45.4408, 12.3155} | Italia | 11 | Puente de los Suspiros |
| 2024-09-13T12:00:00 | Praga | {200, 50.0755, 14.4378} | República Checa | 516 | Puente de Carlos |
| 2024-09-13T12:00:00 | Praga | {200, 50.0755, 14.4378} | República Checa | 343 | Puente de la Legión |
| 2024-09-13T12:00:00 | Budapest | {96, 47.4979, 19.0402} | Hungría | 375 | Puente de las Cadenas |
| 2024-09-13T12:00:00 | Budapest | {96, 47.4979, 19.0402} | Hungría | 333 | Puente de la Libertad |
| 1990-09-13T 12:00:00 | Varsovia | NULL | Polonia | NULL | NULL |
**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
```
| \_time | ciudad | país | length | name | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13T12:00:00 | Londres | Inglaterra | 801 | Puente de la Torre | 35 | 51,5074 | -0,1278 |
| 2024-09-13T12:00:00 | Londres | Inglaterra | 928 | Puente de Londres | 35 | 51,5074 | -0,1278 |
| 2024-09-13T12:00:00 | Paris | Francia | 232 | Puente Nuevo | 35 | 48,8566 | 2.3522 |
| 2024-09-13T12:00:00 | Paris | Francia | 160 | Puente Alejandro III | 35 | 48,8566 | 2.3522 |
| 2024-09-13T12:00:00 | Venecia | Italia | 48 | Puente de Rialto | 2 | 45,4408 | 12,3155 |
| 2024-09-13T12:00:00 | Venecia | Italia | 11 | Puente de los Suspiros | 2 | 45,4408 | 12,3155 |
| 2024-09-13T12:00:00 | Praga | República Checa | 516 | Puente de Carlos | 200 | 50,0755 | 14,4378 |
| 2024-09-13T12:00:00 | Praga | República Checa | 343 | Puente de la Legión | 200 | 50,0755 | 14,4378 |
| 2024-09-13T12:00:00 | Budapest | Hungría | 375 | Puente de las Cadenas | 96 | 47,4979 | 19,0402 |
| 2024-09-13T12:00:00 | Budapest | Hungría | 333 | Puente de la Libertad | 96 | 47,4979 | 19,0402 |
| 1990-09-13T 12:00:00 | Varsovia | Polonia | NULL | NULL | NULL | NULL | NULL |
#### Comando grok
**nota**
Para ver qué integraciones de fuentes AWS de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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
```
**campo**
+ Obligatorio.
+ El campo debe ser un campo de texto.
**pattern**
+ Obligatorio.
+ El patrón grok utilizado para extraer nuevos campos del campo de texto dado.
+ Si ya existe un nombre de campo nuevo, reemplazará al campo original.
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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 [] [from ]
```
****
+ Número entero opcional.
+ El número de resultados que se devolverá.
+ Valor predeterminado: 10
****
+ Entero después de opcional `from`.
+ Número de resultados que se va a saltear.
+ Predeterminado: 0
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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:
**`otel-v1-apm-span-*`**
+ traceId: un identificador único para un rastreo. Todos los tramos de la misma traza comparten el mismo traceId.
+ spanId: identificador único para un tramo dentro de una traza, que se asigna cuando se crea el tramo.
+ parentSpanId - El spAnid del tramo principal de este tramo. Si se trata de un intervalo raíz, este campo debe estar vacío.
+ durationInNanos - La diferencia en nanosegundos entre StartTime y EndTime. (esto está `latency` en la interfaz de usuario)
+ serviceName: el recurso desde el que se origina el tramo.
+ traceGroup: nombre del tramo raíz de la traza.
**`otel-v1-apm-service-map`**
+ serviceName: nombre del servicio que registró el intervalo.
+ destination.domain: el serviceName del servicio que llama este cliente.
+ destination.resource: el nombre del intervalo (API, operación, etc.) al que llama este cliente.
+ target.domain: el serviceName del servicio que llama un cliente.
+ target.resource: el nombre del intervalo (API, operación, etc.) al que llama un cliente.
+ traceGroupName - El nombre del intervalo de nivel superior que inició la cadena de solicitudes.
**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=
|
| [joinType] JOIN
[leftAlias]
ON joinCriteria
|
```
**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
```
**joinType**
+ Sintaxis: `INNER | LEFT OUTER | CROSS`
+ Opcional
+ El tipo de unión que se va a realizar. Si no se especifica, el valor predeterminado es `INNER`.
**leftAlias**
+ Sintaxis: `left = `
+ Opcional
+ El alias de la subconsulta que se debe usar con el lado izquierdo de la combinación, para evitar nombres ambiguos.
**joinCriteria**
+ Sintaxis: ``
+ Obligatorio
+ La sintaxis comienza con `ON`. Puede ser cualquier expresión de comparación. En general, los criterios de unión son los siguientes `.=.`.
Por ejemplo: `l.id = r.id`. Si los criterios de unión contienen varias condiciones, puede especificar operador `AND` y `OR` entre cada expresión de comparación. Por ejemplo, `l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)`.
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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=
|
| LOOKUP ( [AS ])...
[(REPLACE | APPEND) ( [AS ])...]
|
```
**lookupIndex**
+ Obligatorio.
+ El nombre del índice de búsqueda (tabla de dimensiones).
**lookupMappingField**
+ Obligatorio.
+ Una clave de asignación en el índice de búsqueda, análoga a una clave de unión de la tabla de la derecha. Puede especificar múltiples nombres de esquema separados por comas.
**sourceMappingField**
+ Opcional.
+ Predeterminado: < >lookupMappingField.
+ Una clave de asignación de la consulta de origen, análoga a una clave de unión del lado izquierdo.
**inputField**
+ Opcional.
+ Predeterminado: todos los campos del índice de búsqueda en los que se encuentran valores coincidentes.
+ Campo del índice de búsqueda en el que los valores coincidentes se aplican a la salida del resultado. Puede especificar múltiples nombres de esquema separados por comas.
**outputField**
+ Opcional.
+ Predeterminado: ``.
+ Un campo de salida. Puede especificar varios campos de salida. Si especifica un nombre de campo existente en la consulta de origen, sus valores se sustituirán o se agregarán por valores coincidentes de inputField. Si especifica un nombre de campo nuevo, se agregará a los resultados.
**REPLACE \| APPEND**
+ Opcional.
+ Predeterminado: REPLACE
+ Especifica cómo administrar los valores coincidentes. Si especifica REPLACE, los valores coincidentes del campo sobrescribirán los valores del resultado. Si especifica `APPEND`, los valores coincidentes del campo solo se incorporarán a los valores faltantes en el resultado.
**De uso**
+ LOOKUP id AS cid REPLACE mail AS email
+ LOOKUP name REPLACE mail AS email
+ LOOKUP id AS cid, name APPEND address, mail AS email
+ LOOKUP id
**Ejemplo**
Vea los siguientes ejemplos de .
```
SEARCH source=
| WHERE orderType = 'Cancelled'
| LOOKUP account_list, mkt_id AS mkt_code REPLACE amount, account_name AS name
| STATS count(mkt_code), avg(amount) BY name
```
```
SEARCH source=
| DEDUP market_id
| EVAL category=replace(category, "-", ".")
| EVAL category=ltrim(category, "dvp.")
| LOOKUP bounce_category category AS category APPEND classification
```
```
SEARCH source=
| LOOKUP bounce_category category
```
#### Comando parse
El comando `parse` analiza un campo de texto con una expresión regular y agrega el resultado al resultado de la búsqueda.
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Sintaxis**
Utilice la siguiente sintaxis:
```
parse
```
**`field`**
+ Obligatorio.
+ El campo debe ser un campo de texto.
**`pattern`**
+ Cadena obligatoria.
+ Este es el patrón de expresión regular que se utiliza para extraer nuevos campos del campo de texto dado.
+ Si ya existe un nombre de campo nuevo, reemplazará al campo original.
**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 '.+@(?.+)' | 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+ (?.+)' | 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 '(?\d+) (?.+)' | where cast(streetNumber as int) > 500 | sort num(streetNumber) | fields streetNumber, street ;
fetched rows / total rows = 3/3
+----------------+----------------+
| streetNumber | street |
|----------------+----------------|
| *** | Example Street |
| *** | Example Avenue |
| 880 | Example Lane |
+----------------+----------------+
```
**Limitaciones**
El comando parse presenta algunas limitaciones:
+ Los campos definidos por parse no se pueden volver a analizar.
Este comando no funcionara:
```
source=accounts | parse address '\d+ (?.+)' | parse street '\w+ (?\w+)'
```
+ Los campos definidos por parse no se pueden anular con otros comandos.
`where` no coincidirá con ningún documento ya que `street` no se puede anular:
```
source=accounts | parse address '\d+ (?.+)' | eval street='1' | where street='1' ;
```
+ El campo de texto utilizado por parse no se puede anular.
`street` no se analizará correctamente ya que `address` está anulado:
```
source=accounts | parse address '\d+ (?.+)' | eval address='1' ;
```
+ Los campos definidos por parse no se pueden filtrar ni ordenar después de usarlos en el comando `stats`.
`where` en el siguiente comando no funcionará:
```
source=accounts | parse email '.+@(?.+)' | stats avg(age) by host | where host=pyrami.com ;
```
#### Comando patterns
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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=] [pattern=]
```
**new-field-name**
+ Cadena opcional.
+ Este es el nombre del nuevo campo para los patrones extraídos.
+ El valor predeterminado es `patterns_field`.
+ Si el nombre ya existe, sustituirá al campo original.
**pattern**
+ Cadena opcional.
+ Este es el patrón de caracteres regex que deben filtrarse del campo de texto.
+ Si no está presente, el patrón predeterminado son los caracteres alfanuméricos (`[a-zA-Z\d]`).
**campo**
+ Obligatorio.
+ El campo debe ser un campo de texto.
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
Utilice el comando `rare` para buscar la tupla de valores menos común de todos los campos de la lista de campos.
**nota**
Se devuelve un máximo de 10 resultados por cada tupla distinta de valores de los campos agrupados.
**Sintaxis**
Utilice la siguiente sintaxis:
```
rare [N] [by-clause] rare_approx [N] [by-clause]
```
**field-list**
+ Obligatorio.
+ Una lista delimitada por comas de nombres de campo.
**by-clause**
+ Opcional.
+ Uno o más campos por los que agrupar los resultados.
**N**
+ El número de resultados que se devolverá.
+ Valor predeterminado: 10
**rare\_approx**
+ El recuento aproximado de los campos raros (n) mediante el uso de la [cardinalidad](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html) estimada mediante el algoritmo \+\+. HyperLogLog
**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.
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Sintaxis**
Utilice la siguiente sintaxis:
```
rename AS ["," AS ]...
```
**source-field**
+ Obligatorio.
+ Este es el nombre del campo que desea cambiar de nombre.
**target-field**
+ Obligatorio.
+ Este es el nombre al que quiere cambiarle el nombre.
**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 |
+------+---------+
```
**Limitaciones**
+ No se admite la sustitución de un campo existente:
```
source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address
```
#### Comando search
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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=[:] [boolean-expression]
```
**buscar**
+ Opcional.
+ Busca palabras clave, que se pueden omitir.
**índice**
+ Obligatorio.
+ El comando de búsqueda debe especificar el índice desde el que realizar la consulta.
+ El nombre del índice puede tener un prefijo `:` para las búsquedas entre clústeres.
**bool-expression**
+ Opcional.
+ Una cadena de expresión que se evalúa como un valor booleano.
**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.
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Sintaxis**
Utilice la siguiente sintaxis:
```
sort <[+|-] sort-field>...
```
**[\+\|-]**
+ Opcional.
+ El signo más [\+] significa orden ascendente con NULL/MISSING los valores en primer lugar.
+ El signo menos [-] indica el orden descendente con los NULL/MISSING valores al final.
+ Predeterminado: orden ascendente con NULL/MISSING los valores primero.
**sort-field**
+ Obligatorio.
+ El campo que se utiliza para ordenar.
**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.
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
**Manejo de valores NULL o MISSING**
**Manejo de valores NULL o MISSING**
| Función | NULL | AUSENTE |
| --- | --- | --- |
| COUNT | No contado | No contado |
| SUM | Ignore | Ignore |
| AVG | Ignore | Ignore |
| MAX | Ignore | Ignore |
| MIN | Ignore | Ignore |
**Sintaxis**
Utilice la siguiente sintaxis:
```
stats ... [by-clause]
```
**agregación**
+ Obligatorio.
+ Función de agregación aplicada a un campo.
**by-clause**
+ Opcional.
+ Sintaxis: `by [span-expression,] [field,]...`
+ Especifica los campos y expresiones para agrupar los resultados de la agregación. La cláusula secundaria le permite agrupar los resultados de agregación mediante campos y expresiones. Puede utilizar funciones escalares, funciones de agregación e incluso expresiones de extensión para dividir campos específicos en grupos de intervalos iguales.
+ Predeterminado: si `` no se especifica, el comando stats devuelve una sola fila que representa la agregación de todo el conjunto de resultados.
**span-expression**
+ Opcional, como máximo uno.
+ Sintaxis: `span(field_expr, interval_expr)`
+ La unidad de la expresión de intervalo es la unidad natural por defecto. Si el campo es de tipo fecha y hora y el intervalo está en date/time unidades, especifique la unidad en la expresión del intervalo.
+ Por ejemplo, parece que se divide el campo `age` en buckets de 10 años `span(age, 10)`. Para dividir un campo de fecha y hora en intervalos de una hora, utilice `span(timestamp, 1h)`.
**Unidades de tiempo disponibles**
| Unidades de intervalo |
| --- |
| milisegundo (ms) |
| segundo (s) |
| minuto (m, distingue entre mayúsculas y minúsculas) |
| hora (h) |
| día (d) |
| semana (s) |
| mes (M, distingue entre mayúsculas y minúsculas) |
| trimestre (q) |
| año (y) |
**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.
**campo**
+ Obligatorio.
+ El campo debe ser un campo de texto.
**tamaño**
+ Número entero opcional.
+ Debe devolverse el número de valores.
+ El valor predeterminado es 10.
**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.
**porcentaje**
+ El número debe ser una constante entre 0 y 100.
**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
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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 ]
```
**InSubquery Uso**
+ `source = outer | where a in [ source = inner | fields b ]`
+ `source = outer | where (a) in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) in [ source = inner | fields d,e,f ]`
+ `source = outer | where a not in [ source = inner | fields b ]`
+ `source = outer | where (a) not in [ source = inner | fields b ]`
+ `source = outer | where (a,b,c) not in [ source = inner | fields d,e,f ]`
+ `source = outer a in [ source = inner | fields b ]` (filtrado de búsqueda con subconsulta)
+ `source = outer a not in [ source = inner | fields b ]` (filtrado de búsqueda con subconsulta)
+ `source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ]` (anidado)
+ `source = table1 | inner join left = l right = r on l.a = r.a AND r.a in [ source = inner | fields d ] | fields l.a, r.a, b, c` (como filtro de unión)
**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 una consulta PPL: InSubquery
```
source = orders
| where o_orderdate >= "1993-07-01" and o_orderdate < "1993-10-01" and o_orderkey IN
[ source = lineitem
| where l_commitdate < l_receiptdate
| fields l_orderkey
]
| stats count(1) as order_count by o_orderpriority
| sort o_orderpriority
| fields o_orderpriority, order_count
```
TPC-H Q20 (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 una consulta PPL: InSubquery
```
source = supplier
| where s_suppkey IN [
source = partsupp
| where ps_partkey IN [
source = part
| where like(p_name, "forest%")
| fields p_partkey
]
| fields ps_suppkey
]
| inner join left=l right=r on s_nationkey = n_nationkey and n_name = 'CANADA'
nation
| sort s_name
```
**ExistsSubquery uso**
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.
+ `source = outer | where exists [ source = inner | where a = c ]`
+ `source = outer | where not exists [ source = inner | where a = c ]`
+ `source = outer | where exists [ source = inner | where a = c and b = d ]`
+ `source = outer | where not exists [ source = inner | where a = c and b = d ]`
+ `source = outer exists [ source = inner | where a = c ]` (filtrado de búsqueda con subconsulta)
+ `source = outer not exists [ source = inner | where a = c ]` (filtrado de búsqueda con subconsulta)
+ `source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ]` (el alias de la tabla es útil en una subconsulta existente)
+ `source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ]` (anidado)
+ `source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ]` (anidado)
+ `source = outer | where exists [ source = inner | where c > 10 ]` (existe una correlación no correlacionada)
+ `source = outer | where not exists [ source = inner | where c > 10 ]` (existe una relación no correlacionada)
+ `source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l` (existe una relación especial no correlacionada)
**ScalarSubquery uso**
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:
+ `source = outer | eval m = [ source = inner | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | stats max(c) ] + b | fields m, a`
En dónde:
+ `source = outer | where a > [ source = inner | stats min(c) ] | fields a`
Búsqueda filtrada en:
+ `source = outer a > [ source = inner | stats min(c) ] | fields a`
**Subconsulta escalar correlacionada**
Seleccione en:
+ `source = outer | eval m = [ source = inner | where outer.b = inner.d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where b = d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where outer.b > inner.d | stats max(c) ] | fields m, a`
En dónde:
+ `source = outer | where a = [ source = inner | where outer.b = inner.d | stats max(c) ]`
+ `source = outer | where a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer | where [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
Búsqueda filtrada en:
+ `source = outer a = [ source = inner | where b = d | stats max(c) ]`
+ `source = outer [ source = inner | where outer.b = inner.d OR inner.d = 1 | stats count() ] > 0 | fields a`
**Subconsulta escalar anidada**
+ `source = outer | where a = [ source = inner | stats max(c) | sort c ] OR b = [ source = inner | where c = 1 | stats min(d) | sort d ]`
+ `source = outer | where a = [ source = inner | where c = [ source = nested | stats max(e) by f | sort f ] | stats max(d) by c | sort c | head 1 ]`
**(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.
+ `source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ]` (subconsulta en el lado derecho de la unión)
+ `source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1`
**Contexto adicional**
`InSubquery`, `ExistsSubquery` y `ScalarSubquery` son expresiones de subconsulta que se utilizan habitualmente en cláusulas `where` y filtros de búsqueda.
Comando Where:
```
| where | ...
```
Filtro de búsqueda:
```
search source=* | ...
```
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 ``.
En general, denominamos expresión `InSubquery` a este tipo de cláusula de subconsulta. Es una ``.
**Subconsulta con diferentes tipos de unión**
En el ejemplo se utiliza un `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, a no RelationSubquery 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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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] [by-clause] top_approx [N] [by-clause]
```
**N**
+ El número de resultados que se devolverá.
+ Valor predeterminado: 10
**field-list**
+ Obligatorio.
+ Una lista delimitada por comas de nombres de campo.
**by-clause**
+ Opcional.
+ Uno o más campos por los que agrupar los resultados.
**top\_approx**
+ Un recuento aproximado de los (n) campos principales mediante el algoritmo de [cardinalidad estimada mediante HyperLogLog \+\+](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html).
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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]]...
```
**[\+\|-]**
+ Opcional.
+ El signo más [\+] significa orden ascendente con NULL/MISSING los valores en primer lugar.
+ El signo menos [-] indica el orden descendente con los NULL/MISSING valores al final.
+ Predeterminado: orden ascendente con NULL/MISSING los valores primero.
**sort-field**
+ Obligatorio cuando se utiliza la clasificación.
+ El campo que se utiliza para ordenar.
**number-of-datapoints**
+ Obligatorio.
+ El número de puntos de datos que calculan el promedio móvil.
+ Debe ser mayor que cero.
**campo**
+ Obligatorio.
+ El nombre del campo para el que se debe calcular el promedio móvil.
**alias**
+ Opcional.
+ El nombre de la columna resultante que contiene el promedio móvil.
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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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
```
**bool-expression**
+ Opcional.
+ Cualquier expresión que pueda evaluarse en un valor booleano.
**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**
**Filtros con condiciones lógicas**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a between 1 and 4`, Nota: Esto devuelve un >= 1 y un <= 4, es decir, [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`, Nota: Esto devuelve b >= '\*\*\*\*\*\*\*\*\*\*' y b <= '2025-09-10'
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
#### Resumen de campo
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten este comando PPL, consulte. [Comandos](#supported-ppl-commands)
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 CloudWatch los casos de uso de registros, solo se admite un campo en una consulta.
```
... | fieldsummary (nulls=true/false)
```
**includefields**
+ Lista de todas las columnas que se van a recopilar con las estadísticas en un conjunto de resultados unificado.
**Nulos**
+ Opcional.
+ Si se establece como verdadero, incluye valores nulos en los cálculos de agregación (sustituye el valor nulo por cero para los valores numéricos).
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten esta función de PPL, consulte. [Funciones](#supported-ppl-functions)
Utilice el comando `expand` para aplanar un campo de tipo Array o Map, lo que genera filas individuales para cada elemento o par clave-valor.
**Sintaxis**
Utilice la siguiente sintaxis:
```
expand [As alias]
```
**campo**
+ El campo que se va a expandir (explotar).
+ El campo debe ser de un tipo compatible.
**alias**
+ Opcional.
+ El nombre que se va a utilizar en lugar del nombre del campo original.
**Directrices de uso**
El comando expand genera una fila para cada elemento de la matriz o campo de mapa especificado, donde:
+ Los elementos de la matriz se convierten en filas individuales.
+ Los pares clave-valor de la asignación se dividen en filas independientes y cada valor clave se representa como una fila.
+ Cuando se proporciona un alias, los valores desglosados se representan con el alias en lugar del nombre de campo original.
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.
**Ejemplos**
+ `source = table | expand employee | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | stats max(salary) as max by state, company `
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid `
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
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:
+ Es una operación de columna que devuelve una columna nueva.
+ Crea una nueva fila para cada elemento de la columna expandida.
+ Los valores nulos internos se ignoran como parte del campo expandido (no hay filas created/exploded para valores nulos).
#### Funciones PPL
**Topics**
+ [Funciones de condiciones PPL](#supported-ppl-condition-functions)
+ [Funciones hash criptográficas PPL](#supported-ppl-cryptographic-functions)
+ [Funciones de fecha y hora PPL](#supported-ppl-date-time-functions)
+ [Expresiones PPL](#supported-ppl-expressions)
+ [Funciones PPL de dirección IP](#supported-ppl-ip-address-functions)
+ [Nuevas funciones PPL JSON](#supported-ppl-json-functions)
+ [Funciones de Lambda PPL](#supported-ppl-lambda-functions)
+ [Funciones matemáticas PPL](#supported-ppl-math-functions)
+ [Funciones de cadena PPL](#supported-ppl-string-functions)
+ [Función de conversión de tipos PPL](#supported-ppl-type-conversion-functions)
##### Funciones de condiciones PPL
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### ISNULL
**Descripción**: `isnull(field)` devuelve el valor verdadero si el campo es nulo.
**Tipo de argumento:**
+ Cualquier tipo de datos compatible.
**Tipo de devolución:**
+ BOOLEANO
**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.
**Tipo de argumento:**
+ Cualquier tipo de datos compatible.
**Tipo de devolución:**
+ BOOLEANO
**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.
**Tipo de argumento:**
+ Cualquier tipo de datos compatible.
+ Si los dos parámetros son de tipos diferentes, la función no pasará la comprobación semántica.
**Tipo de devolución:**
+ Cualquiera
**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.
**Tipo de argumento:**
+ Cualquier tipo de datos compatible.
+ Si los dos parámetros son de tipos diferentes, la función no pasará la comprobación semántica.
**Tipo de devolución:**
+ Cualquiera
**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`.
**Tipo de argumento:**
+ Cualquier tipo de datos compatible.
+ Si los dos parámetros son de tipos diferentes, la función no pasará la comprobación semántica.
**Tipo de devolución:**
+ Cualquiera
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### MD5
MD5 calcula el MD5 resumen y devuelve el valor en forma de cadena hexadecimal de 32 caracteres.
**Uso**: `md5('hello')`
**Tipo de argumento:**
+ STRING
**Tipo de devolución:**
+ STRING
**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')`
**Tipo de argumento:**
+ STRING
**Tipo de devolución:**
+ STRING
**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
**Uso:**
+ `sha2('hello',256)`
+ `sha2('hello',512)`
**Tipo de argumento:**
+ STRING, INTEGER
**Tipo de devolución:**
+ STRING
**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
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### `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 hora actuales como un `TIMESTAMP` valor en el formato 'YYYY-MM-DD hh:mm:ss'. El valor se expresa en la zona horaria del clúster.
**nota**
`NOW()` devuelve un tiempo constante que indica cuándo comenzó a ejecutarse la sentencia. Esto es diferente de `SYSDATE()`, que devuelve la hora exacta de ejecución.
**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 hora actuales como un `TIMESTAMP` valor 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) -> MARCA DE TIEMPO
(STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP) -> MARCA DE TIEMPO
**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:/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**:
+ intervalo: INTERVAL (SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR)
+ entero: INTEGER
+ fecha: DATE, TIMESTAMP o STRING
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 el inicio y el final date/times en unidades de intervalo especificadas.
**Argumentos**:
+ intervalo: INTERVAL (SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR)
+ inicio: DATE, TIMESTAMP, o STRING
+ final: DATE, TIMESTAMP, o STRING
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
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
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:
1. `+`: suma.
1. `-`: resta.
1. `*`: multiplicación.
1. `/`: división (en el caso de los números enteros, el resultado es un número entero sin la parte fraccionaria)
1. `%`: módulo (se usa solo con números enteros; el resultado es el resto de la división)
**Precedencia**
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:
+ Un valor `MISSING` solo es igual a un valor `MISSING` y es menor que otros valores.
+ Un valor `NULL` es igual a un valor `NULL`, es mayor que un valor `MISSING`, pero menor que todos los demás valores.
**Operadores**
**Operadores de predicados**
| Name | Description (Descripción) |
| --- | --- |
| > | El operador mayor que |
| >= | Operador Mayor o igual que |
| < | El operador menor que |
| \!= | Operador no igual |
| <= | Los operadores menor que o igual a |
| = | Operador igual |
| LIKE | Coincidencia de patrones simple |
| IN | Prueba de valor NULL |
| AND | Operador AND |
| OR | Operador OR |
| XOR | Operador XOR |
| NOT | Prueba de valor NOT NULL |
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:
+ `TIME` se aplica a la fecha de hoy.
+ `DATE` se interpreta a medianoche.
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### `CIDRMATCH`
**Uso**: `CIDRMATCH(ip, cidr)` comprueba si la dirección IP especificada está dentro del rango de cidr dado.
**Tipo de argumento:**
+ STRING, STRING
+ Tipo de devolución: BOOLEAN
**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 |
+-----------------------------------------+
```
**nota**
`ip`puede ser una dirección IPv4 o una IPv6 dirección.
`cidr`puede ser un bloque IPv4 o un IPv6 bloque.
`ip`y `cidr` deben ser ambos IPv4 o ambos IPv6.
`ip` y `cidr` deben ser ambos válidos y no estar vacíos ni ser nulos.
##### Nuevas funciones PPL JSON
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### `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(, [, , ]...)` devuelve un objeto JSON de los miembros de pares clave-valor.
**Tipo de argumento:**
+ La debe ser STRING.
+ El puede ser cualquier tipo de dato.
**Tipo de devolución**: JSON\_OBJECT. StructType Expresión 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(...)` crea una matriz JSON usando una lista de valores.
**Tipo de argumento**: un `` 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
+ Una expresión STRING de un formato de objeto JSON válido.
+ `NULL` se devuelve en caso de un JSON no válido.
**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
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### `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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### `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-> DOBLE
**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 out-of-range un error 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**:
+ (INTEGER/LONG [,INTEGER]) -> LONG
+ (FLOAT/DOUBLE [,INTEGER]) -> LONG
**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**:
+ (No negativo) INTEGER/LONG/FLOAT/DOUBLE -> DOBLE
+ (Negativo) INTEGER/LONG/FLOAT/DOUBLE -> NULO
**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
**nota**
Para ver qué integraciones de fuentes de AWS datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### `CONCAT`
**Uso**: `CONCAT(str1, str2, ...., str_9)` suma hasta 9 cadenas.
**Tipo de argumento:**
+ STRING, STRING, ...., STRING
+ Tipo de devolución: STRING
**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:**
+ STRING, STRING, ...., STRING
+ Tipo de devolución: STRING
**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:**
+ STRING
+ Tipo de devolución: INTEGER
**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:**
+ STRING
+ Tipo de devolución: STRING
**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:**
+ STRING
+ Tipo de devolución: STRING
**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:**
+ STRING, STRING
+ Tipo de devolución INTEGER
**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:**
+ STRING
+ Tipo de devolución: STRING
**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:**
+ STRING, INTEGER
+ Tipo de devolución: STRING
**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:**
+ STRING
+ Tipo de devolución: **STRING**
**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:**
+ STRING, INTEGER, INTEGER
+ Tipo de devolución: STRING
**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:**
+ STRING
+ Tipo de devolución: **STRING**
**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:**
+ STRING
+ Tipo de devolución: STRING
**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
**nota**
Para ver qué integraciones AWS de fuentes de datos admiten esta función PPL, consulte. [Funciones](#supported-ppl-functions)
##### `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:
**Reglas de conversión de tipos**
| Src/Target | STRING | NUMBER | BOOLEANO | TIMESTAMP | DATE | TIME |
| --- | --- | --- | --- | --- | --- | --- |
| STRING | | Note1 | Note1 | TIMESTAMP() | FECHA() | TIME() |
| NUMBER | Note1 | | v\!=0 | N/A | N/A | N/A |
| BOOLEANO | Note1 | v?1:0 | | N/A | N/A | N/A |
| TIMESTAMP | Note1 | N/A | N/A | | FECHA() | TIME() |
| DATE | Note1 | N/A | N/A | N/A | | N/A |
| TIME | Note1 | N/A | N/A | N/A | N/A | |
**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 |
+---------+
```