Guia de início rápido: use o Golang para consultar um banco de dados no Banco de Dados SQL do Azure ou na Instância Gerenciada SQL do Azure

2025-06-13

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

Neste guia rápido, tu usarás a linguagem de programação Golang para te conectar a um banco de dados SQL do Azure ou a um banco de dados na Instância Gerida SQL do Azure com o driver go-mssqldb. O exemplo consulta e modifica dados com instruções Transact-SQL explícitas (T-SQL). Golang é uma linguagem de programação de código aberto que facilita a construção de software simples, confiável e eficiente.

Pré-requisitos

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

Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.

Um banco de dados SQL do Azure ou um banco de dados na Instância Gerenciada SQL do Azure. Você pode usar um destes guias de início rápido para criar um banco de dados:

Banco de dados SQL	Instância Gerida do SQL	SQL Server na VM do Azure
Criar
Portais	Portais	Portais
CLI	CLI
PowerShell	PowerShell	PowerShell
Configurar
Regra de firewall IP no nível do servidor	Conectividade de uma VM
	Conectividade a partir de instalações no local	conectar-se a uma instância do SQL Server
Carregar dados
`AdventureWorks2022` carregado por arranque rápido	Restaurar WideWorldImporters	Restaurar WideWorldImporters
	Restaure ou importe `AdventureWorks2022` de um arquivo BACPAC do GitHub	Restaure ou importe `AdventureWorks2022` de um arquivo BACPAC do GitHub

Importante

Os scripts neste artigo são escritos para usar o banco de dados AdventureWorks2022. Com uma instância gerenciada SQL, deve-se importar o banco de dados AdventureWorks2022 para um banco de dados de instância ou modificar os scripts neste artigo para usar o banco de dados Wide World Importers.

Go e software relacionado instalado no seu sistema operativo.
A versão mais recente do sqlcmd para o seu sistema operacional instalado.
O módulo Az do Azure PowerShell instalado para o seu sistema operativo.

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 do servidor ou nome do host totalmente qualificado, nome do banco de dados e informações de login para os próximos procedimentos.

Inicie sessão no portal Azure.
Navegue para a página Bancos de Dados SQL ou Instâncias SQL Geridas.
Na página Visão Geral do, revise o nome do servidor totalmente qualificado ao lado de Nome do servidor para 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 uma Instância Gerenciada SQL do Azure ou SQL Server na VM do Azure. Para copiar o nome do servidor ou do host, passe o mouse sobre ele e selecione o ícone Copiar.

Observação

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

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

A partir do terminal, crie uma nova pasta de projeto chamada SqlServerSample.
```
mkdir SqlServerSample
```

Criar dados de exemplo

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, 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

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 o servidor e o 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

Crie um arquivo chamado sample.go na pasta SqlServerSample.

No ficheiro, cole este código. Adicione os valores para o servidor e o banco de dados. Este exemplo usa os métodos de contexto Golang para garantir que haja 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 Golang e executar o código

No prompt de comando, navegue até SqlServerSample e instale o driver do SQL Server para Go executando os seguintes comandos.
```
go mod init SqlServerSample
go mod tidy
```
No prompt de comando, execute o seguinte comando.
```
az login
go run sample.go
```

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.

Comentários

Esta página foi útil?