Introdução à sintaxe SELECT - MaxCompute: Central de Documentação do Alibaba Cloud

Consultas SELECT recuperam dados de uma ou mais tabelas. Antes de executar uma instrução SELECT, verifique se você tem a permissão Select na tabela de destino. Para obter mais informações, consulte Permissões do MaxCompute.

Clientes compatíveis:

Sintaxe

[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 consultar a ordem de execução das cláusulas em uma instrução SELECT, consulte Ordem de execução das cláusulas.

Limitações

Uma instrução SELECT exibe no máximo 10.000 linhas e retorna resultados com tamanho não superior a 10 MB. Esse limite não se aplica quando o SELECT é usado como subconsulta; nesse caso, todas as linhas retornam para a consulta pai.
Varreduras completas em tabelas particionadas são proibidas por padrão. Em projetos criados após as 20:00:00 de 10 de janeiro de 2018, é obrigatório especificar uma partição ao consultar uma tabela particionada. Essa medida reduz custos desnecessários de I/O e computação, especialmente no modelo de pagamento conforme o uso. Para executar uma varredura completa na sessão atual, envie SET odps.sql.allow.fullscan=true; junto com a instrução SELECT:
```
SET odps.sql.allow.fullscan=true;
SELECT * FROM sale_detail;
```
Em tabelas clusterizadas, o bucket pruning só é otimizado quando 400 partições ou menos são verificadas por tabela. Se o bucket pruning não entrar em vigor, um volume maior de dados será lido. Isso aumenta os custos no faturamento por uso e degrada o desempenho no faturamento por assinatura.

Tipos de consulta relacionados

Tipo de consulta	Descrição
Subconsultas	Consultam os resultados de uma consulta anterior
INTERSECT, UNION e EXCEPT	Executam interseção, união ou complemento de conjuntos de dados resultantes
JOIN	Unem tabelas e retornam linhas correspondentes às condições de junção e consulta
SEMI JOIN	Filtram linhas da tabela esquerda usando a tabela direita; o resultado contém apenas dados da tabela esquerda
Hint MAPJOIN	Melhoram o desempenho de JOIN ao unir uma tabela grande com uma ou mais tabelas pequenas
Hint SKEWJOIN	Tratam desvio de dados em operações JOIN processando separadamente dados de pontos críticos e não críticos
LATERAL VIEW	Usado com uma função de tabela definida pelo usuário (UDTF) para dividir uma única linha em várias linhas
GROUPING SETS	Agregam e analisam dados em múltiplas dimensões
SELECT TRANSFORM	Iniciam um subprocesso, enviam entrada formatada via stdin e analisam stdout como saída
Hint de tamanho de split	Controlam a concorrência da consulta ajustando o tamanho do split
Time travel e consultas incrementais	Consultam snapshots históricos (time travel) ou dados incrementais (consulta incremental) de tabelas Delta

Dados de exemplo

Os exemplos neste tópico utilizam a tabela sale_detail. Execute as instruções a seguir para criar a tabela e inserir dados de amostra:

-- 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 a tabela para verificar:

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)

A cláusula WITH define uma ou mais expressões de tabela comuns (CTEs). Cada CTE funciona como um conjunto de resultados temporário nomeado, disponível para consultas subsequentes na mesma instrução.

Regras:

Os nomes das CTEs dentro da mesma cláusula WITH devem ser únicos.
Uma CTE pode referenciar outras CTEs definidas anteriormente na mesma cláusula WITH, mas não pode referenciar a si mesma nem criar dependências circulares.

Autorreferência (não compatível)

-- 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

Referência circular (não compatível)

-- 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

Referência sequencial (compatível)

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

Expressão de coluna (SELECT_expr)

O SELECT_expr especifica quais colunas retornar. Use nomes de colunas, *, expressões regulares ou as palavras-chave DISTINCT e ALL.

Selecionar colunas específicas por nome

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

Selecionar todas as colunas com `*`

-- 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 com 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      |
+------------+-------------+-------------+------------+------------+

Selecionar colunas por expressão regular

Envolva a expressão regular entre crases.

Selecione todas as colunas cujos nomes começam com sh:

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

Exclua shop_name e retorne todas as outras colunas:

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      |
+-------------+-------------+------------+------------+

Exclua múltiplas colunas (shop_name e 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      |
+-------------+------------+------------+

Exclua todas as colunas cujos nomes começam com 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      |
+------------+-------------+------------+------------+

Ao excluir múltiplas colunas em que um nome é prefixo de outro, coloque o nome mais longo primeiro na expressão. Por exemplo, se uma tabela tiver partições ds e dshh , use ` SELECT (dshh|ds)?+.+ FROM t; em vez de SELECT (ds|dshh)?+.+ FROM t; `.

Remover duplicatas com DISTINCT

O DISTINCT retorna valores únicos; já o ALL (padrão) retorna todas as linhas, incluindo duplicatas.

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

Quando aplicado a múltiplas colunas, o DISTINCT remove duplicatas com base no valor combinado de todas as colunas listadas:

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

O DISTINCT também funciona com funções de janela e remove linhas duplicadas do resultado da função de janela:

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          |
+-----------+------------+

Não é possível usar DISTINCT e GROUP BY na mesma consulta. A instrução a seguir retorna um erro:

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

Excluir colunas (EXCEPT_expr)

A sintaxe SELECT * EXCEPT(col1, col2, ...) retorna todas as colunas, exceto as 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      |
+-----------+-------------+-------------+-----------+

Substituir colunas (REPLACE_expr)

A sintaxe SELECT * REPLACE(expr AS col, ...) retorna todas as colunas e substitui o valor das colunas especificadas pelas expressões fornecidas.

-- 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 |
+-----------+-------------+-------------+-----------+--------+

Tabela de destino (TABLE_reference)

O TABLE_reference especifica a tabela a ser consultada.

Consultar uma tabela nomeada

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

Usar uma subconsulta aninhada como source

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

A cláusula WHERE filtra linhas. Em tabelas particionadas, condições sobre colunas de partição permitem o partition pruning, fazendo com que apenas as partições correspondentes sejam verificadas.

Operadores relacionais compatíveis: >, <, =, >=, <=, <>, LIKE, RLIKE, IN, NOT IN, BETWEEN...AND. Para detalhes, consulte Operadores relacionais.

Filtrar com um intervalo de partição

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      |
+------------+-------------+-------------+------------+------------+

Execute a instrução EXPLAIN para verificar se o partition pruning está em vigor. Uma função definida pelo usuário (UDF) ou condições de partição em uma cláusula ON de JOIN podem impedir o pruning. Para mais informações, consulte Verificar se o partition pruning é eficaz .

Usar uma UDF para partition pruning

Uma UDF na cláusula WHERE executa como um pequeno pré-job, e o resultado substitui a UDF na instrução original.

Para ativar o partition pruning baseado em UDF, anote a classe da UDF:

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

A anotação com.aliyun.odps.udf.annotation.UdfProperty está definida em odps-sdk-udf.jar . Atualize o odps-sdk-udf para a versão 0.30.x ou posterior.

Alternativamente, adicione SET odps.sql.udf.ppr.deterministic = true; antes da instrução SQL para tratar todas as UDFs na instrução como determinísticas. Esse método preenche partições com os resultados do job, até um máximo de 1.000 partições. Se mais de 1.000 partições forem preenchidas, um erro será retornado. Para suprimir o erro e desativar o partition pruning baseado em UDF, execute SET odps.sql.udf.ppr.to.subquery = false;.

A UDF deve estar na cláusula WHERE da tabela de source para que o pruning tenha efeito:

-- 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';

Aliases de coluna indisponíveis no WHERE

Se uma coluna no SELECT_expr usa uma função e é renomeada com um alias, o alias não pode ser referenciado na cláusula WHERE. A instrução a seguir retorna um erro:

-- 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

O GROUP BY agrupa linhas por colunas especificadas e geralmente é usado com funções de agregação.

Regras:

O GROUP BY executa antes do SELECT. As colunas no GROUP BY podem ser especificadas pelos nomes das colunas da tabela de entrada ou por uma expressão formada pelas colunas dessa tabela. Aliases definidos na lista SELECT também podem ser usados no GROUP BY.
Todas as colunas na lista SELECT que não estiverem envolvidas em uma função de agregação devem aparecer na cláusula GROUP BY.
Expressões regulares no GROUP BY devem usar a expressão completa para as colunas.
Não é permitido usar GROUP BY juntamente com DISTRIBUTE BY ou SORT BY.

Agrupar por uma coluna

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

Agregar com GROUP BY

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

Usar um alias do SELECT no 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 uma expressão de coluna

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

Coluna ausente no GROUP BY retorna erro

-- 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 compatível com BigQuery)

Quando odps.sql.bigquery.compatible=true, o GROUP BY ALL agrupa automaticamente por todas as colunas não agregadas na 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 aliases posicionais no GROUP BY

Execute SET odps.sql.groupby.position.alias=true; para tratar constantes inteiras no GROUP BY como posições de coluna na 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

O HAVING filtra dados agrupados, geralmente usando funções de agregação. Ele é avaliado após o 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

O ORDER BY ordena todas as linhas por uma ou mais colunas. A ordenação é global — todos os dados são mesclados em um único nó.

Aviso

Por padrão, o ORDER BY exige uma cláusula LIMIT. Sem o LIMIT, um erro é retornado. Isso evita o processamento acidental de grandes conjuntos de dados em um único nó.

Regras:

A ordem de classificação padrão é ascendente (ASC). Use DESC para ordem descendente.
Valores NULL são tratados como o menor valor (consistente com o comportamento do MySQL).
As colunas do ORDER BY devem referenciar colunas de saída da instrução SELECT — seja pelo nome da coluna ou pelo alias.
Não é permitido usar ORDER BY juntamente com DISTRIBUTE BY ou SORT BY.

Ordenar ascendente (padrão)

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 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 um alias de coluna no ORDER BY

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

Usar aliases posicionais no ORDER BY

Execute SET odps.sql.orderby.position.alias=true; para tratar constantes inteiras no ORDER BY como posições de coluna:

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      |
+------------+-------------+-------------+------------+------------+

Pular linhas com OFFSET

A sintaxe ORDER BY...LIMIT m OFFSET n retorna m linhas começando após as primeiras n linhas. A forma LIMIT n, m é uma abreviação 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       |
+-------------+-------------+

Remover a exigência de LIMIT para ORDER BY

Como o ORDER BY executa em um único nó, a exigência de LIMIT impede a ordenação acidental de conjuntos de dados muito grandes. Para desativar essa exigência:

Nível de projeto: Execute SETPROJECT odps.sql.validate.orderby.limit=false;
Nível de sessão: Envie SET odps.sql.validate.orderby.limit=false; junto com a instrução SQL.

Ordenar grandes conjuntos de dados em um único nó consome mais recursos e leva mais tempo.

Acelerar a ordenação global com Range Clustering

Em cenários típicos de ORDER BY, todos os dados precisam ser processados em um único nó. O Range Clustering amostra os dados primeiro, divide-os em intervalos e depois ordena cada intervalo simultaneamente, produzindo um resultado globalmente ordenado em paralelo. Para detalhes, consulte Aceleração de ordenação global.

Cláusula DISTRIBUTE BY

O DISTRIBUTE BY realiza fragmentação por hash nas linhas com base nas colunas especificadas e roteia linhas com a mesma chave para o mesmo reducer. Use-o para garantir que dados relacionados sejam processados juntos ou para evitar sobreposição de dados entre reducers.

As colunas no DISTRIBUTE BY devem referenciar colunas de saída da instrução SELECT por seus aliases. Se nenhum alias for especificado, o nome da coluna será usado.

-- 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      |
+------------+

Não é possível usar DISTRIBUTE BY juntamente com ORDER BY ou GROUP BY .

Cláusula SORT BY

O SORT BY ordena dados dentro de cada partição do reducer. Ele não garante uma ordem global.

Regras:

A ordem de classificação padrão é ascendente. Use DESC para descendente.
Quando usado com DISTRIBUTE BY, o SORT BY ordena dentro de cada partição criada pelo DISTRIBUTE BY.
Quando usado sem DISTRIBUTE BY, o SORT BY ordena dentro de cada reducer independentemente.

DISTRIBUTE BY + SORT BY (ordenação distribuída)

-- 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 descendentemente 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 sem DISTRIBUTE BY

O SORT BY isoladamente ordena dentro de cada reducer independentemente. Isso não produz um resultado globalmente ordenado, mas melhora a taxa de compressão de armazenamento e reduz leituras de disco durante filtragens, o que pode acelerar operações subsequentes de ordenação 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        |
+------------+-------------+

Aliases de coluna em ORDER BY , DISTRIBUTE BY e SORT BY podem ser especificados em chinês.

Cláusula LIMIT

A sintaxe LIMIT <number> restringe o número de linhas de saída. O valor deve ser um inteiro de 32 bits com máximo de 2.147.483.647.

O LIMIT filtra dados após uma varredura distribuída. Ele não reduz a quantidade de dados verificados nem diminui os custos de computação.

Remover o limite de exibição na tela

Se uma instrução SELECT não tiver cláusula LIMIT, ou se o LIMIT exceder o limite de exibição do projeto (n), a janela de resultados mostrará no máximo n linhas.

Proteção de dados desativada: No arquivo odpscmd_config.ini, defina use_instance_tunnel=true. Sem o parâmetro instance_tunnel_max_record, a exibição é ilimitada. Com ele, a exibição é limitada pelo valor definido — até 10.000 linhas. Para detalhes, consulte Notas de uso.
Proteção de dados ativada: A exibição é limitada por READ_TABLE_MAX_ROW, até 10.000 linhas.

Execute SHOW SecurityConfiguration; para verificar a configuração de ProjectProtection. Se ProjectProtection=true, desative a proteção de dados com SET ProjectProtection=false; apenas se os requisitos do seu projeto permitirem. Para mais informações, consulte Mecanismo de proteção de dados.

Cláusula WINDOW

Para a sintaxe de funções de janela, consulte Sintaxe de funções de janela.

Sintaxe

Limitações

Tipos de consulta relacionados

Dados de exemplo

Cláusula WITH (CTE)

Autorreferência (não compatível)

Referência circular (não compatível)

Referência sequencial (compatível)

Expressão de coluna (SELECT_expr)

Selecionar colunas específicas por nome

Selecionar todas as colunas com *

Filtrar com WHERE

Selecionar colunas por expressão regular

Remover duplicatas com DISTINCT

Excluir colunas (EXCEPT_expr)

Substituir colunas (REPLACE_expr)

Tabela de destino (TABLE_reference)

Consultar uma tabela nomeada

Usar uma subconsulta aninhada como source

Cláusula WHERE

Filtrar com um intervalo de partição

Usar uma UDF para partition pruning

Aliases de coluna indisponíveis no WHERE

Cláusula GROUP BY

Agrupar por uma coluna

Agregar com GROUP BY

Usar um alias do SELECT no GROUP BY

Agrupar por uma expressão de coluna

Coluna ausente no GROUP BY retorna erro

GROUP BY ALL (modo compatível com BigQuery)

Usar aliases posicionais no GROUP BY

Cláusula HAVING

Cláusula ORDER BY

Ordenar ascendente (padrão)

Ordenar descendente

Usar um alias de coluna no ORDER BY

Usar aliases posicionais no ORDER BY

Pular linhas com OFFSET

Remover a exigência de LIMIT para ORDER BY

Acelerar a ordenação global com Range Clustering

Cláusula DISTRIBUTE BY

Cláusula SORT BY

DISTRIBUTE BY + SORT BY (ordenação distribuída)

SORT BY sem DISTRIBUTE BY

Cláusula LIMIT

Remover o limite de exibição na tela

Cláusula WINDOW

Próximos passos

Selecionar todas as colunas com `*`