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

A következőkre vonatkozik:Azure SQL DatabaseAzure SQL Managed Instance

Ebben a rövid útmutatóban a Golang programozási nyelvet fogja használni egy Azure SQL-adatbázishoz vagy egy felügyelt Azure SQL-példányhoz való csatlakozáshoz a go-mssqldb illesztőprogrammal. A minta explicit Transact-SQL (T-SQL) utasításokkal lekérdezi és módosítja az adatokat. 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ó befejezéséhez ezek szükségesek:

Kiszolgáló kapcsolati adatainak lekérése

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

  1. Jelentkezzen be a Azure portalra.

  2. Lépjen a SQL adatbázisok vagy a SQL kezelt példányok oldalára.

  3. Az Áttekintés lapon tekintse át az Azure SQL Database adatbázisa esetén a kiszolgálónév mellett található teljes kiszolgálónevet. Az Azure SQL Managed Instance vagy az Azure virtuális gépen futó SQL Server esetén a Gazda mellett található teljes kiszolgálónevet (vagy IP-címet) ellenőrizze. A kiszolgáló vagy a gazdagép nevének másolásához vigye az egérmutatót a név fölé, és válassza a Másolás ikont.

Megjegyzés

Az Azure-beli virtuális gépen futó SQL Server kapcsolati információi: Csatlakozás SQL Server-példányhoz.

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

  1. A terminálból hozzon létre egy új, SqlServerSamplenevű projektmappát.

    mkdir SqlServerSample

Mintaadatok létrehozása

  1. Egy szövegszerkesztőben hozzon létre egy CreateTestData.sql nevű fájlt a SqlServerSample mappában. 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 lépjen be a SqlServerSample mappába, és a sqlcmd használatával csatlakozzon az adatbázishoz, majd 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 sample.go nevű fájlt 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 konteksztus metódusait használja azért, hogy biztosítva legyen az aktív kapcsolat.

    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 a 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

  • Last updated on