Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Regla de análisis de lista
<a name="analysis-rules-list"></a>

En AWS Clean Rooms, una *regla de análisis de listas* genera listas a nivel de fila de la superposición entre la tabla configurada a la que se agrega y las tablas configuradas del miembro que puede realizar la consulta. El miembro que puede realizar consultas ejecuta consultas que incluyen una regla de análisis de lista.

El tipo de regla de análisis de listas admite casos de uso como el enriquecimiento y la creación de audiencia. 

Para obtener más información sobre la estructura y la sintaxis de consulta predefinidas de esta regla de análisis, consulte [Estructura predefinida de la regla de análisis de lista](#intersection-list-params-template).

Los parámetros de la regla de análisis de lista, que se define en [Regla de análisis de lista: controles de consulta](#parameters-list-query-controls), tienen controles de consulta. Estos controles de consulta incluyen la posibilidad de seleccionar las columnas que se pueden enumerar en la salida. La consulta debe tener al menos una combinación con una tabla configurada del miembro que puede realizar consultas, ya sea de forma directa o transitiva.

No hay controles de resultados de consulta como los que existen para la [regla de análisis de agregación](analysis-rules-aggregation.md). 

Las consultas de lista solo pueden utilizar operadores matemáticos. No pueden usar otras funciones (por ejemplo, de agregación o escalares).

**Topics**
+ [Estructura y sintaxis de las consultas de lista](#list-query-controls)
+ [Regla de análisis de lista: controles de consulta](#parameters-list-query-controls)
+ [Estructura predefinida de la regla de análisis de lista](#intersection-list-params-template)
+ [Regla de análisis de lista: ejemplo](#list-example)

## Estructura y sintaxis de las consultas de lista
<a name="list-query-controls"></a>

Las consultas de las tablas que tienen una regla de análisis de lista deben respetar la siguiente sintaxis. 

```
--{{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]
```

En la siguiente tabla se explica cada una de las expresiones enumeradas en la sintaxis anterior. 


| Expression | Definición | Ejemplos | 
| --- | --- | --- | 
| {{select\_list\_expression}} | Una lista separada por comas que contiene al menos un nombre de columna de tabla.<br />Es obligatorio un parámetro `DISTINCT`.  La `select_list_expression` pueden asignar un alias a las columnas con o sin el parámetro `AS`.  <br />Para obtener más información, consulte [Referencia de SQL de AWS Clean Rooms](https://docs.aws.amazon.com/clean-rooms/latest/sql-reference/sql-reference.html).  | `SELECT DISTINCT segment` | 
| {{table\_expression}} | Una tabla, o combinación de tablas, con `join_condition` para conectarla a `join_condition`. <br />`join_condition` devuelve un valor booleano. <br />La `table_expression` admite:[See the AWS documentation website for more details](http://docs.aws.amazon.com/es_es/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\_expression}} | Una expresión condicional que devuelve un valor booleano. Puede constar de los siguientes elementos:[See the AWS documentation website for more details](http://docs.aws.amazon.com/es_es/clean-rooms/latest/userguide/analysis-rules-list.html)Las condiciones de comparación admitidas son (`=, >, <, <=, >=, <>, !=, NOT, IN, NOT IN, LIKE, IS NULL, IS NOT NULL`). <br />Los operadores lógicos admitidos son (`AND, OR`).<br />La `where_expression` es opcional. | `WHERE state + '_' + city = 'NY_NYC'`<br />`WHERE timestampColumn = timestampColumn2 - 14`  | 
| {{limit\_expression}} | Esta expresión debe tener adoptar un entero positivo.<br />La `limit_expression` es opcional.  | `LIMIT 100` | 

En cuanto a la estructura y sintaxis de las consultas de lista, tenga en cuenta lo siguiente:
+ No se admiten comandos SQL distintos de SELECT.
+ No se admiten subconsultas ni expresiones de tabla comunes (por ejemplo, WITH).
+ No se admiten las cláusulas HAVING, GROUP BY ni ORDER BY.
+ No se admite el parámetro OFFSET.

## Regla de análisis de lista: controles de consulta
<a name="parameters-list-query-controls"></a>

Los controles de consulta de lista le permiten controlar cómo se utilizan las columnas de su tabla a la hora de consultar esta última. Por ejemplo, puede controlar qué columna se usa para combinar, o qué columna se puede usar en una instrucción SELECT y en una cláusula WHERE.

En las secciones siguientes se explica cada uno de los controles.

**Topics**
+ [Controles de combinación](#list-controls-join-controls)
+ [Controles de lista](#list-controls)

### Controles de combinación
<a name="list-controls-join-controls"></a>

Los *controles de combinación* le permiten controlar cómo se puede combinar su tabla a otras tablas en la **table\_expression**. AWS Clean Rooms solo admite INNER JOIN. En la regla de análisis de lista, se requiere al menos una INNER JOIN, y el miembro que puede realizar consultas debe incluir una tabla de su propiedad en la INNER JOIN. Esto significa que deben combinar su tabla con la suya, ya sea de forma directa o transitiva.

A continuación se muestra un ejemplo de transitividad.

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

Las instrucciones INNER JOIN solo pueden usar columnas que se hayan categorizado explícitamente como `joinColumn` en la regla de análisis. 

La instrucción INNER JOIN debe operar en una `joinColumn` de su tabla configurada y en una `joinColumn` de otra tabla configurada de la colaboración. Usted decide qué columnas de la tabla se pueden usar como `joinColumn`. 

Cada condición de coincidencia de la cláusula ON debe utilizar la condición de comparación de igualdad (`=`) entre dos columnas. 

Las condiciones de coincidencia múltiples dentro de una cláusula ON pueden ser:
+ Combinación con el operador lógico `AND`
+ Separación mediante el operador lógico `OR`

**nota**  
Todas las condiciones de coincidencia JOIN deben coincidir con una fila de cada lado de JOIN. Todos los condicionales conectados por un operador lógico `OR` o `AND` también deben cumplir este requisito.

A continuación se muestra un ejemplo de consulta con un operador lógico `AND`.

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

A continuación se muestra un ejemplo de consulta con un operador lógico `OR`.

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


| Control | Definición | De uso | 
| --- | --- | --- | 
| joinColumns | Las columnas que se desea permitir que el miembro que puede realizar consultas utilice en la instrucción INNER JOIN. | Una misma columna no se puede categorizar como `joinColumn` y `listColumn` a la vez (consulte [Controles de lista](#list-controls)).<br />`joinColumn` no se puede usar en ninguna otra parte de la consulta que no sea INNER JOIN. | 

### Controles de lista
<a name="list-controls"></a>

Los *controles de lista* controlan las columnas que se pueden mostrar en el resultado de la consulta (es decir, que se pueden usar en la instrucción SELECT) o que se pueden usar para filtrar los resultados (es decir, que se pueden usar en la instrucción WHERE).


| Control | Definición | De uso | 
| --- | --- | --- | 
| listColumns | Las columnas que se permite que el miembro que puede realizar consultas utilice en SELECT y WHERE | Se puede usar una listColumn en SELECT y WHERE.Una misma columna no se puede usar como `listColumn` y `joinColumn` a la vez. | 

## Estructura predefinida de la regla de análisis de lista
<a name="intersection-list-params-template"></a>

El siguiente ejemplo incluye una estructura predefinida que muestra cómo completar una regla de análisis de lista. 

En el siguiente ejemplo, {{`MyTable`}} hace referencia a nuestra tabla de datos. Puede reemplazar cada una de ellas {{user input placeholder}} con su propia información. 

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

## Regla de análisis de lista: ejemplo
<a name="list-example"></a>

El siguiente ejemplo demuestra cómo dos empresas pueden colaborar en el AWS Clean Rooms uso del análisis de listas.

La empresa A dispone de datos de administración de las relaciones con los clientes (CRM). La empresa A desea obtener datos de segmento adicionales sobre sus clientes para conocer mejor a estos últimos y, posiblemente, utilizar los atributos como entrada en otros análisis. La empresa B tiene datos de segmento compuestos por atributos de segmento únicos que creó basándose en sus datos de primera parte. La empresa B desea proporcionar los atributos de segmento únicos a la empresa A solo para aquellos clientes que se superponen entre sus datos y los datos de la empresa A. 

Las empresas deciden colaborar para que la empresa A pueda enriquecer los datos superpuestos. La empresa A es el miembro que puede realizar consultas y la empresa B es el colaborador.

Para crear una colaboración y ejecutar en ella un análisis de lista, las empresas hacen lo siguiente: 

1. La empresa A crea una colaboración y crea una pertenencia. La colaboración tiene a la empresa B como un miembro más de la colaboración. La empresa A habilita el registro de consultas en la colaboración y habilita el registro de consultas en su cuenta. 

1. La empresa B crea una pertenencia en la colaboración. Habilita el registro de consultas en su cuenta. 

1. La empresa A crea una tabla configurada de CRM.

1. La empresa A agrega la regla de análisis a la tabla configurada por el cliente, como se muestra en el siguiente ejemplo.

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

   `joinColumns`— La empresa A quiere utilizarla `hashedemail` and/or `thirdpartyid` (obtenida de un proveedor de identidad) para hacer coincidir los clientes a partir de los datos de CRM con los clientes a partir de los datos segmentados. Esto ayudará a garantizar que la empresa A relacione los datos enriquecidos con los clientes correctos. Tienen dos JoinColumns para mejorar potencialmente la tasa de coincidencia del análisis. 

   `listColumns`: la empresa A usa `listColumns` para obtener columnas enriquecidas junto con un `internalid` que utiliza en sus propios sistemas. Añade `segment1`, `segment2` y `customercategory` para, potencialmente, limitar el enriquecimiento a segmentos específicos mediante su uso en filtros. 

1. La empresa B crea una tabla configurada de segmento.

1. La empresa B añade la regla de análisis a la tabla configurada por de segmento. 

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

   `joinColumns`: la empresa B permite a la empresa A combinarse con `identifier2` para relacionar a los clientes de los datos de segmento con los datos de CRM. La empresa A y la empresa B trabajaron con el proveedor de identidades para obtener un `identifier2` que se ajustara a la colaboración. No añadieron otras `joinColumns` porque creían que `identifier2` proporciona la tasa de coincidencia más alta y precisa y que no se precisaban otros identificadores para las consultas. 

   `listColumns`: la empresa B permite a la empresa A enriquecer sus datos con los atributos `segment3` y `segment4`, que son atributos únicos que han creado, recopilado y alineado en (con el cliente A) para formar parte del enriquecimiento de datos. Quieren que la empresa A obtenga estos segmentos para solaparlos a nivel de fila, ya que se trata de una colaboración de enriquecimiento de datos. 

1. La empresa A crea una asociación a la tabla de CRM en la colaboración.

1. La empresa B crea una asociación a la tabla de segmento en la colaboración.

1. La empresa A ejecuta consultas, como la siguiente, para enriquecer los datos de clientes que se solapan. 

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

1. La empresa A y la empresa B revisan los registros de consultas. La empresa B comprueba que la consulta se ajusta a lo acordado en el contrato de colaboración.