mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-19 14:11:58 +00:00
cd14f9ebcb
* split up select.md * array-join.md basic refactoring * distinct.md basic refactoring * format.md basic refactoring * from.md basic refactoring * group-by.md basic refactoring * having.md basic refactoring * additional index.md refactoring * into-outfile.md basic refactoring * join.md basic refactoring * limit.md basic refactoring * limit-by.md basic refactoring * order-by.md basic refactoring * prewhere.md basic refactoring * adjust operators/index.md links * adjust sample.md links * adjust more links * adjust operatots links * fix some links * adjust aggregate function article titles * basic refactor of remaining select clauses * absolute paths in make_links.sh * run make_links.sh * remove old select.md locations * translate docs/es * translate docs/fr * translate docs/fa * remove old operators.md location * change operators.md links * adjust links in docs/es * adjust links in docs/es * minor texts adjustments * wip * update machine translations to use new links * fix changelog * es build fixes * get rid of some select.md links * temporary adjust ru links * temporary adjust more ru links * improve curly brace handling * adjust ru as well * fa build fix * ru link fixes * zh link fixes * temporary disable part of anchor checks
283 lines
10 KiB
Markdown
283 lines
10 KiB
Markdown
---
|
|
machine_translated: true
|
|
machine_translated_rev: 72537a2d527c63c07aa5d2361a8829f3895cf2bd
|
|
---
|
|
|
|
# ARRAY JOIN Cláusula {#select-array-join-clause}
|
|
|
|
Es una operación común para las tablas que contienen una columna de matriz para producir una nueva tabla que tiene una columna con cada elemento de matriz individual de esa columna inicial, mientras que los valores de otras columnas se duplican. Este es el caso básico de lo que `ARRAY JOIN` cláusula hace.
|
|
|
|
Su nombre proviene del hecho de que se puede considerar como una ejecución `JOIN` con una matriz o estructura de datos anidada. La intención es similar a la [arrayJoin](../../functions/array-join.md#functions_arrayjoin) función, pero la funcionalidad de la cláusula es más amplia.
|
|
|
|
Sintaxis:
|
|
|
|
``` sql
|
|
SELECT <expr_list>
|
|
FROM <left_subquery>
|
|
[LEFT] ARRAY JOIN <array>
|
|
[WHERE|PREWHERE <expr>]
|
|
...
|
|
```
|
|
|
|
Solo puede especificar uno `ARRAY JOIN` cláusula en una `SELECT` consulta.
|
|
|
|
Tipos admitidos de `ARRAY JOIN` se enumeran a continuación:
|
|
|
|
- `ARRAY JOIN` - En el caso base, las matrices vacías no se incluyen en el resultado de `JOIN`.
|
|
- `LEFT ARRAY JOIN` - El resultado de `JOIN` contiene filas con matrices vacías. El valor de una matriz vacía se establece en el valor predeterminado para el tipo de elemento de matriz (normalmente 0, cadena vacía o NULL).
|
|
|
|
## Ejemplos básicos de ARRAY JOIN {#basic-array-join-examples}
|
|
|
|
Los siguientes ejemplos demuestran el uso de la `ARRAY JOIN` y `LEFT ARRAY JOIN` clausula. Vamos a crear una tabla con un [Matriz](../../../sql-reference/data-types/array.md) escriba la columna e inserte valores en ella:
|
|
|
|
``` sql
|
|
CREATE TABLE arrays_test
|
|
(
|
|
s String,
|
|
arr Array(UInt8)
|
|
) ENGINE = Memory;
|
|
|
|
INSERT INTO arrays_test
|
|
VALUES ('Hello', [1,2]), ('World', [3,4,5]), ('Goodbye', []);
|
|
```
|
|
|
|
``` text
|
|
┌─s───────────┬─arr─────┐
|
|
│ Hello │ [1,2] │
|
|
│ World │ [3,4,5] │
|
|
│ Goodbye │ [] │
|
|
└─────────────┴─────────┘
|
|
```
|
|
|
|
El siguiente ejemplo utiliza el `ARRAY JOIN` clausula:
|
|
|
|
``` sql
|
|
SELECT s, arr
|
|
FROM arrays_test
|
|
ARRAY JOIN arr;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─arr─┐
|
|
│ Hello │ 1 │
|
|
│ Hello │ 2 │
|
|
│ World │ 3 │
|
|
│ World │ 4 │
|
|
│ World │ 5 │
|
|
└───────┴─────┘
|
|
```
|
|
|
|
El siguiente ejemplo utiliza el `LEFT ARRAY JOIN` clausula:
|
|
|
|
``` sql
|
|
SELECT s, arr
|
|
FROM arrays_test
|
|
LEFT ARRAY JOIN arr;
|
|
```
|
|
|
|
``` text
|
|
┌─s───────────┬─arr─┐
|
|
│ Hello │ 1 │
|
|
│ Hello │ 2 │
|
|
│ World │ 3 │
|
|
│ World │ 4 │
|
|
│ World │ 5 │
|
|
│ Goodbye │ 0 │
|
|
└─────────────┴─────┘
|
|
```
|
|
|
|
## Uso de alias {#using-aliases}
|
|
|
|
Se puede especificar un alias para una matriz en el `ARRAY JOIN` clausula. En este caso, este alias puede acceder a un elemento de matriz, pero el nombre original tiene acceso a la matriz en sí. Ejemplo:
|
|
|
|
``` sql
|
|
SELECT s, arr, a
|
|
FROM arrays_test
|
|
ARRAY JOIN arr AS a;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─arr─────┬─a─┐
|
|
│ Hello │ [1,2] │ 1 │
|
|
│ Hello │ [1,2] │ 2 │
|
|
│ World │ [3,4,5] │ 3 │
|
|
│ World │ [3,4,5] │ 4 │
|
|
│ World │ [3,4,5] │ 5 │
|
|
└───────┴─────────┴───┘
|
|
```
|
|
|
|
Usando alias, puede realizar `ARRAY JOIN` con una matriz externa. Por ejemplo:
|
|
|
|
``` sql
|
|
SELECT s, arr_external
|
|
FROM arrays_test
|
|
ARRAY JOIN [1, 2, 3] AS arr_external;
|
|
```
|
|
|
|
``` text
|
|
┌─s───────────┬─arr_external─┐
|
|
│ Hello │ 1 │
|
|
│ Hello │ 2 │
|
|
│ Hello │ 3 │
|
|
│ World │ 1 │
|
|
│ World │ 2 │
|
|
│ World │ 3 │
|
|
│ Goodbye │ 1 │
|
|
│ Goodbye │ 2 │
|
|
│ Goodbye │ 3 │
|
|
└─────────────┴──────────────┘
|
|
```
|
|
|
|
Múltiples matrices se pueden separar por comas en el `ARRAY JOIN` clausula. En este caso, `JOIN` se realiza con ellos simultáneamente (la suma directa, no el producto cartesiano). Tenga en cuenta que todas las matrices deben tener el mismo tamaño. Ejemplo:
|
|
|
|
``` sql
|
|
SELECT s, arr, a, num, mapped
|
|
FROM arrays_test
|
|
ARRAY JOIN arr AS a, arrayEnumerate(arr) AS num, arrayMap(x -> x + 1, arr) AS mapped;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─arr─────┬─a─┬─num─┬─mapped─┐
|
|
│ Hello │ [1,2] │ 1 │ 1 │ 2 │
|
|
│ Hello │ [1,2] │ 2 │ 2 │ 3 │
|
|
│ World │ [3,4,5] │ 3 │ 1 │ 4 │
|
|
│ World │ [3,4,5] │ 4 │ 2 │ 5 │
|
|
│ World │ [3,4,5] │ 5 │ 3 │ 6 │
|
|
└───────┴─────────┴───┴─────┴────────┘
|
|
```
|
|
|
|
El siguiente ejemplo utiliza el [arrayEnumerate](../../../sql-reference/functions/array-functions.md#array_functions-arrayenumerate) función:
|
|
|
|
``` sql
|
|
SELECT s, arr, a, num, arrayEnumerate(arr)
|
|
FROM arrays_test
|
|
ARRAY JOIN arr AS a, arrayEnumerate(arr) AS num;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─arr─────┬─a─┬─num─┬─arrayEnumerate(arr)─┐
|
|
│ Hello │ [1,2] │ 1 │ 1 │ [1,2] │
|
|
│ Hello │ [1,2] │ 2 │ 2 │ [1,2] │
|
|
│ World │ [3,4,5] │ 3 │ 1 │ [1,2,3] │
|
|
│ World │ [3,4,5] │ 4 │ 2 │ [1,2,3] │
|
|
│ World │ [3,4,5] │ 5 │ 3 │ [1,2,3] │
|
|
└───────┴─────────┴───┴─────┴─────────────────────┘
|
|
```
|
|
|
|
## ARRAY JOIN con estructura de datos anidada {#array-join-with-nested-data-structure}
|
|
|
|
`ARRAY JOIN` también funciona con [estructuras de datos anidados](../../../sql-reference/data-types/nested-data-structures/nested.md):
|
|
|
|
``` sql
|
|
CREATE TABLE nested_test
|
|
(
|
|
s String,
|
|
nest Nested(
|
|
x UInt8,
|
|
y UInt32)
|
|
) ENGINE = Memory;
|
|
|
|
INSERT INTO nested_test
|
|
VALUES ('Hello', [1,2], [10,20]), ('World', [3,4,5], [30,40,50]), ('Goodbye', [], []);
|
|
```
|
|
|
|
``` text
|
|
┌─s───────┬─nest.x──┬─nest.y─────┐
|
|
│ Hello │ [1,2] │ [10,20] │
|
|
│ World │ [3,4,5] │ [30,40,50] │
|
|
│ Goodbye │ [] │ [] │
|
|
└─────────┴─────────┴────────────┘
|
|
```
|
|
|
|
``` sql
|
|
SELECT s, `nest.x`, `nest.y`
|
|
FROM nested_test
|
|
ARRAY JOIN nest;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─nest.x─┬─nest.y─┐
|
|
│ Hello │ 1 │ 10 │
|
|
│ Hello │ 2 │ 20 │
|
|
│ World │ 3 │ 30 │
|
|
│ World │ 4 │ 40 │
|
|
│ World │ 5 │ 50 │
|
|
└───────┴────────┴────────┘
|
|
```
|
|
|
|
Al especificar nombres de estructuras de datos anidadas en `ARRAY JOIN` el significado es el mismo `ARRAY JOIN` con todos los elementos de la matriz en los que consiste. Los ejemplos se enumeran a continuación:
|
|
|
|
``` sql
|
|
SELECT s, `nest.x`, `nest.y`
|
|
FROM nested_test
|
|
ARRAY JOIN `nest.x`, `nest.y`;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─nest.x─┬─nest.y─┐
|
|
│ Hello │ 1 │ 10 │
|
|
│ Hello │ 2 │ 20 │
|
|
│ World │ 3 │ 30 │
|
|
│ World │ 4 │ 40 │
|
|
│ World │ 5 │ 50 │
|
|
└───────┴────────┴────────┘
|
|
```
|
|
|
|
Esta variación también tiene sentido:
|
|
|
|
``` sql
|
|
SELECT s, `nest.x`, `nest.y`
|
|
FROM nested_test
|
|
ARRAY JOIN `nest.x`;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─nest.x─┬─nest.y─────┐
|
|
│ Hello │ 1 │ [10,20] │
|
|
│ Hello │ 2 │ [10,20] │
|
|
│ World │ 3 │ [30,40,50] │
|
|
│ World │ 4 │ [30,40,50] │
|
|
│ World │ 5 │ [30,40,50] │
|
|
└───────┴────────┴────────────┘
|
|
```
|
|
|
|
Se puede usar un alias para una estructura de datos anidada, con el fin de seleccionar `JOIN` resultado o la matriz de origen. Ejemplo:
|
|
|
|
``` sql
|
|
SELECT s, `n.x`, `n.y`, `nest.x`, `nest.y`
|
|
FROM nested_test
|
|
ARRAY JOIN nest AS n;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─n.x─┬─n.y─┬─nest.x──┬─nest.y─────┐
|
|
│ Hello │ 1 │ 10 │ [1,2] │ [10,20] │
|
|
│ Hello │ 2 │ 20 │ [1,2] │ [10,20] │
|
|
│ World │ 3 │ 30 │ [3,4,5] │ [30,40,50] │
|
|
│ World │ 4 │ 40 │ [3,4,5] │ [30,40,50] │
|
|
│ World │ 5 │ 50 │ [3,4,5] │ [30,40,50] │
|
|
└───────┴─────┴─────┴─────────┴────────────┘
|
|
```
|
|
|
|
Ejemplo de uso del [arrayEnumerate](../../../sql-reference/functions/array-functions.md#array_functions-arrayenumerate) función:
|
|
|
|
``` sql
|
|
SELECT s, `n.x`, `n.y`, `nest.x`, `nest.y`, num
|
|
FROM nested_test
|
|
ARRAY JOIN nest AS n, arrayEnumerate(`nest.x`) AS num;
|
|
```
|
|
|
|
``` text
|
|
┌─s─────┬─n.x─┬─n.y─┬─nest.x──┬─nest.y─────┬─num─┐
|
|
│ Hello │ 1 │ 10 │ [1,2] │ [10,20] │ 1 │
|
|
│ Hello │ 2 │ 20 │ [1,2] │ [10,20] │ 2 │
|
|
│ World │ 3 │ 30 │ [3,4,5] │ [30,40,50] │ 1 │
|
|
│ World │ 4 │ 40 │ [3,4,5] │ [30,40,50] │ 2 │
|
|
│ World │ 5 │ 50 │ [3,4,5] │ [30,40,50] │ 3 │
|
|
└───────┴─────┴─────┴─────────┴────────────┴─────┘
|
|
```
|
|
|
|
## Detalles de implementación {#implementation-details}
|
|
|
|
El orden de ejecución de la consulta se optimiza cuando se ejecuta `ARRAY JOIN`. Aunque `ARRAY JOIN` debe especificarse siempre antes de la [WHERE](where.md)/[PREWHERE](prewhere.md) cláusula en una consulta, técnicamente se pueden realizar en cualquier orden, a menos que resultado de `ARRAY JOIN` se utiliza para filtrar. El optimizador de consultas controla el orden de procesamiento.
|