Forudsætninger:
Du skal udføre følgende opgaver, før du øver dig på eksemplerne i denne øvelse:
A. Installer Golang-sproget i systemet, hvis det ikke er installeret før. Kør følgende kommando for at kontrollere den installerede version af Golang:
$ go version
B. Installer sqlite3 i systemet, hvis det ikke er blevet installeret før. Sqlite3 er installeret som standard på Ubuntu 20+. Kør følgende kommando for at kontrollere den installerede version af sqlite3:
$ sqlite3 --version
C. Kør følgende kommandoer for at oprette en mappe med navnet 'golang-sqlite' og gå til den mappe, hvor SQLite-databasefilen og Golang-filen vil blive gemt:
$ mkdir golang-sqlite$ cd golang-sqlite
D. Kør følgende kommando for at downloade den nødvendige Golang-pakke for at bruge SQLite med Golang:
$ gå hen til github.com/mattn/go-sqlite3
Databaseoperationer ved hjælp af Golang og SQLite
De grundlæggende databaseoperationer ved hjælp af SQLite-databasen og Golang-scriptet er vist i denne øvelse. Listen over databaseopgaver, der er dækket af denne øvelse, er nævnt i det følgende:
- Opret en SQLite-database
- Opret en SQLite-databaseforbindelse
- Opret en ny tabel
- Indsæt dataene i tabellen
- Læs dataene fra tabellen
- Opdater dataene i tabellen
- Slet data fra tabellen
Opret en SQLite-database ved hjælp af Golang
Opret en Golang-fil med følgende script, der opretter en ny SQLite-databasefil med navnet 'test.db'. Fire moduler importeres til scriptet. 'fmt'-modulet bruges til at udskrive output i terminalen. 'Log'-modulet bruges til at afbryde programmet, når der opstår en fejl. 'OS'-modulet bruges til at oprette SQLite-databasen og håndtere fejlen. 'go-sqlite3'-modulet bruges til at oprette forbindelser med SQLite-databasen gennem Golang. Create()-metoden for 'os'-modulet bruges her til at oprette en SQLite-database. Hvis databasen er oprettet, udskrives en succesmeddelelse i terminalen. Ellers vil programmet blive afsluttet. Close()-metoden kaldes for at lukke databaseforbindelsen.
pakke vigtigste//Importer de nødvendige moduler
importere (
'fmt'
'log'
'du'
_ 'github.com/mattn/go-sqlite3'
)
func vigtigste () {
//Opret en ny SQLite-database
db , fejl := du . skab ( 'test.db' )
//Tjek for eventuelle fejl
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Udskriv succesmeddelelsen
fmt . Udskrivln ( 'Database er oprettet.' )
}
//Luk databaseforbindelsen
db . Tæt ()
}
Kør følgende kommando for at udføre filen 'db_connect.go':
$ kør db_connect.goKør kommandoen 'ls' for at kontrollere, om databasefilen 'test.db' er oprettet eller ej:
$ lsFølgende output viser, at succesmeddelelsen, 'Database er oprettet', udskrives i outputtet, og 'test.db'-filen oprettes på den aktuelle placering:
Opret forbindelse til en SQLite-database ved hjælp af Golang
Opret en Golang-fil med følgende script, der åbner 'test.db'-databasefilen og lav forbindelsen til databasen. Golangs database/SQL-modul importeres her for at udføre denne opgave. Open()-metoden bruges her til at oprette forbindelsen til den eksisterende SQLite-database. Hvis databasen er tilsluttet korrekt, udskrives en succesmeddelelse i terminalen. Ellers vil programmet blive afsluttet.
pakke vigtigste//Importer de nødvendige moduler
importere (
'fmt'
'log'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func vigtigste () {
//Opret en ny SQLite-database
db , fejl := sql . Åben ( 'sqlite3' , 'test.db' )
//Tjek for eventuelle fejl
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Udskriv succesmeddelelsen
fmt . Udskrivln ( 'Databasen er forbundet med succes.' )
}
//Luk databaseforbindelsen
db . Tæt ()
}
Kør følgende kommando for at udføre filen 'db_connect2.go':
$ kør db_connect2.goFølgende output viser, at 'test.db'-databasefilen er åbnet og tilsluttet. Succesmeddelelsen, 'Database er tilsluttet korrekt', udskrives i outputtet:
Opret en tabel i en SQLite-database ved hjælp af Golang
Opret en Golang-fil med følgende script, der opretter en databasetabel med navnet 'members' inde i 'test.db'-databasefilen. Exec()-metoden bruges her til at udføre CREATE TABLE-forespørgslen, der opretter 'members'-tabellen med seks felter og en primærnøgle. Hvis tabellen er oprettet i databasen, udskrives en succesmeddelelse. Ellers vil programmet blive afsluttet.
pakke vigtigste//Importer de nødvendige moduler
importere (
'fmt'
'log'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func vigtigste () {
//Opret en ny sqlite-database
db , fejl := sql . Åben ( 'sqlite3' , 'test.db' )
//Tjek for eventuelle fejl
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
konst forespørgsel snor = `
OPRET TABEL, HVIS IKKE FINDER medlemmer (
id INTEGER IKKE NULL PRIMÆR NØGLE,
navn CHAR(40) NOT NULL,
mtype CHAR(100) IKKE NULL,
e-mail CHAR(50),
adresse TEKST IKKE NULL,
mobil CHAR(25) IKKE NULL);`
_ , fejl := db . Exec ( forespørgsel );
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Udskriv succesmeddelelsen
fmt . Udskrivln ( 'Tabel er oprettet med succes.' )
}
}
//Luk databaseforbindelsen
db . Tæt ()
}
Kør følgende kommando for at udføre filen 'create_table.go':
$ go run create_table.goFølgende output viser, at tabellen er oprettet med succes i databasen. Succesmeddelelsen, 'Tabel er oprettet med succes', udskrives i terminalen:
Du kan logge ind på SQLite for at kontrollere, om tabellen er oprettet eller ej i databasen.
Kør følgende kommando for at køre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKør SQLite-kommandoen '.tables' fra SQLite-kommandoprompten for at kontrollere databasens tabelnavne:
sqlite3 > .tabellerFølgende output viser, at databasen indeholder 'medlemmer'-tabellen, der er oprettet ved at udføre Golang-scriptet:
Indsæt posterne i SQLite-tabellen ved hjælp af Golang
Flere poster kan indsættes i tabellen ved at udføre INSERT-forespørgslen flere gange eller ved at tilføje flere værdier i en enkelt INSERT-forespørgsel. Opret en Golang-fil med følgende script, der indsætter tre poster i 'members'-tabellen i 'test.db'-databasefilen ved hjælp af en enkelt INSERT-forespørgsel. Exec()-metoden bruges her til at udføre INSERT-forespørgslen. Hvis posterne er indsat korrekt i tabellen, udskrives en succesmeddelelse. Ellers vil programmet blive afsluttet.
pakke vigtigste//Importer de nødvendige moduler
importere (
'fmt'
'log'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func vigtigste () {
//Opret en ny SQLite-database
db , fejl := sql . Åben ( 'sqlite3' , 'test.db' )
//Tjek for eventuelle fejl
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
konst forespørgsel snor = `
INDSÆT I medlemmer (id, navn, mtype, e-mail, adresse, mobil)
VALUES(1, 'Nehal Ahmed', 'Sølv', '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');'
//Udfør forespørgslen
_ , fejl := db . Exec ( forespørgsel );
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Udskriv succesmeddelelsen
fmt . Udskrivln ( 'Records indsat med succes.' )
}
}
//Luk databaseforbindelsen
db . Tæt ()
}
Kør følgende kommando for at udføre filen 'insert_table.go':
$ kør insert_table.goFølgende output viser, at poster er indsat i tabellen. Succesmeddelelsen, 'Optegnelser indsat korrekt', udskrives i outputtet:
Du kan logge ind på SQLite for at kontrollere, om de tre poster er indsat korrekt eller ej i 'members'-tabellen.
Kør følgende kommando for at køre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKør følgende SELECT-forespørgsel for at læse alt indhold i 'medlemmer'-tabellen:
sqlite3 > VÆLG * FRA medlemmer ;Følgende output viser, at tabellen 'medlemmer' indeholder tre poster, der er indsat af Golang-scriptet:
Læs dataene i SQLite-tabellen ved hjælp af Golang
Opret en Golang-fil med følgende script, der læser posterne i tabellen 'medlemmer'. Du skal definere variablerne i Golang for at gemme de værdier, der returneres fra SELECT-forespørgslen. I dette script hentes fem felter fra 'medlemmer'-tabellen ved hjælp af SELECT-forespørgslen. Så fem variabler er defineret i scriptet til at gemme værdierne af de fem felter i 'members'-tabellen, hvor værdien af 'mtype'-feltet er 'Silver'. Metoden Query() bruges her til at udføre SELECT-forespørgslen. Dernæst bruges 'for'-løkken til at læse det resultatsæt, der returneres af SELECT-forespørgslen. Printf()-funktionen bruges til at udskrive de formaterede værdier af resultatsættet.
pakke vigtigste//Importer de nødvendige moduler
importere (
'fmt'
'log'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func vigtigste () {
//Opret en ny SQLite-database
db , fejl := sql . Åben ( 'sqlite3' , 'test.db' )
//Tjek for eventuelle fejl
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Erklær variabler for at gemme rækkeværdierne
var id int
var navn snor
var mtype snor
var adresse snor
var mobil snor
konst forespørgsel snor = `VÆLG id, navn, mtype, adresse, mobil
FRA medlemmer
WHERE mtype = 'Sølv';'
//Udfør forespørgslen
rækker , fejl := db . Forespørgsel ( forespørgsel );
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Udskriv succesmeddelelsen
fmt . Println ( 'Optegnelser over alle sølvmedlemmer:' )
fmt . Println ( 'ID \t Navn \t \t Medlemstype \t Adresse \t \t Kontakt nr' )
til rækker . Næste () {
rækker . Scan ( &id , &navn , &mtype , &adresse , &mobil )
fmt . Printf ( '%d \t %s \t %s \t %s \t %s \n ' , id , navn , mtype , adresse , mobil )
}
}
}
//Luk databaseforbindelsen
db . Tæt ()
}
Kør følgende kommando for at udføre filen 'select_table.go':
$ kør select_table.goDer findes to poster i 'members'-tabellen, der indeholder 'Silver' i 'mtype'-feltet. Følgende output viser to poster i 'members'-tabellen, der returneres af SELECT-forespørgslen:
Opdater dataene i SQLite-tabellen ved hjælp af Golang
Opret en Golang-fil med følgende script, der ændrer værdien af mobilfeltet i 'members'-tabellen, der indeholder id-værdien 2. Exec()-metoden bruges her til at udføre UPDATE-forespørgslen. Hvis posten er opdateret korrekt i tabellen, udskrives en succesmeddelelse. Ellers vil programmet blive afsluttet.
pakke vigtigste//Importer de nødvendige moduler
importere (
'fmt'
'log'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func vigtigste () {
//Opret en ny SQLite-database
db , fejl := sql . Åben ( 'sqlite3' , 'test.db' )
//Tjek for eventuelle fejl
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
konst forespørgsel snor = `
OPDATERE medlemmer SET mobil = '018563452390' WHERE id = 2;`
_ , fejl := db . Exec ( forespørgsel );
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Udskriv succesmeddelelsen
fmt . Println ( 'Recorden er opdateret med succes.' )
}
}
//Luk databaseforbindelsen
db . Tæt ()
}
Kør følgende kommando for at udføre filen 'update_table.go':
$ kør update_table.goI 'medlemmer'-tabellen indeholder den anden række id-værdien 2. Følgende output viser, at posten i tabellen er opdateret. Succesmeddelelsen, 'Record is updated successfully', udskrives i terminalen:
Du kan logge ind på SQLite for at kontrollere, om en registrering af medlemstabellen er opdateret eller ej.
Kør følgende kommando for at køre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKør følgende SELECT-forespørgsel for at læse alt indhold i 'medlemmer'-tabellen:
sqlite3 > VÆLG * FRA medlemmer ;Værdien af mobilfeltet i 2 nd posten for medlemstabellen er '01994563423', før scriptet udføres. Følgende output viser, at værdien af mobilfeltet i 2 nd posten for medlemstabellen ændres til '018563452390' efter udførelse af scriptet:
Slet dataene i SQLite-tabellen ved hjælp af Golang
Opret en Golang-fil med følgende script, der sletter 3 rd post for 'members'-tabellen, der indeholder id-værdien af 3. Exec()-metoden bruges her til at udføre DELETE-forespørgslen. Hvis posten er slettet fra tabellen, udskrives en succesmeddelelse. Ellers vil programmet blive afsluttet.
pakke vigtigste//Importer de nødvendige moduler
importere (
'fmt'
'log'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func vigtigste () {
//Opret en ny SQLite-database
db , fejl := sql . Åben ( 'sqlite3' , 'test.db' )
//Tjek for eventuelle fejl
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Definer sletteforespørgslen
konst forespørgsel snor = `SLET FRA medlemmer WHERE id = 3;`
//Udfør forespørgslen
_ , fejl := db . Exec ( forespørgsel );
hvis fejl != nul {
//Føj fejlmeddelelsen til loggen
log . Fatal ( fejl )
} andet {
//Udskriv succesmeddelelsen
fmt . Udskrivln ( 'Recorden er slettet med succes.' )
}
}
//Luk databaseforbindelsen
db . Tæt ()
}
Kør følgende kommando for at udføre filen 'delete_table.go':
$ go run delete_table.goFølgende output viser, at 3 rd registreringen af 'medlemmer'-tabellen er slettet. Succesmeddelelsen, 'Record is deleted successfully', udskrives i terminalen:
Du kan logge ind på SQLite for at kontrollere, om en registrering af medlemstabellen er slettet eller ej.
Kør følgende kommando for at køre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKør følgende SELECT-forespørgsel for at læse alt indhold i 'medlemmer'-tabellen:
sqlite3 > VÆLG * FRA medlemmer ;Følgende output viser, at værdien af 3 rd posten for medlemstabellen slettes efter udførelse af scriptet, og de to andre poster udskrives i outputtet:
Konklusion
Både SQLite og Golang er populære nu for deres enkelhed og lette funktioner. Enhver simpel databasebaseret applikation kan nemt implementeres ved hjælp af disse værktøjer. Den største del af enhver applikation er at implementere CRUD-operationen. Metoderne til implementering af CRUD-operation ved hjælp af Golang-script og SQLite-database er forklaret i denne tutorial ved hjælp af flere Golang-filer. Hvis du er ny i Go-sproget og SQLite-databasen, vil denne vejledning hjælpe dig med at lære disse fra det grundlæggende.