Rychlý start: Použití jazyka Go k dotazování databáze ve službě Azure SQL Database nebo Azure SQL Managed Instance

  • Článek

Platí pro:Azure SQL DatabaseAzure SQL Managed Instance

V tomto rychlém startu použijete programovací jazyk Go pro připojení k databázi Azure SQL nebo databázi ve službě Azure SQL Managed Instance pomocí ovladače go-mssqldb . Ukázkové dotazy a upraví data explicitními příkazy Jazyka Transact-SQL (T-SQL). Jazyk Go je opensourcový programovací jazyk, který usnadňuje vytváření jednoduchého, spolehlivého a efektivního softwaru.

Požadavky

K dokončení tohoto rychlého startu je potřeba:

Získání informací o připojení k serveru

Získejte informace o připojení, které potřebujete pro připojení k databázi. Pro nadcházející postupy budete potřebovat plně kvalifikovaný název serveru nebo název hostitele, název databáze a přihlašovací údaje.

  1. Přihlaste se k portálu Azure.

  2. Přejděte na stránku SLUŽBY SQL Database nebo SQL Managed Instances .

  3. Na stránce Přehled zkontrolujte plně kvalifikovaný název serveru vedle názvu serveru pro databázi ve službě Azure SQL Database nebo plně kvalifikovaný název serveru (nebo IP adresu) vedle hostitele pro službu Azure SQL Managed Instance nebo SQL Server na virtuálním počítači Azure. Pokud chcete zkopírovat název serveru nebo název hostitele, najeďte myší na něj a vyberte ikonu Kopírovat .

Poznámka:

Informace o připojení k SQL Serveru na virtuálním počítači Azure najdete v tématu Připojení k instanci SQL Serveru.

Vytvoření nové složky pro projekt Golang a závislosti

  1. V terminálu vytvořte novou složku projektu s názvem SqlServerSample.

    mkdir SqlServerSample

Vytvoření ukázkových dat

  1. V textovém editoru vytvořte soubor volaný CreateTestData.sql ve SqlServerSample složce. Do souboru vložte tento kód T-SQL, který vytvoří schéma, tabulku a vloží několik řádků.

    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. Na příkazovém řádku přejděte k SqlServerSample databázi a použijte sqlcmd ji pro připojení k databázi a spusťte nově vytvořený skript Azure SQL. Nahraďte příslušné hodnoty pro váš server a databázi.

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

Vložení kódu pro dotazování databáze

  1. Vytvořte soubor s názvem sample.go ve SqlServerSample složce.

  2. Do souboru vložte tento kód. Přidejte hodnoty pro server a databázi. V tomto příkladu se k zajištění aktivního připojení používá metody kontextu jazyka Go.

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

Získání závislostí projektu Jazyka Go a spuštění kódu

  1. Na příkazovém řádku přejděte na SqlServerSample ovladač SQL Serveru pro Go a nainstalujte ho spuštěním následujících příkazů.

    go mod init SqlServerSample
go mod tidy

  2. Na příkazovém řádku spusťte následující příkaz.

    az login
go run sample.go

  3. Ověřte výstup.

    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.

Související obsah