Předpoklady:
Před procvičováním příkladů v tomto tutoriálu musíte splnit následující úkoly:
A. Nainstalujte jazyk Golang do systému, pokud nebyl nainstalován dříve. Spusťte následující příkaz a zkontrolujte nainstalovanou verzi Golang:
$ go verze
B. Nainstalujte sqlite3 do systému, pokud nebyl nainstalován dříve. Sqlite3 je standardně nainstalován na Ubuntu 20+. Spusťte následující příkaz a zkontrolujte nainstalovanou verzi sqlite3:
$ sqlite3 --verze
C. Spusťte následující příkazy pro vytvoření složky s názvem „golang-sqlite“ a přejděte do této složky, kde bude uložen soubor databáze SQLite a soubor Golang:
$ mkdir golang-sqlite$ cd golang-sqlite
D. Spusťte následující příkaz ke stažení potřebného balíčku Golang pro použití SQLite s Golang:
$ go get github.com/mattn/go-sqlite3
Databázové operace pomocí Golang a SQLite
Základní databázové operace pomocí SQLite databáze a Golang skriptu jsou ukázány v tomto tutoriálu. Seznam databázových úloh, které jsou zahrnuty v tomto kurzu, je uveden v následujícím textu:
- Vytvořte databázi SQLite
- Vytvořte připojení k databázi SQLite
- Vytvořte novou tabulku
- Vložte data do tabulky
- Přečtěte si data z tabulky
- Aktualizujte data tabulky
- Odstraňte data z tabulky
Vytvořte databázi SQLite pomocí Golang
Vytvořte soubor Golang pomocí následujícího skriptu, který vytvoří nový databázový soubor SQLite s názvem „test.db“. Do skriptu jsou importovány čtyři moduly. Pro tisk výstupu v terminálu se používá modul „fmt“. Modul „log“ se používá k přerušení programu, když se objeví jakákoli chyba. Modul „os“ se používá k vytvoření databáze SQLite a zpracování chyby. Modul „go-sqlite3“ se používá k navázání spojení s databází SQLite přes Golang. K vytvoření databáze SQLite je zde použita metoda Create() modulu „os“. Pokud je databáze úspěšně vytvořena, vytiskne se na terminálu zpráva o úspěchu. V opačném případě bude program ukončen. K uzavření databázového připojení je volána metoda Close().
balík hlavní//Importujte potřebné moduly
import (
'fmt'
'log'
'vy'
_ 'github.com/mattn/go-sqlite3'
)
func hlavní () {
//Vytvořte novou databázi SQLite
db , chybovat := vy . Vytvořit ( 'test.db' )
//Zkontrolujte případnou chybu
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Vytiskněte zprávu o úspěchu
fmt . Println ( 'Databáze je vytvořena.' )
}
//Uzavření připojení k databázi
db . Zavřít ()
}
Spuštěním následujícího příkazu spusťte soubor „db_connect.go“:
$ běž spustit db_connect.goSpusťte příkaz „ls“ a zkontrolujte, zda je soubor databáze „test.db“ vytvořen či nikoli:
$ lsNásledující výstup ukazuje, že zpráva o úspěchu „Databáze je vytvořena“ je vytištěna ve výstupu a soubor „test.db“ je vytvořen v aktuálním umístění:
Připojte se k databázi SQLite pomocí Golang
Vytvořte soubor Golang pomocí následujícího skriptu, který otevře soubor databáze „test.db“ a vytvořte spojení s databází. K provedení tohoto úkolu je zde importován databázový/SQL modul Golang. Metoda open() se zde používá k navázání spojení s existující databází SQLite. Pokud je databáze úspěšně připojena, vytiskne se na terminálu zpráva o úspěchu. V opačném případě bude program ukončen.
balík hlavní//Importujte potřebné moduly
import (
'fmt'
'log'
'databáze/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hlavní () {
//Vytvořte novou databázi SQLite
db , chybovat := sql . OTEVŘENO ( 'sqlite3' , 'test.db' )
//Zkontrolujte případnou chybu
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Vytiskněte zprávu o úspěchu
fmt . Println ( 'Databáze je úspěšně připojena.' )
}
//Uzavření připojení k databázi
db . Zavřít ()
}
Spuštěním následujícího příkazu spusťte soubor „db_connect2.go“:
$ běž spustit db_connect2.goNásledující výstup ukazuje, že databázový soubor „test.db“ je otevřen a úspěšně připojen. Na výstupu se vytiskne zpráva o úspěchu „Databáze je úspěšně připojena“:
Vytvořte tabulku v databázi SQLite pomocí Golang
Vytvořte soubor Golang pomocí následujícího skriptu, který vytvoří databázovou tabulku s názvem „členové“ uvnitř databázového souboru „test.db“. Metoda Exec() se zde používá ke spuštění dotazu CREATE TABLE, který vytvoří tabulku „členů“ se šesti poli a primárním klíčem. Pokud je tabulka úspěšně vytvořena v databázi, vytiskne se zpráva o úspěchu. V opačném případě bude program ukončen.
balík hlavní//Importujte potřebné moduly
import (
'fmt'
'log'
'databáze/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hlavní () {
//Vytvořte novou databázi sqlite
db , chybovat := sql . OTEVŘENO ( 'sqlite3' , 'test.db' )
//Zkontrolujte případnou chybu
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
konst dotaz tětiva = `
VYTVOŘIT TABULKU, POKUD NEEXISTUJE členové (
id INTEGER NOT NULL PRIMÁRNÍ KLÍČ,
jméno CHAR(40) NOT NULL,
mtype CHAR(100) NOT NULL,
e-mail CHAR(50),
adresa TEXT NENÍ NULL,
mobile CHAR(25) NOT NULL);“.
_ , chybovat := db . Exec ( dotaz );
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Vytiskněte zprávu o úspěchu
fmt . Println ( 'Tabulka byla úspěšně vytvořena.' )
}
}
//Uzavření připojení k databázi
db . Zavřít ()
}
Spuštěním následujícího příkazu spusťte soubor „create_table.go“:
$ go spustit create_table.goNásledující výstup ukazuje, že tabulka byla úspěšně vytvořena v databázi. V terminálu se vytiskne zpráva o úspěchu „Tabulka byla úspěšně vytvořena“:
Můžete se přihlásit do SQLite a zkontrolovat, zda je tabulka v databázi vytvořena nebo ne.
Spusťte následující příkaz pro spuštění SQLite s databází „test.db“:
$ sqlite3 test.dbSpusťte příkaz SQLite „.tables“ z příkazového řádku SQLite a zkontrolujte názvy tabulek databáze:
sqlite3 > .tablesNásledující výstup ukazuje, že databáze obsahuje tabulku „členů“, která je vytvořena spuštěním skriptu Golang:
Vložte záznamy do tabulky SQLite pomocí Golang
Do tabulky lze vložit více záznamů provedením dotazu INSERT vícekrát nebo přidáním více hodnot do jednoho dotazu INSERT. Vytvořte soubor Golang pomocí následujícího skriptu, který vloží tři záznamy do tabulky „členové“ databázového souboru „test.db“ pomocí jediného dotazu INSERT. K provedení dotazu INSERT se zde používá metoda Exec(). Pokud jsou záznamy úspěšně vloženy do tabulky, vytiskne se zpráva o úspěchu. V opačném případě bude program ukončen.
balík hlavní//Importujte potřebné moduly
import (
'fmt'
'log'
'databáze/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hlavní () {
//Vytvořte novou databázi SQLite
db , chybovat := sql . OTEVŘENO ( 'sqlite3' , 'test.db' )
//Zkontrolujte případnou chybu
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
konst dotaz tětiva = `
INSERT INTO členů (id, jméno, mtype, email, adresa, mobil)
VALUES(1; 'Nehal Ahmed'; 'Stříbrná'; 'nehal@gmail.com','36; Dhanmondi 2, Dháka';'01844657342'),
(2, 'Abir Chowdhury', 'Gold', 'abir@gmail.com','102, Mirpur 10, Dháka','01994563423'),
(3, 'Mirza Abbas', 'Silver', 'abbas@gmail.com','12, Jigatala, Dháka','01640006710');`
//Proveďte dotaz
_ , chybovat := db . Exec ( dotaz );
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Vytiskněte zprávu o úspěchu
fmt . Println ( 'Záznamy byly úspěšně vloženy.' )
}
}
//Uzavření připojení k databázi
db . Zavřít ()
}
Spuštěním následujícího příkazu spusťte soubor „insert_table.go“:
$ go spustit insert_table.goNásledující výstup ukazuje, že záznamy byly úspěšně vloženy do tabulky. Na výstupu se vytiskne zpráva o úspěchu „Záznamy byly úspěšně vloženy“:
Můžete se přihlásit do SQLite a zkontrolovat, zda jsou tři záznamy úspěšně vloženy do tabulky „členové“.
Spusťte následující příkaz pro spuštění SQLite s databází „test.db“:
$ sqlite3 test.dbSpusťte následující dotaz SELECT a přečtěte si veškerý obsah tabulky „členové“:
sqlite3 > VYBRAT * OD členů ;Následující výstup ukazuje, že tabulka „členové“ obsahuje tři záznamy, které jsou vloženy skriptem Golang:
Přečtěte si data tabulky SQLite pomocí Golang
Vytvořte soubor Golang pomocí následujícího skriptu, který čte záznamy tabulky „členové“. Musíte definovat proměnné v Golang pro uložení hodnot, které jsou vráceny z dotazu SELECT. V tomto skriptu je pomocí dotazu SELECT načteno pět polí z tabulky „členové“. Ve skriptu je tedy definováno pět proměnných pro uložení hodnot pěti polí tabulky „členové“, kde hodnota pole „mtype“ je „Stříbrná“. K provedení dotazu SELECT se zde používá metoda Query(). Dále se smyčka „for“ používá ke čtení sady výsledků, která je vrácena dotazem SELECT. Funkce printf() se používá k tisku formátovaných hodnot sady výsledků.
balík hlavní//Importujte potřebné moduly
import (
'fmt'
'log'
'databáze/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hlavní () {
//Vytvořte novou databázi SQLite
db , chybovat := sql . OTEVŘENO ( 'sqlite3' , 'test.db' )
//Zkontrolujte případnou chybu
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Deklarujte proměnné pro uložení hodnot řádků
byl id int
byl název tětiva
byl mtype tětiva
byl adresa tětiva
byl mobilní, pohybliví tětiva
konst dotaz tětiva = `SELECT id, name, mtype, address, mobile
OD členů
WHERE mtype = 'Stříbro';`
//Proveďte dotaz
řádky , chybovat := db . Dotaz ( dotaz );
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Vytiskněte zprávu o úspěchu
fmt . Println ( 'Rekordy všech stříbrných členů:' )
fmt . Println ( 'ID \t název \t \t Typ člena \t Adresa \t \t Kontaktní číslo' )
pro řádky . další () {
řádky . Skenovat ( &id , &název , &mtype , &adresa , &mobilní, pohybliví )
fmt . Printf ( '%d \t %s \t %s \t %s \t %s \n ' , id , název , mtype , adresa , mobilní, pohybliví )
}
}
}
//Uzavření připojení k databázi
db . Zavřít ()
}
Spusťte následující příkaz pro spuštění souboru „select_table.go“:
$ go spustit select_table.goV tabulce „členové“ existují dva záznamy, které v poli „mtype“ obsahují „Silver“. Následující výstup zobrazuje dva záznamy tabulky „členové“, které jsou vráceny dotazem SELECT:
Aktualizujte data tabulky SQLite pomocí Golang
Vytvořte soubor Golang pomocí následujícího skriptu, který změní hodnotu mobilního pole tabulky „členové“, která obsahuje hodnotu id 2. Ke spuštění dotazu UPDATE se zde používá metoda Exec(). Pokud je záznam v tabulce úspěšně aktualizován, vytiskne se zpráva o úspěchu. V opačném případě bude program ukončen.
balík hlavní//Importujte potřebné moduly
import (
'fmt'
'log'
'databáze/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hlavní () {
//Vytvořte novou databázi SQLite
db , chybovat := sql . OTEVŘENO ( 'sqlite3' , 'test.db' )
//Zkontrolujte případnou chybu
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
konst dotaz tětiva = `
AKTUALIZACE členů SET mobile = '018563452390' WHERE id = 2;`
_ , chybovat := db . Exec ( dotaz );
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Vytiskněte zprávu o úspěchu
fmt . Println ( 'Záznam byl úspěšně aktualizován.' )
}
}
//Uzavření připojení k databázi
db . Zavřít ()
}
Spuštěním následujícího příkazu spusťte soubor „update_table.go“:
$ go spustit update_table.goV tabulce „členové“ obsahuje druhý řádek hodnotu id 2. Následující výstup ukazuje, že záznam tabulky byl úspěšně aktualizován. V terminálu se vytiskne úspěšná zpráva „Záznam byl úspěšně aktualizován“:
Můžete se přihlásit do SQLite a zkontrolovat, zda je některý záznam tabulky členů aktualizován nebo ne.
Spusťte následující příkaz pro spuštění SQLite s databází „test.db“:
$ sqlite3 test.dbSpusťte následující dotaz SELECT a přečtěte si veškerý obsah tabulky „členové“:
sqlite3 > VYBRAT * OD členů ;Hodnota mobilního pole 2 nd záznam tabulky členů je před spuštěním skriptu „01994563423“. Následující výstup ukazuje, že hodnota mobilního pole 2 nd záznam tabulky členů se po provedení skriptu změní na „018563452390“:
Odstraňte data tabulky SQLite pomocí Golang
Vytvořte soubor Golang pomocí následujícího skriptu, který odstraní 3 rd záznam tabulky „členové“, který obsahuje hodnotu id 3. Pro provedení dotazu DELETE je zde použita metoda Exec(). Pokud je záznam z tabulky úspěšně odstraněn, vytiskne se zpráva o úspěchu. V opačném případě bude program ukončen.
balík hlavní//Importujte potřebné moduly
import (
'fmt'
'log'
'databáze/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hlavní () {
//Vytvořte novou databázi SQLite
db , chybovat := sql . OTEVŘENO ( 'sqlite3' , 'test.db' )
//Zkontrolujte případnou chybu
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Definujte dotaz na odstranění
konst dotaz tětiva = `DELETE FROM members WHERE id = 3;`
//Proveďte dotaz
_ , chybovat := db . Exec ( dotaz );
-li chybovat != nula {
//Přidat chybovou zprávu do protokolu
log . Fatální ( chybovat )
} jiný {
//Vytiskněte zprávu o úspěchu
fmt . Println ( 'Záznam byl úspěšně smazán.' )
}
}
//Uzavření připojení k databázi
db . Zavřít ()
}
Spusťte následující příkaz pro spuštění souboru „delete_table.go“:
$ go spustit delete_table.goNásledující výstup ukazuje, že 3 rd záznam tabulky „členové“ byl úspěšně smazán. Na terminálu se vytiskne úspěšná zpráva „Záznam byl úspěšně smazán“:
Můžete se přihlásit do SQLite a zkontrolovat, zda je některý záznam z tabulky členů smazán nebo ne.
Spusťte následující příkaz pro spuštění SQLite s databází „test.db“:
$ sqlite3 test.dbSpusťte následující dotaz SELECT a přečtěte si veškerý obsah tabulky „členové“:
sqlite3 > VYBRAT * OD členů ;Následující výstup ukazuje, že hodnota 3 rd záznam tabulky členů je po provedení skriptu smazán a další dva záznamy jsou vytištěny ve výstupu:
Závěr
SQLite i Golang jsou nyní populární pro svou jednoduchost a lehké funkce. Pomocí těchto nástrojů lze snadno implementovat jakoukoli jednoduchou databázovou aplikaci. Hlavní částí každé aplikace je implementace operace CRUD. Metody implementace operace CRUD pomocí skriptu Golang a databáze SQLite jsou vysvětleny v tomto tutoriálu pomocí více souborů Golang. Pokud jste novým studentem jazyka Go a databáze SQLite, tento tutoriál vám pomůže naučit se je od základů.