Kui olete töötanud relatsiooniliste andmebaasisüsteemidega, olete tõenäoliselt kuulnud sellistest populaarsetest andmebaasisüsteemidest nagu MySQL , Server või PostgreSQL . SQLite on veel üks äärmiselt kasulik RDBMS, mida on väga lihtne seadistada ja kasutada. Samuti on sellel teiste relatsiooniliste andmebaaside ees palju erilisi tunnuseid. Selles SQLite-õpetuses õpetatakse põhimõisteid, mida peate teadma ulatuslike praktiliste praktikate abil.
Selles artiklis käsitletavad teemad on:
SQLite'i õpetus: mis on SQLite?
Siin on SQLite tööstusharu standarddefinitsioon:
SQLite on avatud lähtekoodiga, nullkonfiguratsiooniga, iseseisev, eraldiseisev, tehingutega seonduv andmebaasimootor, mis on loodud rakendusse sisseehitamiseks.Võite kaaluda SQLite nagu ' heledam ”Muudest keerukatest RDBMS-idest (Oracle, jne), kus selle andmebaasimootor on konfigureeritud iseseisev töötlemine (protsessisisene raamatukogu) st a serverivaba, iseseisev, nullkonfiguratsiooniga ja tehinguline . See on tuntud oma kaasaskantavuse, töökindluse ja tugeva jõudluse poolest ka vähese mäluga keskkondades. Samuti on SQLite populaarne valik varjatud andmebaasina kohaliku / kliendi salvestamiseks lõppprogrammides või rakendustes, erinevalt teistest RDBMS-idest, kus kliendi-serveri DB-mootor on konfigureeritud.
SQLite omadused
SQLite pakub palju erinevaid funktsioone, näiteks:
- Serverita: Enamik SQL-i andmebaasid on rakendatud eraldi serveriprotsessina, kuid SQLite'il pole eraldi serveriprotsessi. See on serverivaba andmebaasimootor. See loeb ja kirjutab otse tavalistele kettafailidele.
- Nullkonfiguratsioon: Seeei vaja selle käivitamiseks seadistusi. See tähendab, et pole ühtegi serveriprotsessi, mida oleks vaja käivitada, peatada või konfigureerida nagu kliendi / serveri süsteemis.
- Manifesti sisestamine: SQLite kasutab manifesti sisestamist, mis võimaldab salvestada mis tahes koguses mis tahes andmetüüpi mis tahes veergu, olenemata veeru deklareeritud andmetüübist. Pange tähele, et sellel reeglil on teatud erandid.
- Kerge: Nagu nimigi ütleb, SQLite teek on väga kerge. Asi on selles, et kuigi tema kasutatav ruum varieerub sõltuvalt süsteemist, kuhu see on installitud, võib see võtta ruumi vähem kui 600 KB.
- Kaasaskantav: Erinevalt teistest DBMS-idestkogu SQLite andmebaas on salvestatud ühte faili.Seda faili saab hõlpsasti jagada irdkandja või failiedastusprotokolli kaudu.
- Mitmekesine valik: Paljud programmeerimiskeeled pakuvad SQLite jaoks sidemeid, sealhulgas , , C # , , , Rubiin , , ja paljud teised.
- Tasuta: SQLite on tasuta ja avatud lähtekoodiga. SQLite'iga töötamiseks pole ärilitsents vajalik.
Nagu eespool SQLite loetletudon tuntud oma nullkonfiguratsiooni tõttu, mis tähendab, et keerukat seadistamist ega haldamist pole tegelikult vaja. Selle SQLite-õpetuse järgmises osas vaatame, kuidas SQLite oma süsteemi installida.
SQLite'i õpetus: SQLite'i installimine Windowsi
Järgige järgmisi samme:
Samm 1: Mine ametlik SQLite veebisaidil ja klõpsake allalaadimiseks sobivat linkieelkoostatud kahendfailid.
2. samm: Laadige alla SQLite käsurea zip-fail (siit: sqlite-tools-win32-x86-3270200.zip) ja laiendage neid faile valitud kaustas.
See SQLite käsurea tööriist sisaldab järgmisi SQLite tooteid
- SQLite tuum : SQLite tuum sisaldab tegelikku andmebaasimootorit ja avalikku API-d.
- SQLite3 käsurea tööriist : Rakendus sqlite3 on käsurea tööriist, mis on ehitatud SQLite tuuma kohale.
- Tcl pikendamine : See teek on sisuliselt SQLite tuuma koopia, millele on kinnitatud Tcl-sidemed.
- SQLite analüsaatori tööriist : SQLite analüsaatori tööriista kasutatakse andmebaasifailide analüüsimiseks.
3. samm: Pärast seda on SQLite käsurea käivitamine sama lihtne kui rakendusel sqlite3 klõpsamine, mis muudab käsurea hüpikaknaks.
Kui soovite veel katsetada, tippige lihtsalt .aita käsk sqlite> viip, et näha kõiki saadaolevaid käske sqlite3 nagu allpool näidatud.
Märge: Vaikimisi kasutab SQLite'i seanss mälusisest andmebaasi, mistõttu seansi lõppedes kaovad kõik muudatused.
Piisavalt lihtne, eks? Seejärel alustame SQLite-käskudega.
SQLite'i õpetus: SQLite käsud
Selles SQLite-õpetuse jaotises esitatakse SQL-i põhilaused, mida saate kasutada koos SQLite-iga.
Märge: SQLite käsud lõpevad semikooloniga (). See ütleb SQLite'ile, et teie käsk on täielik ja see tuleks käivitada.Samuti saate jaotada käsu mitmele reale ja kasutada viimasel real semikoolonit.
Andmebaasi käsud
See jaotis koosneb nendest käskudest, mille abil saate oma andmebaasiga tegeleda. Käsud on järgmised:
- SQLite'i andmebaasi loomine
SQLite ei kasuta käsku CREATE DATABASE nagu teistes relatsioonide andmebaaside haldussüsteemides, näiteks MySQL , SQL Server jne. Uue andmebaasi loomiseks SQLite'is sisestage lihtsalt sqlite3, millele järgneb faili nimi, mida soovite andmebaasi jaoks kasutada. Tjärgmine kood loob andmebaasifaili nimega StudentDetails.db:
Näide
sqlite3 StudentDetails.db sqlite> .andmebaasid peamine: D: sqliteStudentDetails.db
- SQLite Manuse andmebaas
Kui teil on mitu andmebaasi, saate korraga kasutada ainult ühte. SQLite'is kasutatakse käsu ATTACH DATABASE konkreetse andmebaasi lisamiseks praeguse ühenduse jaoks. ASelle käsu korral käivitatakse kõik SQLite-laused lisatud andmebaasis.
Näide
sqlite> ANDMebaasi lisamine 'DepartmentDetails.db' AS 'Department' sqlite> .andmebaasid main: D: sqliteStudentDetails.db Osakond: D: sqliteDepartmentDetails.db
- SQLite andmebaasi eraldamine
SQLite'is kasutatakse lauset DETACH DATABASE varjunime nimelise andmebaasi lahutamiseks andmebaasiühendusest, mis oli varem ATTACH-lause abil lisatud. Kui sama andmebaasifail on lisatud mitme varjunimega, katkestab see käsk ainult antud nime ja ülejäänud manus on endiselt olemas.Mälus või ajutises andmebaasis olevad andmebaasid hävitatakse täielikult ja sisu kaob.
Näide
sqlite> .databases main: D: sqliteStudentDetails.db Osakond: D: sqliteDepartmentDetails.db Õpilane: D: sqliteStudentDetails.db DeptInformation: D: sqliteDepartmentDetails.db sqlite> DETACH DATABASE 'Department' sqlite.dat: sqlite>. Õpilane: D: sqliteStudentDetails.db DeptInformation: D: sqliteDepartmentDetails.db
Tabeli käsud
Siit saame teada, kuidas SQLite kasutamisel tabelitega hakkama saada.
- SQLi tabeli loomine
SQLite'is kasutatakse uue tabeli loomiseks käsku CREATE TABLE. Tabeli loomise ajal peate tabelile nime andma ja määrama selle veeru ning iga veeru andmetüübid.
Süntaks:
CREATE TABLE tabeli_nimi (veerg1 veeru_tüüp [piirangud] veerg2 veeru_tüüp [piirangud] [.....])
Näide
LOE TABEL StudentInfo (ID INT PÕHIVÕTI EI NULL, NIMI TEKST EI NULL, VANUS INT NULL, AADRESS CHAR (50), DEPARTMENTID INTEGER NOT NULL, TELEFONITEKSTI DEFAULT 'TUNNUS', VÕLKE NÕU (DEPARTMENTID) REFERENTSID (ID)
Selle abil saate kontrollida, kas tabel on loodud või mitte .tabelid käsk, nagu allpool näidatud. Pange tähele, et olen juba loonud tabeli nimega Osakonnainfo kus DeptID on peamine võti.Osakondade tabelis on tabeli Õpilased piirang välismaise võtme jaoks.
sqlite> .tabelid StudentInfo Kontaktid Emp_Master
- SQLite kukutustabel
SQLite'is võimaldab DROP TABLE käsk tabeli SQLite andmebaasist eemaldada või kustutada. Kui tabel on langenud, eemaldatakse kõik selles sisalduvad andmed andmebaasist jäädavalt. Samuti eemaldatakse kõik seotud indeksid ja käivitajad. Kui selles tabelis on lubatud võõra võtme piirang, eemaldatakse see iga tabeli rea kohta samaväärselt ja ka kõik tabeliga seotud käivitajad loobutakse.
Süntaks
LABI TABEL [KUI OLEMAS] tabeli_nimi
Näide
DROP TABEL Osakonna viga: sellist tabelit pole: Osakond DROP TABEL Ettevõtte sqlite> .tabelid StudentInfo
Märge: KUI ON, on vabatahtlik klausel. Kui see on täpsustatud, ei tekita DROP TABLE lause viga, kui ühte tabelit pole olemas.
Samuti on olemas SQLite Alter Table väljavõte , millest saame aru selle artikli järgmistes jaotistes. Nüüd, kui oleme tabeli loonud, uurime, kuidas andmeid sisestada, kustutada ja muuta.
SQLite'i õpetus: CRUD-toimingud
- SQLite Sisesta päring
Pärast tabeli loomist saab määratud tabelis uute ridade loomiseks kasutada käsku SQLite Insert Into. SQLite insert-lause on kaks sisukat vormi. Esimene vorm kasutab lisatavate väärtuste loendi määramiseks klauslit VALUES.
Süntaks
INSERT IN TABLE_NAME [(veerg1, veerg2, veerg3, ... veergN)] VÄÄRTUSED (väärtus1, väärtus2, väärtus3, ... väärtusN)
Näide
INSERTTEERI StudentInfosse (ID, NIMI, VANUS, AADRESS, DEPARTMENTID, TELEFON) VÄÄRTUSED (1, 'Dean', 20, 'California', 2, '934 *******')
Väljund
VALI * valikust StudentInfo ID NIMI VANUS AADRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 dekaan 20 California 2 934 *******
Siin luuakse üks uus rida ja iga väärtus salvestatakse vastavasse veergu. Pange tähele, et mõlemal loendil peab olema sama üksuste arv. Siin, veergude loend on vabatahtlik. Samuti võime tabelisse andmeid sisestada veergude loendit täpsustamata .
Näide
Sisestage õpilasinfo väärtused (2, 'SAM', 22, 'Texas', 2, '976 *******')
Väljund
VALI * valikust StudentInfo ID NIMI VANUS AADRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 dekaan 20 California 2 934 ******* 2 SAM 22 Texas 2 976 *******
SQLite pakub ka funktsiooni sisestage mitu rida ühes INSERT-avalduses. Süntaks on selline, nagu allpool näidatud.
Näide
Sisesta õpilasinfo väärtused (3, 'John', 23, 'Norra', 1, '923 *******'), (4, 'Mitch', 22, 'Houston', 3, '934 ** ***** ')
Väljund
Valige * StudentInfo 1-st | Dean | 20 | California | 2 | 934 ******* 2 | SAM | 22 | Texas | 2 | 976 ******* 3 | John | 23 | Norra | 1 | 923 ******* 4 | Mitch | 22 | Houston | 3 | 934 *******
Nagu näete, pole väljundi formaat päris sarnane varasemaga. Niisiis, kuidas muuta SQLite'i väljundi vormingut? Vormindame väljundi nii, et meie tulemusi oleks natuke lihtsam lugeda.
- Kujundamine
Väljundrežiimi muutmiseks saate kasutada .mode. Ülaltoodud näide kasutab .režiim nimekiri, mis kuvab tulemused loendina. Samuti saate kasutada .päised avaldus, et määrata, kas kuvada veerupäiseid või mitte. Kui olete muudatused teinud, saate seadet vaadata, kasutades .näita käsk.
Näide
sqlite> .mode 'veerg' sqlite> .lubid sqlite'il> .show echo: off eqp: off seleta: automaatsed päised: on mode: veeru nullvalue: '' output: stdout colseparator: '|' reaseparaator: 'n' stats: väljas laius: failinimi: StudentDetails.db
Väljund
VALI * StudentInfo ID-NIMI VANUSTE AADRESSI OSAKONDA TELEFON ---------- ---------- ---------- ---------- ---------- ---------- 1 dekaan 20 California 2 934 ******* 2 SAM 22 Texas 2 976 ******* 3 Jaan 23 Norra 1 923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Valige päring
SQLite'is kasutatakse käsku Selectandmete toomiseks tabelist, mis tagastab andmed tulemustabeli kujul. Neid tulemustabeleid nimetatakse ka tulemuseks komplektid. Kasutades SQLite select-lauset, saame vastavalt vajadustele teha lihtsaid arvutusi või mitu avaldist.Oleme andmete sisestamisel varem kasutanud SELECT-lauset.
Süntaks
VALI [KÕIK | DISTINCT] tulemus [FROM table-list] [WHERE expr]
- ERISTAMA - Kui kasutame valitud lauses eraldi märksõna, tagastab see ainult erinevad andmeread.
- KÕIK - Kui me kasutame valitud lauses KÕIK märksõna, tagastab see kõik andmeread, isegi kui see on dubleeritud.
- FROM tabeliloendist - See on loetelu tabelitest, kust soovite andmeid hankida.
- KUS väljend - Avaldist WHERE kasutatakse meie kohandatud tingimuste määratlemiseks, et saada tabelitest nõutavad andmed.
Näide1
Valige ID, NIMI StudentInfost KUS VANUS<21
Väljund
ID NIMI ---------- ---------- 1 dekaan
Näide2
Valige NIMI StudentInfost WHERE DEPARTMENTID = (Valige DeptID FROM DepartmentInfo WHERE DeptName = 'psühholoogia')
Väljund
// tõmbab osakonnast inimesi, kelle ID on 2 NIMI ---------- Dean SAM
- SQLite värskenduspäring
SQLite'is saab käsku UPDATE tabelis olemasolevate kirjete muutmiseks kasutada.SQLite WHERE-klauslit saab kasutada täpsustamiseks, milliseid ridu tuleks värskendada. Sõltuvalt WHERE klauslis rakendatud filtreerimistingimustest saate hõlpsasti värskendada kõiki ridu, mõnda rida või mitte ühtegi.
Süntaks
UPDATE tabeli_nimi SET veerg1 = väärtus1, veerg2 = väärtus2 ...., veergN = väärtusN KUS [tingimus]
Näide
UPDATE StudentInfo MÄÄRA DEPARTMENTID = 4 KUS ID = '2'
Väljund
VALI * StudentInfo ID-st NIMI VANUS AADRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 dekaan 20 California 2 934 ******* 2 SAM 22 Texas 4 976 ******* 3 Johannes 23 Norra 1 923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Kustuta päring
SQLite'is saab käsku DELETE kirje tabelist kustutamiseks kasutada. Sõltuvalt WHERE klauslis rakendatud filtreerimistingimustest saate hõlpsalt kustutada kõik read, mõned read või ükski.
Näide
KUSTUTA DepartmentInfost WHERE DeptName = 'Teadus'
Väljund
VALI * FROM DepartmentInfo DeptID DeptName ---------- ----------- 1 Matemaatika 2 Psühholoogia 3 Sport 4 Muusika
Kui proovite kustutada kirjet, millele on viidatud võõrvõti, kuvatakse tõrge. Enne esmase võtme kirje kustutamist peate esmalt kustutama võõrvõtmekirjed. Proovime osakonna teaduse kustutada.
Näide
KUSTUTA DepartmentInfost WHERE DeptName = 'Muusika' tõrge: VÕLKVIISI piirang ei õnnestunud
Niisiis, enne peamise võtme kustutamist peame kustutama võõrvõtmekirjed.
KUSTUTA StudentInfost WHERE DEPARTMENTID = 4 sqlite> KUSTUTA DepartmentInfost WHERE DeptName = 'Muusika' sqlite> SELECT * FROM DepartmentInfo DeptID DeptName ---------- ----------- 1 Matemaatika 2 Psühholoogia 3 spordiala VALI * StudentInfo ID-st NIMI VANUS AADRESS DEPARTMENTID PHONE ---------- ---------- ---------- ------- --- ------------ ---------- 1 dekaan 20 California 2 934 ******* 3 Johannese 23 Norra 1 923 ****** * 4 Mitch 22 Houston 3 934 *******
Nüüd teate, kuidas redigeerida tabelis SQLite andmebaasi kirjeid. Selles SQLite juhendajablogis edasi liikudes arutame erinevaid klausleid ja tingimusi, millega SQLite'is kõige sagedamini kokku puutute.
SQLite klauslid / tingimused
Enne klauslitega alustamist on siin SQLite avaldise SELECT täielik süntaks.
Süntaks
VALI [KÕIK | DISTINCT] tulemus [FROM table-list] [WHERE expr] [GROUP BY expr-list] [HAVING expr] [compos-op select] * [ORDER BY sort-expr-list] [LIMIT integer [(OFFSET |,) täisarv ]]
Märkus. Olen värskendanud StudentInfo ja DepartmentInfo tabeleid, nagu allpool näidatud.
// Õpilaslaua ID NIMI VANUS AADRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 dekaan 20 California 2 934 ******* 3 Johannes 23 Norra 1 923 ******* 4 Mitch 22 Houston 3 934 ******* 2 SAM 22 Texas 4 976 ******* 5 Johny 23 Norra 2 945 ******* 6 Robin 23 Norra 2 Tundmatu // Osakonna üksikasjad DeptID DeptName - --------- ----------- 1 Matemaatika 2 Psühholoogia 3 Sport 4 Muusika 5 Teadus
- SQLite KUS
SQLite'is kasutatakse WHERE klauslit, et kehtestada SELECT-lause piirangud, määratledes ühe või mitu tingimust nõutavate andmete saamiseks andmebaasi tabelitest.Kui määratud tingimus on täidetud või tõene, tagastab see tabelist konkreetse väärtuse. Nagu te varem nägite, ei kasutata klauslit WHERE mitte ainult SELECT-lauses, vaid seda kasutatakse ka lauses UPDATE, DELETE jne.
Näide
VALI NIMI StudentInfost, KUS VANUS = 23NIMI ---------- John Johny Robin
SQLite'is on WHERE-klausliga võimalik kasutada mitmeid seoseoperaatoreid.
- SQLite GROUP BY
SQLite'is kasutatakse klauslit GROUP BY andmete koondamiseks ühte ritta, kus korratakse ühe või mitme määratud veeru väärtust. Seda klauslit kasutatakse koos lause WHERE lausega ja see eelneb klauslile ORDER BY.
Süntaks
VALI tulemus FROM [table-list] GROUP BY [expr-list]
VALI NIMI, AADRESS StudentInfo GRUPIST NIMI NIMI AADRESSI JÄRGI ---------- ---------- Dean California John Norra Johny Norra Mitch Houston Robin Norra SAM Texas
Pange tähele, et rühmitamisprotsessil on kaks sammu. Esiteks kasutatakse väljendit GROUP BY, et korraldada tabeliread erinevatesse rühmadesse. Kui rühmad on määratletud, määratleb lause SELECT, kuidas need rühmad on ühele reale tasandatud.
- SQLite TELLI
Üldiselt salvestavad SQLite-tabelid andmeid määratlemata järjekorras ja see tagastab kirjed samas määratlemata järjekorras, samal ajal kui SQLite select-lauset kasutades andmeid tõmmatakse. Sellistel juhtudel saate kasutada veerukirjete sortimiseks kasvavas või kahanevas järjestuses klauslit ORDER BY. Allpool toodud näites olen andmed rühmitanud ja järjestanud kahanevas järjestuses) aadressi põhjal.
Süntaks
r-i kasutamine masinõppeks
VALI väljendid tabelite loendist [WHERE tingimused] TELLI veerg1, veerg2, ... [ASC | DESC]
Näide
VALI AADRESS, ARV (AADRESS) StudentInfo GRUPIST AADRESSIKORRALUSE JÄRGI AADRESSI JÄRGI DESC AADRESSI ARV (AADRESS) ---------- -------------- Texas 1 Norra 3 Houston 1 California 1
- SQLite, KES ON
SQLite'is VÕIMALIK klausel on identne KUS klausel. HAVING-klausel on täiendav tingimus, mida rakendatakse pärast seda, kui liitmine toimub koos rühmaga valitud lauses. Üldiselt SQLite'is KUS klauslit kasutatakse tingimuse rakendamiseks tabeli üksikutele elementidele ja VÕIMALIK klauslit kasutatakse filtritingimuste lisamiseks grupi järgi loodud gruppide põhjal.
Näide
VALI AADRESS, ARV (AADRESS) StudentInfo RÜHMAST AADRESSI JÄRGI, KUS ON LOEND (*)> 1 AADRESSI ARV (AADRESS) ---------- -------------- Norra 3
- SQLite'i piiranguklausel
SQLite'is kasutatakse klahvi LIMIT, et seada limiit valitud lausega tagastatud kirjetele. Vaatame mõiste mõistmiseks näite.
Süntaks
VALI avaldised tabelite loendist [WHERE tingimused] LIMIT number_read OFFSET offset_value
Näide
VALI NIMI, AADRESS StudentInfo-lt LIMIT 4 NIMETUS 2 NIMI AADRESS ---------- ---------- Mitch Houston SAM Texas Johny Norra Robin Norra
NIHEon valikuline ja see määratleb mitu rida tulemuste komplekti alguses vahele jätta offset_value .
- SQLite JA & OR
SQLite'is kasutatakse operaatoreid AND & OR mitmete tingimuste täitmiseks lausete valimisel, sisestamisel, värskendamisel ja kustutamisel vastavalt meie nõuetele. Operaator SQLite AND tagastab ridu või kirjeid, mis vastavad operaatori AND abil määratletud tingimustele.
Näide1
VALI NIMI StudentInfost, KUS VANUS = 22 JA AADRESS = 'Texas' NIMI ---------- SAM
Tingimust OR kasutatakse SQLite lausetes mitme tingimuse määratlemiseks ja see tagastab lausest ridad või kirjed, kui mõni ühest tingimusest on täidetud.
Näide2
VALI NIMI StudentInfo KOHT (VANUS = 22 JA AADRESS = 'Norra') VÕI AADRESS = 'Norra' NIMI ---------- John Johny Robin
- SQLite GLOB-operaator
SQLite'is kontrollitakse GLOB-operaatorit, kas antud stringi väärtus sobib konkreetse mustriga või mitte. Juhul, kui stringi väärtus sobib mustri väärtusega, siis see naaseb tõsi ja see sarnaneb operaatoriga LIKE. Samuti on GLOB tõstutundlik.
Süntaks
VALI * FROM tabeli_nimi WHERE veeru_nimi GLOB 'otsingu-avaldis'
Näide
VALI * FROM StudentInfost KUHU NIMEKOGU 'Joh *' ID NIMI VANUS AADRESS DEPARTMENTID PHONE ---------- ---------- ---------- --- ------- ------------ ---------- 3 Johannese 23 Norra 1 923 ******* 5 Johny 23 Norra 2 945 ** *****
- SQLite Distinct
SQLite'is skannib märksõna DISTINCT käsu SELECT tulemuste komplekti ja kõrvaldab kõik duplikaatread. Samuti loetakse NULL-väärtused duplikaatideks, nii et kui kasutame klauslit DISTINCT veeruga, millel on NULL-väärtused, hoiab see NULL-väärtusest ainult ühte rida. Kui rakendate DISTINCT mitme veeru jaoks, tagastab lause iga kordumatu kombinatsiooni coulnm1 ja veerg2.
Näide
VALIGE StudentInfo VANUSEST EHITUSVANUS ---------- 20 23 22
- SQLite IN operaator
SQLite'is kasutatakse IN-operaatorit, et teha kindlaks, kas antud väärtus vastab antud väärtuste loendile või alampäringu tagastatud tulemusele.
Näide
VALI NIMI StudentInfost, KUS AADRESS ON ('Texas', 'Houston') NIMI ---------- Mitch SAM- SQLite UNION & UNION ALL
SQLite'is kasutatakse UNIONi operaatorit tulemuste komplektide ühendamiseks 2 või enam SELECT-lauset ja see eemaldab duplikaatread erinevate SELECT-lausete vahel. Pidage meeles, et SELECT-lausetes, mida me kasutasime operaatoriga UNION, peab tulemuste komplektides olema sama arv välju sarnaste andmetüüpidega.
Süntaks
SELECT avaldis1, avaldis2, ... avaldis_n tabelitest [WHERE tingimused] UNION / UNION ALL VALI avaldis1, avaldis2, ... avaldis_n tabelitest [WHERE tingimused]
Näide
VALI DEPARTMENTID FILMIST StudentInfo UNIONist Valige DeptId DepartmentInfost TELLI DEPARTMENTID ASC DEPARTMENTID ------------ 1 2 3 4 5
Operaatorit UNION ALL kasutatakse 2 või enama SELECT-lause tulemuste komplekti kombineerimiseks ja see tagastab kõik read koos duplikaatidega.
Näide
VALI DEPARTMENTID FILMIST StudentInfo UNION'ist KÕIK VALI DeptId DepartmentInfost TELLI DEPARTMENTID ASC DEPARTMENTID ------------ 1 1 2 2 2 2 3 3 4 4 5
Sellega oleme käsitlenud kõige põhilisemaid käske, mida võib-olla peate kasutama SQLite'iga töötamisel. Selle SQLite-juhendajaga edasi liikudes tutvume SQLite-i liitumislausega.
Liitub SQLite'iga
SQLite'is on liitumisedkasutatakse andmebaasi kahe või enama tabeli kirjete ühendamiseks ja meie nõuetest lähtuvate kirjete saamiseks. DSQLite'is saadaval olevad JOINSi tüübid on järgmised:
- Sisemine liitumine -INNER JOIN-i kasutatakse korrutustabelitest ainult sobivate kirjete ühendamiseks ja tagastamiseks SQLite-lausetes määratletud tingimuste põhjal.
- Väline liitumine -SQLite Outer Join valib mitmest tabelist samad read nagu samad Sisemine liitumine ja veel mõned suhtevälised read.Lihtsamalt öeldes võime öelda SQLiteVÄLIS LIITUMINEon täiendusSISSE LIITU . Üldiselt on meil SQL-standardis kolme tüüpi väliseid ühendusi, näiteks LEFT, RIGHT ja FULL Outer Joins, kuid SQLite toetab ainult LEFT OUTER JOIN-i.
- Ristliitumine -Seda kasutatakse ridade ristkoostise korrutise saamisekssobitades esimese tabeli iga rea teise tabeli iga reaga.
- Ise liituma - Seekasutatakse sama tabeli ühendamiseks iseendaga. Iseliitumise kasutamiseks peame looma samale tabelile erinevad varjunimed, et meie nõuetest lähtuvalt toiminguid teha.
Kontseptsioon on sarnane teiste relatsiooniliste andmebaasisüsteemide, näiteks SQL, mõistega. Nii et lisateabe saamiseks võite sellele artiklile viidata .
Sellega oleme käsitlenud SQLite põhikäske. Täpsemaid kontseptsioone siin ei käsitleta. Niisiis, oodake veel ühte artiklit, mis käsitleb täiustatud SQLite-kontseptsioone. Isegi kõigi SQLite pakutavate heade omaduste korral on sellel ka teatud puudused.
SQLite'i õpetus: SQLite'i puudused
Allpool on loetletud SQLite'i kasutamise tingimused:
- See ei tööta hästi kliendi / serveri arhitektuuris.
- SQLite andmebaasi suurus on enamasti piiratud 2 GB-ga.
- SQLite pole rakendanud RIGHT OUTER JOIN ja FULL OUTER JOIN. SQLite abil saame rakendada ainult LEFT OUTER JOIN.
- SQLite'i vaated on kirjutuskaitstud. Me ei saa vaadetega kasutada DML-i lauseid (Sisesta, Värskenda ja Kustuta).
- Me ei saa SQLite'iga kasutada GRANT- ja REVOKE-lauseid.
Sellega jõuame selle SQLite-õpetuse lõpuni.
Kui soovite rohkem teada saada MySQL ja tutvuge selle avatud lähtekoodiga relatsioonide andmebaasiga ning vaadake siis meie mis on varustatud juhendajate juhitud elava koolituse ja reaalse elu projektikogemusega. See koolitus aitab teil MySQL-i põhjalikult mõista ja aitab teil selle teema üle meisterlikkust saavutada.
Kas teil on meile küsimus? Palun mainige seda selle SQLite juhendaja kommentaaride jaotises ja pöördun teie poole.