Udostępnij za pośrednictwem

Szybki start: wykonywanie zapytań względem bazy danych w usłudze Azure SQL Database lub Azure SQL Managed Instance przy użyciu języka Golang

Dotyczy:Azure SQL DatabaseAzure SQL Managed Instance

W tym szybkim starcie wykorzystasz język Golang, aby połączyć się z bazą danych Azure SQL lub bazą danych w usłudze Azure SQL Managed Instance za pomocą sterownika go-mssqldb. Przykładowe zapytania modyfikują dane za pomocą instrukcji jawnych Języka Transact-SQL (T-SQL). Golang jest językiem programowania typu „open source”, który umożliwia łatwe tworzenie prostego, niezawodnego i wydajnego oprogramowania.

Wymagania wstępne

Aby ukończyć ten przewodnik Szybki Start, musisz spełnić następujące warunki:

Uzyskiwanie informacji o połączeniu z serwerem

Uzyskaj informacje o połączeniu potrzebne do podłączenia się do bazy danych. W następnych procedurach będą potrzebne w pełni kwalifikowana nazwa serwera lub nazwa hosta, nazwa bazy danych i informacje logowania.

  1. Zaloguj się w witrynie Azure Portal.

  2. Przejdź do strony Bazy danych SQL lub Zarządzane wystąpienia SQL.

  3. Na stronie Przegląd sprawdź w pełni kwalifikowaną nazwę serwera znajdującą się obok Server name w bazie danych Azure SQL Database lub w pełni kwalifikowaną nazwę serwera (lub adres IP) obok Host dla Azure SQL Managed Instance lub SQL Server na maszynie wirtualnej Azure. Aby skopiować nazwę serwera lub hosta, umieść na niej wskaźnik myszy i wybierz ikonę Kopiuj.

Uwaga

Aby uzyskać informacje o połączeniu dla programu SQL Server na maszynie wirtualnej platformy Azure, zobacz Nawiązywanie połączenia z wystąpieniem programu SQL Server.

Tworzenie nowego folderu dla projektu Golang i zależności

  1. W terminalu utwórz nowy folder projektu o nazwie SqlServerSample.

    mkdir SqlServerSample

Tworzenie danych przykładowych

  1. W edytorze tekstów utwórz plik o nazwie CreateTestData.sql w folderze SqlServerSample . W pliku wklej poniższy kod T-SQL, który tworzy schemat oraz tabelę i wstawia kilka wierszy.

    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. W wierszu polecenia przejdź do SqlServerSample i użyj sqlcmd, aby nawiązać połączenie z bazą danych i uruchomić nowo utworzony skrypt usługi Azure SQL. Zastąp odpowiednie wartości dla serwera i bazy danych.

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

Wstawianie kodu w celu wykonywania zapytań względem bazy danych

  1. Utwórz plik o nazwie sample.go w folderze SqlServerSample .

  2. Wklej ten kod w pliku. Dodaj wartości dla serwera i bazy danych. W tym przykładzie użyto metod kontekstowych języka Golang, aby upewnić się, że istnieje aktywne połączenie.

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

Pobieranie zależności projektu Golang i uruchamianie kodu

  1. W wierszu polecenia przejdź do SqlServerSample i zainstaluj sterownik programu SQL Server dla języka Go, uruchamiając następujące polecenia.

    go mod init SqlServerSample
go mod tidy

  2. W wierszu polecenia uruchom następujące polecenie.

    az login
go run sample.go

  3. Sprawdź dane wyjściowe.

    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.

Powiązana zawartość

  • Last updated on