Présentation de la syntaxe SELECT - MaxCompute - Centre de documentation Alibaba Cloud

Syntaxe

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

Pour connaître l'ordre d'exécution des clauses dans une instruction SELECT, consultez la rubrique Ordre d'exécution des clauses.

Limites

Une instruction SELECT affiche au maximum 10 000 lignes et renvoie des résultats dont la taille ne dépasse pas 10 Mo. Cette limite ne s'applique pas lorsque SELECT sert de sous-requête ; dans ce cas, toutes les lignes sont renvoyées à la requête parente.
Les analyses complètes de table sur les tables partitionnées sont interdites par défaut. Pour les projets créés après le 10 janvier 2018 à 20:00:00, vous devez spécifier une partition lors de l'interrogation d'une table partitionnée. Cela réduit les coûts d'E/S et de calcul inutiles, en particulier avec la facturation au paiement à l'utilisation. Pour exécuter une analyse complète de table pour la session actuelle, soumettez l'instruction SET odps.sql.allow.fullscan=true; conjointement avec l'instruction SELECT :
```
SET odps.sql.allow.fullscan=true;
SELECT * FROM sale_detail;
```
Pour les tables clusterisées, l'optimisation de l'élagage des buckets (bucket pruning) n'est efficace que si 400 partitions ou moins sont analysées par table. Si l'élagage des buckets ne s'applique pas, davantage de données sont analysées, ce qui augmente les coûts en mode paiement à l'utilisation et dégrade les performances en mode abonnement.

Types de requêtes connexes

Type de requête

Description

Sous-requêtes

Interroger les résultats d'une requête précédente

INTERSECT, UNION et EXCEPT

Effectuer l'intersection, l'union ou le complément des ensembles de résultats de requête

JOIN

Joindre des tables et renvoyer les lignes correspondant aux conditions de jointure et de requête

SEMI JOIN

Filtrer les lignes de la table de gauche à l'aide de la table de droite ; le résultat contient uniquement les données de la table de gauche

Indice MAPJOIN

Améliorer les performances des jointures lors de la jonction d'une grande table avec une ou plusieurs petites tables

Indice SKEWJOIN

Gérer les déséquilibres de données dans les opérations JOIN en traitant séparément les données à forte concentration (hot-spot) et les autres

LATERAL VIEW

Utiliser conjointement avec une fonction définie par l'utilisateur renvoyant une table (UDTF) pour diviser une seule ligne en plusieurs lignes

GROUPING SETS

Agréger et analyser les données selon plusieurs dimensions

SELECT TRANSFORM

Démarrer un processus enfant, envoyer l'entrée formatée via stdin et analyser stdout comme sortie

Indice de taille de fractionnement

Contrôler la concurrence des requêtes en ajustant la taille de fractionnement

Voyage dans le temps et requêtes incrémentielles

Interroger des instantanés historiques (voyage dans le temps) ou des données incrémentielles (requête incrémentielle) à partir de tables Delta

Exemple de données

Les exemples de cette rubrique utilisent la table sale_detail. Exécutez les instructions suivantes pour créer la table et insérer des exemples de données :

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

Interrogez la table pour vérifier :

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

Clause WITH (CTE)

La clause WITH définit une ou plusieurs expressions de table communes (CTE). Chaque CTE agit comme un ensemble de résultats nommé temporaire disponible pour les requêtes suivantes dans la même instruction.

Règles :

Les noms des CTE au sein d'une même clause WITH doivent être uniques.
Une CTE peut référencer d'autres CTE définies précédemment dans la même clause WITH, mais ne peut pas se référencer elle-même ni créer de dépendance circulaire.

Auto-référence (non prise en charge)

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

Référence circulaire (non prise en charge)

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

Référence séquentielle (prise en charge)

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

Expression de colonne (SELECT_expr)

SELECT_expr spécifie les colonnes à renvoyer. Utilisez les noms de colonne, *, des expressions régulières ou les mots-clés DISTINCT et ALL.

Sélectionner des colonnes spécifiques par nom

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

Sélectionner toutes les colonnes avec `*`

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

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

Sélectionner des colonnes par expression régulière

Entourez l'expression régulière d'accents graves.

Sélectionnez toutes les colonnes dont les noms commencent par sh :

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

Excluez shop_name et renvoyez toutes les autres colonnes :

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

Excluez plusieurs colonnes (shop_name et 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      |
+-------------+------------+------------+

Excluez toutes les colonnes dont les noms commencent par 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      |
+------------+-------------+------------+------------+

Lors de l'exclusion de plusieurs colonnes où un nom est un préfixe d'un autre, placez le nom le plus long en premier dans l'expression. Par exemple, si une table possède des partitions ds et dshh , utilisez ` SELECT (dshh|ds)?+.+ FROM t; plutôt que SELECT (ds|dshh)?+.+ FROM t; `.

Supprimer les doublons avec DISTINCT

DISTINCT renvoie des valeurs uniques ; ALL (par défaut) renvoie toutes les lignes, y compris les doublons.

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

Lorsqu'elle est appliquée à plusieurs colonnes, DISTINCT supprime les doublons en fonction de la valeur combinée de toutes les colonnes listées :

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

DISTINCT fonctionne également avec les fonctions de fenêtrage, en supprimant les lignes dupliquées du résultat de la fonction de fenêtrage :

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 et GROUP BY ne peuvent pas être utilisés dans la même requête. L'instruction suivante renvoie une erreur :

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

Exclure des colonnes (EXCEPT_expr)

SELECT * EXCEPT(col1, col2, ...) renvoie toutes les colonnes sauf celles spécifiées.

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

Remplacer des colonnes (REPLACE_expr)

SELECT * REPLACE(expr AS col, ...) renvoie toutes les colonnes, en remplaçant la valeur des colonnes spécifiées par les expressions données.

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

Table cible (TABLE_reference)

TABLE_reference spécifie la table à interroger.

Interroger une table nommée

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

Utiliser une sous-requête imbriquée comme source

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

Clause WHERE

La clause WHERE filtre les lignes. Pour les tables partitionnées, les conditions sur les colonnes de partition permettent l'élagage des partitions (partition pruning) : seules les partitions correspondantes sont analysées.

Opérateurs relationnels pris en charge : >, <, =, >=, <=, <>, LIKE, RLIKE, IN, NOT IN, BETWEEN...AND. Pour plus de détails, consultez la rubrique Opérateurs relationnels.

Filtrer avec une plage de partitions

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

Exécutez l'instruction EXPLAIN pour vérifier que l'élagage des partitions est effectif. Une fonction définie par l'utilisateur (UDF) ou des conditions de partition dans une clause ON de JOIN peuvent empêcher l'élagage. Pour plus d'informations, consultez la rubrique Vérifier l'efficacité de l'élagage des partitions .

Utiliser une UDF pour l'élagage des partitions

Une UDF dans la clause WHERE s'exécute comme une petite tâche préliminaire, et le résultat remplace la UDF dans l'instruction d'origine.

Pour activer l'élagage des partitions basé sur les UDF, annotez la classe UDF :

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

com.aliyun.odps.udf.annotation.UdfProperty est défini dans odps-sdk-udf.jar . Mettez à niveau odps-sdk-udf vers la version 0.30.x ou ultérieure.

Vous pouvez également ajouter SET odps.sql.udf.ppr.deterministic = true; avant l'instruction SQL pour traiter toutes les UDF de l'instruction comme déterministes. Cette méthode remplit rétroactivement les partitions avec les résultats de la tâche, jusqu'à un maximum de 1 000 partitions. Si plus de 1 000 partitions sont remplies rétroactivement, une erreur est renvoyée. Pour supprimer l'erreur et désactiver l'élagage des partitions basé sur les UDF, exécutez SET odps.sql.udf.ppr.to.subquery = false;.

La UDF doit se trouver dans la clause WHERE de la table source pour que l'élagage prenne effet :

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

Les alias de colonne ne sont pas disponibles dans WHERE

Si une colonne dans SELECT_expr utilise une fonction et est renommée avec un alias, l'alias ne peut pas être référencé dans la clause WHERE. L'instruction suivante renvoie une erreur :

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

Clause GROUP BY

GROUP BY regroupe les lignes par colonnes spécifiées et est généralement utilisé avec des fonctions d'agrégation.

Règles :

GROUP BY est exécuté avant SELECT. Les colonnes dans GROUP BY peuvent être spécifiées par les noms de colonne de la table d'entrée, ou par une expression formée à partir des colonnes de cette table. Les alias définis dans la liste SELECT peuvent également être utilisés dans GROUP BY.
Toutes les colonnes de la liste SELECT qui ne sont pas encapsulées dans une fonction d'agrégation doivent apparaître dans la clause GROUP BY.
Les expressions régulières dans GROUP BY doivent utiliser l'expression complète pour les colonnes.
GROUP BY ne peut pas être utilisé conjointement avec DISTRIBUTE BY ou SORT BY.

Grouper par une colonne

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

Agréger avec GROUP BY

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

Utiliser un alias SELECT dans 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      |
+------------+

Grouper par une expression de colonne

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

Colonne GROUP BY manquante renvoie une erreur

-- 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 (mode compatible BigQuery)

Lorsque odps.sql.bigquery.compatible=true, GROUP BY ALL groupe automatiquement par toutes les colonnes non agrégées de la liste 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       |
+-----------+-------------+-----------+--------+-------------+

Utiliser des alias positionnels dans GROUP BY

Exécutez SET odps.sql.groupby.position.alias=true; pour traiter les constantes entières dans GROUP BY comme des positions de colonne dans la liste 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      |
+------------+------------+

Clause HAVING

HAVING filtre les données groupées, généralement à l'aide de fonctions d'agrégation. Elle est évaluée après 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      |
+------------+------------+

Clause ORDER BY

ORDER BY trie toutes les lignes selon une ou plusieurs colonnes. Le tri est global : toutes les données sont fusionnées en un seul nœud.

Avertissement

Par défaut, ORDER BY nécessite une clause LIMIT. Sans LIMIT, une erreur est renvoyée. Cela évite de traiter accidentellement de grands ensembles de données sur un seul nœud.

Règles :

L'ordre de tri par défaut est croissant (ASC). Utilisez DESC pour un ordre décroissant.
Les valeurs NULL sont traitées comme la plus petite valeur (conforme au comportement de MySQL).
Les colonnes ORDER BY doivent référencer les colonnes de sortie de l'instruction SELECT — soit par nom de colonne, soit par alias.
ORDER BY ne peut pas être utilisé conjointement avec DISTRIBUTE BY ou SORT BY.

Tri croissant (par défaut)

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

Tri décroissant

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

Utiliser un alias de colonne dans ORDER BY

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

Utiliser des alias positionnels dans ORDER BY

Exécutez SET odps.sql.orderby.position.alias=true; pour traiter les constantes entières dans ORDER BY comme des positions de colonne :

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

Ignorer des lignes avec OFFSET

ORDER BY...LIMIT m OFFSET n renvoie m lignes en commençant après les premières n lignes. LIMIT n, m est un raccourci équivalent.

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

Supprimer l'exigence LIMIT pour ORDER BY

Étant donné que ORDER BY s'exécute sur un seul nœud, l'exigence LIMIT empêche le tri accidentel de très grands ensembles de données. Pour désactiver cette exigence :

Niveau projet : Exécutez SETPROJECT odps.sql.validate.orderby.limit=false;
Niveau session : Soumettez SET odps.sql.validate.orderby.limit=false; conjointement avec l'instruction SQL.

Le tri de grands ensembles de données sur un seul nœud consomme plus de ressources et prend plus de temps.

Accélérer le tri global avec Range Clustering

Dans les scénarios typiques de ORDER BY, toutes les données doivent être traitées sur un seul nœud. Range Clustering échantillonne d'abord les données, les divise en plages, puis trie chaque plage simultanément, produisant un résultat globalement ordonné en parallèle. Pour plus de détails, consultez la rubrique Accélération du tri global.

Clause DISTRIBUTE BY

DISTRIBUTE BY effectue un hachage des lignes basé sur les colonnes spécifiées, acheminant les lignes ayant la même clé vers le même réducteur. Utilisez-le pour garantir que les données connexes sont traitées ensemble, ou pour éviter le chevauchement des données entre les réducteurs.

Les colonnes dans DISTRIBUTE BY doivent référencer les colonnes de sortie de l'instruction SELECT par leurs alias. Si aucun alias n'est spécifié, le nom de la colonne est utilisé.

-- 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 ne peut pas être utilisé conjointement avec ORDER BY ou GROUP BY .

Clause SORT BY

SORT BY trie les données au sein de chaque partition de réducteur. Elle ne garantit pas un ordre global.

Règles :

L'ordre de tri par défaut est croissant. Utilisez DESC pour un ordre décroissant.
Lorsqu'elle est utilisée avec DISTRIBUTE BY, SORT BY trie au sein de chaque partition créée par DISTRIBUTE BY.
Lorsqu'elle est utilisée sans DISTRIBUTE BY, SORT BY trie indépendamment au sein de chaque réducteur.

DISTRIBUTE BY + SORT BY (tri distribué)

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

Tri décroissant au sein de chaque fragment :

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 sans DISTRIBUTE BY

SORT BY seul trie indépendamment au sein de chaque réducteur. Cela ne produit pas un résultat globalement trié, mais améliore le taux de compression du stockage et réduit les lectures disque lors du filtrage, ce qui peut accélérer les opérations de tri global ultérieures.

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

Les alias de colonne dans ORDER BY , DISTRIBUTE BY et SORT BY peuvent être spécifiés en chinois.

Clause LIMIT

LIMIT <number> restreint le nombre de lignes de sortie. La valeur doit être un entier 32 bits avec un maximum de 2 147 483 647.

LIMIT filtre les données après une analyse distribuée. Elle ne réduit pas la quantité de données analysées ni les coûts de calcul.

Supprimer la limite d'affichage à l'écran

Si une instruction SELECT ne comporte pas de clause LIMIT, ou si LIMIT dépasse la limite d'affichage du projet (n), la fenêtre de résultats affiche au maximum n lignes.

Protection des données désactivée : Dans odpscmd_config.ini, définissez use_instance_tunnel=true. Sans instance_tunnel_max_record, l'affichage est illimité. Avec ce paramètre, l'affichage est plafonné par la valeur — jusqu'à 10 000 lignes. Pour plus de détails, consultez la rubrique Notes d'utilisation.
Protection des données activée : L'affichage est plafonné par READ_TABLE_MAX_ROW, jusqu'à 10 000 lignes.

Exécutez SHOW SecurityConfiguration; pour vérifier le paramètre ProjectProtection. Si ProjectProtection=true, désactivez la protection des données avec SET ProjectProtection=false; uniquement si les exigences de votre projet le permettent. Pour plus d'informations, consultez la rubrique Mécanisme de protection des données.

Clause WINDOW

Pour la syntaxe des fonctions de fenêtrage, consultez la rubrique Syntaxe des fonctions de fenêtrage.

Syntaxe

Limites

Types de requêtes connexes

Exemple de données

Clause WITH (CTE)

Auto-référence (non prise en charge)

Référence circulaire (non prise en charge)

Référence séquentielle (prise en charge)

Expression de colonne (SELECT_expr)

Sélectionner des colonnes spécifiques par nom

Sélectionner toutes les colonnes avec *

Filtrer avec WHERE

Sélectionner des colonnes par expression régulière

Supprimer les doublons avec DISTINCT

Exclure des colonnes (EXCEPT_expr)

Remplacer des colonnes (REPLACE_expr)

Table cible (TABLE_reference)

Interroger une table nommée

Utiliser une sous-requête imbriquée comme source

Clause WHERE

Filtrer avec une plage de partitions

Utiliser une UDF pour l'élagage des partitions

Les alias de colonne ne sont pas disponibles dans WHERE

Clause GROUP BY

Grouper par une colonne

Agréger avec GROUP BY

Utiliser un alias SELECT dans GROUP BY

Grouper par une expression de colonne

Colonne GROUP BY manquante renvoie une erreur

GROUP BY ALL (mode compatible BigQuery)

Utiliser des alias positionnels dans GROUP BY

Clause HAVING

Clause ORDER BY

Tri croissant (par défaut)

Tri décroissant

Utiliser un alias de colonne dans ORDER BY

Utiliser des alias positionnels dans ORDER BY

Ignorer des lignes avec OFFSET

Supprimer l'exigence LIMIT pour ORDER BY

Accélérer le tri global avec Range Clustering

Clause DISTRIBUTE BY

Clause SORT BY

DISTRIBUTE BY + SORT BY (tri distribué)

SORT BY sans DISTRIBUTE BY

Clause LIMIT

Supprimer la limite d'affichage à l'écran

Clause WINDOW

Étapes suivantes

Sélectionner toutes les colonnes avec `*`