sql >> Database teknologi >  >> RDS >> Sqlserver

Begræns antallet af returnerede rækker i en SQL Server-forespørgsel ved at bruge TOP-klausulen

I SQL Server kan du bruge TOP klausul for at begrænse de rækker, der returneres fra et forespørgselsresultatsæt. Denne klausul giver lignende funktionalitet som LIMIT i MySQL og ROWNUM i Oracle, selvom der er forskel på, hvordan hver af disse fungerer.

Nedenfor er eksempler på brug af TOP klausul for at begrænse resultatsættet i SQL Server.

Eksempel 1 – Grundlæggende brug

Her er et grundlæggende eksempel på, hvordan TOP virker:

SELECT TOP(3) * 
FROM Albums;

Resultat:

+-----------+-----------------------+---------------+------------+-----------+
| AlbumId   | AlbumName             | ReleaseDate   | ArtistId   | GenreId   |
|-----------+-----------------------+---------------+------------+-----------|
| 1         | Powerslave            | 1984-09-03    | 1          | 1         |
| 2         | Powerage              | 1978-05-05    | 2          | 1         |
| 3         | Singing Down the Lane | 1956-01-01    | 6          | 3         |
+-----------+-----------------------+---------------+------------+-----------+

I dette tilfælde begrænsede jeg resultaterne til kun tre rækker.

Lad os køre forespørgslen igen, men denne gang uden TOP klausul:

SELECT * 
FROM Albums;

Resultat:

+-----------+--------------------------+---------------+------------+-----------+
| AlbumId   | AlbumName                | ReleaseDate   | ArtistId   | GenreId   |
|-----------+--------------------------+---------------+------------+-----------|
| 1         | Powerslave               | 1984-09-03    | 1          | 1         |
| 2         | Powerage                 | 1978-05-05    | 2          | 1         |
| 3         | Singing Down the Lane    | 1956-01-01    | 6          | 3         |
| 4         | Ziltoid the Omniscient   | 2007-05-21    | 5          | 1         |
| 5         | Casualties of Cool       | 2014-05-14    | 5          | 1         |
| 6         | Epicloud                 | 2012-09-18    | 5          | 1         |
| 7         | Somewhere in Time        | 1986-09-29    | 1          | 1         |
| 8         | Piece of Mind            | 1983-05-16    | 1          | 1         |
| 9         | Killers                  | 1981-02-02    | 1          | 1         |
| 10        | No Prayer for the Dying  | 1990-10-01    | 1          | 1         |
| 11        | No Sound Without Silence | 2014-09-12    | 9          | 4         |
| 12        | Big Swing Face           | 1967-06-01    | 4          | 2         |
| 13        | Blue Night               | 2000-11-01    | 12         | 4         |
| 14        | Eternity                 | 2008-10-27    | 12         | 4         |
| 15        | Scandinavia              | 2012-06-11    | 12         | 4         |
| 16        | Long Lost Suitcase       | 2015-10-09    | 7          | 4         |
| 17        | Praise and Blame         | 2010-06-26    | 7          | 4         |
| 18        | Along Came Jones         | 1965-05-21    | 7          | 4         |
| 19        | All Night Wrong          | 2002-05-05    | 3          | 2         |
| 20        | The Sixteen Men of Tain  | 2000-03-20    | 3          | 2         |
| 21        | Yo Wassup                | 2019-03-12    | 9          | 3         |
| 22        | Busted                   | 1901-05-11    | 9          | 3         |
+-----------+--------------------------+---------------+------------+-----------+

Så vi kan se, at den første forespørgsel kun returnerede de tre første fra et større sæt.

Eksempel 2 – Brug af ORDER BY-klausulen

Microsoft udtaler, at det er bedste praksis altid at bruge ORDER BY når du bruger TOP klausul. Dette skyldes, at det er den eneste måde at forudsigeligt angive, hvilke rækker der er påvirket af TOP .

Derfor kunne vi omskrive det første eksempel til følgende:

SELECT TOP(3) * 
FROM Albums
ORDER BY AlbumId;

Resultat:

+-----------+-----------------------+---------------+------------+-----------+
| AlbumId   | AlbumName             | ReleaseDate   | ArtistId   | GenreId   |
|-----------+-----------------------+---------------+------------+-----------|
| 1         | Powerslave            | 1984-09-03    | 1          | 1         |
| 2         | Powerage              | 1978-05-05    | 2          | 1         |
| 3         | Singing Down the Lane | 1956-01-01    | 6          | 3         |
+-----------+-----------------------+---------------+------------+-----------+

Det er vigtigt at forstå, hvordan bestilling påvirker resultaterne. Ellers kan du ende med uventede resultater.

Her er, hvad der sker, hvis jeg bruger den samme forespørgsel igen, men bestiller efter en anden kolonne:

SELECT TOP(3) * 
FROM Albums
ORDER BY ArtistId;

Resultat:

+-----------+-------------------+---------------+------------+-----------+
| AlbumId   | AlbumName         | ReleaseDate   | ArtistId   | GenreId   |
|-----------+-------------------+---------------+------------+-----------|
| 1         | Powerslave        | 1984-09-03    | 1          | 1         |
| 7         | Somewhere in Time | 1986-09-29    | 1          | 1         |
| 8         | Piece of Mind     | 1983-05-16    | 1          | 1         |
+-----------+-------------------+---------------+------------+-----------+

Indsættelse, sletning og opdatering i rækkefølge

Bemærk, at selvom du kan bruge TOP klausul i INSERT , UPDATE , MERGE og DELETE udsagn, kan du ikke direkte angive ORDER BY klausul i disse erklæringer. Du kan dog bruge en sub-select-sætning til at indsætte, slette eller ændre rækker i en meningsfuld kronologisk rækkefølge.

Eksempel 3 – Brug af WITH TIES-argumentet

Du kan bruge den valgfrie WITH TIES argument for at returnere alle rækker, der er lige til sidstepladsen i det begrænsede resultatsæt. Dette gælder kun (og kan kun bruges), når du bruger ORDER BY klausul.

Hvis ORDER BY klausul bevirker, at to eller flere rækker hænger sammen til sidste plads ved hjælp af WITH TIES , vil få dem alle til at blive returneret. Dette kan forårsage, at der returneres flere rækker, end du faktisk angiver.

Dette er lettere forklaret med et eksempel.

SELECT TOP(3) WITH TIES *
FROM Albums
ORDER BY ArtistId;

Resultat:

+-----------+-------------------------+---------------+------------+-----------+
| AlbumId   | AlbumName               | ReleaseDate   | ArtistId   | GenreId   |
|-----------+-------------------------+---------------+------------+-----------|
| 1         | Powerslave              | 1984-09-03    | 1          | 1         |
| 7         | Somewhere in Time       | 1986-09-29    | 1          | 1         |
| 8         | Piece of Mind           | 1983-05-16    | 1          | 1         |
| 9         | Killers                 | 1981-02-02    | 1          | 1         |
| 10        | No Prayer for the Dying | 1990-10-01    | 1          | 1         |
+-----------+-------------------------+---------------+------------+-----------+

Her angiver jeg, at kun de øverste 3 rækker skal returneres, men 5 returneres faktisk. Dette skyldes, at der er 5 rækker, der bruger det samme ArtistId, og så rækker 3 – 5 er alle lige til sidstepladsen. I dette tilfælde bruger jeg WITH TIES at returnere dem alle.

Hvis jeg fjerner WITH TIES , kun 3 rækker returneres:

SELECT TOP(3) *
FROM Albums
ORDER BY ArtistId;

Resultat:

+-----------+-------------------+---------------+------------+-----------+
| AlbumId   | AlbumName         | ReleaseDate   | ArtistId   | GenreId   |
|-----------+-------------------+---------------+------------+-----------|
| 1         | Powerslave        | 1984-09-03    | 1          | 1         |
| 7         | Somewhere in Time | 1986-09-29    | 1          | 1         |
| 8         | Piece of Mind     | 1983-05-16    | 1          | 1         |
+-----------+-------------------+---------------+------------+-----------+

Bemærk, at WITH TIES argument kan kun angives i SELECT sætninger, og kun hvis de bruger ORDER BY klausul. Den returnerede rækkefølge af binding af poster er også vilkårlig.

Eksempel 4 – Brug af procenter

Du har også mulighed for at angive en procentværdi i stedet for et bestemt antal rækker. For at gøre dette skal du bruge PERCENT argument.

Eksempel:

SELECT TOP(10) PERCENT * 
FROM Albums
ORDER BY AlbumId;

Resultat:

+-----------+-----------------------+---------------+------------+-----------+
| AlbumId   | AlbumName             | ReleaseDate   | ArtistId   | GenreId   |
|-----------+-----------------------+---------------+------------+-----------|
| 1         | Powerslave            | 1984-09-03    | 1          | 1         |
| 2         | Powerage              | 1978-05-05    | 2          | 1         |
| 3         | Singing Down the Lane | 1956-01-01    | 6          | 3         |
+-----------+-----------------------+---------------+------------+-----------+

Bemærk, at brøkværdier rundes op til næste heltalsværdi. I dette tilfælde er 10 procent af 22 rækker 2,2, men fordi det blev rundet op, ender vi med 3 rækker.

Så en fordobling af procentdelen vil ikke nødvendigvis resultere i det dobbelte antal rækker:

SELECT TOP(20) PERCENT * 
FROM Albums
ORDER BY AlbumId;

Resultat:

+-----------+------------------------+---------------+------------+-----------+
| AlbumId   | AlbumName              | ReleaseDate   | ArtistId   | GenreId   |
|-----------+------------------------+---------------+------------+-----------|
| 1         | Powerslave             | 1984-09-03    | 1          | 1         |
| 2         | Powerage               | 1978-05-05    | 2          | 1         |
| 3         | Singing Down the Lane  | 1956-01-01    | 6          | 3         |
| 4         | Ziltoid the Omniscient | 2007-05-21    | 5          | 1         |
| 5         | Casualties of Cool     | 2014-05-14    | 5          | 1         |
+-----------+------------------------+---------------+------------+-----------+

I dette tilfælde er 20 procent af 22 4,4. Endnu en gang er det rundet op, og vi får 5 rækker.

Eksempel 5 – Fjernelse af parenteser

Det er muligt at fjerne parenteserne, når du bruger TOP klausul, men det anbefales ikke.

Uanset hvad, her er et eksempel på at fjerne parenteserne fra det forrige eksempel:

SELECT TOP 20 PERCENT * 
FROM Albums
ORDER BY AlbumId;

Resultat:

+-----------+------------------------+---------------+------------+-----------+
| AlbumId   | AlbumName              | ReleaseDate   | ArtistId   | GenreId   |
|-----------+------------------------+---------------+------------+-----------|
| 1         | Powerslave             | 1984-09-03    | 1          | 1         |
| 2         | Powerage               | 1978-05-05    | 2          | 1         |
| 3         | Singing Down the Lane  | 1956-01-01    | 6          | 3         |
| 4         | Ziltoid the Omniscient | 2007-05-21    | 5          | 1         |
| 5         | Casualties of Cool     | 2014-05-14    | 5          | 1         |
+-----------+------------------------+---------------+------------+-----------+

Microsoft anbefaler, at du altid bruger parenteserne, da det giver overensstemmelse med dens påkrævede brug i INSERT , UPDATE , MERGE og DELETE udsagn.

Parentesen er valgfri af årsager til bagudkompatibilitet.


  1. Hvad er den bedste måde at oprette og udfylde en taltabel på?

  2. SQLite - JOIN-sætninger

  3. Hvordan erklærer man en variabel i MySQL?

  4. Håndtering af endnu en PostgreSQL Commitfest