SQLite BESZÚRÁS, FRISSÍTÉS, TÖRLÉS Lekérdezés példával

⚡ Okos összefoglaló

SQLite Az INSERT, UPDATE és DELETE utasítások új sorok hozzáadásával, meglévő értékek módosításával és rekordok eltávolításával módosítják az adatbázisban található adatokat, míg az ON CONFLICT záradék dönti el, hogyan oldódnak fel a korlátozások megsértései ezen műveletek során.

  • 📝 BESZÁLLÍTÁS: Az INSERT utasítás egy vagy több új sort ad hozzá, a VALUES záradékkal listázva a cél oszlopokat és azok értékeit.
  • ✏️ UPDATE: Az UPDATE utasítás módosítja a meglévő oszlopok értékeit, a SET utasítást használva új adatokhoz, a WHERE utasítást pedig adott sorok megcélzásához.
  • 🗑️ TÖRÖL: A DELETE utasítás eltávolítja a WHERE feltételnek megfelelő sorokat, vagy minden sort, ha a WHERE záradékot elhagyjuk.
  • ⚠️ Konfliktuszáradék: Az ON CONFLICT záradék a korlátozások megsértését ROLLBACK, ABORT, FAIL, IGNORE vagy REPLACE utasításokkal oldja fel.
  • 🔁 Tranzakciók: Egy adatbázis-tranzakció több műveletet egyetlen egységbe csoportosít, amely vagy teljesen véglegesít, vagy teljesen megszakítja a műveletet.
  • 🤖 AI segítség: AI szöveg-SQL eszközök és a GitHub Copilot generál SQLite INSERT, UPDATE és DELETE utasítások egyszerű angol promptokból.

SQLite BESZÚRÁS, FRISSÍTÉS, TÖRLÉS Lekérdezés

Lekérdezés beszúrása, frissítése és törlése itt: SQLite

Az adatmódosítási záradékok a SQLite INSERT, UPDATE és DELETE utasítások. Új sorok beszúrására, meglévő értékek frissítésére vagy sorok törlésére szolgál az adatbázisból.

Vegye figyelembe, hogy a következő példák mindegyikéhez le kell futtatnia az sqlite3.exe fájlt, és meg kell nyitnia a kapcsolatot a mintaadatbázishoz folyamként:

Step 1) Ebben a lépésben a

  • Nyissa meg a Sajátgép ablakot, és keresse meg a következő könyvtárat: „C:\sqlite”, majd
  • Ezután nyissa meg az „sqlite3.exe” fájlt:

SQLite Lekérdezés - BESZÚRÁS, FRISSÍTÉS, TÖRLÉS

Step 2) Nyissa meg a „TutorialsSampleDB.db” adatbázist a következő paranccsal:

.open TutorialsSampleDB.db

SQLite Lekérdezés - BESZÚRÁS, FRISSÍTÉS, TÖRLÉS

Most már készen áll bármilyen típusú lekérdezés futtatására az adatbázisban.

SQLite INSERT

SQLite Az INSERT a rekordok beszúrására szolgál az adatbázis meghatározott táblájába. az 'INSERT' záradékot kell használnia. Az INSERT záradék szintaxisa a következő:

SQLite INSERT

  • Az INSERT záradék után meg kell adni, hogy melyik táblába kell beszúrni az értékeket.
  • A táblázat neve után az oszlopok listáját írja be, amelybe be szeretné szúrni az értékeket.
  • Figyelmen kívül hagyhatja az oszlopok nevét, és nem írhat rájuk.
  • Ha nem írja be az oszlopok nevét, akkor az értékek a táblázatban található összes oszlopba azonos sorrendben kerülnek be, az oszlopok a táblázatban vannak meghatározva.
  • Az VALUES záradék után fel kell sorolnia a beszúrandó értékeket.
  • Minden INSERT záradék csak egy sort szúr be. Ha több sort szeretne beszúrni, írjon több INSERT záradékot, minden sorhoz egyet.

SQLite Példa beszúrása

A következő példában 2 sort fogunk beszúrni a tanulók táblázatába, minden tanulóhoz egyet:

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

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

Ennek sikeresen le kell futnia, és ehhez nincs kimenet:

SQLite betétlap

Ezzel beszúr két tanulót:

  • Az első diák, akinek StudentId=11, StudentName=Ahmad, DepartmentId=4 és DateOfBirth=1997-10-12.
  • A második diák, akinek a StudentId=12, a StudentName = Aly, a DepartmentId = 4 és a DateOfBirth = 1996-10-12.

Az első utasításban felsoroltuk a „StudentId, StudentName, DepartmentId, DateOfBirth” oszlopneveket. A második utasításban azonban ezt nem tettük meg.

A négy érték („12, 'Aly', 4, '1996-10-12'”) a Students tábla mind a négy oszlopába be lesz szúrva ugyanabban a sorrendben, ahogyan az oszlopok definiálva vannak.

Most ellenőrizzük, hogy a két tanuló bekerült-e a Diákok táblázatba a következő futtatásával kérdés:

SELECT * FROM Students;

Ekkor a következőképpen kell látnia a két diákot a lekérdezésből:

SQLite betétlap

SQLite Frissítések

SQLite Az UPDATE lekérdezés a tábla meglévő rekordjainak módosítására szolgál. Használhatja a WHERE záradékot az UPDATE lekérdezéssel a kiválasztott sorok frissítéséhez. Az UPDATE záradék egy adott oszlop értékének módosításával frissíti a táblát. A következő az UPDATE záradék szintaxisa:

SQLite Frissítések

Az alábbiak szerint:

  • A „frissítési záradék” után meg kell írni a frissítendő tábla nevét.
  • Be kell írnia a „SET záradékot”, amely a frissítendő oszlopnév és a frissítendő érték írásához szolgál.
  • Egynél több oszlopot frissíthet. Az egyes sorok között vesszőt is használhat.
  • Megadhat egy WHERE záradékot, hogy csak néhány sort adjon meg. Csak azok a sorok frissülnek, amelyeket a kifejezés igazra értékel. Ha nem adott meg WHERE záradékot, az összes sor frissül.

SQLite Frissítési példa

A következő UPDATE utasításban a StudentId = 6 diák DepartmentId-jét 3-ra frissítjük:

UPDATE Students
SET DepartmentId = 3 
WHERE StudentId = 6;

Ennek sikeresen kell futnia, és nem kap semmilyen kimenetet:

SQLite Frissítések

Az UPDATE záradékban megadtuk, hogy frissíteni szeretnénk a Diákok táblát.

  • A WHERE záradékban az összes tanulót kiszűrtük, hogy csak a StudentId = 6 sort jelöljük ki.
  • A SET záradék a kiválasztott hallgatók osztályazonosítójának értékét 3-ra frissíti.

Most ellenőrizzük, hogy a 6-os azonosítójú tanuló frissítve van-e a következő parancs futtatásával:

SELECT * FROM Students WHERE StudentId = 6;

Most látnia kell, hogy a Department Id értéke most 3, a következőképpen:

SQLite Frissítések

SQLite Törölni

SQLite A DELETE lekérdezés a meglévő rekordok eltávolítására szolgál egy megadott táblából. Használhatja a WHERE záradékot a DELETE lekérdezésekkel a kijelölt sorok törléséhez.

A DELETE záradék szintaxisa a következő:

SQLite Törölni

  • A DELETE FROM záradék után egy táblanevet kell írni, amelyből rekordokat szeretnél törölni. (Megjegyzés: a DELETE záradékkal csak néhány rekordot vagy az összes rekordot törölhetünk egy táblából, magát a táblát nem. A DROP záradékkal azonban a teljes táblát, az összes benne lévő rekorddal együtt törölhetjük.)
  • Ha a DELETE záradékot így írod be: "DELETE FROM guru", ez törli az összes rekordot a "guru" táblából.
  • Megadhat egy WHERE feltételt egy kifejezéssel, ha törölni szeretne néhány konkrét sort. Csak azok a sorok törlődnek, amelyeknél a kifejezés igazra értékel. Például: „DELETE FROM guru WHERE id > 5” – ez csak az 5-nél nagyobb azonosítójú rekordokat törli.

Példa

A következő nyilatkozatban törölünk két diákot, akiknek StudentId 11 és 12:

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

A „StudentId = 11 VAGY StudentId = 12” kifejezés csak a 11-es és 12-es azonosítóval rendelkező diákokra lesz igaz. Tehát a DELETE záradék mindkettőre érvényes lesz, és csak őket törli.

Ennek a parancsnak sikeresen le kell futnia, és nem kaphat semmilyen kimenetet a következőképpen:

SQLite Törölni

Ellenőrizheti, hogy a két tanulót törölték, ha kiválasztja az összes rekordot a Hallgatók táblázatból az alábbiak szerint:

SELECT * FROM Students;

Nem szabad látnia a két 11-es és 12-es azonosítójú diákot a következők szerint:

SQLite Törölni

SQLite Konfliktus záradék

Tegyük fel, hogy van egy oszlopa, amely a következő oszlopkényszerekkel rendelkezik: EGYEDI, NEM NULL, ELLENŐRZÉS vagy ELSŐDLEGES KULCS. Ezután megpróbált beszúrni vagy frissíteni egy értéket az oszlopba olyan értékkel, amely ütközik ezzel a megszorítással.

Például, ha egy oszlop EGYEDI kényszerrel rendelkezik, és megpróbált beszúrni egy már létező értéket (másodlagos érték), amely ütközik az EGYEDI kényszerrel. Ezután a CONFLICT záradék lehetővé teszi, hogy eldöntse, mit tegyen ilyen esetekben a konfliktus megoldása érdekében.

Mielőtt folytatnánk annak magyarázatát, hogyan oldja meg a konfliktust a CONFLICT záradék. Meg kell értenie, mi az adatbázis-tranzakció.

Adatbázis-tranzakció

Az adatbázis-tranzakció kifejezés a következők listája SQLite műveletek (beszúrás vagy frissítés vagy törlés). Az adatbázis-tranzakciót egy egységként kell végrehajtani, vagy az összes műveletet sikeresen, vagy egyáltalán nem. Minden művelet megszakad, ha az egyiket nem sikerült végrehajtani.

Példa adatbázis-tranzakcióra

A pénz egyik bankszámláról a másikra történő átutalására irányuló tranzakció több tevékenységet is magában foglal. Ez a tranzakciós művelet magában foglalja a pénz felvételét az első számláról és egy másik számlára történő befizetését. Ezt a tranzakciót teljesen be kell fejezni vagy teljesen törölni kell, és nem lehet félúton meghiúsítani.

Íme az öt állásfoglalás listája, amelyeket a CONFLICT záradékban választhat:

  1. ROLLBACK – ez visszavonja azt a tranzakciót, amelyben az aktuális SQLite ütközést tartalmazó nyilatkozat (az egész tranzakciót törli). Például, ha 10 sort próbál frissíteni, és az ötödik sor értéke ütközik egy megszorítással, akkor egyetlen sor sem frissül, a 10 sor változatlan marad. Hibaüzenet jelenik meg.
  2. MEGSZAKÍTÁS – ez megszakítja (törli) az aktuális SQLite csak az ütközésben lévő nyilatkozat, és a tranzakció nem törlődik. Például, ha 10 sort próbál frissíteni, és az ötödik sor olyan értéket tartalmaz, amely ütközik egy megszorítással, akkor csak az ötödik érték nem frissül, de a többi 9 sor frissül. Hibaüzenet jelenik meg.
  3. FAIL – megszakítja az aktuális SQLite kijelentés, amely az ütközést tartalmazza. A tranzakció azonban nem folytatódik, de az ütközést tartalmazó sor előtti sorokban végrehajtott korábbi módosítások végrehajtásra kerülnek. Például, ha 10 sort próbál frissíteni, és az ötödik sor olyan értéket tartalmaz, amely ütközik egy megszorítással, akkor csak a 4 sor frissül, a másik pedig nem. Hibaüzenet jelenik meg.
  4. IGNORE – ez kihagyja a korlátozás megsértését tartalmazó sort, és folytatja a következő sorok feldolgozását. SQLite nyilatkozat. Például, ha 10 sort próbál frissíteni, és az ötödik sor olyan értéket tartalmaz, amely ütközik egy megszorítással, akkor csak a 4 sor frissül, a másik pedig nem. Nem folytatja a további sorok frissítését, és megáll az ütköző értékkel rendelkező sornál. Hiba nem fog megjelenni.
  5. CSERÉLÉS – a szabálysértést okozó korlátozás típusától függ:
    • Ha az EGYEDI vagy ELSŐDLEGES KULCS kényszer megsértése történik. A REPLACE lecseréli a szabálysértést okozó sort az új beszúrt vagy frissített sorra.
    • Ha a NOT NULL megszorítás megsértése történik, a REPLACE záradék lecseréli a NULL értéket az adott oszlop alapértelmezett értékére. Ha az oszlopnak nincs alapértelmezett értéke, akkor SQLite megszakítja a nyilatkozatot (kivonat törlődik)
    • HA a CHECK kényszer megsértése megtörténik, a záradék megszakad.

Megjegyzés: A fenti 5 megoldási lehetőség a konfliktus megoldására. Nem feltétlenül alkalmazható az egyik konfliktus megoldására más típusú konfliktusok megoldására is.

Hogyan kell deklarálni a CONFLICT záradékot

Az ON CONFLICT záradékot akkor deklarálhatja, amikor a CREATE TABLE záradékon belül megszorítást ad meg egy oszlopdefinícióhoz. A következő szintaxis használata:

SQLite Konfliktus záradék

Az öt megoldás közül választhat egyet a konfliktus feloldásához, ahogyan azt korábban leírtuk.

A KONFLIKTUS IGNORÁLÁSÁRÓL Példa

Step 1) Hozzon létre egy új táblázat tárgyát az alábbiak szerint:

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

Figyeljük meg, hogy a SubjectId oszlopban definiáltunk egy PRIMARY KEY megszorítást. Az elsődleges kulcs megszorítás nem engedélyezi két ismétlődő érték beszúrását a SubjectId oszlopba, így az oszlopban lévő összes értéknek egyedinek kell lennie. Azt is figyeljük meg, hogy az ütközés feloldására az „IGNORE” lehetőséget választottuk.

A parancsnak sikeresen le kell futnia, és nem jelenhet meg semmilyen hiba:

A KONFLIKTUS IGNORÁLÁSÁRÓL Példa

Step 2) Most pedig szúrjunk be néhány értéket az új táblázattárgyakba, de olyan értékkel, amely sérti az elsődleges kulcs megkötését:

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

Ebben az INSERT utasításban megpróbáltunk két kurzust beszúrni ugyanazzal a 2-es elsődleges kulcstárgy-azonosítóval, ami sérti az elsődleges kulcs megkötését.

A parancsoknak megfelelően kell futniuk, és nem szabad semmilyen hibát észlelnie. A következőképpen:

A KONFLIKTUS IGNORÁLÁSÁRÓL Példa

Step 3) Válassza ki az összes tárgyat a táblázatból az alábbiak szerint:

SELECT * FROM Subjects;

Ekkor megjelenik a tantárgyak listája:

A KONFLIKTUS IGNORÁLÁSÁRÓL Példa

Figyeljük meg, hogy csak három tantárgyat illesztettek be: „Algebra, Adatbázis kurzus és Algorithms” 4 sor helyett.

A rendszer figyelmen kívül hagyta és nem szúrta be azt a sort, amelynek értéke sérti az elsődleges kulcs megkötését, azaz az „Adatstruktúrák”. Azonban, SQLite a sor után folytatja a többi utasítás végrehajtását.

Step 4) TÖRLÉSE a táblázat tárgyait, hogy újból létrehozza egy másik ON CONFLICT záradékkal a következő példában a következő parancs futtatásával:

DROP TABLE Subjects;

A drop parancs törli a teljes táblát. A Table Subjects most nem létezik.

ON CONFLICT REPLACE Példa

Step 1) Hozzon létre egy új táblázat tárgyát az alábbiak szerint:

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

Figyelje meg, hogy a SubjectId oszlopban meghatároztunk egy PRIMARY KEY kényszert. Az elsődleges kulcs megszorítása nem teszi lehetővé két duplikált érték beszúrását a SubjectId oszlopba, hogy az oszlopban lévő összes érték egyedi legyen.

Azt is vedd figyelembe, hogy a konfliktusfeloldási opciót a „REPLACE”-re választottuk. A parancsnak sikeresen le kell futnia, és nem szabad hibákat kapnod:

ON CONFLICT REPLACE Példa

Step 2) Most szúrjunk be néhány értéket az új Tárgyak táblába, de olyan értékkel, amely sérti az elsődleges kulcs megkötését:

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

Ebben az INSERT utasításban megpróbáltunk két kurzust beszúrni ugyanazzal a 2-es elsődleges kulcstárgy-azonosítóval, ami sérti az elsődleges kulcs megkötését.

A parancsoknak megfelelően kell futniuk, és nem szabad semmilyen hibát észlelnie. A következőképpen:

ON CONFLICT REPLACE Példa

Step 3) Válassza ki az összes tárgyat a táblázatból az alábbiak szerint:

SELECT * FROM Subjects;

Ekkor megjelenik a tantárgyak listája:

ON CONFLICT REPLACE Példa

Figyeljük meg, hogy csak három tantárgyat illesztettek be: „Algebra, Adatszerkezetek és Algorithms”, míg mi 4 sort próbáltunk beszúrni.

Az elsődleges kulcskorlátozást megsértő értéket tartalmazó sor, amely az „Adatszerkezetek”, az „Adatbázis tanfolyam” értéket a következőképpen cserélte le:

  • Az első két beillesztési utasítás hibátlanul fut. Két tárgy, az algebra és az adatbázis kurzus kerül beillesztésre 1-es, 2-es azonosítókkal.
  • Amikor SQLite Ha megpróbálja lefuttatni a harmadik beszúrási utasítást a 2-es SubjectId és a „Data Structures” SubjectName paraméterekkel, azt tapasztalja, hogy már létezik egy 2-es SubjectId értékű alany. Ez sérti a SubjectId oszlopban definiált elsődleges kulcskorlátozást.
  • SQLite A REPLACE utasítás egy REPLACE feloldást választ erre az ütközésre. Ez a subjects táblában már létező értéket lecseréli az INSERT utasításból származó új értékre. Így az „Adatbázis kurzus” SubjectName értéke az „Adatstruktúrák” SubjectName értékre lesz cserélve.

GYIK

Az UPSERT egyesíti a beszúrást és az frissítést. Mivel SQLite 3.24.0 (2018), INSERT INTO … ON CONFLICT(oszlop) DO UPDATE SET … új sort szúr be, vagy frissíti a meglévőt, ha UNIQUE vagy PRIMARY KEY ütközés történik. A DO NOTHING parancs instant módon kihagyja a sort.

Az INSERT OR REPLACE törli az ütköző sort, és egy újat szúr be, így a nem listázott oszlopok visszaállnak az alapértelmezett értékre. ON CONFLICT DO UPDATE a meglévő sort a helyén szerkeszti, megtartva aping más oszlopok épek, ami biztonságosabbá teszi az igazi felfelé irányuló állítást.

Soroljon fel több értékcsoportot a VALUES után, vesszővel elválasztva: INSERT INTO Students (id, name) VALUES (1,'A'), (2,'B'), (3,'C');. Ez a többsoros űrlap a következő időponttól működik: SQLite 3.7.11-es verzióban, és gyorsabb, mint soronként egy INSERT utasítás futtatása.

Futtassa a DELETE FROM table_name; parancsot WHERE záradék nélkül. SQLite nincs TRUNCATE parancsa, de csonkolásoptimalizálást alkalmaz, amely egyszerre törli az összes sort. A tábla szerkezete megmarad; a DROP TABLE paranccsal teljesen eltávolítható a tábla.

Óta SQLite A 3.35.0 (2021) verzióban az INSERT, UPDATE és DELETE utasítások elfogadnak egy opcionális RETURNING záradékot, amely kiírja az érintett sorokat. Például az INSERT … RETURNING id; utasítás azonnal visszaadja a generált értékeket, elkerülve egy külön SELECT utasítást a változások kiolvasásához.

Használja az INSERT INTO … KIVÁLASZTÁS parancsot: INSERT INTO Archive (azonosító, név) SELECT azonosító, név FROM Hallgatók WHERE TanszékId = 4;. SQLite A SELECT függvény minden olyan sort beszúr, amelyet a SELECT visszaad, így az oszlopok sorrendjének és számának meg kell egyeznie a céltáblázatban szereplőkkel.

Igen. A mesterséges intelligenciával működő szöveg-SQL asszisztensek egyszerű angol kéréseket alakítanak át SQLite INSERT, UPDATE és DELETE utasítások, beleértve a WHERE és ON CONFLICT záradékokat. A tábla- és oszlopnevek megadása javítja a pontosságot, és minden létrehozott utasítást át kell tekinteni és tesztelni kell, mielőtt valós adatokon futtatnánk.

GitHub másodpilóta javasolja SQLite INSERT, UPDATE és DELETE lekérdezések beágyazva olyan szerkesztőkbe, mint a VS CodeBeolvassa a közeli sémákat és megjegyzéseket, így a kiegészítések újra felhasználják a valódi tábla- és oszlopneveket, de a végrehajtás előtt továbbra is ellenőrizni kell az egyes utasításokat.

Foglald össze ezt a bejegyzést a következőképpen: