다음을 통해 공유


빠른 시작: Golang을 사용하여 Azure SQL Database 또는 Azure SQL Managed Instance에서 데이터베이스 쿼리

적용 대상: Azure SQL 데이터베이스 Azure SQL Managed Instance

이 빠른 시작에서는 Golang 프로그래밍 언어를 사용하여 Azure SQL Database 연결하는 방법 또는 go-mssqldb 드라이버를 사용하여 Azure SQL Managed Instance의 데이터베이스에 연결하는 법을 안내합니다. 이 샘플은 명시적 Transact-SQL 문을 사용하여 데이터를 쿼리하고 수정합니다. Golang은 간단하고, 신뢰할 수 있으며, 효율적인 소프트웨어를 쉽게 빌드할 수 있는 오픈 소스 프로그래밍 언어입니다.

필수 조건

이 빠른 시작을 완료하려면 다음이 필요합니다.

서버 연결 정보 가져오기

데이터베이스에 연결하는 데 필요한 연결 정보를 가져옵니다. 다음 절차를 수행하려면 정규화된 서버 이름이나 호스트 이름, 데이터베이스 이름 및 로그인 정보가 필요합니다.

  1. Azure Portal에 로그인합니다.

  2. SQL Databases 또는 SQL Managed Instances 페이지로 이동합니다.

  3. 개요 페이지에서 Azure SQL Database의 데이터베이스에 대한 서버 이름 옆에 있는 정규화된 서버 이름 또는 Azure VM의 Azure SQL Managed Instance 또는 SQL Server에 대한 호스트 옆에 있는 정규화된 서버 이름(또는 IP 주소)을 검토합니다. 서버 이름이나 호스트 이름을 복사하려면 마우스로 해당 이름 위를 가리키고 복사 아이콘을 선택합니다.

참고

Azure VM의 SQL Server에 대한 연결 정보는 SQL Server 인스턴스에 연결을 참조하세요.

Golang 프로젝트와 종속성에 사용할 새 폴더와 Go 파일 만들기

  1. 터미널에서 SqlServerSample(이)라는 새 프로젝트 폴더를 만듭니다.

    mkdir SqlServerSample
    

샘플 데이터 만들기

  1. 텍스트 편지기에서 SqlServerSample 폴더 안에 CreateTestData.sql(이)라는 파일을 만듭니다. 파일에서 스키마와 테이블을 만들는 T-SQL 코드를 복사하여 붙여넣고 행 몇 개를 삽입합니다.

    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. 명령 프롬프트에서 SqlServerSample(으)로 이동하여 sqlcmd(을)를 사용하여 데이터베이스에 연결하고 새로 만든 Azure SQL 스크립트를 실행합니다. 서버와 데이터베이스를 적절한 값으로 바꿉니다.

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

데이터베이스를 쿼리하는 코드 추가

  1. SqlServerSample 폴더에서 sample.go(이)라는 새 파일을 만듭니다.

  2. 다음 코드를 파일에 붙여넣습니다. 서버 및 데이터베이스에 대한 값을 추가합니다. 이 예제에서는 Golang 컨텍스트 메서드를 사용하여 활성 연결이 있는지 확인합니다.

    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 프로젝트 종속성 가져오기 및 코드 실행

  1. 명령 프롬프트에서 SqlServerSample(으)로 이동한 다음, 다음 명령을 실행하여 Go용 SQL Server 드라이버를 설치합니다.

    go mod init SqlServerSample
    go mod tidy
    
  2. 명령 프롬프트에서 다음 명령을 실행합니다.

    az login
    go run sample.go
    
  3. 출력 확인

    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.