> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-parallel-read-in-order-multi-part.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > Documentation de la clause LIMIT # 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`](#limit-after-until). ## Syntaxe de base **Sélectionner les premières lignes :** ```sql theme={null} 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) :** ```sql theme={null} -- 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 :** ```sql theme={null} 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 :** ```sql theme={null} 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](#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](/fr/reference/data-types/float) 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 : ```sql theme={null} 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](#limit-after-until) 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`](/fr/reference/statements/select/limit-by) peut précéder une plage dans la même query, et le paramètre [`limit`](/fr/reference/settings/session-settings/other#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](#limit-after-until). ```sql theme={null} SELECT * FROM ( SELECT number % 50 AS n FROM numbers(100) ) ORDER BY n LIMIT 0, 5 ``` ```response theme={null} ┌─n─┐ │ 0 │ │ 0 │ │ 1 │ │ 1 │ │ 2 │ └───┘ ``` Avec `WITH TIES`, toutes les lignes ayant la même valeur que la dernière sont incluses : ```sql theme={null} SELECT * FROM ( SELECT number % 50 AS n FROM numbers(100) ) ORDER BY n LIMIT 0, 5 WITH TIES ``` ```response theme={null} ┌─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` : ```sql theme={null} SELECT * FROM ( SELECT number % 50 AS n FROM numbers(100) ) ORDER BY n LIMIT 3 OFFSET 2 WITH TIES ``` ```response theme={null} ┌─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 : ```sql theme={null} SELECT number % 3 AS n FROM numbers(15) ORDER BY n LIMIT -4 OFFSET -3 WITH TIES ``` ```response theme={null} ┌─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`](/fr/reference/statements/select/order-by#order-by-expr-with-fill-modifier). ## LIMIT ... AFTER ... UNTIL (plage par conditions) Vous pouvez limiter le résultat à une *plage* de ligne comprises entre deux conditions de délimitation : ```sql theme={null} 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` : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT 3 AFTER number >= 3; ``` ```response theme={null} ┌─number─┐ │ 3 │ │ 4 │ │ 5 │ └────────┘ ``` Lignes depuis la première ligne où `number >= 2` jusqu'à (exclue) la première ligne où `number >= 6` : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT 10 AFTER number >= 2 UNTIL number >= 6; ``` ```response theme={null} ┌─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 : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number >= 7; ``` ```response theme={null} ┌─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 : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number >= 2 UNTIL number >= 6; ``` ```response theme={null} ┌─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` : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number = 3 UNTIL number IN (1, 6); ``` ```response theme={null} ┌─number─┐ │ 3 │ │ 4 │ │ 5 │ └────────┘ ``` Émettre 2 lignes après chaque ligne correspondante, sans dupliquer les chevauchements : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT 2 AFTER number IN (2, 3, 6) ALL; ``` ```response theme={null} ┌─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` : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT 2 AFTER number IN (2, 6) ALL UNTIL number = 7; ``` ```response theme={null} ┌─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 : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT AFTER number IN (2, 6) ALL UNTIL number = 4; ``` ```response theme={null} ┌─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 : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT UNTIL number >= 3; ``` ```response theme={null} ┌─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 : ```sql theme={null} SELECT number FROM numbers(10) ORDER BY number LIMIT 2 UNTIL number >= 3; ``` ```response theme={null} ┌─number─┐ │ 0 │ │ 1 │ └────────┘ ``` Une plage peut suivre [`LIMIT BY`](/fr/reference/statements/select/limit-by) et s'applique alors aux lignes conservées par `LIMIT BY` : ```sql theme={null} SELECT number % 4 AS k, number FROM numbers(12) ORDER BY k, number LIMIT 2 BY k LIMIT 3 AFTER k >= 1; ``` ```response theme={null} ┌─k─┬─number─┐ │ 1 │ 1 │ │ 1 │ 5 │ │ 2 │ 2 │ └───┴────────┘ ``` ## Considérations **Résultats non déterministes :** Sans clause [`ORDER BY`](/fr/reference/statements/select/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](/fr/reference/settings/session-settings/other#limit). ## Voir aussi * [LIMIT BY](/fr/reference/statements/select/limit-by) — Limite le nombre de lignes par groupe de valeurs, utile pour obtenir les résultats top N dans chaque catégorie.