Predpoklady:
Pred precvičovaním príkladov v tomto návode musíte splniť nasledujúce úlohy:
A. Nainštalujte jazyk Golang do systému, ak ešte nie je nainštalovaný. Ak chcete skontrolovať nainštalovanú verziu Golang, spustite nasledujúci príkaz:
$ go verzia
B. Nainštalujte sqlite3 do systému, ak ešte nebol nainštalovaný. Sqlite3 je predvolene nainštalovaný na Ubuntu 20+. Ak chcete skontrolovať nainštalovanú verziu sqlite3, spustite nasledujúci príkaz:
$ sqlite3 --verzia
C. Spustite nasledujúce príkazy na vytvorenie priečinka s názvom „golang-sqlite“ a prejdite do tohto priečinka, kde bude uložený databázový súbor SQLite a súbor Golang:
$ mkdir golang-sqlite$ cd golang-sqlite
D. Spustite nasledujúci príkaz na stiahnutie potrebného balíka Golang na používanie SQLite s Golang:
$ prejdite na stránku github.com/mattn/go-sqlite3
Operácie databázy pomocou Golang a SQLite
Základné operácie s databázou pomocou databázy SQLite a skriptu Golang sú uvedené v tomto návode. Zoznam databázových úloh, ktoré sú zahrnuté v tomto návode, je uvedený v nasledujúcom texte:
- Vytvorte databázu SQLite
- Vytvorte pripojenie k databáze SQLite
- Vytvorte novú tabuľku
- Vložte údaje do tabuľky
- Prečítajte si údaje z tabuľky
- Aktualizujte údaje tabuľky
- Odstráňte údaje z tabuľky
Vytvorte databázu SQLite pomocou Golang
Vytvorte súbor Golang pomocou nasledujúceho skriptu, ktorý vytvorí nový databázový súbor SQLite s názvom „test.db“. Do skriptu sú importované štyri moduly. Modul „fmt“ sa používa na tlač výstupu v termináli. Modul „log“ sa používa na prerušenie programu pri výskyte akejkoľvek chyby. Modul „os“ sa používa na vytvorenie databázy SQLite a spracovanie chyby. Modul „go-sqlite3“ sa používa na vytváranie spojení s databázou SQLite cez Golang. Metóda Create() modulu „os“ sa tu používa na vytvorenie databázy SQLite. Ak je databáza úspešne vytvorená, na termináli sa vytlačí správa o úspechu. V opačnom prípade bude program ukončený. Na zatvorenie pripojenia k databáze sa volá metóda Close().
balík Hlavná//Importujte potrebné moduly
importovať (
'fmt'
'log'
'ty'
_ 'github.com/mattn/go-sqlite3'
)
func Hlavná () {
//Vytvorte novú databázu SQLite
db , chybovať := vy . Vytvorte ( 'test.db' )
//Skontrolujte prípadné chyby
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Vytlačte správu o úspechu
fmt . Println ( 'Databáza je vytvorená.' )
}
//Zatvorte pripojenie k databáze
db . Zavrieť ()
}
Spustite nasledujúci príkaz na spustenie súboru „db_connect.go“:
$ choď spustiť db_connect.goSpustite príkaz „ls“ a skontrolujte, či je databázový súbor „test.db“ vytvorený alebo nie:
$ lsNasledujúci výstup ukazuje, že správa o úspechu „Databáza je vytvorená“ sa vytlačí na výstupe a súbor „test.db“ sa vytvorí v aktuálnom umiestnení:
Pripojte sa k databáze SQLite pomocou Golang
Vytvorte súbor Golang pomocou nasledujúceho skriptu, ktorý otvorí databázový súbor „test.db“ a vytvorte spojenie s databázou. Na vykonanie tejto úlohy sa sem importuje databáza/SQL modul Golang. Metóda open() sa tu používa na vytvorenie spojenia s existujúcou databázou SQLite. Ak je databáza úspešne pripojená, na termináli sa vytlačí správa o úspechu. V opačnom prípade bude program ukončený.
balík Hlavná//Importujte potrebné moduly
importovať (
'fmt'
'log'
'databáza/sql'
_ 'github.com/mattn/go-sqlite3'
)
func Hlavná () {
//Vytvorte novú databázu SQLite
db , chybovať := sql . OTVORENÉ ( 'sqlite3' , 'test.db' )
//Skontrolujte prípadné chyby
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Vytlačte správu o úspechu
fmt . Println ( 'Databáza je úspešne pripojená.' )
}
//Zatvorte pripojenie k databáze
db . Zavrieť ()
}
Spustite nasledujúci príkaz na spustenie súboru „db_connect2.go“:
$ choď spustiť db_connect2.goNasledujúci výstup ukazuje, že databázový súbor „test.db“ je otvorený a úspešne pripojený. Na výstupe sa vytlačí správa o úspechu „Databáza je úspešne pripojená“:
Vytvorte tabuľku v databáze SQLite pomocou Golang
Vytvorte súbor Golang pomocou nasledujúceho skriptu, ktorý vytvorí databázovú tabuľku s názvom „členovia“ v súbore databázy „test.db“. Metóda Exec() sa tu používa na vykonanie dotazu CREATE TABLE, ktorý vytvorí tabuľku „členov“ so šiestimi poľami a primárnym kľúčom. Ak je tabuľka úspešne vytvorená v databáze, vytlačí sa správa o úspechu. V opačnom prípade bude program ukončený.
balík Hlavná//Importujte potrebné moduly
importovať (
'fmt'
'log'
'databáza/sql'
_ 'github.com/mattn/go-sqlite3'
)
func Hlavná () {
//Vytvorte novú databázu sqlite
db , chybovať := sql . OTVORENÉ ( 'sqlite3' , 'test.db' )
//Skontrolujte prípadné chyby
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
konšt dopyt reťazec = `
VYTVORIŤ TABUĽKU, AK NEEXISTUJE členovia (
id INTEGER NOT NULL PRIMÁRNY KĽÚČ,
meno CHAR(40) NOT NULL,
mtype CHAR(100) NOT NULL,
e-mail CHAR(50),
adresa TEXT NIE JE NULL,
mobile CHAR(25) NOT NULL);“.
_ , chybovať := db . Exec ( dopyt );
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Vytlačte správu o úspechu
fmt . Println ( 'Tabuľka bola úspešne vytvorená.' )
}
}
//Zatvorte pripojenie k databáze
db . Zavrieť ()
}
Spustite nasledujúci príkaz na spustenie súboru „create_table.go“:
$ choď spustiť create_table.goNasledujúci výstup ukazuje, že tabuľka bola úspešne vytvorená v databáze. V termináli sa vytlačí správa o úspechu „Tabuľka bola úspešne vytvorená“:
Môžete sa prihlásiť do SQLite a skontrolovať, či je tabuľka vytvorená alebo nie v databáze.
Ak chcete spustiť SQLite s databázou „test.db“, spustite nasledujúci príkaz:
$ sqlite3 test.dbSpustite príkaz SQLite „.tables“ z príkazového riadka SQLite a skontrolujte názvy tabuliek databázy:
sqlite3 > .tabuľkyNasledujúci výstup ukazuje, že databáza obsahuje tabuľku „členov“, ktorá sa vytvorí spustením skriptu Golang:
Vložte záznamy do tabuľky SQLite pomocou Golang
Do tabuľky je možné vložiť viacero záznamov vykonaním dotazu INSERT viackrát alebo pridaním viacerých hodnôt do jedného dotazu INSERT. Vytvorte súbor Golang pomocou nasledujúceho skriptu, ktorý vloží tri záznamy do tabuľky „členov“ databázového súboru „test.db“ pomocou jediného dotazu INSERT. Metóda Exec() sa tu používa na vykonanie dotazu INSERT. Ak sú záznamy úspešne vložené do tabuľky, vytlačí sa správa o úspechu. V opačnom prípade bude program ukončený.
balík Hlavná//Importujte potrebné moduly
importovať (
'fmt'
'log'
'databáza/sql'
_ 'github.com/mattn/go-sqlite3'
)
func Hlavná () {
//Vytvorte novú databázu SQLite
db , chybovať := sql . OTVORENÉ ( 'sqlite3' , 'test.db' )
//Skontrolujte prípadné chyby
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
konšt dopyt reťazec = `
INSERT INTO members (id, name, mtype, email, address, mobile)
VALUES(1; 'Nehal Ahmed'; 'Striebro'; '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', 'Striebro', 'abbas@gmail.com','12, Jigatala, Dháka','01640006710');`
//Vykonanie dotazu
_ , chybovať := db . Exec ( dopyt );
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Vytlačte správu o úspechu
fmt . Println ( 'Záznamy boli úspešne vložené.' )
}
}
//Zatvorte pripojenie k databáze
db . Zavrieť ()
}
Spustite nasledujúci príkaz na spustenie súboru „insert_table.go“:
$ choď spustiť insert_table.goNasledujúci výstup ukazuje, že záznamy boli úspešne vložené do tabuľky. Na výstupe sa vytlačí správa o úspechu „Záznamy boli úspešne vložené“:
Môžete sa prihlásiť do SQLite a skontrolovať, či sú tri záznamy vložené úspešne alebo nie v tabuľke „členovia“.
Ak chcete spustiť SQLite s databázou „test.db“, spustite nasledujúci príkaz:
$ sqlite3 test.dbAk chcete prečítať celý obsah tabuľky „členovia“, spustite nasledujúci dotaz SELECT:
sqlite3 > SELECT * OD členov ;Nasledujúci výstup ukazuje, že tabuľka „členovia“ obsahuje tri záznamy, ktoré sú vložené skriptom Golang:
Prečítajte si údaje tabuľky SQLite pomocou Golang
Vytvorte súbor Golang pomocou nasledujúceho skriptu, ktorý číta záznamy tabuľky „členovia“. Musíte definovať premenné v Golang na ukladanie hodnôt, ktoré sa vrátia z dotazu SELECT. V tomto skripte je päť polí získaných z tabuľky „členovia“ pomocou dotazu SELECT. V skripte je teda definovaných päť premenných na ukladanie hodnôt piatich polí tabuľky „členovia“, kde hodnota poľa „mtype“ je „Striebro“. Metóda Query() sa tu používa na vykonanie dotazu SELECT. Ďalej sa cyklus „for“ používa na čítanie sady výsledkov, ktorá je vrátená dotazom SELECT. Funkcia printf() sa používa na tlač formátovaných hodnôt sady výsledkov.
balík Hlavná//Importujte potrebné moduly
importovať (
'fmt'
'log'
'databáza/sql'
_ 'github.com/mattn/go-sqlite3'
)
func Hlavná () {
//Vytvorte novú databázu SQLite
db , chybovať := sql . OTVORENÉ ( 'sqlite3' , 'test.db' )
//Skontrolujte prípadné chyby
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Deklarovanie premenných na uloženie hodnôt riadkov
bol id int
bol názov reťazec
bol mtype reťazec
bol adresu reťazec
bol mobilné reťazec
konšt dopyt reťazec = `SELECT id, name, mtype, address, mobile
OD členov
WHERE mtype = 'Striebro';'
//Vykonanie dotazu
riadkov , chybovať := db . Dopyt ( dopyt );
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Vytlačte správu o úspechu
fmt . Println ( 'Rekordy všetkých strieborných členov:' )
fmt . Println ( 'ID \t názov \t \t Typ člena \t Adresa \t \t Kontaktné číslo' )
pre riadkov . Ďalšie () {
riadkov . skenovať ( &id , &názov , &mtype , &adresa , &mobilné )
fmt . Printf ( '%d \t %s \t %s \t %s \t %s \n ' , id , názov , mtype , adresu , mobilné )
}
}
}
//Zatvorte pripojenie k databáze
db . Zavrieť ()
}
Spustite nasledujúci príkaz na spustenie súboru „select_table.go“:
$ ísť spustiť select_table.goV tabuľke „členovia“ existujú dva záznamy, ktoré v poli „mtype“ obsahujú „Striebro“. Nasledujúci výstup zobrazuje dva záznamy tabuľky „členovia“, ktoré vracia dotaz SELECT:
Aktualizujte údaje tabuľky SQLite pomocou Golang
Vytvorte súbor Golang pomocou nasledujúceho skriptu, ktorý zmení hodnotu mobilného poľa tabuľky „členovia“, ktorá obsahuje hodnotu id 2. Na vykonanie dotazu UPDATE sa tu používa metóda Exec(). Ak sa záznam v tabuľke úspešne aktualizuje, vytlačí sa správa o úspechu. V opačnom prípade bude program ukončený.
balík Hlavná//Importujte potrebné moduly
importovať (
'fmt'
'log'
'databáza/sql'
_ 'github.com/mattn/go-sqlite3'
)
func Hlavná () {
//Vytvorte novú databázu SQLite
db , chybovať := sql . OTVORENÉ ( 'sqlite3' , 'test.db' )
//Skontrolujte prípadné chyby
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
konšt dopyt reťazec = `
AKTUALIZOVAŤ SET členov mobile = '018563452390' WHERE id = 2;`
_ , chybovať := db . Exec ( dopyt );
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Vytlačte správu o úspechu
fmt . Println ( 'Záznam bol úspešne aktualizovaný.' )
}
}
//Zatvorte pripojenie k databáze
db . Zavrieť ()
}
Spustite nasledujúci príkaz na spustenie súboru „update_table.go“:
$ choď spustiť update_table.goV tabuľke „členovia“ druhý riadok obsahuje hodnotu id 2. Nasledujúci výstup ukazuje, že záznam tabuľky bol úspešne aktualizovaný. V termináli sa vytlačí správa o úspechu „Záznam je úspešne aktualizovaný“:
Môžete sa prihlásiť do SQLite a skontrolovať, či je niektorý záznam tabuľky členov aktualizovaný alebo nie.
Ak chcete spustiť SQLite s databázou „test.db“, spustite nasledujúci príkaz:
$ sqlite3 test.dbAk chcete prečítať celý obsah tabuľky „členovia“, spustite nasledujúci dotaz SELECT:
sqlite3 > SELECT * OD členov ;Hodnota mobilného poľa 2 nd záznam tabuľky členov je „01994563423“ pred spustením skriptu. Nasledujúci výstup ukazuje, že hodnota mobilného poľa 2 nd záznam tabuľky členov sa po vykonaní skriptu zmení na „018563452390“:
Odstráňte údaje tabuľky SQLite pomocou Golang
Vytvorte súbor Golang pomocou nasledujúceho skriptu, ktorý odstráni 3 rd záznam tabuľky „členovia“, ktorý obsahuje hodnotu id 3. Na vykonanie dotazu DELETE sa tu používa metóda Exec(). Ak sa záznam z tabuľky úspešne odstráni, vytlačí sa správa o úspechu. V opačnom prípade bude program ukončený.
balík Hlavná//Importujte potrebné moduly
importovať (
'fmt'
'log'
'databáza/sql'
_ 'github.com/mattn/go-sqlite3'
)
func Hlavná () {
//Vytvorte novú databázu SQLite
db , chybovať := sql . OTVORENÉ ( 'sqlite3' , 'test.db' )
//Skontrolujte prípadné chyby
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Definujte dotaz na odstránenie
konšt dopyt reťazec = `DELETE FROM members WHERE id = 3;`
//Vykonanie dotazu
_ , chybovať := db . Exec ( dopyt );
ak chybovať != nula {
//Pridajte chybové hlásenie do protokolu
log . Osudný ( chybovať )
} inak {
//Vytlačte správu o úspechu
fmt . Println ( 'Záznam bol úspešne odstránený.' )
}
}
//Zatvorte pripojenie k databáze
db . Zavrieť ()
}
Spustite nasledujúci príkaz na spustenie súboru „delete_table.go“:
$ ísť spustiť delete_table.goNasledujúci výstup ukazuje, že 3 rd záznam tabuľky „členovia“ bol úspešne vymazaný. V termináli sa vytlačí správa o úspechu „Záznam bol úspešne vymazaný“:
Môžete sa prihlásiť do SQLite a skontrolovať, či je niektorý záznam z tabuľky členov odstránený alebo nie.
Ak chcete spustiť SQLite s databázou „test.db“, spustite nasledujúci príkaz:
$ sqlite3 test.dbAk chcete prečítať celý obsah tabuľky „členovia“, spustite nasledujúci dotaz SELECT:
sqlite3 > SELECT * OD členov ;Nasledujúci výstup ukazuje, že hodnota 3 rd záznam tabuľky členov sa po vykonaní skriptu vymaže a ďalšie dva záznamy sa vytlačia vo výstupe:
Záver
SQLite aj Golang sú teraz populárne pre svoju jednoduchosť a ľahké funkcie. Pomocou týchto nástrojov je možné jednoducho implementovať akúkoľvek jednoduchú databázovú aplikáciu. Hlavnou časťou každej aplikácie je implementácia operácie CRUD. Metódy implementácie operácie CRUD pomocou skriptu Golang a databázy SQLite sú vysvetlené v tomto návode pomocou viacerých súborov Golang. Ak ste novým študentom jazyka Go a databázy SQLite, tento tutoriál vám pomôže naučiť sa ich od základov.