Catégories :: Syntaxe de requête

LIMIT / FETCH¶

Contraint le nombre maximal de lignes renvoyées par une instruction ou une sous-requête. LIMIT (syntaxe PostgreSQL) et FETCH (syntaxe ANSI) sont pris en charge et produisent le même résultat.

Voir aussi :: TOP <n>

Syntaxe¶

Syntaxe PostgreSQL¶

SELECT ...
FROM ...
[ ORDER BY ... ]
LIMIT <count> [ OFFSET <start> ]
[ ... ]

Syntaxe ANSI¶

SELECT ...
FROM ...
[ ORDER BY ... ]
[ OFFSET <start> ] [ { ROW | ROWS } ] FETCH [ { FIRST | NEXT } ] <count> [ { ROW | ROWS } ] [ ONLY ]
[ ... ]

Paramètres¶

count

Nombre de lignes retournées. Doit être une constante entière non négative.

Les valeurs NULL, la chaîne vide ('') et $$$$ sont également acceptées et sont traitées comme « illimitées » ; cela est utile principalement pour les connecteurs et les pilotes (tels que le pilote JDBC) s’ils reçoivent une liste de paramètres incomplète lorsqu’ils lient dynamiquement des paramètres à une instruction.

OFFSET start

Le numéro de ligne après lequel les lignes limitées/extraites sont renvoyées. Doit être une constante entière non négative.

Si OFFSET est omis, la sortie commence à la première ligne du jeu de résultats.

Les valeurs NULL, chaîne vide ('') et $$$$ sont également acceptées et sont traitées comme 0 (c’est-à-dire qu’aucune ligne n’est ignorée) ; cela est utile principalement pour les connecteurs et les pilotes (tels que le pilote JDBC) s’ils reçoivent une liste de paramètres incomplète lorsqu’ils lient dynamiquement des paramètres à une instruction.

ONLY

Mot-clé facultatif qui n’affecte pas la sortie. Il est utilisé pour mettre l’accent sur le lecteur humain.

Notes sur l’utilisation¶

Une clause ORDER BY n’est pas requise ; cependant, sans une clause ORDER BY, les résultats ne sont pas déterministes car les résultats des requêtes ne sont pas nécessairement dans un ordre particulier. Pour contrôler les résultats renvoyés, utilisez une clause ORDER BY.
Une clause ORDERBY dans une sous-requête ne garantit que l’ordre dans cette sous-requête. L’ordre n’est pas préservé dans les niveaux de requête externes. Lorsqu’une clause LIMIT dépend d’une clause ORDERBY d’un niveau d’imbrication différent, l’optimiseur peut ne pas appliquer la clause LIMIT comme prévu, et le nombre de lignes retournées peut différer de la valeur LIMIT. Une requête COUNT(*) sur la même sous-requête peut également signaler un nombre de lignes différent du nombre réel de lignes retournées.

Par exemple, dans la requête suivante, la sous-requête la plus interne ordonne les résultats, la sous-requête intermédiaire limite la sortie à six lignes et la requête externe limite la sortie à 100 lignes. Vous pouvez attendre six lignes parce que la clause LIMIT intérieure est plus petite, mais parce que la clause ORDERBY se trouve dans une sous-requête différente de la clause LIMIT, les résultats sont imprévisibles et la requête peut renvoyer plus ou moins de six lignes :
```
SELECT *
  FROM (
        SELECT *
          FROM (
                 SELECT *
                   FROM my_table
                   ORDER BY col1  -- Ordering: innermost level
               )
          LIMIT 6                 -- LIMIT: middle level
       )
  LIMIT 100;                      -- LIMIT: outermost level
```
Pour éviter des résultats imprévisibles, conservez la clause ORDERBY et la clause LIMIT (ou FETCH ) au même niveau de requête :
```
SELECT *
  FROM my_table
  ORDER BY col1
  LIMIT 6;
```
L’élagage Top-K peut améliorer les performances des requêtes qui comprennent à la fois les clauses LIMIT et ORDER BY. Pour plus d’informations, voir Élagage des K premiers résultats pour améliorer la performance des requêtes.
TOP n et LIMIT count sont équivalents.
La clause LIMIT et la clause SAMPLE renvoient un sous-ensemble de lignes d’une table. Lorsque vous utilisez la clause LIMIT, Snowflake renvoie le nombre de lignes spécifié de la manière la plus rapide possible. Lorsque vous utilisez la SAMPLE clause, Snowflake renvoie des lignes en fonction de la méthode d’échantillonnage spécifiée dans la clause.

Exemples¶

Les exemples suivants montrent l’effet de LIMIT. Pour des raisons de simplicité, ces requêtes omettent la clause ORDER BY et supposent que l’ordre de sortie est toujours le même que celui indiqué par la première requête. Les requêtes du monde réel doivent inclure ORDER BY.

SELECT c1 FROM testtable;

+------+
|   C1 |
|------|
|    1 |
|    2 |
|    3 |
|   20 |
|   19 |
|   18 |
|    1 |
|    2 |
|    3 |
|    4 |
| NULL |
|   30 |
| NULL |
+------+

SELECT c1 FROM testtable LIMIT 3 OFFSET 3;

+----+
| C1 |
|----|
| 20 |
| 19 |
| 18 |
+----+

SELECT c1 FROM testtable ORDER BY c1;

+------+
|   C1 |
|------|
|    1 |
|    1 |
|    2 |
|    2 |
|    3 |
|    3 |
|    4 |
|   18 |
|   19 |
|   20 |
|   30 |
| NULL |
| NULL |
+------+

SELECT c1 FROM testtable ORDER BY c1 LIMIT 3 OFFSET 3;

+----+
| ID |
|----|
|  2 |
|  3 |
|  3 |
+----+

Les exemples suivants montrent l’utilisation de NULLs pour indiquer :

Pas de limite au nombre de lignes.

Début à la ligne 1 (aucune ligne n’est ignorée)

CREATE TABLE demo1 (i INTEGER);
INSERT INTO demo1 (i) VALUES (1), (2);

SELECT * FROM demo1 ORDER BY i LIMIT NULL OFFSET NULL;

+---+
| I |
|---|
| 1 |
| 2 |
+---+

SELECT * FROM demo1 ORDER BY i LIMIT '' OFFSET '';

+---+
| I |
|---|
| 1 |
| 2 |
+---+

SELECT * FROM demo1 ORDER BY i LIMIT $$$$ OFFSET $$$$;

+---+
| I |
|---|
| 1 |
| 2 |
+---+