Instrucciones DQL - Tablestore - Centro de documentación de Alibaba Cloud

Tablestore ofrece una sintaxis DQL compatible con MySQL para consultar tablas de asignación, que incluye instrucciones SELECT, funciones de agregación, operaciones JOIN, búsqueda de texto completo, búsqueda vectorial y funciones JSON.

Requisitos previos

Cree una relación de asignación antes de ejecutar instrucciones SELECT. Para obtener más información, consulte DDL operations.

Consultar datos

Use instrucciones SELECT para recuperar filas de las tablas de asignación con opciones de filtrado, agrupación, ordenamiento y paginación.

Nota

Las tablas de asignación de índices de búsqueda admiten funciones adicionales como búsqueda de texto completo, consultas de arreglos, consultas anidadas, búsqueda vectorial y funciones JSON. Para obtener más información, consulte Search index operations.
Si existen tanto índices secundarios como índices de búsqueda en una tabla de datos, el motor SQL selecciona automáticamente el índice más adecuado. Para obtener más información, consulte Query optimization.
Orden de ejecución de cláusulas: WHERE > GROUP BY > HAVING > ORDER BY > LIMIT/OFFSET.

Sintaxis

SELECT
    [ALL | DISTINCT | DISTINCTROW]
    select_expr [, select_expr] ...
    [FROM table_references | join_expr]
    [WHERE where_condition]
    [GROUP BY groupby_condition]
    [HAVING having_condition]
    [ORDER BY order_condition]
    [LIMIT {[offset,] row_count | row_count OFFSET offset}]

Parámetros

Parámetro	Obligatorio	Descripción
ALL \	DISTINCT \	DISTINCTROW	No	Modo de deduplicación. ALL (predeterminado) devuelve todas las filas. DISTINCT elimina las filas duplicadas del conjunto de resultados. DISTINCTROW equivale a DISTINCT.
select_expr	Sí	Nombres de columnas o expresiones con el formato `column_name	expression [AS alias]`. Use `*` para devolver todas las columnas.
table_references	Sí	Tabla de destino. Especifique un nombre de tabla o una subconsulta SELECT con el formato `table_name	select_statement`. Para consultas de varias tablas, consulte la sección Join.
where_condition	No	Cláusula WHERE. Admite condiciones de igualdad y rango de clave primaria, operadores lógicos (AND/OR/NOT), operadores de comparación (=, >, <, >=, <=, !=), IN, LIKE, IS NULL y BETWEEN.
groupby_condition	No	Cláusula GROUP BY. Agrupa filas por las columnas especificadas; se usa generalmente con funciones de agregación.
having_condition	No	Cláusula HAVING. Filtra los resultados agrupados generados por GROUP BY.
order_condition	No	Cláusula ORDER BY. Ordena los resultados según las columnas especificadas. Admite ASC (ascendente, predeterminado) y DESC (descendente).
LIMIT / OFFSET	No	Limita el número de filas devueltas. `LIMIT row_count` devuelve las primeras N filas. `LIMIT offset, row_count` o `LIMIT row_count OFFSET offset` omite las filas indicadas en offset y luego devuelve N filas.

Ejemplos

Consulte todos los datos de exampletable y obtenga hasta 20 filas:

SELECT * FROM exampletable LIMIT 20;

Consulta con condiciones y ordenamiento:

SELECT pk, col_long, col_keyword FROM exampletable WHERE col_long > 100 ORDER BY col_long DESC LIMIT 10;

Deduplique los resultados:

SELECT DISTINCT col_keyword FROM exampletable;

Agrupe y cuente:

SELECT col_keyword, COUNT(*) AS cnt FROM exampletable GROUP BY col_keyword HAVING cnt > 1;

Paginación de resultados (omitir las primeras 10 filas y devolver 5 filas):

SELECT * FROM exampletable LIMIT 10, 5;

Funciones de agregación

Las funciones de agregación calculan un único resultado a partir de varias filas. Úselas junto con GROUP BY para generar estadísticas agrupadas.

Función	Tipo de retorno	Descripción
COUNT()	BIGINT	Devuelve el número de filas que cumplen una condición especificada. `COUNT(*)` cuenta todas las filas. `COUNT(column)` cuenta solo los valores no NULL.
COUNT(DISTINCT)	BIGINT	Devuelve el número de valores distintos en la columna especificada.
SUM()	DOUBLE	Devuelve la suma de una columna numérica.
AVG()	DOUBLE	Devuelve el promedio de una columna numérica.
MAX()	Igual al tipo de la columna	Devuelve el valor máximo en una columna.
MIN()	Igual al tipo de la columna	Devuelve el valor mínimo en una columna.

Ejemplos

SELECT COUNT(*) FROM exampletable;
SELECT SUM(col_long), AVG(col_long) FROM exampletable;
SELECT col_keyword, COUNT(*) AS cnt, MAX(col_long) FROM exampletable GROUP BY col_keyword;

Join

Combine dos o más tablas para unir filas según valores de columnas coincidentes.

Sintaxis

table_references join_type table_references [ ON join_condition | USING ( join_column [, ...] ) ]

table_references : {
  table_name [ [ AS ] alias_name ]
  | select_statement
}

join_type : {
  [ INNER ] JOIN
  | LEFT [ OUTER ] JOIN
  | RIGHT [ OUTER ] JOIN
  | CROSS JOIN
}

Parámetros

Parámetro	Obligatorio	Descripción
table_references	Sí	Tablas para combinar. Especifique un nombre de tabla con un alias opcional o una subconsulta SELECT. La tabla situada a la izquierda de la palabra clave JOIN es la tabla izquierda, y la de la derecha es la tabla derecha.
join_type	Sí	Tipo de join: INNER JOIN (predeterminado): Devuelve solo las filas que satisfacen la condición de unión en ambas tablas. LEFT OUTER JOIN: Devuelve todas las filas de la tabla izquierda. Asigna NULL a las columnas donde no existe coincidencia en la tabla derecha. RIGHT OUTER JOIN: Devuelve todas las filas de la tabla derecha. Asigna NULL a las columnas donde no existe coincidencia en la tabla izquierda. CROSS JOIN: Devuelve el producto cartesiano de ambas tablas.
join_condition	Sí	Define las columnas de unión. Use `ON` para especificar la condición, o `USING(column)` cuando ambas tablas comparten columnas con nombres idénticos. A continuación, las dos instrucciones son equivalentes: `SELECT * FROM t1 JOIN t2 ON t1.col_a = t2.col_a AND t1.col_b = t2.col_b; SELECT * FROM t1 JOIN t2 USING (col_a, col_b);`

Algoritmos de join

Tablestore usa INDEX JOIN de forma predeterminada y recurre a HASH JOIN cuando las columnas de unión de la tabla derecha no cumplen las condiciones del índice.

Algoritmo

Condición aplicable

Descripción

INDEX JOIN

Las columnas de unión de la tabla derecha cumplen las condiciones del índice

Lee datos de la tabla izquierda y usa el índice o la clave primaria de la tabla derecha para buscar filas coincidentes. Las columnas de unión de la tabla derecha deben cumplir una de las siguientes condiciones:

Al acceder mediante una clave primaria o un índice secundario, las columnas de unión satisfacen la coincidencia de prefijo más a la izquierda.
Al acceder mediante un índice de búsqueda, todas las columnas de unión están indexadas en dicho índice y las condiciones de filtro se pueden transferir (push down).

HASH JOIN

Las columnas de unión no cumplen las condiciones de INDEX JOIN

Construye una tabla hash a partir de la tabla izquierda y luego la explora con las filas de la tabla derecha para encontrar coincidencias. No requiere índice.

Nota

Sin un índice adecuado en la tabla derecha, INDEX JOIN se degrada a un escaneo completo de la tabla. Agregue índices en las columnas de unión y en las columnas de filtro para mejorar el rendimiento de la consulta.
INNER JOIN tiene mejor rendimiento en conjuntos de resultados pequeños, mientras que HASH JOIN funciona mejor en conjuntos grandes. Coloque la tabla más pequeña en el lado izquierdo para optimizar el rendimiento.

Ejemplos

Suponga que existen dos tablas, orders y customers:

-- orders table
+----------+-------------+------------+--------------+
| order_id | customer_id | order_date | order_amount |
+----------+-------------+------------+--------------+
|     1001 |           1 | 2023-01-01 |           50 |
|     1002 |           2 | 2023-01-02 |           80 |
|     1003 |           3 | 2023-01-03 |          180 |
|     1004 |           4 | 2023-01-04 |          220 |
|     1005 |           6 | 2023-01-05 |          250 |
+----------+-------------+------------+--------------+

-- customers table
+-------------+---------------+----------------+
| customer_id | customer_name | customer_phone |
+-------------+---------------+----------------+
|           1 |         Alice |    11111111111 |
|           2 |           Bob |    22222222222 |
|           3 |         Carol |    33333333333 |
|           4 |         David |    44444444444 |
|           5 |           Eve |    55555555555 |
+-------------+---------------+----------------+

INNER JOIN devuelve solo las filas donde customer_id coincide en ambas tablas. El pedido 1005 (customer_id=6) se excluye porque no existe ningún cliente coincidente.

SELECT * FROM orders JOIN customers ON orders.customer_id = customers.customer_id;
-- Equivalent:
SELECT * FROM orders JOIN customers USING(customer_id);

LEFT JOIN devuelve todas las filas de la tabla izquierda (orders). Las columnas de la tabla derecha se rellenan con NULL cuando no hay coincidencia.

SELECT * FROM orders LEFT JOIN customers ON orders.customer_id = customers.customer_id;

CROSS JOIN devuelve el producto cartesiano de ambas tablas.

SELECT * FROM orders CROSS JOIN customers;