SQLite INDSÆT, OPDATER, SLET Forespørgsel med eksempel

Indsæt, opdater og slet forespørgsel i SQLite

Dataændringsklausulerne i SQLite er INSERT-, UPDATE- og DELETE-sætninger. Det bruges til at indsætte nye rækker, opdatere eksisterende værdier eller slette rækker fra databasen.

Bemærk, at for alle de følgende eksempler skal du køre sqlite3.exe og åbne en forbindelse til eksempeldatabasen som flydende:

Trin 1) I dette trin,

• Åbn Denne computer og naviger til følgende mappe “C:\sqlite” og
• Åbn derefter “sqlite3.exe“:

Trin 2) Åbn databasen “TutorialsSampleDB.db” med følgende kommando:

.open TutorialsSampleDB.db

Nu er du klar til at køre enhver form for forespørgsel på databasen.

SQLite INSERT

SQLite INSERT bruges til at indsætte poster i en specificeret tabel i databasen. du skal bruge 'INSERT'-klausulen. INSERT-klausulens syntaks er som følger:

• Efter INSERT-sætningen skal du angive, hvilken tabel du skal indsætte værdierne i.
• Efter tabelnavnet skriver du listen over kolonner, du vil indsætte værdierne i.
• Du kan ignorere kolonnenavnet og ikke skrive til dem.
• Hvis du ikke skriver kolonnenavnet, vil værdierne blive indsat i alle kolonnerne i tabellen i samme rækkefølge, kolonnerne er defineret i tabellen.
• Efter VALUES-sætningen skal du angive de værdier, der skal indsættes.
• Hver INSERT-sætning indsætter kun én række. Hvis du vil indsætte flere rækker, skal du skrive flere INSERT-sætninger, en for hver række.

SQLite Indsæt eksempel

I det følgende eksempel vil vi indsætte 2 rækker i elevtabellen, en for hver elev:

INSERT INTO Students(StudentId, StudentName, DepartmentId, DateOfBirth)
              VALUES(11, 'Ahmad', 4, '1997-10-12');

INSERT INTO Students VALUES(12, 'Aly', 4, '1996-10-12');

Dette skulle køre med succes, og der er ikke noget output for dette:

Dette vil indsætte to elever:

• Den første elev med StudentId=11, StudentName = Ahmad, DepartmentId = 4 og DateOfBirth = 1997-10-12.
• Den anden studerende med StudentId=12, StudentName = Aly, DepartmentId = 4 og DateOfBirth = 1996-10-12.

I den første sætning angav vi kolonnenavnene "StudentId, StudentName, DepartmentId, DateOfBirth". I den anden sætning gjorde vi det dog ikke.

De fire værdier “12, 'Aly', 4, '1996-10-12'” vil blive indsat i alle fire kolonner i tabellen Studenter i samme rækkefølge, som kolonnerne er defineret.

Lad os nu kontrollere, at de to elever blev indsat i tabellen Elever ved at køre følgende query:

SELECT * FROM Students;

Så skulle du se de to elever, der er returneret fra den forespørgsel som følger:

SQLite Opdatering

SQLite UPDATE Query bruges til at ændre de eksisterende poster i en tabel. Du kan bruge WHERE-sætning med UPDATE-forespørgsel til at opdatere valgte rækker. UPDATE-sætningen opdaterer en tabel ved at ændre en værdi for en specifik kolonne. Følgende er syntaksen for UPDATE-klausulen:

Som følgende:

• Efter "opdateringsklausulen" skal du skrive tabelnavnet for at opdatere.
• Du skal skrive "SET-klausul", som bruges til at skrive kolonnenavnet, der skal opdateres, og værdien, der skal opdateres.
• Du kan opdatere mere end én kolonne. Du kan bruge et komma mellem hver linje.
• Du kan angive et WHERE-udtryk for kun at angive nogle rækker. Kun de rækker, som udtrykket evaluerer til sand, opdateres. Hvis du ikke har angivet en WHERE-sætning, vil alle rækkerne blive opdateret.

SQLite Opdateringseksempel

I den følgende UPDATE-erklæring vil vi opdatere afdelings-id'et for den studerende med StudentId = 6 til 3:

UPDATE Students
SET DepartmentId = 3 
WHERE StudentId = 6;

Dette skulle køre med succes, og du skulle ikke få noget output:

I UPDATE-klausulen specificerede vi, at vi ønsker at opdatere tabellen Studenter.

• I WHERE-sætningen filtrerede vi alle eleverne for kun at vælge rækken for StudentId = 6.
• SET-klausulen vil opdatere værdien af ​​afdelings-id'et for de valgte studerende til 3.

Lad os nu kontrollere, at eleven med ID 6 er opdateret ved at køre følgende kommando:

SELECT * FROM Students WHERE StudentId = 6;

Du skulle nu se, at afdelings-id-værdien nu er 3 som følger:

SQLite Slette

SQLite DELETE-forespørgsel bruges til at fjerne eksisterende poster fra en specificeret tabel. Du kan bruge WHERE-sætningen med DELETE-forespørgsler til at slette de valgte rækker.

DELETE-sætning har følgende syntaks:

• Du skal skrive et tabelnavn efter DELETE FROM-klausulen, hvorfra du vil slette poster. (Bemærk: DELETE-klausulen bruges til at slette nogle poster fra en tabel eller slette alle poster, og den sletter ikke selve tabellen. DROP-klausulen bruges dog til at slette hele tabellen med alle poster i den.)
• Hvis du skriver DELETE-sætningen som denne "DELETE FROM guru", vil dette slette alle poster fra tabellen "guru".
• Du kan angive en WHERE-betingelse med et udtryk, hvis du vil slette nogle bestemte rækker. Kun de rækker, som udtrykket vurderes til at være sandt, vil blive slettet. For eksempel, "DELETE FROM guru WHERE id > 5" - dette sletter kun de poster, der har id større end 5.

Eksempel

I den følgende erklæring vil vi slette to elever med StudentId 11 og 12:

DELETE FROM Students WHERE StudentId = 11 OR StudentId = 12;

Udtrykket "StudentId = 11 ELLER StudentId = 12" vil kun være sandt for studerende med Id'erne 11 og 12. Så DELETE-klausulen vil blive anvendt på begge og vil kun slette dem.

Denne kommando bør køre med succes, og du bør ikke få noget output som følgende:

Du kan bekræfte, at de to elever blev slettet, ved at vælge alle posterne fra tabellen Elever som følger:

SELECT * FROM Students;

Du bør ikke se de to elever med id 11 og 12 som følger:

SQLite Konfliktklausul

Antag, at du har en kolonne, der har en af ​​følgende kolonnebegrænsninger: UNIQUE, NOT NULL, CHECK eller PRIMARY KEY. Og så forsøgte du at indsætte eller opdatere en værdi på den kolonne med en værdi, der er i konflikt med denne begrænsning.

For eksempel, hvis en kolonne har en UNIQUE begrænsning, og du forsøgte at indsætte en værdi, der allerede eksisterer (en dubletværdi), som er i konflikt med den UNIQUE begrænsning. Derefter lader CONFLICT-klausulen dig vælge, hvad du skal gøre i sådanne tilfælde for at løse denne konflikt.

Før vi fortsætter med at forklare, hvordan KONFLICT-klausulen løser konflikten. Du bør forstå, hvad en databasetransaktion er.

Databasetransaktion

Udtrykket databasetransaktion er en liste over SQLite operationer (indsæt eller opdater eller slet). Databasetransaktionen skal udføres som én enhed, enten alle operationerne er udført med succes eller slet ikke. Alle handlinger vil blive annulleret, hvis en af ​​dem ikke kunne udføres.

Eksempel på en databasetransaktion

Transaktionen for at overføre penge fra en bankkonto til en anden vil involvere et par aktiviteter. Denne transaktionsoperation inkluderer hævning af penge fra den første konto og indbetaling på en anden konto. Denne transaktion skal fuldføres eller helt annulleres og må ikke mislykkes halvvejs.

Her er listen over fem løsninger, du kan vælge i CONFLICT-klausulen:

1. TILBAGERULNING – dette vil rulle den transaktion tilbage, hvor den aktuelle SQLite erklæring, der har konflikten (det vil annullere hele transaktionen). For eksempel, hvis du forsøger at opdatere 10 rækker, og den femte række har en værdi, der er i konflikt med en begrænsning, så vil ingen rækker blive opdateret, de 10 rækker forbliver de samme. En fejl vil blive kastet.
2. AFBRYD – dette vil afbryde (annullere) den aktuelle SQLite kun erklæring, der har konflikten, og transaktionen vil ikke blive annulleret. For eksempel, hvis du forsøger at opdatere 10 rækker, og den femte række har en værdi, der er i konflikt med en begrænsning, så vil kun den femte værdi ikke blive opdateret, men de andre 9 rækker vil blive opdateret. En fejl vil blive kastet.
3. FAIL – afbryder den aktuelle SQLite udtalelse, der har konflikten. Transaktionen fortsætter dog ikke, men de tidligere ændringer, der er foretaget i rækker før den række, der har konflikten, vil blive begået. For eksempel, hvis du forsøger at opdatere 10 rækker, og den femte række har en værdi, der er i konflikt med en begrænsning, vil kun de 4 rækker blive opdateret, og den anden vil ikke. En fejl vil blive kastet.
4. IGNORER – dette springer den række over, der indeholder begrænsningsovertrædelsen, og fortsætter behandlingen af ​​de efterfølgende rækker i SQLite udmelding. For eksempel, hvis du forsøger at opdatere 10 rækker, og den femte række har en værdi, der er i konflikt med en begrænsning, vil kun de 4 rækker blive opdateret, og den anden vil ikke. Den fortsætter ikke længere for at opdatere andre rækker og stopper ved den række, der har konfliktværdien. Ingen fejl vil blive kastet.
5. ERSTAT – det afhænger af typen af ​​begrænsning, der har overtrædelsen:
   • Når der er en overtrædelse af begrænsningen for begrænsningen UNIQUE eller PRIMARY KEY. REPLACE erstatter den række, der forårsager overtrædelsen, med den nye indsatte eller opdaterede række.
   • Når der er en NOT NULL-begrænsningsovertrædelse, erstatter REPLACE-udtrykket NULL-værdien med standardværdien for den kolonne. Hvis kolonnen ikke har en standardværdi, så SQLite vil afbryde erklæringen (erklæringen vil blive annulleret)
   • HVIS KONTROL-begrænsningen overtrædelse opstår, vil klausulen blive afbrudt.

Bemærk: Ovenstående 5 løsninger er muligheder for, hvordan du ønsker at løse konflikten. Det er ikke nødvendigvis tilfældet, at det, der er relevant for at løse én konflikt, også er relevant for at løse andre typer konflikter.

Sådan erklærer du KONFLIKT-klausulen

Du kan erklære ON CONFLICT-udtrykket, når du definerer en begrænsning for en kolonnedefinition i CREATE TABLE-udtrykket. Brug af følgende syntaks:

Du kan vælge en af ​​de fem løsninger for at løse konflikten som forklaret før.

OM KONFLIKT IGNORER Eksempel

Trin 1) Opret et nyt tabelemne som følger:

CREATE TABLE [Subjects] (  
    [SubjectId] INTEGER NOT NULL PRIMARY KEY ON CONFLICT IGNORE,
    [SubjectName] NVARCHAR NOT NULL
);

Bemærk, at vi har defineret en PRIMARY KEY-begrænsning på SubjectId-kolonnen. Begrænsningen for den primære nøgle tillader ikke, at to duplikerede værdier indsættes i SubjectId-kolonnen, så alle værdierne i den kolonne skal være unikke. Bemærk også, at vi vælger en konfliktløsning til at være "IGNORE".

Kommandoen skulle køre med succes, og du skulle ikke få nogen fejl:

Trin 2) Lad os nu indsætte nogle værdier i de nye tabelemner, men med en værdi, der overtræder den primære nøglebegrænsning:

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');

I denne INSERT-sætning forsøgte vi at indsætte to kurser med det samme Primary Key Subject id 2, hvilket er en overtrædelse af den primære nøgle-begrænsning.

Kommandoerne skulle køre fint, og du skulle ikke få nogen fejl. Som følgende:

Trin 3) Vælg alle emnerne fra tabellen som følger:

SELECT * FROM Subjects;

Dette vil give dig listen over emner:

Bemærk, at kun tre emner blev indsat “Algebra, Databasekursus og Algorithms” i stedet for 4 rækker.

Rækken, der har den værdi, der overtræder den primære nøglebegrænsning, som er "Datastrukturer", blev ignoreret og ikke indsat. Imidlertid, SQLite fortsætter med at udføre andre udsagn efter den række.

Trin 4) SLET tabelemnerne for at oprette den igen med en anden ON CONFLICT-sætning til følgende eksempel ved at køre følgende kommando:

DROP TABLE Subjects;

Drop-kommandoen sletter hele tabellen. Tabel Emner eksisterer nu ikke.

OM KONFLIKT ERSTAT Eksempel

Trin 1) Opret et nyt tabelemne som følger:

CREATE TABLE [Subjects] (  
    [SubjectId] INTEGER NOT NULL PRIMARY KEY ON CONFLICT REPLACE,
    [SubjectName] NVARCHAR NOT NULL
);

Bemærk, at vi definerede en PRIMÆR NØGLE-begrænsning på kolonnen SubjectId. Den primære nøglebegrænsning tillader ikke, at to duplikerede værdier indsættes i kolonnen SubjectId, så alle værdierne i den kolonne skal være unikke.

Bemærk også, at vi har valgt "REPLACE" som konfliktløsningsmulighed. Kommandoen burde køre korrekt, og du burde ikke få nogen fejl:

Trin 2) Lad os nu indsætte nogle værdier i den nye tabel Emner, men med en værdi, der overtræder den primære nøglebegrænsning:

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');

I denne INSERT-sætning forsøgte vi at indsætte to kurser med det samme Primary Key Subject id 2, hvilket er en overtrædelse af den primære nøgle-begrænsning.

Kommandoerne skulle køre fint, og du skulle ikke få nogen fejl. Som følgende:

Trin 3) Vælg alle emnerne fra tabellen som følger:

SELECT * FROM Subjects;

Dette vil give dig listen over emner:

Bemærk, at kun tre emner blev indsat "Algebra, datastrukturer og Algorithms” hvorimod vi forsøgte at indsætte 4 rækker.

Rækken med den værdi, der overtræder den primære nøglebegrænsning, som er "Datastrukturer", erstattede værdien "Databasekursus" som følger:

• De første to indsæt-sætninger kører fint uden problemer. To fag Algebra og Databasekursus vil blive indsat med id 1, 2.
• Når SQLite forsøger at køre den tredje insert-sætning med SubjectId 2 og SubjectName “Data Structures”, finder den ud af, at der allerede er et subjekt med SubjectId = 2. Hvilket er en overtrædelse af den primære nøglebegrænsning, der er defineret i SubjectId-kolonnen.
• SQLite vil vælge en REPLACE-løsning til denne konflikt. Den erstatter den værdi, der allerede findes i emnetabellen, med den nye værdi fra insert-sætningen. Således vil emnenavnet i "Databasekursus" blive erstattet med emnenavnet i "Datastrukturer".

Ofte Stillede Spørgsmål