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

SQL-kyselyjen kirjoittaminen 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

1. Avaa Oma tietokone ja siirry seuraavaan hakemistoon "C:\sqlite"Ja
2. 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 edelleen "Opiskelijan nimi"; sarake StudentName 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 Opiskelijataulukolle aliaksen "s" ja osastotaulukoille aliaksen "d".
• Sitten sen sijaan, että käyttäisimme koko taulukon nimeä, käytimme heidän aliaksiaan viittaamaan niihin.
• INNER JOIN liittää kaksi tai useampia taulukkoja yhteen ehdon avulla. Esimerkissämme yhdistettiin Opiskelijat-taulukko Osastot-taulukkoon, jossa on OsastoId-sarake. Sisältöliittymiselle on myös syvällinen selitys "SQLite Liittyy" 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-lausetta käytetään suodattamaan tuloksen palauttama tulosjoukko SQL-kysely. Näin WHERE-lause 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"

• Kirjaimellinen merkkijonoarvo "Id ja nimi: "
• arvolla "Opiskelijanumero” sarake ja
• arvolla "Opiskelijan nimi” sarake

SQLite CAST-operaattori:

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

Jos sinulla on esimerkiksi numeroarvo, joka on tallennettu merkkijonoarvona, kuten tämä " '12.5' " ja haluat muuntaa sen numeeriseksi arvoksi, voit käyttää CAST-operaattoria tehdäksesi tämän näin "CAST ('12.5' TODELLAAN)". Tai jos sinulla on desimaaliarvo, kuten 12.5, ja sinun on saatava vain kokonaislukuosa, voit heittää sen kokonaisluvuksi, kuten "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:

Lisäys "+” – anna kahden operandin summa. Vähennys"-” – vähentää kaksi operandia ja johtaa erotukseen. Kertominen"*” – kahden operandin tulo. Muistutus (modulo) "%” – antaa jäännöksen, joka saadaan jakamalla yksi operandi toisella operandilla. divisioona "/” – palauttaa osamäärän, joka saadaan jakamalla vasen operandi oikealla.

Esimerkiksi:

Seuraavassa esimerkissä kokeillaan viittä aritmeettista operaattoria, joilla on kirjaimelliset numeeriset arvot samassa

valitse lauseke:

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 tosi, jos vasen operandi on pienempi kuin oikea operandi. "<=” – palauttaa tosi, jos vasen operandi on pienempi tai yhtä suuri kuin oikea operandi. ">” – palauttaa tosi, jos vasen operandi on suurempi kuin oikea operandi. ">=” – palauttaa tosi, jos vasen operandi on suurempi tai yhtä suuri kuin oikea operandi. "="Ja"==” – palauttaa arvon tosi, jos molemmat operandit ovat yhtä suuret. Huomaa, että molemmat operaattorit ovat samat, eikä niiden välillä ole eroa. "!="Ja"<>” – palauttaa arvon tosi, jos molemmat operandit eivät ole yhtä suuret. Huomaa, että molemmat operaattorit ovat samat, 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. Käyttämällä "Pitää", voit etsiä arvoja, jotka vastaavat jokerimerkillä määritettyä mallia.

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

• Sisältää kuvion. Esimerkiksi, Oppilaan nimi LIKE '%a%' – Tämä etsii opiskelijoiden nimet, jotka sisältävät kirjaimen "a" missä tahansa kohdassa Opiskelijanimi-sarakkeessa.
• Alkaa kuviosta. Esimerkiksi, "Oppilaan nimi LIKE 'a%'” – etsi oppilaiden nimet, jotka alkavat kirjaimella "a".
• Päättyy kuvioon. Esimerkiksi, "Oppilaan nimi LIKE '%a'” – Hae oppilaiden nimiä, jotka päättyvät kirjaimeen "a".
• Vastaa mikä tahansa merkkijonon yksittäinen merkki käyttämällä alaviivaa "_". Esimerkiksi, "Oppilaan nimi LIKE 'J___'” – Hae oppilaiden nimiä, jotka ovat 4 merkin pituisia. Sen on aloitettava J-kirjaimella ja siinä voi olla kolme muuta merkkiä J-kirjaimen jälkeen.

Mallin yhteensopivuuden esimerkkejä:

1. Hanki opiskelijoiden nimet, jotka alkavat j-kirjaimella:

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

   Tulos:

   

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

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

   Tulos:

   

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

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

   Tulos:

   

"LORAUS" – vastaa LIKE-operaattoria, mutta GLOB on kirjainkoon erottelukyky, toisin kuin LIKE-operaattori. Esimerkiksi seuraavat kaksi komentoa palauttavat erilaiset 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 käytetään valitsemaan arvot, jotka ovat kahden arvon alueella. Esimerkiksi, "X Y:N JA Z:N VÄLILLÄ” palauttaa tosi (1), jos arvo X on kahden arvon Y ja Z välissä. Muussa tapauksessa se palauttaa epätosi (0). "X Y:N JA Z:N VÄLILLÄ" vastaa "X >= Y JA X <= Z", X:n on oltava suurempi tai yhtä suuri kuin Y ja X on 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).

Kuten tämä: "sarake IN(x, y, z)". Tämä vastaa" (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-operaattorien käyttöä. "WHERE StudentId IN(2, 4, 6, 8)"vastaa" WHERE (StudentId = 2) OR (StudentId = 4) OR (StudentId = 6) OR (StudentId = 8);"

Tykkää tästä:

SQLite EI SISÄLLÄ

"NOT IN" -operandi on IN-operaattorin vastakohta. Mutta samalla syntaksilla; se vaatii yhden operandin ja listan operandeista. Se palauttaa tosi, jos ensimmäinen operandiarvo ei ole yhtä suuri kuin jonkin listan operandin arvo. eli se palauttaa tosi (0), jos operandiluettelo ei sisällä ensimmäistä operandia. Kuten tämä: "sarake EI IN(x, y, z)". Tämä vastaa "(sarake<>x) JA (sarake<>y) AND (sarake<>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. Ja osaston nimi "Matematiikka” ei palauteta, koska sillä osastolla ei ole opiskelijaa, joten osastotunnusta ei ole opiskelijataulukossa. Tästä syystä EXISTS-operaattori jätti huomiotta "Matematiikka”osasto.

SQLite ÄLÄ

Revmäärittää sen jälkeen tulevan edellisen operaattorin tuloksen. 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);

ulostulo:

Vain osasto"Matematiikka ” palautetaan. Koska "Matematiikka” osasto on ainoa osasto, jota ei ole opiskelijataulukossa.

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ä paikasta käyttämällä OFFSET-lausetta. Esimerkiksi, "RAJA 4 SIIRTYMÄ 4” jättää huomioimatta ensimmäiset 4 riviä ja palauttaa 4 riviä alkaen viidennestä rivistä, joten saat rivit 5,6,7, 8, XNUMX ja XNUMX.

Huomaa, että OFFSET-lause on valinnainen, voit kirjoittaa sen kuten "RAJO 4, 4" ja se antaa sinulle tarkat tulokset.

esimerkki:

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 päällekkäisiä arvoja, voit käyttää "DISTINCT” -avainsana poistaaksesi kaksoiskappaleet ja palauttaaksesi erilliset arvot. Voit määrittää useamman kuin yhden sarakkeen DISTINCT-avaimen työ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 alimman arvosanan "Merkit" pöytä:

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 summa-arvoa saadaksemme kaikkien "Merkit"taulukot:

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 erityinen arvo SQLite. Sitä käytetään edustamaan arvoa, joka on tuntematon tai puuttuva arvo. Huomaa, että nolla-arvo on täysin erilainen kuin "0" tai tyhjä "" arvo. Koska 0 ja tyhjä arvo ovat tunnettuja arvoja, nolla-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ä "ON NULL" operaattori etsii nolla-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 nollia, sinun on käytettävä "EI OLE NULL”operaattori näin:

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:

1. Voit käyttää erilaisia ​​ehtoja:

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

2. 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 ilmaisu kanssa NULL arvo Opiskelijat-taulukon osaston tunnus -sarakkeessa näyttääksesi tekstin "Ei osastoa" 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, voit viitata siihen myöhemmin. Huomaa, että voit määrittää SELECT-, UPDATE-, INSERT- tai DELETE-käskyn CTE:ille

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ääritimme CTE:n ja annoimme sille nimen "Kaikki osastot". Tämä CTE määritettiin SELECT-kyselystä:

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 a LIITY lauseke saadaksesi DepartmentName Osastot-taulukosta. Sen jälkeen lisäsimme GROUP BY -lauseen kahdella koostefunktiolla:

• "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:

Yhteenveto

Tämä oli johdatus kirjoittamiseen SQLite kyselyt ja tietokannan kyselyn perusteet ja kuinka voit suodattaa palautetut tiedot. Nyt voit kirjoittaa omasi SQLite kyselyitä.