Om du har arbetat med relationsdatabassystem är det troligt att du har hört talas om populära databassystem som MySQL, SQL Server eller PostgreSQL. SQLite är en annan extremt användbar RDBMS som är mycket enkel att installera och använda. Dessutom har den många distinkta funktioner jämfört med andra relationsdatabaser. Denna SQLite-handledning lär ut grundläggande begrepp som du behöver känna till med hjälp av omfattande praktiska metoder.
Ämnen som diskuteras i den här artikeln är:
- Vad är SQLite?
- Funktioner i SQLite
- Installera SQLite på Windows
- SQLite-kommandon
- Databaskommandon
- Tabellkommandon
- CRUD Operations
- SQLite-klausuler/villkor
- Gå med i SQLite
- Nackdelar med SQLite
SQLite Tutorial:Vad är SQLite?
Här är industristandarddefinitionen av SQLite:
SQLite är en öppen källkod, noll-konfiguration, fristående, fristående, transaktionsrelationsdatabasmotor designad för att bäddas in i en applikation.
Du kan överväga SQLite som en "tändare ” version av andra komplexa RDBMS (Oracle, SQL, etc.), där dess databasmotor är konfigurerad för oberoende bearbetning (i-process-bibliotek) d.v.s. en serverlös, fristående, nollkonfiguration och transaktions . Den är känd för sin bärbarhet, tillförlitlighet och starka prestanda även i miljöer med lågt minne. SQLite är också ett populärt val som en inbäddad databas för lokal/klientlagring i slutprogram eller applikationer, till skillnad från andra RDBMS, där klient-server DB-motorn är konfigurerad.
Funktioner i SQLite
SQLite erbjuder många distinkta funktioner som:
- Serverlös: De flesta SQL-databaser är implementerade som en separat serverprocess, men SQLite har ingen separat serverprocess. Det är en serverlös databasmotor. Den läser och skriver direkt till vanliga diskfiler.
- Nollkonfiguration: Den kräver ingen konfiguration för att få den igång. Det betyder att det inte finns någon serverprocess som behöver startas, stoppas eller konfigureras som i ett klient-/serversystem.
- Manifestskrivning: SQLite använder manifest typing, vilket tillåter lagring av valfri mängd av vilken datatyp som helst i vilken kolumn som helst, oavsett kolumnens deklarerade datatyp. Observera att det finns vissa undantag från denna regel.
- Lättvikt: Som namnet antyder är SQLite-biblioteket väldigt lätt. Saken är att även om utrymmet det använder varierar beroende på systemet där det är installerat, kan det ta upp mindre än 600 kB utrymme.
- Bärbar: Till skillnad från andra DBMS lagras en hel SQLite-databas i en enda fil. Den här filen kan delas via flyttbara media eller filöverföringsprotokoll mycket enkelt.
- Många val: Många programmeringsspråk tillhandahåller bindningar för SQLite, inklusive C, C++, C#, Java, JavaScript, Ruby, Python och många fler.
- Gratis: SQLite är gratis och öppen källkod. För att arbeta med SQLite krävs ingen kommersiell licens.
Som listat ovan är SQLite känt för sin nollkonfiguration vilket innebär att ingen komplex installation eller administration egentligen krävs. I nästa del av denna SQLite-handledning, låt oss se hur du installerar SQLite på ditt system.
SQLite självstudie:Installera SQLite på Windows
Stegen att följa är:
Steg 1: Gå till den officiella SQLite-webbplatsen och klicka på lämplig länk för att ladda ner förkompilerade binärer.
Steg 2: Ladda ner SQLites kommandoradszip-fil (här:sqlite-tools-win32-x86-3270200.zip) och expandera dessa filer i en valfri mapp.
Detta SQLite kommandoradsverktyg kommer att innehålla följande SQLite-produkter
- SQLite-kärna :SQLite-kärnan innehåller den faktiska databasmotorn och offentliga API.
- SQLite3 kommandoradsverktyg :sqlite3-applikationen är ett kommandoradsverktyg som är byggt ovanpå SQLite-kärnan.
- Tcl-tillägg :Det här biblioteket är i huvudsak en kopia av SQLite-kärnan med Tcl-bindningarna påsatta.
- SQLite analysverktyg :SQLite-analysverktyget används för att analysera databasfiler.
Steg 3: Efter det är det så enkelt att initiera SQLite-kommandoraden som att klicka på sqlite3-applikationen, vilket kommer att få kommandoraden att dyka upp.
Om du vill testa vidare, skriv bara .help kommando från sqlite> uppmaning för att se alla tillgängliga kommandon i sqlite3 som visas nedan.
Obs! Som standard använder en SQLite-session databasen i minnet, därför kommer alla ändringar att försvinna när sessionen slutar.
Enkelt nog? Låt oss sedan komma igång med SQLite-kommandon.
SQLite Handledning:SQLite-kommandon
Det här avsnittet av SQLite-handledningen presenterar grundläggande SQL-satser som du kan använda med SQLite.
Obs! SQLite-kommandon slutar med semikolon (; ). Det talar om för SQLite att ditt kommando är komplett och bör köras. Du kan också sprida ditt kommando över flera rader och använda semikolon på den sista raden.
Databaskommandon
Det här avsnittet består av de kommandon som du kan använda för din databas. Kommandona är:
- SQLite Skapa databas
SQLite använder inte CREATE DATABASE-satsen som i andra relationsdatabashanteringssystem, såsom MySQL, SQL Server, etc. För att skapa en ny databas i SQLite, skriv bara in sqlite3 följt med namnet på filen som du vill använda för databasen. Följande kod skapar en databasfil som heter StudentDetails.db:
Exempel
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- SQLite Attach Database
När du har flera databaser kan du bara använda en åt gången. I SQLite används ATTACH DATABASE-satsen för att bifoga en viss databas för den aktuella anslutningen. Efter detta kommando kommer alla SQLite-satser att köras under den bifogade databasen.
Exempel
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- SQLite Lossa databas
I SQLite används DETACH DATABASE-satsen för att koppla bort den alias-namnade databasen från en databasanslutning som tidigare bifogats med hjälp av ATTACH-satsen. Om samma databasfil har bifogats med flera alias, kommer detta kommando att koppla bort endast det angivna namnet och resten av bilagan kommer fortfarande att finnas kvar. Databaserna i minnet eller den temporära databasen kommer att förstöras helt och innehållet kommer att gå förlorat.
Exempel
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
Tabellkommandon
Här kommer vi att lära oss hur man hanterar tabeller när man använder SQLite.
- SQL Skapa tabell
I SQLite används CREATE TABLE-satsen för att skapa en ny tabell. När du skapar tabellen måste du namnge tabellen och definiera dess kolumn och datatyper för varje kolumn.
Syntax:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Exempel
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) );
Du kan kontrollera om tabellen skapades eller inte genom att använda .tables kommando som visas nedan. Observera att jag redan har skapat en tabell som heter DepartmentInfo där DeptID är den primära nyckeln. Tabellen Institutioner har en utländsk nyckel-begränsning till tabellen Studenter.
sqlite> .tables StudentInfo Contacts Emp_Master
- SQLite Drop Table
I SQLite låter DROP TABLE-satsen dig ta bort eller ta bort en tabell från SQLite-databasen. När tabellen har släppts tas all data den innehåller permanent bort från databasen. Eventuella associerade index och triggers tas också bort. Om det finns någon begränsning av främmande nyckel aktiverad i den tabellen, kommer det att tas bort på motsvarande sätt för varje rad i tabellen och alla utlösare som är kopplade till tabellen kommer också att tas bort.
Syntax
DROP TABLE [ IF EXISTS ] table_name;
Exempel
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Obs! OM FINNS, är en valfri klausul. Om det anges kommer DROP TABLE-satsen inte att ge upp ett fel om någon av tabellerna inte finns.
Det finns också en SQLite Alter Table-sats , som vi kommer att förstå i de kommande avsnitten av den här artikeln. Nu när vi har skapat en tabell, låt oss kolla in hur man infogar, tar bort och ändrar data.
SQLite Tutorial:CRUD Operations
- SQLite Insert Query
Efter att ha skapat tabellen kan SQLite Insert Into-kommandot användas för att skapa nya rader i den angivna tabellen. Det finns två meningsfulla former av SQLite insert-satsen. Den första formen använder en VALUES-sats för att specificera en lista med värden som ska infogas.
Syntax
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Exempel
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Utdata
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Här skapas en enda ny rad och varje värde registreras i sin respektive kolumn. Observera att båda listorna måste ha samma antal artiklar. Här är listan över kolumner är valfritt. Vi kan också infoga data i tabellen utan att ange listan med kolumner .
Exempel
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Utdata
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite erbjuder också en funktion för attinfoga flera rader i en enda INSERT-sats. Syntaxen är som visas nedan.
Exempel
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Utdata
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*******
Som du kan se är formatet på utdata inte riktigt likt det tidigare. Så, hur ändrar du formatet för utdata i SQLite? Låt oss formatera utdata så att våra resultat är lite lättare att läsa.
- Formatera
Du kan använda .mode för att ändra utdataläget. Exemplet ovan använder .mode list, som visar resultaten som en lista. Du kan också använda .headers uttalande för att ange om kolumnrubriker ska visas eller inte. När du har gjort ändringarna kan du se inställningen med .show kommando.
Exempel
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
Utdata
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*******
- SQLite Select Query
I SQLite används Select-satsen för att hämta data från en tabell, som returnerar data i form av en resultattabell. Dessa resultattabeller kallas även resultat-uppsättningar. Med hjälp av SQLite select-satsen kan vi utföra enkla beräkningar eller flera uttryck baserat på våra krav. Vi har redan använt en SELECT-sats tidigare när vi infogade data.
Syntax
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINKT – När vi använder distinkt nyckelord i en select-sats returnerar det endast distinkta rader med data.
- ALLA – Om vi använder nyckelordet ALL i en select-sats returnerar det alla rader med data även om det är duplicerat.
- FRÅN tabelllista – Det är en lista över tabeller som du vill hämta data från.
- WHERE-uttryck – WHERE-uttrycket används för att definiera våra anpassade villkor för att hämta nödvändig data från tabeller.
Exempel1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Utdata
ID NAME ---------- ---------- 1 Dean
Exempel2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Utdata
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- SQLite Update Query
I SQLite kan UPDATE-satsen användas för att modifiera befintliga poster i en tabell. WHERE-satsen i SQLite kan användas för att specificera exakt vilka rader som ska uppdateras. Du kan enkelt uppdatera alla rader, vissa rader eller inga, beroende på de filtreringsvillkor som tillämpas av WHERE-satsen.
Syntax
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Exempel
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Utdata
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
I SQLite kan DELETE-satsen användas för att ta bort posten från tabellen. Du kan enkelt ta bort alla rader, vissa rader eller ingen, beroende på de filtreringsvillkor som tillämpas av WHERE-satsen.
Exempel
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Utdata
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Om du försöker ta bort en post som refereras till av en främmande nyckel får du ett felmeddelande. Du måste först radera posterna med främmande nyckel innan du tar bort den primära nyckelposten. Låt oss försöka ta bort institutionen vetenskap.
Exempel
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Så vi måste ta bort de främmande nyckelposterna innan vi tar bort primärnyckeln.
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*******
Nu vet du hur du redigerar posterna i SQLite Database-tabellen. Om vi går vidare i denna SQLite-instruktionsblogg, låt oss diskutera olika klausuler och villkor som du oftast stöter på i SQLite.
SQLite-klausuler/villkor
Innan du börjar med satser, här är den fullständiga syntaxen för SELECT-satsen i SQLite.
Syntax
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]]
Obs:Jag har uppdaterat StudentInfo- och DepartmentInfo-tabellerna enligt nedan.
//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
- SQLite VAR
I SQLite används WHERE-satsen för att införa begränsningar för SELECT-satsen genom att definiera ett eller flera villkor för att hämta nödvändig data från tabeller i databasen. Om det angivna villkoret är uppfyllt eller sant returnerar det ett specifikt värde från tabellen. Som du har sett tidigare används WHERE-satsen inte bara i SELECT-satsen, utan den används också i UPDATE, DELETE-satsen, etc.
Exempel
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
I SQLite finns det ett antal relationsoperatorer som kan användas med WHERE-satsen.
- SQLite GROUP BY
I SQLite används GROUP BY-satsen för att aggregera data till en enda rad där värdet för en eller flera specificerade kolumner upprepas. Den här satsen används med WHERE-satsen i SELECT-satsen och föregår ORDER BY-satsen.
Syntax
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
Lägg märke till att grupperingsprocessen har två steg. Först används uttrycket GROUP BY för att ordna tabellrader i olika grupper. När grupperna väl har definierats, definierar SELECT-satsen hur dessa grupper plattas till en enda rad.
- SQLite BESTÄLL AV
Allmänt sett lagrar SQLite-tabeller data i ospecificerad ordning och det kommer att returnera poster i samma ospecificerade ordning medan data hämtas med SQLite select-satsen. I sådana fall kan du använda ORDER BY-satsen som används för att sortera kolumnposter antingen i stigande eller fallande ordning. I exemplet nedan har jag grupperat och ordnat9i fallande ordning) data baserat på adressen.
Syntax
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Exempel
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS ORDER BY ADDRESS DESC; ADDRESS COUNT(ADDRESS) ---------- -------------- Texas 1 Norway 3 Houston 1 California 1
- SQLite HAR AV
I SQLite är HAVING satsen är identisk med WHERE klausul. HAVING-sats är ett ytterligare villkor som tillämpas efter att aggregering äger rum tillsammans med gruppen genom in select-sats. Generellt i SQLite, WHERE sats används för att tillämpa ett villkor på enskilda element i en tabell och HAVING sats används för att lägga till filtervillkor baserat på grupperna som skapats av satsen Group By.
Exempel
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- SQLite-gränsklausul
I SQLite används LIMIT-satsen för att sätta en gräns för de poster som returneras av select-satsen. Låt oss överväga ett exempel för att förstå konceptet.
Syntax
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Exempel
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET är valfritt och den definierar hur många rader som ska hoppa över i början av resultatuppsättningen baserat på offset_value .
- SQLite OCH &ELLER
I SQLite används AND &OR-operatorerna för att utföra flera villkor för att välja, infoga, uppdatera och ta bort satser baserat på våra krav. SQLite AND-operatorn kommer att returnera rader eller poster som uppfyller de villkor som definieras med AND-operatorn.
Exempel1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
OR-villkor används för att definiera flera villkor i SQLite-satser och det kommer att returnera rader eller poster från satsen om något av ett villkor är uppfyllt.
Exempel2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- SQLite GLOB-operatör
I SQLite används GLOB-operatorn för att kontrollera om det givna strängvärdet matchar ett specifikt mönster eller inte. Om strängvärdet matchar mönstervärdet kommer det att returnera true och det liknar LIKE-operatören. Dessutom är GLOB skiftlägeskänslig.
Syntax
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Exempel
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*******
- SQLite Distinct
I SQLite kommer nyckelordet DISTINCT att skanna resultatuppsättningen av SELECT-satsen och eliminera alla dubbletter av rader. NULL-värden betraktas också som dubbletter, så om vi använder DISTINCT-satsen med en kolumn som har NULL-värden kommer den bara att behålla en rad med ett NULL-värde. När du använder DISTINCT för flera kolumner returnerar satsen varje unik kombination av coulnm1 och kolumn2.
Exempel
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- SQLite IN-operatör
I SQLite används IN-operatorn för att avgöra om det givna värdet matchar en lista med givna värden eller resultatet som returneras av underfrågan.
Exempel
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALLA
I SQLite används UNION-operatorn för att kombinera resultatuppsättningarna 2 eller fler SELECT-satser och det tar bort dubbletter av rader mellan de olika SELECT-satserna. Kom ihåg att SELECT-satserna som vi använde med UNION-operatorn måste ha samma antal fält i resultatuppsättningarna med liknande datatyper.
Syntax
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Exempel
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
UNION ALL-operatorn används för att kombinera resultatuppsättningarna av 2 eller fler SELECT-satser och den kommer att returnera alla rader inklusive dubbletter.
Exempel
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
Med detta har vi täckt de mest grundläggande kommandona som du kan behöva använda när du arbetar med SQLite. Gå vidare med denna SQLite-handledning, låt oss kolla in join-satsen i SQLite.
Gå med i SQLite
I SQLite används Joins för att kombinera poster från två eller flera tabeller i en databas och få poster baserat på våra krav. Olika typer av JOINS tillgängliga i SQLite är:
- Inner Join – INNER JOIN används för att kombinera och endast returnera matchande poster från multipla tabeller baserat på de villkor som definieras i SQLite-satser.
- Oter Join – SQLite Outer Join kommer att välja matchande rader från flera tabeller på samma sätt som Inner Join och några andra rader utanför förhållandet. Enkelt uttryckt kan vi säga att SQLite OUTER JOIN är ett tillägg av INNER JOIN. Generellt har vi tre typer av Outer Joins i SQL-standarden, de är LEFT, RIGHT och FULL Outer Joins, men SQLite stöder endast LEFT OUTER JOIN.
- Cross Join – Den används för att få den kartesiska produkten av rader genom att matcha varje rad i den första tabellen med varje rad i den andra tabellen.
- Gå med själv – Den används för att sammanfoga samma bord med sig själv. För att använda Self Join måste vi skapa olika aliasnamn för samma tabell för att utföra operationer baserat på våra krav.
Konceptet liknar det för andra relationsdatabassystem som SQL. Så för att veta mer kan du hänvisa till den här artikeln om SQL Joins.
Med detta har vi täckt de grundläggande SQLite-kommandona. Avancerade begrepp täcks inte här. Så håll utkik efter en annan artikel om avancerade SQLite-koncept. Även med alla de bra funktioner som SQLite har att erbjuda, har det vissa nackdelar också.
SQLite Handledning:Nackdelar med SQLite
Nedan listas nackdelarna med att använda SQLite:
- Det fungerar inte bra i klient/serverarkitektur.
- En SQLite-databasstorlek är begränsad till 2 GB i de flesta fall.
- SQLite har inte implementerat RIGHT OUTER JOIN och FULL OUTER JOIN. Med SQLite kan vi bara implementera LEFT OUTER JOIN.
- Vyer i SQLite är skrivskyddade. Vi kan inte använda DML-satser (infoga, uppdatera och ta bort) med vyer.
- Vi kan inte använda GRANT- och REVOKE-satser med SQLite.
Med detta kommer vi till ett slut på denna SQLite-handledning.
Om du vill lära dig mer om MySQL och lära känna denna relationsdatabas med öppen källkod, kolla in vår MySQL DBA-certifieringsutbildning som kommer med instruktörsledd liveutbildning och verklig projektupplevelse. Den här utbildningen hjälper dig att förstå MySQL på djupet och hjälper dig att behärska ämnet.
Har du en fråga till oss? Nämn det i kommentarsfältet i denna SQLite-handledning så återkommer jag till dig.