Als je met relationele databasesystemen hebt gewerkt, heb je waarschijnlijk gehoord van populaire databasesystemen zoals MySQL, SQL Server of PostgreSQL. SQLite is een ander uiterst nuttig RDBMS dat heel eenvoudig in te stellen en te bedienen is. Het heeft ook veel verschillende functies ten opzichte van andere relationele databases. Deze SQLite-zelfstudie leert basisconcepten die u moet kennen met behulp van uitgebreide praktische oefeningen.
De onderwerpen die in dit artikel worden besproken zijn:
- Wat is SQLite?
- Kenmerken van SQLite
- SQlite installeren op Windows
- SQLite-opdrachten
- Database-opdrachten
- Tabelopdrachten
- CRUD-bewerkingen
- SQLite-clausules/voorwaarden
- Doe mee aan SQLite
- Nadelen van SQLite
SQLite-zelfstudie:wat is SQLite?
Hier is de industriestandaarddefinitie van SQLite:
SQLite is een open-source, nulconfiguratie, op zichzelf staande, stand-alone, relationele database-engine voor transacties die is ontworpen om te worden ingebed in een toepassing.
U kunt overwegen SQLite als een “aansteker ” versie van een ander complex RDBMS (Oracle, SQL, etc.), waarbij de database-engine is geconfigureerd voor onafhankelijke verwerking (in-process bibliotheek) d.w.z. een serverloze, op zichzelf staande, nulconfiguratie en transactie- . Het staat bekend om zijn draagbaarheid, betrouwbaarheid en sterke prestaties, zelfs in omgevingen met weinig geheugen. SQLite is ook een populaire keuze als ingebedde database voor lokale/clientopslag in eindprogramma's of toepassingen, in tegenstelling tot andere RDBMS, waar de client-server DB-engine is geconfigureerd.
Kenmerken van SQLite
SQLite biedt veel verschillende functies, zoals:
- Serverloos: De meeste SQL-databases zijn geïmplementeerd als een apart serverproces, maar SQLite heeft geen apart serverproces. Het is een serverloze database-engine. Het leest en schrijft rechtstreeks naar gewone schijfbestanden.
- Nulconfiguratie: Het vereist geen configuratie om het te laten werken. Dit betekent dat er geen serverproces hoeft te worden gestart, gestopt of geconfigureerd zoals in een client-/serversysteem.
- Manifest typen: SQLite maakt gebruik van manifest-typering, waarmee elke hoeveelheid van elk gegevenstype in elke kolom kan worden opgeslagen, ongeacht het gedeclareerde gegevenstype van de kolom. Merk op dat er bepaalde uitzonderingen zijn op deze regel.
- Lichtgewicht: Zoals de naam al aangeeft, is de SQLite-bibliotheek erg licht van gewicht. Het punt is dat, hoewel de ruimte die het gebruikt varieert afhankelijk van het systeem waarop het is geïnstalleerd, het minder dan 600KiB aan ruimte in beslag kan nemen.
- Draagbaar: In tegenstelling tot andere DBMS wordt een volledige SQLite-database in één enkel bestand opgeslagen. Dit bestand kan heel gemakkelijk worden gedeeld via verwisselbare media of een protocol voor bestandsoverdracht.
- Diverse keuze: Veel programmeertalen bieden bindingen voor SQLite, waaronder C, C++, C#, Java, JavaScript, Ruby, Python en nog veel meer.
- Gratis: SQLite is gratis en open source. Om met SQLite te werken is geen commerciële licentie vereist.
Zoals hierboven vermeld staat SQLite bekend om zijn nulconfiguratie, wat betekent dat er geen complexe installatie of administratie nodig is. Laten we in het volgende deel van deze SQLite-zelfstudie kijken hoe u SQLite op uw systeem installeert.
SQLite-zelfstudie:SQLite installeren op Windows
De te volgen stappen zijn:
Stap1: Ga naar de officiële SQLite-website en klik op de geschikte link om voorgecompileerde binaire bestanden te downloaden.
Stap 2: Download het SQLite opdrachtregel zip-bestand (hier:sqlite-tools-win32-x86-3270200.zip) en vouw deze bestanden uit in een map naar keuze.
Deze SQLite-opdrachtregeltool bevat de volgende SQLite-producten
- SQLite-kern :De SQLite-kern bevat de eigenlijke database-engine en openbare API.
- SQLite3 opdrachtregelprogramma :De sqlite3-toepassing is een opdrachtregelprogramma dat bovenop de SQLite-kern is gebouwd.
- Tcl-extensie :Deze bibliotheek is in wezen een kopie van de SQLite-kern met de Tcl-bindingen eraan vastgemaakt.
- SQLite-analysetool :De SQLite-analysetool wordt gebruikt om databasebestanden te analyseren.
Stap3: Daarna is het starten van de SQLite-opdrachtregel net zo eenvoudig als klikken op de sqlite3-toepassing, waardoor de opdrachtregel verschijnt.
Als je verder wilt testen, typ je gewoon .help commando van sqlite> prompt om alle beschikbare commando's te zien in sqlite3 zoals hieronder getoond.
Opmerking: Standaard gebruikt een SQLite-sessie de in-memory database, daarom zijn alle wijzigingen verdwenen wanneer de sessie eindigt.
Simpel genoeg toch? Laten we dan beginnen met SQLite-opdrachten.
SQLite-zelfstudie:SQLite-opdrachten
Dit gedeelte van de SQLite-zelfstudie presenteert basis SQL-instructies die u met SQLite kunt gebruiken.
Opmerking: SQLite-opdrachten eindigen met een puntkomma (; ). Het vertelt SQLite dat uw opdracht compleet is en moet worden uitgevoerd. U kunt uw opdracht ook over meerdere regels spreiden en de puntkomma op de laatste regel gebruiken.
Database-opdrachten
Deze sectie bestaat uit die commando's, waarmee je met je database om kunt gaan. De commando's zijn:
- SQLite Database maken
SQLite gebruikt de CREATE DATABASE-instructie niet zoals in andere relationele databasebeheersystemen, zoals MySQL, SQL Server, enz. Om een nieuwe database in SQLite aan te maken, voert u gewoon sqlite3 in gevolgd door de naam van het bestand dat u voor de database wilt gebruiken. De volgende code maakt een databasebestand aan met de naam StudentDetails.db:
Voorbeeld
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- SQLite Attach Database
Als je meerdere databases hebt, kun je er maar één tegelijk gebruiken. In SQLite wordt de instructie ATTACH DATABASE gebruikt om een bepaalde database voor de huidige verbinding toe te voegen. Na deze opdracht worden alle SQLite-instructies uitgevoerd onder de bijgevoegde database.
Voorbeeld
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- SQLite Detach Database
In SQLite wordt de DETACH DATABASE-instructie gebruikt om de alias-naam database los te koppelen van een databaseverbinding die eerder was gekoppeld met behulp van de ATTACH-instructie. Als hetzelfde databasebestand met meerdere aliassen is bijgevoegd, zal deze opdracht alleen de opgegeven naam ontkoppelen en blijft de rest van de bijlage bestaan. De databases in de in-memory of tijdelijke database worden volledig vernietigd en de inhoud gaat verloren.
Voorbeeld
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
Tabelopdrachten
Hier zullen we leren hoe om te gaan met tabellen bij het gebruik van SQLite.
- SQL-tabel maken
In SQLite wordt de instructie CREATE TABLE gebruikt om een nieuwe tabel te maken. Tijdens het maken van de tabel moet u de tabel een naam geven en de kolom en gegevenstypen van elke kolom definiëren.
Syntaxis:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Voorbeeld
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) );
U kunt controleren of de tabel is gemaakt of niet door de .tables te gebruiken commando zoals hieronder getoond. Merk op dat ik al een tabel heb gemaakt met de naam DepartmentInfo waarbij DeptID de primaire sleutel is. De tabel Afdelingen heeft een beperking voor een externe sleutel voor de tabel Studenten.
sqlite> .tables StudentInfo Contacts Emp_Master
- SQLite-droptabel
In SQLite kunt u met de DROP TABLE-instructie een tabel uit de SQLite-database verwijderen of verwijderen. Zodra de tabel is verwijderd, worden alle gegevens die deze bevat permanent uit de database verwijderd. Alle bijbehorende indexen en triggers worden ook verwijderd. Als er een externe-sleutelbeperking is ingeschakeld voor die tabel, wordt die voor elke rij in de tabel op equivalente wijze verwijderd en worden alle triggers die aan de tabel zijn gekoppeld ook verwijderd.
Syntaxis
DROP TABLE [ IF EXISTS ] table_name;
Voorbeeld
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Opmerking: IF EXISTS, is een optionele clausule. Indien gespecificeerd, zal de DROP TABLE-instructie geen foutmelding geven als een van de tabellen niet bestaat.
Er is ook een SQLite Alter Table-instructie , die we in de volgende paragrafen van dit artikel zullen begrijpen. Nu we een tabel hebben gemaakt, gaan we kijken hoe u de gegevens kunt invoegen, verwijderen en wijzigen.
SQLite-zelfstudie:CRUD-bewerkingen
- SQLite-invoegquery
Na het aanmaken van de tabel kan het SQLite Insert Into commando gebruikt worden om nieuwe rijen in de gespecificeerde tabel te creëren. Er zijn twee betekenisvolle vormen van de SQLite insert-instructie. Het eerste formulier gebruikt een VALUES-clausule om een lijst met in te voegen waarden te specificeren.
Syntaxis
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Voorbeeld
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Uitvoer
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Hier wordt een enkele nieuwe rij gemaakt en wordt elke waarde in de respectievelijke kolom vastgelegd. Merk op dat beide lijsten de dezelfde . moeten hebben aantal stuks. Hier, de lijst van de kolommen is optioneel. We kunnen ook gegevens invoegen in de tabel zonder de lijst met kolommen op te geven .
Voorbeeld
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Uitvoer
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite biedt ook een functie om meerdere rijen in te voegen in een enkele INSERT-instructie. De syntaxis is zoals hieronder weergegeven.
Voorbeeld
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Uitvoer
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*******
Zoals je kunt zien, is het formaat van de uitvoer niet helemaal gelijk aan het vorige. Dus, hoe verander je het uitvoerformaat in SQLite? Laten we de uitvoer formatteren zodat onze resultaten wat gemakkelijker te lezen zijn.
- Opmaak
Je kunt .mode gebruiken om de uitvoermodus te wijzigen. Het bovenstaande voorbeeld gebruikt .mode lijst, die de resultaten als een lijst weergeeft. U kunt ook .headers . gebruiken statement om aan te geven of kolomkoppen wel of niet moeten worden weergegeven. Nadat u de wijzigingen heeft aangebracht, kunt u de instelling bekijken met .show commando.
Voorbeeld
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
Uitvoer
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
In SQLite wordt de Select-instructie gebruikt om gegevens uit een tabel op te halen, die gegevens in de vorm van een resultatentabel retourneert. Deze resultaattabellen worden ook resultaat sets genoemd. Met behulp van SQLite select-statement kunnen we eenvoudige berekeningen of meerdere expressies uitvoeren op basis van onze vereisten. We hebben al eerder een SELECT-instructie gebruikt toen we gegevens invoegden.
Syntaxis
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINCT – Wanneer we een onderscheidend trefwoord gebruiken in een select-statement, worden alleen afzonderlijke rijen met gegevens geretourneerd.
- ALLE – Als we het trefwoord ALL in een select-statement gebruiken, worden alle rijen met gegevens geretourneerd, zelfs als deze zijn gedupliceerd.
- VAN tabellijst – Het is een lijst met tabellen waaruit u gegevens wilt halen.
- WHERE-uitdrukking – De WHERE-expressie wordt gebruikt om onze aangepaste voorwaarden te definiëren om de vereiste gegevens uit tabellen te halen.
Voorbeeld1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Uitvoer
ID NAME ---------- ---------- 1 Dean
Voorbeeld2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Uitvoer
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- SQLite-updatequery
In SQLite kan de UPDATE-instructie worden gebruikt om de bestaande records in een tabel te wijzigen. De WHERE-clausule van SQLite kan worden gebruikt om precies aan te geven welke rijen moeten worden bijgewerkt. U kunt eenvoudig alle rijen, sommige of geen rijen bijwerken, afhankelijk van de filtervoorwaarden die door de WHERE-component worden toegepast.
Syntaxis
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Voorbeeld
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Uitvoer
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-query verwijderen
In SQLite kan de DELETE-instructie worden gebruikt om het record uit de tabel te verwijderen. U kunt eenvoudig alle rijen, sommige of geen rijen verwijderen, afhankelijk van de filtervoorwaarden die door de WHERE-component worden toegepast.
Voorbeeld
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Uitvoer
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Als u een record probeert te verwijderen waarnaar wordt verwezen door een externe sleutel, krijgt u een foutmelding. U moet eerst de externe sleutelrecords verwijderen, voordat u de primaire sleutelrecord verwijdert. Laten we proberen afdelingswetenschap te verwijderen.
Voorbeeld
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
We moeten dus de externe-sleutelrecords verwijderen voordat we de primaire sleutel verwijderen.
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 weet je hoe je de records in de SQLite Database-tabel moet bewerken. Verderop in deze SQLite-zelfstudieblog, laten we de verschillende clausules en voorwaarden bespreken die u het vaakst in SQLite tegenkomt.
SQLite-clausules/-voorwaarden
Voordat u aan de slag gaat met clausules, volgt hier de volledige syntaxis van de SELECT-instructie in SQLite.
Syntaxis
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]]
Opmerking:ik heb de tabellen StudentInfo en DepartmentInfo bijgewerkt zoals hieronder weergegeven.
//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 WAAR
In SQLite wordt de WHERE-component gebruikt om beperkingen op te leggen aan de SELECT-instructie door een of meer voorwaarden te definiëren om de vereiste gegevens uit tabellen in de database te halen. Als aan de opgegeven voorwaarde is voldaan of waar, wordt een specifieke waarde uit de tabel geretourneerd. Zoals je eerder hebt gezien, wordt de WHERE-clausule niet alleen gebruikt in de SELECT-instructie, maar ook in de UPDATE-, DELETE-instructie, enz.
Voorbeeld
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
In SQLite zijn er een aantal relationele operatoren die kunnen worden gebruikt met de WHERE-clausule.
- SQLite GROUP BY
In SQLite wordt de GROUP BY-component gebruikt om gegevens samen te voegen tot een enkele rij waarin de waarde van een of meer gespecificeerde kolommen wordt herhaald. Deze clausule wordt gebruikt met de WHERE-clausule in de SELECT-instructie en gaat vooraf aan de ORDER BY-clausule.
Syntaxis
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
Merk op dat het groeperingsproces twee stappen heeft. Ten eerste wordt de GROUP BY-expressie gebruikt om tabelrijen in verschillende groepen te rangschikken. Zodra de groepen zijn gedefinieerd, definieert de SELECT-instructie hoe die groepen worden samengevoegd tot een enkele rij.
- SQLite BESTELLEN DOOR
Over het algemeen slaan SQLite-tabellen gegevens op in niet-gespecificeerde volgorde en worden records in dezelfde niet-gespecificeerde volgorde geretourneerd terwijl gegevens worden opgehaald met behulp van SQLite select-instructie. In dergelijke gevallen kunt u de ORDER BY-component gebruiken om kolomrecords in oplopende of aflopende volgorde te sorteren. In het onderstaande voorbeeld heb ik de gegevens gegroepeerd en gerangschikt9in aflopende volgorde) op basis van het adres.
Syntaxis
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Voorbeeld
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 IS DOOR
In SQLite, de HAVING clausule is identiek aan WHERE clausule. De HAVING-clausule is een andere voorwaarde die wordt toegepast nadat de aggregatie samen met de group by in de select-instructie heeft plaatsgevonden. Over het algemeen in SQLite, WAAR clausule wordt gebruikt om een voorwaarde toe te passen op individuele elementen in een tabel en de HAVING clausule wordt gebruikt om filtervoorwaarden toe te voegen op basis van de groepen die zijn gemaakt door de clausule Group By.
Voorbeeld
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- SQLite-limietclausule
In SQLite wordt de LIMIT-component gebruikt om een limiet in te stellen voor de records die worden geretourneerd door de select-instructie. Laten we een voorbeeld bekijken om het concept te begrijpen.
Syntaxis
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Voorbeeld
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET is optioneel en bepaalt hoeveel rijen moeten worden overgeslagen aan het begin van de resultatenset op basis van offset_value .
- SQLite EN &OF
In SQLite worden de AND &OR-operatoren gebruikt om meerdere voorwaarden uit te voeren op select-, insert-, update- en delete-instructies op basis van onze vereisten. SQLite AND-operator retourneert rijen of records die voldoen aan de voorwaarden die zijn gedefinieerd met behulp van de AND-operator.
Voorbeeld1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
OR-voorwaarde wordt gebruikt om meerdere voorwaarden in SQLite-instructies te definiëren en het retourneert rijen of records uit de instructie als aan een van de voorwaarden is voldaan.
Voorbeeld2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- SQLite GLOB-operator
In SQLite wordt de GLOB-operator gebruikt om te controleren of de gegeven tekenreekswaarde overeenkomt met een specifiek patroon of niet. Als de tekenreekswaarde overeenkomt met de patroonwaarde, wordt deze true . geretourneerd en het is vergelijkbaar met de LIKE-operator. GLOB is ook hoofdlettergevoelig.
Syntaxis
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Voorbeeld
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 onderscheidend
In SQLite scant het DISTINCT-sleutelwoord de resultatenset van de SELECT-instructie en elimineert eventuele dubbele rijen. NULL-waarden worden ook als duplicaten beschouwd, dus als we de DISTINCT-clausule gebruiken met een kolom die NULL-waarden heeft, zal deze slechts één rij van een NULL-waarde behouden. Wanneer u DISTINCT voor meerdere kolommen toepast, retourneert de instructie elke unieke combinatie van coulnm1 en kolom2.
Voorbeeld
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- SQLite IN-operator
In SQLite wordt de IN-operator gebruikt om te bepalen of de gegeven waarde overeenkomt met een lijst met gegeven waarden of met het resultaat dat door de subquery wordt geretourneerd.
Voorbeeld
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALL
In SQLite wordt de UNION-operator gebruikt om de resultatensets van 2 te combineren of meer SELECT-instructies en het verwijdert dubbele rijen tussen de verschillende SELECT-instructies. Onthoud dat de SELECT-instructies die we hebben gebruikt met de UNION-operator hetzelfde aantal velden in de resultaatsets met vergelijkbare gegevenstypen moeten hebben.
Syntaxis
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Voorbeeld
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
De UNION ALL-operator wordt gebruikt om de resultaatsets van 2 of meer SELECT-instructies te combineren en retourneert alle rijen, inclusief de duplicaten.
Voorbeeld
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
Hiermee hebben we de meest elementaire commando's behandeld die u mogelijk moet gebruiken bij het werken met SQLite. Laten we met deze SQLite-zelfstudie eens kijken naar de join-instructie in SQLite.
Doe mee aan SQLite
In SQLite worden Joins gebruikt om records uit twee of meer tabellen in een database te combineren en records te krijgen op basis van onze vereisten. Verschillende soorten JOINS beschikbaar in SQLite zijn:
- Inner Join – INNER JOIN wordt gebruikt om alleen overeenkomende records uit meerdere tabellen te combineren en terug te sturen op basis van de voorwaarden die zijn gedefinieerd in SQLite-instructies.
- Outer Join – SQLite Outer Join zal overeenkomende rijen uit meerdere tabellen selecteren die hetzelfde zijn als Inner Join en enkele andere rijen buiten de relatie. In eenvoudige bewoordingen kunnen we zeggen dat SQLite OUTER JOIN een toevoeging is van INNER JOIN. Over het algemeen hebben we drie soorten Outer Joins in SQL-standaard, namelijk LEFT, RIGHT en FULL Outer Joins, maar SQLite ondersteunt alleen LEFT OUTER JOIN.
- Kruis deelnemen - Het wordt gebruikt om het Cartesiaanse product van rijen te krijgen door elke rij van de eerste tabel te matchen met elke rij van de tweede tabel.
- Zelf meedoen - Het wordt gebruikt om met zichzelf aan dezelfde tafel deel te nemen. Om Self Join te gebruiken, moeten we verschillende aliasnamen maken voor dezelfde tabel om bewerkingen uit te voeren op basis van onze vereisten.
Het concept is vergelijkbaar met dat van andere relationele databasesystemen zoals SQL. Voor meer informatie kunt u dit artikel over SQL Joins raadplegen.
Hiermee hebben we de basis SQLite-commando's behandeld. Geavanceerde concepten worden hier niet behandeld. Dus houd ons in de gaten voor een ander artikel over geavanceerde SQLite-concepten. Zelfs met alle goede eigenschappen die SQLite te bieden heeft, heeft het ook bepaalde nadelen.
SQLite-zelfstudie:nadelen van SQLite
Hieronder staan de nadelen van het gebruik van SQLite:
- Het werkt niet goed in de client/server-architectuur.
- De grootte van een SQLite-database is in de meeste gevallen beperkt tot 2 GB.
- SQLite heeft RIGHT OUTER JOIN en FULL OUTER JOIN niet geïmplementeerd. Met SQLite kunnen we alleen LEFT OUTER JOIN implementeren.
- Views in SQLite zijn alleen-lezen. We kunnen geen DML-instructies (invoegen, bijwerken en verwijderen) gebruiken met weergaven.
- We kunnen geen GRANT- en REVOKE-instructies gebruiken met SQLite.
Hiermee komen we tot een einde aan deze SQLite-zelfstudie.
Als je meer wilt weten over MySQL en deze open-source relationele database wilt leren kennen, bekijk dan onzeMySQL DBA-certificeringstraining die wordt geleverd met een door een instructeur geleide live training en real-life projectervaring. Deze training zal u helpen MySQL diepgaand te begrijpen en u te helpen het onderwerp onder de knie te krijgen.
Heeft u een vraag voor ons? Vermeld het alsjeblieft in het opmerkingengedeelte van deze SQLite-zelfstudie en ik zal contact met je opnemen.