Partage via

Démarrage rapide : Utiliser Golang pour interroger une base de données dans Azure SQL Database ou Azure SQL Managed Instance

  • Article

S’applique à : Azure SQL Database Azure SQL Managed Instance

Dans ce guide de démarrage rapide, vous allez utiliser le langage de programmation Golang pour vous connecter à une base de données dans Azure SQL Database ou Azure SQL Managed Instance avec le pilote go-mssqldb. Cet exemple interroge et modifie les données à l’aide d’instructions Transact-SQL (T-SQL) explicites. Golang est un langage de programmation open source qui permet de créer facilement des logiciels simples, fiables et efficaces.

Prérequis

Pour effectuer ce démarrage rapide, les éléments suivants sont requis :

Obtenir les informations de connexion du serveur

Obtenez les informations de connexion dont vous avez besoin pour vous connecter à la base de données. Vous aurez besoin du nom complet du serveur ou de l’hôte, du nom de la base de données et des informations de connexion pour les procédures suivantes.

  1. Connectez-vous au portail Azure.

  2. Accédez à la page Bases de données SQL ou Instances managées SQL.

  3. Dans la page Vue d’ensemble, vérifiez le nom de serveur complet à côté de Nom de serveur pour une base de données dans Azure SQL Database, ou le nom de serveur complet (ou l’adresse IP) à côté de Hôte pour une instance managée Azure SQL ou un serveur SQL sur une machine virtuelle Azure. Pour copier le nom du serveur ou de l’hôte, pointez dessus et sélectionnez l’icône Copier.

Notes

Pour obtenir les informations de connexion de SQL Server sur une machine virtuelle Azure, consultez Se connecter à une instance SQL Server.

Créer un dossier pour le projet Golang et les dépendances

  1. À partir du terminal, créez un nouveau dossier de projet nommé SqlServerSample.

    mkdir SqlServerSample

Créer des exemples de données

  1. Dans l’éditeur de texte, créez un nouveau fichier texte appelé CreateTestData.sql dans le dossier SqlServerSample. Dans le fichier, collez ce code T-SQL, qui crée un schéma et une table, et y insère quelques lignes.

    CREATE SCHEMA TestSchema;
GO

CREATE TABLE TestSchema.Employees (
    Id INT IDENTITY(1, 1) NOT NULL PRIMARY KEY,
    Name NVARCHAR(50),
    Location NVARCHAR(50)
);
GO

INSERT INTO TestSchema.Employees (Name, Location)
VALUES (N'Jared', N'Australia'),
    (N'Nikita', N'India'),
    (N'Astrid', N'Germany');
GO

SELECT * FROM TestSchema.Employees;
GO

  2. À l’invite de commandes, cliquez sur SqlServerSample et utilisez sqlcmd pour vous connecter à la base de données et exécuter le script Azure SQL que vous venez de créer. Insérez les valeurs correspondant à votre serveur et à votre base de données.

    az login
sqlcmd -S <your_server>.database.windows.net -G -d <your_database> -i ./CreateTestData.sql

Ajouter du code pour interroger la base de données

  1. Dans le dossier sample.go, créez un fichier nommé SqlServerSample.

  2. Collez ce code dans le fichier. Ajoutez les valeurs de votre serveur et de votre base de données. Cet exemple utilise les méthodes de contexte de Golang pour vérifier l’existence d’une connexion active.

    package main

import (
    "github.com/microsoft/go-mssqldb/azuread"
    "database/sql"
    "context"
    "log"
    "fmt"
    "errors"
)

var db *sql.DB

var server = "<your_server.database.windows.net>"
var port = 1433
var database = "<your_database>"

func main() {
    // Build connection string
    connString := fmt.Sprintf("server=%s;port=%d;database=%s;fedauth=ActiveDirectoryDefault;", server, port, database)

    var err error

    // Create connection pool
        db, err = sql.Open(azuread.DriverName, connString)
    if err != nil {
        log.Fatal("Error creating connection pool: ", err.Error())
    }
    ctx := context.Background()
    err = db.PingContext(ctx)
    if err != nil {
        log.Fatal(err.Error())
    }
    fmt.Printf("Connected!\n")

    // Create employee
    createID, err := CreateEmployee("Jake", "United States")
    if err != nil {
        log.Fatal("Error creating Employee: ", err.Error())
    }
    fmt.Printf("Inserted ID: %d successfully.\n", createID)

    // Read employees
    count, err := ReadEmployees()
    if err != nil {
        log.Fatal("Error reading Employees: ", err.Error())
    }
    fmt.Printf("Read %d row(s) successfully.\n", count)

    // Update from database
    updatedRows, err := UpdateEmployee("Jake", "Poland")
    if err != nil {
        log.Fatal("Error updating Employee: ", err.Error())
    }
    fmt.Printf("Updated %d row(s) successfully.\n", updatedRows)

    // Delete from database
    deletedRows, err := DeleteEmployee("Jake")
    if err != nil {
        log.Fatal("Error deleting Employee: ", err.Error())
    }
    fmt.Printf("Deleted %d row(s) successfully.\n", deletedRows)
}

// CreateEmployee inserts an employee record
func CreateEmployee(name string, location string) (int64, error) {
    ctx := context.Background()
    var err error

    if db == nil {
        err = errors.New("CreateEmployee: db is null")
        return -1, err
    }

    // Check if database is alive.
    err = db.PingContext(ctx)
    if err != nil {
        return -1, err
    }

    tsql := `
      INSERT INTO TestSchema.Employees (Name, Location) VALUES (@Name, @Location);
      select isNull(SCOPE_IDENTITY(), -1);
    `

    stmt, err := db.Prepare(tsql)
    if err != nil {
       return -1, err
    }
    defer stmt.Close()

    row := stmt.QueryRowContext(
        ctx,
        sql.Named("Name", name),
        sql.Named("Location", location))
    var newID int64
    err = row.Scan(&newID)
    if err != nil {
        return -1, err
    }

    return newID, nil
}

// ReadEmployees reads all employee records
func ReadEmployees() (int, error) {
    ctx := context.Background()

    // Check if database is alive.
    err := db.PingContext(ctx)
    if err != nil {
        return -1, err
    }

    tsql := fmt.Sprintf("SELECT Id, Name, Location FROM TestSchema.Employees;")

    // Execute query
    rows, err := db.QueryContext(ctx, tsql)
    if err != nil {
        return -1, err
    }

    defer rows.Close()

    var count int

    // Iterate through the result set.
    for rows.Next() {
        var name, location string
        var id int

        // Get values from row.
        err := rows.Scan(&id, &name, &location)
        if err != nil {
            return -1, err
        }

        fmt.Printf("ID: %d, Name: %s, Location: %s\n", id, name, location)
        count++
    }

    return count, nil
}

// UpdateEmployee updates an employee's information
func UpdateEmployee(name string, location string) (int64, error) {
    ctx := context.Background()

    // Check if database is alive.
    err := db.PingContext(ctx)
    if err != nil {
        return -1, err
    }

    tsql := fmt.Sprintf("UPDATE TestSchema.Employees SET Location = @Location WHERE Name = @Name")

    // Execute non-query with named parameters
    result, err := db.ExecContext(
        ctx,
        tsql,
        sql.Named("Location", location),
        sql.Named("Name", name))
    if err != nil {
        return -1, err
    }

    return result.RowsAffected()
}

// DeleteEmployee deletes an employee from the database
func DeleteEmployee(name string) (int64, error) {
    ctx := context.Background()

    // Check if database is alive.
    err := db.PingContext(ctx)
    if err != nil {
        return -1, err
    }

    tsql := fmt.Sprintf("DELETE FROM TestSchema.Employees WHERE Name = @Name;")

    // Execute non-query with named parameters
    result, err := db.ExecContext(ctx, tsql, sql.Named("Name", name))
    if err != nil {
        return -1, err
    }

    return result.RowsAffected()
}

Obtenir les dépendances du projet Golang et exécuter le code

  1. À l’invite de commandes, accédez à SqlServerSample et installez le pilote SQL Server pour Go en exécutant les commandes suivantes.

    go mod init SqlServerSample
go mod tidy

  2. Exécutez ensuite la commande suivante dans l’invite de commandes.

    az login
go run sample.go

  3. Vérifiez la sortie.

    Connected!
Inserted ID: 4 successfully.
ID: 1, Name: Jared, Location: Australia
ID: 2, Name: Nikita, Location: India
ID: 3, Name: Astrid, Location: Germany
ID: 4, Name: Jake, Location: United States
Read 4 row(s) successfully.
Updated 1 row(s) successfully.
Deleted 1 row(s) successfully.

Contenu connexe