Hvis du har arbejdet med relationelle databasesystemer, er det sandsynligt, at du har hørt om populære databasesystemer som f.eks. MySQL, SQL Server eller PostgreSQL. SQLite er en anden ekstremt nyttig RDBMS, der er meget enkel at konfigurere og betjene. Det har også mange forskellige funktioner i forhold til andre relationelle databaser. Denne SQLite-tutorial lærer dig grundlæggende begreber, som du har brug for at kende ved hjælp af omfattende praktisk praksis.
Emnerne diskuteret i denne artikel er:
- Hvad er SQLite?
- Funktioner i SQLite
- Installation af SQLite på Windows
- SQLite-kommandoer
- Databasekommandoer
- Tabelkommandoer
- CRUD-operationer
- SQLite-klausuler/betingelser
- Deltager i SQLite
- Ulemper ved SQLite
SQLite Tutorial:Hvad er SQLite?
Her er industristandarddefinitionen af SQLite:
SQLite er en open source, nul-konfiguration, selvstændig, selvstændig, transaktionsrelationsdatabasemotor designet til at blive indlejret i en applikation.
Du kan overveje SQLite som en "lighter ” version af andre komplekse RDBMS (Oracle, SQL osv.), hvor dens databasemotor er konfigureret til uafhængig behandling (i-proces bibliotek) dvs. en serverløs, selvstændig, nulkonfiguration og transaktionsmæssig . Den er kendt for sin bærbarhed, pålidelighed og stærke ydeevne selv i miljøer med lav hukommelse. SQLite er også et populært valg som en indlejret database til lokal/klientlagring i slutprogrammer eller applikationer, i modsætning til andre RDBMS, hvor klient-server DB-motoren er konfigureret.
Funktioner i SQLite
SQLite tilbyder mange forskellige funktioner såsom:
- Serverløs: De fleste SQL-databaser er implementeret som en separat serverproces, men SQLite har ikke en separat serverproces. Det er en serverløs databasemotor. Den læser og skriver direkte til almindelige diskfiler.
- Nulkonfiguration: Det kræver ingen konfiguration for at få det til at køre. Det betyder, at der ikke er nogen serverproces, der skal startes, stoppes eller konfigureres som i et klient-/serversystem.
- Manifestskrivning: SQLite bruger manifest typing, som tillader lagring af enhver mængde af enhver datatype i enhver kolonne uden uanset kolonnens erklærede datatype. Bemærk, at der er visse undtagelser fra denne regel.
- Letvægt: Som navnet antyder, er SQLite-biblioteket meget let. Sagen er, at selvom den plads, den bruger, varierer afhængigt af systemet, hvor den er installeret, kan den optage mindre end 600 KB plads.
- Bærbar: I modsætning til andre DBMS er en hel SQLite-database gemt i en enkelt fil. Denne fil kan meget nemt deles via flytbare medier eller filoverførselsprotokol.
- Forskellige valgmuligheder: Mange programmeringssprog giver bindinger til SQLite, inklusive C, C++, C#, Java, JavaScript, Ruby, Python og mange flere.
- Gratis: SQLite er gratis og open source. For at arbejde med SQLite kræves der ikke en kommerciel licens.
Som angivet ovenfor er SQLite kendt for sin nul-konfiguration, hvilket betyder, at ingen kompleks opsætning eller administration er virkelig påkrævet. Lad os se, hvordan du installerer SQLite på dit system i den næste del af denne SQLite-tutorial.
SQLite-vejledning:Installation af SQLite på Windows
De trin, der skal følges, er:
Trin 1: Gå til det officielle SQLite-websted, og klik på det passende link for at downloade prækompilerede binære filer.
Trin 2: Download SQLite-kommandolinje-zip-filen (her:sqlite-tools-win32-x86-3270200.zip) og udvid disse filer i en mappe efter eget valg.
Dette SQLite-kommandolinjeværktøj vil indeholde følgende SQLite-produkter
- SQLite-kerne :SQLite-kernen indeholder den faktiske databasemotor og offentlige API.
- SQLite3 kommandolinjeværktøj :sqlite3-applikationen er et kommandolinjeværktøj, der er bygget oven på SQLite-kernen.
- Tcl-udvidelse :Dette bibliotek er i det væsentlige en kopi af SQLite-kernen med Tcl-bindingerne sat på.
- SQLite analysatorværktøj :SQLite-analysatorværktøjet bruges til at analysere databasefiler.
Trin 3: Derefter er initiering af SQLite-kommandolinjen så simpelt som at klikke på sqlite3-applikationen, hvilket vil få kommandolinjen til at poppe op.
Hvis du vil teste yderligere, skal du blot skrive .help kommando fra sqlite> prompt for at se alle tilgængelige kommandoer i sqlite3 som vist nedenfor.
Bemærk: Som standard bruger en SQLite-session databasen i hukommelsen, derfor vil alle ændringer være væk, når sessionen slutter.
Simpelt nok ikke? Lad os derefter komme i gang med SQLite-kommandoer.
SQLite-vejledning:SQLite-kommandoer
Dette afsnit af SQLite-selvstudiet præsenterer grundlæggende SQL-sætninger, som du kan bruge med SQLite.
Bemærk: SQLite-kommandoer slutter med semikolon (; ). Det fortæller SQLite, at din kommando er fuldført og skal køres. Du kan også sprede din kommando over flere linjer og bruge semikolon på den sidste linje.
Databasekommandoer
Denne sektion består af de kommandoer, som du kan bruge til din database. Kommandoerne er:
- SQLite Opret database
SQLite bruger ikke CREATE DATABASE-sætningen som i andre relationelle databasestyringssystemer, såsom MySQL, SQL Server osv. For at oprette en ny database i SQLite skal du blot indtaste sqlite3 efterfulgt ved navnet på den fil, du ønsker at bruge til databasen. Følgende kode opretter en databasefil kaldet StudentDetails.db:
Eksempel
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- SQLite Attach Database
Når du har flere databaser, kan du kun bruge én ad gangen. I SQLite bruges ATTACH DATABASE-sætningen til at vedhæfte en bestemt database til den aktuelle forbindelse. Efter denne kommando vil alle SQLite-sætninger blive udført under den vedhæftede database.
Eksempel
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- SQLite Frigør database
I SQLite bruges DETACH DATABASE-sætningen til at frakoble den alias-navngivne database fra en databaseforbindelse, der tidligere var tilknyttet ved at bruge ATTACH-sætningen. Hvis den samme databasefil er blevet vedhæftet med flere aliaser, afbryder denne kommando kun det givne navn, og resten af den vedhæftede fil vil stadig eksistere. Databaserne i hukommelsen eller den midlertidige database vil blive fuldstændig ødelagt, og indholdet vil gå tabt.
Eksempel
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
Tabelkommandoer
Her vil vi lære, hvordan du håndterer tabeller, når du bruger SQLite.
- SQL-opret tabel
I SQLite bruges CREATE TABLE-sætningen til at oprette en ny tabel. Mens du opretter tabellen, skal du navngive tabellen og definere dens kolonne og datatyper for hver kolonne.
Syntaks:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Eksempel
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 kontrollere, om tabellen er oprettet eller ej, ved at bruge .tables kommando som vist nedenfor. Bemærk, at jeg allerede har oprettet en tabel kaldet Afdelingsinfo hvor DeptID er den primære nøgle. Afdelingstabellen har en fremmednøglebegrænsning til tabellen Studenter.
sqlite> .tables StudentInfo Contacts Emp_Master
- SQLite Drop Table
I SQLite giver DROP TABLE-sætningen dig mulighed for at fjerne eller slette en tabel fra SQLite-databasen. Når tabellen er slettet, fjernes alle de data, den indeholder, permanent fra databasen. Eventuelle tilknyttede indekser og triggere fjernes også. Hvis der er en fremmednøgle-begrænsning aktiveret på den tabel, vil det fjerne tilsvarende for hver række i tabellen, og alle triggere, der er knyttet til tabellen, vil også blive slettet.
Syntaks
DROP TABLE [ IF EXISTS ] table_name;
Eksempel
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Bemærk: HVIS FINNES, er en valgfri klausul. Hvis angivet, vil DROP TABLE-sætningen ikke give en fejl, hvis en af tabellerne ikke eksisterer.
Der er også en SQLite Alter Table-sætning , som vi vil forstå i de næste par afsnit af denne artikel. Nu hvor vi har oprettet en tabel, lad os se, hvordan du indsætter, sletter og ændrer dataene.
SQLite-vejledning:CRUD-operationer
- SQLite Indsæt forespørgsel
Efter oprettelse af tabellen kan SQLite Insert Into-kommandoen bruges til at oprette nye rækker i den angivne tabel. Der er to meningsfulde former for SQLite insert-sætningen. Den første form bruger en VALUES-sætning til at angive en liste over værdier, der skal indsættes.
Syntaks
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Eksempel
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Output
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Her oprettes en enkelt ny række, og hver værdi registreres i dens respektive kolonne. Bemærk, at begge lister skal have det samme antal stk. Her er listen over kolonnerne er valgfri. Vi kan også indsætte data i tabellen uden at angive listen over kolonner .
Eksempel
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Output
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite tilbyder også en funktion til atindsætte flere rækker i en enkelt INSERT-sætning. Syntaksen er som vist nedenfor.
Eksempel
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Output
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, er formatet af output ikke helt det samme som det før. Så hvordan ændrer du outputformatet i SQLite? Lad os formatere outputtet, så vores resultater er lidt nemmere at læse.
- Formater
Du kan bruge .mode til at ændre outputtilstanden. Ovenstående eksempel bruger .mode liste, som viser resultaterne som en liste. Du kan også bruge .headers sætning for at angive, om kolonneoverskrifter skal vises eller ej. Når du har foretaget ændringerne, kan du se indstillingen ved hjælp af .show kommando.
Eksempel
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
Output
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 bruges Select-sætningen til at hente data fra en tabel, som returnerer data i form af en resultattabel. Disse resultattabeller kaldes også resultatsæt. Ved hjælp af SQLite select-sætning kan vi udføre simple beregninger eller flere udtryk baseret på vores krav. Vi har allerede tidligere brugt en SELECT-sætning, da vi indsatte data.
Syntaks
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINK – Når vi bruger distinkt søgeord i en select-sætning, returnerer det kun distinkte rækker af data.
- ALLE – Hvis vi bruger ALL søgeord i en select-sætning, returnerer det alle rækker af data, selvom det er duplikeret.
- FRA tabelliste – Det er en liste over tabeller, som du ønsker at hente data fra.
- WHERE-udtryk – WHERE-udtrykket bruges til at definere vores brugerdefinerede betingelser for at hente de nødvendige data fra tabeller.
Eksempel1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Output
ID NAME ---------- ---------- 1 Dean
Eksempel 2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Output
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- SQLite-opdateringsforespørgsel
I SQLite kan UPDATE-sætningen bruges til at ændre de eksisterende poster i en tabel. WHERE-sætningen i SQLite kan bruges til at specificere præcis, hvilke rækker der skal opdateres. Du kan nemt opdatere alle rækker, nogle rækker eller ingen, afhængigt af de filtreringsbetingelser, der anvendes af WHERE-sætningen.
Syntaks
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Eksempel
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Output
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 Slet forespørgsel
I SQLite kan DELETE-sætningen bruges til at slette posten fra tabellen. Du kan nemt slette alle rækker, nogle rækker eller ingen, afhængigt af de filtreringsbetingelser, der anvendes af WHERE-sætningen.
Eksempel
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Output
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Hvis du forsøger at slette en post, der refereres til af en fremmednøgle, får du en fejl. Du skal først slette de fremmednøgleposter, før du sletter den primære nøglepost. Lad os prøve at slette afdelingsvidenskab.
Eksempel
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Så vi er nødt til at slette de fremmede nøgleposter, før vi sletter den primære nøgle.
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 ved du, hvordan du redigerer posterne i SQLite-databasetabellen. Gå videre i denne SQLite tutorial blog, lad os diskutere forskellige klausuler og betingelser, som du oftest støder på i SQLite.
SQLite-klausuler/betingelser
Før du går i gang med klausuler, er her den komplette syntaks for SELECT-sætningen i SQLite.
Syntaks
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]]
Bemærk:Jeg har opdateret StudentInfo- og DepartmentInfo-tabellerne som vist nedenfor.
//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 HVOR
I SQLite bruges WHERE-sætningen til at pålægge begrænsninger på SELECT-sætningen ved at definere en eller flere betingelser for at få de nødvendige data fra tabeller i databasen. Hvis den angivne betingelse er opfyldt eller sand, returnerer den specifik værdi fra tabellen. Som du har set før, bruges WHERE-sætningen ikke kun i SELECT-sætningen, men den bruges også i UPDATE, DELETE-sætning osv.
Eksempel
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
I SQLite er der en række relationelle operatorer, der kan bruges med WHERE-sætningen.
- SQLite GROUP BY
I SQLite bruges GROUP BY-sætningen til at aggregere data i en enkelt række, hvor værdien af en eller flere specificerede kolonner gentages. Denne klausul bruges sammen med WHERE-sætningen i SELECT-sætningen og går forud for ORDER BY-sætningen.
Syntaks
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
Bemærk, at grupperingsprocessen har to trin. Først bruges GROUP BY-udtrykket til at arrangere tabelrækker i forskellige grupper. Når grupperne er defineret, definerer SELECT-sætningen, hvordan disse grupper fladtes ned til en enkelt række.
- SQLite BESTIL EFTER
Generelt lagrer SQLite-tabeller data i uspecificeret rækkefølge, og det vil returnere poster i samme uspecificerede rækkefølge, mens de henter data ved hjælp af SQLite select-sætning. I sådanne tilfælde kan du bruge ORDER BY-udtrykket, der bruges til at sortere kolonneposter enten i stigende eller faldende rækkefølge. I eksemplet nedenfor har jeg grupperet og ordnet 9 i faldende rækkefølge) dataene baseret på adressen.
Syntaks
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Eksempel
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 HAVING AF
I SQLite er HAVING klausulen er identisk med WHERE klausul. HAVING-klausul er en yderligere betingelse, der anvendes, efter at aggregering finder sted sammen med gruppen ved i select-sætning. Generelt i SQLite, WHERE klausul bruges til at anvende en betingelse på individuelle elementer i en tabel og HAVING klausul bruges til at tilføje filterbetingelser baseret på grupperne oprettet af Group By-klausul.
Eksempel
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- SQLite-grænseklausul
I SQLite bruges LIMIT-udtrykket til at sætte en grænse for de poster, der returneres af select-sætningen. Lad os overveje et eksempel for at forstå konceptet.
Syntaks
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Eksempel
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET er valgfrit, og det definerer, hvor mange rækker der skal springes over i begyndelsen af resultatsættet baseret på offset_value .
- SQLite OG &ELLER
I SQLite bruges AND &OR-operatorerne til at udføre flere betingelser for at vælge, indsætte, opdatere og slette sætninger baseret på vores krav. SQLite AND-operator vil returnere rækker eller poster, der opfylder de betingelser, der er defineret ved at bruge AND-operatoren.
Eksempel1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
ELLER-betingelsen bruges til at definere flere betingelser i SQLite-sætninger, og den vil returnere rækker eller poster fra sætningen, hvis en af betingelserne er opfyldt.
Eksempel 2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- SQLite GLOB-operatør
I SQLite bruges GLOB-operatoren til at kontrollere, om den givne strengværdi matcher et specifikt mønster eller ej. Hvis strengværdien matcher mønsterværdien, vil den returnere true og det ligner LIKE-operatøren. Desuden er GLOB følsomme mellem store og små bogstaver.
Syntaks
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Eksempel
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 vil nøgleordet DISTINCT scanne resultatsættet af SELECT-sætningen og eliminere eventuelle duplikerede rækker. NULL-værdier betragtes også som dubletter, så hvis vi bruger DISTINCT-sætningen med en kolonne, der har NULL-værdier, vil den kun beholde en række af en NULL-værdi. Når du anvender DISTINCT for flere kolonner, returnerer sætningen hver unik kombination af coulnm1 og kolonne 2.
Eksempel
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- SQLite IN-operatør
I SQLite bruges IN-operatoren til at bestemme, om den givne værdi matcher en liste over givne værdier eller resultatet returneret af underforespørgslen.
Eksempel
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALL
I SQLite bruges UNION-operatoren til at kombinere resultatsættene af 2 eller flere SELECT-sætninger, og det fjerner duplikerede rækker mellem de forskellige SELECT-sætninger. Husk, at SELECT-sætningerne, som vi brugte med UNION-operatoren, skal have det samme antal felter i resultatsættene med lignende datatyper.
Syntaks
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Eksempel
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
UNION ALL-operatoren bruges til at kombinere resultatsættene af 2 eller flere SELECT-sætninger, og den vil returnere alle rækkerne inklusive dubletterne.
Eksempel
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 dette har vi dækket de mest grundlæggende kommandoer, som du muligvis skal bruge, når du arbejder med SQLite. Lad os gå videre med denne SQLite-tutorial, og lad os se join-sætningen i SQLite.
Deltager i SQLite
I SQLite bruges Joins til at kombinere poster fra to eller flere tabeller i en database og få poster baseret på vores krav. Forskellige typer JOINS tilgængelige i SQLite er:
- Indre deltagelse – INNER JOIN bruges til kun at kombinere og returnere matchende poster fra multiple tabeller baseret på betingelserne defineret i SQLite-sætninger.
- Outer Join – SQLite Outer Join vil vælge matchende rækker fra flere tabeller på samme måde som Inner Join og nogle andre rækker uden for forholdet. Enkelt sagt kan vi sige, at SQLite OUTER JOIN er en tilføjelse af INNER JOIN. Generelt har vi tre typer Outer Joins i SQL-standarden, de er LEFT, RIGHT og FULL Outer Joins, men SQLite understøtter kun LEFT OUTER JOIN.
- Cross Join – Det bruges til at få det kartesiske produkt af rækker ved at matche hver række i den første tabel med hver række i den anden tabel.
- Tilmeld dig selv – Det bruges til at forbinde det samme bord med sig selv. For at bruge Self Join skal vi oprette forskellige aliasnavne til den samme tabel for at udføre operationer baseret på vores krav.
Konceptet ligner det for andre relationelle databasesystemer som SQL. Så for at vide mere kan du henvise til denne artikel om SQL Joins.
Med dette har vi dækket de grundlæggende SQLite-kommandoer. Avancerede begreber er ikke dækket her. Så følg med for endnu en artikel om avancerede SQLite-koncepter. Selv med alle de gode funktioner, som SQLite har at tilbyde, har det også visse ulemper.
SQLite Tutorial:Ulemper ved SQLite
Nedenstående er ulemperne ved at bruge SQLite:
- Det fungerer ikke godt i klient/serverarkitektur.
- En SQLite-databasestørrelse er begrænset til 2 GB i de fleste tilfælde.
- SQLite har ikke implementeret RIGHT OUTER JOIN og FULL OUTER JOIN. Med SQLite kan vi kun implementere LEFT OUTER JOIN.
- Visninger i SQLite er skrivebeskyttede. Vi kan ikke bruge DML-sætninger (Indsæt, Opdater og Slet) med Views.
- Vi kan ikke bruge GRANT- og REVOKE-sætninger med SQLite.
Med dette kommer vi til en ende på denne SQLite-tutorial.
Hvis du ønsker at lære mere om MySQL og lære denne open source relationsdatabase at kende, så tjek vores MySQL DBA Certification Training som kommer med instruktørledet livetræning og projekterfaring i det virkelige liv. Denne træning vil hjælpe dig med at forstå MySQL i dybden og hjælpe dig med at opnå beherskelse over emnet.
Har du et spørgsmål til os? Nævn det i kommentarfeltet i denne SQLite-vejledning, så vender jeg tilbage til dig.