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.
# SELECT
El comando SELECT devuelve filas de tablas y funciones definidas por el usuario.
AWS Clean Rooms Spark SQL admite los siguientes comandos, cláusulas y operadores de conjuntos SELECT SQL:
**Topics**
+ [SELECT list](sql-function-select-list-spark.md)
+ [Cláusula WITH](WITH_clause.md)
+ [Cláusula FROM](FROM_clause30.md)
+ [Cláusula JOIN](join-clause.md)
+ [Cláusula WHERE](WHERE_clause.md)
+ [cláusula VALUES](VALUES.md)
+ [Cláusula GROUP BY](GROUP_BY_clause.md)
+ [Cláusula HAVING](HAVING_clause.md)
+ [Operadores de establecimiento](UNION.md)
+ [Cláusula ORDER BY](ORDER_BY_clause.md)
+ [Ejemplos de subconsultas](Subquery_examples.md)
+ [Subconsultas correlacionadas](correlated_subqueries.md)
La sintaxis, los argumentos y algunos ejemplos provienen de la [Referencia SQL de Apache Spark](https://spark.apache.org/docs/latest/api/sql/).
# SELECT list
La SELECT list designa las columnas, funciones y expresiones que se desea que devuelva la consulta. La lista representa el resultado de la consulta.
## Sintaxis
```
SELECT
[ DISTINCT ] | expression [ AS column_alias ] [, ...]
```
## Parameters
DISTINCT
Opción que elimina las filas duplicadas del conjunto de resultados basándose en los valores coincidentes de una o más columnas.
*expression*
Una expresión formada a partir de una o más columnas que existen en las tablas a las que hace referencia la consulta. Una expresión puede contener funciones SQL. Por ejemplo:
```
coalesce(dimension, 'stringifnull') AS column_alias
```
AS column\$1alias
Un nombre temporal para la columna que se utiliza en el conjunto de resultados finales. La palabra clave AS es opcional. Por ejemplo:
```
coalesce(dimension, 'stringifnull') AS dimensioncomplete
```
Si no se especifica un alias para una expresión que no sea un nombre de columna simple, el conjunto de resultados aplica un nombre predeterminado a esa columna.
**nota**
El alias se reconoce justo después de definirlo en la lista de destino. No puedes usar un alias en otras expresiones definidas después de este en la misma lista de objetivos.
# Cláusula WITH
Una cláusula WITH es una cláusula opcional que precede a la lista SELECT en una consulta. La cláusula WITH define una o más *common\$1table\$1expressions*. Cada expresión común de tabla (CTE) define una tabla temporal, que es similar a la definición de una vista. Puede referenciar estas tablas temporales en la cláusula FROM. Solo se utilizan mientras se ejecuta la consulta a la que pertenecen. Cada CTE de la cláusula WITH especifica un nombre de tabla, una lista opcional de nombres de columnas y una expresión de consulta que toma el valor de una tabla (una instrucción SELECT).
Las subconsultas de la cláusula WITH son una manera eficiente de definir tablas que puede utilizarse al ejecutar una única consulta. En todos los casos, se pueden obtener los mismos resultados al utilizar subconsultas en el cuerpo principal de la instrucción SELECT, pero las subconsultas de la cláusula WITH pueden resultar más sencillas de escribir y leer. Cuando es posible, las subconsultas de la cláusula WITH a las que se hace referencia varias veces se optimizan como subexpresiones comunes; es decir, puede ser posible evaluar una subconsulta WITH una vez y reutilizar sus resultados (tenga en cuenta que las subexpresiones comunes no se limitan a aquellas definidas en la cláusula WITH).
## Sintaxis
```
[ WITH common_table_expression [, common_table_expression , ...] ]
```
donde *common\$1table\$1expression* puede ser no recursiva. A continuación se presenta la forma no recursiva:
```
CTE_table_name AS ( query )
```
## Parameters
*common\$1table\$1expression*
Define una tabla temporal a la que se puede referenciar en [Cláusula FROM](FROM_clause30.md) y se utiliza solo durante la ejecución de la consulta a la que pertenece.
*CTE\$1table\$1name*
Un nombre único para una tabla temporal que define los resultados de una subconsulta de la cláusula WITH. No se pueden usar nombres duplicados dentro de una cláusula WITH. Cada subconsulta debe tener un nombre de tabla al que se pueda hacer referencia en la [Cláusula FROM](FROM_clause30.md).
*consulta*
Cualquier consulta SELECT que AWS Clean Rooms admita. Consulte [SELECT](sql-commands-select-spark.md).
## Notas de uso
Puede usar una cláusula WITH en las siguientes instrucciones SQL:
+ SELECCIONE, CON, UNION, UNION ALL, INTERSECT, INTERSECT ALL, EXCEPTO O EXCEPTO ALL
Si la cláusula FROM de una consulta que contiene una cláusula WITH no referencia ninguna de las tablas definidas por la cláusula WITH, se ignora la cláusula WITH y la consulta se ejecuta como siempre.
Se puede hacer referencia a una tabla definida por una subconsulta de la cláusula WITH solo en el alcance de la consulta SELECT que inicia la cláusula WITH. Por ejemplo, se puede hacer referencia a dicha tabla en la cláusula FROM de una subconsulta en la lista SELECT, la cláusula WHERE o la cláusula HAVING. No se puede usar una cláusula WITH en una subconsulta y hacer referencia a su tabla en la cláusula FROM de una consulta principal o de otra subconsulta. Este patrón de consulta provoca un mensaje de error `relation table_name doesn't exist` para la tabla de la cláusula WITH.
No se puede especificar otra cláusula WITH dentro de una subconsulta de la cláusula WITH.
No se pueden realizar referencias futuras a tablas definidas por las subconsultas de la cláusula WITH. Por ejemplo, la siguiente consulta devuelve un error debido a la referencia futura a la tabla W2 en la definición de la tabla W1:
```
with w1 as (select * from w2), w2 as (select * from w1)
select * from sales;
ERROR: relation "w2" does not exist
```
## Ejemplos
En el siguiente ejemplo, se muestra el caso posible más simple de una consulta que contiene una cláusula WITH. La consulta WITH denominada VENUECOPY selecciona todas las filas de la tabla VENUE. La consulta principal, a su vez, selecciona todas las filas de VENUECOPY. La tabla VENUECOPY existe solo durante esta consulta.
```
with venuecopy as (select * from venue)
select * from venuecopy order by 1 limit 10;
```
```
venueid | venuename | venuecity | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park | Bridgeview | IL | 0
2 | Columbus Crew Stadium | Columbus | OH | 0
3 | RFK Stadium | Washington | DC | 0
4 | CommunityAmerica Ballpark | Kansas City | KS | 0
5 | Gillette Stadium | Foxborough | MA | 68756
6 | New York Giants Stadium | East Rutherford | NJ | 80242
7 | BMO Field | Toronto | ON | 0
8 | The Home Depot Center | Carson | CA | 0
9 | Dick's Sporting Goods Park | Commerce City | CO | 0
v 10 | Pizza Hut Park | Frisco | TX | 0
(10 rows)
```
En el siguiente ejemplo, se muestra una cláusula WITH que produce dos tablas, denominadas VENUE\$1SALES y TOP\$1VENUES. La segunda tabla de la consulta WITH selecciona desde la primera. A su vez, la cláusula WHERE del bloque de la consulta principal contiene una subconsulta que limita la tabla TOP\$1VENUES.
```
with venue_sales as
(select venuename, venuecity, sum(pricepaid) as venuename_sales
from sales, venue, event
where venue.venueid=event.venueid and event.eventid=sales.eventid
group by venuename, venuecity),
top_venues as
(select venuename
from venue_sales
where venuename_sales > 800000)
select venuename, venuecity, venuestate,
sum(qtysold) as venue_qty,
sum(pricepaid) as venue_sales
from sales, venue, event
where venue.venueid=event.venueid and event.eventid=sales.eventid
and venuename in(select venuename from top_venues)
group by venuename, venuecity, venuestate
order by venuename;
```
```
venuename | venuecity | venuestate | venue_qty | venue_sales
------------------------+---------------+------------+-----------+-------------
August Wilson Theatre | New York City | NY | 3187 | 1032156.00
Biltmore Theatre | New York City | NY | 2629 | 828981.00
Charles Playhouse | Boston | MA | 2502 | 857031.00
Ethel Barrymore Theatre | New York City | NY | 2828 | 891172.00
Eugene O'Neill Theatre | New York City | NY | 2488 | 828950.00
Greek Theatre | Los Angeles | CA | 2445 | 838918.00
Helen Hayes Theatre | New York City | NY | 2948 | 978765.00
Hilton Theatre | New York City | NY | 2999 | 885686.00
Imperial Theatre | New York City | NY | 2702 | 877993.00
Lunt-Fontanne Theatre | New York City | NY | 3326 | 1115182.00
Majestic Theatre | New York City | NY | 2549 | 894275.00
Nederlander Theatre | New York City | NY | 2934 | 936312.00
Pasadena Playhouse | Pasadena | CA | 2739 | 820435.00
Winter Garden Theatre | New York City | NY | 2838 | 939257.00
(14 rows)
```
En los siguientes dos ejemplos se muestran las reglas para el alcance de las referencias de la tabla en función de las subconsultas de la cláusula WITH. La primera consulta se ejecuta, pero en la segunda se produce un error inesperado. La primera consulta tiene una subconsulta de la cláusula WITH dentro de la lista SELECT de la consulta principal. Se hace referencia a la tabla definida por la cláusula WITH (HOLIDAYS) en la cláusula FROM de la subconsulta de la lista SELECT:
```
select caldate, sum(pricepaid) as daysales,
(with holidays as (select * from date where holiday ='t')
select sum(pricepaid)
from sales join holidays on sales.dateid=holidays.dateid
where caldate='2008-12-25') as dec25sales
from sales join date on sales.dateid=date.dateid
where caldate in('2008-12-25','2008-12-31')
group by caldate
order by caldate;
caldate | daysales | dec25sales
-----------+----------+------------
2008-12-25 | 70402.00 | 70402.00
2008-12-31 | 12678.00 | 70402.00
(2 rows)
```
La segunda consulta falla porque intenta hacer referencia a la tabla HOLIDAYS en la consulta principal, así como en la subconsulta de la lista SELECT. Las referencias de la consulta principal están fuera de alcance.
```
select caldate, sum(pricepaid) as daysales,
(with holidays as (select * from date where holiday ='t')
select sum(pricepaid)
from sales join holidays on sales.dateid=holidays.dateid
where caldate='2008-12-25') as dec25sales
from sales join holidays on sales.dateid=holidays.dateid
where caldate in('2008-12-25','2008-12-31')
group by caldate
order by caldate;
ERROR: relation "holidays" does not exist
```
# Cláusula FROM
La cláusula FROM en una consulta enumera las referencias de la tabla (tablas, vistas y subconsultas) desde las que se seleccionan los datos. Si se enumeran varias referencias de tabla, se deben combinar las tablas a través de la sintaxis adecuada en la cláusula FROM o en la cláusula WHERE. Si no se especifican criterios de combinación, el sistema procesa la consulta como una combinación cruzada (producto cartesiano).
**Topics**
+ [Sintaxis](#FROM_clause30-synopsis)
+ [Parameters](#FROM_clause30-parameters)
+ [Notas de uso](#FROM_clause_usage_notes)
## Sintaxis
```
FROM table_reference [, ...]
```
donde *table\$1reference* es uno de los siguientes:
```
with_subquery_table_name | table_name | ( subquery ) [ [ AS ] alias ]
table_reference [ NATURAL ] join_type table_reference [ USING ( join_column [, ...] ) ]
table_reference [ INNER ] join_type table_reference ON expr
```
## Parameters
*with\$1subquery\$1table\$1name*
Una tabla definida por una subconsulta en la [Cláusula WITH](WITH_clause.md).
*table\$1name*
Nombre de una tabla o vista.
*alias*
Nombre alternativo temporal para una tabla o vista. Se debe proporcionar un alias para una tabla obtenida de una subconsulta. En otras referencias de tabla, los alias son opcionales La palabra clave AS es siempre opcional. Los alias de la tabla brindan un acceso directo para identificar tablas en otras partes de una consulta, como la cláusula WHERE.
Por ejemplo:
```
select * from sales s, listing l
where s.listid=l.listid
```
Si hay un alias de tabla definido, se debe usar el alias para hacer referencia a esa tabla en la consulta.
Por ejemplo, si la consulta es `SELECT "tbl"."col" FROM "tbl" AS "t"`, la consulta dará error porque en este caso el nombre de la tabla básicamente se anula. Una consulta válida en este caso sería `SELECT "t"."col" FROM "tbl" AS "t"`.
*column\$1alias*
Nombre alternativo temporal para una columna en una tabla o vista.
*subquery*
Una expresión de consulta que toma el valor de una tabla. La tabla solo existe mientras dura la consulta y, por lo general, se le asigna un nombre o un *alias*. No obstante, no es obligatorio tener un alias. También puede definir nombres de columnas para tablas que derivan de subconsultas. Designar un nombre a los alias de las columnas es importante cuando desea combinar los resultados de las subconsultas con otras tablas y cuando desea seleccionar o limitar esas columnas en otros sitios de la consulta.
Una subconsulta puede contener una cláusula ORDER BY, pero es posible que esta cláusula no tenga ningún efecto si no se especifica también una cláusula OFFSET o LIMIT.
NATURAL
Define una combinación que utiliza automáticamente todos los pares de columnas con nombres idénticos en las dos tablas como las columnas de combinación. No se requiere una condición de combinación explícita. Por ejemplo, si las tablas CATEGORY y EVENT tienen columnas denominadas CATID, una combinación natural de estas tablas es una combinación de las columnas CATID.
Si se especifica una combinación NATURAL, pero no existen pares de columnas con nombres idénticos en las tablas que deben combinarse, la consulta se establece en una combinación cruzada.
*join\$1type*
Especifique uno de los siguientes tipos de combinación:
+ [INNER] JOIN
+ LEFT [OUTER] JOIN
+ RIGHT [OUTER] JOIN
+ FULL [OUTER] JOIN
+ CROSS JOIN
Las combinaciones cruzadas son combinaciones no calificadas; devuelven el producto cartesiano de dos tablas.
Las combinaciones internas y externas son combinaciones calificadas. Están calificadas implícitamente (en combinaciones naturales), con la sintaxis ON o USING en la cláusula FROM, o con una condición WHERE.
Una combinación interna devuelve filas coincidentes únicamente en función a la condición de combinación o a la lista de columnas de combinación. Una combinación externa devuelve todas las filas que la combinación interna equivalente devolvería, además de filas no coincidentes de la tabla "izquierda", tabla "derecha" o ambas tablas. La tabla izquierda es la primera tabla de la lista, y la tabla derecha es la segunda tabla de la lista. Las filas no coincidentes contienen valores NULL para llenar el vacío de las columnas de salida.
ON *join\$1condition*
Especificación del tipo de combinación donde las columnas de combinación se establecen como una condición que sigue la palabra clave ON. Por ejemplo:
```
sales join listing
on sales.listid=listing.listid and sales.eventid=listing.eventid
```
USING ( *join\$1column* [, ...] )
Especificación del tipo de combinación donde las columnas de combinación aparecen enumeradas entre paréntesis. Si se especifican varias columnas de combinación, se delimitan por comas. La palabra clave USING debe preceder a la lista. Por ejemplo:
```
sales join listing
using (listid,eventid)
```
## Notas de uso
Las columnas de combinación deben tener tipos de datos comparables.
Una combinación NATURAL o USING retiene solo uno de cada par de columnas de combinación en el conjunto de resultados intermedios.
Una combinación con la sintaxis ON retiene ambas columnas de combinación en su conjunto de resultados intermedios.
Véase también [Cláusula WITH](WITH_clause.md).
# Cláusula JOIN
Se utiliza una cláusula JOIN de SQL para combinar los datos de dos o más tablas en función de los campos comunes. Es posible que los resultados cambien o no cambien según el método de combinación especificado. Las combinaciones externas izquierdas y derechas conservan valores de una de las tablas combinadas cuando no se encuentra una coincidencia en la otra tabla.
La combinación del tipo JOIN y la condición de unión determina qué filas se incluyen en el conjunto de resultados final. A continuación, las cláusulas SELECT y WHERE controlan qué columnas se devuelven y cómo se filtran las filas. Comprender los diferentes tipos de JOIN y cómo utilizarlos de forma eficaz es una habilidad crucial en SQL, ya que permite combinar datos de varias tablas de forma flexible y eficaz.
## Sintaxis
```
SELECT column1, column2, ..., columnn
FROM table1
join_type table2
ON table1.column = table2.column;
```
## Parameters
*SELECCIONE la columna 1, la columna 2,..., la columna N*
Las columnas que desea incluir en el conjunto de resultados. Puede seleccionar columnas de una o de las dos tablas incluidas en la COMBINACIÓN.
*DE LA TABLA 1*
La primera tabla (izquierda) de la operación JOIN.
*[UNIÓN \$1 UNIÓN INTERIOR \$1 UNIÓN IZQUIERDA [EXTERIOR] \$1 UNIÓN DERECHA [EXTERIOR] UNIÓN \$1 UNIÓN COMPLETA [EXTERIOR]] Tabla 2:*
El tipo de UNIÓN que se va a realizar. JOIN o INNER JOIN devuelven solo las filas con valores coincidentes en ambas tablas.
LEFT [OUTER] JOIN devuelve todas las filas de la tabla de la izquierda, con las filas coincidentes de la tabla de la derecha.
RIGHT [OUTER] JOIN devuelve todas las filas de la tabla de la derecha, con las filas coincidentes de la tabla de la izquierda.
FULL [OUTER] JOIN devuelve todas las filas de ambas tablas, independientemente de si coinciden o no.
CROSS JOIN crea un producto cartesiano de las filas de las dos tablas.
*EN la tabla1.columna = tabla2.columna*
La condición de unión, que especifica cómo se hacen coincidir las filas de las dos tablas. La condición de unión se puede basar en una o más columnas.
*Condición WHERE:*
Cláusula opcional que se puede utilizar para filtrar aún más el conjunto de resultados en función de una condición específica.
## Ejemplo
El ejemplo siguiente es una combinación entre dos tablas con la cláusula USING. En este caso, las columnas listid y eventid se utilizan como columnas de combinación. Los resultados tienen un límite de cinco filas.
```
select listid, listing.sellerid, eventid, listing.dateid, numtickets
from listing join sales
using (listid, eventid)
order by 1
limit 5;
listid | sellerid | eventid | dateid | numtickets
-------+----------+---------+--------+-----------
1 | 36861 | 7872 | 1850 | 10
4 | 8117 | 4337 | 1970 | 8
5 | 1616 | 8647 | 1963 | 4
5 | 1616 | 8647 | 1963 | 4
6 | 47402 | 8240 | 2053 | 18
```
# Tipos de combinación
## INNER
Este es el tipo de unión predeterminado. Devuelve las filas que tienen valores coincidentes en ambas referencias de tabla.
La combinación interna es el tipo de combinación más común que se utiliza en SQL. Es una forma eficaz de combinar datos de varias tablas en función de una columna o conjunto de columnas común.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
INNER JOIN table2
ON table1.column = table2.column;
```
La siguiente consulta devolverá todas las filas en las que haya un valor de custome\$1id coincidente entre las tablas de clientes y pedidos. El conjunto de resultados contendrá las columnas customer\$1id, name, order\$1id y order\$1date.
```
SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date
FROM customers
INNER JOIN orders
ON customers.customer_id = orders.customer_id;
```
La siguiente consulta es una combinación interna (sin la palabra clave JOIN) entre la tabla LISTING y la tabla SALES, donde LISTID de la tabla LISTING está entre 1 y 5. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTID 1, 4 y 5 coinciden con los criterios.
```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing, sales
where listing.listid = sales.listid
and listing.listid between 1 and 5
group by 1
order by 1;
listid | price | comm
-------+--------+--------
1 | 728.00 | 109.20
4 | 76.00 | 11.40
5 | 525.00 | 78.75
```
El siguiente ejemplo es una combinación interna con la cláusula ON. En este caso, las filas NULL no se devuelven.
```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from sales join listing
on sales.listid=listing.listid and sales.eventid=listing.eventid
where listing.listid between 1 and 5
group by 1
order by 1;
listid | price | comm
-------+--------+--------
1 | 728.00 | 109.20
4 | 76.00 | 11.40
5 | 525.00 | 78.75
```
La siguiente consulta es una combinación interna de dos subconsultas en la cláusula FROM. La consulta busca la cantidad de tickets vendidos y sin vender para diferentes categorías de eventos (conciertos y espectáculos). Estas subconsultas de la cláusula FROM son subconsultas de *tabla*; pueden devolver varias columnas y filas.
```
select catgroup1, sold, unsold
from
(select catgroup, sum(qtysold) as sold
from category c, event e, sales s
where c.catid = e.catid and e.eventid = s.eventid
group by catgroup) as a(catgroup1, sold)
join
(select catgroup, sum(numtickets)-sum(qtysold) as unsold
from category c, event e, sales s, listing l
where c.catid = e.catid and e.eventid = s.eventid
and s.listid = l.listid
group by catgroup) as b(catgroup2, unsold)
on a.catgroup1 = b.catgroup2
order by 1;
catgroup1 | sold | unsold
----------+--------+--------
Concerts | 195444 |1067199
Shows | 149905 | 817736
```
## IZQUIERDA [EXTERIOR]
Devuelve todos los valores de la referencia de la tabla izquierda y los valores coincidentes de la referencia de la tabla derecha, o añade NULL si no hay ninguna coincidencia. También se conoce como *unión exterior izquierda*.
Devuelve todas las filas de la tabla izquierda (primera) y las filas coincidentes de la tabla derecha (segunda). Si no hay ninguna coincidencia en la tabla de la derecha, el conjunto de resultados contendrá valores NULOS para las columnas de la tabla de la derecha. La palabra clave OUTER se puede omitir y la unión se puede escribir simplemente como LEFT JOIN. Lo opuesto a una unión exterior izquierda es una unión exterior derecha, que devuelve todas las filas de la tabla de la derecha y las filas coincidentes de la tabla de la izquierda.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
LEFT [OUTER] JOIN table2
ON table1.column = table2.column;
```
La siguiente consulta devolverá todas las filas de la tabla de clientes, junto con las filas coincidentes de la tabla de pedidos. Si un cliente no tiene ningún pedido, el conjunto de resultados seguirá incluyendo la información del cliente, con valores NULOS para las columnas order\$1id y order\$1date.
```
SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date
FROM customers
LEFT OUTER JOIN orders
ON customers.customer_id = orders.customer_id;
```
La siguiente consulta es una combinación externa izquierda. Las combinaciones externas izquierdas y derechas conservan valores de una de las tablas combinadas cuando no se encuentra una coincidencia en la otra tabla. Las tablas izquierda y derecha son la primera tabla y la segunda tabla que aparecen en la sintaxis. Los valores NULL se utilizan para rellenar los "espacios" en el conjunto de resultados. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTIDs 2 y 3 no generaron ninguna venta.
```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing left outer join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;
listid | price | comm
-------+--------+--------
1 | 728.00 | 109.20
2 | NULL | NULL
3 | NULL | NULL
4 | 76.00 | 11.40
5 | 525.00 | 78.75
```
## DERECHA [EXTERIOR]
Devuelve todos los valores de la referencia de la tabla derecha y los valores coincidentes de la referencia de la tabla izquierda, o añade NULL si no hay ninguna coincidencia. También se conoce como *unión exterior derecha*.
Devuelve todas las filas de la tabla derecha (segunda) y las filas coincidentes de la tabla izquierda (primera). Si no hay ninguna coincidencia en la tabla de la izquierda, el conjunto de resultados contendrá valores NULOS para las columnas de la tabla de la izquierda. La palabra clave OUTER se puede omitir y la unión se puede escribir simplemente como RIGHT JOIN. Lo opuesto a una unión exterior derecha es una unión exterior izquierda, que devuelve todas las filas de la tabla izquierda y las filas coincidentes de la tabla derecha.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
RIGHT [OUTER] JOIN table2
ON table1.column = table2.column;
```
La siguiente consulta devolverá todas las filas de la tabla de clientes, junto con las filas coincidentes de la tabla de pedidos. Si un cliente no tiene ningún pedido, el conjunto de resultados seguirá incluyendo la información del cliente, con valores NULOS para las columnas order\$1id y order\$1date.
```
SELECT orders.order_id, orders.order_date, customers.customer_id, customers.name
FROM orders
RIGHT OUTER JOIN customers
ON orders.customer_id = customers.customer_id;
```
La siguiente consulta es una combinación externa derecha. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTIDs 1, 4 y 5 coinciden con los criterios.
```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing right outer join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;
listid | price | comm
-------+--------+--------
1 | 728.00 | 109.20
4 | 76.00 | 11.40
5 | 525.00 | 78.75
```
## COMPLETO [EXTERIOR]
Devuelve todos los valores de ambas relaciones, añadiendo valores NULL en el lado que no coincida. También se conoce como *unión externa completa*.
Devuelve todas las filas de las tablas izquierda y derecha, independientemente de si coinciden o no. Si no hay ninguna coincidencia, el conjunto de resultados contendrá valores NULOS para las columnas de la tabla que no tengan ninguna fila coincidente. La palabra clave OUTER se puede omitir y la unión se puede escribir simplemente como FULL JOIN. La combinación externa completa se usa con menos frecuencia que la unión externa izquierda o la unión externa derecha, pero puede resultar útil en algunos escenarios en los que es necesario ver todos los datos de ambas tablas, incluso si no hay coincidencias.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
FULL [OUTER] JOIN table2
ON table1.column = table2.column;
```
La siguiente consulta devolverá todas las filas de las tablas de clientes y de pedidos. Si un cliente no tiene ningún pedido, el conjunto de resultados seguirá incluyendo la información del cliente, con valores NULOS para las columnas order\$1id y order\$1date. Si un pedido no tiene ningún cliente asociado, el conjunto de resultados incluirá ese pedido, con valores NULOS para las columnas customer\$1id y name.
```
SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date
FROM customers
FULL OUTER JOIN orders
ON customers.customer_id = orders.customer_id;
```
La siguiente consulta es una combinación completa. Las combinaciones completas retienen valores de las tablas combinadas cuando no se encuentra una coincidencia en la otra tabla. Las tablas izquierda y derecha son la primera tabla y la segunda tabla que aparecen en la sintaxis. Los valores NULL se utilizan para rellenar los "espacios" en el conjunto de resultados. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). Los resultados muestran que LISTIDs 2 y 3 no generaron ninguna venta.
```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing full join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
group by 1
order by 1;
listid | price | comm
-------+--------+--------
1 | 728.00 | 109.20
2 | NULL | NULL
3 | NULL | NULL
4 | 76.00 | 11.40
5 | 525.00 | 78.75
```
La siguiente consulta es una combinación completa. Esta consulta relaciona los valores de la columna LISTID en la tabla LISTING (la tabla izquierda) y la tabla SALES (la tabla derecha). En los resultados solo aparecen las filas que no generan ventas (LISTIDs 2 y 3).
```
select listing.listid, sum(pricepaid) as price, sum(commission) as comm
from listing full join sales on sales.listid = listing.listid
where listing.listid between 1 and 5
and (listing.listid IS NULL or sales.listid IS NULL)
group by 1
order by 1;
listid | price | comm
-------+--------+--------
2 | NULL | NULL
3 | NULL | NULL
```
## [IZQUIERDA] SEMIRREMOLQUE
Devuelve los valores del lado izquierdo de la referencia de la tabla que coinciden con los de la derecha. También se conoce como *semiunión izquierda*.
Solo devuelve las filas de la tabla izquierda (primera) que tienen una fila coincidente en la tabla derecha (segunda). No devuelve ninguna columna de la tabla de la derecha, solo las columnas de la tabla de la izquierda. El comando LEFT SEMI JOIN es útil cuando se quieren buscar las filas de una tabla que coinciden con las de otra tabla, sin necesidad de devolver ningún dato de la segunda tabla. LEFT SEMI JOIN es una alternativa más eficaz que utilizar una subconsulta con una cláusula IN o EXISTS.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
LEFT SEMI JOIN table2
ON table1.column = table2.column;
```
La siguiente consulta devolverá solo las columnas customer\$1id y name de la tabla de clientes, para los clientes que tengan al menos un pedido en la tabla de pedidos. El conjunto de resultados no incluirá ninguna columna de la tabla de pedidos.
```
SELECT customers.customer_id, customers.name
FROM customers
LEFT SEMI JOIN orders
ON customers.customer_id = orders.customer_id;
```
## CROSS JOIN
Devuelve el producto cartesiano de dos relaciones. Esto significa que el conjunto de resultados contendrá todas las combinaciones posibles de filas de las dos tablas, sin aplicar ninguna condición ni filtro.
El método CROSS JOIN resulta útil cuando se necesitan generar todas las combinaciones posibles de datos a partir de dos tablas, como en el caso de crear un informe que muestre todas las combinaciones posibles de información sobre clientes y productos. La COMBINACIÓN CRUZADA es diferente de otros tipos de combinación (COMBINACIÓN INTERIOR, UNIÓN IZQUIERDA, etc.) porque no tiene una condición de unión en la cláusula ON. La condición de unión no es obligatoria para una COMBINACIÓN CRUZADA.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
CROSS JOIN table2;
```
La siguiente consulta devolverá un conjunto de resultados que contiene todas las combinaciones posibles de customer\$1id, customer\$1name, product\$1id y product\$1name de las tablas de clientes y productos. Si la tabla de clientes tiene 10 filas y la tabla de productos tiene 20 filas, el conjunto de resultados del CROSS JOIN contendrá 10 x 20 = 200 filas.
```
SELECT customers.customer_id, customers.name, products.product_id, products.product_name
FROM customers
CROSS JOIN products;
```
La siguiente consulta es una combinación cruzada o cartesiana de la tabla LISTING y la tabla SALES con un predicado para limitar los resultados. Esta consulta hace coincidir los valores de las columnas LISTID de la tabla VENTAS y los valores LISTIDs 1, 2, 3, 4 y 5 de la tabla LISTING de ambas tablas. Los resultados muestran que 20 filas coinciden con los criterios.
```
select sales.listid as sales_listid, listing.listid as listing_listid
from sales cross join listing
where sales.listid between 1 and 5
and listing.listid between 1 and 5
order by 1,2;
sales_listid | listing_listid
-------------+---------------
1 | 1
1 | 2
1 | 3
1 | 4
1 | 5
4 | 1
4 | 2
4 | 3
4 | 4
4 | 5
5 | 1
5 | 1
5 | 2
5 | 2
5 | 3
5 | 3
5 | 4
5 | 4
5 | 5
5 | 5
```
## ANTIUNIÓN
Devuelve los valores de la referencia de la tabla izquierda que no coinciden con la referencia de la tabla derecha. También se conoce como *antiunión izquierda*.
La función ANTI JOIN es una operación útil cuando se quieren encontrar las filas de una tabla que no coinciden con las de otra.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
LEFT ANTI JOIN table2
ON table1.column = table2.column;
```
La siguiente consulta mostrará todos los clientes que no han realizado ningún pedido.
```
SELECT customers.customer_id, customers.name
FROM customers
LEFT ANTI JOIN orders
ON customers.customer_id = orders.customer_id
WHERE orders.order_id IS NULL;
```
## NATURAL
Especifica que las filas de las dos relaciones coincidirán implícitamente en igualdad de condiciones en todas las columnas con nombres coincidentes.
Hace coincidir automáticamente las columnas con el mismo nombre y tipo de datos entre las dos tablas. No requiere que especifique explícitamente la condición de unión en la cláusula ON. Combina todas las columnas coincidentes de las dos tablas en el conjunto de resultados.
La combinación NATURAL es una forma abreviada práctica cuando las tablas que se van a unir tienen columnas con los mismos nombres y tipos de datos. Sin embargo, generalmente se recomienda usar la combinación interna más explícita... La sintaxis ON permite que las condiciones de unión sean más explícitas y fáciles de entender.
**Sintaxis:**
```
SELECT column1, column2, ..., columnn
FROM table1
NATURAL JOIN table2;
```
El siguiente ejemplo es una unión natural entre dos tablas `employees` y`departments`, con las siguientes columnas:
+ `employees`tabla:`employee_id`,`first_name`,`last_name`, `department_id `
+ `departments`mesa:`department_id`, `department_name `
La siguiente consulta devolverá un conjunto de resultados que incluye el nombre, los apellidos y el nombre del departamento de todas las filas coincidentes entre las dos tablas, según la `department_id` columna.
```
SELECT e.first_name, e.last_name, d.department_name
FROM employees e
NATURAL JOIN departments d;
```
El ejemplo siguiente es una combinación natural entre dos tablas. En este caso, las columnas listid, sellerid, eventid y dateid tienen nombres y tipos de datos idénticos en ambas tablas y, por lo tanto, se utilizan como columnas de combinación. Los resultados tienen un límite de cinco filas.
```
select listid, sellerid, eventid, dateid, numtickets
from listing natural join sales
order by 1
limit 5;
listid | sellerid | eventid | dateid | numtickets
-------+-----------+---------+--------+-----------
113 | 29704 | 4699 | 2075 | 22
115 | 39115 | 3513 | 2062 | 14
116 | 43314 | 8675 | 1910 | 28
118 | 6079 | 1611 | 1862 | 9
163 | 24880 | 8253 | 1888 | 14
```
# Cláusula WHERE
La cláusula WHERE contiene condiciones que combinan tablas o que aplican predicados a columnas de las tablas. Las tablas pueden combinarse de manera interna a través de la sintaxis adecuada en la cláusula WHERE o en la cláusula FROM. Los criterios de combinación externa deben especificarse en la cláusula FROM.
## Sintaxis
```
[ WHERE condition ]
```
## *condition*
Cualquier condición de búsqueda con un resultado booleano, como una condición de combinación o un predicado en una columna de la tabla. Los siguientes ejemplos son condiciones de combinación válidas:
```
sales.listid=listing.listid
sales.listid<>listing.listid
```
Los siguientes ejemplos son condiciones válidas de columnas en tablas:
```
catgroup like 'S%'
venueseats between 20000 and 50000
eventname in('Jersey Boys','Spamalot')
year=2008
length(catdesc)>25
date_part(month, caldate)=6
```
Las condiciones pueden ser simples o complejas. Para las condiciones complejas, puede utilizar paréntesis para aislar las unidades lógicas. En el siguiente ejemplo, la condición de combinación está entre paréntesis.
```
where (category.catid=event.catid) and category.catid in(6,7,8)
```
## Notas de uso
Puede usar alias en la cláusula WHERE para hacer referencia a expresiones de listas de selección.
No puede limitar los resultados de las funciones de agregación en la cláusula WHERE; utilice la cláusula HAVING con este fin.
Las columnas que están limitadas en la cláusula WHERE deben derivar de referencias de tabla en la cláusula FROM.
## Ejemplo
La siguiente consulta utiliza una combinación de diferentes restricciones de la cláusula WHERE, incluida una condición de combinación para las tablas SALES y EVENT, un predicado en la columna EVENTNAME y dos predicados en la columna STARTTIME.
```
select eventname, starttime, pricepaid/qtysold as costperticket, qtysold
from sales, event
where sales.eventid = event.eventid
and eventname='Hannah Montana'
and date_part(quarter, starttime) in(1,2)
and date_part(year, starttime) = 2008
order by 3 desc, 4, 2, 1 limit 10;
eventname | starttime | costperticket | qtysold
----------------+---------------------+-------------------+---------
Hannah Montana | 2008-06-07 14:00:00 | 1706.00000000 | 2
Hannah Montana | 2008-05-01 19:00:00 | 1658.00000000 | 2
Hannah Montana | 2008-06-07 14:00:00 | 1479.00000000 | 1
Hannah Montana | 2008-06-07 14:00:00 | 1479.00000000 | 3
Hannah Montana | 2008-06-07 14:00:00 | 1163.00000000 | 1
Hannah Montana | 2008-06-07 14:00:00 | 1163.00000000 | 2
Hannah Montana | 2008-06-07 14:00:00 | 1163.00000000 | 4
Hannah Montana | 2008-05-01 19:00:00 | 497.00000000 | 1
Hannah Montana | 2008-05-01 19:00:00 | 497.00000000 | 2
Hannah Montana | 2008-05-01 19:00:00 | 497.00000000 | 4
(10 rows)
```
# cláusula VALUES
La cláusula VALUES se usa para proporcionar un conjunto de valores de fila directamente en la consulta, sin necesidad de hacer referencia a una tabla.
La cláusula VALUES se puede utilizar en los siguientes escenarios:
+ Puede usar la cláusula VALUES en una instrucción INSERT INTO para especificar los valores de las nuevas filas que se insertan en una tabla.
+ Puede utilizar la cláusula VALUES por sí sola para crear un conjunto de resultados temporal, o una tabla en línea, sin necesidad de hacer referencia a una tabla.
+ Puede combinar la cláusula VALUES con otras cláusulas SQL, como WHERE, ORDER BY o LIMIT, para filtrar, ordenar o limitar las filas del conjunto de resultados.
Esta cláusula resulta especialmente útil cuando se necesita insertar, consultar o manipular un conjunto pequeño de datos directamente en la sentencia SQL, sin necesidad de crear o hacer referencia a una tabla permanente. Le permite definir los nombres de las columnas y los valores correspondientes para cada fila, lo que le brinda la flexibilidad de crear conjuntos de resultados temporales o insertar datos sobre la marcha, sin la sobrecarga de administrar una tabla independiente.
## Sintaxis
```
VALUES ( expression [ , ... ] ) [ table_alias ]
```
## Parameters
*expression*
Expresión que especifica una combinación de uno o más valores, operadores y funciones SQL que da como resultado un valor.
*table\$1alias*
Un alias que especifica un nombre temporal con una lista de nombres de columnas opcional.
## Ejemplo
El siguiente ejemplo crea una tabla en línea, un conjunto de resultados similar a una tabla temporal con dos columnas, y. `col1` `col2` La única fila del conjunto de resultados contiene los valores `"one"` y`1`, respectivamente. La `SELECT * FROM` parte de la consulta simplemente recupera todas las columnas y filas de este conjunto de resultados temporal. El sistema de base de datos genera automáticamente los nombres de las columnas (`col1`y`col2`), ya que la cláusula VALUES no especifica explícitamente los nombres de las columnas.
```
SELECT * FROM VALUES ("one", 1);
+----+----+
|col1|col2|
+----+----+
| one| 1|
+----+----+
```
Si desea definir nombres de columnas personalizados, puede hacerlo utilizando una cláusula AS después de la cláusula VALUES, de la siguiente manera:
```
SELECT * FROM (VALUES ("one", 1)) AS my_table (name, id);
+------+----+
| name | id |
+------+----+
| one | 1 |
+------+----+
```
Esto crearía un conjunto de resultados temporal con los nombres de las columnas `name` y`id`, en lugar del predeterminado `col1` y`col2`.
# Cláusula GROUP BY
La cláusula GROUP BY identifica las columnas de agrupación para la consulta. Las columnas de agrupación deben declararse cuando la consulta computa las agregaciones con funciones estándar como SUM, AVG y COUNT. Si hay una función de agregado en la expresión SELECT, cualquier columna de la expresión SELECT que no esté en una función de agregado debe estar en la cláusula GROUP BY.
Para obtener más información, consulte [AWS Clean Rooms Funciones de Spark SQL](sql-functions-topic-spark.md).
## Sintaxis
```
GROUP BY group_by_clause [, ...]
group_by_clause := {
expr |
ROLLUP ( expr [, ...] ) |
}
```
## *Parámetros*
*expr*
La lista de columnas o expresiones debe coincidir con la lista de expresiones no agregadas en la lista de selección de la consulta. Por ejemplo, considere la siguiente consulta simple.
```
select listid, eventid, sum(pricepaid) as revenue,
count(qtysold) as numtix
from sales
group by listid, eventid
order by 3, 4, 2, 1
limit 5;
listid | eventid | revenue | numtix
-------+---------+---------+--------
89397 | 47 | 20.00 | 1
106590 | 76 | 20.00 | 1
124683 | 393 | 20.00 | 1
103037 | 403 | 20.00 | 1
147685 | 429 | 20.00 | 1
(5 rows)
```
En esta consulta, la lista de selección consta de dos expresiones agregadas. La primera usa la función SUM y la segunda usa la función COUNT. Las dos columnas restantes, LISTID y EVENTID, deben declararse como columnas de agrupación.
Las expresiones de la cláusula GROUP BY también pueden hacer referencia a la lista de selección a través de números ordinales. Por ejemplo, el caso anterior podría abreviarse de la siguiente manera.
```
select listid, eventid, sum(pricepaid) as revenue,
count(qtysold) as numtix
from sales
group by 1,2
order by 3, 4, 2, 1
limit 5;
listid | eventid | revenue | numtix
-------+---------+---------+--------
89397 | 47 | 20.00 | 1
106590 | 76 | 20.00 | 1
124683 | 393 | 20.00 | 1
103037 | 403 | 20.00 | 1
147685 | 429 | 20.00 | 1
(5 rows)
```
*ROLLUP*
Puede utilizar la extensión de agregación ROLLUP para realizar el trabajo de varias operaciones GROUP BY en una sola instrucción. Para obtener más información sobre las extensiones de agregación y las funciones relacionadas, consulte [Extensiones de agregación](GROUP_BY_aggregation-extensions.md).
# Extensiones de agregación
AWS Clean Rooms admite extensiones de agregación para realizar el trabajo de varias operaciones GROUP BY en una sola sentencia.
## *GROUPING SETS*
Calcula uno o más conjuntos de agrupación en una sola instrucción. Un conjunto de agrupación es el conjunto de una sola cláusula GROUP BY, un conjunto de 0 o más columnas mediante el que se puede agrupar el conjunto de resultados de una consulta. GROUP BY GROUPING SETS equivale a ejecutar una consulta UNION ALL en un conjunto de resultados agrupado por columnas diferentes. Por ejemplo, GROUP BY GROUPING SETS((a), (b)) equivale a GROUP BY a UNION ALL GROUP BY b.
En el siguiente ejemplo se devuelve el costo de los productos de la tabla de pedidos agrupados en función tanto de las categorías de los productos como del tipo de productos vendidos.
```
SELECT category, product, sum(cost) as total
FROM orders
GROUP BY GROUPING SETS(category, product);
category | product | total
----------------------+----------------------+-------
computers | | 2100
cellphones | | 1610
| laptop | 2050
| smartphone | 1610
| mouse | 50
(5 rows)
```
## *ROLLUP*
Se supone una jerarquía en la que las columnas anteriores se consideran las principales de las columnas posteriores. ROLLUP agrupa los datos por las columnas proporcionadas y devuelve filas de subtotales adicionales que representan los totales de todos los niveles de agrupación de columnas, además de las filas agrupadas. Por ejemplo, puede usar GROUP BY ROLLUP ((a), (b)) para devolver un conjunto de resultados agrupado primero por a y luego por b, suponiendo que b es una subsección de a. ROLLUP también devuelve una fila con todo el conjunto de resultados sin agrupar columnas.
GROUP BY ROLLUP((a), (b)) equivale a GROUP BY GROUPING SETS((a,b), (a), ()).
En el siguiente ejemplo se devuelve el costo de los productos de la tabla de pedidos agrupados primero por categoría y, a continuación, por producto, con el producto como una subdivisión de la categoría.
```
SELECT category, product, sum(cost) as total
FROM orders
GROUP BY ROLLUP(category, product) ORDER BY 1,2;
category | product | total
----------------------+----------------------+-------
cellphones | smartphone | 1610
cellphones | | 1610
computers | laptop | 2050
computers | mouse | 50
computers | | 2100
| | 3710
(6 rows)
```
## *CUBE*
Agrupa los datos por las columnas proporcionadas y devuelve filas de subtotales adicionales que representan los totales de todos los niveles de agrupación de columnas, además de las filas agrupadas. CUBE devuelve las mismas filas que ROLLUP, a la vez que agrega filas de subtotales adicionales por cada combinación de columnas de agrupación no incluidas en ROLLUP. Por ejemplo, puede usar GROUP BY CUBE ((a), (b)) para devolver un conjunto de resultados agrupado primero por a y luego por b, suponiendo que b es una subsección de a. CUBE también devuelve una fila con todo el conjunto de resultados sin agrupar columnas.
GROUP BY CUBE((a), (b)) equivale a GROUP BY GROUPING SETS((a, b), (a), (b), ()).
En el siguiente ejemplo se devuelve el costo de los productos de la tabla de pedidos agrupados primero por categoría y, a continuación, por producto, con el producto como una subdivisión de la categoría. A diferencia del ejemplo anterior de ROLLUP, la instrucción devuelve resultados para cada combinación de columnas de agrupación.
```
SELECT category, product, sum(cost) as total
FROM orders
GROUP BY CUBE(category, product) ORDER BY 1,2;
category | product | total
----------------------+----------------------+-------
cellphones | smartphone | 1610
cellphones | | 1610
computers | laptop | 2050
computers | mouse | 50
computers | | 2100
| laptop | 2050
| mouse | 50
| smartphone | 1610
| | 3710
(9 rows)
```
# Cláusula HAVING
La cláusula HAVING aplica una condición al conjunto de resultados agrupado intermedio que una consulta devuelve.
## Sintaxis
```
[ HAVING condition ]
```
Por ejemplo, puede limitar los resultados de una función SUM:
```
having sum(pricepaid) >10000
```
La condición HAVING se aplica después de que se aplican todas las condiciones de la cláusula WHERE y se completan todas las operaciones de GROUP BY.
La condición toma la misma forma que cualquier condición de la cláusula WHERE.
## Notas de uso
+ Cualquier columna a la que se haga referencia en una condición de la cláusula HAVING debe ser una columna de agrupación o una columna que haga referencia al resultado de una función agregada.
+ En una cláusula HAVING, no se puede especificar:
+ Un número ordinal que hace referencia a un elemento de la lista de selección. Solo las cláusulas GROUP BY y ORDER BY aceptan números ordinales.
## Ejemplos
La siguiente consulta calcula las ventas de tickets totales para todos los eventos por nombre y, luego, elimina eventos donde las ventas totales sean inferiores a \$1800 000. La condición HAVING se aplica a los resultados de la función agregada en la lista de selección: `sum(pricepaid)`.
```
select eventname, sum(pricepaid)
from sales join event on sales.eventid = event.eventid
group by 1
having sum(pricepaid) > 800000
order by 2 desc, 1;
eventname | sum
------------------+-----------
Mamma Mia! | 1135454.00
Spring Awakening | 972855.00
The Country Girl | 910563.00
Macbeth | 862580.00
Jersey Boys | 811877.00
Legally Blonde | 804583.00
(6 rows)
```
La siguiente consulta calcula un conjunto de resultados similar. No obstante, en este caso, la condición HAVING se aplica a una agregación que no se especifica en la lista de selección: `sum(qtysold)`. Los eventos que no vendieron más de 2 000 tickets se eliminan del resultado final.
```
select eventname, sum(pricepaid)
from sales join event on sales.eventid = event.eventid
group by 1
having sum(qtysold) >2000
order by 2 desc, 1;
eventname | sum
------------------+-----------
Mamma Mia! | 1135454.00
Spring Awakening | 972855.00
The Country Girl | 910563.00
Macbeth | 862580.00
Jersey Boys | 811877.00
Legally Blonde | 804583.00
Chicago | 790993.00
Spamalot | 714307.00
(8 rows)
```
# Operadores de establecimiento
Los *operadores de conjunto* se utilizan para comparar y combinar los resultados de dos expresiones de consulta distintas.
AWS Clean Rooms Spark SQL admite los siguientes operadores de conjunto que se muestran en la siguiente tabla.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/clean-rooms/latest/sql-reference/UNION.html)
Por ejemplo, si desea saber qué usuarios de un sitio web son compradores y vendedores pero los nombres de usuario están almacenados en diferentes columnas o tablas, puede buscar la *intersección* de estos dos tipos de usuarios. Si desea saber qué usuarios de un sitio web son compradores pero no vendedores, puede usar el operador EXCEPT para buscar la *diferencia* entre las dos listas de usuarios. Si desea crear una lista de todos los usuarios, independientemente de la función, puede usar el operador UNION.
**nota**
Las cláusulas ORDER BY, LIMIT, SELECT TOP y OFFSET no se pueden utilizar en las expresiones de consulta combinadas por los operadores de conjunto UNION, UNION ALL, INTERSECT y EXCEPT.
**Topics**
+ [Sintaxis](#UNION-synopsis)
+ [Parameters](#UNION-parameters)
+ [Orden de evaluación para los operadores de conjunto](#UNION-order-of-evaluation-for-set-operators)
+ [Notas de uso](#UNION-usage-notes)
+ [Ejemplo de consultas UNION](example_union_query.md)
+ [Ejemplo de consultas UNION ALL](example_unionall_query.md)
+ [Ejemplo de consultas INTERSECT](example_intersect_query.md)
+ [Ejemplo de consulta EXCEPT](Example_EXCEPT_query.md)
## Sintaxis
```
subquery1
{ { UNION [ ALL | DISTINCT ] |
INTERSECT [ ALL | DISTINCT ] |
EXCEPT [ ALL | DISTINCT ] } subquery2 } [...] }
```
## Parameters
*subconsulta1, subconsulta2*
Expresión de consulta que corresponde, en forma de lista de selección, a una segunda expresión de consulta que sigue al operador UNION, UNION ALL, INTERSECT, INTERSECT ALL, EXCEPT o EXCEPT ALL. Las dos expresiones deben contener la misma cantidad de columnas de salida con tipos de datos compatibles; de lo contrario, no se podrán comparar ni fusionar los dos conjuntos de resultados. Las operaciones de conjunto no permiten la conversión implícita entre diferentes categorías de tipos de datos. Para obtener más información, consulte [Conversión y compatibilidad de tipos](s_Type_conversion.md).
Puede crear consultas que contengan una cantidad ilimitada de expresiones de consulta y vincularlas con operadores UNION, INTERSECT y EXCEPT en cualquier combinación. Por ejemplo, la siguiente estructura de consulta es válida, suponiendo que las tablas T1, T2 y T3 contienen conjuntos de columnas compatibles:
```
select * from t1
union
select * from t2
except
select * from t3
```
UNIÓN [TODOS \$1 DISTINTOS]
Operación de conjunto que devuelve filas de dos expresiones de consulta, independientemente de si las filas provienen de una o ambas expresiones.
INTERSECAR [TODOS \$1 DISTINTOS]
Operación de conjunto que devuelve filas que provienen de dos expresiones de consulta. Las filas que no se devuelven en las dos expresiones se descartan.
EXCEPTO [TODOS \$1 DISTINTOS]
Operación de conjunto que devuelve filas que provienen de una de las dos expresiones de consulta. Para calificar para el resultado, las filas deben existir en la primera tabla de resultados, pero no en la segunda.
EXCEPT ALL no elimina los duplicados de las filas de resultados.
MINUS y EXCEPT son sinónimos exactos.
## Orden de evaluación para los operadores de conjunto
Los operadores de conjunto UNION y EXCEPT se asocian por la izquierda. Si no se especifican paréntesis para establecer el orden de prioridad, los operadores se evalúan de izquierda a derecha. Por ejemplo, en la siguiente consulta, UNION de T1 y T2 se evalúa primero, luego se realiza la operación EXCEPT en el resultado de UNION:
```
select * from t1
union
select * from t2
except
select * from t3
```
El operador INTERSECT prevalece sobre los operadores UNION y EXCEPT cuando se utiliza una combinación de operadores en la misma consulta. Por ejemplo, la siguiente consulta evalúa la intersección de T2 y T3, y luego unirá el resultado con T1:
```
select * from t1
union
select * from t2
intersect
select * from t3
```
Al agregar paréntesis, puede aplicar un orden diferente de evaluación. En el siguiente caso, el resultado de la unión de T1 y T2 está intersectado con T3, y la consulta probablemente produzca un resultado diferente.
```
(select * from t1
union
select * from t2)
intersect
(select * from t3)
```
## Notas de uso
+ Los nombres de la columnas que se devuelven en el resultado de una consulta de operación de conjunto son los nombres (o alias) de la columnas de las tablas de la primera expresión de consulta. Debido a que estos nombres de columnas pueden ser confusos, porque los valores de la columna provienen de tablas de cualquier lado del operador de conjunto, se recomienda proporcionar alias significativos para el conjunto de resultados.
+ Cuando las consultas del operador de conjunto devuelven resultados decimales, las columnas de resultado correspondientes se promueven a devolver la misma precisión y escala. Por ejemplo, en la siguiente consulta, donde T1.REVENUE es una columna DECIMAL(10,2) y T2.REVENUE es una columna DECIMAL(8,4), el resultado decimal se promueve a DECIMAL(12,4):
```
select t1.revenue union select t2.revenue;
```
La escala es `4` ya que es la escala máxima de las dos columnas. La precisión es `12` ya que T1.REVENUE requiere 8 dígitos a la izquierda del punto decimal (12 - 4 = 8). Este tipo de promoción garantiza que todos los valores de ambos lados de UNION encajen en el resultado. Para valores de 64 bits, la precisión de resultados máxima es 19 y la escala de resultados máxima es 18. Para valores de 128 bits, la precisión de resultados máxima es 38 y la escala de resultados máxima es 37.
Si el tipo de datos resultante supera los límites de AWS Clean Rooms precisión y escala, la consulta devuelve un error.
+ En el caso de las operaciones de conjunto, las dos filas se tratan como idénticas si, para cada par de columnas correspondiente, los dos valores de datos son *iguales* o *NULL*. Por ejemplo, si las tablas T1 y T2 contienen una columna y una fila, y esa fila es NULL en ambas tablas, una operación INTERSECT sobre esas tablas devuelve esa fila.
# Ejemplo de consultas UNION
En la siguiente consulta UNION, las filas de la tabla SALES se fusionan con las filas de la tabla LISTING. Se seleccionan tres columnas compatibles de cada tabla. En este caso, las columnas correspondientes tienen los mismos nombres y tipos de datos.
```
select listid, sellerid, eventid from listing
union select listid, sellerid, eventid from sales
listid | sellerid | eventid
--------+----------+---------
1 | 36861 | 7872
2 | 16002 | 4806
3 | 21461 | 4256
4 | 8117 | 4337
5 | 1616 | 8647
```
En el siguiente ejemplo, se muestra cómo puede agregar un valor literal para el resultado de una consulta UNION para ver cuál expresión de consulta produjo cada fila en el conjunto de resultados. La consulta identifica filas de la primera expresión de consulta como "B" (por compradores, "buyers" en inglés) y filas de la segunda expresión de consulta como "S" (por vendedores, "sellers" en inglés).
La consulta identifica compradores y vendedores para transacciones de ticket que cuestan \$110 000 o más. La única diferencia entre las dos expresiones de consulta de cualquier lado del operador UNION es la columna de combinación para la tabla SALES.
```
select listid, lastname, firstname, username,
pricepaid as price, 'S' as buyorsell
from sales, users
where sales.sellerid=users.userid
and pricepaid >=10000
union
select listid, lastname, firstname, username, pricepaid,
'B' as buyorsell
from sales, users
where sales.buyerid=users.userid
and pricepaid >=10000
listid | lastname | firstname | username | price | buyorsell
--------+----------+-----------+----------+-----------+-----------
209658 | Lamb | Colette | VOR15LYI | 10000.00 | B
209658 | West | Kato | ELU81XAA | 10000.00 | S
212395 | Greer | Harlan | GXO71KOC | 12624.00 | S
212395 | Perry | Cora | YWR73YNZ | 12624.00 | B
215156 | Banks | Patrick | ZNQ69CLT | 10000.00 | S
215156 | Hayden | Malachi | BBG56AKU | 10000.00 | B
```
En el siguiente ejemplo, se utiliza un operador UNION ALL porque las filas duplicadas, si se encuentran, deben conservarse en el resultado. Para una serie de eventos específica IDs, la consulta devuelve 0 o más filas por cada venta asociada a cada evento y 0 o 1 fila por cada anuncio de ese evento. IDs Los eventos son únicos para cada fila de las tablas LISTING y EVENT, pero es posible que haya varias ventas para la misma combinación de evento y anuncio IDs en la tabla VENTAS.
La tercera columna en el conjunto de resultados identifica la fuente de la fila. Si viene de la tabla SALES, se marca "Sí" en la columna SALESROW. (SALESROW es un alias para SALES.LISTID). Si la fila proviene de la tabla LISTING, se marca "No" en la columna SALESROW.
En este caso, el conjunto de resultados consta de tres filas de ventas para la lista 500, evento 7787. En otras palabras, se llevaron a cabo tres transacciones diferentes para esta combinación de lista y evento. Los otros dos anuncios, 501 y 502, no generaron ventas, por lo que la única fila que la consulta genera para estas listas IDs proviene de la tabla de anuncios (SALESROW = «No»).
```
select eventid, listid, 'Yes' as salesrow
from sales
where listid in(500,501,502)
union all
select eventid, listid, 'No'
from listing
where listid in(500,501,502)
eventid | listid | salesrow
---------+--------+----------
7787 | 500 | No
7787 | 500 | Yes
7787 | 500 | Yes
7787 | 500 | Yes
6473 | 501 | No
5108 | 502 | No
```
Si ejecuta la misma consulta sin la palabra clave ALL, el resultado conserva solo una de las transacciones de ventas.
```
select eventid, listid, 'Yes' as salesrow
from sales
where listid in(500,501,502)
union
select eventid, listid, 'No'
from listing
where listid in(500,501,502)
eventid | listid | salesrow
---------+--------+----------
7787 | 500 | No
7787 | 500 | Yes
6473 | 501 | No
5108 | 502 | No
```
# Ejemplo de consultas UNION ALL
En el siguiente ejemplo, se utiliza un operador UNION ALL porque las filas duplicadas, si se encuentran, deben conservarse en el resultado. Para una serie de eventos específica IDs, la consulta devuelve 0 o más filas por cada venta asociada a cada evento y 0 o 1 fila por cada anuncio de ese evento. IDs Los eventos son únicos para cada fila de las tablas LISTING y EVENT, pero es posible que haya varias ventas para la misma combinación de evento y anuncio IDs en la tabla VENTAS.
La tercera columna en el conjunto de resultados identifica la fuente de la fila. Si viene de la tabla SALES, se marca "Sí" en la columna SALESROW. (SALESROW es un alias para SALES.LISTID). Si la fila proviene de la tabla LISTING, se marca "No" en la columna SALESROW.
En este caso, el conjunto de resultados consta de tres filas de ventas para la lista 500, evento 7787. En otras palabras, se llevaron a cabo tres transacciones diferentes para esta combinación de lista y evento. Los otros dos anuncios, 501 y 502, no generaron ventas, por lo que la única fila que la consulta genera para estas listas IDs proviene de la tabla de anuncios (SALESROW = «No»).
```
select eventid, listid, 'Yes' as salesrow
from sales
where listid in(500,501,502)
union all
select eventid, listid, 'No'
from listing
where listid in(500,501,502)
eventid | listid | salesrow
---------+--------+----------
7787 | 500 | No
7787 | 500 | Yes
7787 | 500 | Yes
7787 | 500 | Yes
6473 | 501 | No
5108 | 502 | No
```
Si ejecuta la misma consulta sin la palabra clave ALL, el resultado conserva solo una de las transacciones de ventas.
```
select eventid, listid, 'Yes' as salesrow
from sales
where listid in(500,501,502)
union
select eventid, listid, 'No'
from listing
where listid in(500,501,502)
eventid | listid | salesrow
---------+--------+----------
7787 | 500 | No
7787 | 500 | Yes
6473 | 501 | No
5108 | 502 | No
```
# Ejemplo de consultas INTERSECT
Compare el siguiente ejemplo con el primer ejemplo de UNION. La única diferencia entre los dos ejemplos es el operador de conjunto que se utiliza, pero los resultados son muy diferentes. Solo una de las filas es igual:
```
235494 | 23875 | 8771
```
Esta es la única fila en el resultado limitado de 5 filas que se encontró en ambas tablas.
```
select listid, sellerid, eventid from listing
intersect
select listid, sellerid, eventid from sales
listid | sellerid | eventid
--------+----------+---------
235494 | 23875 | 8771
235482 | 1067 | 2667
235479 | 1589 | 7303
235476 | 15550 | 793
235475 | 22306 | 7848
```
La siguiente consulta busca eventos (para los que se vendieron tickets) que ocurrieron en lugares en la Ciudad de Nueva York y Los Ángeles en marzo. La diferencia entre las dos expresiones de consulta es la restricción en la columna VENUECITY.
```
select distinct eventname from event, sales, venue
where event.eventid=sales.eventid and event.venueid=venue.venueid
and date_part(month,starttime)=3 and venuecity='Los Angeles'
intersect
select distinct eventname from event, sales, venue
where event.eventid=sales.eventid and event.venueid=venue.venueid
and date_part(month,starttime)=3 and venuecity='New York City';
eventname
----------------------------
A Streetcar Named Desire
Dirty Dancing
Electra
Running with Annalise
Hairspray
Mary Poppins
November
Oliver!
Return To Forever
Rhinoceros
South Pacific
The 39 Steps
The Bacchae
The Caucasian Chalk Circle
The Country Girl
Wicked
Woyzeck
```
# Ejemplo de consulta EXCEPT
La tabla CATEGORY de la base de datos contiene las siguientes 11 filas:
```
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
1 | Sports | MLB | Major League Baseball
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
6 | Shows | Musicals | Musical theatre
7 | Shows | Plays | All non-musical theatre
8 | Shows | Opera | All opera and light opera
9 | Concerts | Pop | All rock and pop music concerts
10 | Concerts | Jazz | All jazz singers and bands
11 | Concerts | Classical | All symphony, concerto, and choir concerts
(11 rows)
```
Supongamos que una tabla CATEGORY\$1STAGE (una tabla provisional) contiene una fila adicional:
```
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
1 | Sports | MLB | Major League Baseball
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
6 | Shows | Musicals | Musical theatre
7 | Shows | Plays | All non-musical theatre
8 | Shows | Opera | All opera and light opera
9 | Concerts | Pop | All rock and pop music concerts
10 | Concerts | Jazz | All jazz singers and bands
11 | Concerts | Classical | All symphony, concerto, and choir concerts
12 | Concerts | Comedy | All stand up comedy performances
(12 rows)
```
Devuelve la diferencia entre las dos tablas. En otras palabras, devuelve filas que están en la tabla CATEGORY\$1STAGE pero no en la tabla CATEGORY:
```
select * from category_stage
except
select * from category;
catid | catgroup | catname | catdesc
-------+----------+---------+----------------------------------
12 | Concerts | Comedy | All stand up comedy performances
(1 row)
```
La siguiente consulta equivalente usa el sinónimo MINUS.
```
select * from category_stage
minus
select * from category;
catid | catgroup | catname | catdesc
-------+----------+---------+----------------------------------
12 | Concerts | Comedy | All stand up comedy performances
(1 row)
```
Si revierte el orden de las expresiones SELECT, la consulta no devuelve filas.
# Cláusula ORDER BY
La cláusula ORDER BY ordena el conjunto de resultados de una consulta.
**nota**
La expresión ORDER BY más externa solo debe tener columnas que estén en la lista de selección.
**Topics**
+ [Sintaxis](#ORDER_BY_clause-synopsis)
+ [Parameters](#ORDER_BY_clause-parameters)
+ [Notas de uso](#ORDER_BY_usage_notes)
+ [Ejemplos con ORDER BY](Examples_with_ORDER_BY.md)
## Sintaxis
```
[ ORDER BY expression [ ASC | DESC ] ]
[ NULLS FIRST | NULLS LAST ]
[ LIMIT { count | ALL } ]
[ OFFSET start ]
```
## Parameters
*expression*
Un marco que especifica el orden de clasificación de los resultados de las consultas. Consta de una o más columnas en la lista de selección. Los resultados se devuelven en función de la ordenación UTF-8 binaria. También puede especificar lo siguiente:
+ Números ordinales que representan la posición de las entradas de la lista de selección (o la posición de columnas en la tabla si no existe una lista de selección)
+ Alias que definen las entradas de la lista de selección
Cuando la cláusula ORDER BY contiene varias expresiones, el conjunto de resultados se ordena según la primera expresión, luego se aplica la segunda expresión a las filas que tienen valores coincidentes de la primera expresión, etc.
ASC \$1 DESC
Opción que define el orden de ordenación para la expresión, de la siguiente manera:
+ ASC: ascendente (por ejemplo, de menor a mayor para valores numéricos y de la A a la Z para cadenas con caracteres). Si no se especifica ninguna opción, los datos se ordenan, de manera predeterminada, en orden ascendente.
+ DESC: descendente (de mayor a menor para valores numéricos y de la Z a la A para cadenas).
NULLS FIRST \$1 NULLS LAST
Opción que especifica si los valores NULL se deben ordenar en primer lugar, antes de los valores no nulos, o al final, después de los valores no nulos. De manera predeterminada, los valores NULL se ordenan y clasificación al final en orden ASC, y se ordenan y se clasifican primero en orden DESC.
LIMIT *number (número)* \$1 ALL
Opción que controla la cantidad de filas ordenadas que una consulta devuelve. El número LIMIT deber ser un entero positivo; el valor máximo es `2147483647`.
LIMIT 0 no devuelve filas. Puede usar la sintaxis para realizar pruebas: para verificar que una consulta se ejecuta (sin mostrar filas) o para devolver una lista de columnas de una tabla. Una cláusula ORDER BY es redundante si está utilizando LIMIT 0 para devolver una lista de columnas. El predeterminado es LIMIT ALL.
OFFSET *start (inicio)*
Opción que especifica que se omita el número de filas que hay delante de *start (inicio)* antes de comenzar a devolver filas. El número OFFSET deber ser un entero positivo; el valor máximo es `2147483647`. Cuando se utiliza con la opción LIMIT, las filas OFFSET se omiten antes de comenzar a contar las filas LIMIT que se devuelven. Si no se utiliza la opción LIMIT, la cantidad de filas del conjunto de resultados se reduce por la cantidad de filas que se omiten. Las filas omitidas por una cláusula OFFSET aún deben analizarse, por lo que puede ser ineficiente utilizar un valor OFFSET grande.
## Notas de uso
Tenga en cuenta el siguiente comportamiento esperado con las cláusulas ORDER BY:
+ Los valores NULL son considerados "superiores" a todos los otros valores. Con el orden ascendente predeterminado, los valores NULL se ordenan al final. Para cambiar este comportamiento, utilice la opción NULLS FIRST.
+ Cuando una consulta no contiene una cláusula ORDER BY, el sistema devuelve conjuntos de resultados sin un orden predecible de las filas. Si se ejecuta la misma consulta dos veces, puede devolver el conjunto de resultados en un orden diferente.
+ Las opciones LIMIT y OFFSET pueden utilizarse sin una cláusula ORDER BY; no obstante, para devolver un conjunto consistente de filas, use estas opciones junto con ORDER BY.
+ En cualquier sistema paralelo AWS Clean Rooms, por ejemplo, cuando ORDER BY no produce un orden único, el orden de las filas no es determinista. Es decir, si la expresión ORDER BY produce valores duplicados, el orden de retorno de esas filas puede variar de un sistema a otro o de una serie AWS Clean Rooms a otra.
+ AWS Clean Rooms no admite cadenas literales en las cláusulas ORDER BY.
# Ejemplos con ORDER BY
Devuelva todas las 11 filas de la tabla CATEGORY, ordenadas por la segunda columna, CATGROUP. Para los resultados que tienen el mismo valor CATGROUP, ordene los valores de la columna CATDESC por la longitud de la cadena de caracteres. Ordene, a continuación, por columna CATID y CATNAME.
```
select * from category order by 2, 1, 3;
catid | catgroup | catname | catdesc
-------+----------+-----------+----------------------------------------
10 | Concerts | Jazz | All jazz singers and bands
9 | Concerts | Pop | All rock and pop music concerts
11 | Concerts | Classical | All symphony, concerto, and choir conce
6 | Shows | Musicals | Musical theatre
7 | Shows | Plays | All non-musical theatre
8 | Shows | Opera | All opera and light opera
5 | Sports | MLS | Major League Soccer
1 | Sports | MLB | Major League Baseball
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
(11 rows)
```
Devuelva las columnas seleccionadas de la tabla SALES, ordenadas por los valores QTYSOLD más altos. Limite el resultado a las primeras 10 filas:
```
select salesid, qtysold, pricepaid, commission, saletime from sales
order by qtysold, pricepaid, commission, salesid, saletime desc
salesid | qtysold | pricepaid | commission | saletime
---------+---------+-----------+------------+---------------------
15401 | 8 | 272.00 | 40.80 | 2008-03-18 06:54:56
61683 | 8 | 296.00 | 44.40 | 2008-11-26 04:00:23
90528 | 8 | 328.00 | 49.20 | 2008-06-11 02:38:09
74549 | 8 | 336.00 | 50.40 | 2008-01-19 12:01:21
130232 | 8 | 352.00 | 52.80 | 2008-05-02 05:52:31
55243 | 8 | 384.00 | 57.60 | 2008-07-12 02:19:53
16004 | 8 | 440.00 | 66.00 | 2008-11-04 07:22:31
489 | 8 | 496.00 | 74.40 | 2008-08-03 05:48:55
4197 | 8 | 512.00 | 76.80 | 2008-03-23 11:35:33
16929 | 8 | 568.00 | 85.20 | 2008-12-19 02:59:33
```
Devuelve una lista de columnas y ninguna fila a través de la sintaxis LIMIT 0:
```
select * from venue limit 0;
venueid | venuename | venuecity | venuestate | venueseats
---------+-----------+-----------+------------+------------
(0 rows)
```
# Ejemplos de subconsultas
En los siguientes ejemplos se muestran diferentes maneras en que las subconsultas encajan en las consultas SELECT. Para ver otro ejemplo del uso de las subconsultas, consulte [Ejemplo](join-clause.md#Join_examples).
## Subconsulta de la lista SELECT
En el siguiente ejemplo, se observa una subconsulta en la lista SELECT. Esta subconsulta es *escalar*: devuelve solamente una columna y un valor, que se repite en el resultado de cada fila que se devuelve desde la consulta externa. La consulta compara el valor Q1SALES que la subconsulta computa con valores de venta de otros dos trimestres (2 y 3) en 2008, como la consulta externa lo define.
```
select qtr, sum(pricepaid) as qtrsales,
(select sum(pricepaid)
from sales join date on sales.dateid=date.dateid
where qtr='1' and year=2008) as q1sales
from sales join date on sales.dateid=date.dateid
where qtr in('2','3') and year=2008
group by qtr
order by qtr;
qtr | qtrsales | q1sales
-------+-------------+-------------
2 | 30560050.00 | 24742065.00
3 | 31170237.00 | 24742065.00
(2 rows)
```
## Subconsulta de la cláusula WHERE
En el siguiente ejemplo, se observa una subconsulta de tabla en la cláusula WHERE. Esta subconsulta produce varias filas. En este caso, las filas contienen solo una columna, pero las subconsultas de la tabla pueden contener varias columnas y filas, como cualquier otra tabla.
La consulta busca los principales 10 vendedores en términos de cantidad máxima de tickets vendidos. La lista de los 10 principales está limitada por la subconsulta, que elimina usuarios que viven en ciudades donde hay lugares de venta de tickets. Esta consulta puede escribirse en diferentes maneras; por ejemplo, se puede volver a escribir la subconsulta como una combinación dentro de la consulta principal.
```
select firstname, lastname, city, max(qtysold) as maxsold
from users join sales on users.userid=sales.sellerid
where users.city not in(select venuecity from venue)
group by firstname, lastname, city
order by maxsold desc, city desc
limit 10;
firstname | lastname | city | maxsold
-----------+-----------+----------------+---------
Noah | Guerrero | Worcester | 8
Isadora | Moss | Winooski | 8
Kieran | Harrison | Westminster | 8
Heidi | Davis | Warwick | 8
Sara | Anthony | Waco | 8
Bree | Buck | Valdez | 8
Evangeline | Sampson | Trenton | 8
Kendall | Keith | Stillwater | 8
Bertha | Bishop | Stevens Point | 8
Patricia | Anderson | South Portland | 8
(10 rows)
```
## Subconsultas de la cláusula WITH
Consulte [Cláusula WITH](WITH_clause.md).
# Subconsultas correlacionadas
En el siguiente ejemplo, se observa una *subconsulta correlacionada* en la cláusula WHERE; este tipo de subconsulta contiene una o varias correlaciones entre sus columnas y las columnas producidas por la consulta externa. En este caso, la correlación es `where s.listid=l.listid`. Para cada fila que la consulta externa produce, se ejecuta la subconsulta para calificar o descalificar la fila.
```
select salesid, listid, sum(pricepaid) from sales s
where qtysold=
(select max(numtickets) from listing l
where s.listid=l.listid)
group by 1,2
order by 1,2
limit 5;
salesid | listid | sum
--------+--------+----------
27 | 28 | 111.00
81 | 103 | 181.00
142 | 149 | 240.00
146 | 152 | 231.00
194 | 210 | 144.00
(5 rows)
```
## Patrones de subconsultas correlacionadas que no se admiten
El planificador de consultas usa un método de reescritura de consulta denominado descorrelación de subconsulta para optimizar varios patrones de subconsultas correlacionadas para la ejecución en un entorno MPP. Algunos tipos de subconsultas correlacionadas siguen patrones que no AWS Clean Rooms pueden decorrelacionarse ni son compatibles. Las consultas que contienen las siguientes referencias de correlación devuelven errores:
+ Referencias de correlación que omiten un bloque de consulta, también conocidas como "referencias de correlación con nivel omitido". Por ejemplo, en la siguiente consulta, el bloque que contiene la referencia de correlación y el bloque omitido están conectados por un predicado NOT EXISTS:
```
select event.eventname from event
where not exists
(select * from listing
where not exists
(select * from sales where event.eventid=sales.eventid));
```
En este caso, el bloque omitido es la subconsulta que se ejecuta contra la tabla LISTING. La referencia de correlación correlaciona las tablas EVENT y SALES.
+ Referencias de correlación de una subconsulta que es parte de una cláusula ON en una consulta externa:
```
select * from category
left join event
on category.catid=event.catid and eventid =
(select max(eventid) from sales where sales.eventid=event.eventid);
```
La cláusula ON contiene una referencia de correlación de SALES en la subconsulta a EVENT en la consulta externa.
+ Referencias de correlación sensibles a valores nulos a una tabla del sistema. AWS Clean Rooms Por ejemplo:
```
select attrelid
from my_locks sl, my_attribute
where sl.table_id=my_attribute.attrelid and 1 not in
(select 1 from my_opclass where sl.lock_owner = opcowner);
```
+ Referencias de correlación de una subconsulta que contiene una función de ventana.
```
select listid, qtysold
from sales s
where qtysold not in
(select sum(numtickets) over() from listing l where s.listid=l.listid);
```
+ Referencias en una columna GROUP BY a los resultados de una subconsulta correlacionada. Por ejemplo:
```
select listing.listid,
(select count (sales.listid) from sales where sales.listid=listing.listid) as list
from listing
group by list, listing.listid;
```
+ Referencias de correlación de una subconsulta con una función agregada y una cláusula GROUP BY, conectadas a la consulta externa por un predicado IN. (Esta restricción no se aplica a las funciones agregadas MIN y MAX). Por ejemplo:
```
select * from listing where listid in
(select sum(qtysold)
from sales
where numtickets>4
group by salesid);
```