Als u met relationele databasesystemen heeft gewerkt, heeft u waarschijnlijk wel eens gehoord van populaire databasesystemen zoals MySQL , Server of PostgreSQL . SQLite is een ander buitengewoon handig RDBMS dat heel eenvoudig is in te stellen en te bedienen. Het heeft ook veel verschillende kenmerken ten opzichte van andere relationele databases. Deze SQLite-tutorial leert basisconcepten die u moet kennen met behulp van uitgebreide praktische oefeningen.
De onderwerpen die in dit artikel worden besproken zijn:
SQLite-zelfstudie: wat is SQLite?
Hier is de standaarddefinitie van SQLite:
SQLite is een open-source, nul-configuratie, op zichzelf staande, stand-alone, relationele transactiedatabase-engine die is ontworpen om in een applicatie te worden ingebed.U kunt overwegen SQLite als een ' aansteker ”Versie van andere complexe RDBMS (Oracle, , etc.), waarvoor de database-engine is geconfigureerd onafhankelijke verwerking (in-process bibliotheek) d.w.z. een serverloos, op zichzelf staand, 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 embedded database voor lokale / client-opslag in eindprogramma's of applicaties, in tegenstelling tot andere RDBMS, waar de client-server DB-engine is geconfigureerd.
Kenmerken van SQLite
SQLite biedt veel verschillende functies, zoals:
- Serverloos: Meest SQL-databases worden geïmplementeerd als een afzonderlijk serverproces, maar SQLite heeft geen afzonderlijk serverproces. Het is een serverloze database-engine. Het leest en schrijft rechtstreeks naar gewone schijfbestanden.
- Nul-configuratie: Hetvereist 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 manifestypen, waardoor elke hoeveelheid van elk gegevenstype in elke kolom kan worden opgeslagen, ongeacht het opgegeven datatype van de kolom. Merk op dat er bepaalde uitzonderingen zijn op deze regel.
- Lichtgewicht: Zoals de naam impliceertis de SQLite-bibliotheek erg licht van gewicht. Het punt is dat, hoewel de gebruikte ruimte varieert afhankelijk van het systeem waarop het is geïnstalleerd, het minder dan 600 KB ruimte in beslag kan nemen.
- Draagbaar: In tegenstelling tot andere DBMS, eenvolledige SQLite-database wordt opgeslagen in een enkel bestand.Dit bestand kan heel gemakkelijk worden gedeeld via verwijderbare media of een protocol voor bestandsoverdracht.
- Diverse keuze: Veel programmeertalen bieden bindingen voor SQLite, inclusief , , C # , , , Robijn , , en nog veel meer.
- Vrij: SQLite is gratis en open-source. Om met SQLite te werken is een commerciële licentie niet vereist.
Zoals hierboven vermeld SQLitestaat 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 kunt installeren.
SQLite Tutorial: SQLite installeren op Windows
De te volgen stappen zijn:
Stap 1: Ga naar het officiële SQLite website en klik op de geschikte link om te downloadenvoorgecompileerde binaire bestanden.
Stap 2: Download het SQLite-opdrachtregelzipbestand (hier: sqlite-tools-win32-x86-3270200.zip) en vouw deze bestanden uit in een map naar keuze.
Deze SQLite-opdrachtregelhulpprogramma bevat de volgende SQLite-producten
- SQLite-kern : De SQLite-kern bevat de eigenlijke database-engine en openbare API.
- SQLite3-opdrachtregelprogramma : De sqlite3-applicatie 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 erop geplakt.
- SQLite-analyseprogramma : De SQLite-analysetool wordt gebruikt om databasebestanden te analyseren.
Stap 3: Daarna is het starten van de SQLite-opdrachtregel net zo eenvoudig als klikken op de sqlite3-applicatie, waardoor de opdrachtregel verschijnt.
Als je verder wilt testen, typ je gewoon .helpen commando van sqlite> prompt om alle beschikbare opdrachten 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 vervolgens aan de slag gaan met SQLite-opdrachten.
SQLite-zelfstudie: SQLite-opdrachten
Dit gedeelte van de SQLite-zelfstudie bevat eenvoudige 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 u met uw database kunt omgaan. De commando's zijn:
- SQLite Database maken
SQLite gebruikt de instructie CREATE DATABASE niet zoals in andere relationele databasebeheersystemen, zoals MySQL , SQL Server, enz. Om een nieuwe database in SQLite aan te maken, typt u simpelweg sqlite3 gevolgd door de naam van het bestand dat u voor de database wilt gebruiken. TDe volgende code maakt een databasebestand aan met de naam StudentDetails.db:
Voorbeeld
sqlite3 StudentDetails.db sqlite> .databases hoofd: D: sqliteStudentDetails.db
- SQLite Attach-database
Als u meerdere databases heeft, kunt u er maar één tegelijk gebruiken. In SQLite wordt de instructie ATTACH DATABASE gebruikt om een bepaalde database voor de huidige verbinding te koppelen. EENNa 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 Database loskoppelen
In SQLite wordt de instructie DETACH DATABASE gebruikt om de database met aliasnaam los te koppelen van een databaseverbinding die eerder was gekoppeld met behulp van de instructie ATTACH. Als hetzelfde databasebestand is bijgevoegd met meerdere aliassen, verbreekt deze opdracht alleen de opgegeven naam 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 Afdeling: D: sqliteDepartmentDetails.db Student: D: sqliteStudentDetails.db DeptInformation: D: sqliteDepartmentDetails.db sqlite> DETACH DETACHDETACHERING 'Department' sqlite> .database DATABASE 'Department' sqlite> .databases main: 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 Create Table
In SQLite wordt de instructie CREATE TABLE gebruikt om een nieuwe tabel te maken. Bij 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
TABEL MAKEN StudentInfo (ID INT PRIMAIRE SLEUTEL NIET NULL, NAAM TEKST NIET NULL, AGE INT NIET NULL, ADRESCHAR (50), DEPARTMENTID INTEGER NIET NULL, TELEFOONTEKST STANDAARD 'ONBEKEND', BUITENLANDSE SLEUTEL (DEPARTMENTID) REFERENTIES Afdelingsinfo (DeptID))
U kunt controleren of de tabel is gemaakt of niet door de .tafels commando zoals hieronder getoond. Merk op dat ik al een tabel heb gemaakt met de naam Afdelingsinfo waarbij DeptID de primaire sleutel is.De afdelingstabel heeft een beperking voor de buitenlandse sleutel voor de tabel Studenten.
sqlite> .tables StudentInfo Contacten Emp_Master
- SQLite Drop-tabel
In SQLite kunt u met de instructie DROP TABLE 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 voor die tabel een beperking met een externe sleutel is ingeschakeld, 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 [INDIEN BESTAAT] table_name
Voorbeeld
DROP TABLE Afdelingsfout: deze tabel bestaat niet: Afdeling DROP TABLE Bedrijf sqlite> .tables StudentInfo
Opmerking: INDIEN BESTAAT, is een optionele clausule. Indien gespecificeerd, zal de instructie DROP TABLE geen foutmelding geven als een van de tabellen niet bestaat.
Er is ook een SQLite Alter Table-instructie , die we in de volgende secties van dit artikel zullen begrijpen. Nu we een tabel hebben gemaakt, gaan we kijken hoe we de gegevens kunnen invoegen, verwijderen en wijzigen.
SQLite-zelfstudie: CRUD-bewerkingen
- SQLite Query invoegen
Na het maken van de tabel, kan de SQLite Insert Into-opdracht worden gebruikt om nieuwe rijen in de opgegeven tabel te maken. Er zijn twee betekenisvolle vormen van de SQLite-instructie insert. Het eerste formulier gebruikt een VALUES-clausule om een lijst met in te voegen waarden op te geven.
Syntaxis
INSERT INTO TABLE_NAME [(column1, column2, column3, ... columnN)] VALUES (value1, value2, value3, ... valueN)
Voorbeeld
INVOEGEN IN StudentInfo (ID, NAAM, LEEFTIJD, ADRES, DEPARTMENTID, TELEFOON) WAARDEN (1, 'Dean', 20, 'California', 2, '934 *******')
Uitvoer
SELECTEER * van StudentInfo ID NAAM LEEFTIJD ADRES VERTREK TELEFOON ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 Californië 2934 *******
Hier wordt een enkele nieuwe rij gemaakt en elke waarde wordt geregistreerd in de bijbehorende kolom. Merk op dat beide lijsten de dezelfde aantal stuks. Hier de lijst met kolommen is optioneel. We kunnen ook gegevens in de tabel invoegen zonder de lijst met kolommen op te geven .
Voorbeeld
INVOEGEN IN StudentInfo WAARDEN (2, 'SAM', 22, 'Texas', 2, '976 *******')
Uitvoer
SELECTEER * van StudentInfo ID NAAM LEEFTIJD ADRES VERTREK TELEFOON ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 Californië 2934 ******* 2 SAM 22 Texas 2976 *******
SQLite biedt ook een functie aan voeg meerdere rijen in in een enkele INSERT-instructie. De syntaxis is zoals hieronder weergegeven.
Voorbeeld
sessiebeheer in java webapplicatie
INVOEGEN IN StudentInfo WAARDEN (3, 'John', 23, 'Noorwegen', 1, '923 *******'), (4, 'Mitch', 22, 'Houston', 3, '934 ** ***** ')
Uitvoer
Selecteer * uit StudentInfo 1 | Dean | 20 | Californië | 2 | 934 ******* 2 | SAM | 22 | Texas | 2 | 976 ******* 3 | John | 23 | Noorwegen | 1 | 923 ******* 4 | Mitch | 22 | Houston | 3 | 934 *******
Zoals u kunt zien, lijkt het formaat van de uitvoer niet helemaal op het vorige. Dus, hoe verander je het formaat van de output in SQLite? Laten we de uitvoer zo formatteren dat onze resultaten wat gemakkelijker te lezen zijn.
- Vormen
U kunt .mode gebruiken om de uitvoermodus te wijzigen. Het bovenstaande voorbeeld gebruikt .mode lijst, waarin de resultaten als een lijst worden weergegeven. U kunt ook .headers instructie om aan te geven of kolomkoppen al dan niet moeten worden weergegeven. Nadat u de wijzigingen heeft aangebracht, kunt u de instelling bekijken met .tonen opdracht.
Voorbeeld
sqlite> .mode 'column' sqlite> .headers on sqlite> .show echo: off eqp: off verklaar: auto headers: on mode: column nullvalue: '' output: stdout colseparator: '|' rowseparator: 'n' stats: off width: filename: StudentDetails.db
Uitvoer
SELECTEER * UIT StudentInfo ID NAAM LEEFTIJD ADRES AFDELING TELEFOON ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 Californië 2934 ******* 2 SAM 22 Texas 2976 ******* 3 John 23 Noorwegen 1923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Select Query
In SQLite wordt de Select-instructie gebruiktom gegevens op te halen uit een tabel, die gegevens retourneert in de vorm van een resultaattabel. Deze resultaattabellen worden ook wel resultaat genoemd sets. Met behulp van SQLite select-instructie kunnen we eenvoudige berekeningen of meerdere expressies uitvoeren op basis van onze vereisten.We hebben al eerder een SELECT-instructie gebruikt bij het invoegen van gegevens.
Syntaxis
SELECTEER [ALLE | DISTINCT] resultaat [FROM table-list] [WHERE expr]
- DISTINCT - Wanneer we een onderscheidend sleutelwoord gebruiken in een select-instructie, retourneert het alleen verschillende rijen gegevens.
- ALLE - Als we het ALL-sleutelwoord gebruiken in een select-instructie, retourneert het alle rijen met gegevens, zelfs als deze zijn gedupliceerd.
- VAN tabel-lijst - Het is een lijst met tabellen waaruit u gegevens wilt halen.
- WAAR uitdrukking - De WHERE-expressie wordt gebruikt om onze aangepaste voorwaarden te definiëren om de vereiste gegevens uit tabellen te halen.
Voorbeeld 1
SELECTEER ID, NAAM UIT StudentInfo WAAR DE LEEFTIJD<21
Uitvoer
ID NAAM ---------- ---------- 1 Dean
Voorbeeld2
Selecteer NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology')
Uitvoer
// haalt mensen op van afdeling met ID 2 NAAM ---------- Dean SAM
- SQLite Update Query
In SQLite kan de instructie UPDATE 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 rijen of geen enkele bijwerken, afhankelijk van de filtervoorwaarden die worden toegepast door de WHERE-component.
Syntaxis
UPDATE tabelnaam SET kolom1 = waarde1, kolom2 = waarde2 ..., kolomN = waardeN WAAR [voorwaarde]
Voorbeeld
UPDATE StudentInfo SET DEPARTMENTID = 4 WAAR ID = '2'
Uitvoer
SELECTEER * UIT StudentInfo ID NAAM LEEFTIJD ADRES VERTREK TELEFOON ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 Californië 2934 ******* 2 SAM 22 Texas 4976 ******* 3 John 23 Noorwegen 1923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Query verwijderen
In SQLite kan de DELETE-instructie worden gebruikt om het record uit de tabel te verwijderen. U kunt eenvoudig alle rijen, enkele rijen of geen enkele verwijderen, afhankelijk van de filtervoorwaarden die worden toegepast door de WHERE-component.
Voorbeeld
VERWIJDEREN UIT DepartmentInfo WAAR DeptName = 'Science'
Uitvoer
SELECTEER * UIT Afdelingsinfo DeptID Afdelingsnaam ---------- ----------- 1 Wiskunde 2 Psychologie 3 Sport 4 Muziek
Als u een record probeert te verwijderen waarnaar wordt verwezen door een externe sleutel, krijgt u een foutmelding. U moet eerst de refererende-sleutelrecords verwijderen voordat u de primaire-sleutelrecord verwijdert. Laten we proberen de wetenschappelijke afdeling te verwijderen.
Voorbeeld
VERWIJDEREN UIT DepartmentInfo WHERE DeptName = 'Muziek'-fout: beperking FOREIGN KEY is mislukt
We moeten dus de records met externe sleutels verwijderen voordat we de primaire sleutel verwijderen.
VERWIJDEREN UIT StudentInfo WHERE DEPARTMENTID = 4 sqlite> VERWIJDEREN UIT DepartmentInfo WHERE DeptName = 'Muziek' sqlite> SELECTEER * UIT DepartmentInfo DeptID DeptName ---------- ----------- 1 Wiskunde 2 Psychologie 3 Sport SELECTEER * VAN StudentInfo ID NAAM LEEFTIJD ADRES VERTREK TELEFOON ---------- ---------- ---------- ------- --- ------------ ---------- 1 Dean 20 Californië 2934 ******* 3 John 23 Noorwegen 1923 ****** * 4 Mitch 22 Houston 3934 *******
Nu weet u hoe u de records in de SQLite Database-tabel moet bewerken. Laten we verder gaan in deze SQLite-zelfstudieblog en bespreken verschillende clausules en voorwaarden die u het vaakst tegenkomt in SQLite.
SQLite-clausules / voorwaarden
Voordat u aan de slag gaat met clausules, is hier de volledige syntaxis van de SELECT-instructie in SQLite.
Syntaxis
SELECTEER [ALLE | DISTINCT] resultaat [UIT tabellijst] [WAAR expr] [GROUP BY expr-lijst] [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.
// Studententafel ID NAAM LEEFTIJD ADRES VERTREK TELEFOON ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 Californië 2934 ******* 3 John 23 Noorwegen 1923 ******* 4 Mitch 22 Houston 3934 ******* 2 SAM 22 Texas 4976 ******* 5 Johny 23 Noorwegen 2945 ******* 6 Robin 23 Noorwegen 2 ONBEKEND // Afdelingsdetails DeptID DeptName - --------- ----------- 1 Wiskunde 2 Psychologie 3 Sport 4 Muziek 5 Wetenschap
- SQLite WAAR
In SQLite wordt de WHERE-clausule 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 voldaan of waar is, 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
KIES NAAM UIT StudentInfo WAAR AGE = 23NAME ---------- John Johny Robin
In SQLite zijn er een aantal relationele operatoren die kunnen worden gebruikt met de WHERE-component.
- SQLite GROEP OP
In SQLite wordt de GROUP BY-component gebruikt om gegevens samen te voegen tot een enkele rij waar de waarde van een of meer opgegeven kolommen wordt herhaald. Deze clausule wordt gebruikt met de WHERE-clausule in de SELECT-instructie en gaat vooraf aan de ORDER BY-clausule.
Syntaxis
SELECTEER resultaat UIT [table-list] GROUP BY [expr-list]
KIES NAAM, ADRES UIT StudentInfo GROEP OP NAAM NAAM ADRES ---------- ---------- Dean Californië John Noorwegen Johny Noorwegen Mitch Houston Robin Noorwegen SAM Texas
Merk op dat het groeperingsproces twee stappen heeft. Ten eerste wordt de GROUP BY-uitdrukking gebruikt om tabelrijen in verschillende groepen te rangschikken. Zodra de groepen zijn gedefinieerd, definieert de SELECT-instructie hoe die groepen worden afgevlakt tot een enkele rij.
- SQLite BESTEL DOOR
Over het algemeen slaan SQLite-tabellen gegevens op in niet-gespecificeerde volgorde en retourneert records in dezelfde niet-gespecificeerde volgorde tijdens het ophalen van gegevens met behulp van de SQLite select-instructie. In dergelijke gevallen kunt u de ORDER BY-clausule gebruiken om kolomrecords in oplopende of aflopende volgorde te sorteren. In het onderstaande voorbeeld heb ik de gegevens gegroepeerd en geordend9 in aflopende volgorde) op basis van het adres.
Syntaxis
SELECTEER expressies UIT tabellen-lijst [WAAR voorwaarden] ORDER BY kolom1, kolom2, ... [ASC | DESC]
Voorbeeld
SELECTEER ADRES, AANTAL (ADRES) UIT StudentInfo GROEP OP ADRES VOLGORDE OP ADRES DESC ADRESAANTAL (ADRES) ---------- -------------- Texas 1 Noorwegen 3 Houston 1 Californië 1
- SQLite BIJ
In SQLite is het HEBBEN clausule is identiek aan WAAR clausule. HAVING-clausule is een verdere voorwaarde die wordt toegepast nadat aggregatie samen met de group by in 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 ende HEBBEN clausule wordt gebruikt om filtervoorwaarden toe te voegen op basis van de groepen die zijn gemaakt door de clausule Group By.
Voorbeeld
SELECTEER ADRES, AANTAL (ADRES) UIT StudentInfo GROEP OP ADRES MET AANTAL (*)> 1 ADRESAANTAL (ADRES) ---------- -------------- Noorwegen 3
- SQLite Limit-clausule
In SQLite wordt de LIMIT-clausule gebruikt om een limiet in te stellen voor de records die door de select-instructie worden geretourneerd. Laten we een voorbeeld bekijken om het concept te begrijpen.
Syntaxis
SELECTEER uitdrukkingen UIT tabellenlijst [WHERE voorwaarden] LIMIT number_rows OFFSET offset_value
Voorbeeld
SELECTEER NAAM, ADRES UIT StudentInfo LIMIT 4 OFFSET 2 NAAM ADRES ---------- ---------- Mitch Houston SAM Texas Johny Noorwegen Robin Noorwegen
OFFSETis optioneel en definieert hoeveel rijen er aan het begin van de resultatenset moeten worden overgeslagen op basis van offset_waarde .
- SQLite EN & OF
In SQLite worden de EN- & OF-operators gebruikt om meerdere voorwaarden uit te voeren op instructies voor selecteren, invoegen, bijwerken en verwijderen op basis van onze vereisten. SQLite AND-operator retourneert rijen of records die voldoen aan de voorwaarden die zijn gedefinieerd met de AND-operator.
Voorbeeld 1
SELECTEER NAAM UIT StudentInfo WAAR AGE = 22 EN ADRES = 'Texas' NAAM ---------- SAM
OR-voorwaarde wordt gebruikt om meerdere voorwaarden in SQLite-instructies te definiëren en het zal rijen of records uit de instructie retourneren als aan een van de voorwaarden is voldaan.
Voorbeeld2
SELECTEER NAAM UIT StudentInfo WAAR (LEEFTIJD = 22 EN ADRES = 'Noorwegen') OF ADRES = 'Noorwegen' NAAM ---------- John Johny Robin
- SQLite GLOB-operator
In SQLite wordt de GLOB-operator gebruikt om te controleren of de opgegeven tekenreekswaarde overeenkomt met een specifiek patroon of niet. Als de tekenreekswaarde overeenkomt met de patroonwaarde, wordt deze geretourneerd waar en het is vergelijkbaar met de LIKE-operator. GLOB is ook hoofdlettergevoelig.
Syntaxis
SELECT * FROM tabelnaam WHERE kolomnaam GLOB 'zoekuitdrukking'
Voorbeeld
SELECTEER * UIT StudentInfo WAAR NAAM GLOB 'Joh *' ID NAAM LEEFTIJD ADRES VERTREK TELEFOON ---------- ---------- ---------- --- ------- ------------ ---------- 3 John 23 Noorwegen 1923 ******* 5 Johny 23 Noorwegen 2945 ** *****
- SQLite onderscheidend
In SQLite scant het trefwoord DISTINCT de resultatenset van de SELECT-instructie en verwijdert eventuele dubbele rijen. NULL-waarden beschouwen ook als duplicaten, dus als we de DISTINCT-clausule gebruiken met een kolom die NULL-waarden heeft, blijft er slechts één rij van een NULL-waarde behouden. Als u DISTINCT toepast op meerdere kolommen, retourneert de instructie elke unieke combinatie van coulnm1 en column2.
Voorbeeld
SELECTEER ONDERSCHEIDENDE LEEFTIJD UIT StudentInfo AGE ---------- 20 23 22
- SQLite IN-operator
In SQLite wordt de IN-operator gebruikt om te bepalen of de opgegeven waarde overeenkomt met een lijst met opgegeven waarden of met het resultaat dat door de subquery wordt geretourneerd.
Voorbeeld
SELECTEER NAAM UIT StudentInfo WAAR ADRES IN ('Texas', 'Houston') NAAM ---------- Mitch SAM- SQLite UNION & UNION ALL
In SQLite wordt de UNION-operator gebruikt om de resultaatsets van 2 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 resultatensets met vergelijkbare gegevenstypen moeten hebben.
Syntaxis
SELECT expression1, expression2, ... expression_n FROM tabellen [WHERE-voorwaarden] UNION / UNION ALL SELECT expression1, expression2, ... expression_n FROM tabellen [WHERE-voorwaarden]
Voorbeeld
SELECTEER DEPARTMENTID VAN StudentInfo UNION SELECTEER DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC DEPARTMENTID ------------ 1 2 3 4 5
De operator UNION ALL wordt gebruikt om de resultaatsets van 2 of meer SELECT-instructies te combineren en het retourneert alle rijen inclusief de duplicaten.
Voorbeeld
SELECTEER DEPARTMENTID UIT StudentInfo UNION ALLES SELECTEER DeptId VANAF DepartmentInfo BESTEL OP DEPARTMENTID ASC DEPARTMENTID ------------ 1 1 2 2 2 2 3 3 4 4 5
Hiermee hebben we de meest elementaire opdrachten behandeld die u mogelijk moet gebruiken bij het werken met SQLite. Laten we verder gaan met deze SQLite-zelfstudie, laten we eens kijken naar de join-instructie in SQLite.
Sluit zich aan bij SQLite
In SQLite zijn joinsgebruikt om records van twee of meer tabellen in een database te combineren en records op te halen op basis van onze vereisten. Different type JOINS beschikbaar in SQLite zijn:
- Innerlijke verbinding -INNER JOIN wordt gebruikt om alleen overeenkomende records uit tabellen met veelvouden te combineren en terug te sturen op basis van de voorwaarden die zijn gedefinieerd in SQLite-instructies.
- Outer Join -SQLite Outer Join selecteert overeenkomende rijen uit meerdere tabellen, hetzelfde als Innerlijke verbinding en enkele andere rijen buiten de relatie.In eenvoudige bewoordingen kunnen we SQLite zeggenBUITENKOMis een toevoeging vanBINNENKOM . Over het algemeen hebben we drie typen Outer Joins in SQL-standaard, namelijk LEFT, RIGHT en FULL Outer Joins, maar SQLite ondersteunt alleen LEFT OUTER JOIN.
- Cross Join -Het wordt gebruikt om het Cartesiaanse product van rijen te krijgendoor elke rij van de eerste tafel te matchen met elke rij van de tweede tafel.
- Zelf deelnemen - Hetwordt gebruikt om met zichzelf aan dezelfde tafel te zitten. Om Self Join te gebruiken, moeten we verschillende aliasnamen voor dezelfde tabel maken om bewerkingen uit te voeren op basis van onze vereisten.
Het concept is vergelijkbaar met dat van andere relationele databasesystemen zoals SQL. Dus voor meer informatie kunt u dit artikel raadplegen op .
Hiermee hebben we de basis SQLite-opdrachten behandeld. Geavanceerde concepten worden hier niet behandeld. Blijf dus op de hoogte voor nog een artikel over geavanceerde SQLite-concepten. Ondanks 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.
- Weergaven in SQLite zijn alleen-lezen. We kunnen geen DML-instructies (invoegen, bijwerken en verwijderen) gebruiken met weergaven.
- We kunnen de instructies GRANT en REVOKE niet gebruiken met SQLite.
Hiermee komen we een einde aan deze SQLite Tutorial.
Als u meer wilt weten over MySQL en maak kennis met deze open-source relationele database, bekijk dan onze die wordt geleverd met live training onder leiding van een instructeur en real-life projectervaring. Deze training zal je helpen MySQL diepgaand te begrijpen en je te helpen het onderwerp onder de knie te krijgen.
Heeft u een vraag voor ons? Vermeld het in het commentaargedeelte van deze SQLite-zelfstudie en ik neem zo spoedig mogelijk contact met u op.