Szybki start: Połącz się i zapytaj za pomocą go-mssqldb

W tym szybkim starcie łączysz się z bazą danych SQL Server z Go i uruchamiasz zapytanie. Używasz sterownika go-mssqldb ze standardowym pakietem database/sql.

Wymagania wstępne

Do głównego przykładu w tym artykule potrzebujesz:

Jeśli łączysz się z Azure SQL zamiast lokalnej instancji SQL Server, użyj Go-mssqldb z Azure SQL Database do wymagań i konfiguracji specyficznych dla Azure.

Wybieranie punktu początkowego

Główny przykład w tym artykule wykorzystuje lokalną instancję SQL Server na Windows z zintegrowaną uwierzytelnianiem. Użyj wariantów uwierzytelniania SQL lub Microsoft Entra ID w późniejszej części artykułu, jeśli korzystasz z Linuksa lub macOS, albo jeśli łączysz się z Azure SQL.

  • Czytaj dalej ten artykuł, jeśli chcesz skorzystać z najmniejszego kompletnego przykładu dla SQL Server i możesz utworzyć lokalną bazę testową.
  • Jeśli łączysz się za pomocą logowania SQL Server zamiast Windows authentication, kontynuuj ten artykuł i później skorzystaj z wariantu uwierzytelniania SQL.
  • Jeśli łączysz się z Azure SQL Database, Azure SQL Managed Instance lub bazą danych SQL w Fabric, zacznij od Use go-mssqldb with Azure SQL Database. Ten artykuł dotyczy wymagań Azure TLS, limitów połączeń oraz uwierzytelniania bez hasła.
  • Jeśli używasz Microsoft Entra ID, zaimportuj github.com/microsoft/go-mssqldb/azuread i użyj nazwy sterownikaazuresql. Szczegóły dotyczące przepływu danych uwierzytelniających można znaleźć w Microsoft Entra ID authentication.

Tworzenie projektu języka Go

  1. Utwórz i inicjalizuj nowy katalog:

    mkdir go-sql-quickstart
cd go-sql-quickstart
go mod init go-sql-quickstart

  2. Zainstaluj sterownik:

    go get github.com/microsoft/go-mssqldb

Nawiązywanie połączenia i wykonywanie zapytań

Stwórz plik o nazwie main.go z następującym kodem Go:

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"

    _ "github.com/microsoft/go-mssqldb"
)

func main() {
    // Build the connection string.
    connString := "sqlserver://<server>?database=AdventureWorks2025&trusted_connection=yes"

    // Open and verify the connection.
    db, err := sql.Open("sqlserver", connString)
    if err != nil {
        log.Fatal("Error opening connection: ", err.Error())
    }
    defer db.Close()

    if err = db.PingContext(context.Background()); err != nil {
        log.Fatal("Error pinging database: ", err.Error())
    }
    fmt.Println("Connected to SQL Server.")

    // Run a SELECT query.
    rows, err := db.QueryContext(context.Background(),
        "SELECT DepartmentID, Name, GroupName FROM HumanResources.Department")
    if err != nil {
        log.Fatal("Error running query: ", err.Error())
    }
    defer rows.Close()

    // Iterate through the results.
    fmt.Println("\nDepartments:")
    for rows.Next() {
        var id int
        var name, groupName string
        if err := rows.Scan(&id, &name, &groupName); err != nil {
            log.Fatal("Error scanning row: ", err.Error())
        }
        fmt.Printf("  %d: %s (%s)\n", id, name, groupName)
    }
    if err = rows.Err(); err != nil {
        log.Fatal("Error after row iteration: ", err.Error())
    }
}

Uruchom aplikację:

go run main.go

Oczekiwane dane wyjściowe:

Connected to SQL Server.

Departments:
  1: Engineering (Research and Development)
  2: Tool Design (Research and Development)
  3: Sales (Sales and Marketing)
  4: Marketing (Sales and Marketing)
  ...

Wstaw wiersz

Dodaj następującą funkcję do main.go i wywołaj ją z main():

func insertDepartment(db *sql.DB, name, groupName string) (int64, error) {
    ctx := context.Background()
    result, err := db.ExecContext(ctx,
        "INSERT INTO HumanResources.Department (Name, GroupName) VALUES (@p1, @p2)",
        sql.Named("p1", name),
        sql.Named("p2", groupName))
    if err != nil {
        return 0, err
    }
    return result.RowsAffected()
}

Ważna

Sterownik go-mssqldb nie obsługuje LastInsertId(). Przy wywołaniu zwracany jest błąd. Użyj klauzuli OUTPUT lub oddzielnego zapytania SELECT SCOPE_IDENTITY(), aby pobrać wstawioną wartość identyfikatora.

Korzystanie z uwierzytelniania SQL

Aby użyć uwierzytelniania programu SQL Server zamiast uwierzytelniania systemu Windows, zmień parametry połączenia. Wszystkie formaty i opcje parametry połączenia znajdziesz w sekcji Connection strings.

connString := "sqlserver://<user>:<password>@<server>:1433?database=AdventureWorks2025"

Korzystanie z identyfikatora Entra firmy Microsoft

Jeśli łączysz się z Azure SQL Database, Azure SQL Managed Instance lub bazą danych SQL w Fabric, zacznij od Use go-mssqldb with Azure SQL Database. Przykład w tej sekcji pokazuje tylko minimalne zmiany kodu wymagane w main.go.

Aby uwierzytelnić się za pomocą Microsoft Entra ID, zaimportuj pakiet:azuread

import (
    _ "github.com/microsoft/go-mssqldb/azuread"
)

Następnie użyj nazwy sterownika azuresql i dodaj fedauth do parametrów połączenia. Wszystkie opcje Microsoft Entra znajdziesz w artykule Microsoft Entra ID authentication.

db, err := sql.Open("azuresql", "sqlserver://<server>.database.windows.net?database=AdventureWorks2025&fedauth=ActiveDirectoryDefault&encrypt=true&TrustServerCertificate=false")

Treści powiązane

  • Last updated on