Go - AnalyticDB: Central de Documentação do Alibaba Cloud

Pré-requisitos

Antes de começar, verifique se você tem:

git instalado com o caminho adicionado à variável de ambiente PATH
Go instalado — consulte Baixe e instale
Driver MySQL para Go instalado:
1. Baixe o driver em go-sql-driver/mysql.
2. Execute o comando a seguir para instalá-lo em $GOPATH:
```
go get github.com/go-sql-driver/mysql
```

Conectar-se a um cluster

O exemplo a seguir abre uma conexão com o cluster do AnalyticDB for MySQL, configura o pool de conexões e executa uma consulta 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)
    }
}

Ative prepared statements no servidor

Use db.Prepare para criar uma prepared statement que o servidor compila e armazena em 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))
    }
}

Ative prepared statements no cliente

Para usar prepared statements no lado do cliente, defina interpolateParams=true na URL de conexão. Assim, o driver interpola os parâmetros da consulta localmente antes de enviar a instrução ao servidor.

Importante

Os métodos db.Prepare e stmt.Query não detectam se interpolateParams está definido. Use db.Query para executar prepared statements no lado do cliente.

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))
    }
}

Observações de uso

Configurações do pool de conexões

Os três métodos de pool de conexões controlam como o pacote database/sql gerencia as conexões:

Método	Padrão	Descrição
`SetMaxOpenConns(n)`	0 (ilimitado)	Número máximo de conexões abertas com o banco de dados
`SetMaxIdleConns(n)`	—	Número máximo de conexões ociosas no pool
`SetConnMaxLifetime(d)`	0 (sem limite)	Tempo de vida máximo de uma conexão

**Sobre SetConnMaxLifetime: Uma conexão expira após a duração especificada contada a partir de sua criação inicial**, e não desde a última vez que ficou ociosa. Definir um tempo de vida mais curto aumenta a frequência de criação de novas conexões. O driver pode fechar uma conexão antes que o tempo de vida expire caso ela fique indisponível.

Prepared statements no servidor vs. no cliente

Modo	Funcionamento	Quando usar
Servidor	O servidor analisa e armazena a instrução em cache	Comportamento padrão; use `db.Prepare` + `stmt.Query`
Cliente	O driver interpola os parâmetros antes do envio	Defina `interpolateParams=true`; use `db.Query`

Próximos passos

Saiba mais sobre os parâmetros de conexão compatíveis com o driver MySQL para Go na documentação do go-sql-driver/mysql.
Consulte a sintaxe SQL do AnalyticDB for MySQL para crie consultas para sua aplicação.