Megosztás a következőn keresztül:

Rövid útmutató: Adatbázis lekérdezése a Golang használatával az Azure SQL Database-ben vagy a felügyelt Azure SQL-példányban

  • Cikk

A következőre vonatkozik: Azure SQL DatabaseFelügyelt Azure SQL-példány

Ebben a rövid útmutatóban a Golang programozási nyelv használatával fog csatlakozni egy Azure SQL-adatbázishoz vagy egy felügyelt Azure SQL-példányhoz a go-mssqldb illesztőprogrammal. A minta lekérdezi és módosítja az adatokat explicit Transact-SQL (T-SQL) utasításokkal. A Golang egy nyílt forráskódú programozási nyelv, amely megkönnyíti az egyszerű, megbízható és hatékony szoftverek készítését.

Előfeltételek

A rövid útmutató elvégzéséhez a következőkre lesz szüksége:

Kiszolgáló kapcsolati adatainak lekérése

Szerezze be az adatbázishoz való csatlakozáshoz szükséges kapcsolati adatokat. A közelgő eljárásokhoz szüksége lesz a teljes kiszolgálónévre vagy állomásnévre, adatbázisnévre és bejelentkezési adatokra.

  1. Jelentkezzen be az Azure Portalra.

  2. Lépjen az SQL Databases vagy a felügyelt SQL-példányok lapra.

  3. Az Áttekintés lapon tekintse át az Azure SQL Database-beli adatbázis Kiszolgáló neve melletti teljes kiszolgálónevet, vagy a gazdagép melletti teljes kiszolgálónevet (vagy IP-címet) egy Felügyelt Azure SQL-példányhoz vagy azure-beli virtuális gépen futó SQL Serverhez. A kiszolgáló vagy a gazdagép nevének másolásához mutasson rá, és válassza a Másolás ikont.

Megjegyzés:

Az Azure-beli virtuális gépeken futó SQL Server kapcsolati információiért tekintse meg az SQL Server-példányokra vonatkozó Csatlakozás.

Új mappa létrehozása a Golang-projekthez és a függőségekhez

  1. A terminálból hozzon létre egy új, .SqlServerSample

    mkdir SqlServerSample

Mintaadatok létrehozása

  1. Egy szövegszerkesztőben hozzon létre egy fájlt, amelyet a SqlServerSample mappában hív CreateTestData.sql meg. A fájlba illessze be ezt a T-SQL-kódot, amely létrehoz egy sémát, táblázatot, és beszúr néhány sort.

    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. A parancssorban keresse meg SqlServerSample és használja sqlcmd az adatbázishoz való csatlakozáshoz, és futtassa az újonnan létrehozott Azure SQL-szkriptet. Cserélje le a kiszolgáló és az adatbázis megfelelő értékeit.

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

Kód beszúrása az adatbázis lekérdezéséhez

  1. Hozzon létre egy fájlt sample.go a SqlServerSample mappában.

  2. Illessze be ezt a kódot a fájlba. Adja hozzá a kiszolgáló és az adatbázis értékeit. Ez a példa a Golang környezeti metódusokat használja annak biztosításához, hogy aktív kapcsolat legyen.

    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-projektfüggőségek lekérése és a kód futtatása

  1. A parancssorban keresse meg SqlServerSample és telepítse a Go SQL Server-illesztőprogramot az alábbi parancsok futtatásával.

    go mod init SqlServerSample
go mod tidy

  2. A parancssorban futtassa a következő parancsot.

    az login
go run sample.go

  3. Ellenőrizze a kimenetet.

    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.

Kapcsolódó tartalom