Dela via

Snabbstart: Använda Golang för att fråga en databas i Azure SQL Database eller Azure SQL Managed Instance

  • Artikel

gäller för:Azure SQL DatabaseAzure SQL Managed Instance

I den här snabbstarten använder du programmeringsspråket Golang för att ansluta till en Azure SQL-databas eller en databas i Azure SQL Managed Instance med go-mssqldb- drivrutin. Exemplet frågar och ändrar data med explicita Transact-SQL-instruktioner (T-SQL). Golang är ett programmeringsspråk med öppen källkod som gör det enkelt att skapa enkel, tillförlitlig och effektiv programvara.

Förutsättningar

För att slutföra den här snabbstarten behöver du:

Hämta serveranslutningsinformation

Hämta den anslutningsinformation som du behöver för att ansluta till databasen. Du behöver det fullständigt kvalificerade servernamnet eller värdnamnet, databasnamnet och inloggningsinformationen för de kommande procedurerna.

  1. Logga in på Azure-portalen.

  2. Gå till sidan SQL Databases eller SQL Managed Instances.

  3. På sidan Översikt granskar du det fullständigt kvalificerade servernamnet bredvid Servernamn för en databas i Azure SQL Database eller det fullständigt kvalificerade servernamnet (eller IP-adressen) bredvid Värd för en Hanterad Azure SQL-instans eller SQL Server på en virtuell Azure-dator. Om du vill kopiera servernamnet eller värdnamnet hovra över det och välj ikonen Kopiera.

Anmärkning

Anslutningsinformation för SQL Server på en virtuell Azure-dator finns i Ansluta till en SQL Server-instans.

Skapa en ny mapp för Golang-projektet och beroenden

  1. Från terminalen skapar du en ny projektmapp med namnet SqlServerSample.

    mkdir SqlServerSample

Skapa exempeldata

  1. I en textredigerare skapar du en fil med namnet CreateTestData.sql i mappen SqlServerSample. I filen klistrar du in den här T-SQL-koden, som skapar ett schema, en tabell och infogar några rader.

    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. I kommandotolken går du till SqlServerSample och använder sqlcmd för att ansluta till databasen och kör ditt nyligen skapade Azure SQL-skript. Ersätt lämpliga värden för servern och databasen.

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

Infoga kod för att fråga databasen

  1. Skapa en fil med namnet sample.go i mappen SqlServerSample.

  2. Klistra in den här koden i filen. Lägg till värdena för servern och databasen. I det här exemplet används golang-kontextmetoder för att kontrollera att det finns en aktiv anslutning.

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

Hämta Golang-projektberoenden och kör koden

  1. I kommandotolken går du till SqlServerSample och installerar SQL Server-drivrutinen för Go genom att köra följande kommandon.

    go mod init SqlServerSample
go mod tidy

  2. Kör följande kommando i kommandotolken.

    az login
go run sample.go

  3. Kontrollera utdata.

    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.

Relaterat innehåll