Prerequisiti:
Devi completare le seguenti attività prima di esercitarti con gli esempi in questo tutorial:
A. Installa la lingua Golang nel sistema se non è stata installata prima. Esegui il seguente comando per verificare la versione installata di Golang:
Versione $ vai
B. Installare sqlite3 nel sistema se non è stato installato prima. Sqlite3 è installato per impostazione predefinita su Ubuntu 20+. Eseguire il seguente comando per verificare la versione installata di sqlite3:
$ sqlite3 --versione
C. Esegui i seguenti comandi per creare una cartella denominata 'golang-sqlite' e vai a quella cartella in cui verranno archiviati il file del database SQLite e il file Golang:
$ mkdir golang-sqlite$cd golang-sqlite
D. Esegui il seguente comando per scaricare il pacchetto Golang necessario per utilizzare SQLite con Golang:
$ vai su github.com/mattn/go-sqlite3
Operazioni di database utilizzando Golang e SQLite
Le operazioni di base del database utilizzando il database SQLite e lo script Golang sono mostrate in questo tutorial. L'elenco delle attività del database trattate in questo tutorial è menzionato di seguito:
- Crea un database SQLite
- Crea una connessione al database SQLite
- Crea una nuova tabella
- Inserisci i dati nella tabella
- Leggi i dati dalla tabella
- Aggiorna i dati della tabella
- Elimina i dati dalla tabella
Crea un database SQLite usando Golang
Crea un file Golang con il seguente script che crea un nuovo file di database SQLite denominato 'test.db'. Nello script vengono importati quattro moduli. Il modulo 'fmt' viene utilizzato per stampare l'output nel terminale. Il modulo 'log' viene utilizzato per interrompere il programma quando viene visualizzato un errore. Il modulo 'os' viene utilizzato per creare il database SQLite e gestire l'errore. Il modulo 'go-sqlite3' viene utilizzato per effettuare connessioni con il database SQLite tramite Golang. Il metodo Create() del modulo 'os' viene utilizzato qui per creare un database SQLite. Se il database viene creato correttamente, nel terminale viene stampato un messaggio di successo. In caso contrario, il programma verrà terminato. Il metodo Close() viene chiamato per chiudere la connessione al database.
pacchetto principale//Importa i moduli necessari
importare (
'fmt'
'tronco d'albero'
'Voi'
_ 'github.com/mattn/go-sqlite3'
)
funz principale () {
//Crea un nuovo database SQLite
db , errare := Voi . Creare ( 'prova.db' )
//Controlla eventuali errori
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Stampa il messaggio di successo
fmt . Stampaln ( 'Il database è stato creato.' )
}
//chiude la connessione al database
db . Vicino ()
}
Eseguire il comando seguente per eseguire il file 'db_connect.go':
$ vai a eseguire db_connect.goEseguire il comando 'ls' per verificare se il file di database 'test.db' è stato creato o meno:
$ lIl seguente output mostra che il messaggio di successo, 'Database is created', viene stampato nell'output e il file 'test.db' viene creato nella posizione corrente:
Connettiti con un database SQLite utilizzando Golang
Crea un file Golang con il seguente script che apre il file di database 'test.db' ed effettua la connessione con il database. Il modulo database/SQL di Golang viene importato qui per eseguire questa operazione. Il metodo open() viene utilizzato qui per stabilire la connessione con il database SQLite esistente. Se il database è connesso correttamente, nel terminale viene stampato un messaggio di successo. In caso contrario, il programma verrà terminato.
pacchetto principale//Importa i moduli necessari
importare (
'fmt'
'tronco d'albero'
'banca dati/sql'
_ 'github.com/mattn/go-sqlite3'
)
funz principale () {
//Crea un nuovo database SQLite
db , errare := sql . Aprire ( 'sqlite3' , 'prova.db' )
//Controlla eventuali errori
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Stampa il messaggio di successo
fmt . Stampaln ( 'Il database è connesso correttamente.' )
}
//Chiude la connessione al database
db . Vicino ()
}
Eseguire il seguente comando per eseguire il file 'db_connect2.go':
$ vai a eseguire db_connect2.goL'output seguente mostra che il file di database 'test.db' è stato aperto e connesso correttamente. Il messaggio di successo, 'Il database è connesso correttamente', viene stampato nell'output:
Creare una tabella in un database SQLite utilizzando Golang
Crea un file Golang con il seguente script che crea una tabella di database denominata 'membri' all'interno del file di database 'test.db'. Il metodo Exec() viene utilizzato qui per eseguire la query CREATE TABLE che crea la tabella 'membri' con sei campi e una chiave primaria. Se la tabella viene creata correttamente nel database, viene stampato un messaggio di successo. In caso contrario, il programma verrà terminato.
pacchetto principale//Importa i moduli necessari
importare (
'fmt'
'tronco d'albero'
'banca dati/sql'
_ 'github.com/mattn/go-sqlite3'
)
funz principale () {
//Crea un nuovo database sqlite
db , errare := sql . Aprire ( 'sqlite3' , 'prova.db' )
//Controlla eventuali errori
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
cost domanda corda = `
CREATE TABLE SE NON ESISTE membri (
id INTERO NON NULL CHIAVE PRIMARIA,
nome CHAR(40) NOT NULL,
mtype CHAR(100) NOT NULL,
e-mail CAR(50),
indirizzo TEXT NOT NULL,
mobile CHAR(25) NOT NULL);`
_ , errare := db . Esec ( domanda );
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Stampa il messaggio di successo
fmt . Stampaln ( 'La tabella è stata creata correttamente.' )
}
}
//chiude la connessione al database
db . Vicino ()
}
Eseguire il comando seguente per eseguire il file 'create_table.go':
$ vai a eseguire create_table.goL'output seguente mostra che la tabella è stata creata correttamente nel database. Il messaggio di successo, 'La tabella è stata creata con successo', viene stampato nel terminale:
Puoi accedere a SQLite per verificare se la tabella è stata creata o meno nel database.
Eseguire il seguente comando per eseguire SQLite con il database 'test.db':
$ prova sqlite3.dbEseguire il comando SQLite '.tables' dal prompt dei comandi SQLite per controllare i nomi delle tabelle del database:
sqlite3 > .tablesIl seguente output mostra che il database contiene la tabella 'membri' che viene creata eseguendo lo script Golang:
Inserisci i record nella tabella SQLite utilizzando Golang
È possibile inserire più record nella tabella eseguendo più volte la query INSERT o aggiungendo più valori in una singola query INSERT. Crea un file Golang con il seguente script che inserisce tre record nella tabella 'membri' del file di database 'test.db' utilizzando una singola query INSERT. Il metodo Exec() viene utilizzato qui per eseguire la query INSERT. Se i record vengono inseriti correttamente nella tabella, viene stampato un messaggio di successo. In caso contrario, il programma verrà terminato.
pacchetto principale//Importa i moduli necessari
importare (
'fmt'
'tronco d'albero'
'banca dati/sql'
_ 'github.com/mattn/go-sqlite3'
)
funz principale () {
//Crea un nuovo database SQLite
db , errare := sql . Aprire ( 'sqlite3' , 'prova.db' )
//Controlla eventuali errori
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
cost domanda corda = `
INSERT INTO membri (id, nome, mtype, email, indirizzo, cellulare)
VALUES(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');`
//Esegue la query
_ , errare := db . Esec ( domanda );
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Stampa il messaggio di successo
fmt . Stampaln ( 'Record inseriti correttamente.' )
}
}
//chiude la connessione al database
db . Vicino ()
}
Eseguire il seguente comando per eseguire il file 'insert_table.go':
$ vai a eseguire insert_table.goL'output seguente mostra che i record sono stati inseriti correttamente nella tabella. Il messaggio di successo, 'Record inseriti con successo', viene stampato nell'output:
Puoi accedere a SQLite per verificare se i tre record sono inseriti correttamente o meno nella tabella 'membri'.
Eseguire il seguente comando per eseguire SQLite con il database 'test.db':
$ prova sqlite3.dbEseguire la seguente query SELECT per leggere tutto il contenuto della tabella 'membri':
sqlite3 > SELEZIONA * A PARTIRE DAL membri ;L'output seguente mostra che la tabella 'membri' contiene tre record inseriti dallo script Golang:
Leggere i dati della tabella SQLite utilizzando Golang
Crea un file Golang con il seguente script che legge i record della tabella 'membri'. Devi definire le variabili in Golang per memorizzare i valori restituiti dalla query SELECT. In questo script, cinque campi vengono recuperati dalla tabella 'membri' utilizzando la query SELECT. Quindi, nello script sono definite cinque variabili per memorizzare i valori dei cinque campi della tabella “membri” dove il valore del campo “mtype” è “Silver”. Il metodo Query() viene utilizzato qui per eseguire la query SELECT. Successivamente, il ciclo 'for' viene utilizzato per leggere il set di risultati restituito dalla query SELECT. La funzione printf() viene utilizzata per stampare i valori formattati del set di risultati.
pacchetto principale//Importa i moduli necessari
importare (
'fmt'
'tronco d'albero'
'banca dati/sql'
_ 'github.com/mattn/go-sqlite3'
)
funz principale () {
//Crea un nuovo database SQLite
db , errare := sql . Aprire ( 'sqlite3' , 'prova.db' )
//Controlla eventuali errori
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Dichiara le variabili per memorizzare i valori di riga
era id int
era nome corda
era mtype corda
era indirizzo corda
era mobile corda
cost domanda corda = `SELECT id, nome, mtype, indirizzo, cellulare
A PARTIRE DAL membri
WHERE mtype = 'Argento';`
//Esegue la query
righe , errare := db . Domanda ( domanda );
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Stampa il messaggio di successo
fmt . Stampaln ( 'Record di tutti i membri d'argento:' )
fmt . Stampaln ( 'ID \T Nome \T \T Tipo di membro \T Indirizzo \T \T N. contatto' )
per righe . Prossimo () {
righe . Scansione ( &id , &nome , &mtype , &indirizzo , &mobile )
fmt . Stampaf ( '%D \T %S \T %S \T %S \T %S \N ' , id , nome , mtype , indirizzo , mobile )
}
}
}
//chiude la connessione al database
db . Vicino ()
}
Eseguire il seguente comando per eseguire il file 'select_table.go':
$ vai a eseguire select_table.goEsistono due record nella tabella 'members' che contiene 'Silver' nel campo 'mtype'. Il seguente output mostra due record della tabella 'members' restituiti dalla query SELECT:
Aggiorna i dati della tabella SQLite utilizzando Golang
Crea un file Golang con il seguente script che modifica il valore del campo mobile della tabella 'membri' che contiene il valore id di 2. Il metodo Exec() viene utilizzato qui per eseguire la query UPDATE. Se il record viene aggiornato correttamente nella tabella, viene stampato un messaggio di successo. In caso contrario, il programma verrà terminato.
pacchetto principale//Importa i moduli necessari
importare (
'fmt'
'tronco d'albero'
'banca dati/sql'
_ 'github.com/mattn/go-sqlite3'
)
funz principale () {
//Crea un nuovo database SQLite
db , errare := sql . Aprire ( 'sqlite3' , 'prova.db' )
//Controlla eventuali errori
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
cost domanda corda = `
UPDATE membri SET mobile = '018563452390' WHERE id = 2;`
_ , errare := db . Esec ( domanda );
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Stampa il messaggio di successo
fmt . Stampaln ( 'Il record è stato aggiornato correttamente.' )
}
}
//chiude la connessione al database
db . Vicino ()
}
Eseguire il comando seguente per eseguire il file 'update_table.go':
$ vai esegui update_table.goNella tabella 'membri', la seconda riga contiene il valore id 2. L'output seguente mostra che il record della tabella è stato aggiornato correttamente. Il messaggio di successo, 'Il record è stato aggiornato correttamente', viene stampato nel terminale:
Puoi accedere a SQLite per verificare se qualsiasi record della tabella dei membri è aggiornato o meno.
Eseguire il seguente comando per eseguire SQLite con il database 'test.db':
$ prova sqlite3.dbEseguire la seguente query SELECT per leggere tutto il contenuto della tabella 'membri':
sqlite3 > SELEZIONA * A PARTIRE DAL membri ;Il valore del campo mobile del 2 nd record della tabella dei membri è '01994563423' prima di eseguire lo script. L'output seguente mostra che il valore del campo mobile di 2 nd record della tabella dei membri viene modificato in '018563452390' dopo l'esecuzione dello script:
Elimina i dati della tabella SQLite utilizzando Golang
Crea un file Golang con il seguente script che elimina il file 3 rd record della tabella “members” che contiene il valore id di 3. Il metodo Exec() viene utilizzato qui per eseguire la query DELETE. Se il record viene eliminato correttamente dalla tabella, viene stampato un messaggio di successo. In caso contrario, il programma verrà terminato.
pacchetto principale//Importa i moduli necessari
importare (
'fmt'
'tronco d'albero'
'banca dati/sql'
_ 'github.com/mattn/go-sqlite3'
)
funz principale () {
//Crea un nuovo database SQLite
db , errare := sql . Aprire ( 'sqlite3' , 'prova.db' )
//Controlla eventuali errori
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Definisci la query di eliminazione
cost domanda corda = `DELETE FROM membri WHERE id = 3;`
//Esegue la query
_ , errare := db . Esec ( domanda );
Se errare != zero {
//Aggiungi il messaggio di errore al registro
tronco d'albero . Fatale ( errare )
} altro {
//Stampa il messaggio di successo
fmt . Stampaln ( 'Il record è stato eliminato correttamente.' )
}
}
//chiude la connessione al database
db . Vicino ()
}
Eseguire il comando seguente per eseguire il file 'delete_table.go':
$ vai esegui delete_table.goL'output seguente mostra che 3 rd record della tabella 'membri' viene eliminato correttamente. Il messaggio di successo, 'Il record è stato eliminato con successo', viene stampato nel terminale:
È possibile accedere a SQLite per verificare se un record della tabella dei membri è stato eliminato o meno.
Eseguire il seguente comando per eseguire SQLite con il database 'test.db':
$ prova sqlite3.dbEseguire la seguente query SELECT per leggere tutto il contenuto della tabella 'membri':
sqlite3 > SELEZIONA * A PARTIRE DAL membri ;L'output seguente mostra che il valore di 3 rd record della tabella dei membri viene eliminato dopo l'esecuzione dello script e gli altri due record vengono stampati nell'output:
Conclusione
Sia SQLite che Golang sono popolari ora per la loro semplicità e funzionalità leggere. Qualsiasi semplice applicazione basata su database può essere implementata facilmente utilizzando questi strumenti. La maggior parte di qualsiasi applicazione consiste nell'implementare l'operazione CRUD. I metodi di implementazione dell'operazione CRUD utilizzando lo script Golang e il database SQLite sono spiegati in questo tutorial utilizzando più file Golang. Se sei un nuovo studente della lingua Go e del database SQLite, questo tutorial ti aiuterà a impararli dalle basi.