Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Comandi PPL supportati
Le tabelle seguenti mostrano quali comandi PPL sono supportati da OpenSearch Dashboards per interrogare CloudWatch Logs, Amazon S3 o Security Lake e quali comandi supporta Logs Insights. CloudWatch CloudWatch Logs Insights utilizza la stessa sintassi PPL di OpenSearch Dashboards per interrogare CloudWatch Logs e le tabelle si riferiscono a entrambi come Logs. CloudWatch
**Nota**
Quando si analizzano i dati al di fuori del OpenSearch servizio, i comandi potrebbero essere eseguiti in modo diverso rispetto agli indici. OpenSearch
**Topics**
+ [Comandi](#supported-ppl-commands)
+ [Funzioni](#supported-ppl-functions)
+ [Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano PPL OpenSearch](#supported-ppl-for-cloudwatch-users)
## Comandi
| Comando PPL | Description | CloudWatch Registri | Simple Storage Service (Amazon S3) | Lago di sicurezza | Esempio di comando |
| --- | --- | --- | --- | --- | --- |
| [comando fields](#supported-ppl-fields-command) | Visualizza una serie di campi che necessitano di proiezione. | Supportato | Supportato | Supportato | fields field1, field2
|
| [comando where](#supported-ppl-where-command) | Filtra i dati in base alle condizioni specificate. | Supportato | Supportato | Supportato | where field1="success"
| where field2 != "i -023fe0a90929d8822"
| fields field3, col4, col5, col6
| head 1000
|
| [comando stats](#supported-ppl-stats-command) | Esegue aggregazioni e calcoli. | Supportato | Supportato | Supportato | stats count(),
count(`field1`),
min(`field1`),
max(`field1`),
avg(`field1`)
by field2
| head 1000
|
| [comando parse](#supported-ppl-parse-command) | Estrae un pattern di espressione regolare (regex) da una stringa e visualizza il pattern estratto. Il pattern estratto può essere ulteriormente utilizzato per creare nuovi campi o filtrare i dati. | Supportato | Supportato | Supportato | parse `field1` ".*/(?[^/]+$)"
| where field2 = "requestId"
| fields field2, `field2`
| head 1000
|
| [comando patterns](#supported-ppl-patterns-command) | Estrae i modelli di registro da un campo di testo e aggiunge i risultati al risultato della ricerca. Il raggruppamento dei log in base ai relativi schemi semplifica l'aggregazione delle statistiche provenienti da grandi volumi di dati di registro per l'analisi e la risoluzione dei problemi. | Non supportato | Supportato | Supportato | patterns new_field='no_numbers' pattern='[0-9]' message
| fields message, no_numbers
|
| [comando sort](#supported-ppl-sort-command) | Ordina i risultati visualizzati in base al nome di un campo. Usa **sort - *FieldName***per ordinare in ordine decrescente. | Supportato | Supportato | Supportato | stats count(),
count(`field1`),
min(`field1`) as field1Alias,
max(`field1`),
avg(`field1`)
by field2
| sort -field1Alias
| head 1000
|
| [comando eval](#supported-ppl-eval-command) | Modifica o elabora il valore di un campo e lo memorizza in un campo diverso. Ciò è utile per modificare matematicamente una colonna, applicare funzioni di stringa a una colonna o applicare funzioni di data a una colonna. | Supportato | Supportato | Supportato | eval field2 = `field1` * 2
| fields field1, field2
| head 20
|
| [comando di ridenominazione](#supported-ppl-rename-command) | Rinomina uno o più campi nei risultati della ricerca. | Supportato | Supportato | Supportato | rename field2 as field1
| fields field1
|
| [comando head](#supported-ppl-head-command) | Limita i risultati dell'interrogazione visualizzati alle prime N righe. | Supportato | Supportato | Supportato | fields `@message`
| head 20
|
| [comando grok](#supported-ppl-grok-command) | Analizza un campo di testo con un pattern grok basato su un'espressione regolare e aggiunge i risultati al risultato della ricerca. | Supportato | Supportato | Supportato | grok email '.+@%{HOSTNAME:host}'
| fields email |
| [comando top](#supported-ppl-top-command) | Trova i valori più frequenti per un campo. | Supportato | Supportato | Supportato | top 2 Field1 by Field2
|
| [comando dedup](#supported-ppl-dedup-command) | Rimuove le voci duplicate in base ai campi specificati. | Supportato | Supportato | Supportato | dedup field1
| fields field1, field2, field3
|
| [comando join](#supported-ppl-join-commands) | Unisce due set di dati. | Supportato | Supportato | Supportato | source=customer
| join ON c_custkey = o_custkey orders
| head 10
|
| [comando lookup](#supported-ppl-lookup-commands) | Arricchisce i dati di ricerca aggiungendo o sostituendo i dati da un indice di ricerca (tabella delle dimensioni). È possibile estendere i campi di un indice con i valori di una tabella delle dimensioni, aggiungere o sostituire valori quando viene soddisfatta la condizione di ricerca | Non supportato | Supportato | Supportato | where orderType = 'Cancelled'
| lookup account_list, mkt_id AS mkt_code
replace amount, account_name as name
| stats count(mkt_code), avg(amount)
by name
|
| [comando subquery](#supported-ppl-subquery-commands) | Esegue interrogazioni complesse e annidate all'interno delle istruzioni PPL (Piped Processing Language). | Supportato | Supportato | Supportato | where id in [
subquery source=users
| where user in [
subquery source=actions
| where action="login"
| fields user
]
| fields uid
]
|
| [comando raro](#supported-ppl-rare-command) | Trova i valori meno frequenti di tutti i campi nell'elenco dei campi. | Supportato | Supportato | Supportato | rare Field1 by Field2
|
| [comando trendline](#supported-ppl-trendline-commands) | Calcola le medie mobili dei campi. | Supportato | Supportato | Supportato | trendline sma(2, field1) as field1Alias
|
| [comando eventstats](#supported-ppl-eventstats-command) | Arricchisce i dati degli eventi con statistiche riassuntive calcolate. Analizza i campi specifici all'interno degli eventi, calcola varie misure statistiche e quindi aggiunge questi risultati a ciascun evento originale come nuovi campi. | Supportato (eccetto) `count()` | Supportato | Supportato | eventstats sum(field1) by field2
|
| [comando flatten](#supported-ppl-flatten-command) | Appiattisce un campo. Il campo deve essere di questo tipo: `struct or array>` | Supportato | Supportato | Supportato | source=table | flatten field1
|
| [riepilogo del campo](#supported-ppl-field-summary-command) | Calcola le statistiche di base per ogni campo (conteggio, conteggio distinto, min, max, avg, stddev e mean). | Supportato (un campo per query) | Supportato | Supportato | where field1 != 200
| fieldsummary includefields=field1 nulls=true
|
| [comando fillnull](#supported-ppl-fillnull-command) | Riempie i campi nulli con il valore fornito. Può essere utilizzato in uno o più campi. | Supportato | Supportato | Supportato | fields field1
| eval field2=field1
| fillnull value=0 field1
|
| [comando expand](#supported-ppl-expand-command) | Suddivide un campo contenente più valori in righe separate, creando una nuova riga per ogni valore nel campo specificato. | Supportato | Supportato | Supportato | expand employee
| stats max(salary) as max
by state, company
|
| [comando describe](#supported-ppl-describe-command) | Ottiene informazioni dettagliate sulla struttura e i metadati di tabelle, schemi e cataloghi | Non supportato | Supportato | Supportato | describe schema.table
|
## Funzioni
| Funzione PPL | Description | CloudWatch Registri | Simple Storage Service (Amazon S3) | Lago di sicurezza | Esempio di comando |
| --- | --- | --- | --- | --- | --- |
| [Funzioni di stringa PPL](#supported-ppl-string-functions)
(`CONCAT`, `CONCAT_WS`, `LENGTH`, `LOWER`, `LTRIM`, `POSITION`, `REVERSE`, `RIGHT`, `RTRIM`, `SUBSTRING`, `TRIM`, `UPPER`) | Funzioni integrate in PPL in grado di manipolare e trasformare stringhe e dati di testo all'interno di query PPL. Ad esempio, convertire maiuscole e minuscole, combinare stringhe, estrarre parti e pulire il testo. | Supportato | Supportato | Supportato | eval col1Len = LENGTH(col1)
| fields col1Len
|
| [Funzioni di data e ora 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`) | Funzioni integrate per la gestione e la trasformazione dei dati di data e ora nelle query PPL. ******Ad esempio, **date\_add, date\_format, datediff e current\_date**.****** | Supportato | Supportato | Supportato | eval newDate = ADDDATE(DATE('2020-08-26'), 1)
| fields newDate |
| [Funzioni di condizione PPL](#supported-ppl-condition-functions)
(`EXISTS`, `IF`, `IFNULL`, `ISNOTNULL`, `ISNULL`, `NULLIF`) | Funzioni integrate che eseguono calcoli su più righe per produrre un unico valore riepilogato. **Ad esempio, **sum**, **count**, **avg**, **max** e min.** | Supportato | Supportato | Supportato | eval field2 = isnull(col1)
| fields field2, col1, field3
|
| [Funzioni matematiche 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`) | Funzioni integrate per eseguire calcoli e trasformazioni matematiche nelle query PPL. Ad esempio: **abs** (valore assoluto), **round** (arrotonda i numeri), **sqrt** (radice quadrata), **pow** (calcolo della potenza) e **ceil** (arrotonda al numero intero più vicino). | Supportato | Supportato | Supportato | eval field2 = ACOS(col1)
| fields col1
|
| [espressioni PPL](#supported-ppl-expressions)
(Operatori aritmetici (`+`,,`*`)`-`, Operatori predicati (,) `>. <` `IN)` | Le funzioni integrate per le espressioni, in particolare le espressioni di valore, restituiscono un valore scalare. Le espressioni hanno tipi e forme diversi. | Supportato | Supportato | Supportato | where age > (25 + 5)
| fields age
|
| [Funzioni degli indirizzi IP PPL](#supported-ppl-ip-address-functions)
(`CIDRMATCH`) | Funzioni integrate per la gestione di indirizzi IP come CIDR. | Supportato | Supportato | Supportato | where cidrmatch(ip, '***********/24')
| fields ip
|
| [Funzioni PPL JSON](#supported-ppl-json-functions)
(`ARRAY_LENGTH`, `ARRAY_LENGTH`, `JSON`, `JSON_ARRAY`, `JSON_EXTRACT`, `JSON_KEYS`, `JSON_OBJECT`, `JSON_VALID`, `TO_JSON_STRING`) | Funzioni integrate per la gestione di JSON, tra cui array, estrazione e convalida. | Supportato | Supportato | Supportato | eval `json_extract('{"a":"b"}', '$.a')` = json_extract('{"a":"b"}', '$a') |
| [Funzioni PPL Lambda](#supported-ppl-lambda-functions)
(`EXISTS`, `FILTER`, `REDUCE`, `TRANSFORM`) | Funzioni integrate per la gestione di JSON, tra cui array, estrazione e convalida. | Non supportata | Supportato | Supportato | eval array = json_array(1, -1, 2),
result = filter(array, x -> x > 0)
| fields result
|
| [funzioni hash crittografiche PPL](#supported-ppl-cryptographic-functions)
(`MD5`, `SHA1`, `SHA2`) | Funzioni integrate che consentono di generare impronte digitali uniche di dati, che possono essere utilizzate per la verifica, il confronto o come parte di protocolli di sicurezza più complessi. | Supportato | Supportato | Supportato | eval `MD5('hello')` = MD5('hello')
| fields `MD5('hello')` |
## Informazioni aggiuntive per gli utenti di CloudWatch Logs Insights che utilizzano PPL OpenSearch
Sebbene CloudWatch Logs Insights supporti la maggior parte dei comandi e delle funzioni OpenSearch PPL, alcuni comandi e funzioni non sono attualmente supportati. Ad esempio, attualmente non supporta i comandi Lookup in PPL. A partire dal 2 giugno 2025, CloudWatch Logs Insights ora supporta le funzioni JOIN, subqueries, Flatten, Fillnull, Expand, Cidrmatch e JSON in PPL. Per un elenco completo dei comandi e delle funzioni di query supportati, consulta le colonne di Amazon CloudWatch Logs nelle tabelle precedenti.
### Esempi di domande e quote
Quanto segue si applica sia agli utenti di CloudWatch Logs Insights che agli utenti che effettuano query sui dati. OpenSearch CloudWatch
Per informazioni sui limiti che si applicano all'interrogazione di CloudWatch Logs from OpenSearch Service, consulta [CloudWatch Logs quotas nella Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html) User Guide. I limiti riguardano il numero di gruppi di CloudWatch log su cui è possibile eseguire query, il numero massimo di query simultanee che è possibile eseguire, il tempo massimo di esecuzione delle query e il numero massimo di righe restituite nei risultati. I limiti sono gli stessi indipendentemente dal linguaggio utilizzato per interrogare i log (ovvero OpenSearch PPL, SQL e CloudWatch Logs Insights QL).
### Comandi PPL
**Topics**
+ [comment](#supported-ppl-comment)
+ [comando di correlazione](#supported-ppl-correlation-commands)
+ [comando dedup](#supported-ppl-dedup-command)
+ [comando describe](#supported-ppl-describe-command)
+ [comando eval](#supported-ppl-eval-command)
+ [comando eventstats](#supported-ppl-eventstats-command)
+ [comando expand](#supported-ppl-expand-commands)
+ [comando explain](#supported-ppl-explain-command)
+ [comando fillnull](#supported-ppl-fillnull-command)
+ [comando fields](#supported-ppl-fields-command)
+ [comando flatten](#supported-ppl-flatten-command)
+ [comando grok](#supported-ppl-grok-command)
+ [comando head](#supported-ppl-head-command)
+ [comando join](#supported-ppl-join-commands)
+ [comando lookup](#supported-ppl-lookup-commands)
+ [comando parse](#supported-ppl-parse-command)
+ [comando patterns](#supported-ppl-patterns-command)
+ [comando raro](#supported-ppl-rare-command)
+ [comando di ridenominazione](#supported-ppl-rename-command)
+ [comando di ricerca](#supported-ppl-search-command)
+ [comando sort](#supported-ppl-sort-command)
+ [comando stats](#supported-ppl-stats-command)
+ [comando subquery](#supported-ppl-subquery-commands)
+ [comando top](#supported-ppl-top-command)
+ [comando trendline](#supported-ppl-trendline-commands)
+ [comando where](#supported-ppl-where-command)
+ [riepilogo del campo](#supported-ppl-field-summary-command)
+ [comando expand](#supported-ppl-expand-command)
+ [Funzioni PPL](#supported-ppl-functions-details)
#### comment
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
PPL supporta sia i commenti di riga che i commenti a blocchi. Il sistema non valuta il testo dei commenti.
**Commenti di riga**
I commenti alle righe iniziano con due barre//e terminano con una nuova riga.
Esempio:
```
os> source=accounts | top gender // finds most common gender of all the accounts
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Blocca commenti**
I commenti di blocco iniziano con una barra seguita da un asterisco\\ \* e terminano con un asterisco seguito da una barra \*/.
Esempio:
```
os> source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender
fetched rows / total rows = 3/3
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 6 | M |
| 13 | F |
+------------------+----------+
```
#### comando di correlazione
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
È possibile correlare diverse fonti di dati in base a dimensioni e intervalli di tempo comuni.
Questa correlazione è fondamentale quando si ha a che fare con grandi quantità di dati provenienti da vari settori verticali che condividono gli stessi periodi di tempo ma non sono formalmente sincronizzati.
Correlando queste diverse fonti di dati in base a intervalli di tempo e dimensioni simili, puoi arricchire i dati e scoprire informazioni preziose.
**Esempio**
Il dominio dell'osservabilità ha tre fonti di dati distinte:
+ Log
+ Metriche
+ Tracce
Queste fonti di dati potrebbero condividere dimensioni comuni. Per passare da una fonte di dati all'altra, è necessario correlarle correttamente. Utilizzando le convenzioni di denominazione semantica, puoi identificare gli elementi condivisi tra log, tracce e metriche.
Esempio:
```
{
"@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"
}
```
Questo esempio mostra un log AWS ELB proveniente da un servizio che risiede su. AWS Mostra una risposta HTTP di backend con un codice di stato 500, che indica un errore. Ciò potrebbe attivare un avviso o far parte del normale processo di monitoraggio. Il passo successivo è raccogliere dati pertinenti su questo evento per un'indagine approfondita.
Anche se potreste essere tentati di interrogare tutti i dati relativi al periodo di tempo, questo approccio può rivelarsi faticoso. Potresti finire con troppe informazioni e dedicare più tempo a filtrare i dati irrilevanti che a identificare la causa principale.
Puoi invece utilizzare un approccio più mirato correlando i dati provenienti da fonti diverse. Puoi utilizzare queste dimensioni per la correlazione:
+ **IP -** `"ip": "10.0.0.1" | "ip": "**************"`
+ **Porta** - `"port": 2817 | "target_port": "10.0.0.1:80"`
Supponendo che tu abbia accesso a tracce e indici metrici aggiuntivi e che tu abbia familiarità con la struttura dello schema, puoi creare una query di correlazione più precisa.
Ecco un esempio di documento con indice di traccia contenente informazioni HTTP che potresti voler correlare:
```
{
"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": {
...
}
}
}
}
}
```
In questo approccio puoi vedere gli `traceId` e gli http client/server `ip` che possono essere correlati ai log elb per comprendere meglio il comportamento e le condizioni del sistema.
**Nuovo comando di interrogazione di correlazione**
Ecco il nuovo comando che consentirebbe questo tipo di indagine:
```
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 )
```
Ecco cosa fa ogni parte del comando:
1. `source alb_logs, traces`- Seleziona le fonti di dati che desideri correlare.
1. `where ip="10.0.0.1" AND cloud.provider="aws"`- Questo restringe l'ambito della ricerca.
1. `correlate exact fields(traceId, ip)`- Ciò indica al sistema di correlare i dati in base alle corrispondenze esatte dei seguenti campi:
+ Il `ip` campo ha una condizione di filtro esplicita, quindi verrà utilizzato nella correlazione per tutte le fonti di dati.
+ Il `traceId` campo non ha un filtro esplicito, quindi corrisponderà agli stessi traceID in tutte le fonti di dati.
I nomi dei campi indicano il significato logico della funzione all'interno del comando di correlazione. La condizione di unione effettiva si basa sull'istruzione di mappatura fornita.
Il termine `exact` indica che le istruzioni di correlazione richiederanno che tutti i campi corrispondano per soddisfare l'istruzione di query.
Il termine `approximate` cercherà di corrispondere nel migliore dei casi e non rifiuterà le righe con corrispondenze parziali.
**Risolvere diversi tipi di mappatura dei campi**
Nei casi in cui lo stesso campo logico (ad esempio`ip`) ha nomi diversi tra le fonti di dati, è necessario fornire la mappatura esplicita dei campi del percorso. Per risolvere questo problema, puoi estendere le condizioni di correlazione in modo che corrispondano nomi di campo diversi con significati logici simili. Ecco come puoi farlo:
```
alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId
```
Per ogni campo che partecipa al join di correlazione, è necessario fornire una dichiarazione di mappatura pertinente che includa tutte le tabelle che devono essere unite da questo comando di correlazione.
**Esempio**
In questo esempio, ci sono 2 fonti: `alb_logs, traces`
Ci sono 2 campi: `traceId, ip`
Esistono 2 istruzioni di mappatura: `alb_logs.ip = traces.attributes.http.server.address, alb_logs.traceId = traces.traceId`
**Definizione dei tempi di correlazione**
Per semplificare il lavoro svolto dal motore di esecuzione (driver), puoi aggiungere l'istruzione scope. Ciò indica in modo esplicito alla join query l'ora in cui deve spaziare per questa ricerca.
`scope(@timestamp, 1D)`i
In questo esempio, l'ambito di ricerca si concentra su base giornaliera, quindi le correlazioni che appaiono nello stesso giorno vengono raggruppate. Questo meccanismo di definizione dell'ambito semplifica e consente un migliore controllo sui risultati, abilitando una risoluzione incrementale della ricerca in base alle esigenze dell'utente.
**Driver di supporto**
Il nuovo comando di correlazione è in realtà un comando join «nascosto». Pertanto, solo i seguenti driver PPL supportano questo comando. In questi driver, il comando di correlazione verrà tradotto direttamente nel piano logico Catalyst Join appropriato.
**Esempio**
`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)`
**Piano logico:**
```
'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]
```
Il motore catalyst ottimizza questa query in base all'ordinamento di giunzione più efficiente.
#### comando dedup
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `dedup` comando per rimuovere documenti identici dai risultati della ricerca in base ai campi specificati.
**Sintassi**
Utilizzare la seguente sintassi:
```
dedup [int] [keepempty=] [consecutive=]
```
**`int`**
+ Opzionale.
+ Il `dedup` comando conserva più eventi per ogni combinazione quando viene specificata. Il numero per deve essere maggiore di 0. Se non si specifica un numero, viene mantenuto solo il primo evento che si verifica. Tutti gli altri duplicati vengono rimossi dai risultati.
+ Impostazione predefinita: 1
**`keepempty`**
+ Opzionale.
+ Se vero, mantiene i documenti in cui qualsiasi campo dell'elenco dei campi ha un valore NULL o è MANCANTE.
+ Impostazione predefinita: false
**`consecutive`**
+ Opzionale.
+ Se vero, rimuove solo gli eventi con combinazioni di valori duplicate consecutive.
+ Impostazione predefinita: false
**`field-list`**
+ Obbligatorio.
+ Un elenco di campi delimitato da virgole. È richiesto almeno un campo.
**Esempio 1: deduplicazione per un campo**
Questo esempio mostra come deduplicare i documenti utilizzando il campo gender.
Interrogazione PPL:
```
os> source=accounts | dedup gender | fields account_number, gender;
fetched rows / total rows = 2/2
+------------------+----------+
| account_number | gender |
|------------------+----------|
| 1 | M |
| 13 | F |
+------------------+----------+
```
**Esempio 2: Conserva 2 documenti duplicati**
L'esempio mostra come deduplicare i documenti con il campo relativo al genere, conservando due duplicati.
Interrogazione 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 |
+------------------+----------+
```
**Esempio 3: Mantieni o ignora il campo vuoto per impostazione predefinita**
L'esempio mostra come deduplicare il documento mantenendo il campo con valore nullo.
Interrogazione 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'esempio mostra come deduplicare il documento ignorando il campo del valore vuoto.
Interrogazione 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 |
+------------------+-----------------------+
```
**Esempio 4: deduplicazione in documenti consecutivi**
L'esempio mostra come eseguire la deduplicazione in documenti consecutivi.
Interrogazione 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 |
+------------------+----------+
```
**Esempi aggiuntivi**
+ `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 deduplicazione consecutiva non è supportata)
**Limitazione**
+ Per `| 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
```
+ Per `| dedup 2 a, b keepempty=true`
```
Union
:- DataFrameDropColumns('_row_number_)
: +- Filter ('_row_number_ <= 2)
: +- Window [row_number() windowspecdefinition('a, 'b, 'a ASC NULLS FIRST, 'b ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS _row_number_], ['a, 'b], ['a ASC NULLS FIRST, 'b ASC NULLS FIRST]
: +- Filter (isnotnull('a) AND isnotnull('b))
: +- Project
: +- UnresolvedRelation
+- Filter (isnull('a) OR isnull('b))
+- Project
+- UnresolvedRelation
```
#### comando describe
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `describe` comando per ottenere informazioni dettagliate sulla struttura e i metadati di tabelle, schemi e cataloghi. Di seguito sono riportati vari esempi e casi d'uso del comando. `describe`
**Describe**
+ `describe table`Questo comando è uguale al comando `DESCRIBE EXTENDED table` SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
#### comando eval
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Il `eval` comando valuta l'espressione e aggiunge il risultato al risultato della ricerca.
**Sintassi**
Utilizzare la seguente sintassi:
```
eval = ["," = ]...
```
+ `field`: Obbligatorio. Se il nome del campo non esiste, viene aggiunto un nuovo campo. Se il nome del campo esiste già, verrà sovrascritto.
+ `expression`: Obbligatorio. Qualsiasi espressione supportata dal sistema.
**Esempio 1: creare il nuovo campo**
Questo esempio mostra come creare un nuovo `doubleAge` campo per ogni documento. Il nuovo `doubleAge` è il risultato della valutazione dell'età moltiplicato per 2.
Interrogazione 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 |
+-------+-------------+
```
**Esempio 2: sovrascrivi il campo esistente**
Questo esempio mostra come sovrascrivere il campo età esistente con age plus 1.
Interrogazione PPL:
```
os> source=accounts | eval age = age + 1 | fields age ;
fetched rows / total rows = 4/4
+-------+
| age |
|-------|
| 33 |
| 37 |
| 29 |
| 34 |
+-------+
```
**Esempio 3: crea il nuovo campo con il campo definito in eval**
Questo esempio mostra come creare un nuovo `ddAge` campo con un campo definito nel comando eval. Il nuovo campo `ddAge` è il risultato della valutazione di `doubleAge` moltiplicato per 2, dove `doubleAge` è definito nel comando eval.
Interrogazione 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 |
+-------+-------------+---------+
```
Ipotesi:`a`,`b`, `c` sono campi esistenti in `table`
**Esempi aggiuntivi**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(campi di output 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`
**Valuta con un esempio di caso:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Valuta con un altro esempio di caso:**
Ipotesi:`a`,`b`, `c` sono campi esistenti in `table`
**Esempi aggiuntivi**
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(campi di output 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`
**Valuta con un esempio di caso:**
```
source = table | eval e = eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Unknown')
```
**Valuta con un altro esempio di caso:**
```
source = table | where ispresent(a) |
eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
)
| stats count() by status_category
```
**Limitazioni**
+ La sovrascrittura dei campi esistenti non è supportata. Le query che tentano di farlo genereranno delle eccezioni con il messaggio «Il riferimento 'a' è ambiguo».
```
- `source = table | eval a = 10 | fields a,b,c`
- `source = table | eval a = a * 2 | stats avg(a)`
- `source = table | eval a = abs(a) | where a > 0`
- `source = table | eval a = signum(a) | where a < 0`
```
#### comando eventstats
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `eventstats` comando per arricchire i dati degli eventi con statistiche di riepilogo calcolate. Funziona analizzando campi specifici all'interno degli eventi, calcolando varie misure statistiche e quindi aggiungendo questi risultati come nuovi campi a ciascun evento originale.
**Aspetti chiave di eventstats**
1. Esegue calcoli sull'intero set di risultati o all'interno di gruppi definiti.
1. Gli eventi originali rimangono intatti, con nuovi campi aggiunti per contenere i risultati statistici.
1. Il comando è particolarmente utile per l'analisi comparativa, l'identificazione di valori anomali o l'aggiunta di un contesto aggiuntivo ai singoli eventi.
**Differenza tra stats e eventstats**
`eventstats`I comandi `stats` and vengono entrambi utilizzati per il calcolo delle statistiche, ma presentano alcune differenze fondamentali nel modo in cui funzionano e nei risultati che producono.
**Formato di output**
+ `stats`: produce una tabella di riepilogo con solo le statistiche calcolate.
+ `eventstats`: aggiunge le statistiche calcolate come nuovi campi agli eventi esistenti, preservando i dati originali.
**Conservazione degli eventi**
+ `stats`: Riduce il set di risultati al solo riepilogo statistico, eliminando i singoli eventi.
+ `eventstats`: conserva tutti gli eventi originali e aggiunge nuovi campi con le statistiche calcolate.
**Casi d’uso**
+ `stats`: Ideale per creare report o dashboard di riepilogo. Spesso utilizzato come comando finale per riepilogare i risultati.
+ `eventstats`: Utile quando è necessario arricchire gli eventi con un contesto statistico per ulteriori analisi o filtri. Può essere utilizzato durante la ricerca per aggiungere statistiche da utilizzare nei comandi successivi.
**Sintassi**
Utilizzare la seguente sintassi:
```
eventstats ... [by-clause]
```
**Aggregazione**
+ Obbligatorio.
+ Una funzione di aggregazione.
+ L'argomento dell'aggregazione deve essere un campo.
**clausola secondaria**
+ Opzionale.
+ Sintassi: `by [span-expression,] [field,]...`
+ La clausola by può includere campi ed espressioni come funzioni scalari e funzioni di aggregazione. È inoltre possibile utilizzare la clausola span per suddividere un campo specifico in bucket di intervalli uguali. Il comando eventstats esegue quindi l'aggregazione in base a questi span bucket.
+ Impostazione predefinita: se non si specifica una clausola by, il comando eventstats si aggrega sull'intero set di risultati.
**espressione span-expression**
+ Facoltativo, al massimo uno.
+ Sintassi: `span(field_expr, interval_expr)`
+ L'unità dell'espressione dell'intervallo è l'unità naturale di default. Tuttavia, per i campi relativi ai tipi di data e ora, è necessario specificare l'unità nell'espressione dell'intervallo quando si utilizzano unità di data/ora.
Ad esempio, per dividere il campo `age` in bucket per 10 anni, usa. `span(age, 10)` Per i campi basati sul tempo, puoi dividere un `timestamp` campo in intervalli orari utilizzando. `span(timestamp, 1h)`
**Unità di tempo disponibili**
| Unità di intervallo di ampiezza |
| --- |
| millisecondo (ms) |
| secondo/i |
| minuto (m, distinzione tra maiuscole e minuscole) |
| ora (h) |
| giorno (d) |
| settimana (e) |
| mese (M, distinzione tra maiuscole e minuscole) |
| trimestre (q) |
| anno (y) |
**Funzioni di aggregazione**
**`COUNT`**
`COUNT`restituisce un conteggio del numero di espr nelle righe recuperate da un'istruzione SELECT.
Per CloudWatch Logs utilizza le query, `COUNT` non è supportata.
Esempio:
```
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)`restituisce la somma di expr.
Esempio:
```
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)`restituisce il valore medio di expr.
Esempio:
```
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)`Restituisce il valore massimo di expr.
Esempio
```
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)`Restituisce il valore minimo di expr.
Esempio
```
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)`Restituisce la deviazione standard del campione di expr.
Esempio
```
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)`Restituisce la deviazione standard della popolazione di expr.
Esempio
```
os> source=accounts | eventstats stddev_pop(age);
fetched rows / total rows = 4/4
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| account_number | balance | firstname | lastname | age | gender | address | employer | email | city | state | stddev_pop(age) |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
| 1 | 39225 | Jane | Doe | 32 | M | 880 Any Lane | AnyCorp | janedoe@anycorp.com | Brogan | IL | 2.**************** |
| 6 | 5686 | Mary | Major | 36 | M | *** Example Street | Any Company | marymajor@anycompany.com | Dante | TN | 2.**************** |
| 13 | 32838 | Nikki | Wolf | 28 | F | *** Any Street | AnyOrg | | Nogal | VA | 2.**************** |
| 18 | 4180 | Juan | Li | 33 | M | *** Example Court | | juanli@exampleorg.com | Orick | MD | 2.**************** |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+------------------------+
```
**PERCENTILE o PERCENTILE\_APPROX**
`PERCENTILE(expr, percent)`o `PERCENTILE_APPROX(expr, percent)` Restituisce il valore percentile approssimativo di expr alla percentuale specificata.
**percentuale**
+ Il numero deve essere una costante compresa tra 0 e 100.
Esempio
```
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+--------------------------------+
```
**Esempio 1: calcola la media, la somma e il conteggio di un campo per gruppo**
L'esempio mostra come calcolare l'età media, la somma dell'età e il conteggio degli eventi di tutti gli account raggruppati per genere.
```
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+-----------+-----------+-------+
```
**Esempio 2: calcola il conteggio per un intervallo**
L'esempio ottiene il conteggio dell'età per un intervallo di 10 anni.
```
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+--------------------------+--------+-------+----------+
```
**Esempio 3: calcola il conteggio in base al sesso e all'intervallo**
L'esempio ottiene il conteggio dell'età per intervallo di 5 anni e il gruppo per sesso.
```
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 |
+----------------+----------+-----------+----------+-----+--------+-----------------------+-------------+---------------------------+--------+-------+-----+
```
**Utilizzo**
+ `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)`
**Aggregazioni con span**
+ `source = table | eventstats count(a) by span(a, 10) as a_span`
+ `source = table | eventstats sum(age) by span(age, 5) as age_span | head 2`
+ `source = table | eventstats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
**Aggregazioni con intervallo di tempo (funzione tumble windowing)**
+ `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`
**Le aggregazioni sono raggruppate per più livelli**
+ `source = table | eventstats avg(age) as avg_state_age by country, state | eventstats avg(avg_state_age) as avg_country_age by country`
+ `source = table | eventstats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | eventstats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | eventstats avg(avg_state_age) as avg_adult_country_age by country`
#### comando expand
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `expand` comando per appiattire un campo di tipo:
+ `Array`
+ `Map`
**Sintassi**
Utilizzare la seguente sintassi:
```
expand [As alias]
```
**field**
+ Il campo da espandere (esplodere). Deve essere di un tipo supportato.
**alias**
+ Opzionale. Il nome da utilizzare al posto del nome del campo originale.
**Utilizzo**
Il `expand` comando produce una riga per ogni elemento nell'array o nel campo della mappa specificato, dove:
+ Gli elementi dell'array diventano righe singole.
+ Le coppie chiave-valore della mappa sono suddivise in righe separate, con ogni valore chiave rappresentato come una riga.
+ Quando viene fornito un alias, i valori esplosi vengono rappresentati sotto l'alias anziché nel nome del campo originale.
+ Questo può essere usato in combinazione con altri comandi, come `stats``eval`, e `parse` per manipolare o estrarre i dati dopo l'espansione.
**Esempi**
+ `source = table | expand employee | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | stats max(salary) as max by state, company`
+ `source = table | expand employee as worker | eval bonus = salary * 3 | fields worker, bonus`
+ `source = table | expand employee | parse description '(?.+@.+)' | fields employee, email`
+ `source = table | eval array=json_array(1, 2, 3) | expand array as uid | fields name, occupation, uid`
+ `source = table | expand multi_valueA as multiA | expand multi_valueB as multiB`
#### comando explain
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Il `explain` comando consente di comprendere i piani di esecuzione delle query, consentendovi di analizzare e ottimizzare le query per migliorare le prestazioni. Questa introduzione fornisce una panoramica concisa dello scopo del comando explain e della sua importanza nell'ottimizzazione delle query.
**Comment**
+ `source=accounts | top gender // finds most common gender of all the accounts`(commento di riga)
+ `source=accounts | dedup 2 gender /* dedup the document with gender field keep 2 duplication */ | fields account_number, gender`(commento del blocco)
**Describe**
+ `describe table`Questo comando è uguale al comando `DESCRIBE EXTENDED table` SQL
+ `describe schema.table`
+ `describe schema.`table``
+ `describe catalog.schema.table`
+ `describe catalog.schema.`table``
+ `describe `catalog`.`schema`.`table``
**Spiegazione**
+ `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`
**Campi**
+ `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`
**Riepilogo del campo**
+ `source = t | fieldsummary includefields=status_code nulls=false`
+ `source = t | fieldsummary includefields= id, status_code, request_path nulls=true`
+ `source = t | where status_code != 200 | fieldsummary includefields= status_code nulls=true`
**Campo annidato**
+ `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`
**Filtri**
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a not in (1, 2, 3) | fields a,b,c`
+ `source = table | where a between 1 and 4`- Nota: questo restituisce un >= 1 e un <= 4, cioè [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Nota: restituisce b >= '\*\*\*\*\*\*\*\*\*\*' e b <= '2025-09-10'
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
+ `source = table | trendline sma(2, temperature) as temp_trend`
**Interrogazioni relative all'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`
**Filtri complessi**
```
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
```
**Filtri con condizioni logiche**
+ `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`
**Valutazione**
Ipotesi:`a`,`b`, `c` sono campi esistenti in `table`
+ `source = table | eval f = 1 | fields a,b,c,f`
+ `source = table | eval f = 1`(campi di output a, b, c, f)
+ `source = table | eval n = now() | eval t = unix_timestamp(a) | fields n,t`
+ `source = table | eval f = a | where f > 1 | sort f | fields a,b,c | head 5`
+ `source = table | eval f = a * 2 | eval h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = f * 2 | fields a,f,h`
+ `source = table | eval f = a * 2, h = b | stats avg(f) by h`
+ `source = table | eval f = ispresent(a)`
+ `source = table | eval r = coalesce(a, b, c) | fields r`
+ `source = table | eval e = isempty(a) | fields e`
+ `source = table | eval e = isblank(a) | fields e`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one', a = 2, 'two', a = 3, 'three', a = 4, 'four', a = 5, 'five', a = 6, 'six', a = 7, 'se7en', a = 8, 'eight', a = 9, 'nine')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else 'unknown')`
+ `source = table | eval f = case(a = 0, 'zero', a = 1, 'one' else concat(a, ' is an incorrect binary digit'))`
+ `source = table | eval digest = md5(fieldName) | fields digest`
+ `source = table | eval digest = sha1(fieldName) | fields digest`
+ `source = table | eval digest = sha2(fieldName,256) | fields digest`
+ `source = table | eval digest = sha2(fieldName,512) | fields digest`
#### comando fillnull
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
**Description**
Utilizzate il `fillnull` comando per sostituire i valori nulli con un valore specificato in uno o più campi dei risultati della ricerca.
**Sintassi**
Utilizzare la seguente sintassi:
```
fillnull [with in ["," ]] | [using = ["," = ]]
```
+ null-replacement: obbligatorio. Il valore usato per sostituire i valori nulli.
+ nullable-field: obbligatorio. Riferimento al campo. I valori nulli in questo campo verranno sostituiti con il valore specificato in null-replacement.
**Esempio 1: Riempi un campo**
L'esempio mostra come utilizzare fillnull su un singolo campo:
```
os> source=logs | fields status_code | eval input=status_code | fillnull with 0 in status_code;
| input | status_code |
|-------|-------------|
| 403 | 403 |
| 403 | 403 |
| NULL | 0 |
| NULL | 0 |
| 200 | 200 |
| 404 | 404 |
| 500 | 500 |
| NULL | 0 |
| 500 | 500 |
| 404 | 404 |
| 200 | 200 |
| 500 | 500 |
| NULL | 0 |
| NULL | 0 |
| 404 | 404 |
```
**Esempio 2: Fillnull applicato a più campi**
L'esempio mostra fillnull applicato a più campi.
```
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 |
```
**Esempio 3: Fillnull applicato a più campi con vari valori sostitutivi nulli.**
L'esempio mostra fillnull con vari valori usati per sostituire i valori null.
+ `/error`nel `request_path` campo
+ `1970-01-01 00:00:00`in `timestamp` campo
```
os> source=logs | fields request_path, timestamp | eval input_request_path=request_path, input_timestamp = timestamp | fillnull using request_path = '/error', timestamp='1970-01-01 00:00:00';
| input_request_path | input_timestamp | request_path | timestamp |
|------------------------------------------------------------------------------------|
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| /home | NULL | /home | 1970-01-01 00:00:00 |
| /about | 2023-10-01 10:30:00 | /about | 2023-10-01 10:30:00 |
| /home | 2023-10-01 10:15:00 | /home | 2023-10-01 10:15:00 |
| NULL | 2023-10-01 10:20:00 | /error | 2023-10-01 10:20:00 |
| NULL | 2023-10-01 11:05:00 | /error | 2023-10-01 11:05:00 |
| /about | NULL | /about | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:00:00 | /home | 2023-10-01 10:00:00 |
| /contact | NULL | /contact | 1970-01-01 00:00:00 |
| NULL | 2023-10-01 10:05:00 | /error | 2023-10-01 10:05:00 |
| NULL | 2023-10-01 10:50:00 | /error | 2023-10-01 10:50:00 |
| /services | NULL | /services | 1970-01-01 00:00:00 |
| /home | 2023-10-01 10:45:00 | /home | 2023-10-01 10:45:00 |
| /services | 2023-10-01 11:00:00 | /services | 2023-10-01 11:00:00 |
| NULL | 2023-10-01 10:35:00 | /error | 2023-10-01 10:35:00 |
```
#### comando fields
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `fields` comando per mantenere o rimuovere campi dal risultato della ricerca.
**Sintassi**
Utilizzare la seguente sintassi:
```
field [+|-]
```
+ `index`: facoltativo.
Se si utilizza il segno più (\+), verranno conservati solo i campi specificati nell'elenco dei campi.
Se si utilizza il segno meno (-), tutti i campi specificati nell'elenco dei campi verranno rimossi.
*Impostazione predefinita*: \+
+ `field list`: Obbligatorio. Un elenco di campi delimitati da virgole da conservare o rimuovere.
**Esempio 1: Seleziona i campi specificati dal risultato**
Questo esempio mostra come recuperare `account_number` `lastname` i campi e dai risultati di ricerca. `firstname`
Interrogazione 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 |
+------------------+-------------+------------+
```
**Esempio 2: rimuovere i campi specificati dal risultato**
Questo esempio mostra come rimuovere il `account_number` campo dai risultati di ricerca.
Interrogazione 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 |
+-------------+------------+
```
**Esempi aggiuntivi**
+ `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`
Esempio di campi annidati:
```
`source = catalog.schema.table1, catalog.schema.table2 | fields A.nested1, B.nested1`
`source = catalog.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
`source = catalog.schema.table | where struct_col2.field1.subfield > 'valueA' | sort int_col | fields int_col, struct_col.field1.subfield, struct_col2.field1.subfield`
```
#### comando flatten
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il comando flatten per espandere i campi dei seguenti tipi:
+ `struct`
+ `array>`
**Sintassi**
Utilizzare la seguente sintassi:
```
flatten
```
+ *field*: Il campo da appiattire. Il campo deve essere del tipo supportato.
**Schema**
| nome\_col | data\_type |
| --- | --- |
| \_ora | stringa |
| ponti | matrice |
| città | stringa |
| colore | struttura |
| paese | stringa |
**Dati**
| \_tempo | ponti | città | colore | paese |
| --- | --- | --- | --- | --- |
| 2024-09-13H 12:00:00 | [{801, Tower Bridge}, {928, Ponte di Londra}] | Londra | {35, 51,5074, -0,1278} | Inghilterra |
| 2024-09-13H 12:00:00 | [{232, Pont Neuf}, {160, Ponte Alessandro III}] | Parigi | {35, 48,8566, 2,3522} | Francia |
| 2024-09-13H 12:00:00 | [{48, Ponte di Rialto}, {11, Ponte dei Sospiri}] | Venezia | {2, 45.408, 12.315} | Italia |
| 2024-09-13H 12:00:00 | [{\*\*\*, Ponte Carlo}, {343, Ponte della Legione}] | Praga | {200, 50.0755, 14.4378} | Repubblica Ceca |
| 2024-09-13H 12:00:00 | [{375, Ponte delle Catene}, {333, Ponte della Libertà}] | Budapest | {96, 47,4979, 19.0402} | Ungheria |
| 1990-09-13H 12:00:00 | NULL | Varsavia | NULL | Polonia |
**Esempio 1: appiattire la struttura**
Questo esempio mostra come appiattire un campo struct.
Interrogazione PPL:
```
source=table | flatten coor
```
| \_ora | ponti | città | paese | alt | Lat | Long |
| --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13H 12:00:00 | [{801, Tower Bridge}, {928, Ponte di Londra}] | Londra | Inghilterra | 35 | 51,5074 | -0,1278 |
| 2024-09-13H 12:00:00 | [{232, Pont Neuf}, {160, Ponte Alessandro III}] | Parigi | Francia | 35 | 48,8566 | 2,3522 |
| 2024-09-13H 12:00:00 | [{48, Ponte di Rialto}, {11, Ponte dei Sospiri}] | Venezia | Italia | 2 | 45.408 | 12,3155 |
| 2024-09-13H 12:00:00 | [{516, Ponte Carlo}, {343, Ponte della Legione}] | Praga | Repubblica Ceca | 200 | 50.0755 | 14,4378 |
| 2024-09-13H 12:00:00 | [{375, Ponte delle Catene}, {333, Ponte della Libertà}] | Budapest | Ungheria | 96 | 47,4979 | 19,0402 |
| 1990-09-13H 12:00:00 | NULL | Varsavia | Polonia | NULL | NULL | NULL |
**Esempio 2: flatten array**
L'esempio mostra come appiattire una matrice di campi struct.
Interrogazione PPL:
```
source=table | flatten bridges
```
| \_ora | città | colore | paese | length | nome |
| --- | --- | --- | --- | --- | --- |
| 2024-09-13H 12:00:00 | Londra | {35, 51,5074, -0,1278} | Inghilterra | 801 | Tower Bridge |
| 2024-09-13H 12:00:00 | Londra | {35, 51,5074, -0,1278} | Inghilterra | 928 | Ponte di Londra |
| 2024-09-13H 12:00:00 | Parigi | {35, 48,8566, 2,3522} | Francia | 232 | Pont-Neuf |
| 2024-09-13H 12:00:00 | Parigi | {35, 48,8566, 2,3522} | Francia | 160 | Ponte Alessandro III |
| 2024-09-13H 12:00:00 | Venezia | {2, 45.408, 12.315} | Italia | 48 | Ponte di Rialto |
| 2024-09-13H 12:00:00 | Venezia | {2, 45.408, 12.315} | Italia | 11 | Ponte dei Sospiri |
| 2024-09-13H 12:00:00 | Praga | {200, 50.0755, 14.4378} | Repubblica Ceca | 516 | Ponte Carlo |
| 2024-09-13H 12:00:00 | Praga | {200, 50.0755, 14.4378} | Repubblica Ceca | 343 | Ponte della Legione |
| 2024-09-13H 12:00:00 | Budapest | {96, 47,4979, 19.0402} | Ungheria | 375 | Ponte delle Catene |
| 2024-09-13H 12:00:00 | Budapest | {96, 47,4979, 19.0402} | Ungheria | 333 | Ponte della Libertà |
| 1990-09-13H 12:00:00 | Varsavia | NULL | Polonia | NULL | NULL |
**Esempio 3: appiattire l'array e la struttura**
Questo esempio mostra come appiattire più campi.
Interrogazione PPL:
```
source=table | flatten bridges | flatten coor
```
| \_ora | città | paese | length | nome | alt | Lat | Long |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 2024-09-13H 12:00:00 | Londra | Inghilterra | 801 | Tower Bridge | 35 | 51,5074 | -0,1278 |
| 2024-09-13H 12:00:00 | Londra | Inghilterra | 928 | Ponte di Londra | 35 | 51,5074 | -0,1278 |
| 2024-09-13H 12:00:00 | Parigi | Francia | 232 | Pont-Neuf | 35 | 48,8566 | 2,3522 |
| 2024-09-13H 12:00:00 | Parigi | Francia | 160 | Ponte Alessandro III | 35 | 48,8566 | 2,3522 |
| 2024-09-13H 12:00:00 | Venezia | Italia | 48 | Ponte di Rialto | 2 | 45,408 | 12,3155 |
| 2024-09-13H 12:00:00 | Venezia | Italia | 11 | Ponte dei Sospiri | 2 | 45.408 | 12,3155 |
| 2024-09-13H 12:00:00 | Praga | Repubblica Ceca | 516 | Ponte Carlo | 200 | 50,0755 | 14,4378 |
| 2024-09-13H 12:00:00 | Praga | Repubblica Ceca | 343 | Ponte della Legione | 200 | 50.0755 | 14,4378 |
| 2024-09-13H 12:00:00 | Budapest | Ungheria | 375 | Ponte delle Catene | 96 | 47,4979 | 19,0402 |
| 2024-09-13H 12:00:00 | Budapest | Ungheria | 333 | Ponte della Libertà | 96 | 47,4979 | 19,0402 |
| 1990-09-13H 12:00:00 | Varsavia | Polonia | NULL | NULL | NULL | NULL | NULL |
#### comando grok
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Il `grok` comando analizza un campo di testo con uno schema grok e aggiunge i risultati al risultato della ricerca.
**Sintassi**
Utilizzare la seguente sintassi:
```
grok
```
**field**
+ Obbligatorio.
+ Il campo deve essere un campo di testo.
**pattern**
+ Obbligatorio.
+ Il modello grok usato per estrarre nuovi campi dal campo di testo specificato.
+ Se esiste già un nuovo nome di campo, sostituirà il campo originale.
**Pattern grok**
Il pattern grok viene utilizzato per abbinare il campo di testo di ogni documento per estrarre nuovi campi.
**Esempio 1: creare il nuovo campo**
Questo esempio mostra come creare un nuovo campo `host` per ogni documento. `host`sarà il nome host dopo `@` nel `email` campo. L'analisi di un campo nullo restituirà una stringa vuota.
```
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 |
+-------------------------+-------------+
```
**Esempio 2: sovrascrivi il campo esistente**
Questo esempio mostra come sostituire il `address` campo esistente con il numero civico rimosso.
```
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 |
+------------------+
```
**Esempio 3: Usare grok per analizzare i log**
Questo esempio mostra come usare grok per analizzare i log non elaborati.
```
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 |
+-----------------------------------------------------------------------------------------------------------------------------+----------------------------+------------+---------+
```
**Limitazioni**
Il comando grok presenta le stesse limitazioni del comando parse.
#### comando head
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `head` comando per restituire il primo numero N di risultati specificati dopo un offset opzionale nell'ordine di ricerca.
**Sintassi**
Utilizzare la seguente sintassi:
```
head [] [from ]
```
****
+ Numero intero opzionale.
+ Il numero di risultati da restituire.
+ Impostazione predefinita: 10
****
+ Numero intero dopo facoltativo`from`.
+ Il numero di risultati da saltare.
+ Impostazione predefinita: 0
**Esempio 1: ottieni i primi 10 risultati**
Questo esempio mostra come recuperare un massimo di 10 risultati dall'indice dei conti.
Interrogazione PPL:
```
os> source=accounts | fields firstname, age | head;
fetched rows / total rows = 4/4
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
**Esempio 2: ottieni i primi N risultati**
L'esempio mostra i primi N risultati dell'indice dei conti.
Interrogazione PPL:
```
os> source=accounts | fields firstname, age | head 3;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| Jane | 32 |
| John | 36 |
| Jorge | 28 |
+-------------+-------+
```
**Esempio 3: ottieni i primi N risultati dopo l'offset M**
Questo esempio mostra come recuperare i primi N risultati dopo aver saltato M risultati dall'indice dei conti.
Interrogazione PPL:
```
os> source=accounts | fields firstname, age | head 3 from 1;
fetched rows / total rows = 3/3
+-------------+-------+
| firstname | age |
|-------------+-------|
| John | 36 |
| Jorge | 28 |
| Juan | 33 |
+-------------+-------+
```
#### comando join
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Il comando join consente di combinare dati provenienti da più fonti in base a campi comuni, consentendoti di eseguire analisi complesse e ottenere informazioni più approfondite dai set di dati distribuiti
**Schema**
Esistono almeno due indici, `otel-v1-apm-span-*` (grande) e `otel-v1-apm-service-map` (piccolo).
Campi pertinenti degli indici:
**`otel-v1-apm-span-*`**
+ TraceID: un identificatore univoco per una traccia. Tutti gli intervalli della stessa traccia condividono lo stesso traceID.
+ spanID: un identificatore univoco per uno spazio all'interno di una traccia, assegnato al momento della creazione dello span.
+ parentSpanId - Lo spanID dello span principale di questo spazio. Se si tratta di uno span principale, questo campo deve essere vuoto.
+ durationInNanos - La differenza in nanosecondi tra StartTime ed EndTime. (questo è nell'interfaccia utente) `latency`
+ Servicename: la risorsa da cui proviene lo span.
+ TraceGroup: il nome dell'estensione principale della traccia.
**`otel-v1-apm-service-map`**
+ ServiceName - Il nome del servizio che ha emesso lo span.
+ destination.domain - Il ServiceName del servizio chiamato da questo client.
+ destination.resource - Lo span name (API, operation e così via) chiamato da questo client.
+ target.domain - Il ServiceName del servizio chiamato da un client.
+ target.resource - Lo span name (API, operation e così via) chiamato da un client.
+ traceGroupName - Lo span name di primo livello che ha avviato la catena di richieste.
**Requisito**
Support **join** per il calcolo di quanto segue:
Per ogni servizio, unisci span index all'indice della mappa dei servizi per calcolare le metriche in base a diversi tipi di filtri.
Questa query di esempio calcola la latenza quando viene filtrata per gruppo di traccia per il servizio. `client_cancel_order` `order`
```
SELECT avg(durationInNanos)
FROM `otel-v1-apm-span-000001` t1
WHERE t1.serviceName = `order`
AND ((t1.name in
(SELECT target.resource
FROM `otel-v1-apm-service-map`
WHERE serviceName = `order`
AND traceGroupName = `client_cancel_order`)
AND t1.parentSpanId != NULL)
OR (t1.parentSpanId = NULL
AND t1.name = `client_cancel_order`))
AND t1.traceId in
(SELECT traceId
FROM `otel-v1-apm-span-000001`
WHERE serviceName = `order`)
```
**Esegui la migrazione a PPL**
Sintassi del comando join
```
SEARCH source=
|
| [joinType] JOIN
[leftAlias]
ON joinCriteria
|
```
**Riscrittura**
```
SEARCH source=otel-v1-apm-span-000001
| WHERE serviceName = 'order'
| JOIN left=t1 right=t2
ON t1.traceId = t2.traceId AND t2.serviceName = 'order'
otel-v1-apm-span-000001 -- self inner join
| EVAL s_name = t1.name -- rename to avoid ambiguous
| EVAL s_parentSpanId = t1.parentSpanId -- RENAME command would be better when it is supported
| EVAL s_durationInNanos = t1.durationInNanos
| FIELDS s_name, s_parentSpanId, s_durationInNanos -- reduce colunms in join
| LEFT JOIN left=s1 right=t3
ON s_name = t3.target.resource AND t3.serviceName = 'order' AND t3.traceGroupName = 'client_cancel_order'
otel-v1-apm-service-map
| WHERE (s_parentSpanId IS NOT NULL OR (s_parentSpanId IS NULL AND s_name = 'client_cancel_order'))
| STATS avg(s_durationInNanos) -- no need to add alias if there is no ambiguous
```
**Tipo di giunto**
+ Sintassi: `INNER | LEFT OUTER | CROSS`
+ Facoltativo
+ Il tipo di join da eseguire. L'impostazione predefinita è `INNER` se non è specificata.
**Alias sinistro**
+ Sintassi: `left = `
+ Facoltativo
+ L'alias della subquery da usare con il lato sinistro del join, per evitare denominazioni ambigue.
**JoinCriteria**
+ Sintassi: ``
+ Richiesto
+ La sintassi inizia con. `ON` Potrebbe essere qualsiasi espressione di confronto. In genere, i criteri di unione sono i seguenti`.=.`.
Ad esempio: `l.id = r.id`. Se i criteri di unione contengono più condizioni, è possibile specificare `AND` un `OR` operatore tra ogni espressione di confronto. Ad esempio, `l.id = r.id AND l.email = r.email AND (r.age > 65 OR r.age < 18)`.
**Altri esempi**
Migrazione da una query 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;
```
Riscritto dalla join query 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
```
Limitazione: le ricerche secondarie non sono supportate nella parte destra di join.
Se le ricerche secondarie sono supportate, è possibile riscrivere la precedente query PPL come segue:
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN
ON c_custkey = o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS count(o_orderkey) AS c_count BY c_custkey
| STATS count() AS custdist BY c_count
| SORT - custdist, - c_count
```
#### comando lookup
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `lookup` comando per arricchire i dati di ricerca aggiungendo o sostituendo i dati da un indice di ricerca (tabella delle dimensioni). Questo comando consente di estendere i campi di un indice con i valori di una tabella delle dimensioni. È inoltre possibile utilizzarlo per aggiungere o sostituire valori quando vengono soddisfatte le condizioni di ricerca. Il `lookup` comando è più adatto del `Join` comando per arricchire i dati di origine con un set di dati statico.
**Sintassi**
Utilizzare la seguente sintassi:
```
SEARCH source=
|
| LOOKUP ( [AS ])...
[(REPLACE | APPEND) ( [AS ])...]
|
```
**Indice di ricerca**
+ Obbligatorio.
+ Il nome dell'indice di ricerca (tabella delle dimensioni).
**lookupMappingField**
+ Obbligatorio.
+ Una chiave di mappatura nell'indice di ricerca, analoga a una chiave di join della tabella destra. È possibile specificare più campi, separati da virgole.
**sourceMappingField**
+ Opzionale.
+ Impostazione predefinita: < lookupMappingField >.
+ Una chiave di mappatura dalla query di origine, analoga a una chiave di unione dal lato sinistro.
**Campo di input**
+ Opzionale.
+ Predefinito: tutti i campi dell'indice di ricerca in cui vengono trovati i valori corrispondenti.
+ Un campo dell'indice di ricerca in cui i valori corrispondenti vengono applicati all'output dei risultati. È possibile specificare più campi, separati da virgole.
**Campo di output**
+ Opzionale.
+ Default: ``.
+ Un campo nell'output. È possibile specificare più campi di output. Se si specifica un nome di campo esistente dalla query di origine, i relativi valori verranno sostituiti o aggiunti dai valori corrispondenti di InputField. Se si specifica un nuovo nome di campo, questo verrà aggiunto ai risultati.
**SOSTITUISCI \| AGGIUNGI**
+ Opzionale.
+ Predefinito: REPLACE
+ Specifica come gestire i valori corrispondenti. Se si specifica REPLACE, i valori corrispondenti nel campo sovrascrivono i valori nel risultato. Se si specifica`APPEND`, i valori corrispondenti nel campo vengono aggiunti solo ai valori mancanti nel risultato.
**Utilizzo**
+ LOOKUP id AS cid SOSTITUISCI mail AS email
+ NOME CERCA SOSTITUISCI mail COME email
+ ID LOOKUP AS cid, nome AGGIUNGI indirizzo, mail COME email
+ ID LOOKUP
**Esempio**
Fare riferimento agli esempi riportati di seguito.
```
SEARCH source=
| WHERE orderType = 'Cancelled'
| LOOKUP account_list, mkt_id AS mkt_code REPLACE amount, account_name AS name
| STATS count(mkt_code), avg(amount) BY name
```
```
SEARCH source=
| DEDUP market_id
| EVAL category=replace(category, "-", ".")
| EVAL category=ltrim(category, "dvp.")
| LOOKUP bounce_category category AS category APPEND classification
```
```
SEARCH source=
| LOOKUP bounce_category category
```
#### comando parse
Il `parse` comando analizza un campo di testo con un'espressione regolare e aggiunge il risultato al risultato della ricerca.
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
**Sintassi**
Utilizzare la seguente sintassi:
```
parse
```
**`field`**
+ Obbligatorio.
+ Il campo deve essere un campo di testo.
**`pattern`**
+ Stringa obbligatoria.
+ Questo è il modello di espressione regolare usato per estrarre nuovi campi dal campo di testo specificato.
+ Se esiste già un nuovo nome di campo, sostituirà il campo originale.
**Espressione regolare**
Il modello di espressione regolare viene utilizzato per abbinare l'intero campo di testo di ogni documento con il motore regex Java. Ogni gruppo di acquisizione denominato nell'espressione diventerà un nuovo `STRING` campo.
**Esempio 1: creare un nuovo campo**
L'esempio mostra come creare un nuovo campo `host` per ogni documento. `host`sarà il nome host dopo `@` nel `email` campo. L'analisi di un campo nullo restituirà una stringa vuota.
Interrogazione 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 |
+-----------------------+-------------+
```
**Esempio 2: sovrascrivere un campo esistente**
L'esempio mostra come sostituire il `address` campo esistente con il numero civico rimosso.
Interrogazione PPL:
```
os> source=accounts | parse address '\d+ (?.+)' | fields address ;
fetched rows / total rows = 4/4
+------------------+
| address |
|------------------|
| Example Lane |
| Example Street |
| Example Avenue |
| Example Court |
+------------------+
```
**Esempio 3: filtra e ordina per campo analizzato**
L'esempio mostra come ordinare i numeri civici che sono superiori a 500 nel `address` campo.
Interrogazione 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 |
+----------------+----------------+
```
**Limitazioni**
Esistono alcune limitazioni con il comando parse:
+ I campi definiti da parse non possono essere analizzati nuovamente.
Il seguente comando non funzionerà:
```
source=accounts | parse address '\d+ (?.+)' | parse street '\w+ (?\w+)'
```
+ I campi definiti da parse non possono essere sovrascritti con altri comandi.
`where`non corrisponderà a nessun documento poiché non `street` può essere sovrascritto:
```
source=accounts | parse address '\d+ (?.+)' | eval street='1' | where street='1' ;
```
+ Il campo di testo utilizzato da parse non può essere sovrascritto.
`street`non verrà analizzato correttamente poiché è stato sovrascritto: `address`
```
source=accounts | parse address '\d+ (?.+)' | eval address='1' ;
```
+ I campi definiti da parse non possono essere filtrati o ordinati dopo averli utilizzati nel comando. `stats`
`where`nel seguente comando non funzionerà:
```
source=accounts | parse email '.+@(?.+)' | stats avg(age) by host | where host=pyrami.com ;
```
#### comando patterns
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Il `patterns` comando estrae i modelli di registro da un campo di testo e aggiunge i risultati al risultato della ricerca. Il raggruppamento dei log in base ai relativi schemi semplifica l'aggregazione delle statistiche provenienti da grandi volumi di dati di registro per l'analisi e la risoluzione dei problemi.
**Sintassi**
Utilizzare la seguente sintassi:
```
patterns [new_field=] [pattern=]
```
**new-field-name**
+ Stringa opzionale.
+ Questo è il nome del nuovo campo per i modelli estratti.
+ Il valore predefinito è `patterns_field`.
+ Se il nome esiste già, sostituirà il campo originale.
**pattern**
+ Stringa opzionale.
+ Questo è lo schema regex dei caratteri che devono essere filtrati dal campo di testo.
+ Se assente, lo schema predefinito è costituito da caratteri alfanumerici (). `[a-zA-Z\d]`
**field**
+ Obbligatorio.
+ Il campo deve essere un campo di testo.
**Esempio 1: creare il nuovo campo**
L'esempio mostra come utilizzare l'estrazione della punteggiatura `email` per ogni documento. L'analisi di un campo nullo restituirà una stringa vuota.
Interrogazione 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 | @. |
+-----------------------+------------------+
```
**Esempio 2: Estrarre i modelli di registro**
L'esempio mostra come estrarre la punteggiatura da un campo di log non elaborato utilizzando i modelli predefiniti.
Interrogazione 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 | ... - - [//::: -] " / /." |
+-----------------------------------------------------------------------------------------------------------------------------+---------------------------------+
```
**Esempio 3: Estrai modelli di log con un modello regex personalizzato**
L'esempio mostra come estrarre la punteggiatura da un campo di log non elaborato utilizzando modelli definiti dall'utente.
Interrogazione 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/." |
+-----------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------+
```
**Limitazione**
Il comando patterns presenta le stesse limitazioni del comando parse.
#### comando raro
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `rare` comando per trovare la tupla di valori meno comune di tutti i campi nell'elenco dei campi.
**Nota**
Vengono restituiti un massimo di 10 risultati per ogni distinta tupla di valori dei campi raggruppati per.
**Sintassi**
Utilizzare la seguente sintassi:
```
rare [N] [by-clause] rare_approx [N] [by-clause]
```
**elenco di campi**
+ Obbligatorio.
+ Un elenco di nomi di campo delimitato da virgole.
**clausola secondaria**
+ Opzionale.
+ Uno o più campi in base ai quali raggruppare i risultati.
**N**
+ Il numero di risultati da restituire.
+ Impostazione predefinita: 10
**rare\_approx**
+ Il conteggio approssimativo dei campi rari (n) utilizzando la [cardinalità](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html) stimata mediante l'algoritmo \+\+. HyperLogLog
**Esempio 1: trova i valori meno comuni in un campo**
L'esempio trova il sesso meno comune tra tutti gli account.
Interrogazione 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 |
+----------+
```
**Esempio 2: trova i valori meno comuni organizzati per genere**
L'esempio trova l'età minima comune di tutti gli account raggruppati per genere.
Interrogazione PPL:
```
os> source=accounts | rare 5 age by gender;
os> source=accounts | rare_approx 5 age by gender;
fetched rows / total rows = 4/4
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
| M | 33 |
| M | 36 |
+----------+-------+
```
#### comando di ridenominazione
Usa il `rename` comando per modificare i nomi di uno o più campi nel risultato della ricerca.
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
**Sintassi**
Utilizzare la seguente sintassi:
```
rename AS ["," AS ]...
```
**campo sorgente**
+ Obbligatorio.
+ Questo è il nome del campo che vuoi rinominare.
**campo-destinazione**
+ Obbligatorio.
+ Questo è il nome con cui vuoi rinominare.
**Esempio 1: Rinomina un campo**
Questo esempio mostra come rinominare un singolo campo.
Interrogazione PPL:
```
os> source=accounts | rename account_number as an | fields an;
fetched rows / total rows = 4/4
+------+
| an |
|------|
| 1 |
| 6 |
| 13 |
| 18 |
+------+
```
**Esempio 2: rinominare più campi**
Questo esempio mostra come rinominare più campi.
Interrogazione 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 |
+------+---------+
```
**Limitazioni**
+ La sovrascrittura del campo esistente non è supportata:
```
source=accounts | grok address '%{NUMBER} %{GREEDYDATA:address}' | fields address
```
#### comando di ricerca
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `search` comando per recuperare i documenti da un indice. Il `search` comando può essere utilizzato solo come primo comando in una query PPL.
**Sintassi**
Utilizzare la seguente sintassi:
```
search source=[:] [boolean-expression]
```
**cerca**
+ Opzionale.
+ Parole chiave di ricerca, che possono essere omesse.
**indice**
+ Obbligatorio.
+ Il comando search deve specificare da quale indice eseguire la ricerca.
+ Il nome dell'indice può essere preceduto da `:` per le ricerche tra cluster.
**espressione bool**
+ Opzionale.
+ Qualsiasi espressione che restituisce un valore booleano.
**Esempio 1: recupera tutti i dati**
L'esempio mostra il recupero di tutto il documento dall'indice degli account.
Interrogazione 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 |
+------------------+-------------+----------------------+-----------+----------+--------+----------------+---------+-------+-----------------------+------------+
```
**Esempio 2: recupera dati con condizione**
L'esempio mostra recuperare tutto il documento dall'indice degli account con.
Interrogazione PPL:
```
os> SEARCH source=accounts account_number=1 or gender="F";
+------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------+
| account_number | firstname | address | balance | gender | city | employer | state | age | email - | lastname |
|------------------+-------------+--------------------+-----------+----------+--------+----------------+---------+-------+-------------------------+------------|
| 1 | Jorge | *** Any Lane | ***** | M | Brogan | ExampleCorp | IL | 32 | jorge_souza@example.com | Souza |
| 13 | Jane | *** Any Street | ***** | F | Nogal | ExampleCompany | VA | 28 | null | Doe |
+------------------+-------------+--------------------+-----------+----------+--------+-----------------+---------+-------+------------------------+------------+
```
#### comando sort
Usa il `sort` comando per ordinare i risultati della ricerca in base ai campi specificati.
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
**Sintassi**
Utilizzare la seguente sintassi:
```
sort <[+|-] sort-field>...
```
**[\+\|-]**
+ Opzionale.
+ Il segno più [\+] indica l'ordine crescente con NULL/MISSING i valori al primo posto.
+ Il segno meno [-] indica l'ordine decrescente con NULL/MISSING i valori per ultimi.
+ Predefinito: ordine crescente con NULL/MISSING i valori per primi.
**campo di ordinamento**
+ Obbligatorio.
+ Il campo utilizzato per l'ordinamento.
**Esempio 1: ordina per un campo**
L'esempio mostra come ordinare il documento con il campo dell'età in ordine crescente.
Interrogazione 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 |
+------------------+-------+
```
**Esempio 2: ordina per un campo e restituisci tutti i risultati**
L'esempio mostra come ordinare il documento con il campo età in ordine crescente.
Interrogazione 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 |
+------------------+-------+
```
**Esempio 3: ordina per un campo in ordine decrescente**
L'esempio mostra come ordinare il documento con il campo età in ordine decrescente.
Interrogazione 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 |
+------------------+-------+
```
**Esempio 4: ordina per più campi**
L'esempio mostra come ordinare il documento con il campo genere in ordine crescente e il campo età in ordine decrescente.
Interrogazione 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 |
+------------------+----------+-------+
```
**Esempio 5: Ordina per campo e include un valore nullo**
L'esempio mostra come ordinare il campo del datore di lavoro in base all'opzione predefinita (ordine crescente e prima null). Il risultato mostra che il valore nullo è nella prima riga.
Interrogazione PPL:
```
os> source=accounts | sort employer | fields employer;
fetched rows / total rows = 4/4
+------------+
| employer |
|------------|
| null |
| AnyCompany |
| AnyCorp |
| AnyOrgty |
+------------+
```
#### comando stats
Usa il `stats` comando per calcolare l'aggregazione dai risultati della ricerca.
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
**Gestione dei valori NULL/MANCANTI**
**Gestione dei valori NULL/MANCANTI**
| Funzione | NULL | MANCANTE |
| --- | --- | --- |
| COUNT | Non contato | Non contato |
| SUM | Ignorare | Ignorare |
| AVG | Ignorare | Ignorare |
| MAX | Ignorare | Ignorare |
| MIN | Ignorare | Ignorare |
**Sintassi**
Utilizzare la seguente sintassi:
```
stats ... [by-clause]
```
**Aggregazione**
+ Obbligatorio.
+ Una funzione di aggregazione applicata a un campo.
**clausola secondaria**
+ Opzionale.
+ Sintassi: `by [span-expression,] [field,]...`
+ Specifica i campi e le espressioni per il raggruppamento dei risultati dell'aggregazione. La by-clausola consente di raggruppare i risultati dell'aggregazione utilizzando campi ed espressioni. È possibile utilizzare funzioni scalari, funzioni di aggregazione e persino espressioni span per dividere campi specifici in bucket di intervalli uguali.
+ Predefinito: se `` viene specificato no, il comando stats restituisce una singola riga che rappresenta l'aggregazione sull'intero set di risultati.
**espressione spanx**
+ Facoltativo, al massimo uno.
+ Sintassi: `span(field_expr, interval_expr)`
+ L'unità dell'espressione dell'intervallo è l'unità naturale di default. Se il campo è di tipo data e ora e l'intervallo è espresso in date/time unità, è necessario specificare l'unità nell'espressione dell'intervallo.
+ Ad esempio, suddividendo il `age` campo in secchi per 10 anni, sembra. `span(age, 10)` Per dividere un campo timestamp in intervalli orari, usa. `span(timestamp, 1h)`
**Unità di tempo disponibili**
| Unità di intervallo di ampiezza |
| --- |
| millisecondo (ms) |
| secondo/i |
| minuto (m, distinzione tra maiuscole e minuscole) |
| ora (h) |
| giorno (d) |
| settimana (e) |
| mese (M, distinzione tra maiuscole e minuscole) |
| trimestre (q) |
| anno (y) |
**Funzioni di aggregazione**
**`COUNT`**
Restituisce un conteggio del numero di espr nelle righe recuperate da un'istruzione SELECT.
Esempio:
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**`SUM`**
Si usa `SUM(expr)` per restituire la somma di expr.
Esempio
```
os> source=accounts | stats sum(age) by gender;
fetched rows / total rows = 2/2
+------------+----------+
| sum(age) | gender |
|------------+----------|
| 28 | F |
| 101 | M |
+------------+----------+
```
**`AVG`**
Usa `AVG(expr)` per restituire il valore medio di expr.
Esempio
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**`MAX`**
Usa `MAX(expr)` per restituire il valore massimo di expr.
Esempio
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**`MIN`**
Usa `MIN(expr)` per restituire il valore minimo di expr.
Esempio
```
os> source=accounts | stats min(age);
fetched rows / total rows = 1/1
+------------+
| min(age) |
|------------|
| 28 |
+------------+
```
**`STDDEV_SAMP`**
Si usa `STDDEV_SAMP(expr)` per restituire la deviazione standard campionaria di expr.
Esempio:
```
os> source=accounts | stats stddev_samp(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_samp(age) |
|--------------------|
| 3.304037933599835 |
+--------------------+
```
**STDDEV\_POP**
Utilizzare `STDDEV_POP(expr)` per restituire la deviazione standard della popolazione di expr.
Esempio:
```
os> source=accounts | stats stddev_pop(age);
fetched rows / total rows = 1/1
+--------------------+
| stddev_pop(age) |
|--------------------|
| 2.**************** |
+--------------------+
```
**AFFERRARE**
Si usa `TAKE(field [, size])` per restituire i valori originali di un campo. Non garantisce l'ordine dei valori.
**field**
+ Obbligatorio.
+ Il campo deve essere un campo di testo.
**formato**
+ Numero intero opzionale.
+ Il numero di valori deve essere restituito.
+ L'impostazione predefinita è 10.
**Esempio**
```
os> source=accounts | stats take(firstname);
fetched rows / total rows = 1/1
+-----------------------------+
| take(firstname) |
|-----------------------------|
| [Jane, Mary, Nikki, Juan |
+-----------------------------+
```
**PERCENTILE o PERCENTILE\_APPROX**
Usa `PERCENTILE(expr, percent)` o `PERCENTILE_APPROX(expr, percent)` per restituire il valore percentile approssimativo di expr alla percentuale specificata.
**percentuale**
+ Il numero deve essere una costante compresa tra 0 e 100.
**Esempio**
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Esempio 1: calcola il conteggio degli eventi**
L'esempio mostra come calcolare il conteggio degli eventi nei conti.
```
os> source=accounts | stats count();
fetched rows / total rows = 1/1
+-----------+
| count() |
|-----------|
| 4 |
+-----------+
```
**Esempio 2: calcola la media di un campo**
L'esempio mostra come calcolare l'età media per tutti gli account.
```
os> source=accounts | stats avg(age);
fetched rows / total rows = 1/1
+------------+
| avg(age) |
|------------|
| 32.25 |
+------------+
```
**Esempio 3: calcola la media di un campo per gruppo**
L'esempio mostra come calcolare l'età media per tutti gli account, raggruppati per sesso.
```
os> source=accounts | stats avg(age) by gender;
fetched rows / total rows = 2/2
+--------------------+----------+
| avg(age) | gender |
|--------------------+----------|
| 28.0 | F |
| 33.666666666666664 | M |
+--------------------+----------+
```
**Esempio 4: calcola la media, la somma e il conteggio di un campo per gruppo**
L'esempio mostra come calcolare l'età media, la somma dell'età e il conteggio degli eventi per tutti gli account, raggruppati per sesso.
```
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 |
+--------------------+------------+-----------+----------+
```
**Esempio 5: calcola il massimo di un campo**
L'esempio calcola l'età massima per tutti gli account.
```
os> source=accounts | stats max(age);
fetched rows / total rows = 1/1
+------------+
| max(age) |
|------------|
| 36 |
+------------+
```
**Esempio 6: calcola il massimo e il minimo di un campo per gruppo**
L'esempio calcola i valori di età massima e minima per tutti gli account, raggruppati per sesso.
```
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 |
+------------+------------+----------+
```
**Esempio 7: calcola il conteggio distinto di un campo**
Per ottenere il conteggio dei valori distinti di un campo, puoi usare la funzione `DISTINCT_COUNT` (or`DC`) invece di`COUNT`. L'esempio calcola sia il campo di conteggio che quello di conteggio distinto per genere di tutti gli account.
```
os> source=accounts | stats count(gender), distinct_count(gender);
fetched rows / total rows = 1/1
+-----------------+--------------------------+
| count(gender) | distinct_count(gender) |
|-----------------+--------------------------|
| 4 | 2 |
+-----------------+--------------------------+
```
**Esempio 8: calcola il conteggio in base a un intervallo**
L'esempio ottiene il conteggio dell'età per un intervallo di 10 anni.
```
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 |
+--------------+------------+
```
**Esempio 9: calcola il conteggio in base al sesso e all'intervallo**
Questo esempio conta i record raggruppati per sesso e intervalli di età di 5 anni.
```
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'espressione span appare sempre come prima chiave di raggruppamento, indipendentemente dall'ordine specificato nel comando.
```
os> source=accounts | stats count() as cnt by gender, span(age, 5) as age_span
fetched rows / total rows = 3/3
+-------+------------+----------+
| cnt | age_span | gender |
|-------+------------+----------|
| 1 | 25 | F |
| 2 | 30 | M |
| 1 | 35 | M |
+-------+------------+----------+
```
**Esempio 10: calcola il conteggio e ottieni l'elenco di e-mail in base al sesso e all'intervallo**
L'esempio ottiene il conteggio dell'età per l'intervallo di 10 anni e il gruppo per sesso, inoltre per ogni riga ottieni un elenco di al massimo 5 email.
```
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 |
+-------+----------------------------------------------------+------------+----------+
```
**Esempio 11: calcola il percentile di un campo**
L'esempio mostra come calcolare il percentile di 90° età di tutti gli account.
```
os> source=accounts | stats percentile(age, 90);
fetched rows / total rows = 1/1
+-----------------------+
| percentile(age, 90) |
|-----------------------|
| 36 |
+-----------------------+
```
**Esempio 12: calcola il percentile di un campo per gruppo**
L'esempio mostra come calcolare il percentile di 90° età di tutti i gruppi di account per sesso.
```
os> source=accounts | stats percentile(age, 90) by gender;
fetched rows / total rows = 2/2
+-----------------------+----------+
| percentile(age, 90) | gender |
|-----------------------+----------|
| 28 | F |
| 36 | M |
+-----------------------+----------+
```
**Esempio 13: calcola il percentile in base al sesso e all'intervallo**
L'esempio ottiene il percentile di 90° età per intervallo di 10 anni e il gruppo per sesso.
```
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)`
```
**Aggregazioni con span**
```
- `source = table | stats count(a) by span(a, 10) as a_span`
- `source = table | stats sum(age) by span(age, 5) as age_span | head 2`
- `source = table | stats avg(age) by span(age, 20) as age_span, country | sort - age_span | head 2`
```
**Aggregazioni con timewindow span (funzione tumble windowing)**
```
- `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`
```
**Le aggregazioni sono raggruppate per più livelli**
```
- `source = table | stats avg(age) as avg_state_age by country, state | stats avg(avg_state_age) as avg_country_age by country`
- `source = table | stats avg(age) as avg_city_age by country, state, city | eval new_avg_city_age = avg_city_age - 1 | stats avg(new_avg_city_age) as avg_state_age by country, state | where avg_state_age > 18 | stats avg(avg_state_age) as avg_adult_country_age by country`
```
#### comando subquery
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `subquery` comando per eseguire query complesse e annidate all'interno delle istruzioni PPL (Piped Processing Language).
```
source=logs | where field in [ subquery source=events | where condition | fields field ]
```
In questo esempio, la ricerca primaria (`source=logs`) viene filtrata in base ai risultati della subquery (). `source=events`
Il comando subquery supporta più livelli di annidamento per l'analisi di dati complessi.
**Esempio di subquery annidata**
```
source=logs | where id in [ subquery source=users | where user in [ subquery source=actions | where action="login" | fields user] | fields uid ]
```
**InSubquery Utilizzo**
+ `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 ]`(filtro di ricerca con sottoquery)
+ `source = outer a not in [ source = inner | fields b ]`(filtro di ricerca con subquery)
+ `source = outer | where a in [ source = inner1 | where b not in [ source = inner2 | fields c ] | fields b ]`(annidato)
+ `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`(come filtro di unione)
**Esempi di migrazione SQL con In-Subquery PPL**
TPC-H Q4 (nella subquery con aggregazione)
```
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
```
Riscritto da InSubquery una query PPL:
```
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 (annidato nella sottoquery)
```
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
```
Riscritto da una query 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 utilizzo**
Ipotesi:`a`, `b` sono campi della tabella esterna`c`, `d` sono campi della tabella interna`e`, `f` sono campi della tabella 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 ]`(filtro di ricerca con sottoquery)
+ `source = outer not exists [ source = inner | where a = c ]`(filtro di ricerca con subquery)
+ `source = table as t1 exists [ source = table as t2 | where t1.a = t2.a ]`(L'alias della tabella è utile nella sottoquery exists)
+ `source = outer | where exists [ source = inner1 | where a = c and exists [ source = inner2 | where c = e ] ]`(annidato)
+ `source = outer | where exists [ source = inner1 | where a = c | where exists [ source = inner2 | where c = e ] ]`(annidato)
+ `source = outer | where exists [ source = inner | where c > 10 ]`(esiste una correlazione non correlata)
+ `source = outer | where not exists [ source = inner | where c > 10 ]`(esiste una correlazione non correlata)
+ `source = outer | where exists [ source = inner ] | eval l = "nonEmpty" | fields l`(esistono elementi non correlati speciali)
**ScalarSubquery utilizzo**
Presupposti:`a`, `b` sono campi della tabella esterni`c`, `d` sono campi della tabella interna`e`, `f` sono campi della tabella annidati
**Sottoquery scalare non correlata**
In Seleziona:
+ `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`
In dove:
+ `source = outer | where a > [ source = inner | stats min(c) ] | fields a`
Nel filtro di ricerca:
+ `source = outer a > [ source = inner | stats min(c) ] | fields a`
**Sottoquery scalare correlata**
In Seleziona:
+ `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`
In dove:
+ `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`
Nel filtro di ricerca:
+ `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`
**Sottoquery scalare annidata**
+ `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 ]`
**(Relazione) Sottoquery**
`InSubquery`, `ExistsSubquery` e `ScalarSubquery` sono tutte espressioni di sottoquery. Ma non `RelationSubquery` è un'espressione di sottoquery, è un piano di sottoquery che è comunemente usato nella clausola Join o From.
+ `source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ]`(subquery nella parte destra di join)
+ `source = [ source = table1 | join left = l right = r [ source = table2 | where d > 10 | head 5 ] | stats count(a) by b ] as outer | head 1`
**Contesto aggiuntivo**
`InSubquery``ExistsSubquery`, e `ScalarSubquery` sono espressioni di sottoquery comunemente utilizzate nelle `where` clausole e nei filtri di ricerca.
Comando Where:
```
| where | ...
```
Filtro di ricerca:
```
search source=* | ...
```
Un'espressione di sottoquery può essere utilizzata in un'espressione booleana:
```
| where orders.order_id in [ source=returns | where return_reason="damaged" | field order_id ]
```
Il `orders.order_id in [ source=... ]` è un. ``
In generale, chiamiamo questo tipo di clausola di sottoquery espressione. `InSubquery` È un. ``
**Sottoquery con diversi tipi di join**
Esempio utilizzando un `ScalarSubquery`:
```
source=employees
| join source=sales on employees.employee_id = sales.employee_id
| where sales.sale_amount > [ source=targets | where target_met="true" | fields target_value ]
```
A differenza di InSubquery ExistsSubquery, e ScalarSubquery, a non RelationSubquery è un'espressione di sottoquery. Si tratta invece di un piano di subquery.
```
SEARCH source=customer
| FIELDS c_custkey
| LEFT OUTER JOIN left = c, right = o ON c.c_custkey = o.o_custkey
[
SEARCH source=orders
| WHERE o_comment NOT LIKE '%unusual%packages%'
| FIELDS o_orderkey, o_custkey
]
| STATS ...
```
#### comando top
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `top` comando per trovare la tupla di valori più comune di tutti i campi nell'elenco dei campi.
**Sintassi**
Utilizzare la seguente sintassi:
```
top [N] [by-clause] top_approx [N] [by-clause]
```
**N**
+ Il numero di risultati da restituire.
+ Impostazione predefinita: 10
**elenco di campi**
+ Obbligatorio.
+ Un elenco di nomi di campo delimitato da virgole.
**clausola secondaria**
+ Opzionale.
+ Uno o più campi in base ai quali raggruppare i risultati.
**top\_approx**
+ Un conteggio approssimativo dei campi (n) principali utilizzando la [cardinalità stimata mediante l'algoritmo \+\+](https://spark.apache.org/docs/latest/sql-ref-functions-builtin.html). HyperLogLog
**Esempio 1: trova i valori più comuni in un campo**
L'esempio trova il sesso più comune per tutti gli account.
Interrogazione PPL:
```
os> source=accounts | top gender;
os> source=accounts | top_approx gender;
fetched rows / total rows = 2/2
+----------+
| gender |
|----------|
| M |
| F |
+----------+
```
**Esempio 2: trova i valori più comuni in un campo (limitato a 1)**
L'esempio individua il genere singolo più comune per tutti gli account.
Interrogazione PPL:
```
os> source=accounts | top_approx 1 gender;
fetched rows / total rows = 1/1
+----------+
| gender |
|----------|
| M |
+----------+
```
**Esempio 3: trova i valori più comuni, raggruppati per genere**
L'esempio trova l'età più comune per tutti gli account, raggruppati per sesso.
Interrogazione PPL:
```
os> source=accounts | top 1 age by gender;
os> source=accounts | top_approx 1 age by gender;
fetched rows / total rows = 2/2
+----------+-------+
| gender | age |
|----------+-------|
| F | 28 |
| M | 32 |
+----------+-------+
```
#### comando trendline
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `trendline` comando per calcolare le medie mobili dei campi.
**Sintassi**
Utilizzate la seguente sintassi
```
TRENDLINE [sort <[+|-] sort-field>] SMA(number-of-datapoints, field) [AS alias] [SMA(number-of-datapoints, field) [AS alias]]...
```
**[\+\|-]**
+ Opzionale.
+ Il segno più [\+] indica l'ordine crescente con NULL/MISSING i valori al primo posto.
+ Il segno meno [-] indica l'ordine decrescente con NULL/MISSING i valori per ultimi.
+ Predefinito: ordine crescente con NULL/MISSING i valori per primi.
**campo di ordinamento**
+ Obbligatorio quando si utilizza l'ordinamento.
+ Il campo utilizzato per l'ordinamento.
**number-of-datapoints**
+ Obbligatorio.
+ Il numero di punti dati che calcolano la media mobile.
+ Deve essere maggiore di zero.
**field**
+ Obbligatorio.
+ Il nome del campo per cui deve essere calcolata la media mobile.
**alias**
+ Opzionale.
+ Il nome della colonna risultante contenente la media mobile.
È supportato solo il tipo Simple Moving Average (SMA). Viene calcolato in questo modo:
```
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
```
**Esempio 1: calcola la media mobile semplice per una serie temporale di temperature**
L'esempio calcola la media mobile semplice rispetto alle temperature utilizzando due punti dati.
Interrogazione 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|
+-----------+---------+--------------------+----------+
```
**Esempio 2: calcola medie mobili semplici per una serie temporale di temperature con ordinamento**
L'esempio calcola due medie mobili semplici sulle temperature utilizzando due e tre punti dati ordinati in modo decrescente per device-id.
Interrogazione PPL:
```
os> source=t | trendline sort - device-id sma(2, temperature) as temp_trend_2 sma(3, temperature) as temp_trend_3;
fetched rows / total rows = 5/5
+-----------+---------+--------------------+------------+------------------+
|temperature|device-id| timestamp|temp_trend_2| temp_trend_3|
+-----------+---------+--------------------+------------+------------------+
| 15| 258|2023-04-06 17:07:...| NULL| NULL|
| 14| 257|2023-04-06 17:07:...| 14.5| NULL|
| 13| 256|2023-04-06 17:07:...| 13.5| 14.0|
| 12| 1492|2023-04-06 17:07:...| 12.5| 13.0|
| 12| 1492|2023-04-06 17:07:...| 12.0|12.333333333333334|
+-----------+---------+--------------------+------------+------------------+
```
#### comando where
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Il `where` comando utilizza un'espressione bool per filtrare i risultati della ricerca. Restituisce il risultato solo quando bool-expression restituisce true.
**Sintassi**
Utilizzare la seguente sintassi:
```
where
```
**espressione bool**
+ Opzionale.
+ Qualsiasi espressione che possa essere valutata in base a un valore booleano.
**Esempio 1: filtra il set di risultati con condizione**
L'esempio mostra come recuperare dall'indice degli account i documenti che soddisfano condizioni specifiche.
Interrogazione 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 |
+------------------+----------+
```
**Esempi aggiuntivi**
**Filtri con condizioni logiche**
+ `source = table | where c = 'test' AND a = 1 | fields a,b,c`
+ `source = table | where c != 'test' OR a > 1 | fields a,b,c | head 1`
+ `source = table | where c = 'test' NOT a > 1 | fields a,b,c`
+ `source = table | where a = 1 | fields a,b,c`
+ `source = table | where a >= 1 | fields a,b,c`
+ `source = table | where a < 1 | fields a,b,c`
+ `source = table | where b != 'test' | fields a,b,c`
+ `source = table | where c = 'test' | fields a,b,c | head 3`
+ `source = table | where ispresent(b)`
+ `source = table | where isnull(coalesce(a, b)) | fields a,b,c | head 3`
+ `source = table | where isempty(a)`
+ `source = table | where isblank(a)`
+ `source = table | where case(length(a) > 6, 'True' else 'False') = 'True'`
+ `source = table | where a between 1 and 4`- Nota: questo restituisce un >= 1 e un <= 4, cioè [1, 4]
+ `source = table | where b not between '2024-09-10' and '2025-09-10'`- Nota: restituisce b >= '\*\*\*\*\*\*\*\*\*\*' e b <= '2025-09-10'
+ `source = table | where cidrmatch(ip, '***********/24')`
+ `source = table | where cidrmatch(ipv6, '2003:db8::/32')`
```
source = table | eval status_category =
case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code')
| where case(a >= 200 AND a < 300, 'Success',
a >= 300 AND a < 400, 'Redirection',
a >= 400 AND a < 500, 'Client Error',
a >= 500, 'Server Error'
else 'Incorrect HTTP status code'
) = 'Incorrect HTTP status code'
```
```
source = table
| eval factor = case(a > 15, a - 14, isnull(b), a - 7, a < 3, a + 1 else 1)
| where case(factor = 2, 'even', factor = 4, 'even', factor = 6, 'even', factor = 8, 'even' else 'odd') = 'even'
| stats count() by factor
```
#### riepilogo del campo
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questo comando PPL, vedi. [Comandi](#supported-ppl-commands)
Utilizzate il `fieldsummary` comando per calcolare le statistiche di base per ogni campo (count, distinct count, min, max, avg, stddev, mean) e determinare il tipo di dati di ogni campo. Questo comando può essere usato con qualsiasi pipe precedente e ne terrà conto.
**Sintassi**
Utilizzare la seguente sintassi. Per i casi d'uso di CloudWatch Logs, è supportato solo un campo in una query.
```
... | fieldsummary (nulls=true/false)
```
**includere campi**
+ Elenco di tutte le colonne da raccogliere con le statistiche in un set di risultati unificato.
**Nulls**
+ Opzionale.
+ Se impostato su true, includi i valori nulli nei calcoli di aggregazione (sostituisci null con zero per i valori numerici).
**Esempio 1**
Interrogazione 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" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
**Esempio 2**
Interrogazione PPL:
```
os> source = t | fieldsummary includefields= id, status_code, request_path nulls=true
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| Fields | COUNT | COUNT_DISTINCT | MIN | MAX | AVG | MEAN | STDDEV | NUlls | TYPEOF |
|------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "id" | 6 | 6 | 1 | 6 | 3.5 | 3.5 | 1.8708286933869707 | 0 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "status_code" | 4 | 3 | 200 | 403 | 184.0 | 184.0 | 161.16699413961905 | 2 | "int" |
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
| "request_path" | 2 | 2 | /about| /home | 0.0 | 0.0 | 0 | 2 |"string"|
+------------------+-------------+------------+------------+------------+------------+------------+------------+----------------|
```
#### comando expand
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
Utilizzate il `expand` comando per appiattire un campo di tipo Array o Map, producendo righe singole per ogni elemento o coppia chiave-valore.
**Sintassi**
Utilizzare la seguente sintassi:
```
expand [As alias]
```
**field**
+ Il campo da espandere (esplodere).
+ Il campo deve essere di un tipo supportato.
**alias**
+ Opzionale.
+ Il nome da utilizzare al posto del nome del campo originale.
**Linee guida per l'utilizzo**
Il comando expand produce una riga per ogni elemento nell'array o nel campo della mappa specificato, dove:
+ Gli elementi dell'array diventano righe singole.
+ Le coppie chiave-valore della mappa sono suddivise in righe separate, con ogni valore chiave rappresentato come una riga.
+ Quando viene fornito un alias, i valori esplosi vengono rappresentati sotto l'alias anziché nel nome del campo originale.
È possibile utilizzare questo comando in combinazione con altri comandi, come stats, eval e parse, per manipolare o estrarre i dati dopo l'espansione.
**Esempi**
+ `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`
È possibile utilizzare il comando expand in combinazione con altri comandi come eval, stats e altri. L'utilizzo di più comandi di espansione creerà un prodotto cartesiano di tutti gli elementi interni all'interno di ogni matrice o mappa composita.
**Query push-down SQL efficace**
Il comando expand viene tradotto in un'operazione SQL equivalente utilizzando LATERAL VIEW explode, che consente l'esplosione efficiente di array o mappe a livello di query SQL.
```
SELECT customer exploded_productId
FROM table
LATERAL VIEW explode(productId) AS exploded_productId
```
Il comando explode offre le seguenti funzionalità:
+ È un'operazione su colonna che restituisce una nuova colonna.
+ Crea una nuova riga per ogni elemento nella colonna esplosa.
+ I valori null interni vengono ignorati come parte del campo esploso (nessuna riga indica null). created/exploded
#### Funzioni PPL
**Topics**
+ [Funzioni di condizione PPL](#supported-ppl-condition-functions)
+ [funzioni hash crittografiche PPL](#supported-ppl-cryptographic-functions)
+ [Funzioni di data e ora PPL](#supported-ppl-date-time-functions)
+ [espressioni PPL](#supported-ppl-expressions)
+ [Funzioni degli indirizzi IP PPL](#supported-ppl-ip-address-functions)
+ [Funzioni PPL JSON](#supported-ppl-json-functions)
+ [Funzioni PPL Lambda](#supported-ppl-lambda-functions)
+ [Funzioni matematiche PPL](#supported-ppl-math-functions)
+ [Funzioni di stringa PPL](#supported-ppl-string-functions)
+ [Funzioni di conversione di tipo PPL](#supported-ppl-type-conversion-functions)
##### Funzioni di condizione PPL
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### ISNULL
**Descrizione**: `isnull(field)` restituisce true se il campo è nullo.
**Tipo di argomento:**
+ Tutti i tipi di dati supportati.
**Tipo di restituzione:**
+ BOOLEAN
**Esempio**:
```
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 |
+----------+-------------+-------------+
```
##### NON È NULLO
**Descrizione**: `isnotnull(field)` restituisce true se il campo non è nullo.
**Tipo di argomento:**
+ Tutti i tipi di dati supportati.
**Tipo di restituzione:**
+ BOOLEAN
**Esempio**:
```
os> source=accounts | where not isnotnull(employer) | fields account_number, employer
fetched rows / total rows = 1/1
+------------------+------------+
| account_number | employer |
|------------------+------------|
| 18 | null |
+------------------+------------+
```
##### EXISTS
**Esempio**:
```
os> source=accounts | where exists(email) | fields account_number, email
fetched rows / total rows = 1/1
```
##### SE NULL
**Descrizione**: `ifnull(field1, field2)` restituisce `field2` se `field1` è nullo.
**Tipo di argomento:**
+ Tutti i tipi di dati supportati.
+ Se i due parametri hanno tipi diversi, la funzione non supererà il controllo semantico.
**Tipo di restituzione:**
+ Qualsiasi
**Esempio**:
```
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
**Descrizione**: `nullif(field1, field2)` restituisce null se due parametri sono uguali, altrimenti restituisce field1.
**Tipo di argomento:**
+ Tutti i tipi di dati supportati.
+ Se i due parametri hanno tipi diversi, la funzione non supererà il controllo semantico.
**Tipo di restituzione:**
+ Qualsiasi
**Esempio**:
```
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
**Descrizione**: `if(condition, expr1, expr2)` restituisce `expr1` se la condizione è vera, altrimenti restituisce`expr2`.
**Tipo di argomento:**
+ Tutti i tipi di dati supportati.
+ Se i due parametri hanno tipi diversi, la funzione non supererà il controllo semantico.
**Tipo di restituzione:**
+ Qualsiasi
**Esempio**:
```
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 |
+----------+-------------+------------+
```
##### funzioni hash crittografiche PPL
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### MD5
MD5 calcola il MD5 digest e restituisce il valore come stringa esadecimale di 32 caratteri.
**Utilizzo:** `md5('hello')`
**Tipo di argomento:**
+ STRING
**Tipo di restituzione:**
+ STRING
**Esempio**:
```
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 restituisce il risultato della stringa esadecimale di SHA-1.
**Utilizzo:** `sha1('hello')`
**Tipo di argomento:**
+ STRING
**Tipo di restituzione:**
+ STRING
**Esempio**:
```
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 restituisce il risultato della stringa esadecimale della famiglia di funzioni hash SHA-2 (SHA-224, SHA-256, SHA-384 e SHA-512). NumBits indica la lunghezza di bit desiderata del risultato, che deve avere un valore di 224, 256, 384, 512
**Utilizzo:**
+ `sha2('hello',256)`
+ `sha2('hello',512)`
**Tipo di argomento:**
+ STRINGA, NUMERO INTERO
**Tipo di restituzione:**
+ STRING
**Esempio**:
```
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> |
+------------------------------------------------------------------+
```
##### Funzioni di data e ora PPL
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### `DAY`
**Utilizzo**: `DAY(date)` estrae il giorno del mese per una data compresa tra 1 e 31.
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**:`DAYOFMONTH`, `DAY_OF_MONTH`
**Esempio**:
```
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`
**Utilizzo**: `DAYOFMONTH(date)` estrae il giorno del mese per una data compresa tra 1 e 31.
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**:`DAY`, `DAY_OF_MONTH`
**Esempio**:
```
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`
**Utilizzo**: `DAY_OF_MONTH(DATE)` estrae il giorno del mese per una data compresa tra 1 e 31.
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**:`DAY`, `DAYOFMONTH`
**Esempio**:
```
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`
**Utilizzo**: `DAYOFWEEK(DATE)` restituisce l'indice dei giorni feriali per una data (1 = domenica, 2 = lunedì,..., 7 = sabato).
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `DAY_OF_WEEK`
**Esempio**:
```
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`
**Utilizzo**: `DAY_OF_WEEK(DATE)` restituisce l'indice dei giorni feriali per una data (1 = domenica, 2 = lunedì,..., 7 = sabato).
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `DAYOFWEEK`
**Esempio**:
```
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`
**Utilizzo**: `DAYOFYEAR(DATE)` restituisce il giorno dell'anno per una data compresa tra 1 e 366.
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `DAY_OF_YEAR`
**Esempio**:
```
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`
**Utilizzo**: `DAY_OF_YEAR(DATE)` restituisce il giorno dell'anno per una data compresa tra 1 e 366.
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `DAYOFYEAR`
**Esempio**:
```
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`
**Utilizzo**: `DAYNAME(DATE)` restituisce il nome del giorno della settimana per una data, tra cui lunedì, martedì, mercoledì, giovedì, venerdì, sabato e domenica.
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: STRING
**Esempio**:
```
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`
**Utilizzo**: `FROM_UNIXTIME` restituisce una rappresentazione dell'argomento fornito come timestamp o valore di stringa di caratteri. Questa funzione esegue una conversione inversa della `UNIX_TIMESTAMP` funzione.
Se fornite un secondo argomento, lo `FROM_UNIXTIME` utilizza per formattare il risultato in modo simile alla `DATE_FORMAT` funzione.
Se il timestamp non rientra nell'intervallo dal 1970-01-01 00:00:00 al 3001-01-18 23:59:59.999 999 (da 0 a 32536771199.999999 epoca), la funzione restituisce. `NULL`
Tipo **di** argomento: DOUBLE, STRING
**Mappa del tipo di ritorno**:
DOUBLE -> TIMESTAMP
DOUBLE, STRING -> STRING
**Esempi:**
```
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`
**Utilizzo**: `HOUR(TIME)` estrae il valore dell'ora in base al tempo.
A differenza di un'ora del giorno standard, il valore dell'ora in questa funzione può avere un intervallo maggiore di 23. Di conseguenza, il valore restituito da `HOUR(TIME)` può essere maggiore di 23.
**Tipo di argomento**: STRING/TIME/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `HOUR_OF_DAY`
**Esempio**:
```
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`
**Utilizzo**: `HOUR_OF_DAY(TIME)` estrae il valore dell'ora dall'ora specificata.
A differenza di un'ora del giorno standard, il valore dell'ora in questa funzione può avere un intervallo maggiore di 23. Di conseguenza, il valore restituito da `HOUR_OF_DAY(TIME)` può essere maggiore di 23.
**Tipo di argomento**: STRING/TIME/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `HOUR`
**Esempio**:
```
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`
**Utilizzo**: `LAST_DAY` restituisce l'ultimo giorno del mese come valore DATE per l'argomento data specificato.
**Tipo di argomento**: DATE/STRING/TIMESTAMP/TIME
**Tipo di restituzione**: DATA
**Esempio**:
```
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`
**Utilizzo**: `LOCALTIMESTAMP()` è sinonimo di`NOW()`.
**Esempio**:
```
> source=people | eval `LOCALTIMESTAMP()` = LOCALTIMESTAMP() | fields `LOCALTIMESTAMP()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIMESTAMP() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `LOCALTIME`
**Utilizzo**: `LOCALTIME()` è sinonimo di`NOW()`.
**Esempio**:
```
> source=people | eval `LOCALTIME()` = LOCALTIME() | fields `LOCALTIME()`
fetched rows / total rows = 1/1
+---------------------+
| LOCALTIME() |
|---------------------|
| 2022-08-02 15:54:19 |
+---------------------+
```
##### `MAKE_DATE`
**Utilizzo**: `MAKE_DATE` restituisce un valore di data basato sui valori di anno, mese e giorno specificati. Tutti gli argomenti sono arrotondati a numeri interi.
**Specifiche**: 1. MAKE\_DATE (INTERO, INTERO, INTERO) -> DATA
**Tipo di argomento**: INTEGER, INTEGER, INTEGER
**Tipo di restituzione**: DATE
**Esempio**:
```
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`
**Utilizzo**: `MINUTE(TIME)` restituisce la componente in minuti dell'ora specificata, come numero intero compreso tra 0 e 59.
**Tipo di argomento:** STRING/TIME/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `MINUTE_OF_HOUR`
**Esempio**:
```
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`
**Utilizzo**: `MINUTE_OF_HOUR(TIME)` restituisce il componente minuto del tempo specificato, come numero intero compreso tra 0 e 59.
**Tipo di argomento:** STRING/TIME/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `MINUTE`
**Esempio**:
```
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`
**Utilizzo**: `MONTH(DATE)` restituisce il mese della data specificata come numero intero, nell'intervallo da 1 a 12 (dove 1 rappresenta gennaio e 12 rappresenta dicembre).
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `MONTH_OF_YEAR`
**Esempio**:
```
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`
**Utilizzo**: `MONTHNAME(DATE)` restituisce il mese della data specificata come numero intero, nell'intervallo da 1 a 12 (dove 1 rappresenta gennaio e 12 rappresenta dicembre).
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `MONTH_OF_YEAR`
**Esempio**:
```
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`
**Utilizzo**: `MONTH_OF_YEAR(DATE)` restituisce il mese della data specificata come numero intero, nell'intervallo da 1 a 12 (dove 1 rappresenta gennaio e 12 rappresenta dicembre).
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `MONTH`
**Esempio**:
```
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`
**Utilizzo**: `NOW` restituisce la data e l'ora correnti come `TIMESTAMP` valore nel formato YYYY-MM-DD 'hh:mm:ss'. Il valore è espresso nel fuso orario del cluster.
**Nota**
`NOW()`restituisce un tempo costante che indica quando l'istruzione ha iniziato l'esecuzione. Questo differisce da`SYSDATE()`, che restituisce l'ora esatta di esecuzione.
**Tipo di restituzione: TIMESTAMP**
**Specificazione**: NOW () -> TIMESTAMP
**Esempio**:
```
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`
**Utilizzo**: `QUARTER(DATE)` restituisce il trimestre dell'anno per la data specificata come numero intero, nell'intervallo da 1 a 4.
**Tipo di argomento:** STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Esempio**:
```
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`
**Utilizzo**: `SECOND(TIME)` restituisce il secondo componente dell'ora specificata come numero intero, nell'intervallo da 0 a 59.
**Tipo di argomento:** STRING/TIME/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `SECOND_OF_MINUTE`
**Esempio**:
```
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`
**Utilizzo**: `SECOND_OF_MINUTE(TIME)` restituisce il secondo componente del tempo specificato come numero intero, nell'intervallo da 0 a 59.
**Tipo di argomento:** STRING/TIME/TIMESTAMP
**Tipo restituito**: INTEGER
**Sinonimi**: `SECOND`
**Esempio**:
```
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`
**Utilizzo**: `SUBDATE(DATE, DAYS)` sottrae il secondo argomento (ad esempio `DATE` o`DAYS`) dalla data specificata.
**Tipo di argomento: DATE/TIMESTAMP**, LONG
**Mappa del tipo di ritorno**: (DATE, LONG) -> DATE
**Contrari**: `ADDDATE`
**Esempio**:
```
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`
**Utilizzo**: `SYSDATE()` restituisce la data e l'ora correnti come `TIMESTAMP` valore nel formato 'YYYY-MM-DD hh:mm:ss.nnnnnnn'.
`SYSDATE()`restituisce l'ora esatta in cui viene eseguito. Ciò differisce da NOW (), che restituisce un tempo costante che indica quando l'istruzione ha iniziato l'esecuzione.
**Tipo di argomento opzionale**: INTEGER (da 0 a 6): specifica il numero di cifre per frazioni di secondo nel valore restituito.
**Tipo restituito: TIMESTAMP**
**Esempio**:
```
os> source=people | eval `SYSDATE()` = SYSDATE() | fields `SYSDATE()`
fetched rows / total rows = 1/1
+----------------------------+
| SYSDATE() |
|----------------------------|
| 2022-08-02 15:39:05.123456 |
+----------------------------+
```
##### `TIMESTAMP`
**Utilizzo**: `TIMESTAMP(EXPR)` costruisce un tipo di timestamp con la stringa di input come timestamp. `expr`
Con un solo argomento, `TIMESTAMP(expr)` costruisce un timestamp dall'input. Se `expr` è una stringa, viene interpretata come un timestamp. Per argomenti non di tipo stringa, la funzione esegue il cast su un timestamp `expr` utilizzando il fuso orario UTC. Quando `expr` è un `TIME` valore, la funzione applica la data odierna prima del casting.
Se utilizzata con due argomenti, `TIMESTAMP(expr1, expr2)` aggiunge l'espressione time (`expr2`) all'espressione date o timestamp (`expr1`) e restituisce il risultato come valore di timestamp.
**Tipo di argomento:** STRING/DATE/TIME/TIMESTAMP
**Mappa del tipo di ritorno**:
(STRING/DATE/TIME/TIMESTAMP) -> TIMESTAMP
() -> STRING/DATE/TIME/TIMESTAMP, STRING/DATE/TIME/TIMESTAMP TIMESTAMP
**Esempio**:
```
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`
**Utilizzo**: `UNIX_TIMESTAMP` converte un determinato argomento di data in ora Unix (secondi dall'Epoca, iniziata all'inizio del 1970). Se non viene fornito alcun argomento, restituisce l'ora Unix corrente.
L'argomento della data può essere un`DATE`, una `TIMESTAMP` stringa o un numero in uno dei seguenti formati:`YYMMDD`, `YYMMDDhhmmss``YYYYMMDD`, o`YYYYMMDDhhmmss`. Se l'argomento include un componente temporale, può facoltativamente includere frazioni di secondi.
Se l'argomento è in un formato non valido o non rientra nell'intervallo compreso tra 00:00:00 e 3001-01-18 23:59:59.999 (da 0 a 32536771199.999999 nell'ora dell'epoca), la funzione restituisce. `NULL`
La `DOUBLE` funzione accetta o come tipi di argomento `DATE` o nessun argomento. `TIMESTAMP` Restituisce sempre un `DOUBLE` valore che rappresenta il timestamp Unix.
Per la conversione inversa, puoi usare la funzione FROM\_UNIXTIME.
**Tipo di argomento:/DOUBLE/DATE/TIMESTAMP**
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
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`
**Utilizzo**: `WEEK(DATE)` restituisce il numero della settimana per una determinata data.
**Tipo di argomento**: DATE/TIMESTAMP/STRING
**Tipo restituito**: INTEGER
**Sinonimi**: `WEEK_OF_YEAR`
**Esempio**:
```
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`
**Utilizzo**: `WEEKDAY(DATE)` restituisce l'indice dei giorni feriali per la data (0 = lunedì, 1 = martedì,..., 6 = domenica).
È simile alla `dayofweek` funzione, ma restituisce indici diversi per ogni giorno.
Tipo di **argomento**: STRING/DATE/TIME/TIMESTAMP
**Tipo restituito**: INTEGER
**Esempio**:
```
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`
**Utilizzo**: `WEEK_OF_YEAR(DATE)` restituisce il numero della settimana per la data specificata.
**Tipo di argomento**: DATE/TIMESTAMP/STRING
**Tipo restituito**: INTEGER
**Sinonimi**: `WEEK`
**Esempio**:
```
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`
**Utilizzo**: `YEAR(DATE)` restituisce l'anno come data, nell'intervallo da 1000 a 9999 o 0 per la data «zero».
**Tipo di argomento**: STRING/DATE/TIMESTAMP
**Tipo restituito**: INTEGER
**Esempio**:
```
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`
**Utilizzo**: `DATE_ADD(date, INTERVAL expr unit)` aggiunge l'intervallo specificato alla data specificata.
**Tipo di argomento**: DATE, INTERVAL
**Tipo di restituzione**: DATE
**Contrari**: `DATE_SUB`
**Esempio**:
```
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`
**Utilizzo**: `DATE_SUB(date, INTERVAL expr unit)` sottrae l'intervallo expr dalla data.
**Tipo di argomento**: DATE, INTERVAL
**Tipo di restituzione**: DATE
**Contrari**: `DATE_ADD`
**Esempio**:
```
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`
**Utilizzo**: restituisce un `TIMESTAMP` valore dopo aver aggiunto un intervallo di tempo specificato a una determinata data.
**Argomenti**:
+ INTERVALLO: INTERVALLO (SECONDO, MINUTO, ORA, GIORNO, SETTIMANA, MESE, TRIMESTRE, ANNO)
+ numero intero: INTERO
+ data: DATE, TIMESTAMP o STRING
Se fornisci un `STRING` come argomento per la data, formattalo come valido. `TIMESTAMP` La funzione converte automaticamente un `DATE` argomento in un`TIMESTAMP`.
**Esempi:**
```
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`
**Utilizzo**: `TIMESTAMPDIFF(interval, start, end)` restituisce la differenza tra l'inizio e la fine date/times in unità di intervallo specificate.
**Argomenti**:
+ INTERVALLO: INTERVALLO (SECONDO, MINUTO, ORA, GIORNO, SETTIMANA, MESE, TRIMESTRE, ANNO)
+ inizio: DATE, TIMESTAMP o STRING
+ fine: DATE, TIMESTAMP o STRING
La funzione converte automaticamente gli argomenti in modo appropriato. `TIMESTAMP` Formatta `STRING` gli argomenti come file validi`TIMESTAMP`.
**Esempi:**
```
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`
**Utilizzo**: `UTC_TIMESTAMP` restituisce il timestamp UTC corrente come valore in 'YYYY-MM-DD hh:mm:ss'.
**Tipo** di restituzione: TIMESTAMP
**Specificazione**: UTC\_TIMESTAMP () -> TIMESTAMP
**Esempio**:
```
> 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`
**Utilizzo: restituisce** il fuso orario locale corrente. `CURRENT_TIMEZONE`
**Tipo restituito: STRING**
**Esempio**:
```
> source=people | eval `CURRENT_TIMEZONE()` = CURRENT_TIMEZONE() | fields `CURRENT_TIMEZONE()`
fetched rows / total rows = 1/1
+------------------------+
| CURRENT_TIMEZONE() |
|------------------------|
| America/Chicago |
+------------------------+
```
##### espressioni PPL
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
Le espressioni, in particolare le espressioni di valore, restituiscono un valore scalare. Le espressioni hanno tipi e forme diversi. Ad esempio, esistono valori letterali come espressioni atomiche ed espressioni aritmetiche, predicative e funzionali basate su di essi. È possibile utilizzare le espressioni in diverse clausole, ad esempio l'utilizzo di espressioni aritmetiche nei comandi and. `Filter` `Stats`
**Operatori**
Un'espressione aritmetica è un'espressione formata da valori letterali numerici e operatori aritmetici binari come segue:
1. `+`: Aggiungi.
1. `-`: Sottrai.
1. `*`: Moltiplica.
1. `/`: Dividi (per i numeri interi, il risultato è un numero intero con la parte frazionaria scartata)
1. `%`: Modulo (da utilizzare solo con numeri interi; il risultato è il resto della divisione)
**Precedenza**
Utilizzate le parentesi per controllare la precedenza degli operatori aritmetici. Altrimenti, gli operatori con precedenza più alta vengono eseguiti per primi.
**Conversione del tipo**
La conversione implicita dei tipi viene eseguita durante la ricerca delle firme degli operatori. Ad esempio, un numero intero corrisponde `+` a una firma `+(double,double)` che dà come risultato un numero reale. Questa regola si applica anche alle chiamate di funzione.
Esempio per diversi tipi di espressioni aritmetiche:
```
os> source=accounts | where age > (25 + 5) | fields age ;
fetched rows / total rows = 3/3
+-------+
| age |
|-------|
| 32 |
| 36 |
| 33 |
+-------+
```
**Operatori predicati**
Un operatore predicato è un'espressione che risulta vera. Il confronto dei `NULL` valori `MISSING` e segue queste regole:
+ Un `MISSING` valore è solo uguale a un `MISSING` valore ed è inferiore agli altri valori.
+ Un `NULL` valore è uguale a un `NULL` valore, è maggiore di un `MISSING` valore, ma è minore di tutti gli altri valori.
**Operatori**
**Operatori predicati**
| Nome | Description |
| --- | --- |
| > | Maggiore dell'operatore |
| >= | Operatore maggiore o uguale |
| < | Meno dell'operatore |
| \!= | Operatore non uguale |
| <= | Operatore minore o uguale |
| = | Operatore uguale |
| LIKE | Corrispondenza semplice dei modelli |
| IN | Test del valore NULL |
| AND | Operatore AND |
| OR | Operatore OR |
| XOR | Operatore XOR |
| NOT | Test del valore NOT NULL |
Puoi confrontare le date e le ore. Quando si confrontano diversi tipi di datetime (ad esempio `DATE` e`TIME`), entrambi vengono convertiti in. `DATETIME` Le seguenti regole si applicano alla conversione:
+ `TIME`si applica alla data odierna.
+ `DATE`viene interpretato a mezzanotte.
**Operatore di predicato di base**
Esempio di operatori di confronto:
```
os> source=accounts | where age > 33 | fields age ;
fetched rows / total rows = 1/1
+-------+
| age |
|-------|
| 36 |
+-------+
```
**`IN`**
Esempio del campo di test `IN` dell'operatore nelle liste di valori:
```
os> source=accounts | where age in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`OR`**
Esempio dell'`OR`operatore:
```
os> source=accounts | where age = 32 OR age = 33 | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 32 |
| 33 |
+-------+
```
**`NOT`**
Esempio dell'`NOT`operatore:
```
os> source=accounts | where age not in (32, 33) | fields age ;
fetched rows / total rows = 2/2
+-------+
| age |
|-------|
| 36 |
| 28 |
+-------+
```
##### Funzioni degli indirizzi IP PPL
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### `CIDRMATCH`
**Utilizzo**: `CIDRMATCH(ip, cidr)` verifica se l'indirizzo IP specificato rientra nell'intervallo cidr specificato.
**Tipo di argomento:**
+ STRINGA, STRINGA
+ Tipo restituito: BOOLEAN
**Esempio**:
```
os> source=ips | where cidrmatch(ip, '***********/24') | fields ip
fetched rows / total rows = 1/1
+--------------+
| ip |
|--------------|
| *********** |
+--------------+
os> source=ipsv6 | where cidrmatch(ip, '2003:db8::/32') | fields ip
fetched rows / total rows = 1/1
+-----------------------------------------+
| ip |
|-----------------------------------------|
| 2003:0db8:****:****:****:****:****:0000 |
+-----------------------------------------+
```
**Nota**
`ip`può essere un indirizzo IPv4 o. IPv6
`cidr`può essere un IPv4 o un IPv6 blocco.
`ip`e `cidr` deve essere entrambi IPv4 o entrambi IPv6.
`ip`e `cidr` devono essere entrambi validi e non vuoti/non nulli.
##### Funzioni PPL JSON
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### `JSON`
**Utilizzo**: `json(value)` valuta se una stringa può essere analizzata come formato JSON. La funzione restituisce la stringa originale se è JSON valido o null se non è valida.
Tipo di **argomento**: STRING
**Tipo restituito**: STRING/NULL. Un'espressione STRING di un formato di oggetto JSON valido.
**Esempi:**
```
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`
**Utilizzo**: `json_object(, [, , ]...)` restituisce un oggetto JSON dai membri di coppie chiave-valore.
**Tipo di argomento:**
+ A deve essere STRING.
+ A può essere qualsiasi tipo di dati.
**Tipo restituito**: JSON\_OBJECT. Un' StructType espressione di un oggetto JSON valido.
**Esempi:**
```
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`
**Utilizzo**: `json_array(...)` crea un JSON ARRAY utilizzando un elenco di valori.
**Tipo di argomento**: A `` può essere qualsiasi tipo di valore come stringa, numero o booleano.
**Tipo restituito: ARRAY**. Un array di qualsiasi tipo di dati supportato per un array JSON valido.
**Esempi:**
```
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`
**Utilizzo**: `to_json_string(jsonObject)` restituisce una stringa JSON con un determinato valore di oggetto json.
**Tipo di argomento**: JSON\_OBJECT
**Tipo restituito**: STRING
**Esempi:**
```
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`
**Utilizzo**: `array_length(jsonArray)` restituisce il numero di elementi nell'array più esterno.
**Tipo di argomento: ARRAY**. Un oggetto ARRAY o JSON\_ARRAY.
**Tipo restituito**: INTEGER
**Esempio**:
```
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`
**Utilizzo**: `json_extract(jsonStr, path)` estrae un oggetto JSON da una stringa JSON in base al percorso JSON specificato. La funzione restituisce null se la stringa JSON di input non è valida.
**Tipo di argomento: STRING**, STRING
**Tipo restituito**: STRING
+ Un'espressione STRING di un formato di oggetto JSON valido.
+ `NULL`viene restituito in caso di JSON non valido.
**Esempi:**
```
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`
**Utilizzo**: `json_keys(jsonStr)` restituisce tutte le chiavi dell'oggetto JSON più esterno come array.
**Tipo di argomento**: STRING. Un'espressione STRING di un formato di oggetto JSON valido.
**Tipo restituito**: ARRAY [STRING]. La funzione restituisce `NULL` qualsiasi altra stringa JSON valida, una stringa vuota o un codice JSON non valido.
**Esempi:**
```
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`
**Utilizzo**: `json_valid(jsonStr)` valuta se una stringa JSON utilizza una sintassi JSON valida e restituisce TRUE o FALSE.
**Tipo di argomento: STRING**
**Tipo restituito**: BOOLEAN
**Esempi:**
```
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 |
+------------------+---------+
```
##### Funzioni PPL Lambda
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### `EXISTS`
**Utilizzo**: `exists(array, lambda)` valuta se un predicato Lambda è valido per uno o più elementi dell'array.
**Tipo di argomento**: ARRAY, LAMBDA
**Tipo restituito**: BOOLEAN. Restituisce `TRUE` se almeno un elemento dell'array soddisfa il predicato Lambda, altrimenti. `FALSE`
**Esempi:**
```
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`
**Utilizzo**: `filter(array, lambda)` filtra l'array di input utilizzando la funzione Lambda specificata.
**Tipo di argomento**: ARRAY, LAMBDA
**Tipo restituito**: ARRAY. Un ARRAY che contiene tutti gli elementi dell'array di input che soddisfano il predicato lambda.
**Esempi:**
```
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`
**Utilizzo**: `transform(array, lambda)` trasforma gli elementi di un array utilizzando la funzione di trasformazione Lambda. Il secondo argomento implica l'indice dell'elemento se si utilizza la funzione binaria Lambda. È simile a una `map` nella programmazione funzionale.
**Tipo di argomento**: ARRAY, LAMBDA
**Tipo restituito**: ARRAY. Un ARRAY che contiene il risultato dell'applicazione della funzione di trasformazione lambda a ciascun elemento dell'array di input.
**Esempi:**
```
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`
**Utilizzo**: `reduce(array, start, merge_lambda, finish_lambda)` riduce un array a un singolo valore applicando le funzioni lambda. La funzione applica merge\_lambda al valore iniziale e a tutti gli elementi dell'array, quindi applica il valore al risultato. `finish_lambda`
**Tipo di argomento**: ARRAY, ANY, LAMBDA, LAMBDA
**Tipo di restituzione**: ANY. Il risultato finale dell'applicazione delle funzioni Lambda al valore iniziale e all'array di input.
**Esempi:**
```
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 |
+-----------+
```
##### Funzioni matematiche PPL
**Nota**
Per vedere quali integrazioni di sorgenti AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### `ABS`
**Utilizzo**: `ABS(x) ` calcola il valore assoluto di x.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione:** INTEGER/LONG/FLOAT/DOUBLE
**Esempio**:
```
os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)`
fetched rows / total rows = 1/1
+-----------+
| ABS(-1) |
|-----------|
| 1 |
+-----------+
```
##### `ACOS`
**Utilizzo**: `ACOS(x)` calcola l'arcoseno di x. Restituisce `NULL` se x non è compreso nell'intervallo da -1 a 1.
**Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `ACOS(0)` = ACOS(0) | fields `ACOS(0)`
fetched rows / total rows = 1/1
+--------------------+
| ACOS(0) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `ASIN`
**Utilizzo**: `asin(x)` calcola l'arcoseno di x. Restituisce `NULL` se x non è compreso nell'intervallo da -1 a 1.
**Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `ASIN(0)` = ASIN(0) | fields `ASIN(0)`
fetched rows / total rows = 1/1
+-----------+
| ASIN(0) |
|-----------|
| 0.0 |
+-----------+
```
##### `ATAN`
**Uso**: `ATAN(x)` calcola l'arcotangente di x. `atan(y, x)` Calcola l'arcotangente di y/x, tranne per il fatto che i segni di entrambi gli argomenti determinano il quadrante del risultato.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
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`
**Utilizzo**: `ATAN2(y, x)` calcola l'arcotangente di y/x, tranne per il fatto che i segni di entrambi gli argomenti determinano il quadrante del risultato.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
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`
**Utilizzo**: `CBRT` calcola la radice cubica di un numero.
Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE:
INTEGER/LONG/FLOAT/DOUBLE-> DOPPIO
**Esempio**:
```
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`
**Utilizzo**: un alias per la `CEILING` funzione. `CEILING(T)`prende il limite del valore T.
**Limitazione**: funziona `CEILING` solo come previsto quando il tipo doppio IEEE 754 visualizza un decimale quando memorizzato.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: LUNGO
**Esempio**:
```
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`
**Utilizzo**: `CONV(x, a, b)` converte il numero x da una base a una base b.
**Tipo di argomento**: x: STRING, a: INTEGER, b: INTEGER
**Tipo restituito: STRING**
**Esempio**:
```
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`
**Utilizzo**: `COS(x)` calcola il coseno di x, dove x è espresso in radianti.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione:** DOUBLE
**Esempio**:
```
os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)`
fetched rows / total rows = 1/1
+----------+
| COS(0) |
|----------|
| 1.0 |
+----------+
```
##### `COT`
**Utilizzo**: `COT(x)` calcola la cotangente di x. Restituisce out-of-range un errore se x è uguale a 0.
**Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `COT(1)` = COT(1) | fields `COT(1)`
fetched rows / total rows = 1/1
+--------------------+
| COT(1) |
|--------------------|
| 0.6420926159343306 |
+--------------------+
```
##### `CRC32`
**Utilizzo**: `CRC32` calcola un valore di controllo di ridondanza ciclico e restituisce un valore senza segno a 32 bit.
**Tipo** di argomento: STRING
**Tipo restituito**: LONG
**Esempio**:
```
os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')`
fetched rows / total rows = 1/1
+------------------+
| CRC32('MySQL') |
|------------------|
| 3259397556 |
+------------------+
```
##### `DEGREES`
**Utilizzo**: `DEGREES(x)` converte x da radianti a gradi.
Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
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`
**Utilizzo**: `E()` restituisce il numero di Eulero.
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `E()` = E() | fields `E()`
fetched rows / total rows = 1/1
+-------------------+
| E() |
|-------------------|
| 2.718281828459045 |
+-------------------+
```
##### `EXP`
**Utilizzo**: `EXP(x)` restituisce e elevato alla potenza di x.
**Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `EXP(2)` = EXP(2) | fields `EXP(2)`
fetched rows / total rows = 1/1
+------------------+
| EXP(2) |
|------------------|
| 7.38905609893065 |
+------------------+
```
##### `FLOOR`
**Utilizzo**: `FLOOR(T)` prende il nome dal valore T.
**Limitazione**: funziona `FLOOR` solo come previsto quando il tipo doppio IEEE 754 visualizza un decimale quando memorizzato.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: LUNGO
**Esempio**:
```
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`
**Utilizzo**: `LN(x)` restituisce il logaritmo naturale di x.
Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `LN(2)` = LN(2) | fields `LN(2)`
fetched rows / total rows = 1/1
+--------------------+
| LN(2) |
|--------------------|
| 0.6931471805599453 |
+--------------------+
```
##### `LOG`
**Utilizzo**: `LOG(x)` restituisce il logaritmo naturale di x che è il logaritmo di base e di x. log (B, x) è equivalente a log (x) /log (B).
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
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`
**Utilizzo**: `LOG2(x)` è equivalente a`log(x)`/`log(2)`.
**Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `LOG2(8)` = LOG2(8) | fields `LOG2(8)`
fetched rows / total rows = 1/1
+-----------+
| LOG2(8) |
|-----------|
| 3.0 |
+-----------+
```
##### `LOG10`
**Utilizzo**: `LOG10(x)` è equivalente a`log(x)`/`log(10)`.
**Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `LOG10(100)` = LOG10(100) | fields `LOG10(100)`
fetched rows / total rows = 1/1
+--------------+
| LOG10(100) |
|--------------|
| 2.0 |
+--------------+
```
##### `MOD`
**Utilizzo**: `MOD(n, m)` calcola il resto del numero n diviso per m.
Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo restituito**: tipo più ampio tra i tipi n e m se m è un valore diverso da zero. Se m è uguale a 0, restituisce NULL.
**Esempio**:
```
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`
**Utilizzo**: `PI() ` restituisce la costante pi.
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `PI()` = PI() | fields `PI()`
fetched rows / total rows = 1/1
+-------------------+
| PI() |
|-------------------|
| 3.141592653589793 |
+-------------------+
```
##### `POW`
**Utilizzo**: `POW(x, y)` calcola il valore di x elevato alla potenza di y. Gli input errati restituiscono un `NULL` risultato.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Sinonimi**: `POWER(_, _)`
**Esempio**:
```
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
**Utilizzo**: `POWER(x, y)` calcola il valore di x elevato alla potenza di y. Gli input errati restituiscono un `NULL` risultato.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Sinonimi**: `POW(_, _)`
**Esempio**:
```
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`
**Utilizzo**: `RADIANS(x)` converte x da gradi a radianti.
Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione**: DOUBLE
**Esempio**:
```
os> source=people | eval `RADIANS(90)` = RADIANS(90) | fields `RADIANS(90)`
fetched rows / total rows = 1/1
+--------------------+
| RADIANS(90) |
|--------------------|
| 1.5707963267948966 |
+--------------------+
```
##### `RAND`
**Utilizzo**:`RAND()`/`RAND(N)`restituisce un valore casuale a virgola mobile nell'intervallo 0 <= valore < 1,0. Se specificate il numero intero N, la funzione inizializza il seme prima dell'esecuzione. Un'implicazione di questo comportamento è che con un argomento identico N, `rand(N)` restituisce lo stesso valore ogni volta, producendo una sequenza ripetibile di valori di colonna.
**Tipo di argomento: INTERO**
**Tipo restituito: FLOAT**
**Esempio**:
```
os> source=people | eval `RAND(3)` = RAND(3) | fields `RAND(3)`
fetched rows / total rows = 1/1
+------------+
| RAND(3) |
|------------|
| 0.73105735 |
+------------+
```
##### `ROUND`
**Utilizzo**: `ROUND(x, d)` arrotonda l'argomento x a d cifre decimali. Se non si specifica d, il valore predefinito è 0.
Tipo di **argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Mappa del tipo di ritorno**:
+ (INTEGER/LONG [, INTEGER]) -> LONG
+ (FLOAT/DOUBLE [, INTERO]) -> LUNGO
**Esempio**:
```
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`
**Utilizzo**: `SIGN` restituisce il segno dell'argomento come -1, 0 o 1, a seconda che il numero sia negativo, zero o positivo.
**Tipo di argomento**: INTEGER/LONG/FLOAT/DOUBLE
**Tipo restituito:** INTEGER
**Esempio**:
```
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`
**Utilizzo**: `sin(x)` calcola il seno di x, dove x è espresso in radianti.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Tipo di restituzione:** DOUBLE
**Esempio**:
```
os> source=people | eval `SIN(0)` = SIN(0) | fields `SIN(0)`
fetched rows / total rows = 1/1
+----------+
| SIN(0) |
|----------|
| 0.0 |
+----------+
```
##### `SQRT`
**Utilizzo**: `SQRT` calcola la radice quadrata di un numero non negativo.
**Tipo di argomento:** INTEGER/LONG/FLOAT/DOUBLE
**Mappa del tipo di ritorno:**
+ (Non negativo) INTEGER/LONG/FLOAT/DOUBLE -> DOUBLE
+ (Negativo) INTEGER/LONG/FLOAT/DOUBLE -> NULL
**Esempio**:
```
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 |
+-----------+--------------+
```
##### Funzioni di stringa PPL
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### `CONCAT`
**Utilizzo**: `CONCAT(str1, str2, ...., str_9)` somma fino a 9 stringhe insieme.
**Tipo di argomento:**
+ STRINGA, STRINGA,..., STRINGA
+ Tipo restituito: STRING
**Esempio**:
```
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`
**Utilizzo**: `CONCAT_WS(sep, str1, str2)` concatena due o più stringhe utilizzando un separatore specificato tra di loro.
**Tipo di argomento:**
+ STRINGA, STRINGA,..., STRINGA
+ Tipo restituito: STRING
**Esempio**:
```
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`
**Utilizzo**: `length(str)` restituisce la lunghezza della stringa di input misurata in byte.
**Tipo di argomento:**
+ STRING
+ Tipo restituito: INTEGER
**Esempio**:
```
os> source=people | eval `LENGTH('helloworld')` = LENGTH('helloworld') | fields `LENGTH('helloworld')`
fetched rows / total rows = 1/1
+------------------------+
| LENGTH('helloworld') |
|------------------------|
| 10 |
+------------------------+
```
##### `LOWER`
**Utilizzo**: `lower(string)` converte la stringa di input in lettere minuscole.
**Tipo di argomento:**
+ STRING
+ Tipo restituito: STRING
**Esempio**:
```
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`
**Utilizzo**: `ltrim(str)` rimuove i caratteri spaziali iniziali dalla stringa di input.
**Tipo di argomento:**
+ STRING
+ Tipo restituito: STRING
**Esempio**:
```
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`
**Utilizzo**: `POSITION(substr IN str)` restituisce la posizione della prima occorrenza della sottostringa nella stringa. Restituisce 0 se la sottostringa non è nella stringa. Restituisce NULL se un argomento è NULL.
**Tipo di argomento:**
+ STRINGA, STRINGA
+ Tipo restituito INTEGER
**Esempio**:
```
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`
**Utilizzo**: `REVERSE(str)` restituisce la stringa invertita della stringa di input.
**Tipo di argomento:**
+ STRING
+ Tipo restituito: STRING
**Esempio**:
```
os> source=people | eval `REVERSE('abcde')` = REVERSE('abcde') | fields `REVERSE('abcde')`
fetched rows / total rows = 1/1
+--------------------+
| REVERSE('abcde') |
|--------------------|
| edcba |
+--------------------+
```
##### `RIGHT`
**Utilizzo**: `right(str, len)` restituisce i caratteri più a destra della stringa di input. Restituisce 0 se la sottostringa non è nella stringa. Restituisce NULL se un argomento è NULL.
**Tipo di argomento:**
+ STRINGA, NUMERO INTERO
+ Tipo restituito: STRING
**Esempio**:
```
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`
**Utilizzo**: `rtrim(str)` elimina i caratteri spaziali finali dalla stringa di input.
**Tipo di argomento:**
+ STRING
+ Tipo restituito: **STRING**
**Esempio**:
```
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`
**Utilizzo**: `substring(str, start)` o `substring(str, start, length)` restituisce una sottostringa della stringa di input. Senza una lunghezza specificata, restituisce l'intera stringa dalla posizione iniziale.
**Tipo di argomento:**
+ STRINGA, NUMERO INTERO, NUMERO INTERO
+ Tipo restituito: STRING
**Esempio**:
```
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`
**Utilizzo**: `trim(string)` rimuove gli spazi bianchi iniziali e finali dalla stringa di input.
**Tipo di argomento:**
+ STRING
+ Tipo restituito: **STRING**
**Esempio**:
```
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`
**Utilizzo**: `upper(string)` converte la stringa di input in maiuscolo.
**Tipo di argomento:**
+ STRING
+ Tipo restituito: STRING
**Esempio**:
```
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 |
+-----------------------+-----------------------+
```
##### Funzioni di conversione di tipo PPL
**Nota**
Per vedere quali integrazioni di fonti di AWS dati supportano questa funzione PPL, vedi. [Funzioni](#supported-ppl-functions)
##### `TRIM`
**Utilizzo**: `cast(expr as dateType)` trasmette il `expr` a `dataType` e restituisce il valore di. `dataType`
Si applicano le seguenti regole di conversione:
**Regole di conversione dei tipi**
| Src/Target | STRING | NUMBER | BOOLEAN | TIMESTAMP | DATE | TIME |
| --- | --- | --- | --- | --- | --- | --- |
| STRING | | Nota 1 | Nota 1 | TIMESTAMP() | DATE() | TIME() |
| NUMBER | Nota 1 | | v\! =0 | N/D | N/D | N/D |
| BOOLEAN | Nota 1 | v? 1:0 | | N/D | N/D | N/D |
| TIMESTAMP | Nota 1 | N/D | N/D | | DATE() | TIME() |
| DATE | Nota 1 | N/D | N/D | N/D | | N/D |
| TIME | Nota 1 | N/D | N/D | N/D | N/D | |
**Esempio di cast su stringa:**
```
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 |
+---------+--------+------------+
```
**Esempio di cast to number:**
```
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 |
+---------+-----------+
```
**Esempio di cast to date:**
```
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 |
+------------+----------+---------------------+
```
**Esempio di cast concatenato:**
```
os> source=people | eval `cbool` = CAST(CAST(true as string) as boolean) | fields `cbool`
fetched rows / total rows = 1/1
+---------+
| cbool |
|---------|
| True |
+---------+
```