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.

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:
Step 2) Nyissa meg a „TutorialsSampleDB.db” adatbázist a következő paranccsal:
.open TutorialsSampleDB.db
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ő:
- 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:
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 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:
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:
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 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ő:
- 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:
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 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:
- 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.
- 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.
- 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.
- 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.
- 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:
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:
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:
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:
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:
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:
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:
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.


















