Ovladač SQL Databricks pro Go

Ovladač SQL Databricks pro Go je knihovna Go, která umožňuje spouštět příkazy SQL na výpočetních prostředcích Azure Databricks pomocí kódu Go. Tento článek doplňuje ovladač SQL Databricks pro go README, reference k rozhraní API a příklady.

Požadavky

Vývojový počítač s Go verze 1.20 nebo novější. Pokud chcete vytisknout nainstalovanou verzi Jazyka Go, spusťte příkaz go version. Stáhněte a nainstalujte Go.
Existující cluster nebo SQL úložiště.
Název hostitele serveru, port a cesta HTTP pro existující cluster nebo SQL Warehouse.
- Získejte tyto hodnoty pro cluster.
- Získejte tyto hodnoty pro SQL Warehouse.

Začínáme s ovladačem SQL Databricks for Go

Na vývojovém počítači s go 1.20 nebo novějším nainstalovaným a již vytvořeným existujícím projektem kódu Go vytvořte go.mod soubor pro sledování závislostí kódu Go spuštěním go mod init příkazu, například:
```
go mod init sample
```
Spuštěním příkazu zapněte go mod edit -require závislost na balíčku Databricks SQL Driver for Go a nahraďte v1.5.2 nejnovější verzí balíčku Databricks SQL Driver for Go, jak je uvedeno v vydaných verzích:
```
go mod edit -require github.com/databricks/databricks-sql-go@v1.5.2
```
Soubor go.mod by teď měl vypadat takto:
```
module sample

go 1.20

require github.com/databricks/databricks-sql-go v1.5.2
```

V projektu vytvořte soubor kódu Go, který importuje ovladač SQL Databricks pro Go. Následující příklad v souboru s následujícím main.go obsahem obsahuje seznam všech clusterů v pracovním prostoru Azure Databricks:

package main

import (
  "database/sql"
  "os"
  _ "github.com/databricks/databricks-sql-go"
)

func main() {
  dsn := os.Getenv("DATABRICKS_DSN")

  if dsn == "" {
    panic("No connection string found. " +
     "Set the DATABRICKS_DSN environment variable, and try again.")
  }

  db, err := sql.Open("databricks", dsn)
  if err != nil {
    panic(err)
  }
  defer db.Close()

  if err := db.Ping(); err != nil {
    panic(err)
  }
}

Spuštěním go mod tidy příkazu přidejte všechny chybějící závislosti modulu:
```
go mod tidy
```
Poznámka:

Pokud se zobrazí chyba go: warning: "all" matched no packages, zapomněli jste přidat soubor kódu Go, který importuje ovladač SQL Databricks pro Go.
Spuštěním main příkazu vytvořte kopie všech balíčků potřebných k podpoře sestavení a testů balíčků v go mod vendor modulu:
```
go mod vendor
```
Upravte kód podle potřeby a nastavte DATABRICKS_DSN proměnnou prostředí pro ověřování Azure Databricks. Viz také Připojení s připojovacím řetězcem DSN.
Spuštěním příkazu spusťte soubor kódu Go za předpokladumain.go, že soubor s názvem go run:
```
go run main.go
```
Pokud se nevrátí žádné chyby, úspěšně jste ověřili ovladač SQL Databricks pro Go s pracovním prostorem Azure Databricks a připojili jste se ke spuštěném clusteru Azure Databricks nebo SQL Warehouse v daném pracovním prostoru.

Připojení pomocí připojovací řetězec DSN

Pokud chcete získat přístup ke clusterům a skladům SQL, použijte sql.Open() k vytvoření popisovače databáze prostřednictvím názvu zdroje dat (DSN) připojovací řetězec. Tento příklad kódu načte připojovací řetězec DSN z proměnné prostředí s názvemDATABRICKS_DSN:

package main

import (
  "database/sql"
  "os"
  _ "github.com/databricks/databricks-sql-go"
)

func main() {
  dsn := os.Getenv("DATABRICKS_DSN")

  if dsn == "" {
    panic("No connection string found. " +
          "Set the DATABRICKS_DSN environment variable, and try again.")
  }

  db, err := sql.Open("databricks", dsn)
  if err != nil {
    panic(err)
  }
  defer db.Close()

  if err := db.Ping(); err != nil {
    panic(err)
  }
}

Pokud chcete zadat připojovací řetězec DSN ve správném formátu, podívejte se na příklady připojovacího řetězce DSN v části Ověřování. Například pro ověřování osobního přístupového tokenu Azure Databricks použijte následující syntaxi, kde:

<personal-access-token> je váš osobní přístupový token Azure Databricks z požadavků.
<server-hostname> je hodnota názvu hostitele serveru z požadavků.
<port-number> je hodnota portu z požadavků, což je obvykle 443.
<http-path> je hodnota cesty HTTP z požadavků.
<paramX=valueX> je jeden nebo více volitelných parametrů uvedených dále v tomto článku.

token:<personal-access-token>@<server-hostname>:<port-number>/<http-path>?<param1=value1>&<param2=value2>

Například pro cluster:

token:dapi12345678901234567890123456789012@adb-1234567890123456.7.azuredatabricks.net:443/sql/protocolv1/o/1234567890123456/1234-567890-abcdefgh

Například pro SQL Warehouse:

token:dapi12345678901234567890123456789012@adb-1234567890123456.7.azuredatabricks.net:443/sql/1.0/endpoints/a1b234c5678901d2

Poznámka:

Jako osvědčený postup zabezpečení byste neměli pevně kódovat tento dsN připojovací řetězec do kódu Go. Místo toho byste měli tento dsN načíst připojovací řetězec ze zabezpečeného umístění. Například příklad kódu dříve v tomto článku použil proměnnou prostředí.

Volitelné parametry

Podporované volitelné parametry připojení lze zadat v <param=value>. Mezi nejčastěji používané patří:
- catalog: Nastaví počáteční název katalogu v relaci.
- schema: Nastaví počáteční název schématu v relaci.
- maxRows: Nastaví maximální počet řádků načtených na požadavek. Výchozí hodnota je 10000.
- timeout: Přidá časový limit (v sekundách) pro spuštění dotazu serveru. Výchozí hodnota není vypršení časového limitu.
- userAgentEntry: Slouží k identifikaci partnerů. Další informace najdete v dokumentaci partnera.
Podporované volitelné parametry relace lze zadat v param=value. Mezi nejčastěji používané patří:
- ansi_mode: Logický řetězec. true pro příkazy relace, aby dodržovaly pravidla určená specifikací ANSI SQL. Výchozí hodnota systému je false.
- timezone: Řetězec, například America/Los_Angeles. Nastaví časové pásmo relace. Výchozí hodnota systému je UTC.
- query_tags: Řetězec párů klíč:hodnota oddělených čárkami pro připojení k SQL dotazům pro sledování v system.query.history, například team:engineering,dashboard:abc123. Tato funkce je ve verzi Private Preview. Pokud chcete požádat o přístup, obraťte se na svůj tým účtů.

Například pro SQL Warehouse:

token:dapi12345678901234567890123456789012@adb-1234567890123456.7.azuredatabricks.net:443/sql/1.0/endpoints/a1b234c5678901d2?catalog=hive_metastore&schema=example&maxRows=100&timeout=60&timezone=America/Sao_Paulo&ansi_mode=true&query_tags=team:engineering,env:prod

Připojení pomocí `NewConnector` funkce

Alternativně můžete použít sql.OpenDB() k vytvoření popisovače databáze prostřednictvím nového objektu konektoru vytvořeného pomocí dbsql.NewConnector() (připojení ke clusterům Azure Databricks a skladům SQL s novým objektem konektoru vyžaduje v1.0.0 nebo vyšší ovladač Databricks SQL pro Go). Příklad:

package main

import (
  "database/sql"
  "os"
  dbsql "github.com/databricks/databricks-sql-go"
)

func main() {
  connector, err := dbsql.NewConnector(
    dbsql.WithAccessToken(os.Getenv("DATABRICKS_ACCESS_TOKEN")),
    dbsql.WithServerHostname(os.Getenv("DATABRICKS_HOST")),
    dbsql.WithPort(443),
    dbsql.WithHTTPPath(os.Getenv("DATABRICKS_HTTP_PATH")),
  )
  if err != nil {
    panic(err)
  }

  db := sql.OpenDB(connector)
  defer db.Close()

  if err := db.Ping(); err != nil {
    panic(err)
  }
}

Pokud chcete zadat správnou sadu NewConnector nastavení, podívejte se na příklady v části Ověřování.

Poznámka:

Jako osvědčený postup zabezpečení byste neměli pevně zakódovat nastavení NewConnector do kódu Go. Místo toho byste tyto hodnoty měli načíst ze zabezpečeného umístění. Například předchozí kód používá proměnné prostředí.

Mezi často používané funkční možnosti patří:

WithAccessToken(<access-token>): Osobní přístupový token Azure Databricks z požadavků. Povinné string.
WithServerHostname(<server-hostname>): Hodnota názvu hostitele serveru z požadavků. Povinné string.
WithPort(<port>): Číslo portu serveru, obvykle 443. Povinné int.
WithHTTPPath(<http-path>): Hodnota cesty HTTP z požadavků. Povinné string.
WithInitialNamespace(<catalog>, <schema>):Název katalogu a schématu v relaci. Volitelnéstring, string.
WithMaxRows(<max-rows>): Maximální počet řádků načtených na požadavek. Výchozí hodnota je 10000. Nepovinná int.
WithSessionParams(<params-map>): Parametry relace, včetně "timezone", "ansi_mode" a "query_tags". Volitelnémap[string]string.
WithTimeout(<timeout>). Časový limit (in time.Duration) pro spuštění dotazu serveru. Výchozí hodnota není vypršení časového limitu. Nepovinné.
WithUserAgentEntry(<isv-name-plus-product-name>). Slouží k identifikaci partnerů. Další informace najdete v dokumentaci partnera. Volitelnéstring.

Příklad:

connector, err := dbsql.NewConnector(
  dbsql.WithAccessToken(os.Getenv("DATABRICKS_ACCESS_TOKEN")),
  dbsql.WithServerHostname(os.Getenv("DATABRICKS_HOST")),
  dbsql.WithPort(443),
  dbsql.WithHTTPPath(os.Getenv("DATABRICKS_HTTP_PATH")),
  dbsql.WithInitialNamespace("samples", "nyctaxi"),
  dbsql.WithMaxRows(100),
  dbsql.SessionParams(map[string]string{"timezone": "America/Sao_Paulo", "ansi_mode": "true", "query_tags": "team:analytics,project:reporting"}),
  dbsql.WithTimeout(time.Minute),
  dbsql.WithUserAgentEntry("example-user"),
)

Ověřování

Ovladač SQL Databricks pro Go podporuje následující typy ověřování Azure Databricks:

Ověřování osobního přístupového tokenu Databricks
Ověřování tokenu Microsoft Entra ID
Ověřování uživatele vůči stroji OAuth (U2M)
Ověřování OAuth pro komunikaci stroj-stroj (M2M)

Ovladač SQL Databricks pro Go zatím nepodporuje následující typy ověřování Azure Databricks:

Ověřování osobního přístupového tokenu Databricks

Pokud chcete použít ovladač SQL Databricks pro Go s ověřováním osobního přístupového tokenu Azure Databricks, musíte nejprve vytvořit osobní přístupový token Azure Databricks. Podrobnosti o tomto kroku najdete v tématu Vytvoření osobních přístupových tokenů pro uživatele pracovního prostoru.

Pokud chcete ověřit ovladač SQL pro Databricks Go pomocí připojovacího řetězce DSN a příkladu kódu v části Připojení pomocí připojovacího řetězce DSN, použijte následující syntaxi připojovacího řetězce DSN, kde:

<personal-access-token> je váš osobní přístupový token Azure Databricks z požadavků.
<server-hostname> je hodnota názvu hostitele serveru z požadavků.
<port-number> je hodnota portu z požadavků, což je obvykle 443.
<http-path> je hodnota cesty HTTP z požadavků.

Můžete také připojit jeden nebo více volitelných parametrů uvedených dříve v tomto článku.

token:<personal-access-token>@<server-hostname>:<port-number>/<http-path>

Pokud chcete ověřit ovladač SQL Databricks pro Go pomocí NewConnector funkce, použijte následující fragment kódu a příklad kódu v nástroji Connect s NewConnector funkcí, což předpokládá, že jste nastavili následující proměnné prostředí:

DATABRICKS_SERVER_HOSTNAMEnastavit na hodnotu název hostitele serveru pro váš cluster nebo SQL sklad.
DATABRICKS_HTTP_PATH, nastavte hodnotu cesty HTTP pro váš cluster nebo SQL Warehouse.
DATABRICKS_TOKEN, nastavte na osobní přístupový token Azure Databricks.

Pokud chcete nastavit proměnné prostředí, přečtěte si dokumentaci k vašemu operačnímu systému.

connector, err := dbsql.NewConnector(
  dbsql.WithServerHostname(os.Getenv("DATABRICKS_SERVER_HOSTNAME")),
  dbsql.WithHTTPPath(os.Getenv("DATABRICKS_HTTP_PATH")),
  dbsql.WithPort(443),
  dbsql.WithAccessToken(os.Getenv("DATABRICKS_TOKEN")),
)

Ověřování tokenu Microsoft Entra ID

Ovladač SQL Databricks pro Go podporuje tokeny ID Microsoft Entra pro uživatele Azure Databricks nebo instanční objekt Microsoft Entra ID.

Pokud chcete vytvořit přístupový token Microsoft Entra ID, postupujte takto:

Pro uživatele Azure Databricks nebo služebního principála Microsoft Entra ID použijte Azure CLI. Viz Ruční získání tokenů ID Microsoft Entra. Informace o vytvoření spravovaného služebního principálu Microsoft Entra ID najdete v tématu Služební principály.

Tokeny MICROSOFT Entra ID mají výchozí životnost přibližně 1 hodinu. Pokud chcete vytvořit nový token ID Microsoft Entra, opakujte tento proces.

Pokud chcete ověřit ovladač SQL pro Databricks Go pomocí připojovacího řetězce DSN a příkladu kódu v části Připojení pomocí připojovacího řetězce DSN, použijte následující syntaxi připojovacího řetězce DSN, kde:
- <microsoft-entra-id-token> je váš token ID Microsoft Entra.
- <server-hostname> je hodnota názvu hostitele serveru z požadavků.
- <port-number> je hodnota portu z požadavků, což je obvykle 443.
- <http-path> je hodnota cesty HTTP z požadavků.
Můžete také připojit jeden nebo více volitelných parametrů uvedených dříve v tomto článku.
```
token:<microsoft-entra-id-token>@<server-hostname>:<port-number>/<http-path>
```
Pokud chcete ověřit ovladač SQL Databricks pro Go pomocí NewConnector funkce, použijte následující fragment kódu a příklad kódu v nástroji Connect s NewConnector funkcí, což předpokládá, že jste nastavili následující proměnné prostředí:
- DATABRICKS_SERVER_HOSTNAMEnastavit na hodnotu název hostitele serveru pro váš cluster nebo SQL sklad.
- DATABRICKS_HTTP_PATH, nastavte hodnotu cesty HTTP pro váš cluster nebo SQL Warehouse.
- DATABRICKS_TOKEN, nastavte na token Microsoft Entra ID.
Pokud chcete nastavit proměnné prostředí, přečtěte si dokumentaci k vašemu operačnímu systému.
```
connector, err := dbsql.NewConnector(
  dbsql.WithServerHostname(os.Getenv("DATABRICKS_SERVER_HOSTNAME")),
  dbsql.WithHTTPPath(os.Getenv("DATABRICKS_HTTP_PATH")),
  dbsql.WithPort(443),
  dbsql.WithAccessToken(os.Getenv("DATABRICKS_TOKEN")),
)
```

Ověřování uživatele OAuth na počítač (U2M)

Ovladač SQL Databricks pro Go verze 1.5.0 a vyšší podporuje ověřování uživatele k počítači OAuth (U2M).

Pokud chcete použít ovladač SQL Databricks pro Go s připojovacím řetězcem DSN a příkladem kódu v připojení k připojovacímu řetězci DSN, použijte následující syntaxi připojovacího řetězce DSN, kde:

<server-hostname> je hodnota názvu hostitele serveru z požadavků.
<port-number> je hodnota portu z požadavků, což je obvykle 443.
<http-path> je hodnota cesty HTTP z požadavků.

Můžete také připojit jeden nebo více volitelných parametrů uvedených dříve v tomto článku.

<server-hostname>:<port-number>/<http-path>?authType=OauthU2M

Pokud chcete ověřit ovladač SQL Databricks pro Go pomocí NewConnector funkce, musíte nejprve do deklarace import přidat následující:

"github.com/databricks/databricks-sql-go/auth/oauth/u2m"

Pak použijte následující fragment kódu a příklad kódu ve funkci Connect s NewConnector funkcí, která předpokládá, že jste nastavili následující proměnné prostředí:

DATABRICKS_SERVER_HOSTNAMEnastavit na hodnotu název hostitele serveru pro váš cluster nebo SQL sklad.
DATABRICKS_HTTP_PATH, nastavte hodnotu cesty HTTP pro váš cluster nebo SQL Warehouse.

Pokud chcete nastavit proměnné prostředí, přečtěte si dokumentaci k vašemu operačnímu systému.

authenticator, err := u2m.NewAuthenticator(os.Getenv("DATABRICKS_SERVER_HOSTNAME"), 1*time.Minute)
if err != nil {
  panic(err)
}

connector, err := dbsql.NewConnector(
  dbsql.WithServerHostname(os.Getenv("DATABRICKS_SERVER_HOSTNAME")),
  dbsql.WithHTTPPath(os.Getenv("DATABRICKS_HTTP_PATH")),
  dbsql.WithPort(443),
  dbsql.WithAuthenticator(authenticator),
)

Ověřování M2M (machine-to-machine) OAuth

Ovladač Databricks SQL pro Go ve verzích 1.5.2 a novějších podporuje ověřování OAuth stroj-stroj (M2M).

Pokud chcete použít ovladač SQL Databricks pro Go s ověřováním OAuth M2M, musíte udělat toto:

V pracovním prostoru Azure Databricks vytvořte instanční objekt Azure Databricks a vytvořte pro tento instanční objekt tajný klíč OAuth.

Pokud chcete vytvořit instanční objekt a jeho tajný klíč OAuth, přečtěte si téma Autorizace přístupu instančního objektu k Azure Databricks pomocí OAuth. Poznamenejte si hodnotu UUID nebo ID aplikace instančního objektu a hodnotu Secret pro tajný klíč OAuth instančního objektu.
Dejte danému instančnímu objektu přístup ke clusteru nebo skladu.

Pokud chcete hlavní službě udělit přístup ke clusteru nebo datovému skladu, viz oprávnění výpočetního prostředku nebo správa SQL datového skladu.

<server-hostname> je hodnota názvu hostitele serveru z požadavků.
<port-number> je hodnota portu z požadavků, což je obvykle 443.
<http-path> je hodnota cesty HTTP z požadavků.
<client-id> je hodnota UUID nebo ID aplikace hlavního objektu služby.
<client-secret> je hodnota Secret pro tajný klíč OAuth instančního objektu.

Můžete také připojit jeden nebo více volitelných parametrů uvedených dříve v tomto článku.

<server-hostname>:<port-number>/<http-path>?authType=OAuthM2M&clientID=<client-id>&clientSecret=<client-secret>

Pokud chcete ověřit ovladač SQL Databricks pro Go pomocí NewConnector funkce, musíte nejprve do deklarace import přidat následující:

"github.com/databricks/databricks-sql-go/auth/oauth/m2m"

Pak použijte následující fragment kódu a příklad kódu ve funkci Connect s NewConnector funkcí, která předpokládá, že jste nastavili následující proměnné prostředí:

DATABRICKS_SERVER_HOSTNAMEnastavit na hodnotu název hostitele serveru pro váš cluster nebo SQL sklad.
DATABRICKS_HTTP_PATH, nastavte hodnotu cesty HTTP pro váš cluster nebo SQL Warehouse.
DATABRICKS_CLIENT_ID, nastavte na hodnotu UUID nebo ID aplikace instančního objektu.
DATABRICKS_CLIENT_SECRET, nastavte hodnotu na Secret pro heslo OAuth instančního objektu služby.

Pokud chcete nastavit proměnné prostředí, přečtěte si dokumentaci k vašemu operačnímu systému.

authenticator := m2m.NewAuthenticator(
  os.Getenv("DATABRICKS_CLIENT_ID"),
  os.Getenv("DATABRICKS_CLIENT_SECRET"),
  os.Getenv("DATABRICKS_SERVER_HOSTNAME"),
)

connector, err := dbsql.NewConnector(
  dbsql.WithServerHostname(os.Getenv("DATABRICKS_SERVER_HOSTNAME")),
  dbsql.WithHTTPPath(os.Getenv("DATABRICKS_HTTP_PATH")),
  dbsql.WithPort(443),
  dbsql.WithAuthenticator(authenticator),
)

Zadávání dotazů na data

Následující příklad kódu ukazuje, jak volat ovladač SQL Databricks pro Go ke spuštění základního dotazu SQL na výpočetní prostředek Azure Databricks. Tento příkaz vrátí první dva řádky z trips tabulky ve schématu samples katalogu nyctaxi .

Tento příklad kódu načte připojovací řetězec DSN z proměnné prostředí s názvem DATABRICKS_DSN.

package main

import (
  "database/sql"
  "fmt"
  "os"
  "time"

  _ "github.com/databricks/databricks-sql-go"
)

func main() {
  dsn := os.Getenv("DATABRICKS_DSN")

  if dsn == "" {
    panic("No connection string found." +
          "Set the DATABRICKS_DSN environment variable, and try again.")
  }

  db, err := sql.Open("databricks", dsn)
  if err != nil {
    panic(err)
  }

  defer db.Close()

  var (
    tpep_pickup_datetime  time.Time
    tpep_dropoff_datetime time.Time
    trip_distance         float64
    fare_amount           float64
    pickup_zip            int
    dropoff_zip           int
  )

  rows, err := db.Query("SELECT * FROM samples.nyctaxi.trips LIMIT ?", 2)
  if err != nil {
    panic(err)
  }

  defer rows.Close()

  fmt.Print("tpep_pickup_datetime,",
    "tpep_dropoff_datetime,",
    "trip_distance,",
    "fare_amount,",
    "pickup_zip,",
    "dropoff_zip\n")

  for rows.Next() {
    err := rows.Scan(&tpep_pickup_datetime,
      &tpep_dropoff_datetime,
      &trip_distance,
      &fare_amount,
      &pickup_zip,
      &dropoff_zip)
    if err != nil {
      panic(err)
    }

    fmt.Print(tpep_pickup_datetime, ",",
      tpep_dropoff_datetime, ",",
      trip_distance, ",",
      fare_amount, ",",
      pickup_zip, ",",
      dropoff_zip, "\n")
  }

  err = rows.Err()
  if err != nil {
    panic(err)
  }
}

Správa souborů ve svazcích katalogu Unity

Ovladač SQL Databricks umožňuje zapisovat místní soubory do svazků katalogu Unity, stahovat soubory ze svazků a odstraňovat soubory ze svazků, jak je znázorněno v následujícím příkladu:

package main

import (
  "context"
  "database/sql"
  "os"

  _ "github.com/databricks/databricks-sql-go"
  "github.com/databricks/databricks-sql-go/driverctx"
)

func main() {
  dsn := os.Getenv("DATABRICKS_DSN")

  if dsn == "" {
    panic("No connection string found." +
      "Set the DATABRICKS_DSN environment variable, and try again.")
  }

  db, err := sql.Open("databricks", dsn)
  if err != nil {
    panic(err)
  }
  defer db.Close()

  // For writing local files to volumes and downloading files from volumes,
  // you must first specify the path to the local folder that contains the
  // files to be written or downloaded.
  // For multiple folders, add their paths to the following string array.
  // For deleting files in volumes, this string array is ignored but must
  // still be provided, so in that case its value can be set for example
  // to an empty string.
  ctx := driverctx.NewContextWithStagingInfo(
    context.Background(),
    []string{"/tmp/"},
  )

  // Write a local file to the path in the specified volume.
  // Specify OVERWRITE to overwrite any existing file in that path.
  db.ExecContext(ctx, "PUT '/tmp/my-data.csv' INTO '/Volumes/main/default/my-volume/my-data.csv' OVERWRITE")

  // Download a file from the path in the specified volume.
  db.ExecContext(ctx, "GET '/Volumes/main/default/my-volume/my-data.csv' TO '/tmp/my-downloaded-data.csv'")

  // Delete a file from the path in the specified volume.
  db.ExecContext(ctx, "REMOVE '/Volumes/main/default/my-volume/my-data.csv'")

  db.Close()
}

Protokolování

Slouží github.com/databricks/databricks-sql-go/logger k protokolování zpráv, které generuje ovladač SQL Databricks for Go. Následující příklad kódu používá sql.Open() k vytvoření popisovače databáze prostřednictvím dsN připojovací řetězec. Tento příklad kódu načte připojovací řetězec DSN z proměnné prostředí s názvem DATABRICKS_DSN. Všechny zprávy protokolu, které se vygenerují na debug úrovni a níže, se zapíšou results.log do souboru.

package main

import (
  "database/sql"
  "io"
  "log"
  "os"

  _ "github.com/databricks/databricks-sql-go"
  dbsqllog "github.com/databricks/databricks-sql-go/logger"
)

func main() {
  dsn := os.Getenv("DATABRICKS_DSN")

  // Use the specified file for logging messages to.
  file, err := os.Create("results.log")
  if err != nil {
    log.Fatal(err)
  }
  defer file.Close()

  writer := io.Writer(file)

  // Log messages at the debug level and below.
  if err := dbsqllog.SetLogLevel("debug"); err != nil {
    log.Fatal(err)
  }

  // Log messages to the file.
  dbsqllog.SetLogOutput(writer)

  if dsn == "" {
    panic("Error: Cannot connect. No connection string found. " +
      "Set the DATABRICKS_DSN environment variable, and try again.")
  }

  db, err := sql.Open("databricks", dsn)
  if err != nil {
    panic(err)
  }
  defer db.Close()

  if err := db.Ping(); err != nil {
    panic(err)
  }
}

Testování

K otestování kódu použijte testovací architektury Go, jako je testovací standardní knihovna. K otestování kódu za simulovaných podmínek bez volání koncových bodů rozhraní REST API služby Azure Databricks nebo změny stavu účtů nebo pracovních prostorů Azure Databricks použijte knihovny napodobení Go, jako je testfify.

Například vzhledem k následujícímu souboru s názvem helpers.go obsahujícím GetDBWithDSNPAT funkci, která vrací připojení pracovního prostoru Azure Databricks, GetNYCTaxiTrips funkci, která vrací data z trips tabulky ve samples schématu katalogu nyctaxi a PrintNYCTaxiTrips která vytiskne vrácená data:

package main

import (
  "database/sql"
  "fmt"
  "strconv"
  "time"
)

func GetDBWithDSNPAT(dsn string) (*sql.DB, error) {
  db, err := sql.Open("databricks", dsn)
  if err != nil {
    return nil, err
  }
  return db, nil
}

func GetNYCTaxiTrips(db *sql.DB, numRows int) (*sql.Rows, error) {
  rows, err := db.Query("SELECT * FROM samples.nyctaxi.trips LIMIT ?", numRows)
  if err != nil {
    return nil, err
  }
  return rows, nil
}

func PrintNYCTaxiTrips(rows *sql.Rows) {
  var (
    tpep_pickup_datetime  time.Time
    tpep_dropoff_datetime time.Time
    trip_distance         float64
    fare_amount           float64
    pickup_zip            int
    dropoff_zip           int
  )

  fmt.Print(
    "tpep_pickup_datetime,",
    "tpep_dropoff_datetime,",
    "trip_distance,",
    "fare_amount,",
    "pickup_zip,",
    "dropoff_zip\n",
  )

  for rows.Next() {
    err := rows.Scan(
      &tpep_pickup_datetime,
      &tpep_dropoff_datetime,
      &trip_distance,
      &fare_amount,
      &pickup_zip,
      &dropoff_zip,
    )
    if err != nil {
      panic(err)
    }

    fmt.Print(
      tpep_pickup_datetime, ",",
      tpep_dropoff_datetime, ",",
      trip_distance, ",",
      fare_amount, ",",
      pickup_zip, ",",
      dropoff_zip, "\n",
    )
  }

  err := rows.Err()
  if err != nil {
    panic(err)
  }
}

A vzhledem k následujícímu souboru, main.go který volá tyto funkce:

package main

import (
  "os"
)

func main() {
  db, err := GetDBWithDSNPAT(os.Getenv("DATABRICKS_DSN"))
  if err != nil {
    panic(err)
  }

  rows, err := GetNYCTaxiTrips(db, 2)
  if err != nil {
    panic(err)
  }

  PrintNYCTaxiTrips(rows)
}

Následující soubor s názvem helpers_test.go testuje, zda GetNYCTaxiTrips funkce vrátí očekávanou odpověď. Místo vytvoření skutečného připojení k cílovému pracovnímu prostoru tento test napodobí sql.DB objekt. Test také napodobí některá data, která odpovídají schématu a hodnotám, které jsou ve skutečných datech. Test vrátí napodobená data prostřednictvím napodobeného připojení a pak zkontroluje, jestli jedna z hodnot napodobených řádků dat odpovídá očekávané hodnotě.

package main

import (
  "database/sql"
  "testing"

  "github.com/stretchr/testify/assert"
  "github.com/stretchr/testify/mock"
)

// Define an interface that contains a method with the same signature
// as the real GetNYCTaxiTrips function that you want to test.
type MockGetNYCTaxiTrips interface {
  GetNYCTaxiTrips(db *sql.DB, numRows int) (*sql.Rows, error)
}

// Define a struct that represents the receiver of the interface's method
// that you want to test.
type MockGetNYCTaxiTripsObj struct {
  mock.Mock
}

// Define the behavior of the interface's method that you want to test.
func (m *MockGetNYCTaxiTripsObj) GetNYCTaxiTrips(db *sql.DB, numRows int) (*sql.Rows, error) {
  args := m.Called(db, numRows)
  return args.Get(0).(*sql.Rows), args.Error(1)
}

func TestGetNYCTaxiTrips(t *testing.T) {
  // Instantiate the receiver.
  mockGetNYCTaxiTripsObj := new(MockGetNYCTaxiTripsObj)

  // Define how the mock function should be called and what it should return.
  // We're not concerned with whether the actual database is connected to--just
  // what is returned.
  mockGetNYCTaxiTripsObj.On("GetNYCTaxiTrips", mock.Anything, mock.AnythingOfType("int")).Return(&sql.Rows{}, nil)

  // Call the mock function that you want to test.
  rows, err := mockGetNYCTaxiTripsObj.GetNYCTaxiTrips(nil, 2)

  // Assert that the mock function was called as expected.
  mockGetNYCTaxiTripsObj.AssertExpectations(t)

  // Assert that the mock function returned what you expected.
  assert.NotNil(t, rows)
  assert.Nil(t, err)
}

Vzhledem k tomu, že GetNYCTaxiTrips funkce obsahuje SELECT příkaz, a proto nemění stav trips tabulky, není v tomto příkladu napodobování zcela vyžadováno. Napodobování ale umožňuje rychle spouštět testy bez čekání na skutečné připojení k pracovnímu prostoru. Také napodobení umožňuje spustit simulované testy vícekrát pro funkce, které mohou změnit stav tabulky, například INSERT INTO, UPDATEa DELETE FROM.

Další materiály

Úložiště Databricks SQL Driver for Go na GitHubu
Domovská stránka databáze nebo balíčku SQL
Příklady ovladače SQL Databricks pro Go na GitHubu

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-01-16

Sdílet prostřednictvím

Ovladač SQL Databricks pro Go

Požadavky

Začínáme s ovladačem SQL Databricks for Go

Připojení pomocí připojovací řetězec DSN

Volitelné parametry

Připojení pomocí NewConnector funkce

Ověřování

Ověřování osobního přístupového tokenu Databricks

Ověřování tokenu Microsoft Entra ID

Ověřování uživatele OAuth na počítač (U2M)

Ověřování M2M (machine-to-machine) OAuth

Zadávání dotazů na data

Správa souborů ve svazcích katalogu Unity

Protokolování

Testování

Další materiály

Váš názor

Další materiály

Připojení pomocí `NewConnector` funkce