Cerințe preliminare:
Trebuie să finalizați următoarele sarcini înainte de a exersa exemplele din acest tutorial:
A. Instalați limba Golang în sistem dacă nu a fost instalată înainte. Rulați următoarea comandă pentru a verifica versiunea instalată de Golang:
versiunea $go
B. Instalați sqlite3 în sistem dacă nu a fost instalat înainte. Sqlite3 este instalat implicit pe Ubuntu 20+. Rulați următoarea comandă pentru a verifica versiunea instalată de sqlite3:
$ sqlite3 --versiune
C. Rulați următoarele comenzi pentru a crea un folder numit „golang-sqlite” și mergeți la acel folder în care vor fi stocate fișierul bazei de date SQLite și fișierul Golang:
$ mkdir golang-sqlite$ cd golang-sqlite
D. Rulați următoarea comandă pentru a descărca pachetul Golang necesar pentru a utiliza SQLite cu Golang:
$ go get github.com/mattn/go-sqlite3
Operații cu baze de date folosind Golang și SQLite
Operațiunile de bază ale bazei de date folosind baza de date SQLite și scriptul Golang sunt prezentate în acest tutorial. Lista sarcinilor bazei de date care sunt acoperite în acest tutorial este menționată mai jos:
- Creați o bază de date SQLite
- Faceți o conexiune la baza de date SQLite
- Creați un tabel nou
- Introduceți datele în tabel
- Citiți datele din tabel
- Actualizați datele tabelului
- Ștergeți datele din tabel
Creați o bază de date SQLite folosind Golang
Creați un fișier Golang cu următorul script care creează un nou fișier de bază de date SQLite numit „test.db”. Patru module sunt importate în script. Modulul „fmt” este folosit pentru a imprima ieșirea în terminal. Modulul „jurnal” este folosit pentru a anula programul atunci când apare orice eroare. Modulul „os” este folosit pentru a crea baza de date SQLite și pentru a gestiona eroarea. Modulul „go-sqlite3” este folosit pentru a realiza conexiuni cu baza de date SQLite prin Golang. Metoda Create() a modulului „os” este folosită aici pentru a crea o bază de date SQLite. Dacă baza de date este creată cu succes, în terminal este tipărit un mesaj de succes. În caz contrar, programul va fi încheiat. Metoda Close() este apelată pentru a închide conexiunea la baza de date.
pachet principal//Importă modulele necesare
import (
'fmt'
'Buturuga'
'tu'
_ „github.com/mattn/go-sqlite3”
)
func principal () {
//Creează o nouă bază de date SQLite
db , a greșit := tu . Crea ( 'test.db' )
//Verificați orice eroare
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Tipărește mesajul de succes
fmt . Println ( „Baza de date este creată”. )
}
//Închide conexiunea la baza de date
db . Închide ()
}
Rulați următoarea comandă pentru a executa fișierul „db_connect.go”:
$ go rulați db_connect.goRulați comanda „ls” pentru a verifica dacă fișierul bazei de date „test.db” este creat sau nu:
$ lsUrmătoarea ieșire arată că mesajul de succes, „Bază de date este creată”, este tipărit în rezultat și fișierul „test.db” este creat în locația curentă:
Conectați-vă la o bază de date SQLite folosind Golang
Creați un fișier Golang cu următorul script care deschide fișierul de bază de date „test.db” și faceți conexiunea cu baza de date. Modulul de bază de date/SQL al Golang este importat aici pentru a face această sarcină. Metoda open() este folosită aici pentru a realiza conexiunea cu baza de date SQLite existentă. Dacă baza de date este conectată cu succes, în terminal este tipărit un mesaj de succes. În caz contrar, programul va fi încheiat.
pachet principal//Importă modulele necesare
import (
'fmt'
'Buturuga'
'baza de date/sql'
_ „github.com/mattn/go-sqlite3”
)
func principal () {
//Creează o nouă bază de date SQLite
db , a greșit := sql . Deschis ( „sqlite3” , 'test.db' )
//Verificați orice eroare
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Tipărește mesajul de succes
fmt . Println ( „Baza de date este conectată cu succes.” )
}
//Închide conexiunea la baza de date
db . Închide ()
}
Rulați următoarea comandă pentru a executa fișierul „db_connect2.go”:
$ go rulați db_connect2.goUrmătoarea ieșire arată că fișierul de bază de date „test.db” este deschis și conectat cu succes. Mesajul de succes, „Baza de date este conectată cu succes”, este tipărit în rezultat:
Creați un tabel într-o bază de date SQLite folosind Golang
Creați un fișier Golang cu următorul script care creează un tabel de bază de date numit „membri” în interiorul fișierului de bază de date „test.db”. Metoda Exec() este folosită aici pentru a executa interogarea CREATE TABLE care creează tabelul „membri” cu șase câmpuri și o cheie primară. Dacă tabelul este creat cu succes în baza de date, este tipărit un mesaj de succes. În caz contrar, programul va fi încheiat.
pachet principal//Importă modulele necesare
import (
'fmt'
'Buturuga'
'baza de date/sql'
_ „github.com/mattn/go-sqlite3”
)
func principal () {
//Creează o nouă bază de date sqlite
db , a greșit := sql . Deschis ( „sqlite3” , 'test.db' )
//Verificați orice eroare
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
const interogare şir = `
CREAȚI TABEL DACĂ NU EXISTĂ membrii (
id INTEGER NOT NULL CHEIE PRIMARĂ,
nume CHAR(40) NOT NULL,
mtype CHAR(100) NOT NULL,
e-mail CHAR(50),
adresa TEXT NOT NULL,
mobil CHAR(25) NOT NULL);`
_ , a greșit := db . Exec ( interogare );
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Tipărește mesajul de succes
fmt . Println ( „Tabelul a fost creat cu succes”. )
}
}
//Închide conexiunea la baza de date
db . Închide ()
}
Rulați următoarea comandă pentru a executa fișierul „create_table.go”:
$ go rulați create_table.goUrmătorul rezultat arată că tabelul a fost creat cu succes în baza de date. Mesajul de succes, „Tabelul a fost creat cu succes”, este tipărit în terminal:
Vă puteți conecta la SQLite pentru a verifica dacă tabelul este sau nu creat în baza de date.
Rulați următoarea comandă pentru a rula SQLite cu baza de date „test.db”:
$ sqlite3 test.dbRulați comanda SQLite „.tables” din promptul de comandă SQLite pentru a verifica numele tabelelor din baza de date:
sqlite3 > .tablesUrmătoarea ieșire arată că baza de date conține tabelul „membri” care este creat prin executarea scriptului Golang:
Inserați înregistrările în tabelul SQLite folosind Golang
Mai multe înregistrări pot fi inserate în tabel executând interogarea INSERT de mai multe ori sau adăugând mai multe valori într-o singură interogare INSERT. Creați un fișier Golang cu următorul script care inserează trei înregistrări în tabelul „membri” din fișierul bazei de date „test.db” folosind o singură interogare INSERT. Metoda Exec() este folosită aici pentru a executa interogarea INSERT. Dacă înregistrările sunt introduse cu succes în tabel, este tipărit un mesaj de succes. În caz contrar, programul va fi încheiat.
pachet principal//Importă modulele necesare
import (
'fmt'
'Buturuga'
'baza de date/sql'
_ „github.com/mattn/go-sqlite3”
)
func principal () {
//Creează o nouă bază de date SQLite
db , a greșit := sql . Deschis ( „sqlite3” , 'test.db' )
//Verificați orice eroare
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
const interogare şir = `
INSERT INTO membri (id, nume, mtype, e-mail, adresă, mobil)
VALORI(1, „Nehal Ahmed”, „Silver”, „nehal@gmail.com”, „36, Dhanmondi 2, Dhaka”, „01844657342”)
(2, „Abir Chowdhury”, „Gold”, „abir@gmail.com”, „102, Mirpur 10, Dhaka”, „01994563423”)
(3, 'Mirza Abbas', 'Silver', 'abbas@gmail.com','12, Jigatala, Dhaka','01640006710');`
//Execută interogarea
_ , a greșit := db . Exec ( interogare );
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Tipărește mesajul de succes
fmt . Println ( „Înregistrările au fost introduse cu succes”. )
}
}
//Închide conexiunea la baza de date
db . Închide ()
}
Rulați următoarea comandă pentru a executa fișierul „insert_table.go”:
$ go rulați insert_table.goUrmătoarea ieșire arată că înregistrările au fost introduse cu succes în tabel. Mesajul de succes, „Înregistrările au fost introduse cu succes”, este tipărit în rezultat:
Vă puteți conecta la SQLite pentru a verifica dacă cele trei înregistrări sunt introduse cu succes sau nu în tabelul „membri”.
Rulați următoarea comandă pentru a rula SQLite cu baza de date „test.db”:
$ sqlite3 test.dbRulați următoarea interogare SELECT pentru a citi tot conținutul tabelului „membri”:
sqlite3 > SELECT * DE LA membri ;Următoarea ieșire arată că tabelul „membri” conține trei înregistrări care sunt inserate de scriptul Golang:
Citiți datele tabelului SQLite folosind Golang
Creați un fișier Golang cu următorul script care citește înregistrările tabelului „membri”. Trebuie să definiți variabilele în Golang pentru a stoca valorile care sunt returnate de la interogarea SELECT. În acest script, cinci câmpuri sunt preluate din tabelul „membri” folosind interogarea SELECT. Deci, cinci variabile sunt definite în script pentru a stoca valorile celor cinci câmpuri din tabelul „membri” unde valoarea câmpului „mtype” este „Silver”. Metoda Query() este folosită aici pentru a executa interogarea SELECT. În continuare, bucla „for” este utilizată pentru a citi setul de rezultate care este returnat de interogarea SELECT. Funcția printf() este utilizată pentru a tipări valorile formatate ale setului de rezultate.
pachet principal//Importă modulele necesare
import (
'fmt'
'Buturuga'
'baza de date/sql'
_ „github.com/mattn/go-sqlite3”
)
func principal () {
//Creează o nouă bază de date SQLite
db , a greșit := sql . Deschis ( „sqlite3” , 'test.db' )
//Verificați orice eroare
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Declară variabile pentru a stoca valorile rândurilor
a fost id int
a fost Nume şir
a fost mtype şir
a fost abordare şir
a fost mobil şir
const interogare şir = `SELECT ID, nume, mtype, adresa, mobil
DE LA membri
WHERE mtype = 'Silver';`
//Execută interogarea
rânduri , a greșit := db . Interogare ( interogare );
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Tipărește mesajul de succes
fmt . Println ( „Înregistrările tuturor membrilor de argint:” )
fmt . Println ( „ID \t Nume \t \t Tip de membru \t Abordare \t \t Contact nr' )
pentru rânduri . Următorul () {
rânduri . Scanează ( &id , &Nume , &mtype , &abordare , &mobil )
fmt . Printf ( „%d \t %s \t %s \t %s \t %s \n ' , id , Nume , mtype , abordare , mobil )
}
}
}
//Închide conexiunea la baza de date
db . Închide ()
}
Rulați următoarea comandă pentru a executa fișierul „select_table.go”:
$ go rulați select_table.goExistă două înregistrări în tabelul „membri” care conține „Silver” în câmpul „mtype”. Următoarea ieșire arată două înregistrări ale tabelului „membri” care sunt returnate de interogarea SELECT:
Actualizați datele tabelului SQLite folosind Golang
Creați un fișier Golang cu următorul script care modifică valoarea câmpului mobil al tabelului „membri” care conține valoarea id de 2. Metoda Exec() este folosită aici pentru a executa interogarea UPDATE. Dacă înregistrarea este actualizată cu succes în tabel, este tipărit un mesaj de succes. În caz contrar, programul va fi încheiat.
pachet principal//Importă modulele necesare
import (
'fmt'
'Buturuga'
'baza de date/sql'
_ „github.com/mattn/go-sqlite3”
)
func principal () {
//Creează o nouă bază de date SQLite
db , a greșit := sql . Deschis ( „sqlite3” , 'test.db' )
//Verificați orice eroare
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
const interogare şir = `
UPDATE membrii SET mobil = '018563452390' WHERE id = 2;`
_ , a greșit := db . Exec ( interogare );
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Tipărește mesajul de succes
fmt . Println ( „Înregistrarea a fost actualizată cu succes.” )
}
}
//Închide conexiunea la baza de date
db . Închide ()
}
Rulați următoarea comandă pentru a executa fișierul „update_table.go”:
$ go rulați update_table.goÎn tabelul „membri”, al doilea rând conține valoarea id de 2. Următoarea ieșire arată că înregistrarea tabelului este actualizată cu succes. Mesajul de succes, „Înregistrarea a fost actualizată cu succes”, este tipărit în terminal:
Vă puteți conecta la SQLite pentru a verifica dacă orice înregistrare a tabelului de membri este actualizată sau nu.
Rulați următoarea comandă pentru a rula SQLite cu baza de date „test.db”:
$ sqlite3 test.dbRulați următoarea interogare SELECT pentru a citi tot conținutul tabelului „membri”:
sqlite3 > SELECT * DE LA membri ;Valoarea câmpului mobil al 2 nd înregistrarea tabelului de membri este „01994563423” înainte de a executa scriptul. Următorul rezultat arată că valoarea câmpului mobil al 2 nd înregistrarea tabelului de membri este schimbată în „018563452390” după executarea scriptului:
Ștergeți datele tabelului SQLite folosind Golang
Creați un fișier Golang cu următorul script care șterge fișierul 3 rd înregistrarea tabelului „membri” care conține valoarea id de 3. Metoda Exec() este folosită aici pentru a executa interogarea DELETE. Dacă înregistrarea este ștearsă cu succes din tabel, este tipărit un mesaj de succes. În caz contrar, programul va fi încheiat.
pachet principal//Importă modulele necesare
import (
'fmt'
'Buturuga'
'baza de date/sql'
_ „github.com/mattn/go-sqlite3”
)
func principal () {
//Creează o nouă bază de date SQLite
db , a greșit := sql . Deschis ( „sqlite3” , 'test.db' )
//Verificați orice eroare
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Definește interogarea de ștergere
const interogare şir = `DELETE FROM membri WHERE id = 3;`
//Execută interogarea
_ , a greșit := db . Exec ( interogare );
dacă a greșit != zero {
//Adăugați mesajul de eroare în jurnal
Buturuga . Fatal ( a greșit )
} altfel {
//Tipărește mesajul de succes
fmt . Println ( „Înregistrarea a fost ștearsă cu succes.” )
}
}
//Închide conexiunea la baza de date
db . Închide ()
}
Rulați următoarea comandă pentru a executa fișierul „delete_table.go”:
$ go rulați delete_table.goUrmătoarea ieșire arată că 3 rd înregistrarea tabelului „membri” este ștearsă cu succes. Mesajul de succes, „Înregistrarea a fost ștearsă cu succes”, este tipărit în terminal:
Vă puteți conecta la SQLite pentru a verifica dacă orice înregistrare a tabelului de membri este ștearsă sau nu.
Rulați următoarea comandă pentru a rula SQLite cu baza de date „test.db”:
$ sqlite3 test.dbRulați următoarea interogare SELECT pentru a citi tot conținutul tabelului „membri”:
sqlite3 > SELECT * DE LA membri ;Următoarea ieșire arată că valoarea lui 3 rd înregistrarea tabelului de membri este ștearsă după executarea scriptului, iar celelalte două înregistrări sunt tipărite în rezultat:
Concluzie
Atât SQLite, cât și Golang sunt populare acum pentru simplitatea și caracteristicile lor ușoare. Orice aplicație simplă bazată pe baze de date poate fi implementată cu ușurință folosind aceste instrumente. Cea mai mare parte a oricărei aplicații este implementarea operațiunii CRUD. Metodele de implementare a operațiunii CRUD folosind scriptul Golang și baza de date SQLite sunt explicate în acest tutorial folosind mai multe fișiere Golang. Dacă sunteți un nou învățător al limbajului Go și al bazei de date SQLite, acest tutorial vă va ajuta să le învățați de la bază.