Aracılığıyla paylaş


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

Şunlar için geçerlidir: Azure SQL Veritabanı Azure SQL Yönetilen Örneği

Bu hızlı başlangıçta go-mssqldb sürücüsüyle bir Azure SQL veritabanına veya Azure SQL Yönetilen Örneği'daki bir veritabanına bağlanmak için Golang programlama dilini kullanacaksınız. Örnek, açık Transact-SQL (T-SQL) deyimleriyle verileri sorgular ve değiştirir. Golang basit, güvenilir ve verimli yazılım oluşturmayı kolaylaştıran açık kaynaklı bir programlama dilidir.

Önkoşullar

Bu hızlı başlangıcı tamamlamak için şunlar gerekir:

Sunucu bağlantı bilgilerini alma

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

  1. Azure Portal’ında oturum açın.

  2. SQL Veritabanı veya SQL Yönetilen Örneği s sayfasına gidin.

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

Not

Azure VM'de SQL Server ile ilgili bağlantı bilgileri için bkz . SQL Server örneğine bağlanma.

Golang projesi ve bağımlılıkları için yeni bir klasör oluşturma

  1. Terminalden adlı SqlServerSampleyeni bir proje klasörü oluşturun.

    mkdir SqlServerSample
    

Örnek veri oluşturma

  1. Metin düzenleyicisinde klasöründe adlı CreateTestData.sql SqlServerSample bir dosya oluşturun. Dosyaya, bir şema, tablo oluşturan ve birkaç satır ekleyen bu T-SQL kodunu yapıştırın.

    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. Komut isteminde veritabanına bağlanmak ve yeni oluşturduğunuz Azure SQL betiğini çalıştırmak için adresine gidin SqlServerSample ve komutunu kullanın sqlcmd . Sunucunuz ve veritabanınız için uygun değerleri değiştirin.

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

Veritabanını sorgulamak için kod ekleme

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

  2. Dosyasına bu kodu yapıştırın. Sunucunuz ve veritabanını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/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 proje bağımlılıklarını alma ve kodu çalıştırma

  1. Komut isteminde, aşağıdaki komutları çalıştırarak Go için SQL Server sürücüsüne SqlServerSample gidin ve yükleyin.

    go mod init SqlServerSample
    go mod tidy
    
  2. Komut isteminde aşağıdaki komutu çalıştırın.

    az login
    go run sample.go
    
  3. Çı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: 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.