SQLite Kysely: Valitse, Missä, RAJA, SIIRTYMÄ, Count, Ryhmäperuste

Seuraavissa osioissa käydään läpi datan lukeminen SELECT- ja FROM-operaattoreilla, rivien suodattaminen WHERE-operaattoreilla ja sen operaattoreilla, tulosten järjestäminen ja rajoittaminen, koostefunktiot, GROUP BY- ja HAVING-operaattorit, alikyselyt, joukko-operaatiot, NULL-käsittely, CASE-lausekkeet ja yleiset taulukkolausekkeet.

Kirjoittaa SQL-kyselyt vuonna SQLite tietokanta, sinun on tiedettävä, miten SELECT-, FROM-, WHERE-, GROUP BY-, ORDER BY- ja LIMIT-lausekkeet toimivat ja kuinka niitä käytetään.

Tämän opetusohjelman aikana opit käyttämään näitä lausekkeita ja kuinka kirjoittaa SQLite lausekkeet.

Tietojen lukeminen Select-toiminnolla

SELECT-lause on pääkäsky, jota käytät kyselyyn SQLite tietokanta. SELECT-lauseessa määrität, mitä valitaan. Mutta ennen valintalausetta, katsotaan, mistä voimme valita dataa käyttämällä FROM-lausetta.

FROM-lausetta käytetään määrittämään, mistä haluat valita tiedot. From-lauseessa voit määrittää yhden tai useamman taulukon tai alikyselyn, joista valitaan tiedot, kuten näemme myöhemmin opetusohjelmissa.

Huomaa, että kaikissa seuraavissa esimerkeissä sinun on suoritettava sqlite3.exe ja avattava yhteys mallitietokantaan juoksevana:

Vaihe 1) Tässä vaiheessa

Avaa Oma tietokone ja siirry seuraavaan hakemistoon: “C:\sqlite” ja avaa sitten “sqlite3.exe”:

Vaihe 2) Avaa tietokanta “TutorialsSampleDB.db” seuraavalla komennolla:

Nyt olet valmis suorittamaan minkä tahansa tyyppisiä kyselyjä tietokannassa.

SELECT-lauseessa voit valita sarakkeen nimen lisäksi monia muita vaihtoehtoja valitaksesi mitä valitaan. seuraavasti:

VALINTA *

Tämä komento valitsee kaikki sarakkeet kaikista viitatuista taulukoista (tai alikyselyistä) FROM-lauseessa. Esimerkiksi:

SELECT *
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Tämä valitsee kaikki sarakkeet sekä opiskelijoiden että laitosten taulukoista:

VALITSE taulukon nimi.*

Tämä valitsee kaikki sarakkeet vain taulukosta "taulukon nimi". Esimerkiksi:

SELECT Students.*
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Tämä valitsee kaikki sarakkeet vain oppilaiden taulukosta:

Kirjaimellinen arvo

Literaaliarvo on vakioarvo, joka voidaan määrittää select-käskyssä. Voit käyttää kirjaimellisia arvoja tavallisesti samalla tavalla kuin käytät sarakkeiden nimiä SELECT-lauseessa. Nämä kirjaimelliset arvot näytetään jokaiselle riville SQL-kyselyn palauttamista riveistä.

Tässä on esimerkkejä erilaisista kirjaimellisista arvoista, jotka voit valita:

• Numeerinen kirjaimellinen – numerot missä tahansa muodossa, kuten 1, 2.55, … jne.
• Merkkijonoliteraalit – mikä tahansa merkkijono "USA", "tämä on esimerkkiteksti" jne.
• NULL – NULL-arvo.
• Current_TIME – Se näyttää nykyisen ajan.
• CURRENT_DATE – tämä näyttää nykyisen päivämäärän.

Tämä voi olla kätevää joissakin tilanteissa, joissa sinun on valittava vakioarvo kaikille palautetuille riveille. Jos esimerkiksi haluat valita kaikki opiskelijat Opiskelijat-taulukosta uudella sarakkeella nimeltä maa, joka sisältää arvon "USA", voit tehdä näin:

SELECT *, 'USA' AS Country FROM Students;

Tämä antaa sinulle kaikki oppilaiden sarakkeet sekä uuden sarakkeen "Maa", kuten tämä:

Huomaa, että tämä uusi sarake Maa ei itse asiassa ole uusi taulukkoon lisätty sarake. Se on virtuaalinen sarake, joka on luotu kyselyssä tulosten näyttämistä varten, eikä sitä luoda taulukkoon.

Nimet ja alias

Alias ​​on sarakkeen uusi nimi, jonka avulla voit valita sarakkeen uudella nimellä. Sarakealiakset määritetään avainsanalla "AS".

Jos esimerkiksi haluat valita StudentName-sarakkeen, joka palautetaan nimellä "Student Name" sanan "StudentName" sijaan, voit antaa sille aliaksen seuraavasti:

SELECT StudentName AS 'Student Name' FROM Students;

Tämä antaa sinulle opiskelijoiden nimet nimellä "Student Name" eikä "StudentName" seuraavasti:

Huomaa, että sarakkeen nimi on edelleen ”StudentName”; StudentName-sarake on edelleen sama, se ei muutu aliaksen mukaan.

Alias ​​ei muuta sarakkeen nimeä. se vain muuttaa näyttönimen SELECT-lauseessa.

Huomaa myös, että avainsana "AS" on valinnainen, voit laittaa aliaksen nimen ilman sitä, jotenkin näin:

SELECT StudentName 'Student Name' FROM Students;

Ja se antaa sinulle täsmälleen saman tulosteen kuin edellinen kysely:

Voit myös antaa taulukoille aliaksia, ei vain sarakkeita. Samalla avainsanalla "AS". Voit esimerkiksi tehdä tämän:

SELECT s.* FROM Students AS s;

Näin saat kaikki Opiskelijat-taulukon sarakkeet:

Tämä voi olla erittäin hyödyllistä, jos olet liittymässä useampaan kuin yhteen pöytään; sen sijaan, että toistaisit koko taulukon nimen kyselyssä, voit antaa jokaiselle taulukolle lyhyen aliaksenimen. Esimerkiksi seuraavassa kyselyssä:

SELECT Students.StudentName, Departments.DepartmentName
FROM Students
INNER JOIN Departments ON Students.DepartmentId = Departments.DepartmentId;

Tämä kysely valitsee kunkin opiskelijan nimen "Opiskelijat"-taulukosta ja sen osaston nimen "Osastot"-taulukosta:

Sama kysely voidaan kuitenkin kirjoittaa näin:

SELECT s.StudentName, d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Annoimme Opiskelijat-taulukolle aliaksen ”s” ja osastot-taulukolle aliaksen ”d”. Sitten taulukon koko nimen käyttämisen sijaan käytimme niiden aliaksia viittaamaan niihin. INNER JOIN yhdistää kaksi tai useampia taulukoita ehdon avulla. Esimerkissämme liitimme Opiskelijat-taulukon Osastot-taulukkoon, jossa on OsastoId-sarake. INNER JOIN -komennosta on myös yksityiskohtainen selitys ”SQLite Liitosten"opetusohjelma".

Tämä antaa sinulle tarkan tulosteen kuten edellisessä kyselyssä:

MISTÄ

SQL-kyselyjen kirjoittaminen pelkällä SELECT-lauseella FROM-lauseen kanssa, kuten näimme edellisessä osiossa, saat kaikki taulukoiden rivit. Jos kuitenkin haluat suodattaa palautetut tiedot, sinun on lisättävä WHERE-lauseke.

WHERE-lauseketta käytetään SQL-kyselyn palauttaman tulosjoukon suodattamiseen. Näin WHERE-lauseke toimii:

• WHERE-lauseessa voit määrittää "lausekkeen".
• Tämä lauseke arvioidaan jokaiselle riville, joka palautetaan FROM-lauseessa määritetyistä taulukoista.
• Lauseke arvioidaan Boolen lausekkeena, jonka tuloksena on joko tosi, epätosi tai nolla.
• Tällöin vain rivit, joiden lauseke on arvioitu tosiarvolla, palautetaan, ja ne, joiden tulokset ovat epätosi tai nolla, jätetään huomiotta, eikä niitä sisällytetä tulosjoukkoon.

Jos haluat suodattaa tulosjoukon WHERE-lauseen avulla, sinun on käytettävä lausekkeita ja operaattoreita.

Luettelo toimijoista SQLite ja miten niitä käytetään

Seuraavassa osiossa selitämme, kuinka voit suodattaa lausekkeen ja operaattoreiden avulla.

Lauseke on yksi tai useampi kirjaimellinen arvo tai sarake yhdistettynä toisiinsa operaattorilla.

Huomaa, että voit käyttää lausekkeita sekä SELECT- että WHERE-lauseessa.

Seuraavissa esimerkeissä kokeilemme lausekkeita ja operaattoreita sekä select- että WHERE-lauseessa. Jotta voit näyttää, kuinka he toimivat.

On olemassa erilaisia ​​lausekkeita ja operaattoreita, jotka voit määrittää seuraavasti:

SQLite ketjutusoperaattori "||"

Tätä operaattoria käytetään yhden tai useamman literaaliarvon tai sarakkeen ketjuttamiseen keskenään. Se tuottaa yhden merkkijonon kaikista ketjutetuista literaaliarvoista tai sarakkeista. Esimerkiksi:

SELECT 'Id with Name: '|| StudentId || StudentName AS StudentIdWithName
FROM Students;

Tämä ketjutetaan uudeksi aliakseksi ”StudentIdWithName”:

• Literaalimerkkijonoarvo ”Id with Name:”
• ”StudentId”-sarakkeen arvolla ja
• arvolla ”StudentName”-sarakkeesta

SQLite CAST-operaattori:

CAST-operaattoria käytetään arvon muuntamiseen tiedosta tietotyyppi toiseen tietotyyppiin.

Jos esimerkiksi sinulla on merkkijonomuodossa tallennettu numeerinen arvo, kuten ” '12.5' ​​”, ja haluat muuntaa sen numeeriseksi arvoksi, voit käyttää CAST-operaattoria tähän esimerkiksi näin: ”CAST( '12.5' ​​AS REAL)”. Tai jos sinulla on desimaaliarvo, kuten 12.5, ja sinun on saatava vain kokonaislukuosa, voit muuntaa sen kokonaisluvuksi esimerkiksi näin: ”CAST(12.5 AS INTEGER)”.

esimerkki

Seuraavassa komennossa yritämme muuntaa eri arvoja muihin tietotyyppeihin:

SELECT CAST('12.5' AS REAL) ToReal, CAST(12.5 AS INTEGER) AS ToInteger;

Tämä antaa sinulle:

Tulos on seuraava:

• CAST('12.5' AS REAL) – arvo '12.5' on merkkijonoarvo, se muunnetaan REAL-arvoksi.
• CAST(12.5 AS INTEGER) – arvo 12.5 on desimaaliluku, se muunnetaan kokonaislukuarvoksi. Desimaaliosa katkaistaan, ja siitä tulee 12.

SQLite Aritmeettinen Operatorit:

Ota vähintään kaksi numeerista kirjaimellista arvoa tai numeerista saraketta ja palauta yksi numeerinen arvo. Tuetut aritmeettiset operaattorit SQLite ovat:

• Yhteenlasku ”+” – antaa kahden operandin summan.
• allatraction “–” – alakohtatracts kaksi operandia ja antaa tulokseksi erotuksen.
• Kertolasku ”*” – kahden operandin tulo.
• Muistutus (modulo) “%” – antaa jakojäännöksen, joka saadaan jakamalla yksi operandi toisella operandilla.
• Jakolasku “/” – palauttaa osamäärän, joka saadaan jakamalla vasen operandi oikealla operandilla.

Esimerkiksi:

Seuraavassa esimerkissä kokeilemme viittä aritmeettista operaattoria, joilla on literaalinumeroarvot samassa select-lausekkeessa:

SELECT 25+6, 25-6, 25*6, 25%6, 25/6;

Tämä antaa sinulle:

Huomaa, kuinka käytimme SELECT-lausetta ilman FROM-lausetta tässä. Ja tämä on sallittu SQLite niin kauan kuin valitsemme kirjaimelliset arvot.

SQLite Vertailuoperaattorit

Vertaa kahta operandia keskenään ja palauta arvo tosi tai epätosi seuraavasti:

• “<” – palauttaa arvon true, jos vasen operandi on pienempi kuin oikea operandi.
• “<=” – palauttaa arvon tosi, jos vasen operandi on pienempi tai yhtä suuri kuin oikea operandi.
• “>” – palauttaa arvon true, jos vasen operandi on suurempi kuin oikea operandi.
• “>=” – palauttaa arvon true, jos vasen operandi on suurempi tai yhtä suuri kuin oikea operandi.
• “=” ja “==” – palauttaa arvon tosi, jos operandit ovat samat. Huomaa, että molemmat operaattorit ovat samoja, eikä niiden välillä ole eroa.
• “!=" ja “<>" – palauttaa arvon true, jos operandit eivät ole yhtä suuret. Huomaa, että molemmat operaattorit ovat samoja, eikä niiden välillä ole eroa.

Ota huomioon, että, SQLite ilmaisee todellisen arvon 1:llä ja väärän arvon 0:lla.

Esimerkiksi:

SELECT
  10<6 AS '<', 10<=6 AS '<=',
  10>6 AS '>', 10>=6 AS '>=',
  10=6 AS '=', 10==6 AS '==',
  10!=6 AS '!=', 10<>6 AS '<>';

Tämä antaa jotain tällaista:

SQLite Pattern Matching operaattorit

”LIKE” – käytetään kuvioiden yhteensovittamiseen. ”Like”-toiminnolla voit etsiä arvoja, jotka vastaavat jokerimerkin avulla määritettyä kuviota.

Vasemmalla oleva operandi voi olla joko merkkijonokirjainarvo tai merkkijonosarake. Malli voidaan määrittää seuraavasti:

• Sisältää kuvion. Esimerkiksi StudentName LIKE '%a%' – tämä etsii opiskelijoiden nimiä, jotka sisältävät kirjaimen "a" missä tahansa StudentName-sarakkeen kohdassa.
• Alkaa kuviolla. Esimerkiksi ”OppilaanNimi LIKE 'a%'” – hae opiskelijoiden nimiä, jotka alkavat kirjaimella ”a”.
• Päättyy kuvioon. Esimerkiksi ”OppilaanNimi LIKE '%a'” – Hae opiskelijoiden nimiä, jotka päättyvät kirjaimeen ”a”.
• Yksittäisen merkin löytäminen merkkijonosta käyttämällä alaviivaa ”_”. Esimerkiksi ”OppilaanNimi LIKE 'J___'” – Etsii opiskelijoiden nimiä, jotka ovat neljän merkin pituisia. Nimen on alettava J-kirjaimella ja J-kirjaimen jälkeen voi olla mitä tahansa kolme muuta merkkiä.

Mallin yhteensopivuuden esimerkkejä:

Hanki opiskelijoiden nimet, jotka alkavat j-kirjaimella:

SELECT StudentName FROM Students WHERE StudentName LIKE 'j%';

Tulos:

Hanki opiskelijoiden nimet päättyvät y-kirjaimeen:

SELECT StudentName FROM Students WHERE StudentName LIKE '%y';

Tulos:

Hanki oppilaiden nimet, jotka sisältävät n-kirjaimen:

SELECT StudentName FROM Students WHERE StudentName LIKE '%n%';

Tulos:

”GLOB” – vastaa LIKE-operaattoria, mutta GLOB on kirjainkokoriippuvainen toisin kuin LIKE-operaattori. Esimerkiksi seuraavat kaksi komentoa palauttavat eri tulokset:

SELECT 'Jack' GLOB 'j%';
SELECT 'Jack' LIKE 'j%';

Tämä antaa sinulle:

Ensimmäinen lauseke palauttaa 0 (false), koska GLOB-operaattori on isot ja pienet kirjaimet erotteleva, joten "j" ei ole sama kuin "J". Toinen lauseke palauttaa kuitenkin arvon 1 (tosi), koska LIKE-operaattori ei välitä kirjainkoosta, joten 'j' on yhtä kuin 'J'.

Muut operaattorit:

SQLite JA

Looginen operaattori, joka yhdistää yhden tai useamman lausekkeen. Se palauttaa tosi, vain jos kaikki lausekkeet antavat "true"-arvon. Se palauttaa kuitenkin epätosi vain, jos kaikki lausekkeet antavat "false" arvon.

Esimerkiksi:

Seuraava kysely etsii opiskelijoita, joiden StudentId > 5 ja OpiskelijanNimi alkaa kirjaimella N, palautettujen opiskelijoiden on täytettävä kaksi ehtoa:

SELECT *
FROM Students
WHERE (StudentId > 5) AND (StudentName LIKE 'N%');

Yllä olevassa kuvakaappauksessa tämä antaa sinulle vain "Nancyn". Nancy on ainoa opiskelija, joka täyttää molemmat ehdot.

SQLite OR

Looginen operaattori, joka yhdistää yhden tai useamman lausekkeen siten, että jos jokin yhdistetyistä operaattoreista antaa tosi, se palauttaa tosi. Kuitenkin, jos kaikki lausekkeet antavat epätosi, se palauttaa epätosi.

Esimerkiksi:

Seuraava kysely hakee opiskelijoita, joiden StudentId > 5 tai OpiskelijanNimi alkaa kirjaimella N, palautettujen opiskelijoiden on täytettävä vähintään yksi ehdoista:

SELECT *
FROM Students
WHERE (StudentId > 5) OR (StudentName LIKE 'N%');

Tämä antaa sinulle:

Yllä olevassa kuvakaappauksessa tämä antaa sinulle sellaisen opiskelijan nimen, jonka nimessä on kirjain "n" sekä opiskelijatunnuksen arvo >5.

Kuten näet, tulos on erilainen kuin AND-operaattorilla tehty kysely.

SQLite VÄLILLÄ

BETWEEN-funktiota käytetään valitsemaan arvot, jotka ovat kahden arvon sisällä. Esimerkiksi ”X BETWEEN Y AND Z” palauttaa arvon true (1), jos arvo X on kahden arvon Y ja Z välissä. Muussa tapauksessa se palauttaa arvon false (0). ”X BETWEEN Y AND Z” vastaa funktiota ”X >= Y AND X <= Z”, X:n on oltava suurempi tai yhtä suuri kuin Y ja X:n on oltava pienempi tai yhtä suuri kuin Z.

Esimerkiksi:

Seuraavassa esimerkkikyselyssä kirjoitamme kyselyn saadaksemme opiskelijat, joiden Id-arvo on välillä 5–8:

SELECT *
FROM Students
WHERE StudentId BETWEEN 5 AND 8;

Tämä antaa vain opiskelijoille, joilla on tunnukset 5, 6, 7 ja 8:

SQLite IN

Ottaa yhden operandin ja listan operandiista. Se palauttaa tosi, jos ensimmäinen operandiarvo on yhtä suuri kuin jonkin operandin arvo listasta. IN-operaattori palauttaa tosi (1), jos operandiluettelo sisältää arvojensa sisällä ensimmäisen operandiarvon. Muussa tapauksessa se palauttaa epätosi (0).

Näin: ”col IN(x, y, z)“. Tämä vastaa muotoa ” (col=x) tai (col=y) tai (col=z)”.

Esimerkiksi:

Seuraava kysely valitsee vain opiskelijat, joiden tunnukset ovat 2, 4, 6, 8:

SELECT *
FROM Students
WHERE StudentId IN(2, 4, 6, 8);

Tykkää tästä:

Edellinen kysely antaa tarkan tuloksen seuraavana kyselynä, koska ne ovat vastaavia:

SELECT *
FROM Students
WHERE (StudentId = 2) OR (StudentId =  4) OR (StudentId =  6) OR (StudentId = 8);

Molemmat kyselyt antavat tarkan tuloksen. Ero näiden kahden kyselyn välillä on kuitenkin se, että ensimmäisessä kyselyssä käytimme IN-operaattoria. Toisessa kyselyssä käytimme useita "OR"-operaattoreita.

IN-operaattori vastaa useiden OR-operaattoreiden käyttöä. ”WHERE StudentId IN(2, 4, 6, 8)” vastaa operaatiota ”WHERE (StudentId = 2) OR (StudentId = 4) OR (StudentId = 6) OR (StudentId = 8);“

Tykkää tästä:

SQLite EI SISÄLLÄ

”NOT IN” -operaattori on IN-operaattorin vastakohta. Mutta samalla syntaksilla; se ottaa yhden operandin ja operandilistan. Se palauttaa arvon true, jos ensimmäisen operandin arvo ei ole yhtä suuri kuin yhdenkään listan operandin arvo. Eli se palauttaa arvon true (0), jos operandilista ei sisällä ensimmäistä operandia. Esimerkiksi: ”col NOT IN(x, y, z)”. Tämä vastaa operaattoria ”(col<>x) AND (col<>y) AND (col<>z)”.

Esimerkiksi:

Seuraava kysely valitsee opiskelijat, joiden tunnukset eivät ole yhtä suuria kuin jokin näistä tunnusista 2, 4, 6, 8:

SELECT *
FROM Students
WHERE StudentId NOT IN(2, 4, 6, 8);

Näin

Edellisessä kyselyssä annamme tarkan tuloksen seuraavana kyselynä, koska ne ovat vastaavia:

SELECT *
FROM Students
WHERE (StudentId <> 2) AND (StudentId <> 4) AND (StudentId <> 6) AND (StudentId <> 8);

Tykkää tästä:

Yllä olevassa kuvakaappauksessa

Käytimme useita eri operaattoreita “<>” saadaksemme luettelon opiskelijoista, jotka eivät ole yhtä suuria kuin kumpaakaan seuraavista tunnisteista 2, 4, 6 tai 8. Tämä kysely palauttaa kaikki muut opiskelijat kuin nämä luettelot.

SQLite EXISTS

EXISTS-operaattorit eivät ota operandeja; sen jälkeen tarvitaan vain SELECT-lause. EXISTS-operaattori palauttaa tosi (1), jos SELECT-lauseesta on palautettu rivejä, ja se palauttaa epätosi (0), jos SELECT-lauseesta ei ole palautettu yhtään rivejä.

Esimerkiksi:

Seuraavassa esimerkissä valitsemme osaston nimen, jos laitoksen tunnus on olemassa opiskelijataulukossa:

SELECT DepartmentName
FROM Departments AS d
WHERE EXISTS (SELECT DepartmentId FROM Students AS s WHERE d.DepartmentId = s.DepartmentId);

Tämä antaa sinulle:

Vain kolme osastoa – ”IT, Fysiikka ja Taiteet” – palautetaan. Osaston nimeä ”Matematiikka” ei palauteta, koska kyseisessä osastossa ei ole opiskelijoita, joten osastotunnusta ei ole opiskelijat-taulukossa. Siksi EXISTS-operaattori jätti ”Matematiikka”-osaston huomiotta.

SQLite ÄLÄ

Reverses on sitä edeltävän ja sitä seuraavan operaattorin tulos. Esimerkiksi:

• NOT BETWEEN – Palauttaa arvon tosi, jos BETWEEN palauttaa epätosi ja päinvastoin.
• NOT LIKE – Palauttaa tosi, jos LIKE palauttaa epätosi ja päinvastoin.
• NOT GLOB – Se palauttaa arvon tosi, jos GLOB palauttaa false ja päinvastoin.
• NOT EXISTS – Palauttaa arvon tosi, jos EXISTS palauttaa epätosi ja päinvastoin.

Esimerkiksi:

Seuraavassa esimerkissä käytämme NOT-operaattoria EXISTS-operaattorin kanssa saadaksemme osastojen nimet, joita ei ole Opiskelijat-taulukossa, mikä on EXISTS-operaattorin käänteinen tulos. Joten haku tehdään osastotunnuksella, jota ei ole osastotaulukossa.

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId
                  FROM Students AS s
                  WHERE d.DepartmentId = s.DepartmentId);

lähtö:

Vain osasto ”Matematiikka” palautetaan. Koska ”Matematiikka” on ainoa osasto, sitä ei ole olemassa students-taulukossa.

Rajoitus ja tilaus

SQLite Tilaus

SQLite Järjestys on lajitella tulos yhden tai useamman lausekkeen mukaan. Tilataksesi tulossarjan, sinun on käytettävä ORDER BY -lausetta seuraavasti:

• Ensin sinun on määritettävä ORDER BY -lauseke.
• ORDER BY -lause on määritettävä kyselyn lopussa; sen jälkeen voidaan määrittää vain LIMIT-lause.
• Määritä lauseke, johon tiedot järjestyvät. Tämä lauseke voi olla sarakkeen nimi tai lauseke.
• Lausekkeen jälkeen voit määrittää valinnaisen lajittelusuunnan. Joko DESC, jos haluat järjestää tiedot laskevassa muodossa, tai ASC, jos haluat järjestää tiedot nousevasti. Jos et määritä mitään niistä, tiedot lajitellaan nousevasti.
• Voit määrittää lisää lausekkeita käyttämällä ","-merkkiä toistensa välillä.

esimerkki

Seuraavassa esimerkissä valitaan kaikki opiskelijat nimien mukaan, mutta laskevassa järjestyksessä, sitten osaston nimen mukaan nousevassa järjestyksessä:

SELECT s.StudentName, d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
ORDER BY d.DepartmentName ASC , s.StudentName DESC;

Tämä antaa sinulle:

• SQLite järjestää ensin kaikki opiskelijat osaston nimen mukaan nousevassa järjestyksessä
• Sitten kunkin osaston nimen kohdalla kaikki kyseisen osaston nimen alaiset opiskelijat näytetään nimien mukaan laskevassa järjestyksessä

SQLite Raja:

Voit rajoittaa SQL-kyselysi palauttamien rivien määrää käyttämällä LIMIT-lausetta. Esimerkiksi LIMIT 10 antaa sinulle vain 10 riviä ja jättää huomioimatta kaikki muut rivit.

LIMIT-lauseessa voit valita tietyn määrän rivejä alkaen tietystä kohdasta käyttämällä OFFSET-lausetta. Esimerkiksi ”LIMIT 4 OFFSET 4” jättää huomiotta neljä ensimmäistä riviä ja palauttaa neljä riviä alkaen viidennestä rivistä, joten saat rivit 4, 4, 5,6,7 ja 8.

Huomaa, että OFFSET-lauseke on valinnainen. Voit kirjoittaa sen muotoon ”LIMIT 4, 4”, jolloin saat tarkat tulokset.

Esimerkiksi:

Seuraavassa esimerkissä palautetaan vain 3 opiskelijaa opiskelijatunnuksesta 5 alkaen kyselyllä:

SELECT * FROM Students LIMIT 4,3;

Tämä antaa sinulle vain kolme opiskelijaa riviltä 5 alkaen. Joten se antaa sinulle rivit StudentId 5, 6 ja 7:

Kaksoiskappaleiden poistaminen

Jos SQL-kyselysi palauttaa kaksoiskappaleita, voit käyttää avainsanaa ”DISTINCT” poistaaksesi kaksoiskappaleet ja palauttaaksesi erilliset arvot. Voit määrittää useamman kuin yhden sarakkeen DISTINCT-avaimen käytön jälkeen.

Esimerkiksi:

Seuraava kysely palauttaa päällekkäiset "osaston nimiarvot": Tässä meillä on päällekkäisiä arvoja nimillä IT, Physics ja Arts.

SELECT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Tämä antaa sinulle päällekkäisiä arvoja osaston nimelle:

Huomaa, kuinka osaston nimessä on päällekkäisiä arvoja. Nyt käytämme DISTINCT-avainsanaa samassa kyselyssä poistaaksemme kaksoiskappaleet ja saadaksemme vain yksilölliset arvot. Kuten tämä:

SELECT DISTINCT d.DepartmentName
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Tämä antaa vain kolme yksilöllistä arvoa osaston nimisarakkeelle:

Aggregaatti

SQLite Aggregaatit ovat sisäänrakennettuja toimintoja, jotka on määritelty kohdassa SQLite joka ryhmittelee useiden rivien useita arvoja yhdeksi arvoksi.

Tässä ovat aggregaatit, joita tukee SQLite:

SQLite AVG()

Palautti keskiarvon kaikille x-arvoille.

Esimerkiksi:

Seuraavassa esimerkissä saamme opiskelijoiden kaikkien kokeiden keskiarvosanan:

SELECT AVG(Mark) FROM Marks;

Tämä antaa sinulle arvon "18.375":

Nämä tulokset saadaan laskemalla yhteen kaikki pisteet jaettuna niiden lukumäärällä.

COUNT() – COUNT(X) tai COUNT(*)

Palauttaa x-arvon esiintymiskertojen kokonaismäärän. Ja tässä on joitain vaihtoehtoja, joita voit käyttää COUNT:n kanssa:

• COUNT(x): Laskee vain x-arvoja, joissa x on sarakkeen nimi. Se jättää huomioimatta NULL-arvot.
• COUNT(*): Laske kaikki rivit kaikista sarakkeista.
• COUNT (DISTINCT x): Voit määrittää DISTINCT-avainsanan ennen x:ää, joka saa x:n erillisten arvojen määrän.

esimerkki

Seuraavassa esimerkissä saamme niiden osastojen kokonaismäärän, joissa on COUNT(osastotunnus), COUNT(*) ja COUNT(DISTINCT DepartmentId) ja miten ne eroavat toisistaan:

SELECT COUNT(DepartmentId), COUNT(DISTINCT DepartmentId), COUNT(*) FROM Students;

Tämä antaa sinulle:

seuraavasti:

• COUNT(DepartmentId) antaa sinulle kaikkien osastotunnusten määrän ja jättää tyhjät arvot huomioimatta.
• COUNT(DISTINCT DepartmentId) antaa sinulle erilliset osastotunnuksen arvot, jotka ovat vain 3. Mitkä ovat osaston nimen kolme eri arvoa. Huomaa, että opiskelijan nimessä on 8 osaston nimen arvoa. Mutta vain kolme eri arvoa, jotka ovat matematiikka, IT ja fysiikka.
• COUNT(*) laskee niiden rivien määrän opiskelijataulukossa, jotka ovat 10 riviä 10 opiskelijaa kohti.

GROUP_CONCAT() – GROUP_CONCAT(X) tai GROUP_CONCAT(X,Y)

GROUP_CONCAT-koontifunktio ketjuttaa useita arvoja yhdeksi arvoksi pilkulla erottamaan ne. Siinä on seuraavat vaihtoehdot:

• GROUP_CONCAT(X): Tämä ketjuttaa kaiken x:n arvon yhdeksi merkkijonoksi, jolloin arvojen erottimena käytetään pilkkua "". NULL-arvot ohitetaan.
• GROUP_CONCAT(X, Y): Tämä ketjuttaa x:n arvot yhdeksi merkkijonoksi, jolloin y:n arvoa käytetään erottimena kunkin arvon välillä oletuserottimen ',' sijaan. Myös NULL-arvot jätetään huomioimatta.
• GROUP_CONCAT(DISTINCT X): Tämä ketjuttaa kaikki x:n erilliset arvot yhdeksi merkkijonoksi pilkulla "," käytetään erottimena arvojen välillä. NULL-arvot ohitetaan.

GROUP_CONCAT(osaston nimi) Esimerkki

Seuraava kysely yhdistää kaikki osaston nimen arvot opiskelijoista ja osastotaulukosta yhdeksi pilkulla erotettuun merkkijonoon. Joten arvoluettelon palauttamisen sijaan yksi arvo jokaiselle riville. Se palauttaa vain yhden arvon yhdelle riville, kaikki arvot pilkuilla erotettuna:

SELECT GROUP_CONCAT(d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Tämä antaa sinulle:

Tämä antaa sinulle luettelon 8 osaston nimiarvoista, jotka on ketjutettu yhdeksi merkkijonoksi pilkuilla erotettuna.

GROUP_CONCAT(DISTINCT Osastonnimi) Esimerkki

Seuraava kysely yhdistää osaston nimen erilliset arvot opiskelija- ja osastotaulukosta yhdeksi pilkulla erotettuun merkkijonoon:

SELECT GROUP_CONCAT(DISTINCT d.DepartmentName)
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Tämä antaa sinulle:

Huomaa kuinka tulos eroaa edellisestä tuloksesta; palautti vain kolme arvoa, jotka ovat eri osastojen nimiä, ja päällekkäiset arvot poistettiin.

GROUP_CONCAT(osaston nimi ,'&') Esimerkki

Seuraava kysely yhdistää kaikki opiskelija- ja osastotaulukon osaston nimisarakkeen arvot yhdeksi merkkijonoksi, mutta erottimena on merkki '&' pilkun sijaan:

SELECT GROUP_CONCAT(d.DepartmentName, '&')
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId;

Tämä antaa sinulle:

Huomaa, kuinka arvojen erottamiseen käytetään merkkiä "&" oletusmerkin "" sijaan.

SQLite MAX() & MIN()

MAX(X) palauttaa sinulle suurimman arvon X-arvoista. MAX palauttaa NULL-arvon, jos kaikki x:n arvot ovat tyhjiä. Kun taas MIN(X) palauttaa sinulle pienimmän arvon X-arvoista. MIN palauttaa NULL-arvon, jos kaikki X:n arvot ovat tyhjiä.

esimerkki

Seuraavassa kyselyssä käytämme MIN- ja MAX-funktioita saadaksemme korkeimman ja pienimmän arvosanan "Arvosanat"-taulukosta:

SELECT MAX(Mark), MIN(Mark) FROM Marks;

Tämä antaa sinulle:

SQLite SUMMA(x), yhteensä(x)

Molemmat palauttavat kaikkien x-arvojen summan. Mutta ne eroavat seuraavista:

• SUM palauttaa nollan, jos kaikki arvot ovat nolla, mutta Total palauttaa 0:n.
• TOTAL palauttaa aina liukulukuarvot. SUM palauttaa kokonaisluvun, jos kaikki x-arvot ovat kokonaislukuja. Jos arvot eivät kuitenkaan ole kokonaislukuja, se palauttaa liukulukuarvon.

esimerkki

Seuraavassa kyselyssä käytämme SUM- ja total-funktioita kaikkien "Marks"-taulukoiden pisteiden summan laskemiseen:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks;

Tämä antaa sinulle:

Kuten näet, TOTAL palauttaa aina liukuluku. Mutta SUM palauttaa kokonaisluvun arvon, koska "Mark"-sarakkeen arvot voivat olla kokonaislukuina.

Ero SUM- ja TOTAL-esimerkkien välillä:

Seuraavassa kyselyssä näytämme eron SUM ja TOTAL välillä, kun ne saavat NULL-arvojen SUMMA:

SELECT SUM(Mark), TOTAL(Mark) FROM Marks WHERE TestId = 4;

Tämä antaa sinulle:

Huomaa, että arvolle TestId = 4 ei ole merkkejä, joten kyseiselle testille on nolla-arvoja. SUM palauttaa nolla-arvon tyhjänä, kun taas TOTAL palauttaa 0:n.

Ryhmä BY

GROUP BY -lausetta käytetään määrittämään yksi tai useampi sarake, jota käytetään rivien ryhmittelyyn ryhmiin. Rivit, joilla on samat arvot, kootaan (järjestetään) yhteen ryhmiin.

Muille sarakkeille, jotka eivät sisälly sarakkeiden ryhmään, voit käyttää koontifunktiota.

Esimerkiksi:

Seuraava kysely kertoo kunkin laitoksen opiskelijoiden kokonaismäärän.

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName;

Tämä antaa sinulle:

GROUPBY DepartmentName -lause ryhmittelee kaikki opiskelijat ryhmiin yksi kullekin osaston nimelle. Jokaisen "osaston" ryhmän osalta se laskee mukana olevat opiskelijat.

ON lauseke

Jos haluat suodattaa GROUP BY -lauseen palauttamat ryhmät, voit määrittää HAVING-lauseen lausekkeen GROUP BY jälkeen. Lauseketta käytetään näiden ryhmien suodattamiseen.

esimerkki

Seuraavassa kyselyssä valitsemme ne laitokset, joilla on vain kaksi opiskelijaa:

SELECT d.DepartmentName, COUNT(s.StudentId) AS StudentsCount
FROM Students AS s
INNER JOIN Departments AS d ON s.DepartmentId = d.DepartmentId
GROUP BY d. DepartmentName
HAVING COUNT(s.StudentId) = 2;

Tämä antaa sinulle:

Lause HAVING COUNT(S.StudentId) = 2 suodattaa palautetut ryhmät ja palauttaa vain ne ryhmät, joissa on täsmälleen kaksi opiskelijaa. Meidän tapauksessamme taiteiden osastolla on 2 opiskelijaa, joten se näkyy tulosteessa.

SQLite Kysely ja alikysely

Minkä tahansa kyselyn sisällä voit käyttää toista kyselyä joko SELECT-, INSERT-, DELETE-, UPDATE- tai toisen alikyselyn sisällä.

Tätä sisäkkäistä kyselyä kutsutaan alikyselyksi. Näemme nyt esimerkkejä alikyselyjen käytöstä SELECT-lauseessa. Tietojen muokkaaminen -opetusohjelmassa näemme kuitenkin, kuinka voimme käyttää alikyselyitä INSERT-, DELETE- ja UPDATE-käskyjen kanssa.

Alikyselyn käyttäminen FROM-lauseesimerkissä

Seuraavaan kyselyyn sisällytämme alikyselyn FROM-lauseen sisään:

SELECT
  s.StudentName, t.Mark
FROM Students AS s
INNER JOIN
(
   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId
)  ON s.StudentId = t.StudentId;

Kysely:

   SELECT StudentId, Mark
   FROM Tests AS t
   INNER JOIN Marks AS m ON t.TestId = m.TestId

Yllä olevaa kyselyä kutsutaan tässä alikyselyksi, koska se on sisäkkäin FROM-lauseen sisällä. Huomaa, että annoimme sille aliaksenimen "t", jotta voimme viitata kyselyssä siitä palautettuihin sarakkeisiin.

Tämä kysely antaa sinulle:

Joten meidän tapauksessamme

• s.StudentName valitaan pääkyselystä, joka antaa opiskelijoiden ja nimet
• t.Mark valitaan alikyselystä; joka antaa kunkin opiskelijan saamat arvosanat

Alikyselyn käyttö WHERE-lauseesimerkissä

Seuraavassa kyselyssä sisällytämme alikyselyn WHERE-lauseeseen:

SELECT DepartmentName
FROM Departments AS d
WHERE NOT EXISTS (SELECT DepartmentId
                  FROM Students AS s
                  WHERE d.DepartmentId = s.DepartmentId);

Kysely:

SELECT DepartmentId
FROM Students AS s
WHERE d.DepartmentId = s.DepartmentId

Yllä olevaa kyselyä kutsutaan tässä alikyselyksi, koska se on sisäkkäin WHERE-lauseessa. Alikysely palauttaa OsastonId-arvot, joita operaattori NOT EXISTS käyttää.

Tämä kysely antaa sinulle:

Yllä olevaan kyselyyn olemme valinneet osaston, jolle ei ole ilmoittautunut yhtään opiskelijaa. Mikä on "matematiikan" osasto täällä.

Asettaa Operamuodot – UNION,Intersect

SQLite tukee seuraavia SET-toimintoja:

UNIONI JA UNIONI KAIKKI

Se yhdistää yhden tai useamman useista SELECT-lausekkeista palautetun tulosjoukon (rivien ryhmän) yhdeksi tulosjoukoksi.

UNION palauttaa erilliset arvot. UNION ALL ei kuitenkaan sisälly ja sisältää kaksoiskappaleita.

Huomaa, että sarakkeen nimi on ensimmäisessä SELECT-käskyssä määritetty sarakkeen nimi.

UNIONI Esimerkki

Seuraavassa esimerkissä saamme luettelon DepartmentId-luettelosta opiskelijataulukosta ja luettelon DepartmentId-luettelosta osastotaulukosta samassa sarakkeessa:

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION
SELECT DepartmentId FROM Departments;

Tämä antaa sinulle:

Kysely palauttaa vain 5 riviä, jotka ovat erillisiä osastotunnusarvoja. Huomaa ensimmäinen arvo, joka on nolla-arvo.

SQLite UNIONIN KAIKKI Esimerkki

Seuraavassa esimerkissä saamme luettelon DepartmentId-luettelosta opiskelijataulukosta ja luettelon DepartmentId-luettelosta osastotaulukosta samassa sarakkeessa:

SELECT DepartmentId AS DepartmentIdUnioned FROM Students
UNION ALL
SELECT DepartmentId FROM Departments;

Tämä antaa sinulle:

Kysely palauttaa 14 riviä, 10 riviä opiskelijataulukosta ja 4 riviä osastotaulukosta. Huomaa, että palautetuissa arvoissa on kaksoiskappaleita. Huomaa myös, että sarakkeen nimi oli se, joka määritettiin ensimmäisessä SELECT-käskyssä.

Katsotaan nyt, kuinka UNIONIN kaikki antaa erilaisia ​​​​tuloksia, jos korvaamme UNION ALL:lla UNION:

SQLite RISTEKSI

Palauttaa molemmissa yhdistetyissä tulosjoukoissa olevat arvot. Yhdistetyssä tulosjoukossa olevat arvot ohitetaan.

esimerkki

Seuraavassa kyselyssä valitsemme DepartmentId-arvot, jotka ovat sekä Opiskelijat- että Osastot-taulukoissa OsastoId-sarakkeessa:

SELECT DepartmentId FROM Students
Intersect
SELECT DepartmentId FROM Departments;

Tämä antaa sinulle:

Kysely palauttaa vain kolme arvoa 1, 2 ja 3. Mitkä ovat molemmissa taulukoissa olevat arvot.

Arvoja null ja 4 ei kuitenkaan otettu mukaan, koska nolla-arvo on vain opiskelijataulukossa, ei osastotaulukossa. Ja arvo 4 on osastotaulukossa eikä opiskelijataulukossa.

Tästä syystä sekä arvot NULL että 4 jätettiin huomiotta, eikä niitä sisällytetty palautettuihin arvoihin.

PAITSI

Oletetaan, että jos sinulla on kaksi riviluetteloa, lista1 ja lista2, ja haluat vain rivit listasta1, jota ei ole luettelossa 2, voit käyttää "EXCEPT"-lausetta. EXCEPT-lause vertaa kahta listaa ja palauttaa ne rivit, jotka ovat listassa lista1 ja joita ei ole luettelossa2.

esimerkki

Seuraavassa kyselyssä valitsemme DepartmentId-arvot, jotka ovat osastotaulukossa ja joita ei ole opiskelijataulukossa:

SELECT DepartmentId FROM Departments
EXCEPT
SELECT DepartmentId FROM Students;

Tämä antaa sinulle:

Kysely palauttaa vain arvon 4. Mikä on ainoa arvo, joka on osastotaulukossa, mutta joka ei ole opiskelijataulukossa.

NULL käsittely

”NULL”-arvo on erikoisarvo SQLiteSitä käytetään edustamaan tuntematonta tai puuttuvaa arvoa. Huomaa, että null-arvo on täysin eri asia kuin "0" tai tyhjä ""-arvo. Koska 0 ja tyhjä arvo ovat tunnettuja arvoja, null-arvo on tuntematon.

NULL-arvot vaativat erikoiskäsittelyn SQLite, näemme nyt kuinka käsitellä NULL-arvoja.

Etsi NULL-arvoja

Et voi käyttää normaalia yhtäläisyysoperaattoria (=) nolla-arvojen etsimiseen. Esimerkiksi seuraava kysely etsii opiskelijoita, joilla on tyhjä DepartmentId-arvo:

SELECT * FROM Students WHERE DepartmentId = NULL;

Tämä kysely ei tuota tulosta:

Koska NULL-arvo ei ole yhtä suuri kuin mikään muu itse nolla-arvon sisältämä arvo, se ei siksi palauttanut tulosta.

Jotta kysely toimisi, sinun on kuitenkin käytettävä "IS NULL" -operaattoria etsimään null-arvoja seuraavasti:

SELECT * FROM Students WHERE DepartmentId IS NULL;

Tämä antaa sinulle:

Kysely palauttaa ne opiskelijat, joilla on tyhjä DepartmentId-arvo.

Jos haluat saada arvot, jotka eivät ole null-arvoja, sinun on käytettävä operaattoria ”IS NOT NULL” seuraavasti:

SELECT * FROM Students WHERE DepartmentId IS NOT NULL;

Tämä antaa sinulle:

Kysely palauttaa ne opiskelijat, joilla ei ole NULL DepartmentId-arvoa.

Ehdolliset tulokset

Jos sinulla on luettelo arvoista ja haluat valita jonkin niistä joidenkin ehtojen perusteella. Tätä varten kyseisen arvon ehdon tulee olla tosi, jotta se voidaan valita.

CASE-lauseke arvioi nämä ehtoluettelot kaikille arvoille. Jos ehto on tosi, se palauttaa kyseisen arvon.

Jos sinulla on esimerkiksi sarake Arvosana ja haluat valita arvosanan arvon perusteella tekstiarvon seuraavasti:

– ”Erinomainen”, jos arvosana on korkeampi kuin 85.

– ”Erittäin hyvä”, jos arvosana on välillä 70–85.

– ”Hyvä”, jos arvosana on 60–70.

Sitten voit käyttää CASE-lauseketta tehdäksesi sen.

Tätä voidaan käyttää määrittelemään logiikkaa SELECT-lauseessa, jotta voit valita tietyt tulokset tietyistä ehdoista, kuten esimerkiksi if-lauseesta.

CASE-operaattori voidaan määrittää eri syntakseilla seuraavasti:

Voit käyttää erilaisia ​​ehtoja:

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  WHEN condition3 THEN result3
  …
  ELSE resultn
END

Tai voit käyttää vain yhtä lauseketta ja valita eri mahdollisista arvoista:

CASE expression
  WHEN value1 THEN result1
  WHEN value2 THEN result2
  WHEN value3 THEN result3
  …
  ELSE restuln
END

Huomaa, että ELSE-lauseke on valinnainen.

esimerkki

Seuraavassa esimerkissä käytämme CASE-lauseketta, jonka Opiskelijat-taulukon osastotunnus-sarakkeessa on NULL-arvo, jolloin teksti 'Ei osastoa' näytetään seuraavasti:

SELECT
  StudentName,
  CASE
    WHEN DepartmentId IS NULL THEN 'No Department'
    ELSE DepartmentId
  END AS DepartmentId
FROM Students;

• CASE-operaattori tarkistaa DepartmentId:n arvon, onko se tyhjä vai ei.
• Jos se on NULL-arvo, se valitsee kirjaimellisen arvon 'Ei osastoa' DepartmentId-arvon sijaan.
• Jos ei ole nolla-arvo, se valitsee OsastoId-sarakkeen arvon.

Tämä antaa sinulle alla olevan kuvan mukaisen tulosteen:

Yhteinen taulukkolauseke

Yleiset taulukkolausekkeet (CTE:t) ovat alikyselyjä, jotka määritellään SQL-käskyn sisällä tietyllä nimellä.

Sillä on etu alikyselyihin verrattuna, koska se on määritelty pois SQL-käskyistä ja tekee kyselyistä helpompia lukea, ylläpitää ja ymmärtää.

Yleinen taulukkolauseke voidaan määrittää laittamalla WITH-lause SELECT-lauseiden eteen seuraavasti:

WITH CTEname
AS
(
   SELECT statement
)
SELECT, UPDATE, INSERT, or update statement here FROM CTE

”CTEname” on mikä tahansa nimi, jonka voit antaa CTE:lle, ja voit käyttää sitä viitatessasi siihen myöhemmin. Huomaa, että voit määrittää CTE:ille SELECT-, UPDATE-, INSERT- tai DELETE-lausekkeita.

Katsotaanpa nyt esimerkkiä CTE:n käyttämisestä SELECT-lauseessa.

esimerkki

Seuraavassa esimerkissä määritämme CTE:n SELECT-käskystä ja käytämme sitä myöhemmin toisessa kyselyssä:

WITH AllDepartments
AS
(
  SELECT DepartmentId, DepartmentName
  FROM Departments
)
SELECT
  s.StudentId,
  s.StudentName,
  a.DepartmentName
FROM Students AS s
INNER JOIN AllDepartments AS a ON s.DepartmentId = a.DepartmentId;

Tässä kyselyssä määrittelimme CTE:n ja annoimme sille nimen ”Kaikki osastot”. Tämä CTE määriteltiin SELECT-kyselyllä:

SELECT DepartmentId, DepartmentName
  FROM Departments

Sitten kun määritimme CTE:n, käytimme sitä SELECT-kyselyssä, joka tulee sen jälkeen.

Huomaa, että yleiset taulukkolausekkeet eivät vaikuta kyselyn ulostuloon. Se on tapa määrittää looginen näkymä tai alikysely, jotta niitä voidaan käyttää uudelleen samassa kyselyssä. Yleiset taulukkolausekkeet ovat kuin muuttuja, jonka määrittelet ja käytät sitä uudelleen alikyselynä. Vain SELECT-käsky vaikuttaa kyselyn ulostuloon.

Tämä kysely antaa sinulle:

Tarkennetut kyselyt

Tarkennetut kyselyt ovat kyselyitä, jotka sisältävät monimutkaisia ​​liitoksia, alikyselyjä ja joitain aggregaatteja. Seuraavassa osiossa näemme esimerkin tarkennetusta kyselystä:

Mistä saamme,

• Osaston nimet kaikkien opiskelijoiden kanssa jokaiselle laitokselle
• Oppilaiden nimet erotettuna pilkulla ja
• Näyttää laitoksen, jossa on vähintään kolme opiskelijaa

SELECT
  d.DepartmentName,
  COUNT(s.StudentId) StudentsCount,
  GROUP_CONCAT(StudentName) AS Students
FROM Departments AS d
INNER JOIN Students AS s ON s.DepartmentId = d.DepartmentId
GROUP BY d.DepartmentName
HAVING COUNT(s.StudentId) >= 3;

Lisäsimme JOIN-lauseen, jolla haimme DepartmentName-tiedon Departments-taulukosta. Sen jälkeen lisäsimme GROUP BY -lauseen, jossa on kaksi koostefunktiota:

• "COUNT" laskea kunkin osastoryhmän opiskelijat.
• GROUP_CONCAT ketjuttaaksesi opiskelijat kussakin ryhmässä pilkuilla erotettuina yhdeksi merkkijonoksi.

GROUP BY:n jälkeen käytimme HAVING-lausetta suodattamaan osastot ja valitsemaan vain ne osastot, joissa on vähintään 3 opiskelijaa.

Tulos tulee olemaan seuraava:

UKK