SQLite INSERT, UPDATE, DELETE Query met voorbeeld
Marcus Allen
De gegevenswijzigingsclausules in SQLite zijn INSERT-, UPDATE- en DELETE-instructies. Het wordt gebruikt voor het invoegen van nieuwe rijen, het bijwerken van bestaande waarden of het verwijderen van rijen uit de database.
Houd er rekening mee dat u voor alle onderstaande voorbeelden sqlite3.exe moet uitvoeren en een verbinding met de voorbeeld-database moet openen als volgt:
Stap 1) In deze stap,
- Open Deze computer en navigeer naar de volgende map:C:\sqlite"En
- Open vervolgens “sqlite3.exe"
Stap 2) Open de databank “ZelfstudiesSampleDB.db" door het volgende commando:
.open TutorialsSampleDB.db
Nu bent u klaar om elk type query op de database uit te voeren.
SQLite INSERT
SQLite INSERT wordt gebruikt om records in een opgegeven tabel van de database in te voegen. u moet de clausule 'INSERT' gebruiken. De syntaxis van de INSERT-clausule is als volgt:
- Na de INSERT-clausule moet u aangeven in welke tabel u de waarden moet invoegen.
- Na de tabelnaam schrijft u de lijst met kolommen waarin u de waarden wilt invoegen.
- U kunt de kolomnaam negeren en er niet naar schrijven.
- Als u de naam van de kolom niet opgeeft, worden de waarden in dezelfde volgorde ingevoegd in alle kolommen in de tabel. De kolommen zijn gedefinieerd in de tabel.
- Na de VALUES-clausule moet u de waarden vermelden die moeten worden ingevoegd.
- Elke INSERT-clausule voegt slechts één rij in. Als u meerdere rijen wilt invoegen, moet u meerdere INSERT-clausules schrijven, één voor elke rij.
SQLite Voorbeeld invoegen
In het volgende voorbeeld voegen we twee rijen in de tabel 'studenten' in, één voor elke student:
INSERT INTO Students(StudentId, StudentName, DepartmentId, DateOfBirth)
VALUES(11, 'Ahmad', 4, '1997-10-12');
INSERT INTO Students VALUES(12, 'Aly', 4, '1996-10-12');
Dit zou met succes moeten worden uitgevoerd en er is geen uitvoer hiervoor:
Hierdoor worden twee studenten ingevoegd:
- De eerste student met StudentId=11, StudentName = Ahmad, DepartmentId = 4 en DateOfBirth = 1997-10-12.
- De tweede student met StudentId=12, StudentName = Aly, DepartmentId = 4 en DateOfBirth = 1996-10-12′.
In de eerste verklaring hebben we de kolomnamen vermeld “StudentId, StudentName, AfdelingsId, Geboortedatum“In de tweede verklaring deden we dat echter niet.
De vier waarden “12, 'Aly', 4, '1996-10-12'” wordt ingevoegd in alle vier de kolommen van de tabel Studenten, in dezelfde volgorde waarin de kolommen zijn gedefinieerd.
Laten we nu verifiëren dat de twee studenten in de tabel Studenten zijn ingevoegd door het volgende uit te voeren vraag:
SELECT * FROM Students;
Dan zou je het volgende resultaat van de twee studenten moeten zien:
SQLite bijwerken
SQLite UPDATE Query wordt gebruikt om de bestaande records in een tabel te wijzigen. U kunt de WHERE-component met UPDATE-query gebruiken om geselecteerde rijen bij te werken. De UPDATE-component werkt een tabel bij door een waarde voor een specifieke kolom te wijzigen. Hieronder volgt de syntaxis van de UPDATE-component:
Als volgt:
- Na de “update-clausule” moet u de tabelnaam schrijven die u wilt bijwerken.
- U moet een “SET-clausule” schrijven die wordt gebruikt om de kolomnaam te schrijven die moet worden bijgewerkt en de waarde die moet worden bijgewerkt.
- U kunt meer dan één kolom bijwerken. Tussen elke regel kunt u een komma plaatsen.
- U kunt een WHERE-clausule opgeven om slechts enkele rijen op te geven. Alleen de rijen die door de expressie als waar worden geëvalueerd, worden bijgewerkt. Als u geen WHERE-clausule heeft opgegeven, worden alle rijen bijgewerkt.
SQLite Voorbeeld bijwerken
In de volgende UPDATE-instructie zullen we de DepartmentId voor de Student met StudentId = 6 bijwerken naar 3:
UPDATE Students SET DepartmentId = 3 WHERE StudentId = 6;
Dit zou met succes moeten worden uitgevoerd en u zou geen uitvoer moeten krijgen:
In de UPDATE-clausule hebben we aangegeven dat we de tabel Studenten willen bijwerken.
- In de WHERE-clausule hebben we alle studenten gefilterd om alleen de rij voor StudentId = 6 te selecteren.
- De SET-clausule zal de waarde van de Afdelings-ID voor de geselecteerde studenten bijwerken naar 3.
Laten we nu controleren of de student met ID 6 is bijgewerkt door de volgende opdracht uit te voeren:
SELECT * FROM Students WHERE StudentId = 6;
U zou nu moeten zien dat de waarde van de afdelings-ID 3 is, zoals hieronder weergegeven:
SQLite Verwijder
SQLite DELETE-query wordt gebruikt om bestaande records uit een opgegeven tabel te verwijderen. U kunt de WHERE-clausule gebruiken met DELETE-query's om de geselecteerde rijen te verwijderen.
De DELETE-clausule heeft de volgende syntaxis:
- U moet een tabelnaam schrijven na de DELETE FROM-clausule waaruit u records wilt verwijderen. (Opmerking: dat de DELETE-clausule wordt gebruikt om enkele records uit een tabel te verwijderen of om alle records te verwijderen, maar de tabel zelf wordt niet verwijderd. echter, de DROP-clausule wordt gebruikt om de hele tabel met alle records erop te verwijderen.)
- Als u de DELETE-clausule zo schrijft: “DELETE FROM guru”, worden alle records uit de tabel “guru” verwijderd.
- U kunt een WHERE-voorwaarde opgeven met een expressie als u enkele specifieke rijen wilt verwijderen. Alleen de rijen waarvoor de expressie als waar wordt geëvalueerd, worden verwijderd. Bijvoorbeeld: “DELETE FROM guru WHERE id > 5” – dit zal alleen de records verwijderen die een id groter dan 5 hebben.
Voorbeeld
In de volgende verklaring verwijderen we twee studenten met StudentId 11 en 12:
DELETE FROM Students WHERE StudentId = 11 OR StudentId = 12;
De uitdrukking "StudentId = 11 OF StudentId = 12” geldt alleen voor studenten met ID 11 en 12. De DELETE-clausule wordt dus op beide toegepast en verwijdert alleen deze studenten.
Deze opdracht zou succesvol moeten worden uitgevoerd en u zou niet de volgende uitvoer mogen krijgen:
U kunt controleren of de twee studenten zijn verwijderd door alle records in de tabel Studenten te selecteren, als volgt:
SELECT * FROM Students;
Je moet de twee leerlingen met ID 11 en 12 niet als volgt zien:
SQLite Conflictclausule
Stel dat u een kolom hebt met een van de volgende kolombeperkingen: UNIQUE, NOT NULL, CHECK of PRIMARY KEY. En vervolgens probeerde u een waarde in die kolom in te voegen of bij te werken met een waarde die in conflict is met deze beperking.
Als een kolom bijvoorbeeld een UNIEK-beperking heeft en u probeert een waarde in te voegen die al bestaat (een dubbele waarde), wat in strijd is met de UNIEK-beperking. Vervolgens kunt u met de CONFLICT-clausule kiezen wat u in dergelijke gevallen moet doen om dit conflict op te lossen.
Voordat we verder gaan met uitleggen hoe de CONFLICT-clausule het conflict oplost. U moet begrijpen wat een databasetransactie is.
Database-transactie
De term databasetransactie is een lijst van SQLite bewerkingen (invoegen, bijwerken of verwijderen). De databasetransactie moet als één geheel worden uitgevoerd, waarbij alle bewerkingen succesvol zijn uitgevoerd of helemaal niet. Alle bewerkingen worden geannuleerd als een ervan niet is uitgevoerd.
Voorbeeld voor een databasetransactie
De transactie voor het overmaken van geld van de ene bankrekening naar de andere zal een aantal activiteiten omvatten. Deze transactiebewerking omvat het opnemen van geld van de eerste rekening en het storten ervan op een andere rekening. Deze transactie moet volledig voltooid of volledig geannuleerd worden en mag niet halverwege mislukken.
Hier is de lijst met vijf resoluties die u kunt kiezen in de CONFLICT-clausule:
- TERUGROLLEN – hierdoor wordt de transactie teruggedraaid waarin de huidige SQLite verklaring die het conflict bevat (het zal de hele transactie annuleren). Als u bijvoorbeeld tien rijen probeert bij te werken en de vijfde rij een waarde heeft die in strijd is met een beperking, worden er geen rijen bijgewerkt en blijven de tien rijen hetzelfde. Er wordt een fout gegenereerd.
- AFBREKEN – hierdoor wordt de stroom afgebroken (annuleert). SQLite alleen de verklaring die het conflict bevat en de transactie wordt niet geannuleerd. Als u bijvoorbeeld tien rijen probeert bij te werken en de vijfde rij een waarde heeft die in strijd is met een beperking, wordt alleen de vijfde waarde niet bijgewerkt, maar worden de overige negen rijen wel bijgewerkt. Er wordt een fout gegenereerd.
- MISLUKKING - breekt de stroom af SQLite verklaring die het conflict bevat. De transactie gaat echter niet door, maar de eerdere wijzigingen die zijn aangebracht in rijen voorafgaand aan de rij met het conflict worden doorgevoerd. Als u bijvoorbeeld tien rijen probeert bij te werken en de vijfde rij een waarde heeft die in strijd is met een beperking, worden alleen de vier rijen bijgewerkt en de andere niet. Er wordt een fout gegenereerd.
- NEGEREN – hiermee wordt de rij overgeslagen die de schending van de beperking bevat en worden de andere volgende rijen van de SQLite stelling. Als u bijvoorbeeld tien rijen probeert bij te werken en de vijfde rij een waarde heeft die in strijd is met een beperking, worden alleen de vier rijen bijgewerkt en de andere niet. Er wordt niet verder gegaan met het bijwerken van andere rijen en het stoppen bij de rij met de conflictwaarde. Er wordt geen fout gegenereerd.
- VERVANGEN – het hangt af van het type beperking waarbij de overtreding plaatsvindt:
- Wanneer er sprake is van een beperkingsovertreding voor de UNIEKE of PRIMAIRE SLEUTELbeperking. De REPLACE vervangt de rij die de overtreding veroorzaakt door de nieuwe ingevoegde of bijgewerkte rij.
- Als er sprake is van een overtreding van de NOT NULL-beperking, vervangt de REPLACE-clausule de NULL-waarde door de standaardwaarde van die kolom. Als de kolom geen standaardwaarde heeft, dan SQLite zal de afrekening afbreken (afrekening wordt geannuleerd)
- ALS de CHECK-beperking wordt overtreden, wordt de clausule afgebroken.
Opmerking: De bovenstaande 5 resoluties zijn opties voor hoe u het conflict wilt oplossen. Het hoeft niet noodzakelijkerwijs zo te zijn dat wat van toepassing is om het ene conflict op te lossen, ook van toepassing is op het oplossen van andere soorten conflicten.
Hoe u de CONFLICT-clausule declareert
U kunt de clausule ON CONFLICT declareren wanneer u een beperking voor een kolomdefinitie definieert binnen de clausule CREATE TABLE. Gebruik de volgende syntaxis:
U kunt één van de vijf resoluties kiezen om het conflict op te lossen, zoals eerder uitgelegd.
BIJ CONFLICTEN NEGEER Voorbeeld
Stap 1) Maak als volgt een nieuw tabelonderwerp:
CREATE TABLE [Subjects] (
[SubjectId] INTEGER NOT NULL PRIMARY KEY ON CONFLICT IGNORE,
[SubjectName] NVARCHAR NOT NULL
);
Merk op dat we een PRIMARY KEY-beperking hebben gedefinieerd voor de kolom SubjectId. De beperking van de primaire sleutel staat niet toe dat er twee dubbele waarden in de kolom SubjectId worden ingevoegd, zodat alle waarden in die kolom uniek moeten zijn. Merk ook op dat we een conflictoplossing kiezen als “NEGEREN'.
De opdracht zou succesvol moeten worden uitgevoerd en u zou geen fouten moeten krijgen:
Stap 2) Laten we nu enkele waarden in de nieuwe tabelonderwerpen invoegen, maar met een waarde die de primaire sleutelbeperking schendt:
INSERT INTO Subjects VALUES(1, 'Algebra'); INSERT INTO Subjects VALUES(2, 'Database Course'); INSERT INTO Subjects VALUES(2, 'Data Structures'); INSERT INTO Subjects VALUES(4, 'Algorithms');
In deze INSERT-instructie hebben we geprobeerd twee cursussen in te voegen met dezelfde Primary Key Subject ID 2, wat in strijd is met de beperking van de primaire sleutel.
De commando's zouden goed moeten werken en u zou geen fouten moeten krijgen. Zoals volgt:
Stap 3) Selecteer als volgt alle onderwerpen uit de tabel:
SELECT * FROM Subjects;
Dit geeft je de lijst met onderwerpen:
Merk op dat er slechts drie onderwerpen zijn ingevoegd “Algebra, databasecursus en Algorithms” in plaats van 4 rijen.
De rij met de waarde die in strijd is met de beperking van de primaire sleutel, namelijk 'Gegevensstructuren', is genegeerd en niet ingevoegd. Echter, SQLite gaat door met het uitvoeren van andere instructies na die rij.
Stap 4) VERWIJDER de tabelonderwerpen om deze opnieuw te maken met een andere ON CONFLICT-clausule, bijvoorbeeld in het volgende voorbeeld, door de volgende opdracht uit te voeren:
DROP TABLE Subjects;
Met het drop-commando wordt de hele tabel verwijderd. Tabelonderwerpen bestaan nu niet.
BIJ CONFLICT VERVANGEN Voorbeeld
Stap 1) Maak als volgt een nieuw tabelonderwerp:
CREATE TABLE [Subjects] (
[SubjectId] INTEGER NOT NULL PRIMARY KEY ON CONFLICT REPLACE,
[SubjectName] NVARCHAR NOT NULL
);
Merk op dat we een PRIMARY KEY-beperking hebben gedefinieerd voor de kolom SubjectId. De beperking van de primaire sleutel staat niet toe dat er twee dubbele waarden in de kolom SubjectId worden ingevoegd, zodat alle waarden in die kolom uniek moeten zijn.
Merk ook op dat we een optie voor conflictoplossing kiezen als “VERVANGEN“. De opdracht zou succesvol moeten worden uitgevoerd en u zou geen fouten moeten krijgen:
Stap 2) Laten we nu enkele waarden in de nieuwe tabel Onderwerpen invoegen, maar met een waarde die de primaire sleutelbeperking schendt:
INSERT INTO Subjects VALUES(1, 'Algebra'); INSERT INTO Subjects VALUES(2, 'Database Course'); INSERT INTO Subjects VALUES(2, 'Data Structures'); INSERT INTO Subjects VALUES(4, 'Algorithms');
In deze INSERT-instructie hebben we geprobeerd twee cursussen in te voegen met dezelfde Primary Key Subject ID 2, wat in strijd is met de beperking van de primaire sleutel.
De commando's zouden goed moeten werken en u zou geen fouten moeten krijgen. Zoals volgt:
Stap 3) Selecteer als volgt alle onderwerpen uit de tabel:
SELECT * FROM Subjects;
Dit geeft je de lijst met onderwerpen:
Merk op dat er slechts drie onderwerpen zijn ingevoegd “Algebra, datastructuren, en Algorithms'terwijl we probeerden vier rijen in te voegen.
De rij met de waarde die de primaire sleutelbeperking schendt, namelijk 'Data structuren” verving de waarde “Databasecursus"als volgt:
- De eerste twee insert-instructies werken prima en zonder problemen. Er worden twee vakken Algebra en Databasecursus ingevoegd met ID's 1, 2.
- . SQLite probeert de derde insert-instructie uit te voeren met SubjectId 2 en SubjectName “Data structuren“, komt het erachter dat er al een onderwerp is met SubjectId = 2. Dat is een overtreding van de primaire sleutelbeperking die is gedefinieerd in de kolom SubjectId.
- SQLite zal een VERVANGENDE resolutie voor dit conflict kiezen. Het vervangt de waarde die al bestaat in de onderwerpentabel door de nieuwe waarde uit de insert-instructie. Dus de "Databasecursus'Onderwerpnaam wordt vervangen door'Data structuren" Onderwerp.
Samenvatting
INSERT-, UPDATE- en DELETE-clausules worden gebruikt om de gegevens in de SQLite databank. De CONFLICT-clausule is een krachtige clausule om elk conflict tussen de gegevens en de gegevens die moeten worden gewijzigd op te lossen.
