Databricks SQL-stuurprogramma voor Go
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
- Een ontwikkelcomputer met Go, versie 1.20 of hoger. Als u de geïnstalleerde versie van Go wilt afdrukken, voert u de opdracht
go version
uit. Download en installeer Go. - Een bestaand cluster of SQL-magazijn.
- De waarden voor de serverhostnaam, poort en HTTP-pad voor het bestaande cluster of SQL Warehouse.
Aan de slag met het Databricks SQL-stuurprogramma voor Go
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 dego mod init
opdracht uit te voeren, bijvoorbeeld:go mod init sample
Neem een afhankelijkheid van het Databricks SQL-stuurprogramma voor Go-pakket door de
go mod edit -require
opdracht uit te voeren, waarbijv1.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
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) } }
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 packages
krijgt, bent u vergeten een Go-codebestand toe te voegen waarmee het Databricks SQL-stuurprogramma voor Go wordt geïmporteerd.Maak kopieën van alle pakketten die nodig zijn om builds en tests van pakketten in uw
main
module te ondersteunen door dego mod vendor
opdracht uit te voeren:go mod vendor
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.Voer het Go-codebestand uit, uitgaande van een bestand met de naam
main.go
, door de opdracht uit tego run
voeren:go run main.go
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 doorgaans443
. -
<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 is10000
. -
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, bijvoorbeeldAmerica/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 NewConnector
om de juiste set 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. Vereiststring
. -
WithServerHostname(<server-hostname>)
: De serverhostnaamwaarde van de vereisten. Vereiststring
. -
WithPort(<port>)
: het poortnummer van de server, meestal443
. Vereistint
. -
WithHTTPPath(<http-path>)
: de HTTP-padwaarde van de vereisten. Vereiststring
. -
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 is10000.
Optioneelint
. -
WithSessionParams(<params-map>)
: De sessieparameters, waaronder 'tijdzone' en 'ansi_mode'. Optioneelmap[string]string
. -
WithTimeout(<timeout>)
. De time-out (intime.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:
- Verificatie van persoonlijke toegangstokens van Databricks
- Verificatie van Microsoft Entra-id-token
- OAuth-verificatie van gebruiker naar machine (U2M)
- OAuth-verificatie van machine-naar-machine (M2M)
Het Databricks SQL-stuurprogramma voor Go biedt nog geen ondersteuning voor de volgende Azure Databricks-verificatietypen:
- Verificatie van door Azure beheerde identiteiten
- Verificatie van MS Entra-service-principal
- Azure CLI-verificatie
Verificatie van persoonlijke toegangstokens van Databricks
Als u het Databricks SQL-stuurprogramma voor Go wilt gebruiken met persoonlijke toegangstokenverificatie van Azure Databricks, moet u eerst een persoonlijk toegangstoken voor Azure Databricks maken. Zie persoonlijke toegangstokens van Azure Databricks voor werkruimtegebruikers voor meer informatie over deze stap.
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 doorgaans443
. -
<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_HOSTNAME
ingesteld 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 Microsoft Entra-id-token
Het Databricks SQL-stuurprogramma voor Go ondersteunt Microsoft Entra ID-tokens 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 Microsoft Entra ID-tokens ophalen voor gebruikers met behulp van de Azure CLI.
- Zie Een Microsoft Entra ID-toegangstoken ophalen met de Azure CLI voor een Service-principal van Microsoft Entra ID. Zie Service-principals beheren om een door Microsoft Entra ID beheerde service-principals te maken.
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 doorgaans443
. -
<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_HOSTNAME
ingesteld 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 doorgaans443
. -
<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_HOSTNAME
ingesteld 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:
Maak een Azure Databricks-service-principal in uw Azure Databricks-werkruimte en maak een OAuth-geheim voor die service-principal.
Zie Autoriseer ongecontroleerde toegang tot Azure Databricks-resources met een service-principal en OAuthom de service-principal en zijn 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.
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 doorgaans443
. -
<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_HOSTNAME
ingesteld 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 samples
de nyctaxi
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 samples
de nyctaxi
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
, UPDATE
en DELETE FROM
.
Aanvullende bronnen
- De Databricks SQL-stuurprogramma voor Go-opslagplaats op GitHub
- De startpagina van het database-/SQL-pakket
- Voorbeelden van het Databricks SQL-stuurprogramma voor Go op GitHub