Referência de sintaxe de consulta SQL: SELECT, funções de agregação e junções - Tablestore - Tablestore: Central de Documentação do Alibaba Cloud

Pré-requisitos

Crie um relacionamento de mapeamento antes de executar instruções SELECT. Para mais informações, consulte Operações DDL.

Consultar dados

Use instruções SELECT para recuperar linhas de tabelas de mapeamento com filtragem, agrupamento, ordenação e paginação opcionais.

Nota

Tabelas de mapeamento de índice de busca oferecem recursos adicionais, como busca textual completa, consultas de array, consultas aninhadas, busca vetorial e funções JSON. Para mais detalhes, consulte Operações de índice de busca.
Quando existem índices secundários e índices de busca na mesma tabela de dados, o mecanismo SQL seleciona automaticamente o índice mais adequado. Para mais informações, consulte Otimização de consultas.
Ordem de execução das cláusulas: WHERE > GROUP BY > HAVING > ORDER BY > LIMIT/OFFSET.

Sintaxe

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	Obrigatório	Descrição
ALL \	DISTINCT \	DISTINCTROW	Não	Modo de deduplicação. ALL (padrão) retorna todas as linhas. DISTINCT remove linhas duplicadas do conjunto de resultados. DISTINCTROW equivale a DISTINCT.
select_expr	Sim	Nomes de colunas ou expressões no formato `column_name	expression [AS alias]`. Use `*` para retornar todas as colunas.
table_references	Sim	Tabela de destino. Especifique um nome de tabela ou uma subconsulta SELECT no formato `table_name	select_statement`. Para consultas com múltiplas tabelas, consulte a seção Join.
where_condition	Não	Cláusula WHERE. Suporta condições de igualdade e intervalo de chave primária, operadores lógicos (AND/OR/NOT), operadores de comparação (=, >, <, >=, <=, !=), IN, LIKE, IS NULL e BETWEEN.
groupby_condition	Não	Cláusula GROUP BY. Agrupa linhas pelas colunas especificadas, geralmente usada com funções de agregação.
having_condition	Não	Cláusula HAVING. Filtra os resultados agrupados produzidos pelo GROUP BY.
order_condition	Não	Cláusula ORDER BY. Ordena os resultados pelas colunas especificadas. Suporta ASC (ascendente, padrão) e DESC (descendente).
LIMIT / OFFSET	Não	Limita o número de linhas retornadas. `LIMIT row_count` retorna as primeiras N linhas. `LIMIT offset, row_count` ou `LIMIT row_count OFFSET offset` ignora o deslocamento (offset) de linhas e retorna N linhas subsequentes.

Exemplos

Consulte todos os dados da tabela exampletable, retornando até 20 linhas:

SELECT * FROM exampletable LIMIT 20;

Consulta com condições e ordenação:

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

Deduplique os resultados:

SELECT DISTINCT col_keyword FROM exampletable;

Agrupe e conte:

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

Paginação de resultados (ignore as 10 primeiras linhas e retorne 5):

SELECT * FROM exampletable LIMIT 10, 5;

Funções de agregação

Funções de agregação calculam um único resultado a partir de várias linhas. Use-as com GROUP BY para gerar estatísticas agrupadas.

Função	Tipo de retorno	Descrição
COUNT()	BIGINT	Retorna o número de linhas que correspondem a uma condição especificada. `COUNT(*)` conta todas as linhas. `COUNT(column)` conta apenas valores não nulos.
COUNT(DISTINCT)	BIGINT	Retorna o número de valores distintos na coluna especificada.
SUM()	DOUBLE	Retorna a soma de uma coluna numérica.
AVG()	DOUBLE	Retorna a média de uma coluna numérica.
MAX()	Mesmo tipo da coluna	Retorna o valor máximo em uma coluna.
MIN()	Mesmo tipo da coluna	Retorna o valor mínimo em uma coluna.

Exemplos

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 duas ou mais tabelas para unir linhas com base em valores de colunas correspondentes.

Sintaxe

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	Obrigatório	Descrição
table_references	Sim	Tabelas a serem unidas. Especifique um nome de tabela com um alias opcional ou uma subconsulta SELECT. A tabela à esquerda da palavra-chave JOIN é a tabela da esquerda, e a tabela à direita é a tabela da direita.
join_type	Sim	Tipo de junção: INNER JOIN (padrão): Retorna apenas as linhas que satisfazem a condição de junção em ambas as tabelas. LEFT OUTER JOIN: Retorna todas as linhas da tabela da esquerda. Preenche com NULL as colunas sem correspondência na tabela da direita. RIGHT OUTER JOIN: Retorna todas as linhas da tabela da direita. Preenche com NULL as colunas sem correspondência na tabela da esquerda. CROSS JOIN: Retorna o produto cartesiano de ambas as tabelas.
join_condition	Sim	Defina as colunas de junção. Use `ON` para especificar a condição ou `USING(column)` quando ambas as tabelas compartilharem colunas com nomes idênticos. As duas instruções a seguir são 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 junção

O Tablestore usa INDEX JOIN por padrão e recorre ao HASH JOIN quando as colunas de junção da tabela da direita não atendem às condições de índice.

Algoritmo

Condição aplicável

Descrição

INDEX JOIN

As colunas de junção da tabela da direita satisfazem as condições de índice

Lê dados da tabela da esquerda e usa o índice ou a chave primária da tabela da direita para localizar linhas correspondentes. As colunas de junção da tabela da direita devem atender a uma das seguintes condições:

No acesso via chave primária ou índice secundário, as colunas de junção satisfazem a correspondência de prefixo mais à esquerda.
No acesso via índice de busca, todas as colunas de junção estão indexadas no índice de busca e as condições de filtro podem ser delegadas (pushed down).

HASH JOIN

As colunas de junção não satisfazem as condições de INDEX JOIN

Constrói uma tabela hash a partir da tabela da esquerda e a sonda com linhas da tabela da direita para encontrar correspondências. Não exige índice.

Nota

Sem um índice adequado na tabela da direita, o INDEX JOIN degrada para uma varredura completa da tabela. Adicione índices nas colunas de junção e de filtro para melhorar o desempenho da consulta.
O INNER JOIN tem melhor desempenho em conjuntos de resultados menores, enquanto o HASH JOIN performa melhor em conjuntos maiores. Posicione a tabela menor no lado esquerdo para otimizar o desempenho.

Exemplos

Considere duas tabelas, orders e 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 |
+-------------+---------------+----------------+

O INNER JOIN retorna apenas linhas onde customer_id corresponde em ambas as tabelas. O pedido 1005 (customer_id=6) é excluído porque não existe cliente correspondente.

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

O LEFT JOIN retorna todas as linhas da tabela da esquerda (orders). As colunas da tabela da direita são preenchidas com NULL quando não há correspondência.

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

O CROSS JOIN retorna o produto cartesiano de ambas as tabelas.

SELECT * FROM orders CROSS JOIN customers;