SQLite INSERT, UPDATE, DELETE Query met voorbeeld

Invoegen, bijwerken en verwijderen van query's in SQLite

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 database “TutorialsSampleDB.db” met 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 "StudentId, StudentName, DepartmentId, DateOfBirth" vermeld. In de tweede verklaring hebben we dat echter niet gedaan.

De vier waarden “12, 'Aly', 4, '1996-10-12'” worden in alle vier de kolommen van de tabel Studenten ingevoegd in dezelfde volgorde als 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 Verwijdering

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:

• Je moet na de DELETE FROM-clausule de naam van de tabel opgeven waaruit je records wilt verwijderen. (Let op: de DELETE-clausule wordt gebruikt om bepaalde records uit een tabel te verwijderen of om alle records te verwijderen; de tabel zelf wordt hiermee niet verwijderd. De DROP-clausule daarentegen wordt gebruikt om de hele tabel, inclusief alle records, 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" is alleen waar voor studenten met ID's 11 en 12. De DELETE-clausule wordt dus op beide toegepast en verwijdert alleen hen.

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:

1. ROLLBACK – hiermee 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.
2. ABORT – hiermee wordt het huidige proces afgebroken (geannuleerd). 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.
3. MISLUKKING – beëindigt de huidige procedure 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.
4. NEGEREN – hiermee wordt de rij met de schending van de beperking overgeslagen en worden de volgende rijen verder verwerkt. 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.
5. VERVANGEN – dit hangt af van het type beperking dat de schending veroorzaakt:
   • 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.

Let op: de bovenstaande 5 oplossingen zijn opties voor hoe u het conflict wilt oplossen. Wat geschikt is voor het oplossen van het ene conflict, is niet per se ook geschikt voor 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 primaire sleutelbeperking hebben gedefinieerd voor de kolom SubjectId. De primaire sleutelbeperking voorkomt dat er twee identieke waarden in de kolom SubjectId worden ingevoerd, zodat alle waarden in die kolom uniek moeten zijn. Merk ook op dat we de conflictresolutie hebben ingesteld op "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 opgenomen: "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 bij de conflictoplossing de optie "VERVANGEN" hebben gekozen. De opdracht zou succesvol moeten worden uitgevoerd en er zouden geen fouten moeten optreden.

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 opgenomen: "Algebra, Datastructuren en Algorithms'terwijl we probeerden vier rijen in te voegen.

De rij met de waarde die de primaire sleutelbeperking schendt, namelijk "Datastructuren", heeft de waarde "Databasecursus" als volgt vervangen:

• De eerste twee insert-instructies werken prima en zonder problemen. Er worden twee vakken Algebra en Databasecursus ingevoegd met ID's 1, 2.
• . SQLite Bij het uitvoeren van de derde INSERT-instructie met SubjectId 2 en SubjectName “Data Structures” wordt geconstateerd dat er al een onderwerp bestaat met SubjectId = 2. Dit is een schending van de primaire sleutelbeperking die is gedefinieerd voor de kolom SubjectId.
• SQLite Er wordt gekozen voor een REPLACE-oplossing voor dit conflict. Deze vervangt de bestaande waarde in de tabel Subjects door de nieuwe waarde uit de INSERT-instructie. De SubjectName "Database Course" wordt dus vervangen door SubjectName "Data Structures".

Veelgestelde vragen