Use a biblioteca GORM para desenvolver aplicações - Lindorm: Central de Documentação do Alibaba Cloud

Este guia demonstra como se conectar ao LindormTable com a biblioteca GORM e executar operações básicas de CRUD. Ao final, você terá:

Adicionado as dependências do GORM ao seu projeto Go
Conectado ao LindormTable pelo endpoint compatível com MySQL
Criado uma tabela e executado operações de criação, leitura, atualização e exclusão

Pré-requisitos

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

Go 1.17 ou posterior instalado. Consulte Baixe e instale
LindormTable 2.6.1 ou posterior. Consulte Notas de versão do LindormTable e Atualize a versão secundária do mecanismo de uma instância Lindorm
Recurso de compatibilidade com MySQL ativado na sua instância. Consulte Ative o recurso de compatibilidade com MySQL
Endereço IP do cliente adicionado à lista de permissões da instância. Consulte Configure listas de permissões

Adicionar dependências

No arquivo go.mod do projeto, adicione o driver MySQL do GORM e a biblioteca principal:

require (
    gorm.io/driver/mysql v1.5.1
    gorm.io/gorm v1.25.4
)

Conectar-se ao LindormTable

O LindormTable oferece dois caminhos de rede. Escolha conforme o local de execução da aplicação:

Opção	Quando usar	Endpoint
VPC (recomendado)	A aplicação roda em uma instância ECS na mesma VPC	Endpoint VPC do LindormTable para MySQL
Internet	A aplicação roda em um servidor local ou fora da VPC	Endpoint de Internet do LindormTable para MySQL

Para ativar o endpoint de Internet, acesse o console do Lindorm, selecione Database Connections > Wide Table Engine e clique em Enable Public Endpoint na aba Wide Table Engine.

Para obter o endpoint, consulte Visualize endpoints.

Monte a string de conexão e abra uma sessão GORM:

package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

func connectDB() *gorm.DB {
    // Format: <user>:<password>@tcp(<lindorm_mysql_url>:33060)/<database>
    // Replace the placeholders with your actual credentials and endpoint.
    // The default database name is "default".
    dsn := "<user>:<password>@tcp(<lindorm_mysql_url>:33060)/<database>"

    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic(err)
    }

    // LindormTable does not support transactions.
    // Always create sessions with SkipDefaultTransaction set to true.
    session := db.Session(&gorm.Session{SkipDefaultTransaction: true})
    return session
}

Espaço reservado	Descrição
`<user>`	Nome de usuário para acesso ao LindormTable. Para redefinir a senha, consulte Gerencie usuários.
`<password>`	Senha para acesso ao LindormTable.
`<lindorm_mysql_url>`	Endpoint do LindormTable para MySQL.
`<database>`	Banco de dados de destino. O padrão é `default`.

Defina um modelo

O GORM mapeia structs do Go para tabelas de banco de dados. O LindormTable impõe duas restrições que afetam a definição do modelo:

Sem incremento automático: Defina autoIncrement:false nos campos de chave primária.
Sem longtext: Mapeie campos string explicitamente para varchar. Caso contrário, o GORM usará longtext por padrão, tipo incompatível com o LindormTable.

type Product struct {
    ID    int64   `gorm:"primaryKey;autoIncrement:false"`
    Code  string  `gorm:"type:varchar"`
    Price float64
}

Execute operações CRUD

Os exemplos abaixo usam a session retornada por connectDB(). Todos empregam session.Debug() para registrar o SQL gerado nos logs.

Crie uma tabela

err := session.Migrator().CreateTable(&Product{})
if err != nil {
    panic(err)
}

Inserir linhas

// Insert a row with ID 1
tx := session.Debug().Create(&Product{ID: 1, Code: "D42", Price: 100.1})
if tx.Error != nil {
    panic(tx.Error)
}

// Insert a row with ID 2
tx = session.Debug().Create(&Product{ID: 2, Code: "B41", Price: 105.5})
if tx.Error != nil {
    panic(tx.Error)
}

Consultar linhas

// Query by primary key
var product1 Product
session.Debug().First(&product1, 1)

// Query by a non-primary-key column
var product2 Product
session.Debug().First(&product2, "code = ?", "B41")

Atualize uma linha

// Update the Price column for the row where ID = 1
session.Debug().Model(&Product{}).Where("id = ?", 1).Update("price", 101.8)

Exclua uma linha

// Delete the row where the primary key is 1
session.Delete(&Product{}, 1)

Exemplo completo

O código a seguir integra todas as etapas:

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

// Product maps to the "products" table in LindormTable.
// autoIncrement:false — LindormTable does not support auto increment.
// type:varchar — LindormTable does not support longtext, which is GORM's default for string.
type Product struct {
    ID    int64   `gorm:"primaryKey;autoIncrement:false"`
    Code  string  `gorm:"type:varchar"`
    Price float64
}

func main() {
    // Set user to the username used to access LindormTable.
    // Set password to the password used to access LindormTable.
    // Set lindorm_mysql_url to the LindormTable endpoint for MySQL.
    // Set database to the database to which you want to connect.
    dsn := "user:test@tcp(ld-uf6k8yqb741t3****-proxy-sql-lindorm.lindorm.rds.aliyuncs.com:33060)/default"

    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic(err)
    }

    // LindormTable does not support transactions.
    session := db.Session(&gorm.Session{SkipDefaultTransaction: true})

    // Create the table.
    err = session.Migrator().CreateTable(&Product{})
    if err != nil {
        panic(err)
    }

    // Insert two rows.
    tx := session.Debug().Create(&Product{ID: 1, Code: "D42", Price: 100.1})
    if tx.Error != nil {
        panic(tx.Error)
    }
    tx = session.Debug().Create(&Product{ID: 2, Code: "B41", Price: 105.5})
    if tx.Error != nil {
        panic(tx.Error)
    }

    // Query by primary key.
    var product1 Product
    session.Debug().First(&product1, 1)
    fmt.Println(product1)

    // Query by column value.
    var product2 Product
    session.Debug().First(&product2, "code = ?", "B41")
    fmt.Println(product2)

    // Update the Price column for ID = 1.
    session.Debug().Model(&Product{}).Where("id = ?", 1).Update("price", 101.8)
    product1 = Product{}
    session.Debug().First(&product1, 1)
    fmt.Println(product1)

    // Delete the row where the primary key is 1.
    session.Delete(&Product{}, 1)
    product1 = Product{}
    session.Debug().First(&product1, 1)
    fmt.Println(product1)
}

Saída esperada:

{1 D42 100.1}
{2 B41 105.5}
{1 D42 101.8}
{0  0}