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à.

# Regola di analisi delle liste
<a name="analysis-rules-list"></a>

In AWS Clean Rooms, una *regola di analisi degli elenchi* genera elenchi a livello di riga della sovrapposizione tra la tabella configurata a cui viene aggiunta e le tabelle configurate del membro che può eseguire la query. Il membro che può eseguire query esegue query che includono una regola di analisi dell'elenco.

Il tipo di regola di analisi degli elenchi supporta casi d'uso come l'arricchimento e la creazione di audience. 

Per ulteriori informazioni sulla struttura e sulla sintassi delle query predefinite per questa regola di analisi, vedere. [Struttura predefinita della regola di analisi delle liste](#intersection-list-params-template)

I parametri della regola di analisi dell'elenco, definita in[Regola di analisi delle liste: controlli di interrogazione](#parameters-list-query-controls), dispongono di controlli di interrogazione. I suoi controlli di interrogazione includono la possibilità di selezionare le colonne che possono essere elencate nell'output. La query deve avere almeno un join con una tabella configurata dal membro che può eseguire la query, direttamente o in modo transitivo.

Non esistono controlli sui risultati delle query come quelli per la regola di [analisi di aggregazione](analysis-rules-aggregation.md). 

Le query di elenco possono utilizzare solo operatori matematici. Non possono utilizzare altre funzioni (come l'aggregazione o lo scalare).

**Topics**
+ [Elenca la struttura e la sintassi delle interrogazioni](#list-query-controls)
+ [Regola di analisi delle liste: controlli di interrogazione](#parameters-list-query-controls)
+ [Struttura predefinita della regola di analisi delle liste](#intersection-list-params-template)
+ [Regola di analisi delle liste: esempio](#list-example)

## Elenca la struttura e la sintassi delle interrogazioni
<a name="list-query-controls"></a>

Le interrogazioni su tabelle che dispongono di una regola di analisi degli elenchi devono rispettare la sintassi seguente. 

```
--select_list_expression
SELECT DISTINCT column_name [[AS] column_alias ] [, ...] 

--table_expression
FROM table_name [[AS] table_alias ]
  [[INNER] JOIN table_name [[AS] table_alias] ON join_condition] [...]

--where_expression
[WHERE where_condition]          

--limit_expression
[LIMIT number]
```

Nella tabella seguente vengono illustrate tutte le espressioni elencate nella sintassi precedente. 


| Expression | Definizione | Esempi | 
| --- | --- | --- | 
| select\$1list\$1expression |  Un elenco separato da virgole contenente almeno il nome di una colonna della tabella. È richiesto un `DISTINCT` parametro.   Le colonne `select_list_expression` possono essere utilizzate come alias con o senza il `AS` parametro.  Per ulteriori informazioni, vedere [AWS Clean Rooms SQL Reference.](https://docs.aws.amazon.com/clean-rooms/latest/sql-reference/sql-reference.html)   |  `SELECT DISTINCT segment`  | 
| table\$1expression |  Una tabella, o unione di tabelle, `join_condition` a cui connetterla`join_condition`.  `join_condition`restituisce un valore booleano.  I `table_expression` supporti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/userguide/analysis-rules-list.html)  |  <pre>FROM consumer_table <br />INNER JOIN provider_table<br />ON<br />consumer_table.identifier1 = provider_table.identifier1<br />AND<br />consumer_table.identifier2 = provider_table.identifier2</pre>  | 
| where\$1expression | Un'espressione condizionale che restituisce un valore booleano. Può essere composta dai seguenti elementi:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/clean-rooms/latest/userguide/analysis-rules-list.html)Le condizioni di confronto supportate sono ()`=, >, <, <=, >=, <>, !=, NOT, IN, NOT IN, LIKE, IS NULL, IS NOT NULL`. Gli operatori logici supportati sono (`AND, OR`).Il `where_expression` è facoltativo. |  `WHERE state + '_' + city = 'NY_NYC'` `WHERE timestampColumn = timestampColumn2 - 14`   | 
| limit\$1expression |  Questa espressione deve assumere un numero intero positivo. Il `limit_expression` è facoltativo.   |  `LIMIT 100`  | 

Per quanto riguarda la struttura e la sintassi delle query di elenco, tenete presente quanto segue:
+ I comandi SQL diversi da SELECT non sono supportati.
+ Le sottoquery e le espressioni di tabella comuni (ad esempio,WITH) non sono supportate
+ Le BY clausole GROUP BY HAVING e ORDER non sono supportate
+ Il parametro OFFSET non è supportato

## Regola di analisi delle liste: controlli di interrogazione
<a name="parameters-list-query-controls"></a>

Con i controlli di interrogazione degli elenchi, puoi controllare come le colonne della tabella vengono utilizzate per interrogare la tabella. Ad esempio, è possibile controllare quale colonna viene utilizzata per l'unione o quale colonna può essere utilizzata nell'istruzione e nella WHERE clausola SELECT.

Le seguenti sezioni spiegano ogni controllo.

**Topics**
+ [Unisci i controlli](#list-controls-join-controls)
+ [Elenca i controlli](#list-controls)

### Unisci i controlli
<a name="list-controls-join-controls"></a>

Con *i controlli Join*, puoi controllare come la tua tabella può essere unita ad altre tabelle in **table\$1expression**. AWS Clean Rooms supporta solo JOIN. INNER Nella regola di analisi dell'elenco, è richiesto almeno un INNER JOIN e il membro che può eseguire la query deve includere una tabella di sua proprietà nel INNER JOIN. Ciò significa che devono unire il tuo tavolo al loro, direttamente o transitivamente.

Di seguito è riportato un esempio di transitività.

```
ON 
my_table.identifer = third_party_table.identifier 
.... 
ON 
third_party_table.identifier = member_who_can_query_table.id
```

INNERLe istruzioni JOIN possono utilizzare solo colonne che sono state esplicitamente classificate come una delle regole di `joinColumn` analisi. 

Il INNER JOIN deve funzionare su una `joinColumn` tabella configurata e su un'altra tabella configurata nella collaborazione. `joinColumn` Sei tu a decidere quali colonne della tua tabella possono essere utilizzate come`joinColumn`. 

Ogni condizione di corrispondenza all'interno della ON clausola è richiesta per utilizzare la condizione di confronto di uguaglianza (`=`) tra due colonne. 

Le condizioni di corrispondenza multiple all'interno di una ON clausola possono essere:
+ Combinato utilizzando l'operatore `AND` logico
+ Separato utilizzando l'operatore `OR` logico

**Nota**  
Tutte le JOIN condizioni di partita devono corrispondere a una riga su ciascun lato delJOIN. Anche tutti i condizionali collegati da un operatore logico `OR` o da un operatore `AND` logico devono rispettare questo requisito.

Di seguito è riportato un esempio di interrogazione con un operatore logico`AND`.

```
SELECT some_col, other_col 
FROM table1 
    JOIN table2 
    ON table1.id = table2.id AND table1.name = table2.name
```

Di seguito è riportato un esempio di interrogazione con un operatore `OR` logico.

```
SELECT some_col, other_col 
FROM table1 
    JOIN table2 
    ON table1.id = table2.id OR table1.name = table2.name
```


| Controllo | Definizione | Utilizzo | 
| --- | --- | --- | 
| joinColumns | Le colonne che si desidera consentire al membro che può eseguire la query di utilizzare nell'istruzione INNER JOIN. |  La stessa colonna non può essere classificata sia come a `joinColumn` che come `listColumn` (vedi[Elenca i controlli](#list-controls)). `joinColumn`non può essere utilizzato in altre parti della query diverse da INNER JOIN.  | 

### Elenca i controlli
<a name="list-controls"></a>

*I controlli elenco* controllano le colonne che possono essere elencate nell'output della query (ovvero utilizzate nell'istruzione SELECT) o utilizzate per filtrare i risultati (ovvero utilizzate nell'WHEREistruzione).


| Controllo | Definizione | Utilizzo | 
| --- | --- | --- | 
| listColumns | Le colonne che consentite al membro che può eseguire la query di utilizzare nell'istruzione SELECT e WHERE | A listColumn può essere utilizzato in SELECT eWHERE.La stessa colonna non può essere utilizzata sia come che come `listColumn``joinColumn`. | 

## Struttura predefinita della regola di analisi delle liste
<a name="intersection-list-params-template"></a>

L'esempio seguente include una struttura predefinita che mostra come completare una regola di analisi degli elenchi. 

Nell'esempio seguente, *`MyTable`* fa riferimento alla tabella di dati. È possibile sostituire ciascuno di essi *user input placeholder* con le proprie informazioni. 

```
{
  "joinColumns": [MyTable column name(s)],
  "listColumns": [MyTable column name(s)],
}
```

## Regola di analisi delle liste: esempio
<a name="list-example"></a>

L'esempio seguente dimostra come due aziende possono collaborare AWS Clean Rooms utilizzando l'analisi delle liste.

L'azienda A dispone di dati sulla gestione delle relazioni con i clienti (CRM). L'azienda A desidera ottenere dati di segmento aggiuntivi sui propri clienti per saperne di più sui propri clienti e potenzialmente utilizzare gli attributi come input per altre analisi. L'azienda B dispone di dati sui segmenti composti da attributi di segmento unici creati sulla base dei dati di prima parte. La società B desidera fornire gli attributi univoci del segmento alla società A solo ai clienti che si sovrappongono tra i loro dati e i dati dell'azienda A. 

Le aziende decidono di collaborare in modo che l'azienda A possa arricchire i dati sovrapposti. La società A è il socio che può effettuare le domande e la società B è il collaboratore.

Per creare una collaborazione ed eseguire l'analisi degli elenchi in collaborazione, le aziende eseguono le seguenti operazioni: 

1. L'azienda A crea una collaborazione e crea un'iscrizione. La collaborazione ha l'azienda B come altro membro della collaborazione. La società A consente la registrazione delle interrogazioni nella collaborazione e la registrazione delle interrogazioni nel proprio account. 

1. L'azienda B crea un'appartenenza alla collaborazione. Consente la registrazione delle interrogazioni nel proprio account. 

1. L'azienda A crea una tabella configurata con CRM

1. La società A aggiunge la regola di analisi alla tabella configurata dal cliente, come mostrato nell'esempio seguente.

   ```
   {
     "joinColumns": [
       "identifier1",
       "identifier2"
     ],
     "listColumns": [
       "internalid",
       "segment1",
       "segment2",
       "customercategory"
     ]
   }
   ```

   `joinColumns`— La società A desidera utilizzare `hashedemail` and/or `thirdpartyid` (ottenuto da un fornitore di identità) per abbinare i clienti dei dati CRM ai clienti dei dati del segmento. Ciò contribuirà a garantire che l'azienda A abbini dati arricchiti per i clienti giusti. Dispongono di due JoinColumns per migliorare potenzialmente il tasso di corrispondenza dell'analisi. 

   `listColumns`— La società A le utilizza `listColumns` accanto per ottenere colonne arricchite e `internalid` le utilizza all'interno dei propri sistemi. `segment1`Aggiungono `segment2` e `customercategory` potenzialmente limitano l'arricchimento a segmenti specifici utilizzandoli nei filtri. 

1. La società B crea una tabella configurata per segmenti.

1. La società B aggiunge la regola di analisi alla tabella configurata del segmento. 

   ```
   {
     "joinColumns": [
       "identifier2"
     ],
     "listColumns": [
       "segment3",
       "segment4"
     ]
   }
   ```

   `joinColumns`— La società B consente all'azienda A di partecipare `identifier2` per abbinare i clienti dai dati del segmento ai dati CRM. La società A e la società B hanno collaborato con il fornitore di identità per ottenere `identifier2` una soluzione adatta a questa collaborazione. Non ne hanno aggiunti altri `joinColumns` perché ritenevano che `identifier2` fornisse il tasso di corrispondenza più elevato e preciso e non fossero necessari altri identificatori per le query. 

   `listColumns`— L'azienda B consente all'azienda A di arricchire i propri dati con `segment3` `segment4` attributi unici che ha creato, raccolto e utilizzato (con il cliente A) per contribuire all'arricchimento dei dati. Vogliono che l'azienda A ottenga questi segmenti per la sovrapposizione a livello di riga perché si tratta di una collaborazione per l'arricchimento dei dati. 

1. L'azienda A crea un'associazione di tabelle CRM alla collaborazione.

1. La società B crea un'associazione di tabelle di segmenti alla collaborazione.

1. L'azienda A esegue interrogazioni, come la seguente, per arricchire i dati sovrapposti dei clienti. 

   ```
   SELECT companyA.internalid, companyB.segment3, companyB.segment4
   INNER JOIN returns companyB
    ON companyA.identifier2 = companyB.identifier2
   WHERE companyA.customercategory > 'xxx'
   ```

1. L'azienda A e la società B esaminano i registri delle interrogazioni. La società B verifica che la richiesta sia in linea con quanto concordato nell'accordo di collaborazione.