Pokud jste pracovali s relačními databázovými systémy, je pravděpodobné, že jste slyšeli o populárních databázových systémech, jako je MySQL, SQL Server nebo PostgreSQL. SQLite je další extrémně užitečný RDBMS, který se velmi jednoduše nastavuje a ovládá. Oproti jiným relačním databázím má také mnoho odlišných funkcí. Tento výukový program SQLite učí základní koncepty, které potřebujete znát, pomocí rozsáhlých praktických postupů.
Témata probíraná v tomto článku jsou:
- Co je SQLite?
- Funkce SQLite
- Instalace SQLite na Windows
- Příkazy SQLite
- Databázové příkazy
- Tabulkové příkazy
- Operace CRUD
- Klauzule/podmínky SQLite
- Připojí se k SQLite
- Nevýhody SQLite
Výukový program SQLite:Co je SQLite?
Zde je průmyslová standardní definice SQLite:
SQLite je open source, nulová konfigurace, samostatný, samostatný, transakční relační databázový stroj navržený pro vložení do aplikace.
Můžete zvážit SQLite jako „zapalovač ” verze jiného komplexního RDBMS (Oracle, SQL atd.), kde je jeho databázový stroj nakonfigurován pro nezávislé zpracování (knihovna v procesu) tj. bezserverový, samostatný, bez konfigurace a transakční . Je známý svou přenositelností, spolehlivostí a silným výkonem i v prostředí s nízkou pamětí. SQLite je také oblíbenou volbou jako vestavěná databáze pro lokální/klientské úložiště v koncových programech nebo aplikacích, na rozdíl od jiných RDBMS, kde je konfigurován klient-server DB engine.
Funkce SQLite
SQLite nabízí mnoho odlišných funkcí, jako jsou:
- Bez serveru: Většina databází SQL je implementována jako samostatný serverový proces, ale SQLite samostatný serverový proces nemá. Jedná se o databázový stroj bez serveru. Čte a zapisuje přímo na běžné soubory na disku.
- Nulová konfigurace: Ke spuštění nevyžaduje žádnou konfiguraci. To znamená, že neexistuje žádný serverový proces, který je třeba spouštět, zastavovat nebo konfigurovat jako v systému klient/server.
- Manifestní typ: SQLite používá typování manifestu, které umožňuje ukládání libovolného množství libovolného datového typu do libovolného sloupce bez ohledu na deklarovaný datový typ sloupce. Upozorňujeme, že z tohoto pravidla existují určité výjimky.
- Nízká: Jak název napovídá, knihovna SQLite je velmi lehká. Věc se má tak, že i když se místo, které využívá, liší v závislosti na systému, kde je nainstalováno, může zabírat méně než 600 kB místa.
- Přenosné: Na rozdíl od jiných DBMS je celá databáze SQLite uložena v jediném souboru. Tento soubor lze velmi snadno sdílet prostřednictvím vyměnitelných médií nebo protokolu pro přenos souborů.
- Různý výběr: Mnoho programovacích jazyků poskytuje vazby pro SQLite, včetně C, C++, C#, Java, JavaScript, Ruby, Python a mnoha dalších.
- Zdarma: SQLite je zdarma a s otevřeným zdrojovým kódem. Pro práci s SQLite není vyžadována komerční licence.
Jak je uvedeno výše, SQLite je známý svou nulovou konfigurací, což znamená, že není potřeba žádné složité nastavení nebo administrace. V další části tohoto výukového programu SQLite se podíváme, jak nainstalovat SQLite do vašeho systému.
Výukový program SQLite:Instalace SQLite na Windows
Postupujte takto:
Krok 1: Přejděte na oficiální web SQLite a kliknutím na vhodný odkaz stáhněte předkompilované binární soubory.
Krok 2: Stáhněte si soubor zip příkazového řádku SQLite (zde:sqlite-tools-win32-x86-3270200.zip) a rozbalte tyto soubory do složky dle vašeho výběru.
Tento nástroj příkazového řádku SQLite bude obsahovat následující produkty SQLite
- Jádro SQLite :Jádro SQLite obsahuje skutečný databázový stroj a veřejné API.
- Nástroj příkazového řádku SQLite3 :Aplikace sqlite3 je nástroj příkazového řádku, který je postaven na jádru SQLite.
- Rozšíření Tcl :Tato knihovna je v podstatě kopií jádra SQLite s připojenými vazbami Tcl.
- Nástroj pro analýzu SQLite :Nástroj SQLite analyzátor se používá k analýze databázových souborů.
Krok 3: Poté je spuštění příkazového řádku SQLite stejně jednoduché jako kliknutí na aplikaci sqlite3, čímž se příkazový řádek zobrazí.
Pokud chcete testovat dále, jednoduše zadejte .help příkaz z sqlite> zobrazí všechny dostupné příkazy v sqlite3 jako je uvedeno níže.
Poznámka: Ve výchozím nastavení používá relace SQLite databázi v paměti, takže po skončení relace budou všechny změny odstraněny.
Dost jednoduché, že? Pak začněme s příkazy SQLite.
Výukový program SQLite:Příkazy SQLite
Tato část výukového programu SQLite představuje základní příkazy SQL, které můžete použít s SQLite.
Poznámka: Příkazy SQLite končí středníkem (; ). Říká SQLite, že váš příkaz je dokončen a měl by být spuštěn. Svůj příkaz můžete také rozložit na více řádků a na posledním řádku použít středník.
Databázové příkazy
Tato sekce se skládá z těch příkazů, pomocí kterých můžete pracovat s vaší databází. Příkazy jsou:
- SQLite Create Database
SQLite nepoužívá příkaz CREATE DATABASE jako v jiných systémech správy relačních databází, jako je MySQL, SQL Server atd. Chcete-li vytvořit novou databázi v SQLite, jednoduše zadejte sqlite3 následovaný podle názvu souboru, který chcete použít pro databázi. Následující kód vytvoří databázový soubor s názvem StudentDetails.db:
Příklad
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- SQLite Attach Database
Pokud máte více databází, můžete najednou používat pouze jednu. V SQLite se příkaz ATTACH DATABASE používá k připojení konkrétní databáze pro aktuální připojení. Po tomto příkazu budou všechny příkazy SQLite provedeny v připojené databázi.
Příklad
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- SQLite Detach Database
V SQLite se příkaz DETACH DATABASE používá k odpojení aliasově pojmenované databáze od databázového připojení, které bylo dříve připojeno pomocí příkazu ATTACH. Pokud byl stejný databázový soubor připojen s více aliasy, pak tento příkaz odpojí pouze dané jméno a zbytek přílohy bude nadále existovat. Databáze v rámci in-memory nebo dočasné databáze budou zcela zničeny a obsah bude ztracen.
Příklad
sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db sqlite> DETACH DATABASE 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db
Příkazy tabulky
Zde se naučíme, jak zacházet s tabulkami při používání SQLite.
- SQL Create Table
V SQLite se k vytvoření nové tabulky používá příkaz CREATE TABLE. Při vytváření tabulky musíte tabulku pojmenovat a definovat její sloupec a datové typy každého sloupce.
Syntaxe:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Příklad
CREATE TABLE StudentInfo( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), DEPARTMENTID INTEGER NOT NULL, PHONE TEXT DEFAULT 'UNKNOWN', FOREIGN KEY(DEPARTMENTID) REFERENCES DepartmentInfo(DeptID) );
Zda byla tabulka vytvořena či nikoli, můžete zkontrolovat pomocí .tables příkaz, jak je znázorněno níže. Všimněte si, že jsem již vytvořil tabulku s názvem DepartmentInfo kde DeptID je primární klíč. Tabulka Oddělení má omezení cizího klíče na tabulku Studenti.
sqlite> .tables StudentInfo Contacts Emp_Master
- SQLite Drop Table
V SQLite vám příkaz DROP TABLE umožňuje odstranit nebo odstranit tabulku z databáze SQLite. Jakmile je tabulka zrušena, všechna data, která obsahuje, jsou trvale odstraněna z databáze. Všechny související indexy a spouštěče jsou také odstraněny. Pokud je v této tabulce povoleno jakékoli omezení cizího klíče, bude to odstraněno ekvivalentně pro každý řádek v tabulce a všechny spouštěče spojené s tabulkou budou také zrušeny.
Syntaxe
DROP TABLE [ IF EXISTS ] table_name;
Příklad
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Poznámka: IF EXISTS je volitelná klauzule. Pokud je zadán, příkaz DROP TABLE nevyvolá chybu, pokud jedna z tabulek neexistuje.
K dispozici je také příkaz SQLite Alter Table , které pochopíme v několika následujících částech tohoto článku. Nyní, když jsme vytvořili tabulku, pojďme se podívat, jak vložit, odstranit a upravit data.
Výukový program SQLite:Operace CRUD
- Dotaz na vložení SQLite
Po vytvoření tabulky lze příkaz SQLite Insert Into použít k vytvoření nových řádků v zadané tabulce. Existují dvě smysluplné formy příkazu SQLite insert. První formulář používá klauzuli VALUES k určení seznamu hodnot, které se mají vložit.
Syntaxe
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Příklad
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Výstup
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Zde se vytvoří jeden nový řádek a každá hodnota se zaznamená do příslušného sloupce. Upozorňujeme, že oba seznamy musí mít stejné počet položek. Zde je seznam sloupců je volitelný. Data do tabulky můžeme vkládat ibez uvedení seznamu sloupců .
Příklad
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Výstup
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite také nabízí funkcivložení více řádků v jediném příkazu INSERT. Syntaxe je uvedena níže.
Příklad
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Výstup
Select *from StudentInfo; 1|Dean|20|California|2|934******* 2|SAM|22|Texas|2|976******* 3|John|23|Norway|1|923******* 4|Mitch|22|Houston|3|934*******
Jak vidíte, formát výstupu není úplně podobný tomu předchozímu. Jak tedy změníte formát výstupu v SQLite? Naformátujme výstup, aby byly naše výsledky o něco snáze čitelné.
- Formátování
Ke změně výstupního režimu můžete použít .mode. Výše uvedený příklad používá .mode seznam, který zobrazí výsledky jako seznam. Můžete také použít .headers příkaz k určení, zda se mají či nemají zobrazovat záhlaví sloupců. Jakmile provedete změny, můžete nastavení zobrazit pomocí .show příkaz.
Příklad
sqlite>.mode 'column' sqlite> .headers on sqlite> .show echo: off eqp: off explain: auto headers: on mode: column nullvalue: "" output: stdout colseparator: "|" rowseparator: "n" stats: off width: filename: StudentDetails.db
Výstup
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENT PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- Výběrový dotaz SQLite
V SQLite se k načítání dat z tabulky používá příkaz Select, který vrací data ve formě výsledkové tabulky. Tyto výsledkové tabulky se také nazývají sady výsledků. Pomocí příkazu SQLite select můžeme provádět jednoduché výpočty nebo více výrazů na základě našich požadavků. Při vkládání dat jsme již dříve použili příkaz SELECT.
Syntaxe
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINCT – Když v příkazu select použijeme odlišné klíčové slovo, vrátí pouze odlišné řádky dat.
- VŠECHNY – Pokud v příkazu select použijeme klíčové slovo ALL, vrátí všechny řádky dat, i když jsou duplicitní.
- ZE seznamu tabulek – Je to seznam tabulek, ze kterých chcete získat data.
- výraz WHERE – Výraz WHERE se používá k definování našich vlastních podmínek pro získání požadovaných dat z tabulek.
Příklad1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Výstup
ID NAME ---------- ---------- 1 Dean
Příklad 2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Výstup
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- Aktualizační dotaz SQLite
V SQLite lze příkaz UPDATE použít k úpravě existujících záznamů v tabulce. Klauzuli WHERE SQLite lze použít k přesnému určení, které řádky by měly být aktualizovány. V závislosti na podmínkách filtrování použitých klauzulí WHERE můžete snadno aktualizovat všechny řádky, některé řádky nebo žádný.
Syntaxe
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Příklad
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Výstup
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 4 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- SQLite Delete Query
V SQLite lze k odstranění záznamu z tabulky použít příkaz DELETE. V závislosti na podmínkách filtrování použitých klauzulí WHERE můžete snadno odstranit všechny řádky, některé řádky nebo žádný.
Příklad
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Výstup
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Pokud se pokusíte odstranit záznam, na který odkazuje cizí klíč, zobrazí se chyba. Před odstraněním záznamu primárního klíče budete muset nejprve odstranit záznamy cizího klíče. Zkusme smazat oddělení vědy.
Příklad
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Před odstraněním primárního klíče tedy musíme odstranit záznamy cizích klíčů.
DELETE FROM StudentInfo WHERE DEPARTMENTID = 4; sqlite> DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; sqlite> SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
Nyní víte, jak upravovat záznamy v tabulce databáze SQLite. V tomto výukovém blogu SQLite dále probereme různé klauzule a podmínky, se kterými se v SQLite nejčastěji setkáváte.
Klauzule/podmínky SQLite
Než začnete s klauzulemi, zde je úplná syntaxe příkazu SELECT v SQLite.
Syntaxe
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr] [GROUP BY expr-list] [HAVING expr] [compound-op select]* [ORDER BY sort-expr-list] [LIMIT integer [(OFFSET|,) integer]]
Poznámka:Aktualizoval jsem tabulky StudentInfo a DepartmentInfo, jak je uvedeno níže.
//Student Table ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934******* 2 SAM 22 Texas 4 976******* 5 Johny 23 Norway 2 945******* 6 Robin 23 Norway 2 UNKNOWN //Department Details DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music 5 Science
- KDE SQLite
V SQLite se klauzule WHERE používá k omezení příkazu SELECT definováním jedné nebo více podmínek pro získání požadovaných dat z tabulek v databázi. Pokud je zadaná podmínka splněna nebo pravdivá, vrátí konkrétní hodnotu z tabulky. Jak jste viděli dříve Klauzule WHERE se používá nejen v příkazu SELECT, ale také v příkazu UPDATE, DELETE atd.
Příklad
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
V SQLite existuje řada relačních operátorů, které lze použít s klauzulí WHERE.
- SQLite GROUP BY
V SQLite se klauzule GROUP BY používá k agregaci dat do jednoho řádku, kde se opakuje hodnota jednoho nebo více zadaných sloupců. Tato klauzule se používá s klauzulí WHERE v příkazu SELECT a předchází klauzuli ORDER BY.
Syntaxe
SELECT result FROM [table-list] GROUP BY [expr-list]
SELECT NAME, ADDRESS FROM StudentInfo GROUP BY NAME; NAME ADDRESS ---------- ---------- Dean California John Norway Johny Norway Mitch Houston Robin Norway SAM Texas
Všimněte si, že proces seskupování má dva kroky. Nejprve se výraz GROUP BY používá k uspořádání řádků tabulky do různých skupin. Jakmile jsou skupiny definovány, příkaz SELECT definuje, jak jsou tyto skupiny sloučeny do jednoho řádku.
- SQLite ORDER BY
Tabulky SQLite obecně ukládají data v nespecifikovaném pořadí a při načítání dat pomocí příkazu SQLite select vrátí záznamy ve stejném nespecifikovaném pořadí. V takových případech můžete použít klauzuli ORDER BY, která se používá k řazení záznamů ve sloupcích buď ve vzestupném nebo sestupném pořadí. V níže uvedeném příkladu jsem seskupil a seřadil9v sestupném pořadí) data na základě adresy.
Syntaxe
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Příklad
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS ORDER BY ADDRESS DESC; ADDRESS COUNT(ADDRESS) ---------- -------------- Texas 1 Norway 3 Houston 1 California 1
- HAVING BY SQLite
V SQLite MÍT klauzule je totožná s klauzulí WHERE doložka. Klauzule HAVING je další podmínkou aplikovanou poté, co dojde k agregaci společně se skupinou pomocí příkazu select. Obecně v SQLite, KDE klauzule se používá k aplikaci podmínky na jednotlivé prvky v tabulce a HAVING klauzule se používá k přidání podmínek filtru na základě skupin vytvořených klauzulí Seskupit podle.
Příklad
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- Ustanovení o omezení SQLite
V SQLite se klauzule LIMIT používá k nastavení limitu pro záznamy vrácené příkazem select. Podívejme se na příklad, abychom porozuměli konceptu.
Syntaxe
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Příklad
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET je volitelný a určuje, kolik řádků se má přeskočit na začátku sady výsledků na základě hodnota_offsetu .
- SQLite AND &OR
V SQLite se operátory AND &OR používají k provádění více podmínek u příkazů select, insert, update a delete na základě našich požadavků. Operátor SQLite AND vrátí řádky nebo záznamy, které splňují podmínky definované pomocí operátoru AND.
Příklad1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
Podmínka OR se používá k definování více podmínek v příkazech SQLite a vrátí řádky nebo záznamy z příkazu, pokud je splněna některá z podmínek.
Příklad 2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- Operátor SQLite GLOB
V SQLite se operátor GLOB používá ke kontrole, zda daná hodnota řetězce odpovídá konkrétnímu vzoru nebo ne. V případě, že se hodnota řetězce shoduje s hodnotou vzoru, vrátí hodnotu true a je podobný operátoru LIKE. GLOB také rozlišujevelká a malá písmena.
Syntaxe
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Příklad
SELECT *FROM StudentInfo WHERE NAME GLOB 'Joh*'; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 3 John 23 Norway 1 923******* 5 Johny 23 Norway 2 945*******
- Rozlišení SQLite
V SQLite klíčové slovo DISTINCT prohledá sadu výsledků příkazu SELECT a odstraní jakékoli duplicitní řádky. Hodnoty NULL se také považují za duplikáty, takže pokud použijeme klauzuli DISTINCT se sloupcem, který má hodnoty NULL, zachová pouze jeden řádek s hodnotou NULL. Když použijete DISTINCT pro více sloupců, vrátí příkaz každou jedinečnou kombinaci coulnm1 a sloupec 2.
Příklad
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- Operátor SQLite IN
V SQLite se operátor IN používá k určení, zda daná hodnota odpovídá seznamu daných hodnot nebo výsledku vrácenému poddotazem.
Příklad
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALL
V SQLite se operátor UNION používá ke kombinaci sad výsledků 2 nebo více příkazů SELECT a odstraní duplicitní řádky mezi různými příkazy SELECT. Pamatujte, že příkazy SELECT, které jsme použili s operátorem UNION, musí mít stejný počet polí ve výsledkových sadách s podobnými datovými typy.
Syntaxe
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Příklad
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
Operátor UNION ALL se používá ke kombinaci sad výsledků 2 nebo více příkazů SELECT a vrátí všechny řádky včetně duplikátů.
Příklad
SELECT DEPARTMENTID FROM StudentInfo UNION ALL SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 1 2 2 2 2 3 3 4 4 5
Tímto jsme pokryli nejzákladnější příkazy, které možná budete muset používat při práci s SQLite. Posuneme-li se v tomto tutoriálu SQLite vpřed, podívejme se na příkaz join v SQLite.
Připojí se k SQLite
V SQLite se spojení používají ke spojení záznamů ze dvou nebo více tabulek v databázi a získání záznamů na základě našich požadavků. Různé typy JOINS dostupné v SQLite jsou:
- Vnitřní spojení – INNER JOIN se používá ke kombinování a vracení pouze odpovídajících záznamů z vícenásobných tabulek na základě podmínek definovaných v příkazech SQLite.
- Vnější spojení – SQLite Outer Join vybere odpovídající řádky z více tabulek stejně jako Inner Join a některé další řádky mimo vztah. Zjednodušeně lze říci, že SQLite OUTER JOIN je doplňkem INNER JOIN. Obecně máme ve standardu SQL tři typy vnějších spojení, kterými jsou LEFT, RIGHT a FULL Outer Joins, ale SQLite podporuje pouze LEFT OUTER JOIN.
- Křížové připojení – Používá se k získání kartézského součinu řádků porovnáním každého řádku první tabulky s každým řádkem druhé tabulky.
- Vlastní připojení – Používá se ke spojení stejného stolu se sebou samým. Abychom mohli používat Self Join, musíme vytvořit různé názvy aliasů pro stejnou tabulku, aby bylo možné provádět operace na základě našich požadavků.
Koncept je podobný jako u jiných relačních databázových systémů, jako je SQL. Chcete-li se tedy dozvědět více, můžete se podívat na tento článek o SQL Joins.
Tímto jsme pokryli základní příkazy SQLite. Pokročilé koncepty zde nejsou zahrnuty. Takže zůstaňte naladěni na další článek o pokročilých konceptech SQLite. I přes všechny dobré funkce, které SQLite nabízí, má také určité nevýhody.
Výukový program SQLite:Nevýhody SQLite
Níže jsou uvedeny nevýhody používání SQLite:
- Nefunguje dobře v architektuře klient/server.
- Velikost databáze SQLite je ve většině případů omezena na 2 GB.
- SQLite neimplementovalo RIGHT OUTER JOIN a FULL OUTER JOIN. S SQLite můžeme implementovat pouze LEFT OUTER JOIN.
- Zobrazení v SQLite jsou pouze pro čtení. S Views nemůžeme používat příkazy DML (Insert, Update a Delete).
- S SQLite nemůžeme používat příkazy GRANT a REVOKE.
Tímto se dostáváme ke konci tohoto kurzu SQLite.
Pokud se chcete dozvědět více o MySQL a poznat tuto relační databázi s otevřeným zdrojovým kódem, podívejte se na naše školení certifikace MySQL DBA který přichází s instruktorem vedeným živým školením a reálnými zkušenostmi z projektů. Toto školení vám pomůže porozumět MySQL do hloubky a pomůže vám dosáhnout zvládnutí tohoto předmětu.
Máte na nás otázku? Zmiňte to prosím v sekci komentářů tohoto SQLite Tutoriálu a já se vám ozvu.