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ő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.