Quickstart: Golang gebruiken om een query uit te voeren op een database in Azure SQL Database of Azure SQL Managed Instance

2025-06-17

Van toepassing op:Azure SQL Database Azure SQL Managed Instance

In deze quickstart gebruikt u de programmeertaal Golang om verbinding te maken met een Azure SQL-database of een database in Azure SQL Managed Instance, met het go-mssqldb-stuurprogramma . De voorbeeldquery's bewerken en wijzigen gegevens met expliciete Transact-SQL-instructies (T-SQL). Golang is een opensource-programmeertaal waarmee u eenvoudig eenvoudige, betrouwbare en efficiënte software kunt bouwen.

Vereiste voorwaarden

U hebt het volgende nodig om deze quickstart te voltooien:

Een Azure-account met een actief abonnement. Gratis een account maken

Een Azure SQL-database of een database in Azure SQL Managed Instance. U kunt een van deze quickstarts gebruiken om een database te maken:

SQL Databank	SQL Beheerde Instantie	SQL Server op Azure VM
Creëren
Portaal	Portaal	Portaal
CLI	CLI
PowerShell	PowerShell	PowerShell
Configureren
IP-firewallregel op serverniveau	Verbinding vanuit een VM
	Connectiviteit vanuit de lokale omgeving	Verbinding maken met een SQL Server-exemplaar
Gegevens laden
`AdventureWorks2022` geladen via quickstart	WideWorldImporters herstellen	WideWorldImporters herstellen
	Een `AdventureWorks2022` herstellen of importeren vanuit GitHub	Een `AdventureWorks2022` herstellen of importeren vanuit GitHub

Belangrijk

De scripts in dit artikel worden geschreven om de AdventureWorks2022-database te gebruiken. Met een met SQL beheerd exemplaar moet u de AdventureWorks2022 database importeren in een exemplaardatabase of de scripts in dit artikel wijzigen om de Wide World Importers-database te gebruiken.

Go en gerelateerde software voor uw besturingssysteem zijn geïnstalleerd.
De nieuwste versie van sqlcmd voor uw besturingssysteem geïnstalleerd.
De Azure PowerShell Az-module voor uw besturingssysteem geïnstalleerd.

Serververbindingsgegevens ophalen

Haal de verbindingsgegevens op die u nodig hebt om verbinding te maken met de database. Voor de komende procedures hebt u de volledig gekwalificeerde servernaam of hostnaam, databasenaam en aanmeldingsgegevens nodig.

Meld u aan bij het Azure-portaal.
Ga naar de pagina SQL Databases of SQL Managed Instances.
Controleer op de pagina Overzicht de volledig gekwalificeerde servernaam naast servernaam voor een database in Azure SQL Database of de volledig gekwalificeerde servernaam (of het IP-adres) naast Host voor een Azure SQL Managed Instance of SQL Server op Azure VM. Als u de servernaam of hostnaam wilt kopiëren, plaatst u de muisaanwijzer erop en selecteert u het pictogram Kopiëren.

Opmerking

Zie Verbinding maken met een SQL Server-exemplaarvoor verbindingsgegevens voor SQL Server op azure-VM.

Een nieuwe map maken voor het Golang-project en afhankelijkheden

Maak vanuit de terminal een nieuwe projectmap met de naam SqlServerSample.
```
mkdir SqlServerSample
```

Voorbeeldgegevens maken

Maak in een teksteditor een bestand met de naam CreateTestData.sql in de SqlServerSample map. Plak deze T-SQL-code in het bestand, waarmee een schema, tabel en een paar rijen worden gemaakt.

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

Navigeer in de opdrachtprompt naar SqlServerSample en gebruik sqlcmd om verbinding te maken met de database en voer uw zojuist gemaakte Azure SQL-script uit. Vervang de juiste waarden voor uw server en database.
```
az login
sqlcmd -S <your_server>.database.windows.net -G -d <your_database> -i ./CreateTestData.sql
```

Code invoegen om een query uit te voeren op de database

Maak een bestand met de naam sample.go in de SqlServerSample map.

Plak deze code in het bestand. Voeg de waarden voor uw server en database toe. In dit voorbeeld worden de Golang-contextmethoden gebruikt om ervoor te zorgen dat er een actieve verbinding is.

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

Golang-projectafhankelijkheden ophalen en de code uitvoeren

Navigeer in de opdrachtprompt naar SqlServerSample en installeer het SQL Server-stuurprogramma voor Go door de volgende opdrachten uit te voeren.
```
go mod init SqlServerSample
go mod tidy
```
Voer bij de opdrachtprompt de volgende opdracht uit.
```
az login
go run sample.go
```

Controleer de uitvoer.

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.

Feedback

Is deze pagina nuttig?