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à.
# Eseguire query su matrici con tipi complessi e strutture nidificate
I dati di origine contengono spesso matrici con tipi di dati complessi e strutture nidificate. Alcuni esempi di questa sezione mostrano come modificare il tipo di dati degli elementi, individuare elementi all'interno di matrici e trovare parole chiave utilizzando le query Athena.
**Topics**
+ [
# Creazione di una `ROW`
](creating-row.md)
+ [
# Modificare i nomi di campo nelle matrici utilizzando `CAST`
](changing-row-arrays-with-cast.md)
+ [
# Filtrare le matrici utilizzando la notazione `.`
](filtering-with-dot.md)
+ [
# Filtrare le matrici con valori nidificati
](filtering-nested-with-dot.md)
+ [
# Filtrare le matrici utilizzando `UNNEST`
](filtering-with-unnest.md)
+ [
# Cercare parole chiave nelle matrici utilizzando `regexp_like`
](filtering-with-regexp.md)
# Creazione di una `ROW`
**Nota**
Negli esempi di questa sezione viene utilizzato `ROW` come strumento per creare i dati di esempio con cui lavorare. Quando si eseguono le query di tabelle all'interno di Athena, non è necessario creare tipi di dati `ROW`, poiché sono già creati dall'origine dati. Quando si utilizza `CREATE_TABLE`, Athena definisce un `STRUCT` al suo interno, lo popola con i dati e crea il tipo di dati `ROW` per l'utente, per ogni riga nel set di dati. Il tipo di dati `ROW` sottostante è composto da campi designati di qualsiasi tipo di dati SQL supportato.
```
WITH dataset AS (
SELECT
ROW('Bob', 38) AS users
)
SELECT * FROM dataset
```
Questa query restituisce:
```
+-------------------------+
| users |
+-------------------------+
| {field0=Bob, field1=38} |
+-------------------------+
```
# Modificare i nomi di campo nelle matrici utilizzando `CAST`
Per modificare il nome di campo in una matrice che contiene valori `ROW`, è possibile utilizzare `CAST` per l'istruzione `ROW`:
```
WITH dataset AS (
SELECT
CAST(
ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)
) AS users
)
SELECT * FROM dataset
```
Questa query restituisce:
```
+--------------------+
| users |
+--------------------+
| {NAME=Bob, AGE=38} |
+--------------------+
```
**Nota**
Nell'esempio sopra riportato, si dichiara `name` come `VARCHAR`, perché è il suo tipo in Presto. Se dichiari questo `STRUCT` all'interno di un'istruzione `CREATE TABLE`, utilizza il tipo `String`, perché Hive definisce questo tipo di dati come `String`.
# Filtrare le matrici utilizzando la notazione `.`
Nell'esempio seguente, seleziona il `accountId` campo dalla `userIdentity` colonna di una tabella di AWS CloudTrail log utilizzando la `.` notazione a punti. Per ulteriori informazioni, vedere [AWS CloudTrail Interrogazione](cloudtrail-logs.md) dei registri.
```
SELECT
CAST(useridentity.accountid AS bigint) as newid
FROM cloudtrail_logs
LIMIT 2;
```
Questa query restituisce:
```
+--------------+
| newid |
+--------------+
| 112233445566 |
+--------------+
| 998877665544 |
+--------------+
```
Per eseguire query di una matrice di valori, invia questa query:
```
WITH dataset AS (
SELECT ARRAY[
CAST(ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Alice', 35) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Jane', 27) AS ROW(name VARCHAR, age INTEGER))
] AS users
)
SELECT * FROM dataset
```
Tale operazione restituisce questo risultato:
```
+-----------------------------------------------------------------+
| users |
+-----------------------------------------------------------------+
| [{NAME=Bob, AGE=38}, {NAME=Alice, AGE=35}, {NAME=Jane, AGE=27}] |
+-----------------------------------------------------------------+
```
# Filtrare le matrici con valori nidificati
Le matrici di grandi dimensioni spesso contengono strutture nidificate ed è necessario essere in grado di filtrare o cercare i valori all'interno di tali matrici.
Per definire un set di dati per una matrice di valori che include un valore `BOOLEAN` nidificato, emetti la query seguente:
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT * FROM dataset
```
Tale operazione restituisce questo risultato:
```
+----------------------------------------------------------+
| sites |
+----------------------------------------------------------+
| {HOSTNAME=aws.amazon.com, FLAGGEDACTIVITY={ISNEW=true}} |
+----------------------------------------------------------+
```
Quindi, per filtrare e individuare il valore `BOOLEAN` di tale elemento, continua a utilizzare la notazione `.`.
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT sites.hostname, sites.flaggedactivity.isnew
FROM dataset
```
Questa query seleziona i campi nidificati e restituisce questo risultato:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Filtrare le matrici utilizzando `UNNEST`
Per filtrare una matrice che include una struttura nidificata in base a uno dei suoi elementi figlio, invia una query con un operatore `UNNEST`. Per ulteriori informazioni su `UNNEST`, consulta la sezione relativa all'[appiattimento delle matrici nidificate](flattening-arrays.md).
Ad esempio, questa query individua nomi host dei siti nel set di dati.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('news.cnn.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('netflix.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
)
] as items
)
SELECT sites.hostname, sites.flaggedActivity.isNew
FROM dataset, UNNEST(items) t(sites)
WHERE sites.flaggedActivity.isNew = true
```
Restituisce:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Cercare parole chiave nelle matrici utilizzando `regexp_like`
I seguenti esempi illustrano come cercare una parola chiave in un set di dati in un elemento all'interno di una matrice, utilizzando la funzione [regexp\$1like](https://prestodb.io/docs/current/functions/regexp.html). Come input prende in considerazione un modello di espressione regolare da analizzare o un elenco di termini separati da una barra verticale (\$1), valuta i modelli e determina se la stringa specificata li contiene.
L'espressione regolare deve essere contenuta all'interno della stringa e non deve corrispondere con essa. Affinché corrisponda all'intera stringa, racchiudi il motivo con ^ all'inizio e \$1 al termine, ad esempio `'^pattern$'`.
Considera una matrice di siti contenenti il loro nome host e un elemento `flaggedActivity`. Tale elemento include una `ARRAY` che a sua volta contiene diversi elementi `MAP`, ciascuno dei quali elenca diverse parole chiave comuni e il relativo conteggio popolarità. Supponi di voler trovare una determinata parola chiave all'interno di una `MAP` in questa matrice.
Per cercare questo set di dati per i siti con una parola chiave specifica, utilizziamo `regexp_like` anziché l'operatore `LIKE` SQL simile, perché la ricerca di un numero elevato di parole chiave è più efficiente con `regexp_like`.
**Example Esempio 1: utilizzo di `regexp_like`**
La query in questo esempio utilizza la funzione `regexp_like` per cercare termini `'politics|bigdata'`, ubicati nei valori all'interno delle matrici:
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
```
Questa query restituisce due siti:
```
+----------------+
| hostname |
+----------------+
| aws.amazon.com |
+----------------+
| news.cnn.com |
+----------------+
```
**Example Esempio 2: utilizzo di `regexp_like`**
La query nell'esempio seguente aggiunge il punteggio totale di popolarità per i siti che soddisfano i termini di ricerca con la funzione `regexp_like`, quindi li ordina dal più alto al più basso.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname, array_agg(flags['term']) AS terms, SUM(CAST(flags['count'] AS INTEGER)) AS total
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
ORDER BY total DESC
```
Questa query restituisce due siti:
```
+------------------------------------+
| hostname | terms | total |
+----------------+-------------------+
| news.cnn.com | politics | 241 |
+----------------+-------------------+
| aws.amazon.com | bigdata | 10 |
+----------------+-------------------+
```