SQLite INSERT, UPDATE, SLET forespørgsel med eksempel

Indholdsfortegnelse:

Anonim

Datamodifikationsklausulerne 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.

I denne vejledning lærer du-

  • INDSÆT
  • Opdatering
  • Slet
  • Konfliktbestemmelse

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,

  1. Åbn Denne computer, og naviger til følgende bibliotek " C: \ sqlite " og
  2. Åbn derefter " sqlite3.exe ":

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

.åbne TutorialsSampleDB.db

Nu er du klar til at køre alle typer forespørgsler i 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-klausulen skal du angive, hvilken tabel du skal indsætte værdierne i.
  • Efter det tabelnavn, du skriver listen over kolonner, skal du indsætte værdierne i.
  • Du kan ignorere kolonnernes navn og ikke skrive til dem.
  • Hvis du ikke skriver kolonnenavnet, indsættes værdierne i alle kolonnerne, der findes i tabellen i samme rækkefølge, kolonnerne er defineret i tabellen.
  • Efter VALUES-klausulen skal du angive de værdier, der skal indsættes.
  • Hver INSERT-sæt indsætter kun en række. Hvis du vil indsætte flere rækker, skal du skrive flere INSERT-klausuler, en for hver række.

Eksempel på SQLite-indsættelse

I det følgende eksempel indsætter vi 2 rækker i tabellen med studerende, en for hver elev:

INDSÆT I studerende (StudentId, StudentName, DepartmentId, DateOfBirth)VÆRDIER (11, 'Ahmad', 4, '1997-10-12');INDSÆT I StudenterVÆRDIER (12, 'Aly', 4, '1996-10-12');

Dette skal køre med succes, og der er ingen output til dette:

Dette vil indsætte to studerende:

  • Den første studerende 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 erklæring opførte vi kolonnerne " StudentId, StudentName, DepartmentId, DateOfBirth ". I den anden erklæring gjorde vi det dog ikke.

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

Lad os nu kontrollere, at de to studerende blev indsat i tabellen Students ved at køre følgende forespørgsel:

VÆLG * FRA studerende;

Derefter skal du se de to studerende vendt tilbage fra denne forespørgsel som følger:

SQLite-opdatering

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

Som følger:

  • Efter "opdateringsklausulen" skal du skrive tabelnavnet for at opdatere.
  • Du skal skrive "SET-klausul", som bruges til at skrive kolonnenavnet, der skal opdateres, og den værdi, der skal opdateres.
  • Du kan opdatere mere end en kolonne. Du kan bruge et komma mellem hver linje.
  • Du kan angive en WHERE-sætning for kun at specificere nogle rækker. Kun de rækker, som udtrykket evaluerer til sandt, opdateres. Hvis du ikke angav en WHERE-klausul, opdateres alle rækkerne.

Eksempel på SQLite-opdatering

I den følgende UPDATE-erklæring opdaterer vi DepartmentId for studenten med StudentId = 6 til at være 3:

OPDATER studerendeSET DepartmentId = 3HVOR StudentId = 6;

Dette skal køre med succes, og du skal ikke få nogen output:

I UPDATE-klausulen specificerede vi, at vi vil opdatere tabellen Students.

  • I WHERE-klausulen filtrerede vi alle studerende for kun at vælge rækken for StudentId = 6.
  • SET-klausulen opdaterer værdien for afdelings-id for de valgte studerende til at være 3.

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

VÆLG * FRA studerende HVOR StudentId = 6;

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

SQLite Slet

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

SLET klausul har følgende syntaks:

  • Du skal skrive et tabelnavn efter DELETE FROM-klausulen, hvorfra du vil slette poster. ( Bemærk: at DELETE-klausulen bruges til at slette nogle poster fra en tabel eller slette alle poster, og den sletter ikke selve tabellen. DROP-klausulen bruges imidlertid til at slette hele tabellen med alle poster på den. )
  • Hvis du skriver SLET-klausulen som denne "SLET FRA guru", vil dette slette alle poster fra tabellen "guru".
  • Du kan angive en WHERE-tilstand med et udtryk, hvis du vil slette nogle specifikke rækker. Kun de rækker, som udtrykket evalueres til sandt, slettes. For eksempel "SLET FRA guru WHERE id> 5" - dette sletter kun de poster, der har id større end 5.

Eksempel

I den følgende erklæring sletter vi to studerende med StudentId 11 og 12:

Slet fra studerende, hvor StudentId = 11 ELLER StudentId = 12;

Udtrykket " StudentId = 11 ELLER StudentId = 12 " gælder kun for studerende med Id 11 og 12. Så DELETE-klausulen anvendes på begge og sletter dem kun.

Denne kommando skal køre med succes, og du skal ikke få nogen output som følger:

Du kan kontrollere, at de to elever blev slettet ved at vælge alle poster i tabellen Students som følger:

VÆLG * FRA studerende;

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 i den kolonne med en værdi, der er i modstrid med denne begrænsning.

For eksempel, hvis en kolonne har en UNIQUE-begrænsning, og du forsøgte at indsætte en allerede eksisterende værdi (en duplikatværdi), som er i konflikt med UNIQUE-begrænsningen. Derefter giver KONFLIKT-klausulen dig mulighed for at 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 KONFLIKT-klausul løser konflikten. Du skal forstå, hvad der er en databasetransaktion.

Databasetransaktion:

Udtrykket databasetransaktion er en liste over SQLite-operationer (indsæt eller opdater eller slet). Databasetransaktionen skal udføres som en enhed, enten alle de operationer, der udføres med succes eller slet ikke. Alle operationer annulleres, hvis en af ​​dem ikke kunne udføres.

Eksempel på en databasetransaktion:

Transaktionen for overførsel af penge fra en bankkonto til en anden vil involvere et par aktiviteter. Denne transaktionshandling inkluderer udbetaling af penge fra den første konto og deponering af dem på en anden konto. Denne transaktion skal være fuldført eller helt annulleret og ikke mislykkes halvvejs.

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

  1. ROLLBACK - dette vil rulle den transaktion tilbage, hvor den aktuelle SQLite-sætning, der har konflikten (den annullerer 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, opdateres ingen rækker, de 10 rækker forbliver de samme. En fejl vil blive kastet.
  2. ABORT - dette vil kun afbryde (annullere) den aktuelle SQLite-sætning, der har konflikten, og transaktionen annulleres ikke. 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, opdateres kun den femte værdi ikke, men de andre 9 rækker opdateres. En fejl vil blive kastet.
  3. FAIL - afbryder den aktuelle SQLite-sætning, 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, opdateres kun de 4 rækker, og den anden ikke. En fejl vil blive kastet.
  1. IGNORE - dette springer rækken, der indeholder overtrædelsen af ​​begrænsningen, og fortsætter behandlingen af ​​de andre følgende rækker i SQLite-sætningen. Hvis du f.eks. Prøver at opdatere 10 rækker, og den femte række har en værdi, der er i konflikt med en begrænsning, opdateres kun de 4 rækker, og den anden ikke. Det fortsætter ikke længere med at opdatere andre rækker og stoppe ved den række, der har konfliktværdien. Ingen fejl vil blive kastet.
  1. ERSTAT - det afhænger af typen af ​​begrænsning, der har overtrædelsen:
  • Når der er en overtrædelse af begrænsningen for UNIQUE eller PRIMARY KEY-begrænsningen. REPLACE erstatter rækken, der forårsager overtrædelsen, med den nye indsatte eller opdaterede række.
  • Når der er en IKKE NULL-overtrædelse, erstatter klausulen REPLACE NULL-værdien med standardværdien i den pågældende kolonne. Hvis kolonnen ikke har en standardværdi, afbryder SQLite udsagnet (sætningen annulleres)
  • HVIS overtrædelsen af ​​CHECK-begrænsningen opstår, afbrydes klausulen.

Bemærk: Ovenstående 5 opløsninger er muligheder for, hvordan du vil løse konflikten. Det er muligvis ikke nødvendigvis, hvad der er relevant til løsning af en konflikt, der gælder for løsning af andre typer konflikter.

Sådan erklæres CONFLICT-klausulen

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

Du kan vælge en af ​​de fem opløsninger til løsning af konflikten som forklaret før.

PÅ KONFLIKT Ignorer eksempel

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

Opret TABEL [Emner] ([SubjectId] INTEGER IKKE NULL PRIMÆR KEY ON CONFLICT IGNORE,[Emnenavn] NVARCHAR IKKE NULL);

Bemærk, at vi har defineret en PRIMÆR KEY-begrænsning i 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 kolonnen skal være unikke. Bemærk også, at vi vælger en konfliktløsning til at være " IGNORE ".

Kommandoen skal køre med succes, og du skal 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 FAGVÆRDIER (2, 'Databasekursus');INSERT INTO Subjects VALUES (2, 'Datastrukturer');INSERT INTO Subjects VALUES (4, 'Algorithms');

I denne INSERT-erklæring forsøgte vi at indsætte to kurser med samme primære nøgleemne id 2, hvilket er en overtrædelse af den primære nøglebegrænsning.

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

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

VÆLG * FRA emner;

Dette giver dig listen over emner:

Bemærk, at der kun blev indsat tre emner " Algebra, databasekursus og algoritmer " i stedet for 4 rækker.

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

Trin 4) SLET tabelemnerne for at oprette det igen med en anden ON CONFLICT-klausul for følgende eksempel ved at køre følgende kommando:

DROP TABLE Emner;

Drop-kommandoen sletter hele tabellen. Tabelemner eksisterer nu ikke.

OM UDSKIFTNING AF KONFLIKT Eksempel

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

Opret TABEL [Emner] ([SubjectId] INTEGER IKKE NULL PRIMÆR NØGLE PÅ UDSKIFTNING AF KONFLIKT,[Emnenavn] NVARCHAR IKKE NULL);

Bemærk, at vi definerede en PRIMÆR KEY-begrænsning i 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 kolonnen skal være entydige.

Bemærk også, at vi vælger en løsning til konfliktløsning for at være " ERSTAT ". Kommandoen skal køre med succes, og du skal 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 FAGVÆRDIER (2, 'Databasekursus');INSERT INTO Subjects VALUES (2, 'Datastrukturer');INSERT INTO Subjects VALUES (4, 'Algorithms');

I denne INSERT-erklæring forsøgte vi at indsætte to kurser med samme primære nøgleemne id 2, hvilket er en overtrædelse af den primære nøglebegrænsning.

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

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

VÆLG * FRA emner;

Dette giver dig listen over emner:

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

Den række, der har 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ætningsudsagn kører fint uden problemer. To emner Algebra og Databasekursus indsættes med id 1, 2.
  • Når SQLite forsøger at køre den tredje indsætningserklæring med SubjectId 2 og SubjectName " Datastrukturer ", finder den ud af, at der allerede er et emne med SubjectId = 2. Hvilket er en overtrædelse af den primære nøglebegrænsning, der er defineret i kolonnen SubjectId.
  • SQLite vælger en ERSTAT-løsning til denne konflikt. Det erstatter den værdi, der allerede findes i emnetabellen med den nye værdi fra indsætningserklæringen. Så " Database Course " SubjectName erstattes med " Data Structures " SubjectName.

Resumé:

INSERT-, UPDATE- og DELETE-klausuler bruges til at ændre dataene i SQLite-databasen. CONFLICT-klausulen er en kraftig klausul til løsning af enhver konflikt mellem dataene og de data, der skal ændres.