Uso de la biblioteca GORM para desarrollar aplicaciones - Lindorm - Centro de documentación de Alibaba Cloud

Esta guía muestra cómo conectarse a LindormTable mediante la biblioteca GORM y ejecutar operaciones CRUD básicas. Al finalizar, habrá logrado lo siguiente:

Agregar las dependencias de GORM a su proyecto de Go.
Conectarse a LindormTable a través de su endpoint compatible con MySQL.
Crear una tabla y ejecutar operaciones de creación, lectura, actualización y eliminación.

Requisitos previos

Antes de empezar, asegúrese de contar con lo siguiente:

Go 1.17 o una versión posterior instalada. Consulte Descargar e instalar.
LindormTable 2.6.1 o una versión posterior. Consulte Notas de la versión de LindormTable y Actualizar la versión secundaria del motor de una instancia de Lindorm.
La función de compatibilidad con MySQL habilitada en su instancia. Consulte Habilitar la función de compatibilidad con MySQL.
Su dirección IP de cliente agregada a la lista de permitidos de la instancia. Consulte Configurar listas de permitidos.

Agregar dependencias

En el archivo go.mod de su proyecto, agregue el controlador de MySQL y la biblioteca principal de GORM:

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

Conectarse a LindormTable

LindormTable admite dos rutas de red. Elija una según el lugar donde se ejecute su aplicación:

Opción	Cuándo usarla	Endpoint que debe utilizar
VPC (recomendado)	La aplicación se ejecuta en una instancia de ECS dentro de la misma VPC.	Endpoint de VPC de LindormTable para MySQL
Internet	La aplicación se ejecuta en un servidor local o fuera de la VPC.	Endpoint de Internet de LindormTable para MySQL

Para habilitar el endpoint de Internet, vaya a la consola de Lindorm, seleccione Database Connections > Wide Table Engine y haga clic en Enable Public Endpoint en la pestaña Wide Table Engine.

Para obtener su endpoint, consulte View endpoints.

Construya la cadena de conexión y abra una sesión de 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
}

Marcador de posición	Descripción
`<user>`	Nombre de usuario para acceder a LindormTable. Para restablecer la contraseña, consulte Manage users.
`<password>`	Contraseña para acceder a LindormTable.
`<lindorm_mysql_url>`	El endpoint de LindormTable para MySQL.
`<database>`	La base de datos a la que desea conectarse. El valor predeterminado es `default`.

Definir un modelo

GORM asigna estructuras de Go a tablas de bases de datos. LindormTable tiene dos restricciones que afectan la forma en que define su modelo:

Sin incremento automático: Establezca autoIncrement:false en los campos de clave primaria.
Sin longtext: Asigne explícitamente los campos string al tipo varchar. De lo contrario, GORM usará longtext de forma predeterminada, un tipo que LindormTable no admite.

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

Ejecutar operaciones CRUD

Los ejemplos a continuación utilizan la variable session que devuelve connectDB(). Todos los ejemplos usan session.Debug() para registrar el SQL generado.

Crear una tabla

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

Insertar filas

// 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 filas

// 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")

Actualizar una fila

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

Eliminar una fila

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

Ejemplo completo

A continuación se muestra el código que integra todos los pasos:

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

Salida esperada:

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