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à. # Interrogazione di dati annidati AWS Clean Rooms offre un accesso compatibile con SQL ai dati relazionali e annidati. AWS Clean Rooms utilizza la notazione punteggiata e l'array subscript per la navigazione dei percorsi quando si accede ai dati annidati. Inoltre, abilita il FROM elementi di clausola da iterare sugli array e utilizzare per operazioni di disaggregazione. I seguenti argomenti forniscono le descrizioni dei diversi modelli di interrogazione che combinano l'uso del tipo di array/struct/map dati con la navigazione tra percorsi e array, l'unnesting e i join. **Topics** + [Navigazione](#navigation) + [Annullamento di query](#unnesting-queries) + [Semantica permissiva](#lax-semantics) + [Tipi di introspezione](#types-of-introspection) ## Navigazione AWS Clean Rooms consente la navigazione in matrici e strutture utilizzando rispettivamente la notazione `[...]` tra parentesi e punti. Inoltre, è possibile combinare la navigazione in strutture utilizzando la notazione a punti e gli array utilizzando la notazione con parentesi. **Example** Ad esempio, la seguente query di esempio presuppone che la colonna di dati dell'`c_orders`array sia una matrice con una struttura e un attributo è denominato. `o_orderkey` ``` SELECT cust.c_orders[0].o_orderkey FROM customer_orders_lineitem AS cust; ``` È possibile utilizzare le notazioni con punti e parentesi in tutti i tipi di query, ad esempio filtraggio, join e aggregazione. È possibile utilizzare queste notazioni in una query in cui ci sono normalmente riferimenti di colonna. **Example** Nell'esempio seguente viene utilizzata un'istruzione SELECT che filtra i risultati. ``` SELECT count(*) FROM customer_orders_lineitem WHERE c_orders[0].o_orderkey IS NOT NULL; ``` **Example** Nell'esempio seguente viene utilizzata la navigazione con parentesi e punti nelle clausole GROUP BY e ORDER BY. ``` SELECT c_orders[0].o_orderdate, c_orders[0].o_orderstatus, count(*) FROM customer_orders_lineitem WHERE c_orders[0].o_orderkey IS NOT NULL GROUP BY c_orders[0].o_orderstatus, c_orders[0].o_orderdate ORDER BY c_orders[0].o_orderdate; ``` ## Annullamento di query Per annullare le interrogazioni, AWS Clean Rooms abilita l'iterazione sugli array. Lo fa navigando nell'array utilizzando la clausola FROM di una query. **Example** Utilizzando l'esempio precedente, nell'esempio seguente vengono eseguite interazioni sui valori dell'attributo per `c_orders`. ``` SELECT o FROM customer_orders_lineitem c, c.c_orders o; ``` La sintassi di annullamento nidificazione è un'estensione della clausola FROM. In SQL standard, la clausola FROM `x (AS) y` significa che in `y` vengono eseguite iterazioni su ogni tupla in relazione `x`. In questo caso, `x` si riferisce a una relazione e `y` si riferisce a un alias per relazione `x`. Allo stesso modo, la sintassi di unnesting che utilizza l'elemento della clausola FROM `x (AS) y` significa che `y` esegue un'iterazione su ogni valore nell'espressione dell'array. `x` In questo caso, `x` è un'espressione di matrice ed `y` è un alias per. `x` Per la navigazione regolare, con l'operando sinistro si può anche utilizzare la notazione con punti e parentesi. **Example** Nell'esempio precedente: + `customer_orders_lineitem c`è l'iterazione sulla tabella di `customer_order_lineitem` base + `c.c_orders o`è l'iterazione su `c.c_orders array` Per eseguire iterazioni sull'attributo `o_lineitems`, che è un array all'interno di un array, si aggiungono più clausole. ``` SELECT o, l FROM customer_orders_lineitem c, c.c_orders o, o.o_lineitems l; ``` AWS Clean Rooms supporta anche un indice di matrice quando si esegue l'iterazione sull'array utilizzando il AT parola chiave. La clausola esegue un'`x AS y AT z`iterazione sull'array `x` e genera il campo`z`, che è l'indice dell'array. **Example** Nell'esempio seguente viene illustrato il funzionamento di un indice di array: ``` SELECT c_name, orders.o_orderkey AS orderkey, index AS orderkey_index FROM customer_orders_lineitem c, c.c_orders AS orders AT index ORDER BY orderkey_index; c_name | orderkey | orderkey_index -------------------+----------+---------------- Customer#000008251 | 3020007 | 0 Customer#000009452 | 4043971 | 0 (2 rows) ``` **Example** Nell'esempio seguente sono eseguite iterazioni su un array scalare. ``` CREATE TABLE bar AS SELECT json_parse('{"scalar_array": [1, 2.3, 45000000]}') AS data; SELECT index, element FROM bar AS b, b.data.scalar_array AS element AT index; index | element -------+---------- 0 | 1 1 | 2.3 2 | 45000000 (3 rows) ``` **Example** Nell'esempio seguente viene eseguita un'iterazione su un array di più livelli. L'esempio utilizza più clausole unnest per eseguire l'iterazione negli array più interni. Il `f.multi_level_array` AS l'array ripete. `multi_level_array` L'array AS elemento è l'iterazione sugli array all'interno. `multi_level_array` ``` CREATE TABLE foo AS SELECT json_parse('[[1.1, 1.2], [2.1, 2.2], [3.1, 3.2]]') AS multi_level_array; SELECT array, element FROM foo AS f, f.multi_level_array AS array, array AS element; array | element -----------+--------- [1.1,1.2] | 1.1 [1.1,1.2] | 1.2 [2.1,2.2] | 2.1 [2.1,2.2] | 2.2 [3.1,3.2] | 3.1 [3.1,3.2] | 3.2 (6 rows) ``` ## Semantica permissiva Per impostazione predefinita, le operazioni di navigazione sui valori di dati annidati restituiscono null anziché restituire un errore quando la navigazione non è valida. La navigazione tra oggetti non è valida se il valore dei dati nidificati non è un oggetto o se il valore dei dati nidificati è un oggetto ma non contiene il nome dell'attributo utilizzato nella query. **Example** Ad esempio, la seguente query accede a un nome di attributo non valido nella colonna di dati nidificati: `c_orders` ``` SELECT c.c_orders.something FROM customer_orders_lineitem c; ``` La navigazione tra matrici restituisce null se il valore dei dati annidati non è un array o l'indice dell'array non è compreso nei limiti. **Example** La seguente query restituisce null perché `c_orders[1][1]` è fuori dai limiti. ``` SELECT c.c_orders[1][1] FROM customer_orders_lineitem c; ``` ## Tipi di introspezione Le colonne con tipi di dati annidati supportano funzioni di ispezione che restituiscono il tipo e altri tipi di informazioni relative al valore. AWS Clean Rooms supporta le seguenti funzioni booleane per le colonne di dati annidate: + DECIMAL\$1PRECISION + DECIMAL\$1SCALE + IS\$1ARRAY + IS\$1BIGINT + IS\$1CHAR + IS\$1DECIMAL + IS\$1FLOAT + IS\$1INTEGER + IS\$1OBJECT + IS\$1SCALARE + IS\$1SMALLINT + IS\$1VARCHAR + JSON\$1TYPEOF Tutte queste funzioni restituiscono false se il valore di input è null. IS\$1SCALAR, IS\$1OBJECT e IS\$1ARRAY si escludono a vicenda e coprono tutti i valori possibili ad eccezione di null. Per dedurre i tipi corrispondenti ai dati, AWS Clean Rooms utilizza la funzione JSON\$1TYPEOF che restituisce il tipo (il livello più alto del) valore dei dati annidati, come mostrato nell'esempio seguente: ``` SELECT JSON_TYPEOF(r_nations) FROM region_nations; json_typeof ------------- array (1 row) ``` ``` SELECT JSON_TYPEOF(r_nations[0].n_nationkey) FROM region_nations; json_typeof ------------- number ```