Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Commandes PPL prises en charge
Les tableaux suivants indiquent les commandes PPL prises en charge par OpenSearch Dashboards pour interroger CloudWatch Logs, Amazon S3 ou Security Lake, ainsi que les commandes prises en charge par CloudWatch Logs Insights. CloudWatch Logs Insights utilise la même syntaxe PPL que les OpenSearch tableaux de bord lorsqu'il interroge les CloudWatch journaux, et les tables désignent les deux par le terme « journaux ». CloudWatch
**Note**
Lorsque vous analysez des données en dehors de OpenSearch Service, les commandes peuvent s'exécuter différemment de celles OpenSearch des index.
**Topics**
+ [Commandes](#supported-ppl-commands)
+ [Fonctions](#supported-ppl-functions)
+ [Informations supplémentaires pour les utilisateurs de CloudWatch Logs Insights utilisant OpenSearch PPL](#supported-ppl-for-cloudwatch-users)
## Commandes
| commande PPL | Description | CloudWatch Journaux | Amazon S3 | Security Lake | Exemple de commande |
| --- | --- | --- | --- | --- | --- |
| [commande fields](#supported-ppl-fields-command) | Affiche un ensemble de champs devant être projetés. | Soutenu | Soutenu | Soutenu | fields field1, field2
|
| [où commande](#supported-ppl-where-command) | Filtre les données en fonction des conditions que vous spécifiez. | Soutenu | Soutenu | Soutenu | where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000
|
| [commande stats](#supported-ppl-stats-command) | Effectue des agrégations et des calculs. | Soutenu | Soutenu | Soutenu | stats count(),
count(`field1`),
min(`field1`),
max(`field1`),
avg(`field1`)
by field2
| head 1000
|
| [commande d'analyse](#supported-ppl-parse-command) | Extrait un modèle d'expression régulière (regex) d'une chaîne et affiche le modèle extrait. Le modèle extrait peut également être utilisé pour créer de nouveaux champs ou filtrer des données. | Soutenu | Soutenu | Soutenu | parse `field1` ".*/(?[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000
|
| [commande patterns](#supported-ppl-patterns-command) | Extrait les modèles de journal d'un champ de texte et ajoute les résultats aux résultats de recherche. Le regroupement des journaux en fonction de leurs modèles facilite l'agrégation des statistiques provenant de gros volumes de données de journaux à des fins d'analyse et de résolution des problèmes. | Non pris en charge | Soutenu | Soutenu | patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers
|
| [commande de tri](#supported-ppl-sort-command) | Triez les résultats affichés par nom de champ. Utilisez le **tri - *FieldName***pour trier par ordre décroissant. | Soutenu | Soutenu | Soutenu | stats count(),
count(`field1`),
min(`field1`) as field1Alias,
max(`field1`),
avg(`field1`)
by field2
| sort -field1Alias
| head 1000
|
| [commande eval](#supported-ppl-eval-command) | Modifie ou traite la valeur d'un champ et la stocke dans un autre champ. Cela est utile pour modifier mathématiquement une colonne, appliquer des fonctions de chaîne à une colonne ou appliquer des fonctions de date à une colonne. | Soutenu | Soutenu | Soutenu | eval field2 = `field1` * 2
| fields field1, field2
| head 20
|
| [renommer la commande](#supported-ppl-rename-command) | Renomme un ou plusieurs champs dans les résultats de recherche. | Soutenu | Soutenu | Soutenu | rename field2 as field1
| fields field1
|
| [commande principale](#supported-ppl-head-command) | Limite les résultats de requête affichés aux N premières lignes. | Soutenu | Soutenu | Soutenu | fields `@message`
| head 20
|
| [commande grok](#supported-ppl-grok-command) | Analyse un champ de texte avec un modèle grok basé sur une expression régulière et ajoute les résultats aux résultats de recherche. | Soutenu | Soutenu | Soutenu | grok email '.+@%{HOSTNAME:host}'
| fields email |
| [commande supérieure](#supported-ppl-top-command) | Recherche les valeurs les plus fréquentes pour un champ. | Soutenu | Soutenu | Soutenu | top 2 Field1 by Field2
|
| [commande dedup](#supported-ppl-dedup-command) | Supprime les entrées dupliquées en fonction des champs que vous spécifiez. | Soutenu | Soutenu | Soutenu | dedup field1
| fields field1, field2, field3
|
| [commande join](#supported-ppl-join-commands) | Joint deux ensembles de données. | Soutenu | Soutenu | Soutenu | source=customer
| join ON c_custkey = o_custkey orders
| head 10
|
| [commande de recherche](#supported-ppl-lookup-commands) | Enrichit vos données de recherche en ajoutant ou en remplaçant les données d'un index de recherche (table de dimensions). Vous pouvez étendre les champs d'un index avec des valeurs issues d'une table de dimensions, ajouter ou remplacer des valeurs lorsque la condition de recherche correspond | Non pris en charge | Soutenu | Soutenu | 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
|
| [commande de sous-requête](#supported-ppl-subquery-commands) | Exécute des requêtes complexes et imbriquées dans vos instructions PPL (Piped Processing Language). | Soutenu | Soutenu | Soutenu | where id in [
subquery source=users
| where user in [
subquery source=actions
| where action="login"
| fields user
]
| fields uid
]
|
| [commande rare](#supported-ppl-rare-command) | Recherche les valeurs les moins fréquentes de tous les champs de la liste de champs. | Soutenu | Soutenu | Soutenu | rare Field1 by Field2
|
| [commande trendline](#supported-ppl-trendline-commands) | Calcule les moyennes mobiles des champs. | Soutenu | Soutenu | Soutenu | trendline sma(2, field1) as field1Alias
|
| [commande eventstats](#supported-ppl-eventstats-command) | Enrichissez les données de vos événements grâce à des statistiques récapitulatives calculées. Il analyse les champs spécifiés au sein de vos événements, calcule diverses mesures statistiques, puis ajoute ces résultats à chaque événement d'origine sous forme de nouveaux champs. | Supporté (sauf`count()`) | Soutenu | Soutenu | eventstats sum(field1) by field2
|
| [commande aplatir](#supported-ppl-flatten-command) | Aplatit un champ. Le champ doit être de ce type : `struct or array>` | Soutenu | Soutenu | Soutenu | source=table | flatten field1
|
| [résumé du champ](#supported-ppl-field-summary-command) | Calcule les statistiques de base pour chaque champ (nombre, nombre distinct, min, max, avg, stddev et moyenne). | Supporté (un champ par requête) | Soutenu | Soutenu | where field1 != 200
| fieldsummary includefields=field1 nulls=true
|
| [commande fillnull](#supported-ppl-fillnull-command) | Remplit les champs nuls avec la valeur que vous fournissez. Il peut être utilisé dans un ou plusieurs domaines. | Soutenu | Soutenu | Soutenu | fields field1
| eval field2=field1
| fillnull value=0 field1
|
| [commande d'extension](#supported-ppl-expand-command) | Décompose un champ contenant plusieurs valeurs en lignes distinctes, en créant une nouvelle ligne pour chaque valeur du champ spécifié. | Soutenu | Soutenu | Soutenu | expand employee
| stats max(salary) as max
by state, company
|
| [décrire la commande](#supported-ppl-describe-command) | Obtient des informations détaillées sur la structure et les métadonnées des tables, des schémas et des catalogues | Non pris en charge | Soutenu | Soutenu | describe schema.table
|
## Fonctions
| Fonction PPL | Description | CloudWatch Journaux | Amazon S3 | Security Lake | Exemple de commande |
| --- | --- | --- | --- | --- | --- |
| [Fonctions de chaîne PPL](#supported-ppl-string-functions)
(`CONCAT`, `CONCAT_WS`, `LENGTH`, `LOWER`, `LTRIM`, `POSITION`, `REVERSE`, `RIGHT`, `RTRIM`, `SUBSTRING`, `TRIM`, `UPPER`) | Fonctions intégrées dans PPL qui peuvent manipuler et transformer des chaînes et des données de texte dans les requêtes PPL. Par exemple, convertir des majuscules, combiner des chaînes, extraire des parties et nettoyer du texte. | Soutenu | Soutenu | Soutenu | eval col1Len = LENGTH(col1)
| fields col1Len
|
| [Fonctions de date et d'heure 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`) | Fonctions intégrées pour gérer et transformer les données de date et d'horodatage dans les requêtes PPL. **Par exemple, **date\_add, date\_format****, datediff et **current\_date****.** | Soutenu | Soutenu | Soutenu | eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate |
| [Fonctions de condition PPL](#supported-ppl-condition-functions)
(`EXISTS`, `IF`, `IFNULL`, `ISNOTNULL`, `ISNULL`, `NULLIF`) | Fonctions intégrées qui effectuent des calculs sur plusieurs lignes pour produire une seule valeur résumée. Par exemple, **sum**, **count**, **avg**, **max** et **min.** | Soutenu | Soutenu | Soutenu | eval field2 = isnull(col1)
| fields field2, col1, field3
|
| [Fonctions mathématiques 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`) | Fonctions intégrées pour effectuer des calculs mathématiques et des transformations dans les requêtes PPL. Par exemple : **abs** (valeur absolue), **round (arrondit** les nombres), **sqrt** (racine carrée), **pow** (calcul de puissance) et **ceil** (arrondit à l'entier supérieur le plus proche). | Soutenu | Soutenu | Soutenu | eval field2 = ACOS(col1)
| fields col1
|
| [Expressions PPL](#supported-ppl-expressions)
(Opérateurs arithmétiques (`+`,,`*`)`-`, Opérateurs de prédicat (`>. <`,) `IN)` | Les fonctions intégrées pour les expressions, en particulier les expressions de valeur, renvoient une valeur scalaire. Les expressions ont différents types et formes. | Soutenu | Soutenu | Soutenu | where age > (25 + 5)
| fields age
|
| [Fonctions d'adresse IP PPL](#supported-ppl-ip-address-functions)
(`CIDRMATCH`) | Fonctions intégrées pour gérer les adresses IP telles que le CIDR. | Soutenu | Soutenu | Soutenu | where cidrmatch(ip, '***********/24')
| fields ip
|
| [Fonctions JSON PPL](#supported-ppl-json-functions)
(`ARRAY_LENGTH`, `ARRAY_LENGTH`, `JSON`, `JSON_ARRAY`, `JSON_EXTRACT`, `JSON_KEYS`, `JSON_OBJECT`, `JSON_VALID`, `TO_JSON_STRING`) | Fonctions intégrées pour gérer le JSON, notamment les tableaux, l'extraction et la validation. | Soutenu | Soutenu | Soutenu | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a') |
| [Fonctions Lambda PPL](#supported-ppl-lambda-functions)
(`EXISTS`, `FILTER`, `REDUCE`, `TRANSFORM`) | Fonctions intégrées pour gérer le JSON, notamment les tableaux, l'extraction et la validation. | Non pris en charge | Soutenu | Soutenu | eval array = json_array(1, -1, 2),
result = filter(array, x -> x > 0)
| fields result
|
| [Fonctions de hachage cryptographiques PPL](#supported-ppl-cryptographic-functions)
(`MD5`, `SHA1`, `SHA2`) | Des fonctions intégrées vous permettent de générer des empreintes digitales uniques de données, qui peuvent être utilisées à des fins de vérification, de comparaison ou dans le cadre de protocoles de sécurité plus complexes. | Soutenu | Soutenu | Soutenu | eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')` |
## Informations supplémentaires pour les utilisateurs de CloudWatch Logs Insights utilisant OpenSearch PPL
Bien que CloudWatch Logs Insights prenne en charge la plupart des commandes et fonctions OpenSearch PPL, certaines commandes et fonctions ne sont pas prises en charge actuellement. Par exemple, il ne prend actuellement pas en charge les commandes Lookup dans PPL. Depuis le 2 juin 2025, CloudWatch Logs Insights prend désormais en charge les fonctions JOIN, subqueries, Flatten, Fillnull, Expand, Cidrmatch et JSON dans PPL. Pour obtenir la liste complète des commandes et fonctions de requête prises en charge, consultez les colonnes Amazon CloudWatch Logs dans les tableaux ci-dessus.
### Exemples de requêtes et de quotas
Ce qui suit s'applique à la fois aux utilisateurs de CloudWatch Logs Insights et OpenSearch aux utilisateurs interrogeant CloudWatch des données.
Pour plus d'informations sur les limites applicables lors de l'interrogation de CloudWatch Logs from OpenSearch Service, consultez la section [Quotas de CloudWatch journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) dans le guide de l'utilisateur Amazon CloudWatch Logs. Les limites concernent le nombre de groupes de CloudWatch journaux que vous pouvez interroger, le nombre maximal de requêtes simultanées que vous pouvez exécuter, le temps d'exécution maximal des requêtes et le nombre maximum de lignes renvoyées dans les résultats. Les limites sont les mêmes quel que soit le langage que vous utilisez pour interroger CloudWatch les journaux (à savoir, OpenSearch PPL, SQL et Logs Insights QL).
### Commandes PPL
**Topics**
+ [comment](#supported-ppl-comment)
+ [commande de corrélation](#supported-ppl-correlation-commands)
+ [commande dedup](#supported-ppl-dedup-command)
+ [décrire la commande](#supported-ppl-describe-command)
+ [commande eval](#supported-ppl-eval-command)
+ [commande eventstats](#supported-ppl-eventstats-command)
+ [commande d'extension](#supported-ppl-expand-commands)
+ [expliquer la commande](#supported-ppl-explain-command)
+ [commande fillnull](#supported-ppl-fillnull-command)
+ [commande fields](#supported-ppl-fields-command)
+ [commande aplatir](#supported-ppl-flatten-command)
+ [commande grok](#supported-ppl-grok-command)
+ [commande principale](#supported-ppl-head-command)
+ [commande join](#supported-ppl-join-commands)
+ [commande de recherche](#supported-ppl-lookup-commands)
+ [commande d'analyse](#supported-ppl-parse-command)
+ [commande patterns](#supported-ppl-patterns-command)
+ [commande rare](#supported-ppl-rare-command)
+ [renommer la commande](#supported-ppl-rename-command)
+ [commande de recherche](#supported-ppl-search-command)
+ [commande de tri](#supported-ppl-sort-command)
+ [commande stats](#supported-ppl-stats-command)
+ [commande de sous-requête](#supported-ppl-subquery-commands)
+ [commande supérieure](#supported-ppl-top-command)
+ [commande trendline](#supported-ppl-trendline-commands)
+ [où commande](#supported-ppl-where-command)
+ [résumé du champ](#supported-ppl-field-summary-command)
+ [commande d'extension](#supported-ppl-expand-command)
+ [Fonctions PPL](#supported-ppl-functions-details)
#### comment
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
PPL prend en charge à la fois les commentaires de ligne et les commentaires de bloc. Le système n'évalue pas le texte des commentaires.
**Commentaires sur les lignes**
Les commentaires de ligne commencent par deux barres obliques//et se terminent par une nouvelle ligne.
Exemple :
```
os> source=accounts | top gender // finds most common gender of all the accounts
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Bloquer les commentaires**
Les commentaires en bloc commencent par une barre oblique suivie d'un astérisque \\ \* et se terminent par un astérisque suivi d'une barre oblique \*/.
Exemple :
```
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 |
+------------------+----------+
```
#### commande de corrélation
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Vous pouvez corréler différentes sources de données selon des dimensions et des délais communs.
Cette corrélation est cruciale lorsque vous traitez de grandes quantités de données provenant de différents secteurs verticaux qui partagent les mêmes périodes mais ne sont pas officiellement synchronisées.
En corrélant ces différentes sources de données en fonction de délais et de dimensions similaires, vous pouvez enrichir vos données et découvrir des informations précieuses.
**Exemple**
Le domaine de l'observabilité comporte trois sources de données distinctes :
+ Journaux
+ Métriques
+ Suivis
Ces sources de données peuvent avoir des dimensions communes. Pour passer d'une source de données à une autre, vous devez les corréler correctement. À l'aide de conventions de dénomination sémantiques, vous pouvez identifier les éléments partagés dans les journaux, les traces et les métriques.
Exemple :
```
{
"@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"
}
```
Cet exemple montre un journal AWS ELB provenant d'un service résidant sur AWS. Il affiche une réponse HTTP du backend avec un code d'état de 500, indiquant une erreur. Cela peut déclencher une alerte ou faire partie de votre processus de surveillance habituel. La prochaine étape consiste à recueillir des données pertinentes sur cet événement afin de mener une enquête approfondie.
Bien que vous soyez tenté d'interroger toutes les données relatives à la période, cette approche peut être accablante. Vous pourriez vous retrouver avec trop d'informations et passer plus de temps à filtrer les données non pertinentes qu'à en identifier la cause première.
Vous pouvez plutôt utiliser une approche plus ciblée en corrélant les données provenant de différentes sources. Vous pouvez utiliser les dimensions suivantes à des fins de corrélation :
+ **Adresse IP** - `"ip": "10.0.0.1" | "ip": "**************"`
+ **Port** - `"port": 2817 | "target_port": "10.0.0.1:80"`
En supposant que vous avez accès à des traces et à des indices de mesures supplémentaires et que vous connaissez la structure de votre schéma, vous pouvez créer une requête de corrélation plus précise.
Voici un exemple de document d'index de trace contenant des informations HTTP que vous souhaiterez peut-être corréler :
```
{
"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": {
...
}
}
}
}
}
```
Dans cette approche, vous pouvez voir les `traceId` adresses HTTP et HTTP client/server `ip` qui peuvent être corrélées aux journaux ELB afin de mieux comprendre le comportement et l'état du système.
**Nouvelle commande de requête de corrélation**
Voici la nouvelle commande qui permettrait ce type d'investigation :
```
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 )
```
Voici ce que fait chaque partie de la commande :
1. `source alb_logs, traces`- Cela permet de sélectionner les sources de données que vous souhaitez corréler.
1. `where ip="10.0.0.1" AND cloud.provider="aws"`- Cela permet de réduire la portée de votre recherche.
1. `correlate exact fields(traceId, ip)`- Cela indique au système de corréler les données en fonction des correspondances exactes des champs suivants :
+ Le `ip` champ possède une condition de filtre explicite, il sera donc utilisé dans la corrélation pour toutes les sources de données.
+ Le `traceId` champ ne comporte aucun filtre explicite, il correspondra donc aux mêmes TraceID dans toutes les sources de données.
Les noms des champs indiquent la signification logique de la fonction dans la commande de corrélation. La condition de jointure réelle dépend de l'instruction de mappage que vous fournissez.
Le terme `exact` signifie que les instructions de corrélation nécessiteront que tous les champs correspondent afin de répondre à l'instruction de requête.
Le terme `approximate` tentera de correspondre dans le meilleur des cas et ne rejettera pas les lignes présentant des correspondances partielles.
**Aborder différents types de mappage de terrain**
Dans les cas où le même champ logique (tel que`ip`) porte des noms différents selon vos sources de données, vous devez fournir le mappage explicite des champs de chemin. Pour résoudre ce problème, vous pouvez étendre vos conditions de corrélation pour qu'elles correspondent à différents noms de champs ayant des significations logiques similaires. Voici comment vous pouvez procéder :
```
alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId
```
Pour chaque champ participant à la jointure par corrélation, vous devez fournir une instruction de mappage pertinente qui inclut toutes les tables à joindre par cette commande de corrélation.
**Exemple**
Dans cet exemple, il existe 2 sources : `alb_logs, traces`
Il y a 2 champs : `traceId, ip`
Il existe deux instructions de mappage : `alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId`
**Définition des délais de corrélation**
Pour simplifier le travail effectué par le moteur d'exécution (pilote), vous pouvez ajouter l'instruction scope. Cela indique explicitement à la requête de jointure l'heure à laquelle elle doit effectuer cette recherche.
`scope(@timestamp, 1D)`je
Dans cet exemple, le champ de recherche se concentre sur une base quotidienne, de sorte que les corrélations apparaissant le même jour sont regroupées. Ce mécanisme de cadrage simplifie et permet un meilleur contrôle des résultats, permettant une résolution de recherche incrémentielle en fonction de vos besoins.
**Soutenir les conducteurs**
La nouvelle commande de corrélation est en fait une commande de jointure « cachée ». Par conséquent, seuls les pilotes PPL suivants prennent en charge cette commande. Dans ces pilotes, la commande de corrélation sera directement traduite dans le plan logique Catalyst Join approprié.
**Exemple**
`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 logique :**
```
'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]
```
Le moteur Catalyst optimise cette requête en fonction de l'ordre des jointures le plus efficace.
#### commande dedup
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `dedup` commande pour supprimer des documents identiques de vos résultats de recherche en fonction des champs spécifiés.
**Syntaxe**
Utilisez la syntaxe suivante :
```
dedup [int] [keepempty=] [consecutive=]
```
**`int`**
+ Facultatif.
+ La `dedup` commande conserve plusieurs événements pour chaque combinaison lorsque vous la spécifiez. Le nombre pour doit être supérieur à 0. Si vous ne spécifiez aucun chiffre, seul le premier événement est conservé. Tous les autres doublons sont supprimés des résultats.
+ Valeur par défaut : 1
**`keepempty`**
+ Facultatif.
+ Si la valeur est vraie, conserve les documents pour lesquels un champ de la liste de champs possède une valeur NULL ou est MANQUANT.
+ Valeur par défaut : false
**`consecutive`**
+ Facultatif.
+ Si vrai, supprime uniquement les événements comportant des combinaisons de valeurs dupliquées consécutives.
+ Valeur par défaut : false
**`field-list`**
+ Obligatoire.
+ Liste de champs séparés par des virgules. Au moins un champ est obligatoire.
**Exemple 1 : Déduplication par un champ**
Cet exemple montre comment dédupliquer des documents à l'aide du champ de genre.
Requête PPL :
```
os> source=accounts | dedup gender | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Exemple 2 : conserver 2 doublons de documents**
L'exemple montre comment dédupliquer des documents avec le champ de genre, en conservant deux doublons.
Requête 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 |
+------------------+----------+
```
**Exemple 3 : conserver ou ignorer le champ vide par défaut**
L'exemple montre comment déduper le document en conservant le champ de valeur nulle.
Requête 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 |
+------------------+-----------------------+
```
L'exemple montre comment déduper le document en ignorant le champ de valeur vide.
Requête 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 |
+------------------+-----------------------+
```
**Exemple 4 : Déduplication dans des documents consécutifs**
L'exemple montre comment procéder à la déduplication dans des documents consécutifs.
Requête 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 |
+------------------+----------+
```
**Exemples supplémentaires**
+ `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`(la déduplication consécutive n'est pas prise en charge)
**Limitation**
+ Pour `| 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
```
+ Pour `| 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
```
#### décrire la commande
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `describe` commande pour obtenir des informations détaillées sur la structure et les métadonnées des tables, des schémas et des catalogues. Voici différents exemples et cas d'utilisation de la `describe` commande.
**Décrire**
+ `describe table`Cette commande est égale à la commande `DESCRIBE EXTENDED table` SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
#### commande eval
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
La `eval` commande évalue l'expression et ajoute le résultat au résultat de la recherche.
**Syntaxe**
Utilisez la syntaxe suivante :
```
eval = ["," = ]...
```
+ `field`: Obligatoire. Si le nom du champ n'existe pas, un nouveau champ est ajouté. Si le nom du champ existe déjà, il sera remplacé.
+ `expression`: Obligatoire. Toute expression prise en charge par le système.
**Exemple 1 : créer le nouveau champ**
Cet exemple montre comment créer un nouveau `doubleAge` champ pour chaque document. Le nouveau `doubleAge` est le résultat de l'évaluation de l'âge multiplié par 2.
Requête 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 |
+-------+-------------+
```
**Exemple 2 : remplacer le champ existant**
Cet exemple montre comment remplacer le champ d'âge existant par l'âge plus 1.
Requête PPL :
```
os> source=accounts | eval age = age + 1 | fields age ;
fetched rows / total rows = 4/4
+-------+
| age |
|-------|
| 33 |
| 37 |
| 29 |
| 34 |
+-------+
```
**Exemple 3 : créer le nouveau champ avec le champ défini dans eval**
Cet exemple montre comment créer un nouveau `ddAge` champ avec un champ défini dans la commande eval. Le nouveau champ `ddAge` est le résultat de l'évaluation `doubleAge` multiplié par 2, `doubleAge` défini dans la commande eval.
Requête 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 |
+-------+-------------+---------+
```
Hypothèses :`a`,`b`, `c` existe-t-il des champs dans `table`
**Exemples supplémentaires**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(champs de sortie 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`
**Eval avec exemple de cas :**
```
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')
```
**Eval avec un autre exemple de cas :**
Hypothèses :`a`,`b`, `c` existe-t-il des champs dans `table`
**Exemples supplémentaires**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(champs de sortie 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`
**Eval avec exemple de cas :**
```
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')
```
**Eval avec un autre exemple de cas :**
```
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
```
**Limitations**
+ Le remplacement de champs existants n'est pas pris en charge. Les requêtes qui tentent de le faire généreront des exceptions avec le message « La référence « a » est ambiguë ».
```
- `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`
```
#### commande eventstats
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `eventstats` commande pour enrichir les données de vos événements avec des statistiques récapitulatives calculées. Il fonctionne en analysant des champs spécifiques au sein de vos événements, en calculant diverses mesures statistiques, puis en ajoutant ces résultats sous forme de nouveaux champs à chaque événement d'origine.
**Principaux aspects des statistiques sur les événements**
1. Il effectue des calculs sur l'ensemble des résultats ou au sein de groupes définis.
1. Les événements d'origine restent intacts et de nouveaux champs ont été ajoutés pour contenir les résultats statistiques.
1. La commande est particulièrement utile pour effectuer des analyses comparatives, identifier les valeurs aberrantes ou fournir un contexte supplémentaire à des événements individuels.
**Différence entre les statistiques et les statistiques des événements**
Les `eventstats` commandes `stats` and sont toutes deux utilisées pour calculer des statistiques, mais elles présentent des différences importantes dans leur mode de fonctionnement et dans ce qu'elles produisent.
**Format de sortie**
+ `stats`: produit un tableau récapitulatif contenant uniquement les statistiques calculées.
+ `eventstats`: ajoute les statistiques calculées sous forme de nouveaux champs aux événements existants, en préservant les données d'origine.
**Rétention des événements**
+ `stats`: réduit le jeu de résultats au seul résumé statistique, en supprimant les événements individuels.
+ `eventstats`: conserve tous les événements d'origine et ajoute de nouveaux champs avec les statistiques calculées.
**Cas d’utilisation**
+ `stats`: Idéal pour créer des rapports de synthèse ou des tableaux de bord. Souvent utilisée comme commande finale pour résumer les résultats.
+ `eventstats`: Utile lorsque vous devez enrichir des événements avec un contexte statistique pour une analyse ou un filtrage plus approfondis. Peut être utilisé en cours de recherche pour ajouter des statistiques qui pourront être utilisées dans les commandes suivantes.
**Syntaxe**
Utilisez la syntaxe suivante :
```
eventstats ... [by-clause]
```
**agrégation**
+ Obligatoire.
+ Fonction d'agrégation.
+ L'argument de l'agrégation doit être un champ.
**clause**
+ Facultatif.
+ Syntaxe : `by [span-expression,] [field,]...`
+ La clause by peut inclure des champs et des expressions tels que des fonctions scalaires et des fonctions d'agrégation. Vous pouvez également utiliser la clause span pour diviser un champ spécifique en compartiments à intervalles égaux. La commande eventstats effectue ensuite une agrégation en fonction de ces compartiments span.
+ Par défaut : si vous ne spécifiez pas de clause by, la commande eventstats agrège l'ensemble des résultats.
**étendre l'expression**
+ Facultatif, au plus un.
+ Syntaxe : `span(field_expr, interval_expr)`
+ L'unité de l'expression d'intervalle est l'unité naturelle par défaut. Toutefois, pour les champs de type date et heure, vous devez spécifier l'unité dans l'expression d'intervalle lorsque vous utilisez des unités de date/heure.
Par exemple, pour diviser le champ `age` en compartiments sur 10 ans, utilisez`span(age, 10)`. Pour les champs temporels, vous pouvez diviser un `timestamp` champ en intervalles horaires à l'aide `span(timestamp, 1h)` de.
**Unités de temps disponibles**
| Unités d'intervalle d'intervalle |
| --- |
| milliseconde (ms) |
| seconde (s) |
| minute (m, distinction majuscules et minuscules) |
| heure (h) |
| jour (d) |
| semaine (s) |
| mois (M, distinction majuscules et minuscules) |
| trimestre (q) |
| année (y) |
**Fonctions d'agrégation**
**`COUNT`**
`COUNT`renvoie le nombre d'expr dans les lignes récupérées par une instruction SELECT.
Pour les CloudWatch journaux, les requêtes d'utilisation ne `COUNT` sont pas prises en charge.
Exemple :
```
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)`renvoie la somme de expr.
Exemple :
```
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)`renvoie la valeur moyenne de expr.
Exemple :
```
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)`Renvoie la valeur maximale de expr.
Exemple
```
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)`Renvoie la valeur minimale de expr.
Exemple
```
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)`Renvoie l'écart type de l'échantillon de expr.
Exemple
```
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)`Renvoie l'écart type de population de expr.
Exemple
```
os> source=accounts | eventstats stddev_pop(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_pop(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2.**************** |
| 6 | 5686 | Mary | Major | 36 | M | *** Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 2.**************** |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 2.**************** |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2.**************** |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**PERCENTILE ou PERCENTILE\_APPROX**
`PERCENTILE(expr, percent)`ou `PERCENTILE_APPROX(expr, percent)` Renvoie la valeur percentile approximative de expr au pourcentage spécifié.
**pourcentage**
+ Le nombre doit être une constante comprise entre 0 et 100.
Exemple
```
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
```
**Exemple 1 : calculer la moyenne, la somme et le nombre d'un champ par groupe**
L'exemple montre comment calculer l'âge moyen, la somme de l'âge et le nombre d'événements de tous les comptes regroupés par sexe.
```
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
```
**Exemple 2 : calculer le nombre par intervalle**
L'exemple obtient le décompte de l'âge par intervalle de 10 ans.
```
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
```
**Exemple 3 : calculer le nombre par sexe et par intervalle**
L'exemple obtient le décompte de l'âge par intervalle de 5 ans et le groupe par sexe.
```
os> source=accounts | eventstats count() as cnt by span(age, 5) as age_span, gender
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | cnt |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
| 1 | 39225 | Jane | Doe | 32 | M | *** Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2 |
| 6 | 5686 | Mary | Majo | 36 | M | 671 Example Street | Any Company | hattiebond@anycompany.com | Dante | TN | 1 |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 1 |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
```
**Usage**
+ `source = table | eventstats avg(a)`
+ `source = table | where a < 50 | eventstats avg(c)`
+ `source = table | eventstats max(c) by b`
+ `source = table | eventstats count(c) by b | head 5`
+ `source = table | eventstats distinct_count(c)`
+ `source = table | eventstats stddev_samp(c)`
+ `source = table | eventstats stddev_pop(c)`
+ `source = table | eventstats percentile(c, 90)`
+ `source = table | eventstats percentile_approx(c, 99)`
**Agrégations avec 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`
**Agrégations avec plage horaire (fonction de fenêtrage automatique)**
+ `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`
**Les agrégations sont regroupées par plusieurs niveaux**
+ `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`
#### commande d'extension
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `expand` commande pour aplatir un champ de type :
+ `Array`
+ `Map`
**Syntaxe**
Utilisez la syntaxe suivante :
```
expand [As alias]
```
**field**
+ Le champ à étendre (exploser). Doit être d'un type compatible.
**alias**
+ Facultatif. Le nom à utiliser à la place du nom de champ d'origine.
**Usage**
La `expand` commande produit une ligne pour chaque élément du tableau ou du champ de carte spécifié, où :
+ Les éléments du tableau deviennent des lignes individuelles.
+ Les paires clé-valeur de la carte sont divisées en lignes distinctes, chaque valeur-clé étant représentée par une ligne.
+ Lorsqu'un alias est fourni, les valeurs éclatées sont représentées sous l'alias au lieu du nom du champ d'origine.
+ Cela peut être utilisé en combinaison avec d'autres commandes, telles que `stats``eval`, et `parse` pour manipuler ou extraire des données après l'extension.
**Exemples**
+ `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`
#### expliquer la commande
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
La `explain` commande vous aide à comprendre les plans d'exécution des requêtes, ce qui vous permet d'analyser et d'optimiser vos requêtes pour de meilleures performances. Cette introduction fournit un aperçu concis de l'objectif de la commande explain et de son importance dans l'optimisation des requêtes.
**Comment**
+ `source=accounts | top gender // finds most common gender of all the accounts`(commentaire en ligne)
+ `source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender`(bloquer les commentaires)
**Décrire**
+ `describe table`Cette commande est égale à la commande `DESCRIBE EXTENDED table` SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
**Expliquer**
+ `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`
**Champs**
+ `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`
**Résumé du champ**
+ `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`
**Champ imbriqué**
+ `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`
**Filtres**
+ `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`- Remarque : Cela renvoie a >= 1 et a <= 4, c'est-à-dire [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Remarque : cela renvoie b >= '\*\*\*\*\*\*\*\*\*\*' et 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`
**Requêtes liées à l'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`
**Filtres complexes**
```
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
```
**Filtres avec conditions logiques**
+ `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`
**Éval**
Hypothèses :`a`,`b`, `c` existe-t-il des champs dans `table`
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(champs de sortie 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`
#### commande fillnull
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
**Description**
Utilisez la `fillnull` commande pour remplacer les valeurs nulles par une valeur spécifiée dans un ou plusieurs champs de vos résultats de recherche.
**Syntaxe**
Utilisez la syntaxe suivante :
```
fillnull [with in ["," ]] | [using = ["," = ]]
```
+ null-replacement : obligatoire. La valeur utilisée pour remplacer les valeurs nulles.
+ champ nul : obligatoire. Référence de champ. Les valeurs nulles de ce champ seront remplacées par la valeur spécifiée dans null-replacement.
**Exemple 1 : remplir un champ nul**
L'exemple montre comment utiliser fillnull sur un seul champ :
```
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 |
```
**Exemple 2 : Fillnull appliqué à plusieurs champs**
L'exemple montre que fillnull est appliqué à plusieurs champs.
```
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 |
```
**Exemple 3 : Fillnull appliqué à plusieurs champs avec différentes valeurs de remplacement nulles.**
L'exemple montre fillnull avec différentes valeurs utilisées pour remplacer les valeurs nulles.
+ `/error`sur le `request_path` terrain
+ `1970-01-01 00:00:00`sur le `timestamp` terrain
```
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 |
```
#### commande fields
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `fields` commande pour conserver ou supprimer des champs dans les résultats de recherche.
**Syntaxe**
Utilisez la syntaxe suivante :
```
field [+|-]
```
+ `index`: Facultatif.
Si le signe plus (\+) est utilisé, seuls les champs spécifiés dans la liste des champs seront conservés.
Si le signe moins (-) est utilisé, tous les champs spécifiés dans la liste des champs seront supprimés.
*Par défaut* : \+
+ `field list`: Obligatoire. Liste de champs séparés par des virgules à conserver ou à supprimer.
**Exemple 1 : sélectionner les champs spécifiés dans le résultat**
Cet exemple montre comment récupérer des `lastname` champs `account_number``firstname`, et à partir des résultats de recherche.
Requête 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 |
+------------------+-------------+------------+
```
**Exemple 2 : Supprimer les champs spécifiés du résultat**
Cet exemple montre comment supprimer le `account_number` champ des résultats de recherche.
Requête 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 |
+-------------+------------+
```
**Exemples supplémentaires**
+ `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`
Exemple de champs imbriqués :
```
`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`
```
#### commande aplatir
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la commande aplatir pour développer les champs des types suivants :
+ `struct`
+ `array>`
**Syntaxe**
Utilisez la syntaxe suivante :
```
flatten
```
+ *champ* : champ à aplatir. Le champ doit être d'un type compatible.
**Schema** (Schéma)
| col\_name | data\_type |
| --- | --- |
| \_heure | chaîne |
| ponts | tableau |
| city | chaîne |
| couleur | structure |
| country | chaîne |
**Données**
| \_heure | ponts | city | couleur | country |
| --- | --- | --- | --- | --- |
| 13/09/2024 À 12:00:00 | [{801, Tower Bridge}, {928, London Bridge}] | Londres | {35, 51,5074, -0,1278} | Angleterre |
| 13/09/2024 À 12:00:00 | [{232, Pont-Neuf}, {160, Pont Alexandre III}] | Paris | {35, 48,8566, 2,3522} | France |
| 13/09/2024 À 12:00:00 | [{48, Pont du Rialto}, {11, Pont des Soupirs}] | Venise | {2, 45,4408, 12,3155} | Italie |
| 13/09/2024 À 12:00:00 | [{\*\*\*, Pont Charles}, {343, Pont de la Légion}] | Prague | {200, 50,0755, 14,4378} | République tchèque |
| 13/09/2024 À 12:00:00 | [{375, Pont à chaînes}, {333, Pont de la Liberté}] | Budapest | {96, 47,4979, 19,0402} | Hongrie |
| 13/09/1990 12:00:00 | NULL | Varsovie | NULL | Pologne |
**Exemple 1 : aplatir la structure**
Cet exemple montre comment aplatir un champ de structure.
Requête PPL :
```
source=table | flatten coor
```
| \_heure | ponts | city | country | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- |
| 13/09/2024 À 12:00:00 | [{801, Tower Bridge}, {928, London Bridge}] | Londres | Angleterre | 35 | 51,5074 | -0,1278 |
| 13/09/2024 À 12:00:00 | [{232, Pont-Neuf}, {160, Pont Alexandre III}] | Paris | France | 35 | 48,8566 | 2,3522 |
| 13/09/2024 À 12:00:00 | [{48, Pont du Rialto}, {11, Pont des Soupirs}] | Venise | Italie | 2 | 45,4408 | 12,3155 |
| 13/09/2024 À 12:00:00 | [{516, Pont Charles}, {343, Pont de la Légion}] | Prague | République tchèque | 200 | 50,0755 | 14,4378 |
| 13/09/2024 À 12:00:00 | [{375, Pont à chaînes}, {333, Pont de la Liberté}] | Budapest | Hongrie | 96 | 47,4979 | 19,0402 |
| 13/09/1990 12:00:00 | NULL | Varsovie | Pologne | NULL | NULL | NULL |
**Exemple 2 : aplatir un tableau**
L'exemple montre comment aplatir un tableau de champs de structure.
Requête PPL :
```
source=table | flatten bridges
```
| \_heure | city | couleur | country | longueur | name |
| --- | --- | --- | --- | --- | --- |
| 13/09/2024 À 12:00:00 | Londres | {35, 51,5074, -0,1278} | Angleterre | 801 | Tower Bridge |
| 13/09/2024 À 12:00:00 | Londres | {35, 51,5074, -0,1278} | Angleterre | 928 | Pont de Londres |
| 13/09/2024 À 12:00:00 | Paris | {35, 48,8566, 2,3522} | France | 232 | Pont-Neuf |
| 13/09/2024 À 12:00:00 | Paris | {35, 48,8566, 2,3522} | France | 160 | Pont Alexandre III |
| 13/09/2024 À 12:00:00 | Venise | {2, 45,4408, 12,3155} | Italie | 48 | Pont du Rialto |
| 13/09/2024 À 12:00:00 | Venise | {2, 45,4408, 12,3155} | Italie | 11 | Pont des Soupirs |
| 13/09/2024 À 12:00:00 | Prague | {200, 50,0755, 14,4378} | République tchèque | 516 | Pont Charles |
| 13/09/2024 À 12:00:00 | Prague | {200, 50,0755, 14,4378} | République tchèque | 343 | Pont de la Legion |
| 13/09/2024 À 12:00:00 | Budapest | {96, 47,4979, 19,0402} | Hongrie | 375 | Pont à chaînes |
| 13/09/2024 À 12:00:00 | Budapest | {96, 47,4979, 19,0402} | Hongrie | 333 | Pont de la Liberté |
| 13/09/1990 12:00:00 | Varsovie | NULL | Pologne | NULL | NULL |
**Exemple 3 : aplatir un tableau et une structure**
Cet exemple montre comment aplatir plusieurs champs.
Requête PPL :
```
source=table | flatten bridges | flatten coor
```
| \_heure | city | country | longueur | name | alt | lat | long |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 13/09/2024 À 12:00:00 | Londres | Angleterre | 801 | Tower Bridge | 35 | 51,5074 | -0,1278 |
| 13/09/2024 À 12:00:00 | Londres | Angleterre | 928 | Pont de Londres | 35 | 51,5074 | -0,1278 |
| 13/09/2024 À 12:00:00 | Paris | France | 232 | Pont-Neuf | 35 | 48,8566 | 2,3522 |
| 13/09/2024 À 12:00:00 | Paris | France | 160 | Pont Alexandre III | 35 | 48,8566 | 2,3522 |
| 13/09/2024 À 12:00:00 | Venise | Italie | 48 | Pont du Rialto | 2 | 45,4408 | 12,3155 |
| 13/09/2024 À 12:00:00 | Venise | Italie | 11 | Pont des Soupirs | 2 | 45,4408 | 12,3155 |
| 13/09/2024 À 12:00:00 | Prague | République tchèque | 516 | Pont Charles | 200 | 50,0755 | 14,4378 |
| 13/09/2024 À 12:00:00 | Prague | République tchèque | 343 | Pont de la Legion | 200 | 50,0755 | 14,4378 |
| 13/09/2024 À 12:00:00 | Budapest | Hongrie | 375 | Pont à chaînes | 96 | 47,4979 | 19,0402 |
| 13/09/2024 À 12:00:00 | Budapest | Hongrie | 333 | Pont de la Liberté | 96 | 47,4979 | 19,0402 |
| 13/09/1990 12:00:00 | Varsovie | Pologne | NULL | NULL | NULL | NULL | NULL |
#### commande grok
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
La `grok` commande analyse un champ de texte avec un motif grok et ajoute les résultats au résultat de recherche.
**Syntaxe**
Utilisez la syntaxe suivante :
```
grok
```
**field**
+ Obligatoire.
+ Le champ doit être un champ de texte.
**pattern**
+ Obligatoire.
+ Le modèle grok utilisé pour extraire de nouveaux champs d'un champ de texte donné.
+ Si un nouveau nom de champ existe déjà, il remplacera le champ d'origine.
**Modèle grok**
Le modèle grok est utilisé pour faire correspondre le champ de texte de chaque document afin d'extraire de nouveaux champs.
**Exemple 1 : créer le nouveau champ**
Cet exemple montre comment créer un nouveau champ `host` pour chaque document. `host`sera le nom d'hôte indiqué après `@` dans le `email` champ. L'analyse d'un champ nul renverra une chaîne vide.
```
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 |
+-------------------------+-------------+
```
**Exemple 2 : remplacer le champ existant**
Cet exemple montre comment remplacer le `address` champ existant en supprimant le numéro de rue.
```
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 |
+------------------+
```
**Exemple 3 : utilisation de grok pour analyser les journaux**
Cet exemple montre comment utiliser grok pour analyser des journaux bruts.
```
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 |
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
```
**Limitations**
La commande grok a les mêmes limites que la commande parse.
#### commande principale
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `head` commande pour renvoyer le premier nombre N de résultats spécifiés après un décalage facultatif dans l'ordre de recherche.
**Syntaxe**
Utilisez la syntaxe suivante :
```
head [] [from ]
```
****
+ Entier facultatif.
+ Le nombre de résultats à renvoyer.
+ Par défaut: 10
****
+ Entier après facultatif`from`.
+ Le nombre de résultats à ignorer.
+ Par défaut : 0
**Exemple 1 : Obtenir les 10 premiers résultats**
Cet exemple montre comment récupérer un maximum de 10 résultats à partir de l'index des comptes.
Requête PPL :
```
os> source=accounts | fields firstname, age | head;
fetched rows / total rows = 4/4
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
**Exemple 2 : obtenir les N premiers résultats**
L'exemple montre les N premiers résultats de l'index des comptes.
Requête PPL :
```
os> source=accounts | fields firstname, age | head 3;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
+-------------+-------+
```
**Exemple 3 : obtenir les N premiers résultats après le décalage M**
Cet exemple montre comment récupérer les N premiers résultats après avoir ignoré M résultats de l'index des comptes.
Requête 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 |
+-------------+-------+
```
#### commande join
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
La commande join vous permet de combiner des données provenant de plusieurs sources sur la base de champs communs, ce qui vous permet d'effectuer des analyses complexes et d'obtenir des informations plus approfondies à partir de vos ensembles de données distribués
**Schema**
Il existe au moins deux indices, `otel-v1-apm-span-*` (grand) et `otel-v1-apm-service-map` (petit).
Champs pertinents issus des indices :
**`otel-v1-apm-span-*`**
+ TraceID : identifiant unique pour une trace. Tous les spans d'une même trace partagent le même TraceID.
+ SpanID : identifiant unique d'une plage au sein d'une trace, attribué lors de la création de la plage.
+ parentSpanId - Le SpanID de l'espace parent de ce span. S'il s'agit d'une plage racine, ce champ doit être vide.
+ durationInNanos - La différence en nanosecondes entre StartTime et EndTime. (c'est `latency` dans l'interface utilisateur)
+ ServiceName : ressource d'où provient le span.
+ TraceGroup : nom de l'intervalle racine de la trace.
**`otel-v1-apm-service-map`**
+ ServiceName : nom du service qui a émis le span.
+ destination.domain - Le ServiceName du service appelé par ce client.
+ destination.resource - Le nom de l'intervalle (API, opération, etc.) appelé par ce client.
+ target.domain - Le ServiceName du service appelé par un client.
+ target.resource - Le nom de l'intervalle (API, opération, etc.) appelé par un client.
+ traceGroupName - Le nom de l'intervalle de niveau supérieur qui a lancé la chaîne de demandes.
**Exigence**
Support **join** pour calculer les éléments suivants :
Pour chaque service, associez l'index span à l'index de la carte des services afin de calculer les métriques selon différents types de filtres.
Cet exemple de requête calcule le temps de latence lorsqu'il est filtré par groupe de traces `client_cancel_order` pour le `order` service.
```
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`)
```
**Migrer vers PPL**
Syntaxe de la commande join
```
SEARCH source=
|
| [joinType] JOIN
[leftAlias]
ON joinCriteria
|
```
**Réécriture**
```
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
```
**Type de joint**
+ Syntaxe : `INNER | LEFT OUTER | CROSS`
+ Facultatif
+ Type de jointure à effectuer. La valeur par défaut est `INNER` si elle n'est pas spécifiée.
**Alias de gauche**
+ Syntaxe : `left = `
+ Facultatif
+ Alias de sous-requête à utiliser avec le côté gauche de la jointure, afin d'éviter toute ambiguïté en matière de dénomination.
**Critères d'adhésion**
+ Syntaxe : ``
+ Obligatoire
+ La syntaxe commence par`ON`. Il peut s'agir de n'importe quelle expression de comparaison. En général, les critères de jointure sont les `.=.` suivants :
Par exemple : `l.id = r.id`. Si les critères de jointure contiennent plusieurs conditions, vous pouvez spécifier `AND` un `OR` opérateur entre chaque expression de comparaison. Par exemple, `l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)`.
**Exemples supplémentaires**
Migration depuis une requête 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;
```
Réécrit par une requête de jointure PPL :
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey AND o_comment NOT LIKE '%unusual%packages%'
orders
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
Limitation : les sous-recherches ne sont pas prises en charge dans le côté droit de jointure.
Si les sous-recherches sont prises en charge, vous pouvez réécrire la requête PPL ci-dessus comme suit :
```
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
```
#### commande de recherche
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `lookup` commande pour enrichir vos données de recherche en ajoutant ou en remplaçant les données d'un index de recherche (table de dimensions). Cette commande permet d'étendre les champs d'un index avec des valeurs issues d'une table de dimensions. Vous pouvez également l'utiliser pour ajouter ou remplacer des valeurs lorsque les conditions de recherche sont remplies. La `lookup` commande est plus adaptée que la `Join` commande pour enrichir les données sources avec un ensemble de données statique.
**Syntaxe**
Utilisez la syntaxe suivante :
```
SEARCH source=
|
| LOOKUP ( [AS ])...
[(REPLACE | APPEND) ( [AS ])...]
|
```
**Index de recherche**
+ Obligatoire.
+ Nom de l'index de recherche (table de dimensions).
**lookupMappingField**
+ Obligatoire.
+ Une clé de mappage dans l'index de recherche, analogue à une clé de jointure de la table de droite. Vous pouvez spécifier plusieurs champs, séparés par des virgules.
**sourceMappingField**
+ Facultatif.
+ Par défaut : < lookupMappingField >.
+ Une clé de mappage issue de la requête source, analogue à une clé de jointure située sur le côté gauche.
**Champ de saisie**
+ Facultatif.
+ Par défaut : tous les champs de l'index de recherche contenant des valeurs correspondantes sont trouvées.
+ Champ de l'index de recherche dans lequel les valeurs correspondantes sont appliquées au résultat en sortie. Vous pouvez spécifier plusieurs champs, séparés par des virgules.
**Champ de sortie**
+ Facultatif.
+ Valeur par défaut : ``.
+ Un champ dans la sortie. Vous pouvez spécifier plusieurs champs de sortie. Si vous spécifiez un nom de champ existant à partir de la requête source, ses valeurs seront remplacées ou ajoutées par des valeurs correspondantes provenant d'InputField. Si vous spécifiez un nouveau nom de champ, il sera ajouté aux résultats.
**REMPLACER \| AJOUTER**
+ Facultatif.
+ Par défaut : REPLACE
+ Spécifie comment gérer les valeurs correspondantes. Si vous spécifiez REPLACE, les valeurs correspondantes dans le champ remplacent les valeurs du résultat. Si vous le spécifiez`APPEND`, les valeurs correspondantes dans le champ ne sont ajoutées qu'aux valeurs manquantes dans le résultat.
**Usage**
+ ID DE RECHERCHE EN TANT QUE CID REMPLACER LE courrier EN TANT QU'e-mail
+ NOM DE RECHERCHE REMPLACER LE courrier PAR e-mail
+ L'identifiant de recherche est un cid, le nom, l'adresse, l'adresse, le courrier, un e-mail
+ ID LOOKUP
**Exemple**
Voir les exemples suivantes.
```
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
```
#### commande d'analyse
La `parse` commande analyse un champ de texte avec une expression régulière et ajoute le résultat au résultat de la recherche.
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
**Syntaxe**
Utilisez la syntaxe suivante :
```
parse
```
**`field`**
+ Obligatoire.
+ Le champ doit être un champ de texte.
**`pattern`**
+ Chaîne obligatoire.
+ Il s'agit du modèle d'expression régulière utilisé pour extraire de nouveaux champs d'un champ de texte donné.
+ Si un nouveau nom de champ existe déjà, il remplacera le champ d'origine.
**Expression régulière**
Le modèle d'expression régulière est utilisé pour faire correspondre l'ensemble du champ de texte de chaque document avec le moteur Java Regex. Chaque groupe de capture nommé dans l'expression deviendra un nouveau `STRING` champ.
**Exemple 1 : créer un nouveau champ**
L'exemple montre comment créer un nouveau champ `host` pour chaque document. `host`sera le nom d'hôte indiqué après `@` dans le `email` champ. L'analyse d'un champ nul renverra une chaîne vide.
Requête 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 |
+-----------------------+-------------+
```
**Exemple 2 : remplacer un champ existant**
L'exemple montre comment remplacer le `address` champ existant en supprimant le numéro de rue.
Requête PPL :
```
os> source=accounts | parse address '\d+ (?.+)' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Example Street |
| Example Avenue |
| Example Court |
+------------------+
```
**Exemple 3 : Filtrer et trier par champ analysé casté**
L'exemple montre comment trier les numéros de rue supérieurs à 500 dans le `address` champ.
Requête 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 |
+----------------+----------------+
```
**Limitations**
La commande parse comporte quelques limites :
+ Les champs définis par analyse ne peuvent pas être analysés à nouveau.
La commande suivante ne fonctionnera pas :
```
source=accounts | parse address '\d+ (?.+)' | parse street '\w+ (?\w+)'
```
+ Les champs définis par parse ne peuvent pas être remplacés par d'autres commandes.
`where`ne correspondra à aucun document car il `street` ne peut pas être remplacé :
```
source=accounts | parse address '\d+ (?.+)' | eval street='1' | where street='1' ;
```
+ Le champ de texte utilisé par l'analyse ne peut pas être remplacé.
`street`ne sera pas analysé avec succès car il `address` est remplacé :
```
source=accounts | parse address '\d+ (?.+)' | eval address='1' ;
```
+ Les champs définis par parse ne peuvent pas être filtrés ou triés après les avoir utilisés dans la `stats` commande.
`where`dans la commande suivante ne fonctionnera pas :
```
source=accounts | parse email '.+@(?.+)' | stats avg(age) by host | where host=pyrami.com ;
```
#### commande patterns
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
La `patterns` commande extrait les modèles de journalisation d'un champ de texte et ajoute les résultats au résultat de recherche. Le regroupement des journaux en fonction de leurs modèles facilite l'agrégation des statistiques provenant de gros volumes de données de journaux à des fins d'analyse et de résolution des problèmes.
**Syntaxe**
Utilisez la syntaxe suivante :
```
patterns [new_field=] [pattern=]
```
**new-field-name**
+ Chaîne facultative.
+ Il s'agit du nom du nouveau champ pour les modèles extraits.
+ La valeur par défaut est `patterns_field`.
+ Si le nom existe déjà, il remplacera le champ d'origine.
**pattern**
+ Chaîne facultative.
+ Il s'agit du modèle regex des caractères qui doivent être filtrés du champ de texte.
+ En cas d'absence, le modèle par défaut est constitué de caractères alphanumériques (`[a-zA-Z\d]`).
**field**
+ Obligatoire.
+ Le champ doit être un champ de texte.
**Exemple 1 : créer le nouveau champ**
L'exemple montre comment utiliser des extraits de ponctuation `email` pour chaque document. L'analyse d'un champ nul renverra une chaîne vide.
Requête 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 | @. |
+-----------------------+------------------+
```
**Exemple 2 : Extraire les modèles de log**
L'exemple montre comment extraire les ponctuations d'un champ de journal brut en utilisant les modèles par défaut.
Requête 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 | ... - - [//::: -] " / /." |
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
```
**Exemple 3 : Extraire des modèles de journal avec un modèle de regex personnalisé**
L'exemple montre comment extraire les ponctuations d'un champ de journal brut à l'aide de modèles définis par l'utilisateur.
Requête 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/." |
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
```
**Limitation**
La commande patterns présente les mêmes limites que la commande parse.
#### commande rare
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `rare` commande pour rechercher le tuple de valeurs le moins courant de tous les champs de la liste de champs.
**Note**
Un maximum de 10 résultats sont renvoyés pour chaque tuple distinct de valeurs des champs groupés.
**Syntaxe**
Utilisez la syntaxe suivante :
```
rare [N] [by-clause] rare_approx [N] [by-clause]
```
**liste de champs**
+ Obligatoire.
+ Liste de noms de champs séparés par des virgules.
**clause**
+ Facultatif.
+ Un ou plusieurs champs par lesquels regrouper les résultats.
**N**
+ Le nombre de résultats à renvoyer.
+ Par défaut: 10
**rare\_approx**
+ Le nombre approximatif de (n) champs rares en utilisant la [cardinalité estimée par l'algorithme HyperLogLog \+\+](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html).
**Exemple 1 : trouver les valeurs les moins courantes dans un champ**
L'exemple permet de trouver le sexe le moins courant de tous les comptes.
Requête 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 |
+----------+
```
**Exemple 2 : Trouvez les valeurs les moins courantes organisées par sexe**
L'exemple permet de trouver l'âge le moins courant de tous les comptes regroupés par sexe.
Requête 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 |
+----------+-------+
```
#### renommer la commande
Utilisez la `rename` commande pour modifier le nom d'un ou de plusieurs champs dans les résultats de recherche.
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
**Syntaxe**
Utilisez la syntaxe suivante :
```
rename AS ["," AS ]...
```
**champ-source**
+ Obligatoire.
+ Il s'agit du nom du champ que vous souhaitez renommer.
**champ cible**
+ Obligatoire.
+ Il s'agit du nom que vous souhaitez renommer.
**Exemple 1 : renommer un champ**
Cet exemple montre comment renommer un seul champ.
Requête PPL :
```
os> source=accounts | rename account_number as an | fields an;
fetched rows / total rows = 4/4
+------+
| an |
|------|
| 1 |
| 6 |
| 13 |
| 18 |
+------+
```
**Exemple 2 : renommer plusieurs champs**
Cet exemple montre comment renommer plusieurs champs.
Requête 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 |
+------+---------+
```
**Limitations**
+ Le remplacement d'un champ existant n'est pas pris en charge :
```
source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address
```
#### commande de recherche
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `search` commande pour récupérer des documents à partir d'un index. La `search` commande ne peut être utilisée que comme première commande dans une requête PPL.
**Syntaxe**
Utilisez la syntaxe suivante :
```
search source=[:] [boolean-expression]
```
**search**
+ Facultatif.
+ Mots clés de recherche, qui peuvent être omis.
**index**
+ Obligatoire.
+ La commande de recherche doit spécifier l'index à partir duquel effectuer la requête.
+ Le nom de l'index peut être préfixé par `:` pour les recherches entre clusters.
**expression booléenne**
+ Facultatif.
+ Toute expression dont le résultat est une valeur booléenne.
**Exemple 1 : récupérer toutes les données**
L'exemple montre comment récupérer tout le document depuis l'index des comptes.
Requête 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 |
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
```
**Exemple 2 : récupérer des données avec une condition**
L'exemple montre comment récupérer tout le document depuis l'index des comptes avec.
Requête 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 |
+------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+
```
#### commande de tri
Utilisez la `sort` commande pour trier les résultats de recherche en fonction des champs spécifiés.
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
**Syntaxe**
Utilisez la syntaxe suivante :
```
sort <[+|-] sort-field>...
```
**[\+\|-]**
+ Facultatif.
+ Le signe plus [\+] représente l'ordre croissant avec NULL/MISSING les valeurs en premier.
+ Le signe moins [-] représente l'ordre décroissant avec NULL/MISSING les dernières valeurs.
+ Par défaut : ordre croissant avec NULL/MISSING les valeurs en premier.
**champ de tri**
+ Obligatoire.
+ Champ utilisé pour le tri.
**Exemple 1 : Trier selon un champ**
L'exemple montre comment trier le document avec le champ d'âge par ordre croissant.
Requête 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 |
+------------------+-------+
```
**Exemple 2 : trier selon un champ et renvoyer tous les résultats**
L'exemple montre comment trier le document avec le champ d'âge par ordre croissant.
Requête 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 |
+------------------+-------+
```
**Exemple 3 : Trier par un champ par ordre décroissant**
L'exemple montre comment trier le document avec le champ d'âge par ordre décroissant.
Requête 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 |
+------------------+-------+
```
**Exemple 4 : Trier selon plusieurs champs**
L'exemple montre comment trier le document avec le champ de genre par ordre croissant et le champ d'âge par ordre décroissant.
Requête 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 |
+------------------+----------+-------+
```
**Exemple 5 : le tri par champ inclut une valeur nulle**
L'exemple montre comment trier le champ employeur selon l'option par défaut (ordre croissant et valeur nulle en premier). Le résultat indique que la valeur nulle se trouve dans la première ligne.
Requête PPL :
```
os> source=accounts | sort employer | fields employer;
fetched rows / total rows = 4/4
+------------+
| employer |
|------------|
| null |
| AnyCompany |
| AnyCorp |
| AnyOrgty |
+------------+
```
#### commande stats
Utilisez la `stats` commande pour calculer l'agrégation à partir des résultats de recherche.
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
**Gestion des valeurs NULL/MANQUANTES**
**Gestion des valeurs NULL/MANQUANTES**
| Fonction | NULL | MANQUANT |
| --- | --- | --- |
| COUNT | Non compté | Non compté |
| SUM | Ignorer | Ignorer |
| AVG | Ignorer | Ignorer |
| MAX | Ignorer | Ignorer |
| MIN | Ignorer | Ignorer |
**Syntaxe**
Utilisez la syntaxe suivante :
```
stats ... [by-clause]
```
**agrégation**
+ Obligatoire.
+ Fonction d'agrégation appliquée à un champ.
**clause**
+ Facultatif.
+ Syntaxe : `by [span-expression,] [field,]...`
+ Spécifie les champs et les expressions permettant de regrouper les résultats de l'agrégation. La clause secondaire vous permet de regrouper vos résultats d'agrégation à l'aide de champs et d'expressions. Vous pouvez utiliser des fonctions scalaires, des fonctions d'agrégation et même des expressions d'intervalle pour diviser des champs spécifiques en compartiments à intervalles égaux.
+ Par défaut : si non `` est spécifié, la commande stats renvoie une seule ligne représentant l'agrégation sur l'ensemble de résultats.
**étendre l'expression**
+ Facultatif, au plus un.
+ Syntaxe : `span(field_expr, interval_expr)`
+ L'unité de l'expression d'intervalle est l'unité naturelle par défaut. Si le champ est de type date et heure et que l'intervalle est exprimé en date/time unités, vous spécifiez l'unité dans l'expression d'intervalle.
+ Par exemple, diviser le `age` champ en seaux d'ici 10 ans, on dirait. `span(age, 10)` Pour diviser un champ d'horodatage en intervalles horaires, utilisez. `span(timestamp, 1h)`
**Unités de temps disponibles**
| Unités d'intervalle d'intervalle |
| --- |
| milliseconde (ms) |
| seconde (s) |
| minute (m, distinction majuscules et minuscules) |
| heure (h) |
| jour (d) |
| semaine (s) |
| mois (M, distinction majuscules et minuscules) |
| trimestre (q) |
| année (y) |
**Fonctions d'agrégation**
**`COUNT`**
Renvoie le nombre d'expr dans les lignes récupérées par une instruction SELECT.
Exemple :
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**`SUM`**
`SUM(expr)`À utiliser pour renvoyer la somme de expr.
Exemple
```
os> source=accounts | stats sum(age) by gender;
fetched rows / total rows = 2/2
+------------+----------+
| sum(age) | gender |
|------------+----------|
| 28 | F |
| 101 | M |
+------------+----------+
```
**`AVG`**
`AVG(expr)`À utiliser pour renvoyer la valeur moyenne de expr.
Exemple
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**`MAX`**
`MAX(expr)`À utiliser pour renvoyer la valeur maximale de expr.
Exemple
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**`MIN`**
`MIN(expr)`À utiliser pour renvoyer la valeur minimale de expr.
Exemple
```
os> source=accounts | stats min(age);
fetched rows / total rows = 1/1
+------------+
| min(age) |
|------------|
| 28 |
+------------+
```
**`STDDEV_SAMP`**
`STDDEV_SAMP(expr)`À utiliser pour renvoyer l'écart type de l'échantillon de expr.
Exemple :
```
os> source=accounts | stats stddev_samp(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_samp(age) |
|--------------------|
| 3.304037933599835 |
+--------------------+
```
**STDDEV\_POP**
`STDDEV_POP(expr)`À utiliser pour renvoyer l'écart type de population de expr.
Exemple :
```
os> source=accounts | stats stddev_pop(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_pop(age) |
|--------------------|
| 2.**************** |
+--------------------+
```
**PRENDRE**
`TAKE(field [, size])`À utiliser pour renvoyer les valeurs d'origine d'un champ. Il ne fournit aucune garantie quant à l'ordre des valeurs.
**field**
+ Obligatoire.
+ Le champ doit être un champ de texte.
**size**
+ Entier facultatif.
+ Le nombre de valeurs doit être renvoyé.
+ La valeur par défaut est 10.
**Exemple**
```
os> source=accounts | stats take(firstname);
fetched rows / total rows = 1/1
+-----------------------------+
| take(firstname) |
|-----------------------------|
| [Jane, Mary, Nikki, Juan |
+-----------------------------+
```
**PERCENTILE ou PERCENTILE\_APPROX**
Utilisez `PERCENTILE(expr, percent)` ou `PERCENTILE_APPROX(expr, percent)` pour renvoyer la valeur percentile approximative de expr au pourcentage spécifié.
**pourcentage**
+ Le nombre doit être une constante comprise entre 0 et 100.
**Exemple**
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Exemple 1 : calculer le nombre d'événements**
L'exemple montre comment calculer le nombre d'événements dans les comptes.
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**Exemple 2 : calculer la moyenne d'un champ**
L'exemple montre comment calculer l'âge moyen de tous les comptes.
```
os> source=accounts | stats avg(age);
fetched rows / total rows = 1/1
+------------+
| avg(age) |
|------------|
| 32.25 |
+------------+
```
**Exemple 3 : calculer la moyenne d'un champ par groupe**
L'exemple montre comment calculer l'âge moyen de tous les comptes, regroupés par sexe.
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**Exemple 4 : calculer la moyenne, la somme et le nombre d'un champ par groupe**
L'exemple montre comment calculer l'âge moyen, l'âge total et le nombre d'événements pour tous les comptes, regroupés par sexe.
```
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 |
+--------------------+------------+-----------+----------+
```
**Exemple 5 : Calculer le maximum d'un champ**
L'exemple calcule l'âge maximum pour tous les comptes.
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**Exemple 6 : Calculer le maximum et le minimum d'un champ par groupe**
L'exemple calcule les valeurs d'âge maximum et minimum pour tous les comptes, regroupés par sexe.
```
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 |
+------------+------------+----------+
```
**Exemple 7 : Calculer le nombre distinct d'un champ**
Pour obtenir le nombre de valeurs distinctes d'un champ, vous pouvez utiliser la fonction `DISTINCT_COUNT` (ou`DC`) au lieu de`COUNT`. L'exemple calcule à la fois le nombre et le nombre distinct de champs de genre de tous les comptes.
```
os> source=accounts | stats count(gender), distinct_count(gender);
fetched rows / total rows = 1/1
+-----------------+--------------------------+
| count(gender) | distinct_count(gender) |
|-----------------+--------------------------|
| 4 | 2 |
+-----------------+--------------------------+
```
**Exemple 8 : Calculer le nombre par intervalle**
L'exemple obtient le décompte de l'âge par intervalle de 10 ans.
```
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 |
+--------------+------------+
```
**Exemple 9 : Calculez le nombre par sexe et par intervalle**
Cet exemple compte les enregistrements regroupés par sexe et par tranche d'âge de 5 ans.
```
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 |
+-------+------------+----------+
```
L'expression span apparaît toujours comme première clé de regroupement, quel que soit l'ordre spécifié dans la commande.
```
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 |
+-------+------------+----------+
```
**Exemple 10 : Calculez le nombre et obtenez une liste d'e-mails par sexe et par durée**
L'exemple obtient le décompte de l'âge par intervalle de 10 ans et le groupe par sexe. De plus, pour chaque ligne, obtenez une liste d'au plus 5 e-mails.
```
os> source=accounts | stats count() as cnt, take(email, 5) by span(age, 5) as age_span, gender
fetched rows / total rows = 3/3
+-------+----------------------------------------------------+------------+----------+
| cnt | take(email, 5) | age_span | gender |
|-------+----------------------------------------------------+------------+----------|
| 1 | [] | 25 | F |
| 2 | [janedoe@anycompany.com,juanli@examplecompany.org] | 30 | M |
| 1 | [marymajor@examplecorp.com] | 35 | M |
+-------+----------------------------------------------------+------------+----------+
```
**Exemple 11 : Calculer le percentile d'un champ**
L'exemple montre comment calculer le 90e percentile d'âge de tous les comptes.
```
os> source=accounts | stats percentile(age, 90);
fetched rows / total rows = 1/1
+-----------------------+
| percentile(age, 90) |
|-----------------------|
| 36 |
+-----------------------+
```
**Exemple 12 : Calculer le percentile d'un champ par groupe**
L'exemple montre comment calculer le 90e percentile d'âge de tous les comptes regroupés par sexe.
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Exemple 13 : Calculer le percentile en fonction du sexe et de l'intervalle**
L'exemple obtient le 90e percentile d'âge par intervalle de 10 ans et le groupe par sexe.
```
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)`
```
**Agrégations avec 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`
```
**Agrégations avec intervalle de fenêtre temporelle (fonction de fenêtrage Tumble)**
```
- `source = table | stats sum(productsAmount) by span(transactionDate, 1d) as age_date | sort age_date`
- `source = table | stats sum(productsAmount) by span(transactionDate, 1w) as age_date, productId`
```
**Les agrégations sont regroupées par plusieurs niveaux**
```
- `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`
```
#### commande de sous-requête
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `subquery` commande pour exécuter des requêtes complexes et imbriquées dans vos instructions PPL (Piped Processing Language).
```
source=logs | where field in [ subquery source=events | where condition | fields field ]
```
Dans cet exemple, la recherche principale (`source=logs`) est filtrée en fonction des résultats de la sous-requête (`source=events`).
La commande subquery prend en charge plusieurs niveaux d'imbrication pour des analyses de données complexes.
**Exemple de sous-requête imbriquée**
```
source=logs | where id in [ subquery source=users | where user in [ subquery source=actions | where action="login" | fields user] | fields uid ]
```
**InSubquery Usage**
+ `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 ]`(filtrage de recherche avec sous-requête)
+ `source = outer a not in [ source = inner | fields b ]`(filtrage de recherche avec sous-requête)
+ `source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ]`(imbriqué)
+ `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`(en tant que filtre de jointure)
**Exemples de migration SQL avec PPL dans la sous-requête**
TPC-H Q4 (sous-requête intégrée avec agrégation)
```
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
```
Réécrit par requête 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 (sous-requête imbriquée)
```
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
```
Réécrit par requête 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 utilisation**
Hypothèses :`a`, `b` sont des champs de table externe`c`,, `d` sont des champs de table interne`e`, `f` sont des champs de table inner2.
+ `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 ]`(filtrage de recherche avec sous-requête)
+ `source = outer not exists [ source = inner | where a = c ]`(filtrage de recherche avec sous-requête)
+ `source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ]`(l'alias de table est utile dans la sous-requête exists)
+ `source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ]`(imbriqué)
+ `source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ]`(imbriqué)
+ `source = outer | where exists [ source = inner | where c > 10 ]`(il existe une corrélation non corrélée)
+ `source = outer | where not exists [ source = inner | where c > 10 ]`(il existe une corrélation non corrélée)
+ `source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l`(il existe une corrélation spéciale non corrélée)
**ScalarSubquery utilisation**
Hypothèses :`a`, `b` les champs de la table sont-ils extérieurs`c`, `d` sont-ils les champs de la table internes`e`, `f` sont-ils des champs de la table imbriqués
**Sous-requête scalaire non corrélée**
Dans Select :
+ `source = outer | eval m = [ source = inner | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | stats max(c) ] + b | fields m, a`
Où :
+ `source = outer | where a > [ source = inner | stats min(c) ] | fields a`
Dans le filtre de recherche :
+ `source = outer a > [ source = inner | stats min(c) ] | fields a`
**Sous-requête scalaire corrélée**
Dans Select :
+ `source = outer | eval m = [ source = inner | where outer.b = inner.d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where b = d | stats max(c) ] | fields m, a`
+ `source = outer | eval m = [ source = inner | where outer.b > inner.d | stats max(c) ] | fields m, a`
Où :
+ `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`
Dans le filtre de recherche :
+ `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`
**Sous-requête scalaire imbriquée**
+ `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 ]`
**Sous-requête (Relation)**
`InSubquery`, `ExistsSubquery` et `ScalarSubquery` sont toutes des expressions de sous-requêtes. Mais ce n'`RelationSubquery`est pas une expression de sous-requête, c'est un plan de sous-requête couramment utilisé dans les clauses Join ou From.
+ `source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ]`(sous-requête dans le côté droit de la jointure)
+ `source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1`
**Contexte supplémentaire**
`InSubquery``ExistsSubquery`, et `ScalarSubquery` sont des expressions de sous-requêtes couramment utilisées dans les `where` clauses et les filtres de recherche.
Commande où :
```
| where | ...
```
Filtre de recherche :
```
search source=* | ...
```
Une expression de sous-requête peut être utilisée dans une expression booléenne :
```
| where orders.order_id in [ source=returns | where return_reason="damaged" | field order_id ]
```
`orders.order_id in [ source=... ]`C'est un``.
En général, nous appelons ce type de clause de sous-requête l'`InSubquery`expression. C'est un``.
**Sous-requête avec différents types de jointure**
Exemple d’utilisation de `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 ]
```
Contrairement à InSubquery ExistsSubquery, et ScalarSubquery, a n' RelationSubqueryest pas une expression de sous-requête. Il s'agit plutôt d'un plan de sous-requête.
```
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 ...
```
#### commande supérieure
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `top` commande pour rechercher le tuple de valeurs le plus courant de tous les champs de la liste de champs.
**Syntaxe**
Utilisez la syntaxe suivante :
```
top [N] [by-clause] top_approx [N] [by-clause]
```
**N**
+ Le nombre de résultats à renvoyer.
+ Par défaut: 10
**liste de champs**
+ Obligatoire.
+ Liste de noms de champs séparés par des virgules.
**clause**
+ Facultatif.
+ Un ou plusieurs champs par lesquels regrouper les résultats.
**top\_approx**
+ Un décompte approximatif des (n) premiers champs en utilisant la [cardinalité estimée par l'algorithme HyperLogLog \+\+](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html).
**Exemple 1 : trouver les valeurs les plus courantes dans un champ**
L'exemple permet de trouver le sexe le plus courant pour tous les comptes.
Requête PPL :
```
os> source=accounts | top gender;
os> source=accounts | top_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Exemple 2 : Rechercher les valeurs les plus courantes dans un champ (limité à 1)**
L'exemple permet de trouver le sexe le plus courant pour tous les comptes.
Requête PPL :
```
os> source=accounts | top_approx 1 gender;
fetched rows / total rows = 1/1
+----------+
| gender |
|----------|
| M |
+----------+
```
**Exemple 3 : trouver les valeurs les plus courantes, groupées par sexe**
L'exemple permet de trouver l'âge le plus courant pour tous les comptes, groupés par sexe.
Requête 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 |
+----------+-------+
```
#### commande trendline
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `trendline` commande pour calculer les moyennes mobiles des champs.
**Syntaxe**
Utilisez la syntaxe suivante
```
TRENDLINE [sort <[+|-] sort-field>] SMA(number-of-datapoints, field) [AS alias] [SMA(number-of-datapoints, field) [AS alias]]...
```
**[\+\|-]**
+ Facultatif.
+ Le signe plus [\+] représente l'ordre croissant avec NULL/MISSING les valeurs en premier.
+ Le signe moins [-] représente l'ordre décroissant avec NULL/MISSING les dernières valeurs.
+ Par défaut : ordre croissant avec NULL/MISSING les valeurs en premier.
**champ de tri**
+ Obligatoire lorsque le tri est utilisé.
+ Champ utilisé pour le tri.
**number-of-datapoints**
+ Obligatoire.
+ Le nombre de points de données qui calculent la moyenne mobile.
+ Doit être supérieur à zéro.
**field**
+ Obligatoire.
+ Nom du champ pour lequel la moyenne mobile doit être calculée.
**alias**
+ Facultatif.
+ Nom de la colonne résultante contenant la moyenne mobile.
Seul le type de moyenne mobile simple (SMA) est pris en charge. Il est calculé comme suit :
```
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
```
**Exemple 1 : Calculer une moyenne mobile simple pour une série chronologique de températures**
L'exemple calcule la moyenne mobile simple des températures à l'aide de deux points de données.
Requête 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|
+-----------+---------+--------------------+----------+
```
**Exemple 2 : calculer des moyennes mobiles simples pour une série chronologique de températures avec tri**
L'exemple calcule deux moyennes mobiles simples sur les températures à l'aide de deux et trois points de données triés en ordre décroissant par identifiant d'appareil.
Requête 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|
+-----------+---------+--------------------+------------+------------------+
```
#### où commande
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
La `where` commande utilise une expression booléenne pour filtrer le résultat de la recherche. Il ne renvoie le résultat que lorsque l'expression booléenne est évaluée à true.
**Syntaxe**
Utilisez la syntaxe suivante :
```
where
```
**expression booléenne**
+ Facultatif.
+ Toute expression pouvant être évaluée à une valeur booléenne.
**Exemple 1 : Filtrer un ensemble de résultats avec condition**
L'exemple montre comment extraire des documents de l'index des comptes qui répondent à des conditions spécifiques.
Requête 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 |
+------------------+----------+
```
**Exemples supplémentaires**
**Filtres avec conditions logiques**
+ `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`- Remarque : Cela renvoie a >= 1 et a <= 4, c'est-à-dire [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Remarque : cela renvoie b >= '\*\*\*\*\*\*\*\*\*\*' et 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
```
#### résumé du champ
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette commande PPL, consultez. [Commandes](#supported-ppl-commands)
Utilisez la `fieldsummary` commande pour calculer les statistiques de base pour chaque champ (nombre, nombre distinct, min, max, avg, stddev, moyenne) et déterminez le type de données de chaque champ. Cette commande peut être utilisée avec n'importe quel canal précédent et en tiendra compte.
**Syntaxe**
Utilisez la syntaxe suivante. Pour les cas d'utilisation des CloudWatch journaux, un seul champ d'une requête est pris en charge.
```
... | fieldsummary (nulls=true/false)
```
**inclure des champs**
+ Liste de toutes les colonnes à collecter avec des statistiques dans un ensemble de résultats unifié.
**Valeurs null**
+ Facultatif.
+ Si ce paramètre est défini sur true, incluez les valeurs nulles dans les calculs d'agrégation (remplacez null par zéro pour les valeurs numériques).
**Exemple 1**
Requête 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" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
**Exemple 2**
Requête 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"|
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
#### commande d'extension
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
Utilisez la `expand` commande pour aplatir un champ de type Array ou Map, en produisant des lignes individuelles pour chaque élément ou paire clé-valeur.
**Syntaxe**
Utilisez la syntaxe suivante :
```
expand [As alias]
```
**field**
+ Le champ à étendre (exploser).
+ Le champ doit être d'un type compatible.
**alias**
+ Facultatif.
+ Le nom à utiliser à la place du nom de champ d'origine.
**Directives d’utilisation**
La commande expand produit une ligne pour chaque élément du tableau ou du champ de carte spécifié, où :
+ Les éléments du tableau deviennent des lignes individuelles.
+ Les paires clé-valeur de la carte sont divisées en lignes distinctes, chaque valeur-clé étant représentée par une ligne.
+ Lorsqu'un alias est fourni, les valeurs éclatées sont représentées sous l'alias au lieu du nom du champ d'origine.
Vous pouvez utiliser cette commande en combinaison avec d'autres commandes, telles que stats, eval et parse, pour manipuler ou extraire des données après l'expansion.
**Exemples**
+ `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`
Vous pouvez utiliser la commande expand en combinaison avec d'autres commandes telles que eval, stats, etc. L'utilisation de plusieurs commandes d'extension créera un produit cartésien de tous les éléments internes de chaque tableau composite ou carte.
**Requête SQL push-down efficace**
La commande expand est traduite en une opération SQL équivalente à l'aide de LATERAL VIEW explode, ce qui permet une explosion efficace de tableaux ou de cartes au niveau de la requête SQL.
```
SELECT customer exploded_productId
FROM table
LATERAL VIEW explode(productId) AS exploded_productId
```
La commande explode offre les fonctionnalités suivantes :
+ Il s'agit d'une opération de colonne qui renvoie une nouvelle colonne.
+ Il crée une nouvelle ligne pour chaque élément de la colonne éclatée.
+ Les valeurs nulles internes sont ignorées dans le cadre du champ éclaté (aucune ligne ne correspond created/exploded à une valeur nulle).
#### Fonctions PPL
**Topics**
+ [Fonctions de condition PPL](#supported-ppl-condition-functions)
+ [Fonctions de hachage cryptographiques PPL](#supported-ppl-cryptographic-functions)
+ [Fonctions de date et d'heure PPL](#supported-ppl-date-time-functions)
+ [Expressions PPL](#supported-ppl-expressions)
+ [Fonctions d'adresse IP PPL](#supported-ppl-ip-address-functions)
+ [Fonctions JSON PPL](#supported-ppl-json-functions)
+ [Fonctions Lambda PPL](#supported-ppl-lambda-functions)
+ [Fonctions mathématiques PPL](#supported-ppl-math-functions)
+ [Fonctions de chaîne PPL](#supported-ppl-string-functions)
+ [Fonctions de conversion de type PPL](#supported-ppl-type-conversion-functions)
##### Fonctions de condition PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### ISNULL
**Description** : `isnull(field)` renvoie vrai si le champ est nul.
**Type d'argument :**
+ Tous les types de données pris en charge.
**Type de retour :**
+ BOOLEAN
**Exemple :**
```
os> source=accounts | eval result = isnull(employer) | fields result, employer, firstname
fetched rows / total rows = 4/4
+----------+-------------+-------------+
| result | employer | firstname |
|----------+-------------+-------------|
| False | AnyCompany | Mary |
| False | ExampleCorp | Jane |
| False | ExampleOrg | Nikki |
| True | null | Juan |
+----------+-------------+-------------+
```
##### N'EST PAS NUL
**Description** : `isnotnull(field)` renvoie vrai si le champ n'est pas nul.
**Type d'argument :**
+ Tous les types de données pris en charge.
**Type de retour :**
+ BOOLEAN
**Exemple :**
```
os> source=accounts | where not isnotnull(employer) | fields account_number, employer
fetched rows / total rows = 1/1
+------------------+------------+
| account_number | employer |
|------------------+------------|
| 18 | null |
+------------------+------------+
```
##### EXISTS
**Exemple :**
```
os> source=accounts | where exists(email) | fields account_number, email
fetched rows / total rows = 1/1
```
##### SI NUL
**Description** : `ifnull(field1, field2)` renvoie `field2` si la valeur `field1` est nulle.
**Type d'argument :**
+ Tous les types de données pris en charge.
+ Si les deux paramètres sont de types différents, la fonction échouera à la vérification sémantique.
**Type de retour :**
+ N’importe lequel
**Exemple :**
```
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
**Description** : `nullif(field1, field2)` renvoie null si deux paramètres sont identiques, sinon renvoie field1.
**Type d'argument :**
+ Tous les types de données pris en charge.
+ Si les deux paramètres sont de types différents, la fonction échouera à la vérification sémantique.
**Type de retour :**
+ N’importe lequel
**Exemple :**
```
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
**Description** : `if(condition, expr1, expr2)` renvoie `expr1` si la condition est vraie, sinon elle est renvoyée`expr2`.
**Type d'argument :**
+ Tous les types de données pris en charge.
+ Si les deux paramètres sont de types différents, la fonction échouera à la vérification sémantique.
**Type de retour :**
+ N’importe lequel
**Exemple :**
```
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 |
+----------+-------------+------------+
```
##### Fonctions de hachage cryptographiques PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### MD5
MD5 calcule le MD5 résumé et renvoie la valeur sous forme de chaîne hexadécimale de 32 caractères.
**Utilisation** : `md5('hello')`
**Type d'argument :**
+ CHAÎNE
**Type de retour :**
+ CHAÎNE
**Exemple :**
```
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 renvoie le résultat de la chaîne hexadécimale de SHA-1.
**Utilisation** : `sha1('hello')`
**Type d'argument :**
+ CHAÎNE
**Type de retour :**
+ CHAÎNE
**Exemple :**
```
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 renvoie le résultat sous forme de chaîne hexadécimale de la famille de fonctions de hachage SHA-2 (SHA-224, SHA-256, SHA-384 et SHA-512). Le NumBits indique la longueur de bit souhaitée du résultat, qui doit avoir une valeur de 224, 256, 384, 512
**Utilisation :**
+ `sha2('hello',256)`
+ `sha2('hello',512)`
**Type d'argument :**
+ CHAÎNE, ENTIER
**Type de retour :**
+ CHAÎNE
**Exemple :**
```
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> |
+------------------------------------------------------------------+
```
##### Fonctions de date et d'heure PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### `DAY`
**Utilisation** : `DAY(date)` extrait le jour du mois pour une date comprise entre 1 et 31.
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** :`DAYOFMONTH`, `DAY_OF_MONTH`
**Exemple :**
```
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`
**Utilisation** : `DAYOFMONTH(date)` extrait le jour du mois pour une date comprise entre 1 et 31.
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** :`DAY`, `DAY_OF_MONTH`
**Exemple :**
```
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`
**Utilisation** : `DAY_OF_MONTH(DATE)` extrait le jour du mois pour une date comprise entre 1 et 31.
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** :`DAY`, `DAYOFMONTH`
**Exemple :**
```
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`
**Utilisation** : `DAYOFWEEK(DATE)` renvoie l'index des jours de la semaine pour une date (1 = dimanche, 2 = lundi,..., 7 = samedi).
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `DAY_OF_WEEK`
**Exemple :**
```
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`
**Utilisation** : `DAY_OF_WEEK(DATE)` renvoie l'index des jours de la semaine pour une date (1 = dimanche, 2 = lundi,..., 7 = samedi).
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `DAYOFWEEK`
**Exemple :**
```
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`
**Utilisation** : `DAYOFYEAR(DATE)` renvoie le jour de l'année pour une date comprise entre 1 et 366.
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `DAY_OF_YEAR`
**Exemple :**
```
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`
**Utilisation** : `DAY_OF_YEAR(DATE)` renvoie le jour de l'année pour une date comprise entre 1 et 366.
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `DAYOFYEAR`
**Exemple :**
```
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`
**Utilisation** : `DAYNAME(DATE)` renvoie le nom du jour de la semaine pour une date, y compris le lundi, le mardi, le mercredi, le jeudi, le vendredi, le samedi et le dimanche.
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : STRING
**Exemple :**
```
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`
**Utilisation** : `FROM_UNIXTIME` renvoie une représentation de l'argument donné sous forme d'horodatage ou de valeur de chaîne de caractères. Cette fonction effectue une conversion inverse de la `UNIX_TIMESTAMP` fonction.
Si vous fournissez un deuxième argument, `FROM_UNIXTIME` utilisez-le pour formater le résultat de la même manière que la `DATE_FORMAT` fonction.
Si l'horodatage se situe en dehors de la plage 1970-01-01 00:00:00 à 30-01-01-18 23:59:59.999 999 (0 à 32536771199.999999 heure d'époque), la fonction revient. `NULL`
**Type d'argument** : DOUBLE, CHAÎNE
**Carte des types de retour** :
DOUBLE -> HORODATAGE
DOUBLE, CHAÎNE -> CHAÎNE
**Exemples :**
```
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`
**Utilisation** : `HOUR(TIME)` extrait la valeur horaire pour le temps.
Contrairement à une heure standard, la valeur horaire de cette fonction peut avoir une plage supérieure à 23. Par conséquent, la valeur de retour de `HOUR(TIME)` peut être supérieure à 23.
**Type d'argument** : STRING/TIME/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `HOUR_OF_DAY`
**Exemple :**
```
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`
**Utilisation** : `HOUR_OF_DAY(TIME)` extrait la valeur de l'heure à partir de l'heure donnée.
Contrairement à une heure standard, la valeur horaire de cette fonction peut avoir une plage supérieure à 23. Par conséquent, la valeur de retour de `HOUR_OF_DAY(TIME)` peut être supérieure à 23.
**Type d'argument** : STRING/TIME/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `HOUR`
**Exemple :**
```
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`
**Utilisation** : `LAST_DAY` renvoie le dernier jour du mois sous forme de valeur DATE pour l'argument de date donné.
**Type d'argument** : DATE/STRING/TIMESTAMP/TIME
**Type de retour** : DATE
**Exemple :**
```
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`
**Utilisation** : `LOCALTIMESTAMP()` est un synonyme de`NOW()`.
**Exemple :**
```
> source=people | eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP() | fields `LOCALTIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIMESTAMP() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `LOCALTIME`
**Usage** : `LOCALTIME()` est un synonyme de`NOW()`.
**Exemple :**
```
> source=people | eval `LOCALTIME()` = LOCALTIME() | fields `LOCALTIME()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIME() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `MAKE_DATE`
**Utilisation** : `MAKE_DATE` renvoie une valeur de date basée sur les valeurs d'année, de mois et de jour données. Tous les arguments sont arrondis à des nombres entiers.
**Spécifications** : 1. MAKE\_DATE (ENTIER, ENTIER, ENTIER) -> DATE
**Type d'argument** : INTEGER, INTEGER, INTEGER
**Type de retour** : DATE
**Exemple :**
```
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`
**Utilisation** : `MINUTE(TIME)` renvoie la composante minute de l'heure donnée, sous la forme d'un entier compris entre 0 et 59.
**Type d'argument** : STRING/TIME/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `MINUTE_OF_HOUR`
**Exemple :**
```
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`
**Utilisation** : `MINUTE_OF_HOUR(TIME)` renvoie la composante minute de l'heure donnée, sous la forme d'un entier compris entre 0 et 59.
**Type d'argument** : STRING/TIME/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `MINUTE`
**Exemple :**
```
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`
**Utilisation** : `MONTH(DATE)` renvoie le mois de la date donnée sous forme de nombre entier, compris entre 1 et 12 (où 1 représente janvier et 12 représente décembre).
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `MONTH_OF_YEAR`
**Exemple :**
```
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`
**Utilisation** : `MONTHNAME(DATE)` renvoie le mois de la date donnée sous forme de nombre entier, compris entre 1 et 12 (où 1 représente janvier et 12 représente décembre).
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `MONTH_OF_YEAR`
**Exemple :**
```
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`
**Utilisation** : `MONTH_OF_YEAR(DATE)` renvoie le mois de la date donnée sous forme de nombre entier, compris entre 1 et 12 (où 1 représente janvier et 12 représente décembre).
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `MONTH`
**Exemple :**
```
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`
**Utilisation** : `NOW` renvoie la date et l'heure actuelles sous forme de `TIMESTAMP` valeur au format « YYYY-MM-DD hh:mm:ss ». La valeur est exprimée dans le fuseau horaire du cluster.
**Note**
`NOW()`renvoie un temps constant qui indique le début de l'exécution de l'instruction. Cela diffère de`SYSDATE()`, qui renvoie l'heure exacte de l'exécution.
**Type de retour** : TIMESTAMP
**Spécification** : NOW () -> TIMESTAMP
**Exemple :**
```
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`
**Utilisation** : `QUARTER(DATE)` renvoie le trimestre de l'année pour la date donnée sous forme de nombre entier, compris entre 1 et 4.
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Exemple :**
```
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`
**Utilisation** : `SECOND(TIME)` renvoie la deuxième composante du temps donné sous forme d'entier, compris entre 0 et 59.
**Type d'argument** : STRING/TIME/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `SECOND_OF_MINUTE`
**Exemple :**
```
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`
**Utilisation** : `SECOND_OF_MINUTE(TIME)` renvoie la deuxième composante du temps donné sous forme d'entier, compris entre 0 et 59.
**Type d'argument** : STRING/TIME/TIMESTAMP
**Type de retour** : INTEGER
**Synonymes** : `SECOND`
**Exemple :**
```
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`
**Utilisation** : `SUBDATE(DATE, DAYS)` soustrait le deuxième argument (tel que `DATE` ou`DAYS`) de la date donnée.
**Type d'argument** : DATE/TIMESTAMP, LONG
**Carte des types de retour** : (DATE, LONG) -> DATE
**Antonymes** : `ADDDATE`
**Exemple :**
```
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`
**Utilisation** : `SYSDATE()` renvoie la date et l'heure actuelles sous forme de `TIMESTAMP` valeur au format « YYYY-MM-DD hh:mm:ss.nnnnnn ».
`SYSDATE()`renvoie l'heure exacte à laquelle il s'exécute. Cela diffère de NOW (), qui renvoie un temps constant indiquant le moment où l'instruction a commencé à s'exécuter.
**Type d'argument facultatif** : INTEGER (0 à 6) - Spécifie le nombre de chiffres pour les fractions de secondes dans la valeur de retour.
**Type de retour** : TIMESTAMP
**Exemple :**
```
os> source=people | eval `SYSDATE()` = SYSDATE() | fields `SYSDATE()`
fetched rows / total rows = 1/1
+----------------------------+
| SYSDATE() |
|----------------------------|
| 2022-08-02 15:39:05.123456 |
+----------------------------+
```
##### `TIMESTAMP`
**Utilisation** : `TIMESTAMP(EXPR)` construit un type d'horodatage avec la chaîne d'entrée `expr` comme horodatage.
Avec un seul argument, `TIMESTAMP(expr)` construit un horodatage à partir de l'entrée. S'il s'`expr`agit d'une chaîne, elle est interprétée comme un horodatage. Pour les arguments autres que des chaînes, la fonction est convertie `expr` en horodatage en utilisant le fuseau horaire UTC. Quand `expr` est une `TIME` valeur, la fonction applique la date du jour avant le casting.
Lorsqu'il est utilisé avec deux arguments, `TIMESTAMP(expr1, expr2)` ajoute l'expression temporelle (`expr2`) à l'expression de date ou d'horodatage (`expr1`) et renvoie le résultat sous forme de valeur d'horodatage.
**Type d'argument** : STRING/DATE/TIME/TIMESTAMP
**Carte des types de retour** :
(STRING/DATE/TIME/TIMESTAMP) -> HORODATAGE
(STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP) -> HORODATAGE
**Exemple :**
```
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`
**Utilisation** : `UNIX_TIMESTAMP` convertit un argument de date donné en heure Unix (secondes depuis Epoch, qui a débuté début 1970). Si aucun argument n'est fourni, il renvoie l'heure Unix actuelle.
L'argument date peut être une`DATE`, une `TIMESTAMP` chaîne ou un nombre dans l'un des formats suivants : `YYMMDD``YYMMDDhhmmss`,`YYYYMMDD`, ou`YYYYMMDDhhmmss`. Si l'argument inclut une composante temporelle, il peut éventuellement inclure des fractions de secondes.
Si le format de l'argument n'est pas valide ou s'il se situe en dehors de la plage comprise entre 1970-01-01 00:00:00 et 30-01-01-18 23:59:59.999 999 (0 à 32536771199.999999 en temps d'époque), la fonction revient. `NULL`
La fonction accepte `DATE``TIMESTAMP`, ou `DOUBLE` en tant que types d'arguments, ou aucun argument. Elle renvoie toujours une `DOUBLE` valeur représentant l'horodatage Unix.
Pour la conversion inverse, vous pouvez utiliser la fonction FROM\_UNIXTIME.
**Type d'argument** :/DOUBLE/DATE/TIMESTAMP
**Type de retour** : DOUBLE
**Exemple :**
```
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`
**Utilisation** : `WEEK(DATE)` renvoie le numéro de semaine pour une date donnée.
**Type d'argument** : DATE/TIMESTAMP/STRING
**Type de retour** : INTEGER
**Synonymes** : `WEEK_OF_YEAR`
**Exemple :**
```
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`
**Utilisation** : `WEEKDAY(DATE)` renvoie l'index des jours de la semaine pour la date (0 = lundi, 1 = mardi,..., 6 = dimanche).
Elle est similaire à la `dayofweek` fonction, mais renvoie des index différents pour chaque jour.
**Type d'argument** : STRING/DATE/TIME/TIMESTAMP
**Type de retour** : INTEGER
**Exemple :**
```
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`
**Utilisation** : `WEEK_OF_YEAR(DATE)` renvoie le numéro de semaine pour la date donnée.
**Type d'argument** : DATE/TIMESTAMP/STRING
**Type de retour** : INTEGER
**Synonymes** : `WEEK`
**Exemple :**
```
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`
**Utilisation** : `YEAR(DATE)` renvoie l'année pour la date, comprise entre 1000 et 9999, ou 0 pour la date « zéro ».
**Type d'argument** : STRING/DATE/TIMESTAMP
**Type de retour** : INTEGER
**Exemple :**
```
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`
**Utilisation** : `DATE_ADD(date, INTERVAL expr unit)` ajoute l'intervalle spécifié à la date donnée.
**Type d'argument** : DATE, INTERVALLE
**Type de retour** : DATE
**Antonymes** : `DATE_SUB`
**Exemple :**
```
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`
**Utilisation** : `DATE_SUB(date, INTERVAL expr unit)` soustrait l'intervalle expr de la date.
**Type d'argument** : DATE, INTERVALLE
**Type de retour** : DATE
**Antonymes** : `DATE_ADD`
**Exemple :**
```
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`
**Utilisation** : renvoie une `TIMESTAMP` valeur après avoir ajouté un intervalle de temps spécifié à une date donnée.
**Arguments :**
+ intervalle : INTERVALLE (SECONDE, MINUTE, HEURE, JOUR, SEMAINE, MOIS, TRIMESTRE, ANNÉE)
+ entier : ENTIER
+ date : DATE, TIMESTAMP ou CHAÎNE
Si vous fournissez un `STRING` comme argument de date, formatez-le comme valide`TIMESTAMP`. La fonction convertit automatiquement un `DATE` argument en`TIMESTAMP`.
**Exemples :**
```
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`
**Utilisation** : `TIMESTAMPDIFF(interval, start, end)` renvoie la différence entre le début et la fin date/times en unités d'intervalle spécifiées.
**Arguments :**
+ intervalle : INTERVALLE (SECONDE, MINUTE, HEURE, JOUR, SEMAINE, MOIS, TRIMESTRE, ANNÉE)
+ début : DATE, TIMESTAMP ou CHAÎNE
+ fin : DATE, TIMESTAMP ou STRING
La fonction convertit automatiquement les arguments en arguments `TIMESTAMP` lorsque cela est approprié. `STRING`Formatez les arguments en tant que `TIMESTAMP` s valides.
**Exemples :**
```
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`
**Utilisation** : `UTC_TIMESTAMP` renvoie l'horodatage UTC actuel sous forme de valeur dans « YYYY-MM-DD hh:mm:ss ».
**Type de retour** : TIMESTAMP
**Spécification** : UTC\_TIMESTAMP () -> TIMESTAMP
**Exemple :**
```
> 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`
**Utilisation** : `CURRENT_TIMEZONE` renvoie le fuseau horaire local actuel.
**Type de retour** : STRING
**Exemple :**
```
> source=people | eval `CURRENT_TIMEZONE()` = CURRENT_TIMEZONE() | fields `CURRENT_TIMEZONE()`
fetched rows / total rows = 1/1
+------------------------+
| CURRENT_TIMEZONE() |
|------------------------|
| America/Chicago |
+------------------------+
```
##### Expressions PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
Les expressions, en particulier les expressions de valeur, renvoient une valeur scalaire. Les expressions ont différents types et formes. Par exemple, il existe des valeurs littérales sous forme d'expressions atomiques et des expressions arithmétiques, de prédicats et de fonctions basées sur celles-ci. Vous pouvez utiliser des expressions dans différentes clauses, par exemple en utilisant des expressions arithmétiques dans `Stats` les commandes `Filter` et.
**Opérateurs**
Une expression arithmétique est une expression formée de littéraux numériques et d'opérateurs arithmétiques binaires comme suit :
1. `+`: Ajouter.
1. `-`: Soustraire.
1. `*`: Multiplier.
1. `/`: Diviser (pour les entiers, le résultat est un entier dont la partie fractionnaire est supprimée)
1. `%`: Modulo (à utiliser uniquement avec des entiers ; le résultat est le reste de la division)
**Priorité**
Utilisez des parenthèses pour contrôler la priorité des opérateurs arithmétiques. Dans le cas contraire, les opérateurs de priorité supérieure sont exécutés en premier.
**Conversion de type**
Une conversion de type implicite est effectuée lors de la recherche de signatures d'opérateurs. Par exemple, un entier correspond à `+` un nombre réel à une signature`+(double,double)`, ce qui donne un nombre réel. Cette règle s'applique également aux appels de fonctions.
Exemple de différents types d'expressions arithmétiques :
```
os> source=accounts | where age > (25 + 5) | fields age ;
fetched rows / total rows = 3/3
+-------+
| age |
|-------|
| 32 |
| 36 |
| 33 |
+-------+
```
**Opérateurs de prédicat**
Un opérateur de prédicat est une expression qui est évaluée comme vraie. La comparaison `MISSING` des `NULL` valeurs et suit les règles suivantes :
+ Une `MISSING` valeur n'est égale qu'à une `MISSING` valeur et est inférieure aux autres valeurs.
+ Une `NULL` valeur est égale à une `NULL` valeur, est supérieure à une `MISSING` valeur, mais inférieure à toutes les autres valeurs.
**Opérateurs**
**Opérateurs de prédicat**
| Nom | Description |
| --- | --- |
| > | Supérieur à l'opérateur |
| >= | Opérateur supérieur ou égal |
| < | Moins qu'un opérateur |
| \!= | Opérateur non égal |
| <= | Opérateur inférieur ou égal |
| = | Opérateur égal |
| LIKE | Correspondance simple des motifs |
| IN | Test de valeur NULL |
| AND | Opérateur AND |
| OR | Opérateur OR |
| XOR | opérateur XOR |
| NOT | Test de valeur NON NULLE |
Vous pouvez comparer les dates et les heures. Lorsque vous comparez différents types de date/heure (par exemple `DATE` et`TIME`), les deux sont convertis en`DATETIME`. Les règles suivantes s'appliquent à la conversion :
+ `TIME`s'applique à la date d'aujourd'hui.
+ `DATE`est interprété à minuit.
**Opérateur de prédicat de base**
Exemple d'opérateurs de comparaison :
```
os> source=accounts | where age > 33 | fields age ;
fetched rows / total rows = 1/1
+-------+
| age |
|-------|
| 36 |
+-------+
```
**`IN`**
Exemple de champ de test de `IN` l'opérateur dans les listes de valeurs :
```
os> source=accounts | where age in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`OR`**
Exemple de l'`OR`opérateur :
```
os> source=accounts | where age = 32 OR age = 33 | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`NOT`**
Exemple de l'`NOT`opérateur :
```
os> source=accounts | where age not in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 36 |
| 28 |
+-------+
```
##### Fonctions d'adresse IP PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### `CIDRMATCH`
**Utilisation** : `CIDRMATCH(ip, cidr)` vérifie si l'adresse IP spécifiée se situe dans la plage CIDR donnée.
**Type d'argument :**
+ CHAÎNE, CHAÎNE
+ Type de retour : BOOLEAN
**Exemple :**
```
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 |
+-----------------------------------------+
```
**Note**
`ip`peut être une adresse IPv4 ou une IPv6 adresse.
`cidr`peut être un IPv4 ou un IPv6 bloc.
`ip`et `cidr` doit être soit les deux, IPv4 soit les deux IPv6.
`ip`et `cidr` doit être à la fois valide et non vide/non nul.
##### Fonctions JSON PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### `JSON`
**Utilisation** : `json(value)` évalue si une chaîne peut être analysée au format JSON. La fonction renvoie la chaîne d'origine s'il s'agit d'un JSON valide, ou null s'il n'est pas valide.
**Type d'argument** : CHAÎNE
**Type de retour** : STRING/NULL. Expression STRING d'un format d'objet JSON valide.
**Exemples :**
```
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`
**Utilisation** : `json_object(, [, , ]...)` renvoie un objet JSON à partir de membres de paires clé-valeur.
**Type d'argument :**
+ A doit être une chaîne.
+ A peut être n'importe quel type de données.
**Type de retour** : JSON\_OBJECT. StructType Expression d'un objet JSON valide.
**Exemples :**
```
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`
**Utilisation** : `json_array(...)` crée un TABLEAU JSON à l'aide d'une liste de valeurs.
**Type d'argument** : A `` peut être n'importe quel type de valeur, telle qu'une chaîne, un nombre ou un booléen.
**Type de retour** : ARRAY. Un tableau de n'importe quel type de données pris en charge pour un tableau JSON valide.
**Exemples :**
```
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`
**Utilisation** : `to_json_string(jsonObject)` renvoie une chaîne JSON avec une valeur d'objet JSON donnée.
**Type d'argument** : JSON\_OBJECT
**Type de retour** : STRING
**Exemples :**
```
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`
**Utilisation** : `array_length(jsonArray)` renvoie le nombre d'éléments du tableau le plus externe.
**Type d'argument** : ARRAY. Un objet ARRAY ou JSON\_ARRAY.
**Type de retour** : INTEGER
**Exemple :**
```
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`
**Utilisation** : `json_extract(jsonStr, path)` extrait un objet JSON d'une chaîne JSON en fonction du chemin JSON spécifié. La fonction renvoie null si la chaîne JSON d'entrée n'est pas valide.
**Type d'argument** : CHAÎNE, CHAÎNE
**Type de retour** : STRING
+ Expression STRING d'un format d'objet JSON valide.
+ `NULL`est renvoyé en cas de JSON non valide.
**Exemples :**
```
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`
**Utilisation** : `json_keys(jsonStr)` renvoie toutes les clés de l'objet JSON le plus externe sous forme de tableau.
**Type d'argument** : CHAÎNE. Expression STRING d'un format d'objet JSON valide.
**Type de retour** : ARRAY [STRING]. La fonction renvoie `NULL` toute autre chaîne JSON valide, une chaîne vide ou un JSON non valide.
**Exemples :**
```
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`
**Utilisation** : `json_valid(jsonStr)` évalue si une chaîne JSON utilise une syntaxe JSON valide et renvoie VRAI ou FAUX.
**Type d'argument** : CHAÎNE
**Type de retour** : BOOLEAN
**Exemples :**
```
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 |
+------------------+---------+
```
##### Fonctions Lambda PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### `EXISTS`
**Utilisation** : `exists(array, lambda)` évalue si un prédicat Lambda est valable pour un ou plusieurs éléments du tableau.
**Type d'argument** : ARRAY, LAMBDA
**Type de retour** : BOOLEAN. Renvoie `TRUE` si au moins un élément du tableau répond au prédicat Lambda, sinon. `FALSE`
**Exemples :**
```
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`
**Utilisation** : `filter(array, lambda)` filtre le tableau d'entrée à l'aide de la fonction Lambda donnée.
**Type d'argument** : ARRAY, LAMBDA
**Type de retour** : ARRAY. Un ARRAY qui contient tous les éléments du tableau d'entrée qui répondent au prédicat lambda.
**Exemples :**
```
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`
**Utilisation** : `transform(array, lambda)` transforme les éléments d'un tableau à l'aide de la fonction de transformation Lambda. Le deuxième argument implique l'indice de l'élément si vous utilisez la fonction Lambda binaire. Ceci est similaire `map` à une programmation fonctionnelle.
**Type d'argument** : ARRAY, LAMBDA
**Type de retour** : ARRAY. Un ARRAY qui contient le résultat de l'application de la fonction de transformation lambda à chaque élément du tableau d'entrée.
**Exemples :**
```
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`
**Utilisation** : `reduce(array, start, merge_lambda, finish_lambda)` réduit un tableau à une valeur unique en appliquant des fonctions lambda. La fonction applique le merge\_lambda à la valeur de départ et à tous les éléments du tableau, puis l'applique au `finish_lambda` résultat.
**Type d'argument** : ARRAY, ANY, LAMBDA, LAMBDA
**Type de retour** : N'IMPORTE LEQUEL. Résultat final de l'application des fonctions Lambda à la valeur de départ et au tableau d'entrée.
**Exemples :**
```
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 |
+-----------+
```
##### Fonctions mathématiques PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### `ABS`
**Utilisation** : `ABS(x) ` calcule la valeur absolue de x.
**Type d'argument :** INTEGER/LONG/FLOAT/DOUBLE
**Type de retour :** INTEGER/LONG/FLOAT/DOUBLE
**Exemple :**
```
os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)`
fetched rows / total rows = 1/1
+-----------+
| ABS(-1) |
|-----------|
| 1 |
+-----------+
```
##### `ACOS`
**Utilisation** : `ACOS(x)` calcule l'arc cosinus de x. Elle retourne `NULL` si x n'est pas compris entre -1 et 1.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `ACOS(0)` = ACOS(0) | fields `ACOS(0)`
fetched rows / total rows = 1/1
+--------------------+
| ACOS(0) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `ASIN`
**Utilisation** : `asin(x)` calcule l'arc sinusoïdal de x. Elle retourne `NULL` si x n'est pas compris entre -1 et 1.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `ASIN(0)` = ASIN(0) | fields `ASIN(0)`
fetched rows / total rows = 1/1
+-----------+
| ASIN(0) |
|-----------|
| 0.0 |
+-----------+
```
##### `ATAN`
**Utilisation** : `ATAN(x)` calcule la tangente d'arc de x. `atan(y, x)` Calcule la tangente d'arc de y/x, sauf que les signes des deux arguments déterminent le quadrant du résultat.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
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`
**Utilisation** : `ATAN2(y, x)` calcule l'arc tangent de y/ x, sauf que les signes des deux arguments déterminent le quadrant du résultat.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
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`
**Utilisation** : `CBRT` calcule la racine cubique d'un nombre.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE :
INTEGER/LONG/FLOAT/DOUBLE-> DOUBLE
**Exemple :**
```
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`
**Utilisation** : alias de la `CEILING` fonction. `CEILING(T)`prend le plafond de valeur T.
**Limitation** : `CEILING` ne fonctionne comme prévu que lorsque le type double IEEE 754 affiche une décimale lors du stockage.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : LONG
**Exemple :**
```
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`
**Utilisation** : `CONV(x, a, b)` convertit le nombre x d'une base en une base b.
**Type d'argument** : x : CHAÎNE, a : ENTIER, b : ENTIER
**Type de retour** : STRING
**Exemple :**
```
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`
**Utilisation** : `COS(x)` calcule le cosinus de x, où x est donné en radians.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour :** DOUBLE
**Exemple :**
```
os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)`
fetched rows / total rows = 1/1
+----------+
| COS(0) |
|----------|
| 1.0 |
+----------+
```
##### `COT`
**Utilisation** : `COT(x)` calcule la cotangente de x. Elle renvoie out-of-range une erreur si x est égal à 0.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `COT(1)` = COT(1) | fields `COT(1)`
fetched rows / total rows = 1/1
+--------------------+
| COT(1) |
|--------------------|
| 0.6420926159343306 |
+--------------------+
```
##### `CRC32`
**Utilisation** : `CRC32` calcule une valeur de contrôle de redondance cyclique et renvoie une valeur non signée de 32 bits.
**Type d'argument** : CHAÎNE
**Type de retour** : LONG
**Exemple :**
```
os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')`
fetched rows / total rows = 1/1
+------------------+
| CRC32('MySQL') |
|------------------|
| 3259397556 |
+------------------+
```
##### `DEGREES`
**Utilisation** : `DEGREES(x)` convertit x de radians en degrés.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
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`
**Utilisation** : `E()` renvoie le numéro d'Euler.
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `E()` = E() | fields `E()`
fetched rows / total rows = 1/1
+-------------------+
| E() |
|-------------------|
| 2.718281828459045 |
+-------------------+
```
##### `EXP`
**Utilisation** : `EXP(x)` renvoie e élevé à la puissance de x.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `EXP(2)` = EXP(2) | fields `EXP(2)`
fetched rows / total rows = 1/1
+------------------+
| EXP(2) |
|------------------|
| 7.38905609893065 |
+------------------+
```
##### `FLOOR`
**Utilisation** : `FLOOR(T)` prend le plancher de la valeur T.
**Limitation** : `FLOOR` ne fonctionne comme prévu que lorsque le type double IEEE 754 affiche une décimale lors du stockage.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : LONG
**Exemple :**
```
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`
**Utilisation** : `LN(x)` renvoie le logarithme naturel de x.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `LN(2)` = LN(2) | fields `LN(2)`
fetched rows / total rows = 1/1
+--------------------+
| LN(2) |
|--------------------|
| 0.6931471805599453 |
+--------------------+
```
##### `LOG`
**Utilisation** : `LOG(x)` renvoie le logarithme naturel de x qui est le logarithme en base e du x. log (B, x) est équivalent à log (x) /log (B).
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
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`
**Utilisation** : `LOG2(x)` est équivalent à`log(x)`/`log(2)`.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `LOG2(8)` = LOG2(8) | fields `LOG2(8)`
fetched rows / total rows = 1/1
+-----------+
| LOG2(8) |
|-----------|
| 3.0 |
+-----------+
```
##### `LOG10`
**Utilisation** : `LOG10(x)` est équivalent à`log(x)`/`log(10)`.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `LOG10(100)` = LOG10(100) | fields `LOG10(100)`
fetched rows / total rows = 1/1
+--------------+
| LOG10(100) |
|--------------|
| 2.0 |
+--------------+
```
##### `MOD`
**Utilisation** : `MOD(n, m)` calcule le reste du nombre n divisé par m.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : type plus large entre les types de n et m si m est une valeur différente de zéro. Si m est égal à 0, renvoie NULL.
**Exemple :**
```
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`
**Utilisation** : `PI() ` renvoie la constante pi.
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `PI()` = PI() | fields `PI()`
fetched rows / total rows = 1/1
+-------------------+
| PI() |
|-------------------|
| 3.141592653589793 |
+-------------------+
```
##### `POW`
**Utilisation** : `POW(x, y)` calcule la valeur de x élevée à la puissance de y. Les entrées incorrectes renvoient un `NULL` résultat.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Synonymes** : `POWER(_, _)`
**Exemple :**
```
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
**Utilisation** : `POWER(x, y)` calcule la valeur de x élevée à la puissance de y. Les entrées incorrectes renvoient un `NULL` résultat.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Synonymes** : `POW(_, _)`
**Exemple :**
```
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`
**Utilisation** : `RADIANS(x)` convertit x de degrés en radians.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour** : DOUBLE
**Exemple :**
```
os> source=people | eval `RADIANS(90)` = RADIANS(90) | fields `RADIANS(90)`
fetched rows / total rows = 1/1
+--------------------+
| RADIANS(90) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `RAND`
**Utilisation** :`RAND()`/`RAND(N)`renvoie une valeur à virgule flottante aléatoire comprise entre 0 <= valeur < 1,0. Si vous spécifiez un entier N, la fonction initialise la graine avant son exécution. L'une des conséquences de ce comportement est qu'avec un argument N identique, `rand(N)` renvoie la même valeur à chaque fois, ce qui produit une séquence répétable de valeurs de colonne.
**Type d'argument** : INTEGER
**Type de retour** : FLOAT
**Exemple :**
```
os> source=people | eval `RAND(3)` = RAND(3) | fields `RAND(3)`
fetched rows / total rows = 1/1
+------------+
| RAND(3) |
|------------|
| 0.73105735 |
+------------+
```
##### `ROUND`
**Utilisation** : `ROUND(x, d)` arrondit l'argument x à d décimales. Si vous ne spécifiez pas d, la valeur par défaut est 0.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Carte des types de retour** :
+ (ENTIER/LONG [, ENTIER]) -> LONG
+ (FLOAT/DOUBLE [, ENTIER]) -> LONG
**Exemple :**
```
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`
**Utilisation** : `SIGN` renvoie le signe de l'argument sous la forme -1, 0 ou 1, selon que le nombre est négatif, nul ou positif.
**Type d'argument** : INTEGER/LONG/FLOAT/DOUBLE
**Type de retour :** INTEGER
**Exemple :**
```
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`
**Utilisation** : `sin(x)` calcule le sinus de x, où x est exprimé en radians.
**Type d'argument :** INTEGER/LONG/FLOAT/DOUBLE
**Type de retour :** DOUBLE
**Exemple :**
```
os> source=people | eval `SIN(0)` = SIN(0) | fields `SIN(0)`
fetched rows / total rows = 1/1
+----------+
| SIN(0) |
|----------|
| 0.0 |
+----------+
```
##### `SQRT`
**Utilisation** : `SQRT` calcule la racine carrée d'un nombre non négatif.
**Type d'argument :** INTEGER/LONG/FLOAT/DOUBLE
**Carte des types de retour :**
+ (Non négatif) INTEGER/LONG/FLOAT/DOUBLE -> DOUBLE
+ (Négatif) INTEGER/LONG/FLOAT/DOUBLE -> NULL
**Exemple :**
```
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 |
+-----------+--------------+
```
##### Fonctions de chaîne PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### `CONCAT`
**Utilisation** : `CONCAT(str1, str2, ...., str_9)` additionne jusqu'à 9 chaînes.
**Type d'argument :**
+ CHAÎNE, CHAÎNE,..., CHAÎNE
+ Type de retour : STRING
**Exemple :**
```
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`
**Utilisation** : `CONCAT_WS(sep, str1, str2)` concatène deux chaînes ou plus en utilisant un séparateur spécifié entre elles.
**Type d'argument :**
+ CHAÎNE, CHAÎNE,..., CHAÎNE
+ Type de retour : STRING
**Exemple :**
```
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`
**Utilisation** : `length(str)` renvoie la longueur de la chaîne d'entrée mesurée en octets.
**Type d'argument :**
+ CHAÎNE
+ Type de retour : INTEGER
**Exemple :**
```
os> source=people | eval `LENGTH('helloworld')` = LENGTH('helloworld') | fields `LENGTH('helloworld')`
fetched rows / total rows = 1/1
+------------------------+
| LENGTH('helloworld') |
|------------------------|
| 10 |
+------------------------+
```
##### `LOWER`
**Utilisation** : `lower(string)` convertit la chaîne d'entrée en minuscules.
**Type d'argument :**
+ CHAÎNE
+ Type de retour : STRING
**Exemple :**
```
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`
**Utilisation** : `ltrim(str)` supprime les espaces de début de la chaîne d'entrée.
**Type d'argument :**
+ CHAÎNE
+ Type de retour : STRING
**Exemple :**
```
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`
**Utilisation** : `POSITION(substr IN str)` renvoie la position de la première occurrence d'une sous-chaîne dans une chaîne. Elle renvoie 0 si la sous-chaîne n'est pas dans la chaîne. Elle renvoie NULL si l'un des arguments est NULL.
**Type d'argument :**
+ CHAÎNE, CHAÎNE
+ Type de retour INTEGER
**Exemple :**
```
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`
**Utilisation** : `REVERSE(str)` renvoie la chaîne inversée de la chaîne d'entrée.
**Type d'argument :**
+ CHAÎNE
+ Type de retour : STRING
**Exemple :**
```
os> source=people | eval `REVERSE('abcde')` = REVERSE('abcde') | fields `REVERSE('abcde')`
fetched rows / total rows = 1/1
+--------------------+
| REVERSE('abcde') |
|--------------------|
| edcba |
+--------------------+
```
##### `RIGHT`
**Utilisation** : `right(str, len)` renvoie les caractères les plus à droite de la chaîne d'entrée. Elle renvoie 0 si la sous-chaîne n'est pas dans la chaîne. Elle renvoie NULL si l'un des arguments est NULL.
**Type d'argument :**
+ CHAÎNE, ENTIER
+ Type de retour : STRING
**Exemple :**
```
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`
**Utilisation** : `rtrim(str)` supprime les espaces de fin de la chaîne d'entrée.
**Type d'argument :**
+ CHAÎNE
+ Type de retour : **STRING**
**Exemple :**
```
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`
**Utilisation** : `substring(str, start)` or `substring(str, start, length)` renvoie une sous-chaîne de la chaîne d'entrée. Si aucune longueur n'est spécifiée, elle renvoie la chaîne entière à partir de la position de départ.
**Type d'argument :**
+ CHAÎNE, ENTIER, ENTIER
+ Type de retour : STRING
**Exemple :**
```
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`
**Utilisation** : `trim(string)` supprime les espaces de début et de fin de la chaîne d'entrée.
**Type d'argument :**
+ CHAÎNE
+ Type de retour : **STRING**
**Exemple :**
```
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`
**Utilisation** : `upper(string)` convertit la chaîne d'entrée en majuscules.
**Type d'argument :**
+ CHAÎNE
+ Type de retour : STRING
**Exemple :**
```
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 |
+-----------------------+-----------------------+
```
##### Fonctions de conversion de type PPL
**Note**
Pour savoir quelles intégrations de sources de AWS données prennent en charge cette fonction PPL, consultez. [Fonctions](#supported-ppl-functions)
##### `TRIM`
**Utilisation** : `cast(expr as dateType)` convertit le `expr` en `dataType` et renvoie la valeur du`dataType`.
Les règles de conversion suivantes s'appliquent :
**Règles de conversion de type**
| Src/Cible | CHAÎNE | NOMBRE | BOOLEAN | TIMESTAMP | DATE | TIME |
| --- | --- | --- | --- | --- | --- | --- |
| CHAÎNE | | Remarque 1 | Remarque 1 | HORODATAGE () | DATE () | HEURE () |
| NOMBRE | Remarque 1 | | v \! =0 | N/A | N/A | N/A |
| BOOLEAN | Remarque 1 | v ? 1:0 | | N/A | N/A | N/A |
| TIMESTAMP | Remarque 1 | N/A | N/A | | DATE () | HEURE () |
| DATE | Remarque 1 | N/A | N/A | N/A | | N/A |
| TIME | Remarque 1 | N/A | N/A | N/A | N/A | |
**Exemple de conversion en chaîne :**
```
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 |
+---------+--------+------------+
```
**Exemple de conversion numérique :**
```
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 |
+---------+-----------+
```
**Exemple de diffusion à ce jour :**
```
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 |
+------------+----------+---------------------+
```
**Exemple de casting enchaîné :**
```
os> source=people | eval `cbool` = CAST(CAST(true as string) as boolean) | fields `cbool`
fetched rows / total rows = 1/1
+---------+
| cbool |
|---------|
| True |
+---------+
```