Guida introduttiva: Usare il linguaggio Go per connettersi ed eseguire query sui dati in Database di Azure per MySQL
SI APPLICA A: Database di Azure per MySQL - Server singolo
Importante
Database di Azure per MySQL server singolo si trova nel percorso di ritiro. È consigliabile eseguire l'aggiornamento a Database di Azure per MySQL server flessibile. Per altre informazioni sulla migrazione a Database di Azure per MySQL server flessibile, vedere Che cosa accade a Database di Azure per MySQL server singolo?
Questa guida introduttiva illustra come connettersi a un database di Azure per MySQL dalle piattaforme Windows, Ubuntu Linux e Apple macOS usando codice scritto nel linguaggio Go. Spiega come usare le istruzioni SQL per eseguire query, inserire, aggiornare ed eliminare dati nel database. Questo argomento presuppone che si abbia familiarità con lo sviluppo con Go, ma non con Database di Azure per MySQL.
Prerequisiti
Questa guida introduttiva usa le risorse create in una delle guide seguenti come punto di partenza:
- Create an Azure Database for MySQL server using Azure portal (Creare un database di Azure per il server MySQL usando il portale di Azure)
- Creare un database di Azure per il server MySQL tramite l'interfaccia della riga di comando di Azure
Importante
Verificare che l'indirizzo IP da cui ci si sta connettendo sia stato aggiunto alle regole del firewall del server usando il portale di Azure o l’interfaccia della riga di comando di Azure
Installare Go e il connettore MySQL
Installare Go e il driver go-sql per MySQL nel computer. A seconda della piattaforma, seguire le istruzioni nella sezione appropriata:
Scaricare e installare Go per Microsoft Windows seguendo le istruzioni di installazione.
Avviare il prompt dei comandi dal menu Start.
Creare una cartella per il progetto, ad esempio
mkdir %USERPROFILE%\go\src\mysqlgo
.Passare alla cartella del progetto, ad esempio
cd %USERPROFILE%\go\src\mysqlgo
.Impostare la variabile di ambiente per GOPATH in modo che punti alla directory del codice sorgente.
set GOPATH=%USERPROFILE%\go
.Installare il driver go-sql per MySQL eseguendo il comando
go get github.com/go-sql-driver/mysql
.In sintesi, installare Go e quindi eseguire questi comandi nel prompt dei comandi:
mkdir %USERPROFILE%\go\src\mysqlgo cd %USERPROFILE%\go\src\mysqlgo set GOPATH=%USERPROFILE%\go go get github.com/go-sql-driver/mysql
Ottenere informazioni di connessione
Ottenere le informazioni di connessione necessarie per connettersi al database di Azure per MySQL. Sono necessari il nome del server completo e le credenziali di accesso.
- Accedere al portale di Azure.
- Nel menu a sinistra nel portale di Azure fare clic su Tutte le risorse e quindi cercare il server creato, ad esempio mydemoserver.
- Fare clic sul nome del server.
- Nel pannello Panoramica del server prendere nota dei valori riportati in Nome server e Nome di accesso dell'amministratore server. Se si dimentica la password, in questo pannello è anche possibile reimpostarla.
Compilare ed eseguire il codice Go
- Per scrivere codice Golang si può usare un editor di testo semplice, ad esempio Blocco note di Microsoft Windows, vi o Nano in Ubuntu oppure TextEdit in macOS. Se si preferisce un ambiente IDE (Interactive Development Environment) avanzato, provare Gogland di Jetbrains, Visual Studio Code di Microsoft o Atom.
- Incollare il codice Go dalle sezioni seguenti in file di testo e quindi salvarli nella cartella del progetto con estensione file *.go (ad esempio percorso
%USERPROFILE%\go\src\mysqlgo\createtable.go
di Windows o percorso~/go/src/mysqlgo/createtable.go
Linux). - Trovare le costanti
HOST
,DATABASE
,USER
ePASSWORD
nel codice e quindi sostituire i valori di esempio con i propri valori. - Avviare il prompt dei comandi o la shell Bash. Passare alla cartella del progetto, ad esempio
cd %USERPROFILE%\go\src\mysqlgo\
in Windows. In Linuxcd ~/go/src/mysqlgo/
. Alcuni degli editor dell'ambiente di sviluppo integrato indicati offrono funzionalità di debug e di runtime che non richiedono comandi della shell. - Eseguire il codice digitando il comando
go run createtable.go
per compilare l'applicazione ed eseguirla. - In alternativa, per compilare il codice in un'applicazione nativa, digitare
go build createtable.go
e quindi avviarecreatetable.exe
per eseguire l'applicazione.
Connettersi, creare tabelle e inserire dati
Usare il codice seguente per connettersi al server, creare una tabella e caricare i dati usando un'istruzione SQL INSERT.
Il codice importa tre pacchetti: il pacchetto SQL, il driver go sql per MySql come driver per comunicare con il database di Azure per MySQL e il pacchetto fmt per l'input e l'output stampati nella riga di comando.
Il codice chiama il metodo sql.Open() per la connessione al database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il metodo Exec() più volte per eseguire diversi comandi DDL. Il codice usa anche Prepare() ed Exec() per eseguire le istruzioni preparate con parametri diversi per inserire tre righe. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.
Sostituire le costanti host
, database
, user
e password
con i propri valori.
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
const (
host = "mydemoserver.mysql.database.azure.com"
database = "quickstartdb"
user = "myadmin@mydemoserver"
password = "yourpassword"
)
func checkError(err error) {
if err != nil {
panic(err)
}
}
func main() {
// Initialize connection string.
var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true", user, password, host, database)
// Initialize connection object.
db, err := sql.Open("mysql", connectionString)
checkError(err)
defer db.Close()
err = db.Ping()
checkError(err)
fmt.Println("Successfully created connection to database.")
// Drop previous table of same name if one exists.
_, err = db.Exec("DROP TABLE IF EXISTS inventory;")
checkError(err)
fmt.Println("Finished dropping table (if existed).")
// Create table.
_, err = db.Exec("CREATE TABLE inventory (id serial PRIMARY KEY, name VARCHAR(50), quantity INTEGER);")
checkError(err)
fmt.Println("Finished creating table.")
// Insert some data into table.
sqlStatement, err := db.Prepare("INSERT INTO inventory (name, quantity) VALUES (?, ?);")
res, err := sqlStatement.Exec("banana", 150)
checkError(err)
rowCount, err := res.RowsAffected()
fmt.Printf("Inserted %d row(s) of data.\n", rowCount)
res, err = sqlStatement.Exec("orange", 154)
checkError(err)
rowCount, err = res.RowsAffected()
fmt.Printf("Inserted %d row(s) of data.\n", rowCount)
res, err = sqlStatement.Exec("apple", 100)
checkError(err)
rowCount, err = res.RowsAffected()
fmt.Printf("Inserted %d row(s) of data.\n", rowCount)
fmt.Println("Done.")
}
Leggere i dati
Usare il codice seguente per connettersi e leggere i dati usando un'istruzione SQL SELECT.
Il codice importa tre pacchetti: il pacchetto SQL, il driver go sql per MySql come driver per comunicare con il database di Azure per MySQL e il pacchetto fmt per l'input e l'output stampati nella riga di comando.
Il codice chiama il metodo sql.Open() per la connessione al database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il metodo Query() per eseguire il comando SELECT. Esegue quindi il metodo Next() per scorrere il set di risultati e Scan() per analizzare i valori delle colonne, salvando il valore nelle variabili. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.
Sostituire le costanti host
, database
, user
e password
con i propri valori.
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
const (
host = "mydemoserver.mysql.database.azure.com"
database = "quickstartdb"
user = "myadmin@mydemoserver"
password = "yourpassword"
)
func checkError(err error) {
if err != nil {
panic(err)
}
}
func main() {
// Initialize connection string.
var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true", user, password, host, database)
// Initialize connection object.
db, err := sql.Open("mysql", connectionString)
checkError(err)
defer db.Close()
err = db.Ping()
checkError(err)
fmt.Println("Successfully created connection to database.")
// Variables for printing column data when scanned.
var (
id int
name string
quantity int
)
// Read some data from the table.
rows, err := db.Query("SELECT id, name, quantity from inventory;")
checkError(err)
defer rows.Close()
fmt.Println("Reading data:")
for rows.Next() {
err := rows.Scan(&id, &name, &quantity)
checkError(err)
fmt.Printf("Data row = (%d, %s, %d)\n", id, name, quantity)
}
err = rows.Err()
checkError(err)
fmt.Println("Done.")
}
Aggiornamento dei dati
Usare il codice seguente per connettersi e aggiornare i dati usando un'istruzione SQL UPDATE.
Il codice importa tre pacchetti: il pacchetto SQL, il driver go sql per MySql come driver per comunicare con il database di Azure per MySQL e il pacchetto fmt per l'input e l'output stampati nella riga di comando.
Il codice chiama il metodo sql.Open() per la connessione al database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il metodo Exec() per eseguire il comando UPDATE. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.
Sostituire le costanti host
, database
, user
e password
con i propri valori.
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
const (
host = "mydemoserver.mysql.database.azure.com"
database = "quickstartdb"
user = "myadmin@mydemoserver"
password = "yourpassword"
)
func checkError(err error) {
if err != nil {
panic(err)
}
}
func main() {
// Initialize connection string.
var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true", user, password, host, database)
// Initialize connection object.
db, err := sql.Open("mysql", connectionString)
checkError(err)
defer db.Close()
err = db.Ping()
checkError(err)
fmt.Println("Successfully created connection to database.")
// Modify some data in table.
rows, err := db.Exec("UPDATE inventory SET quantity = ? WHERE name = ?", 200, "banana")
checkError(err)
rowCount, err := rows.RowsAffected()
fmt.Printf("Updated %d row(s) of data.\n", rowCount)
fmt.Println("Done.")
}
Eliminare dati
Usare il codice seguente per connettersi e rimuovere i dati usando un'istruzione SQL DELETE.
Il codice importa tre pacchetti: il pacchetto SQL, il driver go sql per MySql come driver per comunicare con il database di Azure per MySQL e il pacchetto fmt per l'input e l'output stampati nella riga di comando.
Il codice chiama il metodo sql.Open() per la connessione al database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il metodo Exec() per eseguire il comando DELETE. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.
Sostituire le costanti host
, database
, user
e password
con i propri valori.
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
const (
host = "mydemoserver.mysql.database.azure.com"
database = "quickstartdb"
user = "myadmin@mydemoserver"
password = "yourpassword"
)
func checkError(err error) {
if err != nil {
panic(err)
}
}
func main() {
// Initialize connection string.
var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true", user, password, host, database)
// Initialize connection object.
db, err := sql.Open("mysql", connectionString)
checkError(err)
defer db.Close()
err = db.Ping()
checkError(err)
fmt.Println("Successfully created connection to database.")
// Modify some data in table.
rows, err := db.Exec("DELETE FROM inventory WHERE name = ?", "orange")
checkError(err)
rowCount, err := rows.RowsAffected()
fmt.Printf("Deleted %d row(s) of data.\n", rowCount)
fmt.Println("Done.")
}
Pulire le risorse
Per pulire tutte le risorse usate in questo argomento di avvio rapido, eliminare il gruppo di risorse con il comando seguente:
az group delete \
--name $AZ_RESOURCE_GROUP \
--yes
Passaggi successivi
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per