Freigeben über

Schnellstart: Abfragen einer Datenbank in Azure SQL-Datenbank oder Azure SQL Managed Instance mithilfe von Golang

  • Artikel

Gilt für: Azure SQL-Datenbank Azure SQL Managed Instance

In dieser Schnellstartanleitung verwenden Sie die Programmiersprache Golang, um eine Verbindung mit einer Azure SQL-Datenbank oder einer Datenbank in Azure SQL Managed Instance mit go-mssqldb herzustellen. Im Beispiel werden Daten mithilfe von expliziten Transact-SQL-Anweisungen (T-SQL) abgefragt und geändert. Golang ist eine Open-Source-Programmiersprache zur einfachen Erstellung von unkomplizierter, zuverlässiger und effizienter Software.

Voraussetzungen

Für die Durchführung dieses Schnellstarts benötigen Sie Folgendes:

Ermitteln von Serververbindungsinformationen

Ermitteln Sie die Verbindungsinformationen, die Sie zum Herstellen einer Verbindung mit der Datenbank benötigen. In den weiteren Verfahren benötigen Sie den vollqualifizierten Server- oder Hostnamen, den Datenbanknamen und die Anmeldeinformationen.

  1. Melden Sie sich beim Azure-Portal an.

  2. Navigieren Sie zur Seite SQL-Datenbanken oder Verwaltete SQL-Instanzen.

  3. Auf der Seite Übersicht finden Sie den vollqualifizierten Servernamen für eine Datenbank in Azure SQL-Datenbank neben Servername oder den vollqualifizierten Servernamen (oder die IP-Adresse) für Azure SQL Managed Instance bzw. für SQL Server auf einem virtuellen Azure-Computer neben Host. Um den Namen des Servers oder Hosts zu kopieren, zeigen Sie darauf, und wählen Sie das Symbol Kopieren aus.

Hinweis

Verbindungsinformationen für SQL Server auf einem virtuellen Azure-Computer finden Sie unter Herstellen einer Verbindung mit einer SQL Server-Instanz.

Erstellen eines neuen Ordners für das Golang-Projekt und Abhängigkeiten

  1. Erstellen Sie über das Terminal einen neuen Projektordner mit dem Namen SqlServerSample.

    mkdir SqlServerSample

Erstellen von Beispieldaten

  1. Erstellen Sie in einem Text-Editor eine Datei mit dem Namen CreateTestData.sql im Ordner SqlServerSample. Fügen Sie diesen T-SQL-Code in die Datei ein. Hiermit werden ein Schema und eine Tabelle erstellt und einige Zeilen eingefügt.

    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. Navigieren Sie an der Eingabeaufforderung zu SqlServerSample, und verwenden sqlcmd, um eine Verbindung mit der Datenbank herzustellen und Ihr neu erstelltes Azure SQL-Skript auszuführen. Setzen Sie dabei die entsprechenden Werte für Server und Datenbank ein.

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

Einfügen von Code zum Abfragen der Datenbank

  1. Erstellen Sie im Ordner SqlServerSample eine Datei mit dem Namen sample.go.

  2. Fügen Sie diesen Code in der Datei ein. Fügen Sie die Werte für Server und Datenbank hinzu. In diesem Beispiel werden die Golang-Kontextmethoden verwendet, um sicherzustellen, dass eine aktive Verbindung besteht.

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

Abrufen von Golang-Projektabhängigkeiten und Ausführen des Codes

  1. Navigieren Sie an der Eingabeaufforderung zu SqlServerSample, und installieren Sie den SQL Server-Treiber für Go, indem Sie die folgenden Befehle ausführen.

    go mod init SqlServerSample
go mod tidy

  2. Führen Sie an der Eingabeaufforderung den folgenden Befehl aus.

    az login
go run sample.go

  3. Überprüfen Sie die Ausgabe.

    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.

Zugehöriger Inhalt