Hızlı Başlangıç: Azure SQL Veritabanı veya Azure Yönetilen Örneği'SQL Golang kullanma

  • Makale
  • Okumak için 5 dakika

Uygulama hedefi: Azure SQL Veritabanı Azure SQL yönetilen örneği

Bu hızlı başlangıçta Golang programlama dilini kullanarak Azure SQL Veritabanı veya Azure SQL Yönetilen Örneği'ne bağlanabilirsiniz. Ardından Transact-SQL deyimlerini çalıştırarak verileri sorgular ve değiştirirsiniz. Golang basit, güvenilir ve verimli yazılımlar derlemeyi kolaylaştıran açık kaynak bir programlama dilidir.

Önkoşullar

Bu hızlı başlangıcı tamamlamak için aşağıdakilere ihtiyacınız vardır:

Sunucu bağlantı bilgilerini al

Veritabanına bağlanmak için ihtiyacınız olan bağlantı bilgilerini alır. Gelecek yordamlar için tam sunucu adına veya ana bilgisayar adına, veritabanı adına ve oturum açma bilgilerine ihtiyacınız olacak.

  1. Azure Portal oturum açın.

  2. SQL Veritabanları veya Yönetilen SQL sayfasına gidin.

  3. Genel Bakış sayfasında, Azure SQL Veritabanı'deki bir veritabanı için Sunucu adı'nın yanındaki tam sunucu adını veya Azure SQL Yönetilen Örneği için konak veya Azure VM'de SQL Server'nin yanındaki tam sunucu adını (veya IP adresini) gözden geçirebilirsiniz. Sunucu adını veya ana bilgisayar adını kopyalamak için üzerine gelin ve Kopyala simgesini seçin.

Not

Azure VM'sinde SQL Server bağlantı bilgileri için bkz. Bağlan bir SQL Server örneğine.

Golang projesi ve bağımlılıkları oluşturma

  1. Terminalden, SqlServerSample adlı yeni bir proje klasörü oluşturun.

    mkdir SqlServerSample

  2. SqlServerSample'a gidin ve Go için SQL Server sürücüsünü yükleyin.

    cd SqlServerSample
go get github.com/denisenkom/go-mssqldb

Örnek veri oluşturma

  1. Bir metin düzenleyicisinde SqlServerSample klasöründe CreateTestData.sql adlı bir dosya oluşturun. dosyasına bu T-SQL kodunu yapıştırın. Bu kod bir şema, tablo oluşturur ve birkaç satır ekler.

    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'Tom',    N'Germany');
GO

SELECT * FROM TestSchema.Employees;
GO

  2. Veritabanına sqlcmd bağlanmak ve yeni oluşturduğunuz Azure depolama betiğinizi SQL kullanın. Sunucunuz, veritabanınız, kullanıcı adınız ve parolanız için uygun değerleri değiştirin.

    sqlcmd -S <your_server>.database.windows.net -U <your_username> -P <your_password> -d <your_database> -i ./CreateTestData.sql

Veritabanını sorgulamak için kod ekleme

  1. SqlServerSample klasöründe sample.go adlı bir dosya oluşturun.

  2. dosyasına bu kodu yapıştırın. Sunucunuz, veritabanınız, kullanıcı adınız ve parolanız için değerleri ekleyin. Bu örnek, etkin bir bağlantı olduğundan emin olmak için Golang bağlam yöntemlerini kullanır.

    package main

import (
    _ "github.com/denisenkom/go-mssqldb"
    "database/sql"
    "context"
    "log"
    "fmt"
    "errors"
)

var db *sql.DB

var server = "<your_server.database.windows.net>"
var port = 1433
var user = "<your_username>"
var password = "<your_password>"
var database = "<your_database>"

func main() {
    // Build connection string
    connString := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%d;database=%s;",
        server, user, password, port, database)

    var err error

    // Create connection pool
    db, err = sql.Open("sqlserver", 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()
}

Kodu çalıştırma

  1. Komut isteminde aşağıdaki komutu çalıştırın.

    go run sample.go

  2. Çıktıyı doğrulayın.

    Connected!
Inserted ID: 4 successfully.
ID: 1, Name: Jared, Location: Australia
ID: 2, Name: Nikita, Location: India
ID: 3, Name: Tom, Location: Germany
ID: 4, Name: Jake, Location: United States
Read 4 row(s) successfully.
Updated 1 row(s) successfully.
Deleted 1 row(s) successfully.

Sonraki adımlar