Início Rápido: Usar o Golang para consultar um banco de dados no Banco de Dados SQL do Azure ou na Instância Gerenciada de SQL do Azure

  • Artigo

Aplica-se a:Banco de Dados SQL do AzureInstância Gerenciada de SQL do Azure

Neste guia de início rápido, você usará a linguagem de programação Golang para se conectar a um Banco de Dados SQL do Azure ou um banco de dados na Instância Gerenciada de SQL do Azure com o driver go-mssqldb. O exemplo consulta e modifica dados com instruções Transact-SQL (T-SQL) explícitas. O Golang é uma linguagem de programação de software livre que facilita a criação de softwares simples, confiáveis e eficientes.

Pré-requisitos

Para concluir este início rápido, você precisa de:

Obter informações de conexão do servidor

Obtenha as informações de conexão necessárias para se conectar ao banco de dados. Você precisará do nome totalmente qualificado do servidor ou do host, do nome do banco de dados e das informações de logon nos próximos procedimentos.

  1. Entre no portal do Azure.

  2. Navegue até a página Bancos de Dados SQL ou Instâncias Gerenciadas de SQL.

  3. Na página Visão geral, examine o nome do servidor totalmente qualificado ao lado de Nome do servidor para obter um banco de dados no Banco de Dados SQL do Azure ou o nome do servidor totalmente qualificado (ou endereço IP) ao lado de Host para obter uma instância gerenciada de SQL do Azure ou um SQL Server na VM do Azure. Para copiar o nome do servidor ou o nome do host, passe o mouse sobre ele e selecione o ícone Copiar.

Observação

Para obter informações de conexão do SQL Server na VM do Azure, confira Conectar-se a uma Instância do SQL Server.

Criar uma nova pasta para o projeto do Golang e suas dependências

  1. No terminal, crie uma nova pasta de projeto chamada SqlServerSample.

    mkdir SqlServerSample

Criar dados de exemplo

  1. Em um editor de texto, crie um arquivo chamado CreateTestData.sql na pasta SqlServerSample. No arquivo, cole esse código T-SQL, que cria um esquema e uma tabela e insere algumas linhas.

    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. No prompt de comando, navegue até SqlServerSample e use sqlcmd para se conectar ao banco de dados e executar seu script SQL do Azure recém-criado. Substitua os valores apropriados para seu servidor e banco de dados.

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

Inserir código para consultar o banco de dados

  1. Crie um arquivo chamado sample.go na pasta SqlServerSample.

  2. No arquivo, cole este código. Adicione os valores para seu servidor e banco de dados. Este exemplo usa os métodos de contexto do Golang para verificar se há uma conexão ativa.

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

Obter dependências do projeto do Golang e executar o código

  1. No prompt de comando, navegue até SqlServerSample e instale o driver do SQL Server para Go executando os comandos a seguir.

    go mod init SqlServerSample
go mod tidy

  2. No prompt de comando, execute o comando a seguir.

    az login
go run sample.go

  3. Verifique a saída.

    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.

Conteúdo relacionado