Introduction to SELECT syntax - MaxCompute - Centro de documentación de Alibaba Cloud

SELECT consulta datos de una o más tablas. Antes de ejecutar una instrucción SELECT, asegúrese de tener el permiso Select en la tabla de destino. Para obtener más información, consulte MaxCompute permissions.

Clientes compatibles:

Sintaxis

[WITH <cte>[, ...] ]
SELECT [ALL | DISTINCT] <SELECT_expr>[, <EXCEPT_expr>][, <REPLACE_expr>] ...
       FROM <TABLE_reference>
       [WHERE <WHERE_condition>]
       [GROUP BY {<col_list>|ROLLUP(<col_list>)}]
       [HAVING <HAVING_condition>]
       [WINDOW <WINDOW_clause>]
       [ORDER BY <ORDER_condition>]
       [DISTRIBUTE BY <DISTRIBUTE_condition> [SORT BY <SORT_condition>]|[ CLUSTER BY <CLUSTER_condition>] ]
       [LIMIT <number>]

Para conocer el orden de ejecución de las cláusulas en una instrucción SELECT, consulte Execution order of clauses.

Limitaciones

Una instrucción SELECT muestra un máximo de 10,000 filas y devuelve resultados que no superan los 10 MB. Este límite no aplica cuando SELECT se utiliza como subconsulta; en ese caso, todas las filas se devuelven a la consulta principal.
Los escaneos completos de tablas particionadas están prohibidos de forma predeterminada. En los proyectos creados después de las 20:00:00 del 10 de enero de 2018, debe especificar una partición al consultar una tabla particionada. Esto reduce las operaciones de E/S innecesarias y los costos de cómputo, especialmente bajo la facturación pay-as-you-go. Para ejecutar un escaneo completo de tabla en la sesión actual, envíe SET odps.sql.allow.fullscan=true; junto con la instrucción SELECT:
```
SET odps.sql.allow.fullscan=true;
SELECT * FROM sale_detail;
```
En las tablas agrupadas en clústeres, la poda de buckets solo se optimiza cuando se escanean 400 particiones o menos por tabla. Si la poda de buckets no surte efecto, se escanea más datos, lo que incrementa los costos bajo la facturación pay-as-you-go y degrada el rendimiento bajo la facturación por suscripción.

Tipos de consulta relacionados

Query type	Description
Subqueries	Consultar los resultados de una consulta anterior
INTERSECT, UNION, and EXCEPT	Realizar intersección, unión o complemento de conjuntos de datos resultantes
JOIN	Unir tablas y devolver filas que cumplen las condiciones de unión y consulta
SEMI JOIN	Filtrar filas de la tabla izquierda mediante la tabla derecha; el resultado solo contiene datos de la tabla izquierda
MAPJOIN hint	Mejorar el rendimiento de JOIN al unir una tabla grande con una o más tablas pequeñas
SKEWJOIN hint	Manejar la asimetría de datos en operaciones JOIN mediante el procesamiento separado de datos críticos y no críticos
LATERAL VIEW	Usar con una función definida por el usuario con valor de tabla (UDTF) para dividir una sola fila en varias filas
GROUPING SETS	Agregar y analizar datos en múltiples dimensiones
SELECT TRANSFORM	Iniciar un proceso secundario, enviar entrada formateada vía stdin y analizar stdout como salida
Split size hint	Controlar la concurrencia de consultas ajustando el tamaño de división
Time travel and incremental queries	Consultar instantáneas históricas (time travel) o datos incrementales (consulta incremental) desde tablas Delta

Datos de ejemplo

Los ejemplos de este tema utilizan la tabla sale_detail. Ejecute las siguientes instrucciones para crear la tabla e insertar datos de ejemplo:

-- Create a partitioned table named sale_detail.
CREATE TABLE IF NOT EXISTS sale_detail
(
shop_name     STRING,
customer_id   STRING,
total_price   DOUBLE
)
PARTITIONED BY (sale_date STRING, region STRING);

-- Add a partition.
ALTER TABLE sale_detail ADD PARTITION (sale_date='2013', region='china');

-- Insert data.
INSERT INTO sale_detail PARTITION (sale_date='2013', region='china') VALUES ('s1','c1',100.1),('s2','c2',100.2),('s3','c3',100.3);

Consulte la tabla para comprobarlo:

SELECT * FROM sale_detail;
-- Result:
+------------+-------------+-------------+------------+------------+
| shop_name  | customer_id | total_price | sale_date  | region     |
+------------+-------------+-------------+------------+------------+
| s1         | c1          | 100.1       | 2013       | china      |
| s2         | c2          | 100.2       | 2013       | china      |
| s3         | c3          | 100.3       | 2013       | china      |
+------------+-------------+-------------+------------+------------+

Cláusula WITH (CTE)

La cláusula WITH define una o más expresiones de tabla comunes (CTE). Cada CTE actúa como un conjunto de resultados temporal con nombre que está disponible para consultas posteriores dentro de la misma instrucción.

Reglas:

Los nombres de las CTE dentro de la misma cláusula WITH deben ser únicos.
Una CTE puede hacer referencia a otras CTE definidas anteriormente en la misma cláusula WITH, pero no a sí misma ni generar dependencias circulares.

Autorreferencia (no compatible)

-- Incorrect: A cannot reference itself.
WITH
A AS (SELECT 1 FROM A)
SELECT * FROM A;
-- FAILED: ODPS-0130161:[1,6] Parse exception - recursive cte A is invalid, it must have an initial_part and a recursive_part, which must be connected by UNION ALL

Referencia circular (no compatible)

-- Incorrect: A references B, and B references A.
WITH
A AS (SELECT * FROM B),
B AS (SELECT * FROM A)
SELECT * FROM B;
-- FAILED: ODPS-0130071:[1,26] Semantic analysis exception - while resolving view B - [1,51]recursive function call is not supported, cycle is A->B->A

Referencia secuencial (compatible)

WITH
A AS (SELECT 1 AS C),
B AS (SELECT * FROM A)
SELECT * FROM B;
-- Result:
+---+
| c |
+---+
| 1 |
+---+

Expresión de columna (SELECT_expr)

SELECT_expr especifica qué columnas se deben devolver. Utilice nombres de columnas, *, expresiones regulares o las palabras clave DISTINCT y ALL.

Seleccionar columnas específicas por nombre

SELECT shop_name FROM sale_detail;
-- Result:
+------------+
| shop_name  |
+------------+
| s1         |
| s2         |
| s3         |
+------------+

Seleccionar todas las columnas con `*`

-- Enable full table scan for the current session.
SET odps.sql.allow.fullscan=true;
SELECT * FROM sale_detail;
-- Result:
+------------+-------------+-------------+------------+------------+
| shop_name  | customer_id | total_price | sale_date  | region     |
+------------+-------------+-------------+------------+------------+
| s1         | c1          | 100.1       | 2013       | china      |
| s2         | c2          | 100.2       | 2013       | china      |
| s3         | c3          | 100.3       | 2013       | china      |
+------------+-------------+-------------+------------+------------+

Filtrar con WHERE

SELECT * FROM sale_detail WHERE shop_name='s1';
-- Result:
+------------+-------------+-------------+------------+------------+
| shop_name  | customer_id | total_price | sale_date  | region     |
+------------+-------------+-------------+------------+------------+
| s1         | c1          | 100.1       | 2013       | china      |
+------------+-------------+-------------+------------+------------+

Seleccionar columnas mediante expresión regular

Encierre la expresión regular entre comillas invertidas.

Seleccione todas las columnas cuyos nombres comiencen con sh:

SELECT `sh.*` FROM sale_detail;
-- Result:
+------------+
| shop_name  |
+------------+
| s1         |
| s2         |
| s3         |
+------------+

Excluya shop_name y devuelva todas las demás columnas:

SELECT `(shop_name)?+.+` FROM sale_detail;
-- Result:
+-------------+-------------+------------+------------+
| customer_id | total_price | sale_date  | region     |
+-------------+-------------+------------+------------+
| c1          | 100.1       | 2013       | china      |
| c2          | 100.2       | 2013       | china      |
| c3          | 100.3       | 2013       | china      |
+-------------+-------------+------------+------------+

Excluya varias columnas (shop_name y customer_id):

SELECT `(shop_name|customer_id)?+.+` FROM sale_detail;
-- Result:
+-------------+------------+------------+
| total_price | sale_date  | region     |
+-------------+------------+------------+
| 100.1       | 2013       | china      |
| 100.2       | 2013       | china      |
| 100.3       | 2013       | china      |
+-------------+------------+------------+

Excluya todas las columnas cuyos nombres comiencen con t:

SELECT `(t.*)?+.+` FROM sale_detail;
-- Result:
+------------+-------------+------------+------------+
| shop_name  | customer_id | sale_date  | region     |
+------------+-------------+------------+------------+
| s1         | c1          | 2013       | china      |
| s2         | c2          | 2013       | china      |
| s3         | c3          | 2013       | china      |
+------------+-------------+------------+------------+

Al excluir varias columnas donde un nombre es prefijo de otro, coloque primero el nombre más largo en la expresión. Por ejemplo, si una tabla tiene las particiones ds y dshh , utilice ` SELECT (dshh|ds)?+.+ FROM t; en lugar de SELECT (ds|dshh)?+.+ FROM t; `.

Eliminar duplicados con DISTINCT

DISTINCT devuelve valores únicos; ALL (valor predeterminado) devuelve todas las filas, incluidos los duplicados.

SELECT DISTINCT region FROM sale_detail;
-- Result:
+------------+
| region     |
+------------+
| china      |
+------------+

Cuando se aplica a varias columnas, DISTINCT elimina duplicados basándose en el valor combinado de todas las columnas listadas:

SELECT DISTINCT region, sale_date FROM sale_detail;
-- Result:
+------------+------------+
| region     | sale_date  |
+------------+------------+
| china      | 2013       |
+------------+------------+

DISTINCT también funciona con funciones de ventana y elimina las filas duplicadas del resultado de la función de ventana:

SET odps.sql.allow.fullscan=true;
SELECT DISTINCT sale_date, ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY total_price) AS rn FROM sale_detail;
-- Result:
+-----------+------------+
| sale_date | rn         |
+-----------+------------+
| 2013      | 1          |
+-----------+------------+

DISTINCT y GROUP BY no pueden utilizarse en la misma consulta. La siguiente instrucción devuelve un error:

SELECT DISTINCT shop_name FROM sale_detail GROUP BY shop_name;
-- Error: GROUP BY cannot be used with SELECT DISTINCT

Excluir columnas (EXCEPT_expr)

SELECT * EXCEPT(col1, col2, ...) devuelve todas las columnas excepto las especificadas.

-- Return all columns except region.
SELECT * EXCEPT(region) FROM sale_detail;
-- Result:
+-----------+-------------+-------------+-----------+
| shop_name | customer_id | total_price | sale_date |
+-----------+-------------+-------------+-----------+
| s1        | c1          | 100.1       | 2013      |
| s2        | c2          | 100.2       | 2013      |
| s3        | c3          | 100.3       | 2013      |
+-----------+-------------+-------------+-----------+

Reemplazar columnas (REPLACE_expr)

SELECT * REPLACE(expr AS col, ...) devuelve todas las columnas y reemplaza el valor de las columnas especificadas con las expresiones indicadas.

-- Return all columns, replacing total_price and region values.
SELECT * REPLACE(total_price+100 AS total_price, 'shanghai' AS region) FROM sale_detail;
-- Result:
+-----------+-------------+-------------+-----------+--------+
| shop_name | customer_id | total_price | sale_date | region |
+-----------+-------------+-------------+-----------+--------+
| s1        | c1          | 200.1       | 2013      | shanghai |
| s2        | c2          | 200.2       | 2013      | shanghai |
| s3        | c3          | 200.3       | 2013      | shanghai |
+-----------+-------------+-------------+-----------+--------+

Tabla de destino (TABLE_reference)

TABLE_reference especifica la tabla que se va a consultar.

Consultar una tabla con nombre

SELECT customer_id FROM sale_detail;
-- Result:
+-------------+
| customer_id |
+-------------+
| c1          |
| c2          |
| c3          |
+-------------+

Usar una subconsulta anidada como origen

SELECT * FROM (SELECT region, sale_date FROM sale_detail) t WHERE region = 'china';
-- Result:
+------------+------------+
| region     | sale_date  |
+------------+------------+
| china      | 2013       |
| china      | 2013       |
| china      | 2013       |
+------------+------------+

Cláusula WHERE

La cláusula WHERE filtra filas. En tablas particionadas, las condiciones sobre columnas de partición permiten la poda de particiones, de modo que solo se escanean las particiones coincidentes.

Operadores relacionales compatibles: >, <, =, >=, <=, <>, LIKE, RLIKE, IN, NOT IN, BETWEEN...AND. Para más detalles, consulte Relational operators.

Filtrar con un rango de particiones

SELECT *
FROM sale_detail
WHERE sale_date >= '2008' AND sale_date <= '2014';

-- Equivalent to:
SELECT *
FROM sale_detail
WHERE sale_date BETWEEN '2008' AND '2014';
-- Result:
+------------+-------------+-------------+------------+------------+
| shop_name  | customer_id | total_price | sale_date  | region     |
+------------+-------------+-------------+------------+------------+
| s1         | c1          | 100.1       | 2013       | china      |
| s2         | c2          | 100.2       | 2013       | china      |
| s3         | c3          | 100.3       | 2013       | china      |
+------------+-------------+-------------+------------+------------+

Ejecute la instrucción EXPLAIN para comprobar que la poda de particiones surte efecto. Una función definida por el usuario (UDF) o condiciones de partición en una cláusula ON de JOIN pueden impedir la poda. Para obtener más información, consulte Check whether partition pruning is effective .

Usar una UDF para la poda de particiones

Una UDF en la cláusula WHERE se ejecuta como un pre-trabajo pequeño, y el resultado reemplaza a la UDF en la instrucción original.

Para habilitar la poda de particiones basada en UDF, anote la clase UDF:

@com.aliyun.odps.udf.annotation.UdfProperty(isDeterministic=true)

com.aliyun.odps.udf.annotation.UdfProperty se define en odps-sdk-udf.jar . Actualice odps-sdk-udf a la versión 0.30.x o posterior.

Como alternativa, agregue SET odps.sql.udf.ppr.deterministic = true; antes de la instrucción SQL para tratar todas las UDF de la instrucción como deterministas. Este método rellena particiones con los resultados del trabajo, hasta un máximo de 1,000 particiones. Si se rellenan más de 1,000 particiones, se devuelve un error. Para suprimir el error y deshabilitar la poda de particiones basada en UDF, ejecute SET odps.sql.udf.ppr.to.subquery = false;.

La UDF debe estar en la cláusula WHERE de la tabla de origen para que la poda surta efecto:

-- Correct: UDF in the WHERE clause of the source table.
SELECT key, value FROM srcp WHERE udf(ds) = 'xx';

-- Incorrect: UDF in a JOIN ON clause does not trigger partition pruning.
SELECT A.c1, A.c2 FROM srcp1 A JOIN srcp2 B ON A.c1 = B.c1 AND udf(A.ds) = 'xx';

Los alias de columna no están disponibles en WHERE

Si una columna en SELECT_expr utiliza una función y se renombra con un alias, no se puede hacer referencia al alias en la cláusula WHERE. La siguiente instrucción devuelve un error:

-- Incorrect: skynet_id is an alias defined in SELECT, not available in WHERE.
SELECT  task_name,
        inst_id,
        settings,
        GET_JSON_OBJECT(settings, '$.SKYNET_ID') AS skynet_id,
        GET_JSON_OBJECT(settings, '$.SKYNET_NODENAME') AS user_agent
FROM    Information_Schema.TASKS_HISTORY
WHERE   ds = '20211215' AND skynet_id IS NOT NULL
LIMIT 10;

Cláusula GROUP BY

GROUP BY agrupa filas según las columnas especificadas y suele utilizarse con aggregate functions.

Reglas:

GROUP BY se ejecuta antes que SELECT. Las columnas en GROUP BY pueden especificarse mediante los nombres de columna de la tabla de entrada o mediante una expresión formada por las columnas de dicha tabla. También pueden usarse en GROUP BY los alias definidos en la lista SELECT.
Todas las columnas de la lista SELECT que no estén envueltas en una función de agregación deben aparecer en la cláusula GROUP BY.
Las expresiones regulares en GROUP BY deben usar la expresión completa para las columnas.
GROUP BY no puede utilizarse junto con DISTRIBUTE BY o SORT BY.

Agrupar por una columna

SELECT region FROM sale_detail GROUP BY region;
-- Result:
+------------+
| region     |
+------------+
| china      |
+------------+

Agregar con GROUP BY

SELECT region, SUM(total_price) FROM sale_detail GROUP BY region;
-- Result:
+------------+------------+
| region     | _c1        |
+------------+------------+
| china      | 300.6      |
+------------+------------+

Usar un alias de SELECT en GROUP BY

SELECT region AS r FROM sale_detail GROUP BY r;
-- Equivalent to:
SELECT region AS r FROM sale_detail GROUP BY region;
-- Result:
+------------+
| r          |
+------------+
| china      |
+------------+

Agrupar por una expresión de columna

SELECT 2 + total_price AS r FROM sale_detail GROUP BY 2 + total_price;
-- Result:
+------------+
| r          |
+------------+
| 102.1      |
| 102.2      |
| 102.3      |
+------------+

La ausencia de columna en GROUP BY devuelve un error

-- Incorrect: total_price is not in GROUP BY and not in an aggregate function.
SELECT region, total_price FROM sale_detail GROUP BY region;
-- Error: FAILED: ODPS-0130071:[1,16] Semantic analysis exception - column reference sale_detail.total_price should appear in GROUP BY key

-- Correct:
SELECT region, total_price FROM sale_detail GROUP BY region, total_price;
-- Result:
+------------+-------------+
| region     | total_price |
+------------+-------------+
| china      | 100.1       |
| china      | 100.2       |
| china      | 100.3       |
+------------+-------------+

GROUP BY ALL (modo compatible con BigQuery)

Cuando odps.sql.bigquery.compatible=true, GROUP BY ALL agrupa automáticamente por todas las columnas no agregadas de la lista SELECT:

-- Explicitly list grouping fields.
SELECT
    shop_name,
    customer_id,
    sale_date,
    region,
    SUM(total_price) AS total_sales
FROM sale_detail
GROUP BY shop_name, customer_id, sale_date, region;

-- Equivalent using GROUP BY ALL.
SET odps.sql.bigquery.compatible=true;
SELECT
    shop_name,
    customer_id,
    sale_date,
    region,
    SUM(total_price) AS total_sales
FROM sale_detail
GROUP BY ALL;
-- Result:
+-----------+-------------+-----------+--------+-------------+
| shop_name | customer_id | sale_date | region | total_sales |
+-----------+-------------+-----------+--------+-------------+
| s1        | c1          | 2013      | china  | 100.1       |
| s2        | c2          | 2013      | china  | 100.2       |
| s3        | c3          | 2013      | china  | 100.3       |
+-----------+-------------+-----------+--------+-------------+

Usar alias posicionales en GROUP BY

Ejecute SET odps.sql.groupby.position.alias=true; para tratar las constantes enteras en GROUP BY como posiciones de columna en la lista SELECT:

SET odps.sql.groupby.position.alias=true;
-- 1 refers to the first column in the SELECT list (region).
SELECT region, SUM(total_price) FROM sale_detail GROUP BY 1;
-- Result:
+------------+------------+
| region     | _c1        |
+------------+------------+
| china      | 300.6      |
+------------+------------+

Cláusula HAVING

HAVING filtra datos agrupados, generalmente mediante funciones de agregación. Se evalúa después de GROUP BY.

-- Insert additional data to demonstrate HAVING.
INSERT INTO sale_detail PARTITION (sale_date='2014', region='shanghai') VALUES ('null','c5',null),('s6','c6',100.4),('s7','c7',100.5);

-- Return only groups where the total price is less than 305.
SELECT region, SUM(total_price) FROM sale_detail
GROUP BY region
HAVING SUM(total_price) < 305;
-- Result:
+------------+------------+
| region     | _c1        |
+------------+------------+
| china      | 300.6      |
| shanghai   | 200.9      |
+------------+------------+

Cláusula ORDER BY

ORDER BY ordena todas las filas según una o más columnas. El ordenamiento es global: todos los datos se fusionan en un solo nodo.

Aviso

De forma predeterminada, ORDER BY requiere una cláusula LIMIT. Sin LIMIT, se devuelve un error. Esto evita el procesamiento accidental de grandes conjuntos de datos en un solo nodo.

Reglas:

El orden de clasificación predeterminado es ascendente (ASC). Use DESC para orden descendente.
Los valores NULL se tratan como el valor más pequeño (consistente con el comportamiento de MySQL).
Las columnas de ORDER BY deben hacer referencia a columnas de salida de la instrucción SELECT, ya sea por nombre de columna o por alias.
ORDER BY no puede utilizarse junto con DISTRIBUTE BY o SORT BY.

Ordenar de forma ascendente (predeterminado)

SELECT * FROM sale_detail ORDER BY total_price LIMIT 2;
-- Result:
+------------+-------------+-------------+------------+------------+
| shop_name  | customer_id | total_price | sale_date  | region     |
+------------+-------------+-------------+------------+------------+
| s1         | c1          | 100.1       | 2013       | china      |
| s2         | c2          | 100.2       | 2013       | china      |
+------------+-------------+-------------+------------+------------+

Ordenar de forma descendente

SELECT * FROM sale_detail ORDER BY total_price DESC LIMIT 2;
-- Result:
+------------+-------------+-------------+------------+------------+
| shop_name  | customer_id | total_price | sale_date  | region     |
+------------+-------------+-------------+------------+------------+
| s3         | c3          | 100.3       | 2013       | china      |
| s2         | c2          | 100.2       | 2013       | china      |
+------------+-------------+-------------+------------+------------+

Usar un alias de columna en ORDER BY

SELECT total_price AS t FROM sale_detail ORDER BY t LIMIT 3;
-- Result:
+------------+
| t          |
+------------+
| 100.1      |
| 100.2      |
| 100.3      |
+------------+

Usar alias posicionales en ORDER BY

Ejecute SET odps.sql.orderby.position.alias=true; para tratar las constantes enteras en ORDER BY como posiciones de columna:

SET odps.sql.orderby.position.alias=true;
-- 3 refers to the third column in the SELECT list (total_price).
SELECT * FROM sale_detail ORDER BY 3 LIMIT 3;
-- Result:
+------------+-------------+-------------+------------+------------+
| shop_name  | customer_id | total_price | sale_date  | region     |
+------------+-------------+-------------+------------+------------+
| s1         | c1          | 100.1       | 2013       | china      |
| s2         | c2          | 100.2       | 2013       | china      |
| s3         | c3          | 100.3       | 2013       | china      |
+------------+-------------+-------------+------------+------------+

Omitir filas con OFFSET

ORDER BY...LIMIT m OFFSET n devuelve m filas comenzando después de las primeras n filas. LIMIT n, m es una forma abreviada equivalente.

-- Sort by total_price ascending, skip the first 2 rows, return up to 3.
SELECT customer_id, total_price FROM sale_detail ORDER BY total_price LIMIT 3 OFFSET 2;

-- Equivalent:
SELECT customer_id, total_price FROM sale_detail ORDER BY total_price LIMIT 2, 3;
-- Result (only 1 row remains after skipping 2):
+-------------+-------------+
| customer_id | total_price |
+-------------+-------------+
| c3          | 100.3       |
+-------------+-------------+

Eliminar el requisito de LIMIT para ORDER BY

Dado que ORDER BY se ejecuta en un solo nodo, el requisito de LIMIT evita que se ordenen accidentalmente conjuntos de datos muy grandes. Para deshabilitar este requisito:

Nivel de proyecto: Ejecute SETPROJECT odps.sql.validate.orderby.limit=false;
Nivel de sesión: Envíe SET odps.sql.validate.orderby.limit=false; junto con la instrucción SQL.

Ordenar grandes conjuntos de datos en un solo nodo consume más recursos y toma más tiempo.

Acelerar el ordenamiento global con Range Clustering

En escenarios típicos de ORDER BY, todos los datos deben procesarse en un solo nodo. Range Clustering muestrea primero los datos, los divide en rangos y luego ordena cada rango de manera concurrente, lo que produce un resultado ordenado globalmente en paralelo. Para más detalles, consulte Global sorting acceleration.

Cláusula DISTRIBUTE BY

DISTRIBUTE BY realiza una fragmentación hash de las filas según las columnas especificadas y enruta las filas con la misma clave al mismo reductor. Úselo para garantizar que los datos relacionados se procesen juntos o para evitar la superposición de datos entre reductores.

Las columnas en DISTRIBUTE BY deben hacer referencia a columnas de salida de la instrucción SELECT mediante sus alias. Si no se especifica ningún alias, se utiliza el nombre de la columna.

-- Hash-shard rows by the region column.
SELECT region FROM sale_detail DISTRIBUTE BY region;

-- The following two statements are equivalent to the one above:
SELECT region AS r FROM sale_detail DISTRIBUTE BY region;
SELECT region AS r FROM sale_detail DISTRIBUTE BY r;
-- Result:
+------------+
| r          |
+------------+
| china      |
| china      |
| china      |
+------------+

DISTRIBUTE BY no puede utilizarse junto con ORDER BY o GROUP BY .

Cláusula SORT BY

SORT BY ordena los datos dentro de cada partición de reductor. No garantiza un orden global.

Reglas:

El orden de clasificación predeterminado es ascendente. Use DESC para orden descendente.
Cuando se usa con DISTRIBUTE BY, SORT BY ordena dentro de cada partición creada por DISTRIBUTE BY.
Cuando se usa sin DISTRIBUTE BY, SORT BY ordena dentro de cada reductor de forma independiente.

DISTRIBUTE BY + SORT BY (ordenamiento distribuido)

-- Insert additional data to show multiple regions.
INSERT INTO sale_detail PARTITION (sale_date='2014', region='shanghai') VALUES ('null','c5',null),('s6','c6',100.4),('s7','c7',100.5);

-- Set 2 reducers.
SET odps.stage.reducer.num=2;

-- Hash-shard by region, then sort by total_price ascending within each shard.
SELECT region, total_price FROM sale_detail DISTRIBUTE BY region SORT BY total_price;
-- Result:
+------------+-------------+
| region     | total_price |
+------------+-------------+
| shanghai   | NULL        |
| shanghai   | 100.4       |
| shanghai   | 100.5       |
| china      | 100.1       |
| china      | 100.2       |
| china      | 100.3       |
+------------+-------------+

Ordene de forma descendente dentro de cada fragmento:

SET odps.stage.reducer.num=2;
SELECT region, total_price FROM sale_detail DISTRIBUTE BY region SORT BY total_price DESC;
-- Result:
+------------+-------------+
| region     | total_price |
+------------+-------------+
| shanghai   | 100.5       |
| shanghai   | 100.4       |
| shanghai   | NULL        |
| china      | 100.3       |
| china      | 100.2       |
| china      | 100.1       |
+------------+-------------+

SORT BY sin DISTRIBUTE BY

SORT BY por sí solo ordena dentro de cada reductor de forma independiente. Esto no produce un resultado ordenado globalmente, pero mejora la tasa de compresión de almacenamiento y reduce las lecturas de disco durante el filtrado, lo que puede acelerar operaciones posteriores de ordenamiento global.

SET odps.stage.reducer.num=2;
SELECT region, total_price FROM sale_detail SORT BY total_price DESC;
-- Result (order across reducers is not guaranteed):
+------------+-------------+
| region     | total_price |
+------------+-------------+
| shanghai   | 100.5       |
| shanghai   | 100.4       |
| china      | 100.3       |
| china      | 100.2       |
| china      | 100.1       |
| shanghai   | NULL        |
+------------+-------------+

Los alias de columna en ORDER BY , DISTRIBUTE BY y SORT BY pueden especificarse en chino.

Cláusula LIMIT

LIMIT <number> restringe el número de filas de salida. El valor debe ser un entero de 32 bits con un máximo de 2,147,483,647.

LIMIT filtra los datos después de un escaneo distribuido. No reduce la cantidad de datos escaneados ni disminuye los costos de cómputo.

Quitar el límite de visualización en pantalla

Si una instrucción SELECT no incluye la cláusula LIMIT, o si LIMIT supera el límite de visualización del proyecto (n), la ventana de resultados muestra como máximo n filas.

Protección de datos deshabilitada: En odpscmd_config.ini, establezca use_instance_tunnel=true. Si no se define instance_tunnel_max_record, la visualización es ilimitada. Si se define, la visualización se limita al valor especificado, hasta un máximo de 10,000 filas. Para más detalles, consulte Usage notes.
Protección de datos habilitada: La visualización está limitada por READ_TABLE_MAX_ROW, hasta un máximo de 10,000 filas.

Ejecute SHOW SecurityConfiguration; para comprobar la configuración de ProjectProtection. Si ProjectProtection=true, deshabilite la protección de datos con SET ProjectProtection=false; solo si los requisitos de su proyecto lo permiten. Para obtener más información, consulte Data protection mechanism.

Cláusula WINDOW

Para consultar la sintaxis de las funciones de ventana, consulte Window function syntax.

Sintaxis

Limitaciones

Tipos de consulta relacionados

Datos de ejemplo

Cláusula WITH (CTE)

Autorreferencia (no compatible)

Referencia circular (no compatible)

Referencia secuencial (compatible)

Expresión de columna (SELECT_expr)

Seleccionar columnas específicas por nombre

Seleccionar todas las columnas con *

Filtrar con WHERE

Seleccionar columnas mediante expresión regular

Eliminar duplicados con DISTINCT

Excluir columnas (EXCEPT_expr)

Reemplazar columnas (REPLACE_expr)

Tabla de destino (TABLE_reference)

Consultar una tabla con nombre

Usar una subconsulta anidada como origen

Cláusula WHERE

Filtrar con un rango de particiones

Usar una UDF para la poda de particiones

Los alias de columna no están disponibles en WHERE

Cláusula GROUP BY

Agrupar por una columna

Agregar con GROUP BY

Usar un alias de SELECT en GROUP BY

Agrupar por una expresión de columna

La ausencia de columna en GROUP BY devuelve un error

GROUP BY ALL (modo compatible con BigQuery)

Usar alias posicionales en GROUP BY

Cláusula HAVING

Cláusula ORDER BY

Ordenar de forma ascendente (predeterminado)

Ordenar de forma descendente

Usar un alias de columna en ORDER BY

Usar alias posicionales en ORDER BY

Omitir filas con OFFSET

Eliminar el requisito de LIMIT para ORDER BY

Acelerar el ordenamiento global con Range Clustering

Cláusula DISTRIBUTE BY

Cláusula SORT BY

DISTRIBUTE BY + SORT BY (ordenamiento distribuido)

SORT BY sin DISTRIBUTE BY

Cláusula LIMIT

Quitar el límite de visualización en pantalla

Cláusula WINDOW

Pasos siguientes

Seleccionar todas las columnas con `*`