Golang SQLite példák

Golang Sqlite Peldak



A Golang egy nyílt forráskódú programozási nyelv. Támogatja a különböző típusú adatbázis-eszközöket. Az SQLite egy népszerű relációs adatbázis-motor, és a Golang rendelkezik egy adatbázis/SQL-csomaggal, amellyel csatlakozhat az SQLite adatbázishoz, és különböző típusú adatbázis-feladatokat hajthat végre. Megjelenik az SQLite adatbázishoz való kapcsolódás módja és különböző típusú adatbázis-műveletek végrehajtása, mint például a tábla létrehozása, a rekordok beillesztése a táblába, az adatok kiolvasása a táblából, a tábla adatainak frissítése és a rekordok törlése a táblából. ebben az oktatóanyagban a Golang szkript használatával.

Előfeltételek:

Az oktatóanyagban szereplő példák gyakorlása előtt a következő feladatokat kell végrehajtania:

V. Telepítse a Golang nyelvet a rendszerbe, ha korábban nem volt telepítve. Futtassa a következő parancsot a Golang telepített verziójának ellenőrzéséhez:







$ go verzió



B. Telepítse az sqlite3-at a rendszerbe, ha korábban még nem volt telepítve. Az Sqlite3 alapértelmezés szerint telepítve van az Ubuntu 20+ rendszeren. Futtassa a következő parancsot az sqlite3 telepített verziójának ellenőrzéséhez:



$ sqlite3 --verzió





C. Futtassa a következő parancsokat egy „golang-sqlite” nevű mappa létrehozásához, és lépjen abba a mappába, ahol az SQLite adatbázisfájl és a Golang fájl tárolásra kerül:

$ mkdir golang-sqlite
$ cd golang-sqlite

D. Futtassa a következő parancsot a szükséges Golang-csomag letöltéséhez, hogy használni tudja az SQLite-ot a Golanggal:



$ menj, szerezd be a github.com/mattn/go-sqlite3-at

Adatbázisműveletek Golang és SQLite használatával

Az SQLite adatbázist és a Golang szkriptet használó alapvető adatbázisműveletek láthatók ebben az oktatóanyagban. Az oktatóanyagban szereplő adatbázis-feladatok listája a következőkben található:

  1. Hozzon létre egy SQLite adatbázist
  2. Hozzon létre egy SQLite adatbázis-kapcsolatot
  3. Hozzon létre egy új táblázatot
  4. Illessze be az adatokat a táblázatba
  5. Olvassa el az adatokat a táblázatból
  6. Frissítse a táblázat adatait
  7. Törölje az adatokat a táblázatból

Hozzon létre egy SQLite adatbázist a Golang segítségével

Hozzon létre egy Golang fájlt a következő szkripttel, amely létrehoz egy új „test.db” nevű SQLite adatbázisfájlt. Négy modul importálva van a szkriptbe. Az „fmt” modul a kimenet kinyomtatására szolgál a terminálon. A „napló” modul a program megszakítására szolgál, ha bármilyen hiba jelentkezik. Az „os” modul az SQLite adatbázis létrehozására és a hiba kezelésére szolgál. A „go-sqlite3” modul az SQLite adatbázissal való kapcsolatok létrehozására szolgál a Golangon keresztül. Az „os” modul Create() metódusa itt SQLite adatbázis létrehozására szolgál. Ha az adatbázis sikeresen létrejött, a terminálban sikeres üzenet kerül nyomtatásra. Ellenkező esetben a program leáll. A Close() metódus meghívása az adatbázis-kapcsolat lezárására szolgál.

csomag fő-

//Importálja a szükséges modulokat
import (
'fmt'
'napló'
'te'
_ 'github.com/mattn/go-sqlite3'
)

func fő- () {

//Új SQLite adatbázis létrehozása
db , téved := te . Teremt ( 'teszt.db' )
//Ellenőrizze az esetleges hibákat
ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
//Nyomtassa ki a sikerüzenetet
fmt . Println ( 'Az adatbázis létrejött.' )
}
//Az adatbázis-kapcsolat bezárása
db . Bezárás ()
}

Futtassa a következő parancsot a „db_connect.go” fájl végrehajtásához:

$ go futtassa a db_connect.go-t

Futtassa az „ls” parancsot annak ellenőrzésére, hogy a „test.db” adatbázisfájl létrejött-e vagy sem:

$ ls

A következő kimenet azt mutatja, hogy az „Adatbázis létrehozva” sikerüzenet kerül kinyomtatásra a kimenetbe, és a „test.db” fájl létrejön az aktuális helyen:

Csatlakozzon egy SQLite adatbázishoz a Golang segítségével

Hozzon létre egy Golang fájlt a következő szkripttel, amely megnyitja a „test.db” adatbázisfájlt, és hozzon létre kapcsolatot az adatbázissal. A feladat elvégzéséhez a Golang adatbázis/SQL modulja importálva ide. Itt az open() metódus használható a meglévő SQLite adatbázissal való kapcsolat létrehozására. Ha az adatbázis sikeresen csatlakozik, egy sikerüzenet kerül kinyomtatásra a terminálon. Ellenkező esetben a program leáll.

csomag fő-

//Importálja a szükséges modulokat
import (
'fmt'
'napló'
'adatbázis/sql'
_ 'github.com/mattn/go-sqlite3'
)

func fő- () {

//Új SQLite adatbázis létrehozása
db , téved := sql . Nyisd ki ( 'sqlite3' , 'teszt.db' )
//Ellenőrizze az esetleges hibákat
ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
//Nyomtassa ki a sikerüzenetet
fmt . Println ( 'Az adatbázis sikeresen csatlakoztatva.' )
}
//Az adatbázis-kapcsolat bezárása
db . Bezárás ()
}

Futtassa a következő parancsot a „db_connect2.go” fájl végrehajtásához:

$ go futtassa a db_connect2.go-t

A következő kimenet azt mutatja, hogy a „test.db” adatbázisfájl megnyitása és sikeres csatlakoztatása megtörtént. Az „Adatbázis sikeresen csatlakoztatva” sikerüzenet jelenik meg a kimeneten:

Hozzon létre egy táblázatot egy SQLite adatbázisban a Golang segítségével

Hozzon létre egy Golang fájlt a következő szkripttel, amely létrehoz egy „members” nevű adatbázistáblát a „test.db” adatbázisfájlban. Az Exec() metódus itt a CREATE TABLE lekérdezés végrehajtására szolgál, amely létrehozza a „members” táblát hat mezővel és egy elsődleges kulccsal. Ha a tábla sikeresen létrejött az adatbázisban, a rendszer sikeres üzenetet nyomtat. Ellenkező esetben a program leáll.

csomag fő-

//Importálja a szükséges modulokat
import (
'fmt'
'napló'
'adatbázis/sql'
_ 'github.com/mattn/go-sqlite3'
)

func fő- () {

//Új sqlite adatbázis létrehozása
db , téved := sql . Nyisd ki ( 'sqlite3' , 'teszt.db' )
//Ellenőrizze az esetleges hibákat
ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
const lekérdezés húr = `
TÁBLÁZAT LÉTREHOZÁSA HA NEM LÉTEZIK tagok (
id INTEGER NOT NULL PRIMARY KEY,
név CHAR(40) NOT NULL,
mtype CHAR(100) NOT NULL,
e-mail CHAR(50),
cím TEXT NOT NULL,
mobil CHAR(25) NOT NULL);'.

_ , téved := db . Exec ( lekérdezés );

ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
//Nyomtassa ki a sikerüzenetet
fmt . Println ( 'A táblázat sikeresen létrejött.' )
}

}
//Az adatbázis-kapcsolat bezárása
db . Bezárás ()
}

Futtassa a következő parancsot a „create_table.go” fájl végrehajtásához:

$ go futtassa a create_table.go-t

A következő kimenet azt mutatja, hogy a tábla sikeresen létrejött az adatbázisban. A „Táblázat sikeresen létrehozta” sikerüzenet megjelenik a terminálban:

Az SQLite-ba bejelentkezve ellenőrizheti, hogy a tábla létrejött-e az adatbázisban vagy sem.

Futtassa a következő parancsot az SQLite futtatásához a „test.db” adatbázissal:

$ sqlite3 test.db

Futtassa a „.tables” SQLite parancsot az SQLite parancssorból az adatbázis táblaneveinek ellenőrzéséhez:

sqlite3 > .tables

A következő kimenet azt mutatja, hogy az adatbázis tartalmazza a „tagok” táblát, amely a Golang szkript végrehajtásával jön létre:

Helyezze be a rekordokat az SQLite táblába a Golang segítségével

Több rekord is beszúrható a táblába az INSERT lekérdezés többszöri végrehajtásával vagy több érték hozzáadásával egyetlen INSERT lekérdezésben. Hozzon létre egy Golang fájlt a következő szkripttel, amely három rekordot szúr be a „test.db” adatbázisfájl „members” táblájába egyetlen INSERT lekérdezéssel. Az Exec() metódus itt az INSERT lekérdezés végrehajtására szolgál. Ha a rekordokat sikeresen beszúrta a táblázatba, a rendszer sikeres üzenetet nyomtat. Ellenkező esetben a program leáll.

csomag fő-

//Importálja a szükséges modulokat
import (
'fmt'
'napló'
'adatbázis/sql'
_ 'github.com/mattn/go-sqlite3'
)

func fő- () {

//Új SQLite adatbázis létrehozása
db , téved := sql . Nyisd ki ( 'sqlite3' , 'teszt.db' )
//Ellenőrizze az esetleges hibákat
ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
const lekérdezés húr = `
INSERT INTO tagok (azonosító, név, mtype, email, cím, mobil)
VALUES(1, 'Nehal Ahmed', 'ezüst', 'nehal@gmail.com','36, Dhanmondi 2, Dhaka','01844657342'),
(2, 'Abir Chowdhury', 'Gold', 'abir@gmail.com', '102, Mirpur 10, Dhaka', '01994563423'),
(3, 'Mirza Abbas', 'Ezüst', 'abbas@gmail.com','12, Jigatala, Dhaka','01640006710');`


//Futtassa a lekérdezést
_ , téved := db . Exec ( lekérdezés );

ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
//Nyomtassa ki a sikerüzenetet
fmt . Println ( 'A rekordok sikeresen beszúrva.' )
}
}

//Az adatbázis-kapcsolat bezárása
db . Bezárás ()
}

Futtassa a következő parancsot az „insert_table.go” fájl végrehajtásához:

$ go futtassa az insert_table.go

A következő kimenet azt mutatja, hogy a rekordok sikeresen beszúrásra kerültek a táblázatba. A „Rekordok sikeresen beszúrva” sikerüzenet kerül kinyomtatásra a kimeneten:

Az SQLite-ba bejelentkezve ellenőrizheti, hogy a három rekord sikeresen bekerült-e a „tagok” táblába.

Futtassa a következő parancsot az SQLite futtatásához a „test.db” adatbázissal:

$ sqlite3 test.db

Futtassa a következő SELECT lekérdezést a „tagok” tábla teljes tartalmának elolvasásához:

sqlite3 > SELECT * A tagoktól ;

A következő kimenet azt mutatja, hogy a „tagok” tábla három rekordot tartalmaz, amelyeket a Golang szkript szúr be:

Olvassa el az SQLite tábla adatait a Golang segítségével

Hozzon létre egy Golang fájlt a következő szkripttel, amely beolvassa a „tagok” tábla rekordjait. Meg kell határoznia a változókat a Golangban, hogy tárolja a SELECT lekérdezésből visszaadott értékeket. Ebben a szkriptben a rendszer öt mezőt kér le a „members” táblából a SELECT lekérdezéssel. Tehát a szkriptben öt változó van meghatározva a „members” tábla öt mezőjének értékeinek tárolására, ahol az „mtype” mező értéke „Ezüst”. A Query() metódus itt használható a SELECT lekérdezés végrehajtására. Ezután a „for” ciklus a SELECT lekérdezés által visszaadott eredménykészlet beolvasására szolgál. A printf() függvény az eredményhalmaz formázott értékeinek kinyomtatására szolgál.

csomag fő-

//Importálja a szükséges modulokat
import (
'fmt'
'napló'
'adatbázis/sql'
_ 'github.com/mattn/go-sqlite3'
)

func fő- () {

//Új SQLite adatbázis létrehozása
db , téved := sql . Nyisd ki ( 'sqlite3' , 'teszt.db' )

//Ellenőrizze az esetleges hibákat
ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {

//Változók deklarálása a sorértékek tárolására
volt id int
volt név húr
volt mtype húr
volt cím húr
volt Mobil húr
const lekérdezés húr = `VÁLASSZON azonosítót, nevet, mtípust, címet, mobilt
A tagoktól
WHERE mtype = 'Ezüst';`


//Futtassa a lekérdezést
sorokat , téved := db . Lekérdezés ( lekérdezés );

ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {

//Nyomtassa ki a sikerüzenetet
fmt . Println ( 'Az összes ezüst tag rekordja:' )
fmt . Println ( 'ID \t Név \t \t Tag típusa \t Cím \t \t Elérhetőség' )
számára sorokat . Következő () {
sorokat . Letapogatás ( &id , &név , &mtype , &cím , &Mobil )
fmt . Printf ( '%d \t %s \t %s \t %s \t %s \n ' , id , név , mtype , cím , Mobil )
}
}
}
//Az adatbázis-kapcsolat bezárása
db . Bezárás ()
}

Futtassa a következő parancsot a „select_table.go” fájl végrehajtásához:

$ go futtassa a select_table.go

A „members” táblában két rekord található, amelyek „mtype” mezőjében „Silver” értéket tartalmaznak. A következő kimenet a „tagok” tábla két rekordját mutatja, amelyeket a SELECT lekérdezés ad vissza:

Frissítse az SQLite tábla adatait a Golang segítségével

Hozzon létre egy Golang fájlt a következő szkripttel, amely megváltoztatja a „members” tábla mobil mezőjének értékét, amely a 2 azonosító értékét tartalmazza. Itt az Exec() metódus használható az UPDATE lekérdezés végrehajtására. Ha a rekord sikeresen frissült a táblázatban, a rendszer sikeres üzenetet nyomtat. Ellenkező esetben a program leáll.

csomag fő-

//Importálja a szükséges modulokat
import (
'fmt'
'napló'
'adatbázis/sql'
_ 'github.com/mattn/go-sqlite3'
)

func fő- () {

//Új SQLite adatbázis létrehozása
db , téved := sql . Nyisd ki ( 'sqlite3' , 'teszt.db' )
//Ellenőrizze az esetleges hibákat
ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
const lekérdezés húr = `
UPDATE tagok SET mobile = '018563452390' WHERE id = 2;`

_ , téved := db . Exec ( lekérdezés );

ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
//Nyomtassa ki a sikerüzenetet
fmt . Println ( 'A rekord sikeresen frissítve.' )
}
}
//Az adatbázis-kapcsolat bezárása
db . Bezárás ()
}

Futtassa a következő parancsot az „update_table.go” fájl végrehajtásához:

$ go futtassa az update_table.go fájlt

A „tagok” táblában a második sor a 2-es azonosítót tartalmazza. A következő kimenet azt mutatja, hogy a tábla rekordja sikeresen frissült. A „Rekord frissítése sikeresen” üzenet jelenik meg a terminálon:

Az SQLite-ba bejelentkezve ellenőrizheti, hogy a tagtábla bármely rekordja frissült-e vagy sem.

Futtassa a következő parancsot az SQLite futtatásához a „test.db” adatbázissal:

$ sqlite3 test.db

Futtassa a következő SELECT lekérdezést a „tagok” tábla teljes tartalmának elolvasásához:

sqlite3 > SELECT * A tagoktól ;

A mobil mező értéke a 2 nd A tagtábla rekordja a „01994563423” a szkript végrehajtása előtt. A következő kimenet azt mutatja, hogy a mobil mező értéke a 2 nd a tagtábla rekordja a szkript végrehajtása után „018563452390” értékre módosul:

Törölje az SQLite tábla adatait a Golang segítségével

Hozzon létre egy Golang fájlt a következő szkripttel, amely törli a 3 rd a „members” tábla rekordja, amely a 3 azonosító értékét tartalmazza. Itt az Exec() metódus használható a DELETE lekérdezés végrehajtására. Ha a rekordot sikeresen törölték a táblából, a rendszer sikeres üzenetet nyomtat. Ellenkező esetben a program leáll.

csomag fő-

//Importálja a szükséges modulokat
import (
'fmt'
'napló'
'adatbázis/sql'
_ 'github.com/mattn/go-sqlite3'
)

func fő- () {

//Új SQLite adatbázis létrehozása
db , téved := sql . Nyisd ki ( 'sqlite3' , 'teszt.db' )
//Ellenőrizze az esetleges hibákat
ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
//A törlési lekérdezés meghatározása
const lekérdezés húr = `DELETE FROM tagok WHERE id = 3;`
//Futtassa a lekérdezést
_ , téved := db . Exec ( lekérdezés );

ha téved != nulla {
//A hibaüzenet hozzáadása a naplóhoz
log . Halálos ( téved )
} más {
//Nyomtassa ki a sikerüzenetet
fmt . Println ( 'A rekord sikeresen törölve.' )
}
}
//Az adatbázis-kapcsolat bezárása
db . Bezárás ()
}

Futtassa a következő parancsot a „delete_table.go” fájl végrehajtásához:

$ go futtassa a delete_table.go-t

A következő kimenet azt mutatja, hogy a 3 rd a „tagok” tábla rekordja sikeresen törölve. A „Rekord sikeresen törölve” sikerüzenet megjelenik a terminálon:

Az SQLite-ba bejelentkezve ellenőrizheti, hogy a tagtábla bármely rekordja törölve van-e vagy sem.

Futtassa a következő parancsot az SQLite futtatásához a „test.db” adatbázissal:

$ sqlite3 test.db

Futtassa a következő SELECT lekérdezést a „tagok” tábla teljes tartalmának elolvasásához:

sqlite3 > SELECT * A tagoktól ;

A következő kimenet azt mutatja, hogy a 3 rd a tagtábla rekordja a szkript végrehajtása után törlődik, a másik két rekord pedig kinyomtatásra kerül a kimenetben:

Következtetés

Mind az SQLite, mind a Golang népszerű most az egyszerűségük és a könnyű funkcióik miatt. Ezekkel az eszközökkel bármilyen egyszerű adatbázis-alapú alkalmazás könnyen megvalósítható. Minden alkalmazás fő része a CRUD művelet megvalósítása. A CRUD művelet végrehajtásának módszereit Golang szkript és SQLite adatbázis használatával több Golang fájl használatával ismertetjük ebben az oktatóanyagban. Ha még nem ismeri a Go nyelvet és az SQLite adatbázist, ez az oktatóanyag segít megtanulni ezeket az alapoktól.