Az SQLite adatbázis elsajátítása Pythonban

Az SQLite egy relációs adatbázis-kezelő rendszer, amely az SQL nyelvre épül; szerver nélküli, nulla konfigurációjú adatbázis-motor. Ez az egyik legnépszerűbb adatbázis-motor, és nagyon könnyen használható kis alkalmazásokban. Csak egy lemezfájlt hoz létre a teljes adatbázis tárolására, ami hordozhatóvá teszi a fájlt. Az Android OS-ben használják elsődleges forrásként az adatok tárolására. A Google Chrome a webhely és a felhasználói adatok, beleértve a jelszavakat is, a helyi gépen tárolja.

Haladó az SQLite Database alkalmazással a Pythonban

Ebben az oktatóanyagban a témák a következők lesznek: képek beszúrása egy SQLite táblába, az adatbázisban lévő táblák felsorolása, az adatbázis csatlakozása óta bekövetkezett összes változás azonosítása, egy adatbázis biztonsági mentése, egy SQLite adatbázis dömpingje, visszagörgetés az SQLite-ben, törlés rekordok egy táblából, egy asztal eldobása és az SQLite adatbázis-kivételek.

Érdemes megtekinteni az oktatóanyag első részét, amely bemutatja a Az SQLite alapjai, Használatának előnyei, Csatlakozás adatbázis fájlhoz, Tábla létrehozása az adatbázisban, Adatok beszúrása a táblába, Adatok lekérdezése a táblából, A táblázat frissítése és még sok más.

Fájlok és képek az SQLite adatbázisban

Az adatbázisokkal való munka során vannak olyan helyzetek, amikor képeket vagy fájlokat kell beillesztenie egy adatbázisba, vagy exportálnia kell onnan. Például, ha adatbázist hoz létre az alkalmazottak adatainak tárolására, akkor előfordulhat, hogy minden egyes alkalmazott képét be kell illesztenie az adatbázisba.

Képek hozzáadásához az SQLite adatbázisba az SQLite BLOB adattípusát kell használnunk. A BLOB () adattípust nagy objektumok, általában nagy fájlok, például képek, zene, videók, dokumentumok, PDF stb. Tárolására használják. Az első lépés az adatok és képek konvertálása a Python bájtobjektumává, amely hasonló az SQLite BLOB adattípusához. A folytatás előtt hozzon létre egy nevű táblázatot diák az adatbázisban az id, név, képek, jelölések mezőkkel. Futtassa a következő kódot a tábla létrehozásához.

import sqlite3 conn = sqlite3.connect ("minta.db ") print (" \ n [+] Sikeresen kapcsolódott az adatbázishoz ") cur = conn.kurzor () print ("\ n [+] A kurzor beállítása sikeresen megtörtént") tábla = cur.execute ("" "CREATE TABLE student (id INT PRIMARY KEY, name TEXT, images BLOB, marks TEXT);" "") print ("\ n [+] A táblázat sikeresen létrehozva") cur.bezár () konn.bekötni () beköt.Bezárás()

Ez a program létrehoz egy új táblázatot a névvel diák. A következő kimenetet fogja látni a terminálon.

Kép beszúrása

Kép beszúrásához egy SQLite adatbázisba alakítsa át a képet egy python bájtos objektumban, majd illessze be a képek oszlopba, amely elfogadja a BLOB adatokat. Kép hozzáadásához futtassa a következő kódot img.png az adatbázisban a Python segítségével.

import sqlite3 conn = sqlite3.connect ("minta.db ") konn.text_factory = str print ("\ n [+] Sikeresen kapcsolódott az adatbázishoz") cur = conn.kurzor () print ("\ n [+] A kurzor sikeresen beállítva") nyitott ("img.png "," rb ") fájlként: adat = fájl.read () python_tuple = (101, "robin", data, "90") print ("\ n [+] A kép sikeresen importálva") print ("\ n [+] Most beillesztés az adatbázisba") cur.végrehajtani ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (?,?,?,?) ", python_tuple) print (" \ n [+] Az adatok sikeresen beillesztve ") cur.bezár () konn.bekötni () bekötni.Bezárás()

Ez a program beilleszti a képet a létrehozott hallgatói adatbázisba. A következő kimenetet fogja látni.

A fenti programban bináris módban megnyitottuk a fájlt, minden bájtot elolvastunk és változóban tároltunk adat. Ezután az INSERT utasításban ezt a változót használjuk a kép beillesztésére az adatbázisba.

Kép lekérése

Kép lekéréséhez az adatbázisból töltse le a sort egy select utasítás segítségével, majd férjen hozzá a kép bináris adataihoz egy python változóba, amelyet egy képfájl tárol. Az illusztrációhoz lásd a következő kódot.

import sqlite3 conn = sqlite3.connect ("minta.db ") konn.text_factory = str print ("\ n [+] Sikeresen kapcsolódott az adatbázishoz") cur = conn.kurzor () print ("\ n [+] A kurzor sikeresen beállítva") print ("\ n [+] A kép lekérése") cur.végrehajtani ("SELECT * FROM hallgató") ret = cur.fetchall () for i in ret: data = i [2] open ("img2.png "," wb ") fájlként: fájl.write (data) print ("\ n [+] A kép mentve") cur.bezár () konn.bekötni () bekötni.Bezárás()

Ez az egyszerű program lekéri a képet az adatbázisból, és elmenti az i nevű lemezremg2.png. A képfájlnak más nevet is választhat. A program kimenete az alábbiakban látható.

Sorolja fel az adatbázis összes tábláját

Egy adatbázisban számos táblázatot készíthetünk. Tehát fel kell sorolni az összes táblázatot egy adatbázisban. Az adatbázisban található táblák felsorolásához az SQL SELECT utasítással kérdezze le az sqlite_master táblát. A lekérdezés szintaxisa a következő lesz:

Név kiválasztása FROM sqlite_master WHERE type = "table"

Így használjuk ezt a lekérdezést az adatbázisunkban található összes táblázat felsorolásához.

import sqlite3 conn = sqlite3.connect ("minta.db ") print (" \ n [+] Sikeresen kapcsolódott az adatbázishoz ") cur = conn.kurzor () print ("\ n [+] Kurzor beállítása sikeresen") cur.execute ("SELECT name from sqlite_master where type =" table "") rows = cur.fetchall () print (sorok) cur.bezár () konn.bekötni () beköt.Bezárás()

A fenti kód felsorolja az adatbázisunkban található összes táblázatot. A végrehajtáskor a kód által előállított kimenet a következő. Az adatbázisban létrehozott tábláktól függően más kimenetet is láthat.

Az adatbázishoz való kapcsolódás óta bekövetkezett összes változás azonosítása

Bármely helyzetben hasznos meghatározni az adatbázis összekapcsolása óta módosított, beillesztett vagy törölt sorok számát. Ehhez használja a total_changes () a kapcsolatobjektum metódusa, amely visszaadja a kapcsolat óta érintett adatbázis-sorok teljes számát. Nézzünk meg egy példa bemutatót, hogy megtudjuk, hogyan működik.

import sqlite3 conn = sqlite3.connect ("minta.db ") konn.text_factory = str print ("\ n [+] Sikeresen kapcsolódott mindkét adatbázishoz") cur = conn.kurzor () print ("\ n [+] Mindkét kurzor sikeresen beállítva") cur.végrehajtani ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (140, 'David',", 99) ") cur.végrehajtani ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (150, 'Sam',", 97) ") változtatások = csatlakozás.total_changes print ("\ n [+] A sorok változása összesen:", változtatások) conn.elkötelez () cur.bezár () konn.Bezárás()

A fenti program kinyomtatja az aktuális kapcsolat sorváltozásainak számát. A következő kimenetet fogja látni.

Visszagörgetés az SQLite-ben

Egyes feladatok visszavonásakor használhatja a rollback () funkciót. Ezzel a módszerrel visszavonható az a feladat, amely az utolsó elkötelezettség után történt. Az alábbi példát szemlélteti.

import sqlite3 conn = sqlite3.connect ("minta.db ") konn.text_factory = str print ("\ n [+] Sikeresen kapcsolódott mindkét adatbázishoz") cur = conn.kurzor () print ("\ n [+] Mindkét kurzor sikeresen beállítva") cur.végrehajtani ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (100001, 'David',", 99) ") cur.végrehajtani ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (100002, 'Sam',", 97) ") összeköttetés.comm () print ("\ n [+] A két sort sikeresen beillesztettük") cur.végrehajtani ("SELECT * FROM hallgató") először = cur.fetchall () print ("\ n [+] Az adatbázis új rekordjai:") az i-hez először: print (i) cur.végrehajtani ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (10003, 'Kishan',", 100) ") cur.végrehajtás ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (10004, 'Ankit',", 100) ") nyomtatás (" \ n [+] A két sort sikeresen beillesztettük, de nem határoztuk meg ") conn.rollback () print ("\ n [+] Visszagörgetjük az előző parancsokat, így az új adatok nem kerülnek beillesztésre") conn.elkötelez () cur.végrehajtani ("SELECT * FROM hallgató") másodperc = cur.fetchall () print ("\ n [+] Az adatbázis új rekordjai:") i-re másodpercenként: print (i) cur.bezár () konn.Bezárás()

A fenti példában az első két beszúrási utasítás beszúrja az adatokat a megadott módon, de az utolsó két beszúrási utasítás visszagörgetésre kerül, így nem adnak hozzá adatokat a táblához. A kimenet az alábbiakban látható lesz.

Biztonsági másolat készítése egy adatbázisról

Az adatbázissal való munka során elengedhetetlen az adatbázisról biztonsági másolat készítése. Az sqlite3 modul funkciót kínál az adatbázis biztonsági mentésének elkészítéséhez. A kapcsolatobjektum backup () metódusával elkészíthetjük az SQLite adatbázis biztonsági mentését. A biztonsági mentési módszer szintaxisa a következő:

biztonsági mentés (cél, *, oldalak = 0, haladás = nincs, név = "fő", alvás = 0.250)

Alapértelmezés szerint, vagy mikor oldalakat vagy 0 vagy negatív egész szám, a teljes adatbázist egyetlen lépésben másoljuk, ami előnyös egy kis adatbázis esetében; különben a módszer hurok másolást hajt végre oldalakat olyan időben, amelyet a kiterjedt adatbázissal meg lehetett tenni. A név Az argumentum megmutatja a másolni kívánt adatbázis nevét: egy karakterláncnak kell lennie, amely vagy az alapértelmezettet tartalmazza a fő adatbázis, vagy az ideiglenes adatbázis megjelölésére. A alvás argument megadja az alvás idejét másodpercekben a fennmaradó oldalak biztonsági mentésének kísérletei között. Ez lehet egész szám vagy lebegőpontos érték.

Készítsen biztonsági másolatot a adatbázis.db az oktatóanyagban használt adatbázis.

import sqlite3 conn_main = sqlite3.connect ("minta.db ") conn_backup = sqlite3.connect ("minta_mentés.db ") print (" \ n [+] Sikeresen kapcsolódott mindkét adatbázishoz ") cur_main = conn_main.kurzor () cur_backup = conn_backup.kurzor () print ("\ n [+] Mindkét kurzor sikeresen beállítva") conn_main.biztonsági másolat (conn_backup, pages = 0, progress = Nincs, name = "main") print ("Az adatbázis biztonsági mentése sikeresen megtörtént") cur_main.bezár () cur_backup.bezár () conn_main.comm () conn_backup.elkötelez () conn_main.bezár () conn_backup.Bezárás()

A fenti kódban a két adatbázis összekapcsolódik, az egyik az az adatbázis, amelyről biztonsági másolatot akarunk készíteni, a másik az az adatbázis, amelyben a biztonsági másolatot készítjük. Használja a biztonsági mentés() az első adatbázis-kapcsolatobjektum biztonsági mentés készítésének módszere. Ez a függvény a második adatbázis csatlakozási objektumát fogadja el célként, hogy biztonsági másolatot készítsen a másik adatbázisról. Használja a oldal = 0 argumentum, tehát a folyamat egy lépésben fog lezajlani, ami a kis adatbázisokhoz ajánlott. Ez a program új adatbázisnévmintát hoz létre_biztonsági mentés.db és töltse ki az első adatbázis biztonsági másolatával. Láthatja, hogy az aktuális mappában új adatbázis jött létre, az előző fájlmérettel megegyező.

SQLite adatbázis dömpingje

Fontos feladat az adatbázisok lerakása. Általában a dump fájl az adatok SQL utasításainak halmaza, amelyet általában biztonsági másolat készítésére használnak. Kiírhatunk egy adatbázist a dump () módszerrel. Az alábbi példában megtudhatja, hogyan dobhatja le az SQLite adatbázist.

import sqlite3 con = sqlite3.connect ("adatbázis.db ") nyitott ('dump.sql ',' w ') as f: a vonalhoz a con-ban.iterdump (): f.írás ('% s \ n'% sor)

A fenti program ki fogja dobni az adatbázis mintáját.db, és a kiíratott adatokat a dump nevű fájlba menti.sql. Megtekintheti a python fájlok aktuális könyvtárában található adatokat, és bármely szövegszerkesztővel megnyithatja.

Az SQLite3 végrehajtóanyaga () metódusa

A végrehajtó sok () metódus végrehajt egy SQL parancsot a szekvenciában található összes paramétersorozat vagy leképezés ellen seq_of_parameters. Az egyszerűség kedvéért ezzel a módszerrel a legtöbb SQL-parancs egy sorban hajtható végre. E.g., A parancs segítségével tetszőleges számú sort beszúrhatunk egy python-listán. Az illusztrációt lásd az alábbi példában.

import sqlite3 conn = sqlite3.connect ("minta.db ") print (" \ n [+] Sikeresen kapcsolódott az adatbázishoz ") cur = conn.kurzor () print ("\ n [+] A kurzor beállítása sikeresen megtörtént") python_list = [(10000000, 'vivek', ", '10'), (100000001, 'rose',", '21'), (100000002, 'robin', ',' 31 '), (100000003,' Dev ',', '4'), (100000004, 'michael', ',' 52 ')] cur.végrehajtó sok ("INSERT INTO hallgató (azonosító, név, képek, jelölések) ÉRTÉKEK (?,?,?,?) ", python_list) print (" \ n [+] Minden adat sikeresen beillesztve ") cur.bezár () konn.bekötni () beköt.Bezárás()

A fenti program beszúrja a python listában megadott összes adatot. Az alábbiakban látható a program által elért kimenet.

Rekordok törlése egy táblázatból

A DELETE művelettel törölhetünk rekordokat egy táblából. Gyorsan eltávolíthatunk egy sort a DELETE művelettel a WHERE záradékkal. A DELETE utasítás alapvető szintaxisa a következő:

TÖRLÉS a table_name helyről WHERE some_condition;

Lássunk egy példát. Töröljük az 1001 azonosítóval rendelkező sort adatbázisunk alkalmazott táblájából.

import sqlite3 conn = sqlite3.connect ("minta.db ") konn.text_factory = str print ("\ n [+] Sikeresen kapcsolódott az adatbázishoz") cur = conn.kurzor () print ("\ n [+] Kurzor beállítása sikeresen") cur.execute ("DELETE FROM student WHERE id = 1001") print ("\ n [+] A sor sikeresen törölve") cur.végrehajtani ("SELECT * FROM hallgató") adatok = cur.fetchall () az adatok sorához: print (sor) cur.bezár () konn.bekötni () beköt.Bezárás()

A fenti kód törli a 1001 azonosítójú sort. A SELECT utasítás visszatéréséből láthatja, hogy a sort eltávolították. A program kimenete az alábbiakban látható.

Dobjon el egy asztalt

Az SQLite DROP utasítás segítségével gyorsan eldobhatunk vagy törölhetünk egy táblázatot. A DROP utasítás szintaxisa az alábbiak szerint alakul:

DROP tábla tábla_neve 

Ha a táblázat nem létezik, akkor az SQLite hibát dob, így ennek megakadályozása érdekében használhatjuk a ha léteznek tag a DROP utasítással. Lásd az alábbi szintaxist:

DROP tábla, ha létezik tábla_neve

Nézzük meg, hogyan használhatjuk ezt az állítást a python-nal sqlite3 modul törléséhez. Ebben a programban eltávolítjuk a diák táblázat, amelyet korábban készítettünk.

import sqlite3 conn = sqlite3.connect ("minta.db ") konn.text_factory = str print ("\ n [+] Sikeresen kapcsolódott az adatbázishoz") cur = conn.kurzor () print ("\ n [+] Kurzor beállítása sikeresen") cur.execute ("DROP TABLE IF EXISTS student") print ("\ n [+] A tábla sikeresen leesett") cur.bezár () konn.bekötni () beköt.Bezárás()

A fenti program törli a táblázatot diák tól minta adatbázis. Használhatjuk a list tábla parancsot, amelyet korábban láttunk, hogy megnézzük, a tábla törölve van-e. A program kimenete az alábbiakban látható.

SQLite adatbázis kivételek

Néhány SQLite adatbázis-kivétel felmerülhet valamilyen hiba miatt. Lássuk egy kicsit, mikor merültek fel ezek a hibák.

• sqlite3.Figyelem: Ez a kivétel egy alosztálya. Ez a kivétel néhány figyelmeztetést mutat, és ezeket sok esetben figyelmen kívül lehet hagyni.
• sqlite3.Hiba: Ez is a kivétel egyik alosztálya. Ez az összes többi kivétel alaposztálya a sqlite3 modul.
• sqlite3.DatabaseError: Ezek azok a hibák, amelyek az adatbázisokban előforduló hibák miatt merülnek fel. Például: - Ha megpróbálunk egy titkosított adatbázishoz vagy rossz adatbázisfájlhoz csatlakozni, akkor az egy DatabaseError-t mutat, hogy az adatok titkosítva vannak, vagy nem érvényes adatbázis-fájlokkal.
• sqlite3.IntegrityError: Ez a kivétel a DatabaseError egyik alosztálya. Ezt a kivételt akkor kapjuk meg, ha az adatbázis relációs integritását befolyásolja, pl.g., Hiba a külföldi kulcsok ellenőrzésében.
• sqlite3.ProgrammingError: Ez a kivétel a DatabaseError alosztálya is. Ez a kivétel programozási hibák miatt merül fel, pl.g., egy már létező azonos nevű tábla létrehozása, szintaxis hiba az SQL lekérdezésekben stb.
• sqlite3.OperationalError: A DatabaseError alosztálya is. Ez a kivétel olyan hibákra vonatkozik, amelyek az adatbázis működéséhez kapcsolódnak, és nem tartoznak a mi kezünkbe. Például egy véletlenszerű lekapcsolás a rendszer leállásával, a kiszolgáló leállásával, időtúllépéssel, adatforrással kapcsolatos problémákkal, a gép leállításával stb.
• sqlite3.NotSupportedError: Ez a kivétel akkor merül fel, ha az adatbázis nem támogatja a használt adatbázis API-t.

Ez az összes SQLite kivétel felsorolása; ezeket a kivételeket programjainkban kezelhetjük a Python alapvető try / kivétel hibakezelési módszerével.

Következtetés

Ezzel eljutottunk az SQLite Python használatával kapcsolatos fejlett módszerekről szóló átfogó útmutató végéhez. Remélem, hogy megtanulta az SQLite3 összes aspektusát a Python használatával, ami fantasztikus Python projektek felépítésében segít.