Développer des applications avec la bibliothèque GORM - Lindorm

Ce guide vous explique comment vous connecter à LindormTable à l'aide de la bibliothèque GORM et effectuer les opérations CRUD de base. À la fin, vous aurez :

Ajouté les dépendances GORM à votre projet Go
Établi une connexion à LindormTable via son endpoint compatible MySQL
Créé une table et exécuté des opérations de création, lecture, mise à jour et suppression

Prérequis

Avant de commencer, assurez-vous d'avoir :

Go 1.17 ou une version ultérieure installé. Consultez Télécharger et installer
LindormTable 2.6.1 ou une version ultérieure. Consultez les Notes de version de LindormTable et Mettre à jour la version mineure du moteur d'une instance Lindorm
La fonctionnalité de compatibilité MySQL activée sur votre instance. Consultez Activer la fonctionnalité de compatibilité MySQL
L'adresse IP de votre client ajoutée à la liste d'autorisation de l'instance. Consultez Configurer des listes d'autorisation

Ajouter les dépendances

Dans le fichier go.mod de votre projet, ajoutez le pilote MySQL GORM et la bibliothèque principale :

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

Se connecter à LindormTable

LindormTable prend en charge deux chemins réseau. Choisissez celui qui correspond à l'emplacement d'exécution de votre application :

Option	Quand l'utiliser	Endpoint à utiliser
VPC (recommandé)	L'application s'exécute sur une instance ECS dans le même VPC	Endpoint VPC LindormTable pour MySQL
Internet	L'application s'exécute sur un serveur local ou en dehors du VPC	Endpoint Internet LindormTable pour MySQL

Pour activer l'endpoint Internet, accédez à la console Lindorm, sélectionnez Database Connections > Wide Table Engine, puis cliquez sur Enable Public Endpoint dans l'onglet Wide Table Engine.

Pour obtenir votre endpoint, consultez Afficher les endpoints.

Construisez la chaîne de connexion et ouvrez une session 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
}

Espace réservé	Description
`<user>`	Nom d'utilisateur pour l'accès à LindormTable. Pour réinitialiser le mot de passe, consultez Gérer les utilisateurs.
`<password>`	Mot de passe pour l'accès à LindormTable.
`<lindorm_mysql_url>`	L'endpoint LindormTable pour MySQL.
`<database>`	La base de données à laquelle se connecter. La valeur par défaut est `default`.

Définir un modèle

GORM mappe les structures Go aux tables de base de données. LindormTable impose deux contraintes qui affectent la définition de votre modèle :

Pas d'incrémentation automatique : Définissez autoIncrement:false sur les champs de clé primaire.
Pas de type longtext : Mappez explicitement les champs string vers varchar ; sinon, GORM utilise par défaut longtext, qui n'est pas pris en charge par LindormTable.

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

Exécuter des opérations CRUD

Les exemples ci-dessous utilisent la session renvoyée par connectDB(). Tous les exemples utilisent session.Debug() pour journaliser le code SQL généré.

Créer une table

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

Insérer des lignes

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

Interroger des lignes

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

Mettre à jour une ligne

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

Supprimer une ligne

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

Exemple complet

Le code suivant regroupe toutes les étapes :

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

Sortie attendue :

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