Delen via

Databricks SQL-stuurprogramma voor Go

  • Artikel

Het Databricks SQL-stuurprogramma voor Go is een Go-bibliotheek waarmee u Go-code kunt gebruiken om SQL-opdrachten uit te voeren op Azure Databricks-rekenresources. Dit artikel is een aanvulling op het Databricks SQL-stuurprogramma voor Go README, API-verwijzing en voorbeelden.

Vereisten

Aan de slag met het Databricks SQL-stuurprogramma voor Go

  1. Maak op uw ontwikkelcomputer waarop Go 1.20 of hoger al is geïnstalleerd en een bestaand Go-codeproject al is gemaakt, een go.mod bestand om de afhankelijkheden van uw Go-code bij te houden door de go mod init opdracht uit te voeren, bijvoorbeeld:

    go mod init sample

  2. Neem een afhankelijkheid van het Databricks SQL-stuurprogramma voor Go-pakket door de go mod edit -require opdracht uit te voeren, waarbij v1.5.2 u de nieuwste versie van het Databricks SQL-stuurprogramma voor Go-pakket vervangt zoals vermeld in de releases:

    go mod edit -require github.com/databricks/databricks-sql-go@v1.5.2

    Uw go.mod bestand moet er nu als volgt uitzien:

    module sample

go 1.20

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

  3. Maak in uw project een Go-codebestand waarmee het Databricks SQL-stuurprogramma voor Go wordt geïmporteerd. In het volgende voorbeeld, in een bestand met de naam main.go met de volgende inhoud, worden alle clusters in uw Azure Databricks-werkruimte vermeld:

    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)
  }
}

  4. Voeg ontbrekende moduleafhankelijkheden toe door de opdracht uit te go mod tidy voeren:

    go mod tidy

    Notitie

    Als u de fout go: warning: "all" matched no packageskrijgt, bent u vergeten een Go-codebestand toe te voegen waarmee het Databricks SQL-stuurprogramma voor Go wordt geïmporteerd.

  5. Maak kopieën van alle pakketten die nodig zijn om builds en tests van pakketten in uw main module te ondersteunen door de go mod vendor opdracht uit te voeren:

    go mod vendor

  6. Pas uw code zo nodig aan om de DATABRICKS_DSN omgevingsvariabele in te stellen voor Azure Databricks-verificatie. Zie ook Verbinding maken met een DSN-verbindingsreeks.

  7. Voer het Go-codebestand uit, uitgaande van een bestand met de naam main.go, door de opdracht uit te go run voeren:

    go run main.go

  8. Als er geen fouten worden geretourneerd, hebt u het Databricks SQL-stuurprogramma voor Go geverifieerd met uw Azure Databricks-werkruimte en verbonden met uw actieve Azure Databricks-cluster of SQL Warehouse in die werkruimte.

Verbinding maken met een DSN-verbindingsreeks

Als u toegang wilt krijgen tot clusters en SQL-warehouses, gebruikt sql.Open() u om een databasehandler te maken via een DSN-verbindingsreeks (gegevensbronnaam). In dit codevoorbeeld wordt de DSN-verbindingsreeks opgehaald uit een omgevingsvariabele met de naamDATABRICKS_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)
  }
}

Als u de DSN-verbindingsreeks in de juiste indeling wilt opgeven, raadpleegt u de DSN-verbindingsreeks voorbeelden in Verificatie. Gebruik bijvoorbeeld voor verificatie van persoonlijke toegangstokens van Azure Databricks de volgende syntaxis, waarbij:

  • <personal-access-token> is uw persoonlijke toegangstoken van Azure Databricks uit de vereisten.
  • <server-hostname> is de serverhostnaamwaarde van de vereisten.
  • <port-number> is de poortwaarde van de vereisten. Dit is doorgaans 443.
  • <http-path> is de HTTP-padwaarde van de vereisten.
  • <paramX=valueX> is een of meer optionele parameters die verderop in dit artikel worden vermeld.
token:<personal-access-token>@<server-hostname>:<port-number>/<http-path>?<param1=value1>&<param2=value2>

Bijvoorbeeld voor een cluster:

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

Bijvoorbeeld voor een SQL Warehouse:

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

Notitie

Als best practice voor beveiliging moet u deze DSN-verbindingsreeks niet in uw Go-code code schrijven. In plaats daarvan moet u deze DSN-verbindingsreeks ophalen vanaf een veilige locatie. In het codevoorbeeld eerder in dit artikel is bijvoorbeeld een omgevingsvariabele gebruikt.

Optionele parameters

  • Ondersteunde optionele verbindingsparameters kunnen worden opgegeven in <param=value>. Enkele van de meest gebruikte zijn:
    • catalog: Hiermee stelt u de initiële catalogusnaam in de sessie in.
    • schema: Hiermee stelt u de eerste schemanaam in de sessie in.
    • maxRows: Hiermee stelt u het maximum aantal rijen in dat per aanvraag is opgehaald. De standaardwaarde is 10000.
    • timeout: Voegt de time-out (in seconden) toe voor de uitvoering van de serverquery. De standaardwaarde is geen time-out.
    • userAgentEntry: Wordt gebruikt om partners te identificeren. Zie de documentatie van uw partner voor meer informatie.
  • Ondersteunde optionele sessieparameters kunnen worden opgegeven in param=value. Enkele van de meest gebruikte zijn:
    • ansi_mode: Een Booleaanse tekenreeks. true voor sessieinstructies om te voldoen aan regels die zijn opgegeven door de ANSI SQL-specificatie. De standaardwaarde van het systeem is onwaar.
    • timezone: Een tekenreeks, bijvoorbeeld America/Los_Angeles. Hiermee stelt u de tijdzone van de sessie in. De standaardinstelling van het systeem is UTC.

Bijvoorbeeld voor een 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

Verbinding maken met de NewConnector functie

U kunt ook sql.OpenDB() een databasehandgreep maken via een nieuw connectorobject waarmee wordt gemaakt dbsql.NewConnector() (verbinding maken met Azure Databricks-clusters en SQL-warehouses met een nieuw connectorobject vereist v1.0.0 of hoger van het Databricks SQL-stuurprogramma voor Go). Voorbeeld:

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)
  }
}

Zie de voorbeelden in Verificatie om de juiste set NewConnector instellingen op te geven.

Notitie

Als best practice voor beveiliging moet u uw NewConnector instellingen niet in code schrijven in uw Go-code. In plaats daarvan moet u deze waarden ophalen van een veilige locatie. De voorgaande code maakt bijvoorbeeld gebruik van omgevingsvariabelen.

Enkele van de meer gebruikte functionele opties zijn:

  • WithAccessToken(<access-token>): uw persoonlijke toegangstoken van Azure Databricks uit de vereisten. Vereist string.
  • WithServerHostname(<server-hostname>): De serverhostnaamwaarde van de vereisten. Vereist string.
  • WithPort(<port>): het poortnummer van de server, meestal 443. Vereist int.
  • WithHTTPPath(<http-path>): de HTTP-padwaarde van de vereisten. Vereist string.
  • WithInitialNamespace(<catalog>, <schema>):De catalogus- en schemanaam in de sessie. Optioneelstring, string.
  • WithMaxRows(<max-rows>): Het maximum aantal rijen dat per aanvraag is opgehaald. De standaardwaarde is 10000. Optioneel int.
  • WithSessionParams(<params-map>): De sessieparameters, waaronder 'tijdzone' en 'ansi_mode'. Optioneelmap[string]string.
  • WithTimeout(<timeout>). De time-out (in time.Duration) voor de uitvoering van de serverquery. De standaardwaarde is geen time-out. Optioneel.
  • WithUserAgentEntry(<isv-name-plus-product-name>). Wordt gebruikt om partners te identificeren. Zie de documentatie van uw partner voor meer informatie. Optioneelstring.

Voorbeeld:

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"}),
  dbsql.WithTimeout(time.Minute),
  dbsql.WithUserAgentEntry("example-user"),
)

Verificatie

Het Databricks SQL-stuurprogramma voor Go ondersteunt de volgende Azure Databricks-verificatietypen:

Het Databricks SQL-stuurprogramma voor Go biedt nog geen ondersteuning voor de volgende Azure Databricks-verificatietypen:

Verificatie van persoonlijke toegangstokens van Databricks

Als u het Databricks SQL-stuurprogramma voor Go wilt gebruiken met persoonlijke toegangstokenverificatie van Azure Databricks, moet u als volgt een persoonlijk Azure Databricks-toegangstoken maken:

  1. Klik in uw Azure Databricks-werkruimte op uw Azure Databricks-gebruikersnaam in de bovenste balk en selecteer vervolgens Instellingen in de vervolgkeuzelijst.
  2. Klik op Ontwikkelaars.
  3. Klik naast Access-tokens op Beheren.
  4. Klik op Nieuw token genereren.
  5. (Optioneel) Voer een opmerking in waarmee u dit token in de toekomst kunt identificeren en de standaardlevensduur van het token van 90 dagen kunt wijzigen. Als u een token zonder levensduur wilt maken (niet aanbevolen), laat u het vak Levensduur (dagen) leeg (leeg).
  6. Klik op Genereren.
  7. Kopieer het weergegeven token naar een veilige locatie en klik vervolgens op Gereed.

Notitie

Zorg ervoor dat u het gekopieerde token op een veilige locatie opslaat. Deel uw gekopieerde token niet met anderen. Als u het gekopieerde token kwijtraakt, kunt u dat token niet opnieuw genereren. In plaats daarvan moet u deze procedure herhalen om een nieuw token te maken. Als u het gekopieerde token kwijtraakt of als u denkt dat het token is aangetast, raadt Databricks u ten zeerste aan dat u dat token onmiddellijk uit uw werkruimte verwijdert door te klikken op het prullenbakpictogram (Intrekken) naast het token op de pagina Toegangstokens .

Als u geen tokens in uw werkruimte kunt maken of gebruiken, kan dit komen doordat uw werkruimtebeheerder tokens heeft uitgeschakeld of u geen toestemming hebt gegeven om tokens te maken of te gebruiken. Neem de werkruimtebeheerder of het volgende weer:

Als u het Databricks SQL-stuurprogramma voor Go wilt verifiëren met een DSN-verbindingsreeks en het codevoorbeeld in Verbinding maken met een DSN-verbindingsreeks, gebruikt u de volgende DSN-verbindingsreeks syntaxis, waarbij:

  • <personal-access-token> is uw persoonlijke toegangstoken van Azure Databricks uit de vereisten.
  • <server-hostname> is de serverhostnaamwaarde van de vereisten.
  • <port-number> is de poortwaarde van de vereisten. Dit is doorgaans 443.
  • <http-path> is de HTTP-padwaarde van de vereisten.

U kunt ook een of meer optionele parameters toevoegen die eerder in dit artikel zijn vermeld.

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

Als u het Databricks SQL-stuurprogramma voor Go wilt verifiëren met de NewConnector functie, gebruikt u het volgende codefragment en het codevoorbeeld in Verbinding maken met de functie NewConnector. Hierbij wordt ervan uitgegaan dat u de volgende omgevingsvariabelen hebt ingesteld:

  • DATABRICKS_SERVER_HOSTNAMEingesteld op de serverhostnaamwaarde voor uw cluster of SQL Warehouse.
  • DATABRICKS_HTTP_PATH, ingesteld op HTTP-padwaarde voor uw cluster of SQL Warehouse.
  • DATABRICKS_TOKEN, ingesteld op het persoonlijke toegangstoken van Azure Databricks.

Als u omgevingsvariabelen wilt instellen, raadpleegt u de documentatie van uw besturingssysteem.

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")),
)

Verificatie van tokens van Microsoft Entra ID (voorheen Azure Active Directory)

Het Databricks SQL-stuurprogramma voor Go ondersteunt Microsoft Entra ID-tokens (voorheen Azure Active Directory) voor een Azure Databricks-gebruiker of een Microsoft Entra ID-service-principal.

Ga als volgt te werk om een Microsoft Entra ID-toegangstoken te maken:

  • Voor een Azure Databricks-gebruiker kunt u de Azure CLI gebruiken. Zie Tokens voor Microsoft Entra-id (voorheen Azure Active Directory) ophalen voor gebruikers met behulp van de Azure CLI.

    Microsoft Entra ID-tokens hebben een standaardlevensduur van ongeveer 1 uur. Herhaal dit proces om een nieuw Microsoft Entra ID-token te maken.

    Als u het Databricks SQL-stuurprogramma voor Go wilt verifiëren met een DSN-verbindingsreeks en het codevoorbeeld in Verbinding maken met een DSN-verbindingsreeks, gebruikt u de volgende DSN-verbindingsreeks syntaxis, waarbij:

    • <microsoft-entra-id-token> is uw Microsoft Entra ID-token.
    • <server-hostname> is de serverhostnaamwaarde van de vereisten.
    • <port-number> is de poortwaarde van de vereisten. Dit is doorgaans 443.
    • <http-path> is de HTTP-padwaarde van de vereisten.

    U kunt ook een of meer optionele parameters toevoegen die eerder in dit artikel zijn vermeld.

    token:<microsoft-entra-id-token>@<server-hostname>:<port-number>/<http-path>

    Als u het Databricks SQL-stuurprogramma voor Go wilt verifiëren met de NewConnector functie, gebruikt u het volgende codefragment en het codevoorbeeld in Verbinding maken met de functie NewConnector. Hierbij wordt ervan uitgegaan dat u de volgende omgevingsvariabelen hebt ingesteld:

    • DATABRICKS_SERVER_HOSTNAMEingesteld op de serverhostnaamwaarde voor uw cluster of SQL Warehouse.
    • DATABRICKS_HTTP_PATH, ingesteld op HTTP-padwaarde voor uw cluster of SQL Warehouse.
    • DATABRICKS_TOKEN, ingesteld op uw Microsoft Entra ID-token.

    Als u omgevingsvariabelen wilt instellen, raadpleegt u de documentatie van uw besturingssysteem.

    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")),
)

OAuth-verificatie van gebruiker naar machine (U2M)

Databricks SQL-stuurprogramma voor Go-versies 1.5.0 en hoger bieden ondersteuning voor OAuth-gebruikers-naar-machine-verificatie (U2M).

Als u het Databricks SQL-stuurprogramma voor Go wilt gebruiken met een DSN-verbindingsreeks en het codevoorbeeld in Verbinding maken met een DSN-verbindingsreeks, gebruikt u de volgende DSN-verbindingsreeks syntaxis, waarbij:

  • <server-hostname> is de serverhostnaamwaarde van de vereisten.
  • <port-number> is de poortwaarde van de vereisten. Dit is doorgaans 443.
  • <http-path> is de HTTP-padwaarde van de vereisten.

U kunt ook een of meer optionele parameters toevoegen die eerder in dit artikel zijn vermeld.

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

Als u het Databricks SQL-stuurprogramma voor Go wilt verifiëren met de NewConnector functie, moet u eerst het volgende toevoegen aan uw import declaratie:

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

Gebruik vervolgens het volgende codefragment en het codevoorbeeld in Verbinding maken met de functie NewConnector. Hierbij wordt ervan uitgegaan dat u de volgende omgevingsvariabelen hebt ingesteld:

  • DATABRICKS_SERVER_HOSTNAMEingesteld op de serverhostnaamwaarde voor uw cluster of SQL Warehouse.
  • DATABRICKS_HTTP_PATH, ingesteld op HTTP-padwaarde voor uw cluster of SQL Warehouse.

Als u omgevingsvariabelen wilt instellen, raadpleegt u de documentatie van uw besturingssysteem.

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),
)

OAuth-verificatie van machine-naar-machine (M2M)

Databricks SQL-stuurprogramma voor Go-versies 1.5.2 en hoger ondersteunen OAuth-verificatie van machine-naar-machine (M2M).

Als u het Databricks SQL-stuurprogramma voor Go wilt gebruiken met OAuth M2M-verificatie, moet u het volgende doen:

  1. Maak een Azure Databricks-service-principal in uw Azure Databricks-werkruimte en maak een OAuth-geheim voor die service-principal.

    Zie Een service-principal gebruiken om te verifiëren met Azure Databricks om de service-principal en het bijbehorende OAuth-geheim te maken. Noteer de UUID- of toepassings-id van de service-principal en de geheime waarde voor het OAuth-geheim van de service-principal.

  2. Geef die service-principal toegang tot uw cluster of magazijn.

    Als u de service-principal toegang wilt geven tot uw cluster of magazijn, raadpleegt u Compute-machtigingen of beheert u een SQL-warehouse.

Als u het Databricks SQL-stuurprogramma voor Go wilt verifiëren met een DSN-verbindingsreeks en het codevoorbeeld in Verbinding maken met een DSN-verbindingsreeks, gebruikt u de volgende DSN-verbindingsreeks syntaxis, waarbij:

  • <server-hostname> is de serverhostnaamwaarde van de vereisten.
  • <port-number> is de poortwaarde van de vereisten. Dit is doorgaans 443.
  • <http-path> is de HTTP-padwaarde van de vereisten.
  • <client-id>is de UUID- of toepassings-id van de service-principal.
  • <client-secret> is de geheime waarde voor het OAuth-geheim van de service-principal.

U kunt ook een of meer optionele parameters toevoegen die eerder in dit artikel zijn vermeld.

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

Als u het Databricks SQL-stuurprogramma voor Go wilt verifiëren met de NewConnector functie, moet u eerst het volgende toevoegen aan uw import declaratie:

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

Gebruik vervolgens het volgende codefragment en het codevoorbeeld in Verbinding maken met de functie NewConnector. Hierbij wordt ervan uitgegaan dat u de volgende omgevingsvariabelen hebt ingesteld:

  • DATABRICKS_SERVER_HOSTNAMEingesteld op de serverhostnaamwaarde voor uw cluster of SQL Warehouse.
  • DATABRICKS_HTTP_PATH, ingesteld op HTTP-padwaarde voor uw cluster of SQL Warehouse.
  • DATABRICKS_CLIENT_ID, ingesteld op de UUID- of toepassings-id van de service-principal.
  • DATABRICKS_CLIENT_SECRET, ingesteld op de geheime waarde voor het OAuth-geheim van de service-principal.

Als u omgevingsvariabelen wilt instellen, raadpleegt u de documentatie van uw besturingssysteem.

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),
)

Querygegevens

In het volgende codevoorbeeld ziet u hoe u het Databricks SQL-stuurprogramma voor Go aanroept om een eenvoudige SQL-query uit te voeren op een Azure Databricks-rekenresource. Met deze opdracht worden de eerste twee rijen uit de trips tabel in het schema van nyctaxi de samples catalogus geretourneerd.

In dit codevoorbeeld wordt de DSN-verbindingsreeks opgehaald uit een omgevingsvariabele met de naam 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)
  }
}

Bestanden beheren in Unity Catalog-volumes

Met het Databricks SQL-stuurprogramma kunt u lokale bestanden schrijven naar Unity Catalog-volumes, bestanden downloaden van volumes en bestanden verwijderen uit volumes, zoals wordt weergegeven in het volgende voorbeeld:

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()
}

Logboekregistratie

Gebruik github.com/databricks/databricks-sql-go/logger dit om berichten te registreren die door het Databricks SQL-stuurprogramma voor Go worden verzonden. In het volgende codevoorbeeld wordt een sql.Open() databasehandler gemaakt via een DSN-verbindingsreeks. In dit codevoorbeeld wordt de DSN-verbindingsreeks opgehaald uit een omgevingsvariabele met de naam DATABRICKS_DSN. Alle logboekberichten die op het debug niveau en hieronder worden verzonden, worden naar het results.log bestand geschreven.

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)
  }
}

Testen

Als u uw code wilt testen, gebruikt u Go-testframeworks zoals de teststandaardbibliotheek . Als u uw code wilt testen onder gesimuleerde omstandigheden zonder Azure Databricks REST API-eindpunten aan te roepen of de status van uw Azure Databricks-accounts of -werkruimten te wijzigen, gebruikt u Go-mockingbibliotheken zoals getuigen.

Bijvoorbeeld, op basis van het volgende bestand met de naam helpers.go een functie die een GetDBWithDSNPAT Azure Databricks-werkruimteverbinding retourneert, een GetNYCTaxiTrips functie die gegevens uit de trips tabel in het schema van nyctaxi de samples catalogus retourneert en een PrintNYCTaxiTrips functie waarmee de geretourneerde gegevens worden afgedrukt:

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 " + strconv.Itoa(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)
  }
}

En gezien het volgende bestand met de naam main.go die deze functies aanroept:

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)
}

Het volgende bestand met de naam helpers_test.go test of de GetNYCTaxiTrips functie het verwachte antwoord retourneert. In plaats van een echte verbinding met de doelwerkruimte te maken, wordt met deze test een sql.DB object gesimuleerd. Met de test worden ook enkele gegevens gesimuleerd die voldoen aan het schema en de waarden die zich in de echte gegevens bevinden. De test retourneert de gesimuleerde gegevens via de gesimuleerde verbinding en controleert vervolgens of een van de gesimuleerde gegevensrijen overeenkomt met de verwachte waarde.

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)
}

Omdat de GetNYCTaxiTrips functie een SELECT instructie bevat en daarom de status van de trips tabel niet wijzigt, is mocking niet absoluut vereist in dit voorbeeld. Met mocking kunt u uw tests echter snel uitvoeren zonder te wachten tot er een werkelijke verbinding met de werkruimte is gemaakt. Met mocking kunt u ook meerdere keren gesimuleerde tests uitvoeren voor functies die de status van een tabel kunnen wijzigen, zoals INSERT INTO, UPDATEen DELETE FROM.

Aanvullende bronnen