Commande des Résultats de la Requête

La clause ORDER BY contrôle l’ordre dans lequel les lignes sont renvoyées ou traitées. Il peut être utilisé dans n’importe quelle requête de sélection, y compris les opérandes INSERT ou UPSERT, ainsi qu’avec les instructions DELETE et UPDATE.

Synopsis

Paramètres

La clause ORDER BY prend une liste de spécifications de commande séparées par des virgules.Chaque spécification de commande est composée d’une sélection de colonne suivie optionnellement par le mot clé ASC ou DESC.

Chaque sélection de colonne peut prendre l’une des formes suivantes:

• Une sélection de colonne simple, déterminée comme suit :
  1. Le nom d’une étiquette de colonne configurée avec AS plus tôt dans la clause SELECT. Cela utilise la valeur calculée par la clause SELECT comme clé de tri.
  2. Un nombre entier positif, désignant l’une des colonnes de la source de données, soit la clause FROM de la clause SELECT où cela se produit, soit la table en cours d’écriture par DELETE ou UPDATE. Cela utilise la valeur d’entrée correspondante de la source de données à utiliser comme clé de tri.
  3. Une expression scalaire arbitraire. Cela utilise le résultat de l’évaluation de cette expression comme clé de tri.
• La notation PRIMARY KEY <table_name>. Cela utilise la ou les colonnes de clé primaire de la table donnée comme clé de tri. Cette table doit faire partie de la source de données.
• La notation INDEX <table_name>@<index_name>. Cela utilise les colonnes indexées par l’index donné comme clé de tri. Cette table doit faire partie de la source de données.

Le mot-clé facultatif ASC après une sélection de colonne indique d’utiliser la clé de tri telle quelle, et n’a donc pas de sens.

Le mot-clé optionnel DESC inverse le sens de la ou des colonnes sélectionnées par la sélection qui précède immédiatement.

CockroachDB prend en charge les clauses NULLS FIRST/ NULLS LAST in ORDER BY pour la compatibilité avec la syntaxe de tri de lignes PostgreSQL.

Conservation de l’ordre

En général, l’ordre des résultats intermédiaires d’une requête n’est pas garanti, même si ORDER BY est spécifié. En d’autres termes, la clause ORDER BY n’est efficace qu’à l’instruction de niveau supérieur. Par exemple, il est ignoré par le planificateur de requêtes lorsqu’il est présent dans une sous-requête dans une clause FROM comme suit:

> SELECT * FROM a, b ORDER BY a.x; -- valid, effective> SELECT * FROM (SELECT * FROM a ORDER BY a.x), b; -- ignored, ineffective

Cependant, lors de la combinaison de requêtes avecsub-queries, certaines combinaisons rendront la clause ORDER BY dans une sous-requête significative:

1. L’ordre de l’opérande d’une clause WITH ORDINALITY (au sein de l’opérande FROM d’une clause SELECT) est conservé, pour contrôler la numérotation des lignes.
2. L’ordre de l’opérande d’une clause LIMIT ou OFFSET autonome (au sein de l’opérande FROM d’une clause SELECT) est conservé, pour déterminer quelles lignes sont conservées dans le résultat.
3. L’ordre de la source de données pour une instruction INSERT ou une instruction UPSERT qui utilise également LIMIT est conservé, afin de déterminer quelles lignes sont traitées, mais pas leur ordre.
4. L’ordre indiqué pour une instruction UPDATE ou DELETE qui utilise également LIMIT est utilisé pour déterminer quelles lignes sont traitées, mais pas leur ordre.(Ceci est une extension CockroachDB.)
5. L’ordre d’une sous-requête utilisée dans une expression scalaire est conservé.

Par exemple, en utilisant WITH ORDINALITY:

> SELECT * FROM (SELECT * FROM a ORDER BY a.x) WITH ORDINALITY; -- ensures that the rows are numbered in the order of column a.x.

Par exemple, en utilisant une clause LIMIT autonome dans FROM:

Par exemple, en utilisant une sous-requête dans un contexte scalaire :

Ordre des lignes sans ORDRE PAR

Sans ORDER BY, les lignes sont traitées ou renvoyées dans un ordre anon-déterministe. « Non déterministe » signifie que l’ordre actuelpeut dépendre du plan logique, de l’ordre des données sur le disque, de la topologie du cluster CAFARDDB et est généralement variable dans le temps.

Tri à l’aide de simples sélections de colonnes

En considérant le tableau suivant:

> CREATE TABLE a(a INT);> INSERT INTO a VALUES (1), (3), (2);

Les instructions suivantes sont équivalentes :

+---------+| a |+---------+| 1 || 2 || 3 |+---------+(3 rows)

Notez que l’ordre des règles compte. En cas d’ambiguïté, les alias AS priorisent les colonnes de la source de données, par exemple :

Il est également possible de trier en utilisant une expression scalaire arbitraire calculée pour chaque ligne, par exemple:

> SELECT a, b FROM ab ORDER BY a + b; -- orders by the result of computing a+b.

Tri à l’aide de plusieurs colonnes

Lorsque plusieurs spécifications de commande sont données, les spécifications ultérieures sont utilisées pour commander des lignes égales aux spécifications antérieures, par exemple :

> CREATE TABLE ab(a INT, b INT);> SELECT a, b FROM ab ORDER BY b, a;

Cela trie les résultats par colonne b, puis s’il y a des multiplicateurs qui ont la même valeur dans la colonne b, il les ordonnera ensuite par colonne a.

Inverser l’ordre de tri

Le mot clé DESC (« décroissant ») peut être ajouté après une spécification de commande pour inverser son ordre. Cela peut être spécifié séparément pour chaque spécification, par exemple :

> CREATE TABLE ab(a INT, b INT);> SELECT a, b FROM ab ORDER BY b DESC, a; -- sorts on b descending, then a ascending.

Tri dans l’ordre de la clé primaire

La notation ORDER BY PRIMARY KEY garantit que les résultats sont présentés dans l’ordre de la clé primaire.

L’avantage particulier est que pour les requêtes utilisant l’index principal, cela garantit l’ordre tout en garantissant qu’il n’y aura pas de calcul de tri supplémentaire pour y parvenir, par exemple :

> CREATE TABLE kv(k INT PRIMARY KEY, v INT);> SELECT k, v FROM kv ORDER BY PRIMARY KEY kv; -- guarantees ordering by column k.

Si une clé primaire utilise déjà le mot-clé DESC, sa signification sera retournée (annulée) si la clause ORDER BY utilise également DESC, par exemple :

Tri dans l’ordre de l’index

La notation ORDER BY INDEX garantit que les résultats sont présentés dans l’ordre d’un index donné.

L’avantage particulier est que pour les requêtes utilisant cet index, cela garantit l’ordre tout en garantissant qu’il n’y aura pas de calcul de tri supplémentaire pour l’atteindre, par exemple:

> CREATE TABLE kv(k INT PRIMARY KEY, v INT, INDEX v_idx(v));> SELECT k, v FROM kv ORDER BY INDEX kv@v_idx; -- guarantees ordering by column v.

Si un index utilise déjà le mot-clé DESC, sa signification sera retournée (annulée) si la clause ORDER BY utilise également DESC, par exemple :

Ordonnant des lignes dans des instructions DML

Lors de l’utilisation de ORDER BY avec un INSERT,UPSERT, UPDATE ou DELETE (c.-à-d., une instruction DML), la clause ORDER BY est signalée si elle n’est pas utilisée en combinaison avec LIMIT et/ou OFFSET.

La combinaison des ORDER BY et LIMIT/ OFFSET détermine quelles lignes de l’entrée sont utilisées pour insérer, mettre à jour ou supprimer les données de la table, mais elle ne détermine pas dans quel ordre la mutation prend place.

Par exemple, en utilisant LIMIT dans INSERT:

> INSERT INTO a SELECT * FROM b ORDER BY b.x LIMIT 1; -- ensures that only the first row of b in the order of column b.x -- is inserted into a.

La raison pour laquelle ORDER BY ne contrôle pas l’ordre final des lignes dans la table est que l’ordre des lignes dans la table cible est déterminé par ses index primaires et secondaires.

Pour ordonner le résultat de la clause RETURNING, reportez-vous à Tri de la sortie des suppressions.

Tri de la sortie de deletes

Pour trier la sortie d’une instruction DELETE, utilisez :

> WITH a AS (DELETE ... RETURNING ...) SELECT ... FROM a ORDER BY ...

Pour un exemple, consultez Trier et renvoyer les lignes supprimées.

Voir aussi

• Requêtes de sélection
• Expressions scalaires
• INSERT
• UPSERT
• DELETE
• UPDATE