Go - AnalyticDB - Centre de documentation Alibaba Cloud

Utilisez le pilote MySQL pour Go (go-sql-driver/mysql) pour connecter votre application Go à un cluster AnalyticDB for MySQL.

Prérequis

Avant de commencer, assurez-vous d'avoir :

Git installé, avec son chemin ajouté à la variable d'environnement PATH
Go installé — consultez la page Download and install
Le pilote MySQL pour Go installé :
1. Téléchargez le pilote depuis le dépôt go-sql-driver/mysql.
2. Exécutez la commande suivante pour l'installer dans $GOPATH :
```
go get github.com/go-sql-driver/mysql
```

Connexion à un cluster

L'exemple suivant ouvre une connexion vers votre cluster AnalyticDB for MySQL, configure le pool de connexions et exécute une requête SHOW TABLES.

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "time"
)

const (
    // Account used to connect. AnalyticDB for MySQL supports privileged accounts and standard accounts.
    user = "adb_test"
    // Password of the account.
    password = "xxx"
    // IP address of the cluster. Find it on the Cluster Information page in the AnalyticDB for MySQL console.
    host = "127.0.xx.xx"
    // Port used to connect to the cluster.
    port = 3306
    // Name of the database in the cluster.
    database = "database_name"
    // Connection timeout.
    connectTimeout = "10s"
)

func main() {
    // Open the database connection.
    url := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?timeout=%s", user, password, host, port, database, connectTimeout)
    db, err := sql.Open("mysql", url)
    if err != nil {
        panic(err.Error())
    }
    // Maximum number of open connections. Default is 0 (unlimited).
    db.SetMaxOpenConns(2)
    // Maximum number of idle connections.
    db.SetMaxIdleConns(1)
    // Maximum lifetime of a connection (see Usage notes below).
    db.SetConnMaxLifetime(time.Hour)
    defer db.Close()

    rows, err := db.Query("show tables")
    if err != nil {
        panic(err.Error())
    }
    for rows.Next() {
        var tableName string
        err := rows.Scan(&tableName)
        if err != nil {
            panic(err.Error())
        }
        fmt.Println(tableName)
    }
}

Activation des instructions préparées côté serveur

Utilisez db.Prepare pour créer une instruction préparée que le serveur compile et met en cache.

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "time"
)

const (
    user           = "adb_test"
    password       = "xxx"
    host           = "127.0.xx.xx"
    port           = 3306
    database       = "database_name"
    connectTimeout = "10s"
)

func main() {
    url := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?timeout=%s", user, password, host, port, database, connectTimeout)
    db, err := sql.Open("mysql", url)
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

    db.SetMaxOpenConns(2)
    db.SetMaxIdleConns(1)
    db.SetConnMaxLifetime(time.Hour)

    stmt, err := db.Prepare("select * from student where id = ?")
    if err != nil {
        panic(err.Error())
    }
    defer stmt.Close()

    rows, err := stmt.Query(9)
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()

    for rows.Next() {
        var id, name, unit string
        err := rows.Scan(&id, &name, &unit)
        if err != nil {
            panic(err.Error())
        }
        fmt.Println(fmt.Sprintf("%s, %s, %s", id, name, unit))
    }
}

Activation des instructions préparées côté client

Pour utiliser les instructions préparées côté client, définissez interpolateParams=true dans l'URL de connexion. Le pilote interpole alors les paramètres de la requête localement avant d'envoyer l'instruction au serveur.

Important

db.Prepare et stmt.Query ne détectent pas si interpolateParams est activé. Utilisez db.Query pour exécuter des instructions préparées côté client.

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
    "time"
)

const (
    user           = "adb_test"
    password       = "xxx"
    host           = "127.0.xx.xx"
    port           = 3306
    database       = "database_name"
    connectTimeout = "10s"
)

func main() {
    // Set interpolateParams=true to enable client-side prepared statements.
    url := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?timeout=%s&interpolateParams=true", user, password, host, port, database, connectTimeout)
    db, err := sql.Open("mysql", url)
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()

    db.SetMaxOpenConns(2)
    db.SetMaxIdleConns(1)
    db.SetConnMaxLifetime(time.Hour)

    rows, err := db.Query("select * from student where id = ?", 9)
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()

    for rows.Next() {
        var id, name, unit string
        err := rows.Scan(&id, &name, &unit)
        if err != nil {
            panic(err.Error())
        }
        fmt.Println(fmt.Sprintf("%s, %s, %s", id, name, unit))
    }
}

Notes d'utilisation

Paramètres du pool de connexions

Les trois méthodes de gestion du pool de connexions contrôlent la manière dont le package database/sql gère les connexions :

Méthode	Valeur par défaut	Description
`SetMaxOpenConns(n)`	0 (illimité)	Nombre maximal de connexions ouvertes à la base de données
`SetMaxIdleConns(n)`	—	Nombre maximal de connexions inactives dans le pool
`SetConnMaxLifetime(d)`	0 (aucune limite)	Durée de vie maximale d'une connexion

**À propos de SetConnMaxLifetime : Une connexion expire après la durée spécifiée à compter de sa création initiale**, et non depuis sa dernière mise en veille. La définition d'une durée de vie plus courte augmente la fréquence de création de nouvelles connexions. Le pilote peut fermer une connexion avant l'expiration de sa durée de vie si celle-ci devient indisponible.

Instructions préparées côté serveur ou côté client

Mode	Fonctionnement	Cas d'utilisation
Côté serveur	Le serveur analyse et met en cache l'instruction	Comportement par défaut ; utilisez `db.Prepare` + `stmt.Query`
Côté client	Le pilote interpole les paramètres avant l'envoi	Définissez `interpolateParams=true` ; utilisez `db.Query`

Étapes suivantes

Consultez la documentation go-sql-driver/mysql documentation pour en savoir plus sur les paramètres de connexion pris en charge par le pilote MySQL pour Go.
Explorez la syntaxe SQL d'AnalyticDB for MySQL pour construire les requêtes de votre application.