Forutsetninger:
Du må fullføre følgende oppgaver før du øver på eksemplene i denne opplæringen:
A. Installer Golang-språket i systemet hvis det ikke er installert før. Kjør følgende kommando for å sjekke den installerte versjonen av Golang:
$ go versjon
B. Installer sqlite3 i systemet hvis den ikke har blitt installert før. Sqlite3 er installert som standard på Ubuntu 20+. Kjør følgende kommando for å sjekke den installerte versjonen av sqlite3:
$ sqlite3 --versjon
C. Kjør følgende kommandoer for å lage en mappe kalt 'golang-sqlite' og gå til den mappen der SQLite-databasefilen og Golang-filen vil bli lagret:
$ mkdir golang-sqlite$ cd golang-sqlite
D. Kjør følgende kommando for å laste ned den nødvendige Golang-pakken for å bruke SQLite med Golang:
$ gå til github.com/mattn/go-sqlite3
Databaseoperasjoner ved hjelp av Golang og SQLite
De grunnleggende databaseoperasjonene som bruker SQLite-databasen og Golang-skriptet er vist i denne opplæringen. Listen over databaseoppgaver som dekkes i denne opplæringen er nevnt i følgende:
- Opprett en SQLite-database
- Lag en SQLite-databasetilkobling
- Lag en ny tabell
- Sett inn dataene i tabellen
- Les dataene fra tabellen
- Oppdater dataene i tabellen
- Slett dataene fra tabellen
Opprett en SQLite-database ved å bruke Golang
Lag en Golang-fil med følgende skript som oppretter en ny SQLite-databasefil kalt 'test.db'. Fire moduler importeres til skriptet. 'fmt'-modulen brukes til å skrive ut utdataene i terminalen. 'Logg'-modulen brukes til å avbryte programmet når en feil oppstår. 'OS'-modulen brukes til å lage SQLite-databasen og håndtere feilen. 'go-sqlite3'-modulen brukes til å opprette forbindelser med SQLite-databasen gjennom Golang. Create()-metoden til 'os'-modulen brukes her for å lage en SQLite-database. Hvis databasen er opprettet, skrives en suksessmelding ut i terminalen. Ellers vil programmet bli avsluttet. Close()-metoden kalles for å lukke databasetilkoblingen.
pakke hoved-//Importer de nødvendige modulene
import (
'fmt'
'Logg'
'du'
_ 'github.com/mattn/go-sqlite3'
)
func hoved- () {
//Opprett en ny SQLite-database
db , feil := du . Skape ( 'test.db' )
//Se etter eventuelle feil
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Skriv ut suksessmeldingen
fmt . Println ( 'Database er opprettet.' )
}
//Lukk databasetilkoblingen
db . Lukk ()
}
Kjør følgende kommando for å utføre filen 'db_connect.go':
$ kjør db_connect.goKjør kommandoen 'ls' for å sjekke om databasefilen 'test.db' er opprettet eller ikke:
$ lsFølgende utdata viser at suksessmeldingen «Database er opprettet» skrives ut i utdataene og «test.db»-filen opprettes på gjeldende plassering:
Koble til en SQLite-database ved å bruke Golang
Lag en Golang-fil med følgende skript som åpner 'test.db'-databasefilen og koble til databasen. Databasen/SQL-modulen til Golang importeres hit for å utføre denne oppgaven. Open()-metoden brukes her for å opprette forbindelsen med den eksisterende SQLite-databasen. Hvis databasen er vellykket tilkoblet, skrives en suksessmelding ut i terminalen. Ellers vil programmet bli avsluttet.
pakke hoved-//Importer de nødvendige modulene
import (
'fmt'
'Logg'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hoved- () {
//Opprett en ny SQLite-database
db , feil := sql . Åpen ( 'sqlite3' , 'test.db' )
//Se etter eventuelle feil
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Skriv ut suksessmeldingen
fmt . Println ( 'Databasen er tilkoblet vellykket.' )
}
//Lukk databasetilkoblingen
db . Lukk ()
}
Kjør følgende kommando for å utføre filen 'db_connect2.go':
$ kjør db_connect2.goFølgende utdata viser at 'test.db'-databasefilen er åpnet og tilkoblet. Suksessmeldingen, 'Database er tilkoblet vellykket', skrives ut i utdataene:
Lag en tabell i en SQLite-database ved å bruke Golang
Lag en Golang-fil med følgende skript som lager en databasetabell kalt 'members' inne i 'test.db'-databasefilen. Exec()-metoden brukes her for å utføre CREATE TABLE-spørringen som lager 'members'-tabellen med seks felt og en primærnøkkel. Hvis tabellen er opprettet i databasen, skrives en suksessmelding ut. Ellers vil programmet bli avsluttet.
pakke hoved-//Importer de nødvendige modulene
import (
'fmt'
'Logg'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hoved- () {
//Opprett en ny sqlite-database
db , feil := sql . Åpen ( 'sqlite3' , 'test.db' )
//Se etter eventuelle feil
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
konst spørsmål streng = `
LAG TABELL HVIS IKKE FINNES medlemmer (
ID INTEGER IKKE NULL PRIMÆR NØKKEL,
navn CHAR(40) NOT NULL,
mtype CHAR(100) IKKE NULL,
e-post CHAR(50),
adresse TEXT NOT NULL,
mobil CHAR(25) IKKE NULL);`
_ , feil := db . Exec ( spørsmål );
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Skriv ut suksessmeldingen
fmt . Println ( 'Tabell er opprettet vellykket.' )
}
}
//Lukk databasetilkoblingen
db . Lukk ()
}
Kjør følgende kommando for å utføre filen 'create_table.go':
$ kjør create_table.goFølgende utdata viser at tabellen er opprettet i databasen. Suksessmeldingen, 'Tabell er opprettet vellykket', skrives ut i terminalen:
Du kan logge på SQLite for å sjekke om tabellen er opprettet eller ikke i databasen.
Kjør følgende kommando for å kjøre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKjør '.tables' SQLite-kommandoen fra SQLite-ledeteksten for å sjekke tabellnavnene til databasen:
sqlite3 > .tabellerFølgende utdata viser at databasen inneholder 'medlemmer'-tabellen som er opprettet ved å kjøre Golang-skriptet:
Sett inn postene i SQLite-tabellen ved å bruke Golang
Flere poster kan settes inn i tabellen ved å utføre INSERT-spørringen flere ganger eller ved å legge til flere verdier i en enkelt INSERT-spørring. Lag en Golang-fil med følgende skript som setter inn tre poster i «members»-tabellen i «test.db»-databasefilen ved å bruke en enkelt INSERT-spørring. Exec()-metoden brukes her for å utføre INSERT-spørringen. Hvis postene er satt inn i tabellen, skrives det ut en suksessmelding. Ellers vil programmet bli avsluttet.
pakke hoved-//Importer de nødvendige modulene
import (
'fmt'
'Logg'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hoved- () {
//Opprett en ny SQLite-database
db , feil := sql . Åpen ( 'sqlite3' , 'test.db' )
//Se etter eventuelle feil
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
konst spørsmål streng = `
INSERT INTO medlemmer (id, navn, mtype, e-post, adresse, mobil)
VERDIER(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');'
//Kjør spørringen
_ , feil := db . Exec ( spørsmål );
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Skriv ut suksessmeldingen
fmt . Println ( 'Oppføringer ble satt inn.' )
}
}
//Lukk databasetilkoblingen
db . Lukk ()
}
Kjør følgende kommando for å utføre filen 'insert_table.go':
$ kjør insert_table.goFølgende utdata viser at poster er satt inn i tabellen. Suksessmeldingen, 'Records inserted successfully', skrives ut i utskriften:
Du kan logge på SQLite for å sjekke om de tre postene er satt inn vellykket eller ikke i 'medlemmer'-tabellen.
Kjør følgende kommando for å kjøre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKjør følgende SELECT-spørring for å lese alt innholdet i «medlemmer»-tabellen:
sqlite3 > VELG * FRA medlemmer ;Følgende utdata viser at 'medlemmer'-tabellen inneholder tre poster som er satt inn av Golang-skriptet:
Les dataene til SQLite-tabellen ved å bruke Golang
Lag en Golang-fil med følgende skript som leser postene til 'medlemmer'-tabellen. Du må definere variablene i Golang for å lagre verdiene som returneres fra SELECT-spørringen. I dette skriptet hentes fem felt fra 'medlemmer'-tabellen ved å bruke SELECT-spørringen. Så fem variabler er definert i skriptet for å lagre verdiene til de fem feltene i 'members'-tabellen der verdien av 'mtype'-feltet er 'Silver'. Query()-metoden brukes her for å utføre SELECT-spørringen. Deretter brukes 'for'-løkken til å lese resultatsettet som returneres av SELECT-spørringen. Printf()-funksjonen brukes til å skrive ut de formaterte verdiene til resultatsettet.
pakke hoved-//Importer de nødvendige modulene
import (
'fmt'
'Logg'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hoved- () {
//Opprett en ny SQLite-database
db , feil := sql . Åpen ( 'sqlite3' , 'test.db' )
//Se etter eventuelle feil
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Deklarer variabler for å lagre radverdiene
var id int
var Navn streng
var mtype streng
var adresse streng
var mobil streng
konst spørsmål streng = `VELG ID, navn, mtype, adresse, mobil
FRA medlemmer
WHERE mtype = 'Sølv';`
//Kjør spørringen
rader , feil := db . Spørsmål ( spørsmål );
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Skriv ut suksessmeldingen
fmt . Println ( 'Rekord over alle sølvmedlemmer:' )
fmt . Println ( 'ID \t Navn \t \t Medlemstype \t Adresse \t \t Kontaktnummer' )
til rader . Neste () {
rader . Skann ( &id , &Navn , &mtype , &adresse , &mobil )
fmt . Printf ( '%d \t %s \t %s \t %s \t %s \n ' , id , Navn , mtype , adresse , mobil )
}
}
}
//Lukk databasetilkoblingen
db . Lukk ()
}
Kjør følgende kommando for å kjøre 'select_table.go'-filen:
$ kjør select_table.goDet finnes to poster i «members»-tabellen som inneholder «Silver» i «mtype»-feltet. Følgende utdata viser to poster av 'medlemmer'-tabellen som returneres av SELECT-spørringen:
Oppdater dataene til SQLite-tabellen ved å bruke Golang
Lag en Golang-fil med følgende skript som endrer verdien til mobilfeltet til «members»-tabellen som inneholder id-verdien til 2. Exec()-metoden brukes her for å utføre UPDATE-spørringen. Hvis posten er vellykket oppdatert i tabellen, skrives en suksessmelding ut. Ellers vil programmet bli avsluttet.
pakke hoved-//Importer de nødvendige modulene
import (
'fmt'
'Logg'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hoved- () {
//Opprett en ny SQLite-database
db , feil := sql . Åpen ( 'sqlite3' , 'test.db' )
//Se etter eventuelle feil
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
konst spørsmål streng = `
OPPDATER medlemmer SET mobil = '018563452390' WHERE id = 2;`
_ , feil := db . Exec ( spørsmål );
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Skriv ut suksessmeldingen
fmt . Println ( 'Recorden er oppdatert.' )
}
}
//Lukk databasetilkoblingen
db . Lukk ()
}
Kjør følgende kommando for å utføre filen 'update_table.go':
$ kjør update_table.goI «medlemmer»-tabellen inneholder den andre raden id-verdien 2. Følgende utdata viser at posten til tabellen er oppdatert. Suksessmeldingen, 'Record is updated successfully', skrives ut i terminalen:
Du kan logge på SQLite for å sjekke om noen oppføring av medlemstabellen er oppdatert eller ikke.
Kjør følgende kommando for å kjøre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKjør følgende SELECT-spørring for å lese alt innholdet i «medlemmer»-tabellen:
sqlite3 > VELG * FRA medlemmer ;Verdien av mobilfeltet til 2 nd posten for medlemstabellen er '01994563423' før skriptet kjøres. Følgende utgang viser at verdien av mobilfeltet til 2 nd posten for medlemstabellen endres til '018563452390' etter utføring av skriptet:
Slett dataene til SQLite-tabellen ved å bruke Golang
Lag en Golang-fil med følgende skript som sletter 3 rd post for 'members'-tabellen som inneholder id-verdien til 3. Exec()-metoden brukes her for å utføre DELETE-spørringen. Hvis posten er slettet fra tabellen, skrives en suksessmelding ut. Ellers vil programmet bli avsluttet.
pakke hoved-//Importer de nødvendige modulene
import (
'fmt'
'Logg'
'database/sql'
_ 'github.com/mattn/go-sqlite3'
)
func hoved- () {
//Opprett en ny SQLite-database
db , feil := sql . Åpen ( 'sqlite3' , 'test.db' )
//Se etter eventuelle feil
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Definer slettespørringen
konst spørsmål streng = `DELETE FROM medlemmer WHERE id = 3;`
//Kjør spørringen
_ , feil := db . Exec ( spørsmål );
hvis feil != null {
//Legg til feilmeldingen i loggen
Logg . Fatal ( feil )
} ellers {
//Skriv ut suksessmeldingen
fmt . Println ( 'Oppføringen er slettet.' )
}
}
//Lukk databasetilkoblingen
db . Lukk ()
}
Kjør følgende kommando for å utføre filen 'delete_table.go':
$ kjør delete_table.goFølgende utgang viser at 3 rd oppføringen for 'medlemmer'-tabellen er slettet. Suksessmeldingen, 'Record is deleted vellykket', skrives ut i terminalen:
Du kan logge på SQLite for å sjekke om noen oppføring av medlemstabellen er slettet eller ikke.
Kjør følgende kommando for å kjøre SQLite med 'test.db'-databasen:
$ sqlite3 test.dbKjør følgende SELECT-spørring for å lese alt innholdet i «medlemmer»-tabellen:
sqlite3 > VELG * FRA medlemmer ;Følgende utgang viser at verdien av 3 rd posten til medlemstabellen slettes etter utføring av skriptet, og de to andre postene skrives ut i utdataene:
Konklusjon
Både SQLite og Golang er populære nå for sin enkelhet og lette funksjoner. Enhver enkel databasebasert applikasjon kan enkelt implementeres ved hjelp av disse verktøyene. Hoveddelen av enhver applikasjon er å implementere CRUD-operasjonen. Metodene for å implementere CRUD-operasjon ved hjelp av Golang-skript og SQLite-database er forklart i denne opplæringen ved å bruke flere Golang-filer. Hvis du er en ny elev av Go-språket og SQLite-databasen, vil denne opplæringen hjelpe deg med å lære disse fra det grunnleggende.