SQLite Bestil efter

Oversigt :i denne øvelse lærer du, hvordan du sorterer et resultatsæt af en forespørgsel ved hjælp af SQLite ORDER BY klausul.

Introduktion til SQLite ORDER BY klausul

SQLite gemmer data i tabellerne i en uspecificeret rækkefølge. Det betyder, at rækkerne i tabellen muligvis er i den rækkefølge, som de blev indsat.

Hvis du bruger SELECT sætning for at forespørge data fra en tabel, rækkefølgen af ​​rækker i resultatsættet er uspecificeret.

For at sortere resultatsættet tilføjer du ORDER BY klausul til SELECT erklæring som følger:

SELECT
   select_list
FROM
   table
ORDER BY
    column_1 ASC,
    column_2 DESC;Code language: SQL (Structured Query Language) (sql)

ORDER BY klausulen kommer efter FROM klausul. Det giver dig mulighed for at sortere resultatsættet baseret på en eller flere kolonner i stigende eller faldende rækkefølge.

I denne syntaks placerer du kolonnenavnet, som du vil sortere efter ORDER BY klausul efterfulgt af ASC eller DESC søgeord.

• ASC søgeord betyder stigende.
• Og DESC søgeord betyder faldende.

Hvis du ikke angiver ASC eller DESC søgeord, sorterer SQLite resultatsættet ved hjælp af ASC mulighed. Med andre ord sorterer den som standard resultatsættet i stigende rækkefølge.

Hvis du vil sortere resultatsættet efter flere kolonner, bruger du et komma (,) til at adskille to kolonner. ORDER BY klausul sorterer rækker ved hjælp af kolonner eller udtryk fra venstre mod højre. Med andre ord, ORDER BY klausul sorterer rækkerne ved hjælp af den første kolonne på listen. Derefter sorterer den de sorterede rækker ved hjælp af den anden kolonne, og så videre.

Du kan sortere resultatsættet ved hjælp af en kolonne, der ikke vises i udvalgslisten for SELECT klausul.

SQLite ORDER BY klausuleksempel

Lad os tage tracks tabel i eksempeldatabasen til demonstrationen.

Antag, at du vil hente data fra kolonner med navn, millisekunder og album-id, så bruger du følgende sætning:

SELECT
	name,
	milliseconds, 
        albumid
FROM
	tracks;Code language: SQL (Structured Query Language) (sql)

Prøv det

SELECT sætning, der ikke bruger ORDER BY klausul returnerer et resultatsæt, der ikke er i nogen rækkefølge.

Antag, at du vil sortere resultatsættet baseret på AlbumId kolonne i stigende rækkefølge, bruger du følgende sætning:

SELECT
	name,
	milliseconds, 
	albumid
FROM
	tracks
ORDER BY
	albumid ASC;Code language: SQL (Structured Query Language) (sql)

Prøv det

Resultatsættet er nu sorteret efter AlbumId kolonne i stigende rækkefølge som vist på skærmbilledet.

SQLite bruger ASC som standard, så du kan udelade det i ovenstående erklæring som følger:

SELECT
	name,
	milliseconds, 
	albumid
FROM
	tracks
ORDER BY
	albumid;

Prøv det

Antag, at du vil sortere det sorterede resultat (efter AlbumId ) ovenfor med Milliseconds kolonne i faldende rækkefølge. I dette tilfælde skal du tilføje Milliseconds kolonnen til ORDER BY klausul som følger:

SELECT
	name,
	milliseconds, 
	albumid
FROM
	tracks
ORDER BY
	albumid ASC,
        milliseconds DESC;Code language: SQL (Structured Query Language) (sql)

Prøv det

SQLite sorterer rækker efter AlbumId kolonne i stigende rækkefølge først. Derefter sorterer den det sorterede resultat indstillet efter Milliseconds kolonne i faldende rækkefølge.

Hvis du ser på numrene på albummet med AlbumId 1, opdager du, at rækkefølgen af ​​spor skifter mellem de to udsagn.

SQLite ORDER BY med kolonnepositionen

I stedet for at angive navnene på kolonner, kan du bruge kolonnens placering i ORDER BY klausul.

For eksempel sorterer følgende sætning sporene efter både albumid (3. kolonne) og milliseconds (2. kolonne) i stigende rækkefølge.

SELECT
	name,
	milliseconds, 
	albumid
FROM
	tracks
ORDER BY
	 3,2;Code language: SQL (Structured Query Language) (sql)

Prøv det

Tallet 3 og 2 refererer til AlbumId og Milliseconds i kolonnelisten, der vises i SELECT klausul.

Sortering af NULL'er

I databaseverdenen er NULL speciel. Det angiver, at oplysningerne mangler, eller at dataene ikke er gældende.

Antag, at du vil gemme en kunstners fødselsdag i et bord. På det tidspunkt, hvor du gemmer kunstnerens rekord, har du ikke fødselsdagsoplysningerne.

For at repræsentere de ukendte fødselsdagsoplysninger i databasen kan du bruge en særlig dato som f.eks. 01.01.1900 eller en '' tom streng. Begge disse værdier viser dog ikke tydeligt, at fødselsdagen er ukendt.

NULL blev opfundet for at løse dette problem. I stedet for at bruge en speciel værdi til at angive, at informationen mangler, bruges NULL.

NULL er speciel, fordi du ikke kan sammenligne den med en anden værdi. Kort sagt, hvis de to oplysninger er ukendte, kan du ikke sammenligne dem.

NULL kan endda ikke sammenlignes med sig selv; NULL er ikke lig med sig selv, så NULL = NULL resulterer altid i falsk.

Når det kommer til sortering, anser SQLite NULL for at være mindre end nogen anden værdi.

Det betyder, at NULL'er vises i begyndelsen af ​​resultatsættet, hvis du bruger ASC eller i slutningen af ​​resultatsættet, når du bruger DESC.

SQLite 3.30.0 tilføjede NULLS FIRST og NULLS LAST muligheder til ORDER BY klausul. NULLS FIRST option angiver, at NULL'erne vises i begyndelsen af ​​resultatsættet, mens NULLS LAST option placer NULLs i slutningen af ​​resultatsættet.

Følgende eksempel bruger ORDER BY klausul for at sortere numre efter komponister:

SELECT 
    TrackId, 
    Name, 
    Composer 
FROM 
   tracks
ORDER BY 
   Composer;Code language: SQL (Structured Query Language) (sql)

Først ser du, at NULL'er vises i begyndelsen af ​​resultatsættet, fordi SQLite behandler dem som de laveste værdier. Når du ruller ned i resultatet, vil du se andre værdier:

Følgende eksempel bruger NULLS LAST mulighed for at placere NULL efter andre værdier:

SELECT 
    TrackId, 
    Name, 
    Composer 
FROM 
    tracks
ORDER BY 
    Composer NULLS LAST;Code language: SQL (Structured Query Language) (sql)

Hvis du ruller ned i outputtet, vil du se, at NULL er placeret i slutningen af ​​resultatsættet:

I denne øvelse har du lært, hvordan du bruger SQLite ORDER BY klausul for at sortere resultatsættet ved hjælp af en enkelt kolonne, flere kolonner i stigende og faldende rækkefølge.