Databricks SQL-drivrutin för Go

Artikel
09/26/2024

Databricks SQL Driver for Go är ett Go-bibliotek som gör att du kan använda Go-kod för att köra SQL-kommandon på Azure Databricks-beräkningsresurser. Den här artikeln kompletterar Databricks SQL-drivrutinen för Go README, API-referens och exempel.

Krav

En utvecklingsdator som kör Go version 1.20 eller senare. Om du vill skriva ut den installerade versionen av Go kör du kommandot go version. Ladda ned och installera Go.
Ett befintligt kluster eller SQL-lager.
Värden för servervärdnamn, port och HTTP-sökväg för det befintliga klustret eller SQL-lagret.
- Hämta dessa värden för ett kluster.
- Hämta dessa värden för ett SQL-lager.

Komma igång med Databricks SQL Driver for Go

På utvecklingsdatorn med Go 1.20 eller senare redan installerat och ett befintligt Go-kodprojekt som redan har skapats skapar du en go.mod fil för att spåra Go-kodens beroenden genom att köra go mod init kommandot, till exempel:
```
go mod init sample
```
Ta ett beroende av Databricks SQL Driver for Go-paketet genom att köra go mod edit -require kommandot och ersätta v1.5.2 med den senaste versionen av Databricks SQL Driver for Go-paketet enligt beskrivningen i versionerna:
```
go mod edit -require github.com/databricks/databricks-sql-go@v1.5.2
```
Filen go.mod bör nu se ut så här:
```
module sample

go 1.20

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

I projektet skapar du en Go-kodfil som importerar Databricks SQL-drivrutinen för Go. I följande exempel, i en fil med namnet main.go med följande innehåll, visas alla kluster på din Azure Databricks-arbetsyta:

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

Lägg till eventuella modulberoenden som saknas genom att go mod tidy köra kommandot:
```
go mod tidy
```
Kommentar

Om du får felet go: warning: "all" matched no packageshar du glömt att lägga till en Go-kodfil som importerar Databricks SQL-drivrutinen för Go.
Gör kopior av alla paket som behövs för att stödja versioner och tester av paket i modulen main genom att go mod vendor köra kommandot:
```
go mod vendor
```
Ändra koden efter behov för att ange DATABRICKS_DSN miljövariabeln för Azure Databricks-autentisering. Se även Ansluta med en DSN-anslutningssträng.
Kör din Go-kodfil, förutsatt att en fil med namnet main.go, genom att go run köra kommandot:
```
go run main.go
```
Om inga fel returneras har du autentiserat Databricks SQL Driver for Go med din Azure Databricks-arbetsyta och anslutit till ditt Azure Databricks-kluster eller SQL-lager som körs på den arbetsytan.

Ansluta med en DSN-anslutningssträng

Om du vill komma åt kluster och SQL-lager använder du sql.Open() för att skapa en databasreferens via ett DSN-anslutningssträng. Det här kodexemplet hämtar DSN-anslutningssträng från en miljövariabel med namnet DATABRICKS_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)
  }
}

Information om hur du anger DSN-anslutningssträng i rätt format finns i DSN-anslutningssträng exempel i Autentisering. För personlig åtkomsttokenautentisering i Azure Databricks använder du till exempel följande syntax, där:

<personal-access-token> är din personliga åtkomsttoken för Azure Databricks från kraven.
<server-hostname> är värdet servervärdnamn från kraven.
<port-number>är portvärdet från kraven, vilket vanligtvis 443är .
<http-path> är värdet för HTTP-sökvägen från kraven.
<paramX=valueX> är en eller flera valfria parametrar som anges senare i den här artikeln.

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

Till exempel för ett kluster:

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

Till exempel för ett SQL-lager:

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

Kommentar

Som bästa säkerhet bör du inte hårdkoda den här DSN-anslutningssträng i Din Go-kod. I stället bör du hämta DSN-anslutningssträng från en säker plats. Kodexemplet tidigare i den här artikeln använde till exempel en miljövariabel.

Valfria parametrar

Valfria anslutningsparametrar som stöds kan anges i <param=value>. Några av de vanligaste är:
- catalog: Anger det första katalognamnet i sessionen.
- schema: Anger det första schemanamnet i sessionen.
- maxRows: Konfigurerar det maximala antalet rader som hämtas per begäran. Standardvärdet är 10000.
- timeout: Lägger till tidsgränsen (i sekunder) för serverfrågekörningen. Standardvärdet är ingen tidsgräns.
- userAgentEntry: Används för att identifiera partner. Mer information finns i din partners dokumentation.
Valfria sessionsparametrar som stöds kan anges i param=value. Några av de vanligaste är:
- ansi_mode: En boolesk sträng. true för sessionsinstruktioner för att följa regler som anges i ANSI SQL-specifikationen. Systemstandarden är false.
- timezone: En sträng, till exempel America/Los_Angeles. Anger tidszonen för sessionen. Systemstandarden är UTC.

Till exempel för ett SQL-lager:

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

Anslut med `NewConnector` funktionen

Du kan också använda sql.OpenDB() för att skapa en databasreferens via ett nytt anslutningsobjekt som skapas med dbsql.NewConnector() (anslutning till Azure Databricks-kluster och SQL-lager med ett nytt anslutningsobjekt kräver v1.0.0 eller senare av Databricks SQL Driver for Go). Till exempel:

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

Information om hur du anger rätt uppsättning NewConnector inställningar finns i exemplen i Autentisering.

Kommentar

Som bästa säkerhet bör du inte hårdkoda NewConnector inställningarna i Go-koden. I stället bör du hämta dessa värden från en säker plats. I föregående kod används till exempel miljövariabler.

Några av de mer använda funktionsalternativen är:

WithAccessToken(<access-token>): Din personliga Åtkomsttoken för Azure Databricks från kraven. Krävs string.
WithServerHostname(<server-hostname>): Värdet servervärdnamn från kraven. Krävs string.
WithPort(<port>): Serverns portnummer, vanligtvis 443. Krävs int.
WithHTTPPath(<http-path>): VÄRDET FÖR HTTP-sökväg från kraven. Krävs string.
WithInitialNamespace(<catalog>, <schema>):Katalog- och schemanamnet i sessionen. Valfrittstring, string.
WithMaxRows(<max-rows>): Det maximala antalet rader som hämtas per begäran. Standardvärdet är 10000. Valfritt int.
WithSessionParams(<params-map>): Sessionsparametrarna inklusive "tidszon" och "ansi_mode". Valfrittmap[string]string.
WithTimeout(<timeout>). Tidsgränsen (i time.Duration) för serverfrågekörningen. Standardvärdet är ingen tidsgräns. Valfritt.
WithUserAgentEntry(<isv-name-plus-product-name>). Används för att identifiera partner. Mer information finns i din partners dokumentation. Valfrittstring.

Till exempel:

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

Autentisering

Databricks SQL Driver for Go stöder följande Azure Databricks-autentiseringstyper:

Autentisering med personlig åtkomsttoken för Databricks
Microsoft Entra ID-tokenautentisering
OAuth-autentisering från användare till dator (U2M)
OAuth-autentisering från dator till dator (M2M)

Databricks SQL Driver for Go stöder ännu inte följande Azure Databricks-autentiseringstyper:

Autentisering med personlig åtkomsttoken för Databricks

Om du vill använda Databricks SQL Driver for Go med personlig åtkomsttokenautentisering i Azure Databricks måste du först skapa en personlig åtkomsttoken för Azure Databricks enligt följande:

I din Azure Databricks-arbetsyta klickar du på ditt Användarnamn för Azure Databricks i det övre fältet och väljer sedan Inställningar i listrutan.
Klicka på Utvecklare.
Bredvid Åtkomsttoken klickar du på Hantera.
Klicka på Generera ny token.
(Valfritt) Ange en kommentar som hjälper dig att identifiera den här token i framtiden och ändra tokens standardlivslängd på 90 dagar. Om du vill skapa en token utan livslängd (rekommenderas inte) lämnar du rutan Livslängd (dagar) tom (tom).
Klicka på Generera.
Kopiera den visade token till en säker plats och klicka sedan på Klar.

Kommentar

Se till att spara den kopierade token på en säker plats. Dela inte din kopierade token med andra. Om du förlorar den kopierade token kan du inte återskapa exakt samma token. I stället måste du upprepa den här proceduren för att skapa en ny token. Om du förlorar den kopierade token eller om du tror att token har komprometterats rekommenderar Databricks starkt att du omedelbart tar bort den token från arbetsytan genom att klicka på papperskorgsikonen (Återkalla) bredvid token på sidan Åtkomsttoken .

Om du inte kan skapa eller använda token på din arbetsyta kan det bero på att arbetsyteadministratören har inaktiverat token eller inte har gett dig behörighet att skapa eller använda token. Se administratören för arbetsytan eller följande avsnitt:

Om du vill autentisera Databricks SQL Driver for Go med en DSN-anslutningssträng och kodexemplet i Anslut med en DSN-anslutningssträng använder du följande DSN-anslutningssträng syntax, där:

<personal-access-token> är din personliga åtkomsttoken för Azure Databricks från kraven.
<server-hostname> är värdet servervärdnamn från kraven.
<port-number>är portvärdet från kraven, vilket vanligtvis 443är .
<http-path> är värdet för HTTP-sökvägen från kraven.

Du kan också lägga till en eller flera valfria parametrar som anges tidigare i den här artikeln.

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

Om du vill autentisera Databricks SQL Driver for Go med NewConnector funktionen använder du följande kodfragment och kodexemplet i Anslut med funktionen NewConnector, som förutsätter att du har angett följande miljövariabler:

DATABRICKS_SERVER_HOSTNAMEange värdet servervärdnamn för klustret eller SQL-lagret.
DATABRICKS_HTTP_PATHanger du till HTTP-sökvägsvärde för klustret eller SQL-lagret.
DATABRICKS_TOKEN, inställt på den personliga åtkomsttoken för Azure Databricks.

Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.

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

Microsoft Entra ID-tokenautentisering

Databricks SQL Driver for Go stöder Microsoft Entra ID-token för en Azure Databricks-användare eller ett Microsoft Entra ID-tjänsthuvudnamn.

Gör följande för att skapa en Microsoft Entra ID-åtkomsttoken:

För en Azure Databricks-användare kan du använda Azure CLI. Se Hämta Microsoft Entra-ID-token för användare med hjälp av Azure CLI.
- Ett microsoft entra-ID-tjänsthuvudnamn finns i Hämta en Microsoft Entra ID-åtkomsttoken med Azure CLI. Information om hur du skapar ett microsoft entra-ID för hanterad tjänsthuvudnamn finns i Hantera tjänstens huvudnamn.
Microsoft Entra-ID-token har en standardlivslängd på cirka 1 timme. Om du vill skapa en ny Microsoft Entra-ID-token upprepar du den här processen.

Om du vill autentisera Databricks SQL Driver for Go med en DSN-anslutningssträng och kodexemplet i Anslut med en DSN-anslutningssträng använder du följande DSN-anslutningssträng syntax, där:
- <microsoft-entra-id-token> är din Microsoft Entra ID-token.
- <server-hostname> är värdet servervärdnamn från kraven.
- <port-number>är portvärdet från kraven, vilket vanligtvis 443är .
- <http-path> är värdet för HTTP-sökvägen från kraven.
Du kan också lägga till en eller flera valfria parametrar som anges tidigare i den här artikeln.
```
token:<microsoft-entra-id-token>@<server-hostname>:<port-number>/<http-path>
```
Om du vill autentisera Databricks SQL Driver for Go med NewConnector funktionen använder du följande kodfragment och kodexemplet i Anslut med funktionen NewConnector, som förutsätter att du har angett följande miljövariabler:
- DATABRICKS_SERVER_HOSTNAMEange värdet servervärdnamn för klustret eller SQL-lagret.
- DATABRICKS_HTTP_PATHanger du till HTTP-sökvägsvärde för klustret eller SQL-lagret.
- DATABRICKS_TOKEN, ange till din Microsoft Entra-ID-token.
Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.
```
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-autentisering från användare till dator (U2M)

Databricks SQL Driver for Go version 1.5.0 och senare stöder OAuth-autentisering från användare till dator (U2M).

Om du vill använda Databricks SQL Driver for Go med en DSN-anslutningssträng och kodexemplet i Anslut med en DSN-anslutningssträng använder du följande DSN-anslutningssträng syntax, där:

<server-hostname> är värdet servervärdnamn från kraven.
<port-number>är portvärdet från kraven, vilket vanligtvis 443är .
<http-path> är värdet för HTTP-sökvägen från kraven.

Du kan också lägga till en eller flera valfria parametrar som anges tidigare i den här artikeln.

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

Om du vill autentisera Databricks SQL Driver for Go med NewConnector funktionen måste du först lägga till följande i import deklarationen:

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

Använd sedan följande kodfragment och kodexemplet i Anslut med funktionen NewConnector, som förutsätter att du har angett följande miljövariabler:

DATABRICKS_SERVER_HOSTNAMEange värdet servervärdnamn för klustret eller SQL-lagret.
DATABRICKS_HTTP_PATHanger du till HTTP-sökvägsvärde för klustret eller SQL-lagret.

Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.

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-autentisering från dator till dator (M2M)

Databricks SQL Driver för Go-versionerna 1.5.2 och senare stöder OAuth-autentisering från dator till dator (M2M).

Om du vill använda Databricks SQL Driver for Go med OAuth M2M-autentisering måste du göra följande:

Skapa ett Huvudnamn för Azure Databricks-tjänsten på din Azure Databricks-arbetsyta och skapa en OAuth-hemlighet för tjänstens huvudnamn.

Information om hur du skapar tjänstens huvudnamn och dess OAuth-hemlighet finns i Autentisera åtkomst till Azure Databricks med ett huvudnamn för tjänsten med OAuth (OAuth M2M). Anteckna tjänstens huvudnamns UUID - eller program-ID-värde och det hemliga värdet för tjänstens huvudnamns OAuth-hemlighet.
Ge tjänstens huvudnamn åtkomst till klustret eller informationslagret.

Information om hur du ger tjänstens huvudnamn åtkomst till klustret eller informationslagret finns i Beräkningsbehörigheter eller Hantera ett SQL-lager.

Om du vill autentisera Databricks SQL Driver for Go med en DSN-anslutningssträng och kodexemplet i Anslut med en DSN-anslutningssträng använder du följande DSN-anslutningssträng syntax, där:

<server-hostname> är värdet servervärdnamn från kraven.
<port-number>är portvärdet från kraven, vilket vanligtvis 443är .
<http-path> är värdet för HTTP-sökvägen från kraven.
<client-id> är tjänstens huvudnamns UUID - eller program-ID-värde .
<client-secret>är hemlighetsvärdet för tjänstens huvudnamns OAuth-hemlighet.

Du kan också lägga till en eller flera valfria parametrar som anges tidigare i den här artikeln.

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

Om du vill autentisera Databricks SQL Driver for Go med NewConnector funktionen måste du först lägga till följande i import deklarationen:

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

Använd sedan följande kodfragment och kodexemplet i Anslut med funktionen NewConnector, som förutsätter att du har angett följande miljövariabler:

DATABRICKS_SERVER_HOSTNAMEange värdet servervärdnamn för klustret eller SQL-lagret.
DATABRICKS_HTTP_PATHanger du till HTTP-sökvägsvärde för klustret eller SQL-lagret.
DATABRICKS_CLIENT_ID, inställt på tjänstens huvudnamns UUID - eller program-ID-värde .
DATABRICKS_CLIENT_SECRET, ange värdet Hemlig för tjänstens huvudnamns OAuth-hemlighet.

Information om hur du anger miljövariabler finns i dokumentationen till operativsystemet.

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

Fråga efter data

Följande kodexempel visar hur du anropar Databricks SQL Driver for Go för att köra en grundläggande SQL-fråga på en Azure Databricks-beräkningsresurs. Det här kommandot returnerar de två första raderna trips från tabellen i samples katalogens nyctaxi schema.

Det här kodexemplet hämtar DSN-anslutningssträng från en miljövariabel med namnet 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)
  }
}

Hantera filer i Unity Catalog-volymer

Med Databricks SQL Driver kan du skriva lokala filer till Unity Catalog-volymer, ladda ned filer från volymer och ta bort filer från volymer, enligt följande exempel:

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

Loggning

Används github.com/databricks/databricks-sql-go/logger för att logga meddelanden som Databricks SQL Driver for Go genererar. I följande kodexempel används sql.Open() för att skapa en databasreferens via en DSN-anslutningssträng. Det här kodexemplet hämtar DSN-anslutningssträng från en miljövariabel med namnet DATABRICKS_DSN. Alla loggmeddelanden som genereras på debug nivån och nedan skrivs results.log till filen.

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

Testning

Om du vill testa koden använder du Go-testramverk som standardbiblioteket för testning . Om du vill testa koden under simulerade förhållanden utan att anropa Azure Databricks REST API-slutpunkter eller ändra tillståndet för dina Azure Databricks-konton eller arbetsytor använder du Go mocking-bibliotek som testfify.

Till exempel med följande fil med namnet helpers.go som innehåller en GetDBWithDSNPAT funktion som returnerar en Azure Databricks-arbetsyteanslutning, en GetNYCTaxiTrips funktion som returnerar data från trips tabellen i samples katalogens nyctaxi schema och en PrintNYCTaxiTrips som skriver ut returnerade 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 " + 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)
  }
}

Och med följande fil med namnet main.go som anropar dessa funktioner:

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

Följande fil med namnet helpers_test.go testar om GetNYCTaxiTrips funktionen returnerar det förväntade svaret. I stället för att skapa en verklig anslutning till målarbetsytan hånar det här testet ett sql.DB objekt. Testet hånar också vissa data som överensstämmer med schemat och värdena som finns i verkliga data. Testet returnerar de simulerade data via den simulerade anslutningen och kontrollerar sedan om ett av de simulerade dataradernas värden matchar det förväntade värdet.

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

GetNYCTaxiTrips Eftersom funktionen innehåller en SELECT -instruktion och därför inte ändrar tabellens trips tillstånd är det inte absolut nödvändigt att håna i det här exemplet. Men genom att håna kan du snabbt köra dina tester utan att vänta på att en faktisk anslutning ska göras med arbetsytan. Genom att håna kan du också köra simulerade tester flera gånger för funktioner som kan ändra en tabells tillstånd, till exempel INSERT INTO, UPDATEoch DELETE FROM.

Ytterligare resurser

Databricks SQL Driver for Go-lagringsplatsen på GitHub
Startsidan för databas-/sql-paket
Databricks SQL Driver for Go-exempel på GitHub

Dela via

Databricks SQL-drivrutin för Go

Krav

Komma igång med Databricks SQL Driver for Go

Ansluta med en DSN-anslutningssträng

Valfria parametrar

Anslut med `NewConnector` funktionen

Autentisering

Autentisering med personlig åtkomsttoken för Databricks

Microsoft Entra ID-tokenautentisering

OAuth-autentisering från användare till dator (U2M)

OAuth-autentisering från dator till dator (M2M)

Fråga efter data

Hantera filer i Unity Catalog-volymer

Loggning

Testning

Ytterligare resurser

Feedback

Ytterligare resurser

Dela via

Databricks SQL-drivrutin för Go

Krav

Komma igång med Databricks SQL Driver for Go

Ansluta med en DSN-anslutningssträng

Valfria parametrar

Anslut med NewConnector funktionen

Autentisering

Autentisering med personlig åtkomsttoken för Databricks

Microsoft Entra ID-tokenautentisering

OAuth-autentisering från användare till dator (U2M)

OAuth-autentisering från dator till dator (M2M)

Fråga efter data

Hantera filer i Unity Catalog-volymer

Loggning

Testning

Ytterligare resurser

Feedback

Ytterligare resurser

Anslut med `NewConnector` funktionen