Sterownik SQL usługi Databricks dla języka Go

Sterownik SQL usługi Databricks dla języka Go to biblioteka języka Go, która umożliwia uruchamianie poleceń SQL w zasobach obliczeniowych usługi Azure Databricks za pomocą kodu Języka Go. Ten artykuł uzupełnia sterownik SQL usługi Databricks dla języka Go README, dokumentacja interfejsu API i przykłady.

Wymagania

• Maszyna deweloperna z systemem Go w wersji 1.20 lub nowszej. Aby wydrukować zainstalowaną wersję języka Go, uruchom polecenie go version. Pobierz i zainstaluj język Go.
• Istniejący klaster lub magazyn SQL Warehouse.
• Wartości Nazwa hosta serwera, Port i Ścieżka HTTP dla istniejącego klastra lub usługi SQL Warehouse.
  • Pobierz te wartości dla klastra.
  • Pobierz te wartości dla usługi SQL Warehouse.

Wprowadzenie do sterownika SQL usługi Databricks dla języka Go

1. Na maszynie deweloperskiej z już zainstalowanym programem Go w wersji 1.20 lub nowszej, a istniejący projekt kodu Języka Go został już utworzony, utwórz go.mod plik w celu śledzenia zależności kodu języka Go, uruchamiając go mod init polecenie, na przykład:

   go mod init sample
   

2. Pobierz zależność od pakietu SQL Driver for Go usługi Databricks, uruchamiając go mod edit -require v1.5.2 polecenie, zastępując element najnowszą wersją pakietu SQL Driver for Go usługi Databricks, jak pokazano w wersjach:

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

   Plik go.mod powinien teraz wyglądać następująco:

   module sample
   
   go 1.20
   
   require github.com/databricks/databricks-sql-go v1.5.2
   

3. W projekcie utwórz plik kodu Języka Go, który importuje sterownik SQL usługi Databricks dla języka Go. Poniższy przykład w pliku o nazwie o następującej main.go zawartości zawiera listę wszystkich klastrów w obszarze roboczym usługi 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)
     }
   }
   

4. Dodaj wszystkie brakujące zależności modułu go mod tidy , uruchamiając polecenie :

   go mod tidy
   

   Uwaga

   Jeśli wystąpi błąd go: warning: "all" matched no packages, nie pamiętasz dodania pliku kodu Języka Go, który importuje sterownik SQL usługi Databricks dla języka Go.

5. Utwórz kopie wszystkich pakietów wymaganych do obsługi kompilacji i testów pakietów w main module, uruchamiając go mod vendor polecenie :

   go mod vendor
   

6. Zmodyfikuj kod zgodnie z potrzebami, aby ustawić zmienną DATABRICKS_DSN środowiskową na potrzeby uwierzytelniania usługi Azure Databricks. Zobacz też Nawiązywanie połączenia za pomocą parametry połączenia DSN.

7. Uruchom plik kodu języka Go, zakładając, że plik o nazwie main.go, uruchamiając go run polecenie :

   go run main.go
   

8. Jeśli nie zostaną zwrócone żadne błędy, pomyślnie uwierzytelniono sterownik SQL usługi Databricks dla języka Go przy użyciu obszaru roboczego usługi Azure Databricks i nawiązano połączenie z uruchomionym klastrem usługi Azure Databricks lub usługą SQL Warehouse w tym obszarze roboczym.

Nawiązywanie połączenia za pomocą parametry połączenia DSN

Aby uzyskać dostęp do klastrów i magazynów SQL, użyj polecenia sql.Open() , aby utworzyć dojście bazy danych za pośrednictwem parametry połączenia nazwy źródła danych (DSN). Ten przykład kodu pobiera parametry połączenia DSN ze zmiennej środowiskowej o nazwie 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)
  }
}

Aby określić parametry połączenia DSN w poprawnym formacie, zobacz przykłady parametry połączenia DSN w temacie Authentication (Uwierzytelnianie). Na przykład w przypadku uwierzytelniania osobistego tokenu dostępu usługi Azure Databricks użyj następującej składni, gdzie:

• <personal-access-token> to osobisty token dostępu usługi Azure Databricks z wymagań.
• <server-hostname>to wartość Nazwa hosta serwera z wymagań.
• <port-number>to wartość Port z wymagań, czyli zazwyczaj 443.
• <http-path>jest wartością ścieżki HTTP z wymagań.
• <paramX=valueX> jest co najmniej jednym parametrem opcjonalnym wymienionym w dalszej części tego artykułu.

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

Na przykład w przypadku klastra:

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

Na przykład w przypadku usługi SQL Warehouse:

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

Uwaga

Najlepszym rozwiązaniem w zakresie zabezpieczeń nie powinno być zakodowanie tej parametry połączenia DSN w kodzie języka Go. Zamiast tego należy pobrać tę parametry połączenia DSN z bezpiecznej lokalizacji. Na przykład przykład kodu wcześniej w tym artykule użyto zmiennej środowiskowej.

Parametry opcjonalne

• Obsługiwane opcjonalne parametry połączenia można określić w pliku <param=value>. Niektóre z najczęściej używanych elementów to:
  • catalog: Ustawia początkową nazwę katalogu w sesji.
  • schema: Ustawia początkową nazwę schematu w sesji.
  • maxRows: Konfiguruje maksymalną liczbę wierszy pobranych na żądanie. Wartość domyślna to 10000.
  • timeout: dodaje limit czasu (w sekundach) dla wykonywania zapytania serwera. Wartość domyślna to brak limitu czasu.
  • userAgentEntry: służy do identyfikowania partnerów. Aby uzyskać więcej informacji, zobacz dokumentację partnera.
• Obsługiwane parametry sesji opcjonalnej można określić w pliku param=value. Niektóre z najczęściej używanych elementów to:
  • ansi_mode: ciąg logiczny. true instrukcje sesji zgodne z regułami określonymi przez specyfikację ANSI SQL. Wartość domyślna systemu to false.
  • timezone: ciąg, na przykład America/Los_Angeles. Ustawia strefę czasową sesji. Domyślną wartością systemu jest UTC.

Na przykład w przypadku usługi 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

Nawiązywanie połączenia z funkcją NewConnector

Alternatywnie użyj polecenia sql.OpenDB() , aby utworzyć dojście bazy danych za pomocą nowego obiektu łącznika utworzonego dbsql.NewConnector() za pomocą programu (nawiązywanie połączenia z klastrami usługi Azure Databricks i magazynami SQL z nowym obiektem łącznika wymaga wersji 1.0.0 lub nowszej sterownika SQL usługi Databricks dla języka Go). Na przykład:

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

Aby określić prawidłowy zestaw NewConnector ustawień, zobacz przykłady w temacie Authentication (Uwierzytelnianie).

Uwaga

Najlepszym rozwiązaniem w zakresie zabezpieczeń nie powinno być zakodowanie NewConnector ustawień w kodzie języka Go. Zamiast tego należy pobrać te wartości z bezpiecznej lokalizacji. Na przykład powyższy kod używa zmiennych środowiskowych.

Niektóre z najczęściej używanych opcji funkcjonalnych to:

• WithAccessToken(<access-token>): Osobisty token dostępu usługi Azure Databricks z wymagań. Wymagane .string
• WithServerHostname(<server-hostname>): wartość Nazwa hosta serwera z wymagań. Wymagane .string
• WithPort(<port>): numer portu serwera, zazwyczaj 443. Wymagane .int
• WithHTTPPath(<http-path>): wartość ścieżka HTTP z wymagań. Wymagane .string
• WithInitialNamespace(<catalog>, <schema>):Nazwa wykazu i schematu w sesji. Opcjonalnystring, string.
• WithMaxRows(<max-rows>): maksymalna liczba wierszy pobranych na żądanie. Wartość domyślna to 10000. Opcjonalne int.
• WithSessionParams(<params-map>): parametry sesji, w tym "strefa czasowa" i "ansi_mode". Opcjonalnymap[string]string.
• WithTimeout(<timeout>). Limit czasu (w ) time.Durationdla wykonywania zapytania serwera. Wartość domyślna to brak limitu czasu. Opcjonalny.
• WithUserAgentEntry(<isv-name-plus-product-name>). Służy do identyfikowania partnerów. Aby uzyskać więcej informacji, zobacz dokumentację partnera. Opcjonalnystring.

Na przykład:

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

Uwierzytelnianie

Sterownik SQL usługi Databricks dla języka Go obsługuje następujące typy uwierzytelniania usługi Azure Databricks:

• Uwierzytelnianie osobistego tokenu dostępu usługi Databricks
• Uwierzytelnianie tokenu identyfikatora entra firmy Microsoft
• Uwierzytelnianie typu użytkownik-komputer (U2M) OAuth
• Uwierzytelnianie OAuth między maszynami (M2M)

Sterownik SQL usługi Databricks dla języka Go nie obsługuje jeszcze następujących typów uwierzytelniania usługi Azure Databricks:

• Uwierzytelnianie tożsamości zarządzanych platformy Azure
• Uwierzytelnianie jednostki usługi MS Entra
• Uwierzytelnianie interfejsu wiersza polecenia platformy Azure

Uwierzytelnianie osobistego tokenu dostępu usługi Databricks

Aby użyć sterownika SQL usługi Databricks dla języka Go z uwierzytelnianiem osobistego tokenu dostępu usługi Azure Databricks, należy najpierw utworzyć osobisty token dostępu usługi Azure Databricks w następujący sposób:

1. W obszarze roboczym usługi Azure Databricks kliknij nazwę użytkownika usługi Azure Databricks na górnym pasku, a następnie wybierz pozycję Ustawienia z listy rozwijanej.
2. Kliknij pozycję Deweloper.
3. Obok pozycji Tokeny dostępu kliknij pozycję Zarządzaj.
4. Kliknij pozycję Generuj nowy token.
5. (Opcjonalnie) Wprowadź komentarz, który pomaga zidentyfikować ten token w przyszłości i zmienić domyślny okres istnienia tokenu na 90 dni. Aby utworzyć token bez okresu istnienia (niezalecane), pozostaw puste pole Okres istnienia (dni) (puste).
6. Kliknij pozycję Generate (Generuj).
7. Skopiuj wyświetlony token do bezpiecznej lokalizacji, a następnie kliknij przycisk Gotowe.

Uwaga

Pamiętaj, aby zapisać skopiowany token w bezpiecznej lokalizacji. Nie udostępniaj skopiowanego tokenu innym osobom. W przypadku utraty skopiowanego tokenu nie można wygenerować tego samego tokenu. Zamiast tego należy powtórzyć tę procedurę, aby utworzyć nowy token. Jeśli utracisz skopiowany token lub uważasz, że token został naruszony, usługa Databricks zdecydowanie zaleca natychmiastowe usunięcie tego tokenu z obszaru roboczego, klikając ikonę kosza (Odwołaj) obok tokenu na stronie Tokeny dostępu.

Jeśli nie możesz utworzyć lub użyć tokenów w obszarze roboczym, może to być spowodowane tym, że administrator obszaru roboczego wyłączył tokeny lub nie udzielił Ci uprawnień do tworzenia lub używania tokenów. Zapoznaj się z administratorem obszaru roboczego lub następującymi tematami:

• Włączanie lub wyłączanie uwierzytelniania osobistego tokenu dostępu dla obszaru roboczego
• Uprawnienia osobistego tokenu dostępu

Aby uwierzytelnić sterownik SQL usługi Databricks dla języka Go przy użyciu parametry połączenia DSN i przykład kodu w temacie Nawiązywanie połączenia z parametry połączenia DSN, użyj następującej składni parametry połączenia DSN, gdzie:

• <personal-access-token> to osobisty token dostępu usługi Azure Databricks z wymagań.
• <server-hostname>to wartość Nazwa hosta serwera z wymagań.
• <port-number>to wartość Port z wymagań, czyli zazwyczaj 443.
• <http-path>jest wartością ścieżki HTTP z wymagań.

Możesz również dołączyć jeden lub więcej parametrów opcjonalnych wymienionych wcześniej w tym artykule.

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

Aby uwierzytelnić sterownik SQL usługi Databricks dla języka Go za NewConnector pomocą funkcji, użyj następującego fragmentu kodu i przykładowego kodu w artykule Connect with the NewConnector function (Połącz z funkcją NewConnector), która zakłada, że ustawiono następujące zmienne środowiskowe:

• DATABRICKS_SERVER_HOSTNAMEustaw wartość Nazwa hosta serwera dla klastra lub usługi SQL Warehouse.
• DATABRICKS_HTTP_PATH, ustaw wartość ścieżka HTTP dla klastra lub usługi SQL Warehouse.
• DATABRICKS_TOKEN, ustaw na osobisty token dostępu usługi Azure Databricks.

Aby ustawić zmienne środowiskowe, zapoznaj się z dokumentacją systemu operacyjnego.

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

Uwierzytelnianie tokenu identyfikatora entra firmy Microsoft

Sterownik SQL usługi Databricks dla języka Go obsługuje tokeny identyfikatora Entra firmy Microsoft dla użytkownika usługi Azure Databricks lub jednostki usługi Microsoft Entra ID.

Aby utworzyć token dostępu microsoft Entra ID, wykonaj następujące czynności:

• W przypadku użytkownika usługi Azure Databricks możesz użyć interfejsu wiersza polecenia platformy Azure. Zobacz Uzyskiwanie tokenów identyfikatora entra firmy Microsoft dla użytkowników przy użyciu interfejsu wiersza polecenia platformy Azure.

  • Aby uzyskać jednostkę usługi Microsoft Entra ID, zobacz Uzyskiwanie tokenu dostępu identyfikatora Entra firmy Microsoft za pomocą interfejsu wiersza polecenia platformy Azure. Aby utworzyć jednostkę usługi zarządzanej identyfikatora entra firmy Microsoft, zobacz Zarządzanie jednostkami usługi.

  Tokeny identyfikatora Entra firmy Microsoft mają domyślny okres istnienia około 1 godziny. Aby utworzyć nowy token identyfikatora Entra firmy Microsoft, powtórz ten proces.

  Aby uwierzytelnić sterownik SQL usługi Databricks dla języka Go przy użyciu parametry połączenia DSN i przykład kodu w temacie Nawiązywanie połączenia z parametry połączenia DSN, użyj następującej składni parametry połączenia DSN, gdzie:

  • <microsoft-entra-id-token> to twój token identyfikatora Entra firmy Microsoft.
  • <server-hostname>to wartość Nazwa hosta serwera z wymagań.
  • <port-number>to wartość Port z wymagań, czyli zazwyczaj 443.
  • <http-path>jest wartością ścieżki HTTP z wymagań.

  Możesz również dołączyć jeden lub więcej parametrów opcjonalnych wymienionych wcześniej w tym artykule.

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

  Aby uwierzytelnić sterownik SQL usługi Databricks dla języka Go za NewConnector pomocą funkcji, użyj następującego fragmentu kodu i przykładowego kodu w artykule Connect with the NewConnector function (Połącz z funkcją NewConnector), która zakłada, że ustawiono następujące zmienne środowiskowe:

  • DATABRICKS_SERVER_HOSTNAMEustaw wartość Nazwa hosta serwera dla klastra lub usługi SQL Warehouse.
  • DATABRICKS_HTTP_PATH, ustaw wartość ścieżka HTTP dla klastra lub usługi SQL Warehouse.
  • DATABRICKS_TOKEN, ustaw wartość tokenu identyfikatora Entra firmy Microsoft.

  Aby ustawić zmienne środowiskowe, zapoznaj się z dokumentacją systemu operacyjnego.

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

Uwierzytelnianie typu użytkownik-komputer (U2M) OAuth

Sterownik SQL usługi Databricks dla języka Go w wersji 1.5.0 lub nowszej obsługuje uwierzytelnianie między użytkownikami protokołu OAuth (U2M).

Aby użyć sterownika SQL usługi Databricks dla języka Go z parametry połączenia DSN i przykładowym kodem w artykule Nawiązywanie połączenia z parametry połączenia DSN, użyj następującej składni parametry połączenia DSN, gdzie:

• <server-hostname>to wartość Nazwa hosta serwera z wymagań.
• <port-number>to wartość Port z wymagań, czyli zazwyczaj 443.
• <http-path>jest wartością ścieżki HTTP z wymagań.

Możesz również dołączyć jeden lub więcej parametrów opcjonalnych wymienionych wcześniej w tym artykule.

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

Aby uwierzytelnić sterownik SQL usługi Databricks dla języka Go za NewConnector pomocą funkcji, należy najpierw dodać następujący kod do import deklaracji:

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

Następnie użyj następującego fragmentu kodu i przykładu kodu w sekcji Connect with the NewConnector function (Połącz z funkcją NewConnector), która zakłada, że ustawiono następujące zmienne środowiskowe:

• DATABRICKS_SERVER_HOSTNAMEustaw wartość Nazwa hosta serwera dla klastra lub usługi SQL Warehouse.
• DATABRICKS_HTTP_PATH, ustaw wartość ścieżka HTTP dla klastra lub usługi SQL Warehouse.

Aby ustawić zmienne środowiskowe, zapoznaj się z dokumentacją systemu operacyjnego.

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

Uwierzytelnianie maszyny do maszyny OAuth (M2M)

Sterownik SQL usługi Databricks dla języka Go w wersji 1.5.2 lub nowszej obsługuje uwierzytelnianie między maszynami OAuth (M2M).

Aby użyć sterownika SQL usługi Databricks dla języka Go z uwierzytelnianiem OAuth M2M, należy wykonać następujące czynności:

1. Utwórz jednostkę usługi Azure Databricks w obszarze roboczym usługi Azure Databricks i utwórz wpis tajny OAuth dla tej jednostki usługi.

   Aby utworzyć jednostkę usługi i jej wpis tajny OAuth, zobacz Uwierzytelnianie dostępu do usługi Azure Databricks przy użyciu jednostki usługi przy użyciu protokołu OAuth (OAuth M2M). Zanotuj wartość UUID lub Identyfikator aplikacji jednostki usługi oraz wartość wpisu tajnego dla wpisu tajnego OAuth jednostki usługi.

2. Nadaj jednostce usługi dostęp do klastra lub magazynu.

   Aby udzielić jednostce usługi dostępu do klastra lub magazynu, zobacz Uprawnienia obliczeniowe lub Zarządzanie usługą SQL Warehouse.

Aby uwierzytelnić sterownik SQL usługi Databricks dla języka Go przy użyciu parametry połączenia DSN i przykład kodu w temacie Nawiązywanie połączenia z parametry połączenia DSN, użyj następującej składni parametry połączenia DSN, gdzie:

• <server-hostname>to wartość Nazwa hosta serwera z wymagań.
• <port-number>to wartość Port z wymagań, czyli zazwyczaj 443.
• <http-path>jest wartością ścieżki HTTP z wymagań.
• <client-id>to wartość UUID lub Identyfikator aplikacji jednostki usługi.
• <client-secret>to wartość wpisu tajnego dla wpisu tajnego OAuth jednostki usługi.

Możesz również dołączyć jeden lub więcej parametrów opcjonalnych wymienionych wcześniej w tym artykule.

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

Aby uwierzytelnić sterownik SQL usługi Databricks dla języka Go za NewConnector pomocą funkcji, należy najpierw dodać następujący kod do import deklaracji:

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

Następnie użyj następującego fragmentu kodu i przykładu kodu w sekcji Connect with the NewConnector function (Połącz z funkcją NewConnector), która zakłada, że ustawiono następujące zmienne środowiskowe:

• DATABRICKS_SERVER_HOSTNAMEustaw wartość Nazwa hosta serwera dla klastra lub usługi SQL Warehouse.
• DATABRICKS_HTTP_PATH, ustaw wartość ścieżka HTTP dla klastra lub usługi SQL Warehouse.
• DATABRICKS_CLIENT_ID, ustaw wartość UUID jednostki usługi lub Identyfikator aplikacji.
• DATABRICKS_CLIENT_SECRET, ustaw wartość wpisu tajnego dla wpisu tajnego OAuth jednostki usługi.

Aby ustawić zmienne środowiskowe, zapoznaj się z dokumentacją systemu operacyjnego.

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

Zapytania o dane

W poniższym przykładzie kodu pokazano, jak wywołać sterownik SQL usługi Databricks dla języka Go, aby uruchomić podstawowe zapytanie SQL w zasobie obliczeniowym usługi Azure Databricks. To polecenie zwraca dwa pierwsze wiersze z trips tabeli w schemacie samples wykazu nyctaxi .

Ten przykładowy kod pobiera parametry połączenia DSN ze zmiennej środowiskowej o nazwie 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)
  }
}

Zarządzanie plikami w woluminach wykazu aparatu Unity

Sterownik SQL usługi Databricks umożliwia zapisywanie plików lokalnych w woluminach wykazu aparatu Unity, pobieranie plików z woluminów i usuwanie plików z woluminów, jak pokazano w poniższym przykładzie:

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

Rejestrowanie

Służy github.com/databricks/databricks-sql-go/logger do rejestrowania komunikatów emitujących sterownik SQL usługi Databricks dla języka Go. W poniższym przykładzie kodu użyto sql.Open() metody do utworzenia dojścia bazy danych za pośrednictwem parametry połączenia DSN. Ten przykład kodu pobiera parametry połączenia DSN ze zmiennej środowiskowej o nazwie DATABRICKS_DSN. Wszystkie komunikaty dziennika, które są emitowane na debug poziomie i poniżej, są zapisywane w results.log pliku.

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

Testowanie

Aby przetestować kod, użyj platform testowych Języka Go, takich jak biblioteka standardowa testowania. Aby przetestować kod w symulowanych warunkach bez wywoływania punktów końcowych interfejsu API REST usługi Azure Databricks lub zmieniania stanu kont lub obszarów roboczych usługi Azure Databricks, użyj języka Go pozorowanych bibliotek, takich jak testowanie.

Na przykład, biorąc pod uwagę następujący plik o nazwie helpers.go zawierającej GetDBWithDSNPAT funkcję, która zwraca połączenie obszaru roboczego usługi Azure Databricks, funkcję zwracającą GetNYCTaxiTrips dane z trips tabeli w samples schemacie wykazu nyctaxi oraz funkcję PrintNYCTaxiTrips , która wyświetla zwrócone dane:

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

I biorąc pod uwagę następujący plik o nazwie main.go , który wywołuje następujące funkcje:

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

Poniższy plik o nazwie helpers_test.go testuje, czy GetNYCTaxiTrips funkcja zwraca oczekiwaną odpowiedź. Zamiast tworzyć rzeczywiste połączenie z docelowym obszarem roboczym, ten test wyśmiewa sql.DB obiekt. Test wyśmiewa również niektóre dane zgodne ze schematem i wartościami, które znajdują się w rzeczywistych danych. Test zwraca wyśmiewane dane za pośrednictwem pozorowanego połączenia, a następnie sprawdza, czy jedna z wyśmiewanych wartości wierszy danych jest zgodna z oczekiwaną wartością.

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 Ponieważ funkcja zawiera instrukcję SELECT i dlatego nie zmienia stanu trips tabeli, pozorowanie nie jest absolutnie wymagane w tym przykładzie. Jednak pozorowanie umożliwia szybkie uruchamianie testów bez oczekiwania na rzeczywiste połączenie z obszarem roboczym. Ponadto wyśmiewanie umożliwia wielokrotne uruchamianie symulowanych testów dla funkcji, które mogą zmienić stan tabeli, takie jak INSERT INTO, UPDATEi DELETE FROM.

Dodatkowe zasoby

• Repozytorium Sql Driver for Go usługi Databricks w witrynie GitHub
• Strona główna pakietu bazy danych/sql
• Przykłady sterownika SQL usługi Databricks dla języka Go w usłudze GitHub