LIMIT

La clause LIMIT détermine le nombre de lignes renvoyées par votre requête. Les lignes peuvent être sélectionnées par nombre et décalage, ou par les conditions qui ouvrent et ferment une plage de lignes avec LIMIT ... AFTER ... UNTIL.

Syntaxe de base

Sélectionner les premières lignes :

LIMIT m

Renvoie les m premières lignes du résultat, ou tous les enregistrements s’il y en a moins de m. Syntaxe alternative de TOP (compatible MS SQL Server) :

-- SELECT TOP number|percent column_name(s) FROM table_name
SELECT TOP 10 * FROM numbers(100);
SELECT TOP 0.1 * FROM numbers(100);

Cela est équivalent à LIMIT m et peut être utilisé pour assurer la compatibilité avec les requêtes de Microsoft SQL Server. Sélection avec OFFSET :

LIMIT m OFFSET n
-- or equivalently:
LIMIT n, m

Saute les n premières lignes, puis renvoie les m lignes suivantes. Dans les deux cas, n et m doivent être des entiers non négatifs. Sélectionner une plage selon des conditions :

LIMIT [n] AFTER start_expr [UNTIL end_expr]
LIMIT [n] UNTIL end_expr

Renvoie les lignes à partir de la première ligne où start_expr est vrai, ou depuis le début du stream lorsque AFTER est omis, jusqu’à la première ligne, à ce début ou après celui-ci, où end_expr est vrai, celle-ci étant exclue ; n limite la longueur de cette plage. AFTER start_expr ALL ouvre une plage à chaque ligne correspondante. Voir LIMIT … AFTER … UNTIL ci-dessous.

Limites négatives

Sélectionnez des lignes depuis la fin de l’ensemble de résultats à l’aide de valeurs négatives :

Syntaxe	Résultat
`LIMIT -m`	`m` dernières lignes
`LIMIT -m OFFSET -n`	`m` dernières lignes après avoir ignoré les `n` dernières lignes
`LIMIT m OFFSET -n`	`m` premières lignes après avoir ignoré les `n` dernières lignes
`LIMIT -m OFFSET n`	`m` dernières lignes après avoir ignoré les `n` premières lignes

La syntaxe LIMIT -n, -m est équivalente à LIMIT -m OFFSET -n.

Limites fractionnaires

Utilisez des valeurs décimales comprises entre 0 et 1 pour sélectionner un pourcentage de lignes :

Syntaxe	Résultat
`LIMIT 0.1`	Les 10 % premières lignes
`LIMIT 1 OFFSET 0.5`	La ligne médiane
`LIMIT 0.25 OFFSET 0.5`	Troisième quartile (25 % des lignes après avoir ignoré les 50 % premières lignes)

Les fractions doivent être des valeurs Float64 supérieures à 0 et inférieures à 1.
Les nombres de lignes fractionnaires sont arrondis à l’entier supérieur.

Combiner différents types de LIMIT

Vous pouvez combiner des entiers standard avec des OFFSET fractionnaires ou négatifs :

LIMIT 10 OFFSET 0.5    -- 10 rows starting from the halfway point
LIMIT 10 OFFSET -20    -- 10 rows after skipping the last 20

La forme par plage ne se combine qu’avec un simple nombre de ligne : LIMIT 3 AFTER start_expr prend au plus trois ligne à partir du point d’ouverture de la plage. OFFSET, les nombres fractionnaires et négatifs, ainsi que WITH TIES sont rejetés lorsqu’ils sont utilisés avec AFTER ou UNTIL. Une clause LIMIT BY peut précéder une plage dans la même query, et le paramètre limit continue de plafonner le résultat.

LIMIT … WITH TIES

Le modificateur WITH TIES inclut des lignes supplémentaires ayant les mêmes valeurs ORDER BY que la dernière ligne incluse dans la limite. Il s’applique uniquement aux limites par nombre et par OFFSET et ne peut pas être combiné avec la forme par plage.

SELECT * FROM (
    SELECT number % 50 AS n FROM numbers(100)
) ORDER BY n LIMIT 0, 5

┌─n─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
└───┘

Avec WITH TIES, toutes les lignes ayant la même valeur que la dernière sont incluses :

SELECT * FROM (
    SELECT number % 50 AS n FROM numbers(100)
) ORDER BY n LIMIT 0, 5 WITH TIES

┌─n─┐
│ 0 │
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
└───┘

La ligne 6 est incluse, car elle a la même valeur (2) que la ligne 5. Le même principe s’applique lorsque le OFFSET est indiqué avec le mot-clé OFFSET :

SELECT * FROM (
    SELECT number % 50 AS n FROM numbers(100)
) ORDER BY n LIMIT 3 OFFSET 2 WITH TIES

┌─n─┐
│ 1 │
│ 1 │
│ 2 │
│ 2 │
└───┘

Si l’on ignore les 2 premières lignes et que l’on en prend 3, le résultat serait normalement 1, 1, 2, mais le deuxième 2 est inclus car il est ex æquo avec la dernière ligne. WITH TIES fonctionne également avec des valeurs négatives de LIMIT et d’OFFSET. Il inclut des lignes supplémentaires ayant les mêmes valeurs ORDER BY que la première ligne sélectionnée :

SELECT number % 3 AS n FROM numbers(15)
ORDER BY n LIMIT -4 OFFSET -3 WITH TIES

┌─n─┐
│ 1 │
│ 1 │
│ 1 │
│ 1 │
│ 1 │
│ 2 │
│ 2 │
└───┘

Sans WITH TIES, le résultat serait 1, 1, 2, 2. Avec WITH TIES, trois lignes supplémentaires ayant la valeur 1 sont incluses, car elles sont ex æquo avec la première ligne sélectionnée. Ce modificateur peut être combiné avec le modificateur ORDER BY ... WITH FILL.

LIMIT … AFTER … UNTIL (plage par conditions)

Vous pouvez limiter le résultat à une plage de ligne comprises entre deux conditions de délimitation :

LIMIT [n] AFTER start_expr [UNTIL end_expr]
LIMIT [n] AFTER start_expr ALL [UNTIL end_expr]
LIMIT [n] UNTIL end_expr

AFTER start_expr : commence la sortie à la première ligne où start_expr est vraie (cette ligne est incluse).
AFTER start_expr ALL : renvoie l’union de toutes les plages correspondantes qui débutent là où start_expr est vraie, sans dupliquer les lignes lorsque les plages se chevauchent.
UNTIL end_expr : termine chaque plage avant la première ligne, située à son début ou après, où end_expr est vraie (cette ligne est exclue).
n : nombre de lignes facultatif. Sans ALL, il correspond à la longueur maximale de l’unique plage ouverte. Avec AFTER ... ALL, il correspond à la longueur de chaque plage ouverte, si bien que le résultat total peut dépasser n (par exemple, LIMIT 2 AFTER number IN (2, 6) ALL peut renvoyer jusqu’à quatre lignes). Pour plafonner le nombre total de lignes de résultat, utilisez le paramètre limit, appliqué comme limite globale après la plage.

L’ordre du flux (l’ordre dans lequel les lignes sont lues) détermine la « première » correspondance ; utilisez ORDER BY pour le contrôler. Les correspondances UNTIL antérieures au début d’une plage n’ont aucun effet. Si les deux conditions correspondent à la ligne de départ, la plage est vide. Si aucune correspondance UNTIL ne survient au début ou après, la plage se poursuit jusqu’à son nombre de lignes n ou jusqu’à la fin du stream. Avec AFTER ... ALL, les correspondances AFTER ultérieures peuvent ouvrir de nouvelles plages après la fin d’une plage précédente. Avec AFTER et sans ALL, l’étape de plage évalue AFTER jusqu’à trouver un fragment contenant une correspondance de début. Elle évalue ensuite UNTIL dans ce fragment et dans les fragments suivants tant que la plage reste ouverte. Les expressions sont évaluées sur des fragments entiers, si bien que UNTIL peut tout de même être évaluée pour des lignes situées avant le début à l’intérieur du fragment de départ. Si UNTIL contient des fonctions à état telles que rowNumberInAllBlocks, ou des fonctions non déterministes au sein de la requête, elle est évaluée dès le premier fragment afin de préserver le comportement de ces fonctions. Sans ALL, AFTER n’est évaluée que jusqu’au fragment de départ inclus ; les fragments suivants n’évaluent que UNTIL. Les correspondances de fin antérieures au début n’ont toujours aucun effet. Exemples : Les 3 premières lignes à partir de la première ligne où number >= 3 :

SELECT number FROM numbers(10) ORDER BY number LIMIT 3 AFTER number >= 3;

┌─number─┐
│      3 │
│      4 │
│      5 │
└────────┘

Lignes depuis la première ligne où number >= 2 jusqu’à (exclue) la première ligne où number >= 6 :

SELECT number FROM numbers(10) ORDER BY number LIMIT 10 AFTER number >= 2 UNTIL number >= 6;

┌─number─┐
│      2 │
│      3 │
│      4 │
│      5 │
└────────┘

Sans n, toutes les ligne depuis la correspondance AFTER jusqu’à la fin du stream (ou jusqu’à UNTIL) sont renvoyées :

SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number >= 7;

┌─number─┐
│      7 │
│      8 │
│      9 │
└────────┘

Sans n mais avec UNTIL, la plage s’étend de la première correspondance AFTER jusqu’à la première correspondance UNTIL située à cette position ou après :

SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number >= 2 UNTIL number >= 6;

┌─number─┐
│      2 │
│      3 │
│      4 │
│      5 │
└────────┘

Une correspondance UNTIL située avant le début est ignorée ; ici, number = 1 n’a aucun effet, et la plage se termine avant number = 6 :

SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number = 3 UNTIL number IN (1, 6);

┌─number─┐
│      3 │
│      4 │
│      5 │
└────────┘

Émettre 2 lignes après chaque ligne correspondante, sans dupliquer les chevauchements :

SELECT number FROM numbers(10) ORDER BY number LIMIT 2 AFTER number IN (2, 3, 6) ALL;

┌─number─┐
│      2 │
│      3 │
│      4 │
│      6 │
│      7 │
└────────┘

Avec ALL et UNTIL, chaque plage ouverte se termine à ses n lignes ou à la correspondance UNTIL suivante, selon ce qui survient en premier ; ici, la plage ouverte à 6 est coupée par number = 7 :

SELECT number FROM numbers(10) ORDER BY number LIMIT 2 AFTER number IN (2, 6) ALL UNTIL number = 7;

┌─number─┐
│      2 │
│      3 │
│      6 │
└────────┘

Sans n, une correspondance UNTIL ferme la plage courante et une correspondance AFTER ultérieure en ouvre une nouvelle, qui s’étend jusqu’à la fin si aucune autre correspondance UNTIL ne suit :

SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number IN (2, 6) ALL UNTIL number = 4;

┌─number─┐
│      2 │
│      3 │
│      6 │
│      7 │
│      8 │
│      9 │
└────────┘

Sans n et sans UNTIL, chaque plage ouverte s’étend jusqu’à la fin du stream, si bien que AFTER start_expr ALL renvoie les mêmes lignes que AFTER start_expr.

WITH TIES, les valeurs fractionnaires/négatives de LIMIT/OFFSET et OFFSET ne sont pas pris en charge conjointement avec AFTER/UNTIL.
Le pushdown préliminaire de LIMIT est désactivé lorsque AFTER/UNTIL est utilisé.
AFTER et UNTIL ne sont reconnus comme mots-clés que si une expression de limite les suit ; ainsi, un identifiant nommé after ou until fonctionne toujours comme un nombre de lignes (LIMIT after, LIMIT after BY x). Lorsque les deux interprétations sont possibles, le mot-clé l’emporte : LIMIT after(2) correspond à la plage LIMIT AFTER (2) ; écrivez LIMIT (after(2)) pour appeler une FUNCTION nommée after.

UNTIL seul renvoie les lignes depuis le début du stream jusqu’à la première ligne où la condition est vrai :

SELECT number FROM numbers(10) ORDER BY number LIMIT UNTIL number >= 3;

┌─number─┐
│      0 │
│      1 │
│      2 │
└────────┘

Avec n, UNTIL employé seul renvoie au maximum n lignes depuis le début du stream, tout en s’arrêtant à la première correspondance :

SELECT number FROM numbers(10) ORDER BY number LIMIT 2 UNTIL number >= 3;

┌─number─┐
│      0 │
│      1 │
└────────┘

Une plage peut suivre LIMIT BY et s’applique alors aux lignes conservées par LIMIT BY :

SELECT number % 4 AS k, number FROM numbers(12) ORDER BY k, number LIMIT 2 BY k LIMIT 3 AFTER k >= 1;

┌─k─┬─number─┐
│ 1 │      1 │
│ 1 │      5 │
│ 2 │      2 │
└───┴────────┘

Considérations

Résultats non déterministes : Sans clause ORDER BY, les lignes renvoyées peuvent être choisies de manière arbitraire et varier d’une exécution de requête à l’autre. Limite côté serveur : Le nombre de lignes renvoyées peut également être affecté par le paramètre limit.

Voir aussi

LIMIT BY — Limite le nombre de lignes par groupe de valeurs, utile pour obtenir les résultats top N dans chaque catégorie.

Référence SQL

Types de données

Moteurs

Fonctions

Formats

Paramètres

Tables système

Lacs de données

Syntaxe de base

Limites négatives

Limites fractionnaires

Combiner différents types de LIMIT

LIMIT … WITH TIES

LIMIT … AFTER … UNTIL (plage par conditions)

Considérations

Voir aussi

​Syntaxe de base

​Limites négatives

​Limites fractionnaires

​Combiner différents types de LIMIT

​LIMIT … WITH TIES

​LIMIT … AFTER … UNTIL (plage par conditions)

​Considérations

​Voir aussi

Syntaxe de base

Limites négatives

Limites fractionnaires

Combiner différents types de LIMIT

LIMIT … WITH TIES

LIMIT … AFTER … UNTIL (plage par conditions)

Considérations

Voir aussi