Connecteur Databricks SQL pour Python

Le Connecteur Databricks SQL pour Python est une bibliothèque Python qui vous permet d'utiliser du code Python pour exécuter des commandes SQL sur le compute polyvalent Databricks et les warehouses Databricks SQL. Le connecteur Databricks SQL pour Python est plus facile à configurer et à utiliser que des bibliothèques Python similaires telles que pyodbc. Cette bibliothèque suit la spécification v2.0 de l'API de base de données Python PEP 249.

important

Connecteur Databricks SQL pour Python version 3.0.0 ...et au-delà prend en charge l'exécution native de requêtes paramétrées, ce qui prévient l'injection SQL et peut améliorer les performances des requêtes. Les versions précédentes utilisaient une exécution paramétrée en ligne, qui n'est pas à l'abri des injections SQL et présente d'autres inconvénients. Pour plus d'informations, voir Utilisation de paramètres natifs.

Le connecteur Databricks SQL pour Python prend également en charge le dialecte SQLAlchemy pour Databricks, mais il doit être installé pour utiliser ces fonctionnalités. Découvrez comment utiliser SQLAlchemy avec Databricks.

Exigences

Une machine de développement exécutant Python 3.8 et versions supérieures.
Databricks recommande d'utiliser des environnements virtuels Python, tels que ceux fournis par venv qui sont inclus avec Python. Les environnements virtuels vous aident à garantir que vous utilisez ensemble les bonnes versions de Python et du connecteur Databricks SQL pour Python. La configuration et l'utilisation d'environnements virtuels dépassent le cadre de cet article. Pour plus d'informations, consultez Création d'environnements virtuels.
Un compute tout usage existant ou un SQL warehouse.

Get start

Installer le connecteur Databricks SQL pour Python. PyArrow est une dépendance facultative du connecteur Databricks SQL pour Python et n’est pas installé par default dans la version 4.0.0 et les versions ultérieures du connecteur. Si PyArrow n’est pas installé, les fonctionnalités telles que CloudFetch et d’autres fonctionnalités d’Apache Arrow ne sont pas disponibles, ce qui peut impacter les performances pour de grands volumes de données.
- Pour installer le connecteur léger, utilisez :
```
pip install databricks-sql-connector
```
- Pour installer le connecteur complet, y compris PyArrow, utilisez :
```
pip install databricks-sql-connector[pyarrow]
```
Recueillez les informations suivantes pour le compute universel ou le SQL warehouse que vous souhaitez utiliser :

All-purpose compute
SQL warehouse

Le hostname du serveur du compute polyvalent. Vous pouvez l'obtenir à partir de la valeur Hostname du serveur dans l'onglet Options avancées > JDBC/ODBC pour votre compute polyvalent.
Le chemin HTTP du compute multifonction. Vous pouvez l’obtenir à partir de la valeur Chemin HTTP dans la Options avancées > JDBC/ODBC tab de votre compute polyvalent.

remarque

The SQL connector does not support connecting to jobs compute.

Authentification

Le connecteur Databricks SQL pour Python prend en charge les types d'authentification Databricks suivants :

Authentification Databricks par jeton d'accès personnel
Authentification OAuth machine à machine (M2M)
Authentification OAuth utilisateur-à-machine (U2M)

Authentification par jeton d'accès personnel Databricks

Pour utiliser le connecteur Databricks SQL pour Python avec l'authentification par jeton d'accès personnel Databricks, vous devez d'abord créer un jeton d'accès personnel Databricks. Pour ce faire, suivez les étapes de Créer des jetons d'accès personnels pour les utilisateurs du Workspace.

Pour authentifier le Connecteur Databricks SQL pour Python, utilisez l’extrait de code suivant. Cet extrait suppose que vous avez défini les variables d'environnement suivantes :

DATABRICKS_SERVER_HOSTNAMEdéfini sur la valeur Hostname du serveur de votre compute multifonction ou SQL Warehouse.
DATABRICKS_HTTP_PATH, défini sur la valeur **Chemin HTTP** pour votre compute polyvalent ou SQL warehouse.
DATABRICKS_TOKEN, défini sur le jeton d'accès personnel Databricks.

Pour définir les variables d’environnement, consultez la documentation de votre système d’exploitation.

Python
from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:
# ...

Authentification OAuth machine à machine (M2M)

Le Connecteur Databricks SQL pour Python versions 2.5.0 et supérieures prend en charge l'authentification OAuth de machine à machine (M2M). Vous devez également installer le SDK Databricks pour Python (par exemple, en exécutant pip install databricks-sdk ou python -m pip install databricks-sdk).

Pour utiliser le connecteur Databricks SQL pour Python avec l'authentification OAuth M2M, vous devez effectuer les opérations suivantes :

Créez un Service Principal Databricks dans votre Workspace Databricks, et créez un secret OAuth pour ce Service Principal.

Pour créer le service principal et son secret OAuth, consultez Autoriser l'accès du service principal à Databricks avec OAuth. Notez la valeur du **UUID** ou de l'**ID d'application** du service principal, ainsi que la valeur du **Secret** du secret OAuth du service principal.
Donnez à ce Service Principal l'accès à votre compute polyvalent ou à votre warehouse.

Pour donner au Service Principal accès à votre compute polyvalent ou à votre warehouse, consultez les autorisations de compute ou la gestion d'un SQL warehouse.

Pour authentifier le Connecteur Databricks SQL pour Python, utilisez l’extrait de code suivant. Cet extrait suppose que vous avez défini les variables d'environnement suivantes :

DATABRICKS_SERVER_HOSTNAME défini sur la valeur Hostname du serveur de votre compute multifonction ou SQL Warehouse.
DATABRICKS_HTTP_PATH, défini sur la valeur **Chemin HTTP** pour votre compute polyvalent ou SQL warehouse.
DATABRICKS_CLIENT_ID, défini sur la valeur **UUID** ou **ID d'Application** du Service Principal.
DATABRICKS_CLIENT_SECRET, défini sur la valeur **Secret** du secret OAuth du Service Principal.

Pour définir les variables d’environnement, consultez la documentation de votre système d’exploitation.

Python
from databricks.sdk.core import Config, oauth_service_principal
from databricks import sql
import os

server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME")

def credential_provider():
  config = Config(
    host          = f"https://{server_hostname}",
    client_id     = os.getenv("DATABRICKS_CLIENT_ID"),
    client_secret = os.getenv("DATABRICKS_CLIENT_SECRET"))
  return oauth_service_principal(config)

with sql.connect(server_hostname      = server_hostname,
                 http_path            = os.getenv("DATABRICKS_HTTP_PATH"),
                 credentials_provider = credential_provider) as connection:
# ...

Authentification OAuth d'utilisateur à machine (U2M)

Connecteur Databricks SQL pour Python versions 2.1.0 et supérieures prennent en charge l'authentification OAuth utilisateur à machine (U2M).

Pour authentifier le connecteur Databricks SQL pour Python avec l’authentification OAuth U2M, utilisez l’extrait de code suivant. L’authentification OAuth U2M utilise la connexion et le consentement humains en temps réel pour authentifier le compte utilisateur Databricks cible. Cet extrait suppose que vous avez défini les variables d'environnement suivantes :

Définissez DATABRICKS_SERVER_HOSTNAME sur la valeur **Hostname du serveur** pour votre compute multifonction ou votre SQL Warehouse.
Définissez DATABRICKS_HTTP_PATH sur la valeur du chemin HTTP pour votre compute multifonction ou votre SQL Warehouse.

Pour définir les variables d’environnement, consultez la documentation de votre système d’exploitation.

Python
from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 auth_type       = "databricks-oauth") as connection:
# ...

Exemples

Les exemples de code suivants montrent comment utiliser le connecteur Databricks SQL pour Python afin d'interroger et d'insérer des données, d'interroger des métadonnées, de gérer les curseurs et les connexions, de gérer les fichiers dans Unity Catalog et de configurer la journalisation.

remarque

Les exemples de code suivants démontrent comment utiliser un jeton d'accès personnel Databricks pour l'authentification. Pour utiliser un type d'authentification différent, consultez Authentification.

Ces exemples de code récupèrent leurs valeurs de variables de connexion server_hostname, http_path et access_token à partir de ces variables d'environnement :

DATABRICKS_SERVER_HOSTNAME, qui représente la valeur **Hostname du serveur** des exigences.
DATABRICKS_HTTP_PATH, qui représente la valeur Chemin HTTP des exigences.
DATABRICKS_TOKEN, qui représente votre jeton d'accès issu des exigences.

Définir User-Agent

L'exemple de code suivant montre comment définir l'application User-Agent product_name pour le suivi de l'utilisation.

Python
from databricks import sql
import os

with sql.connect(server_hostname   = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path         = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token      = os.getenv("DATABRICKS_TOKEN"),
                 user_agent_entry = "product_name") as connection:
  with connection.cursor() as cursor:
    cursor.execute("SELECT 1 + 1")
    result = cursor.fetchall()

    for row in result:
      print(row)

Query des données

L’exemple de code suivant montre comment appeler le connecteur Databricks SQL pour Python pour exécuter une commande SQL de base sur un compute multifonction ou un SQL Warehouse. Cette commande renvoie les deux premières lignes de la table trips dans le schéma nyctaxi du catalogue samples.

Python
from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:

  with connection.cursor() as cursor:
    cursor.execute("SELECT * FROM samples.nyctaxi.trips LIMIT ?", [2])
    result = cursor.fetchall()

    for row in result:
      print(row)

Tags de query

info

Aperçu

Cette fonctionnalité est en aperçu public.

Les exemples suivants montrent comment associer des balises clé-valeur à vos queries SQL à des fins de suivi et d'analytique. Les balises de query apparaissent dans la table system.query.history.

Version minimale : v4.1.3 (au niveau de la session), v4.2.6 (au niveau de l'instruction)

Tags au niveau de la session :

Python
from databricks import sql
import os

with sql.connect(
    server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
    http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
    access_token    = os.getenv("DATABRICKS_TOKEN"),
    query_tags = {"team": "engineering", "dashboard": "abc123", "env": "prod"}
) as connection:
    with connection.cursor() as cursor:
        cursor.execute("SELECT * FROM samples.nyctaxi.trips LIMIT ?", [2])
        result = cursor.fetchall()
        for row in result:
            print(row)

Tags au niveau de l'instruction :

Python
from databricks import sql
import os

with sql.connect(
    server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
    http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
    access_token    = os.getenv("DATABRICKS_TOKEN"),
) as connection:
    with connection.cursor() as cursor:
        cursor.execute(
            "SELECT * FROM samples.nyctaxi.trips LIMIT ?",
            parameters=[2],
            query_tags={&quot;team&quot;: &quot;engineering&quot;, &quot;dashboard&quot;: &quot;abc123&quot;, &quot;env&quot;: &quot;prod&quot;}
        )
        result = cursor.fetchall()
        for row in result:
            print(row)

Insérer des données

L'exemple suivant montre comment insérer de petites quantités de données (des milliers de lignes) :

Python
from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:

  with connection.cursor() as cursor:
    cursor.execute("CREATE TABLE IF NOT EXISTS squares (x int, x_squared int)")

    squares = [(i, i * i) for i in range(100)]

    cursor.executemany("INSERT INTO squares VALUES (?, ?)", squares)

    cursor.execute("SELECT * FROM squares LIMIT ?", [10])

    result = cursor.fetchall()

    for row in result:
      print(row)

Pour de grandes quantités de données, vous devriez d'abord upload les données vers le stockage cloud, puis exécuter la commande COPY INTO.

Métadonnées de la query

Il existe des méthodes dédiées pour la récupération des métadonnées. L'exemple suivant récupère les métadonnées concernant les colonnes d'une table d'exemple :

Python
from databricks import sql
import os

with sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token    = os.getenv("DATABRICKS_TOKEN")) as connection:

  with connection.cursor() as cursor:
    cursor.columns(schema_name="default", table_name="squares")
    print(cursor.fetchall())

Gérer les curseurs et les connexions

Il est recommandé de fermer toutes les connexions et tous les curseurs qui ne sont plus utilisés. Cela libère les Ressources sur les compute Databricks à usage général et les warehouse Databricks SQL.

Vous pouvez utiliser un gestionnaire de contexte (la syntaxe with utilisée dans les exemples précédents) pour gérer les Ressources, ou appeler explicitement close:

Python
from databricks import sql
import os

connection = sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                         http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                         access_token    = os.getenv("DATABRICKS_TOKEN"))

cursor = connection.cursor()

cursor.execute("SELECT * from range(10)")
print(cursor.fetchall())

cursor.close()
connection.close()

Gérer les fichiers dans les volumes Unity Catalog

Le connecteur Databricks SQL vous permet d’écrire des fichiers locaux dans les volumes de Unity Catalog, de download des fichiers à partir de volumes et de supprimer des fichiers des volumes, comme le montre l’exemple suivant :

Python
from databricks import sql
import os

# For writing local files to volumes and downloading files from volumes,
# you must set the staging_allowed_local_path argument to the path to the
# local folder that contains the files to be written or downloaded.
# For deleting files in volumes, you must also specify the
# staging_allowed_local_path argument, but its value is ignored,
# so in that case its value can be set for example to an empty string.
with sql.connect(server_hostname            = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                 http_path                  = os.getenv("DATABRICKS_HTTP_PATH"),
                 access_token               = os.getenv("DATABRICKS_TOKEN"),
                 staging_allowed_local_path = "/tmp/") as connection:

  with connection.cursor() as cursor:

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

    # Download a file from the specified path in a volume.
    cursor.execute(
      "GET '/Volumes/main/default/my-volume/my-data.csv' TO '/tmp/my-downloaded-data.csv'"
    )

    # Delete a file from the specified path in a volume.
    cursor.execute(
      "REMOVE '/Volumes/main/default/my-volume/my-data.csv'"
    )

Configurer la journalisation

Le connecteur Databricks SQL utilise le module de journalisation standard de Python. L'exemple suivant configure le niveau de journalisation et génère un journal de débogage :

Python
from databricks import sql
import os, logging

logging.getLogger("databricks.sql").setLevel(logging.DEBUG)
logging.basicConfig(filename = "results.log",
                    level    = logging.DEBUG)

connection = sql.connect(server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
                         http_path       = os.getenv("DATABRICKS_HTTP_PATH"),
                         access_token    = os.getenv("DATABRICKS_TOKEN"))

cursor = connection.cursor()

cursor.execute("SELECT * from range(10)")

result = cursor.fetchall()

for row in result:
   logging.debug(row)

cursor.close()
connection.close()

Utilisez l'API d'exécution des instructions

Le connecteur Databricks SQL pour Python peut se connecter à l'aide de l'API d'exécution d'instructions, un chemin d'exécution basé sur REST, au lieu du protocole Thrift default. Vous devez utiliser ce chemin pour vous connecter au compute Lakehouse Real-Time.

Le client natif s'installe en tant qu'option supplémentaire et requiert **Python 3.10 ou version ultérieure** :

Shell
pip install "databricks-sql-connector[kernel]"

Lorsque vous vous connectez, transmettez use_kernel=True:

Py
from databricks import sql

connection = sql.connect(
    server_hostname=server_hostname,
    http_path=http_path,
    access_token=access_token,
    use_kernel=True,
)
with connection.cursor() as cursor:
    cursor.execute("SELECT 1")
    print(cursor.fetchall())

remarque

Ce chemin d’exécution n’est utilisé que si vous définissez use_kernel=True. Autrement, le connecteur se comporte comme dans les versions précédentes. Certaines opérations ne sont pas encore prises en charge sur ce chemin et génèrent une erreur « non prise en charge ».

Test

Pour tester votre code, utilisez des frameworks de test Python tels que pytest. Pour tester votre code dans des conditions simulées sans appeler les points de terminaison d'API REST Databricks ou modifier l'état de vos comptes ou workspaces Databricks, vous pouvez utiliser des bibliothèques de simulation Python telles que unittest.mock.

Par exemple, étant donné le fichier suivant nommé helpers.py contenant une fonction get_connection_personal_access_token qui utilise un jeton d'accès personnel Databricks pour renvoyer une connexion à un workspace Databricks, et une fonction select_nyctaxi_trips qui utilise la connexion pour obtenir le nombre spécifié de lignes de données de la table trips dans le schéma nyctaxi du catalogue samples :

Python
# helpers.py

from databricks import sql
from databricks.sql.client import Connection, List, Row, Cursor

def get_connection_personal_access_token(
  server_hostname: str,
  http_path: str,
  access_token: str
) -> Connection:
  return sql.connect(
    server_hostname = server_hostname,
    http_path = http_path,
    access_token = access_token
  )

def select_nyctaxi_trips(
  connection: Connection,
  num_rows: int
) -> List[Row]:
  cursor: Cursor = connection.cursor()
  cursor.execute("SELECT * FROM samples.nyctaxi.trips LIMIT ?", [num_rows])
  result: List[Row] = cursor.fetchall()
  return result

Et étant donné le fichier suivant nommé main.py qui appelle les fonctions get_connection_personal_access_token et select_nyctaxi_trips :

Python
# main.py

from databricks.sql.client import Connection, List, Row
import os
from helpers import get_connection_personal_access_token, select_nyctaxi_trips

connection: Connection = get_connection_personal_access_token(
  server_hostname = os.getenv("DATABRICKS_SERVER_HOSTNAME"),
  http_path = os.getenv("DATABRICKS_HTTP_PATH"),
  access_token = os.getenv("DATABRICKS_TOKEN")
)

rows: List[Row] = select_nyctaxi_trips(
  connection = connection,
  num_rows = 2
)

for row in rows:
  print(row)

Le fichier suivant nommé test_helpers.py teste si la fonction select_nyctaxi_trips renvoie la réponse attendue. Plutôt que de créer une connexion réelle au Workspace cible, ce test simule un objet Connection. Le test simule également des données qui sont conformes au schéma et aux valeurs présentes dans les données réelles. Le test renvoie les données mockées via la connexion mockée, puis vérifie si l'une des valeurs des lignes de données mockées correspond à la valeur attendue.

Python
# test_helpers.py

import pytest
from databricks.sql.client import Connection, List, Row
from datetime import datetime
from helpers import select_nyctaxi_trips
from unittest.mock import create_autospec

@pytest.fixture
def mock_data() -> List[Row]:
  return [
    Row(
      tpep_pickup_datetime = datetime(2016, 2, 14, 16, 52, 13),
      tpep_dropoff_datetime = datetime(2016, 2, 14, 17, 16, 4),
      trip_distance = 4.94,
      fare_amount = 19.0,
      pickup_zip = 10282,
      dropoff_zip = 10171
    ),
    Row(
      tpep_pickup_datetime = datetime(2016, 2, 4, 18, 44, 19),
      tpep_dropoff_datetime = datetime(2016, 2, 4, 18, 46),
      trip_distance = 0.28,
      fare_amount = 3.5,
      pickup_zip = 10110,
      dropoff_zip = 10110
    )
  ]

def test_select_nyctaxi_trips(mock_data: List[Row]):
  # Create a mock Connection.
  mock_connection = create_autospec(Connection)

  # Set the mock Connection's cursor().fetchall() to the mock data.
  mock_connection.cursor().fetchall.return_value = mock_data

  # Call the real function with the mock Connection.
  response: List[Row] = select_nyctaxi_trips(
    connection = mock_connection,
    num_rows = 2)

  # Check the value of one of the mocked data row's columns.
  assert response[1].fare_amount == 3.5

Parce que la fonction select_nyctaxi_trips contient une instruction SELECT et ne modifie donc pas l'état de la table trips, la simulation n'est pas absolument requise dans cet exemple. Cependant, le mocking vous permet d'exécuter rapidement vos tests sans attendre qu'une connexion réelle soit établie avec le workspace. De plus, la simulation vous permet d'exécuter des tests simulés plusieurs fois pour les fonctions qui pourraient modifier l'état d'une table, comme INSERT INTO, UPDATE et DELETE FROM.

Référence de l'API

Cette section contient la référence de l'API pour le package databricks-sql-connector. Voir databricks-sql-connector dans l'index de package Python (PyPI).

Module

Le module databricks.sql du package databricks-sql-connector contient la méthode pour initialiser une connexion à un SQL Warehouse.

méthode de connexion

Initialise une connexion à un SQL Warehouse. Renvoie un objet de connexion.

parameter	Type	Description
`server_hostname`	`str`	Obligatoire. Le hostname du serveur pour le compute polyvalent ou le SQL warehouse, par exemple `dbc-a1b2345c-d6e7.cloud.databricks.com`. Pour obtenir le hostname du serveur, consultez les instructions dans Démarrer.
`http_path`	`str`	Obligatoire. Le chemin HTTP du compute universel ou du SQL Warehouse, par exemple `sql/protocolv1/o/1234567890123456/1234-567890-test123` pour un compute universel ou `/sql/1.0/warehouses/a1b234c567d8e9fa` pour un SQL Warehouse. Pour obtenir le chemin HTTP, consultez les instructions dans Premiers pas.
`access_token`, `auth_type`, `credentials_provider`, `password`, `username`	`str`	Informations sur les paramètres d'authentification de Databricks. Pour plus de détails, consultez Authentification.
`session_configuration`	`dict[str, Any]`	Un dictionnaire de paramètres de configuration de session Spark. La définition d'une configuration équivaut à l'utilisation de la commande SQL `SET key=val`. Exécutez la commande SQL `SET -v` pour obtenir une liste complète des configurations disponibles. La valeur par default est `None`. Exemple : `{"spark.sql.variable.substitute": True}`
`http_headers`	`List[Tuple[str, str]]]`	Facultatif. Paires (clé, valeur) supplémentaires à définir dans les en-têtes HTTP de chaque requête RPC effectuée par le client. L'utilisation typique ne définira aucun en-tête HTTP supplémentaire. La valeur default est `None`.
`catalog`	`str`	Facultatif. Catalogue initial à utiliser pour la connexion. Defaults to `None` (auquel cas le catalogue default, typically `hive_metastore` will be used).
`schema`	`str`	Facultatif. Schéma initial à utiliser pour la connexion. Valeur par default : `None` (auquel cas le schéma par default `default` sera utilisé). Depuis la version 2.0
`use_cloud_fetch`	`bool`	Facultatif. S'il faut envoyer des requêtes de récupération directement au stockage d'objets cloud pour download des blocs de données. La valeur par défaut est `True`. Définissez sur `False` pour envoyer des requêtes de récupération directement à Databricks. Si `use_cloud_fetch` est défini sur `True` mais que l'accès réseau est bloqué, alors les requêtes de récupération échoueront. Depuis la version 2.8
`user_agent_entry`	`str`	Facultatif. L'entrée User-Agent à inclure dans l'en-tête de la requête HTTP pour le suivi de l'utilisation. La valeur par default est `PyDatabricksSqlConnector`.

parameter	Type	Description
`server_hostname`	`str`	Obligatoire. Le hostname du serveur pour le compute polyvalent ou le SQL warehouse, par exemple `dbc-a1b2345c-d6e7.cloud.databricks.com`. Pour obtenir le hostname du serveur, consultez les instructions dans Démarrer.
`http_path`	`str`	Obligatoire. Le chemin HTTP du compute universel ou du SQL Warehouse, par exemple `sql/protocolv1/o/1234567890123456/1234-567890-test123` pour un compute universel ou `/sql/1.0/warehouses/a1b234c567d8e9fa` pour un SQL Warehouse. Pour obtenir le chemin HTTP, consultez les instructions dans Premiers pas.
`access_token`, `auth_type`, `credentials_provider`, `password`, `username`	`str`	Informations sur les paramètres d'authentification de Databricks. Pour plus de détails, consultez Authentification.
`session_configuration`	`dict[str, Any]`	Un dictionnaire de paramètres de configuration de session Spark. La définition d'une configuration équivaut à l'utilisation de la commande SQL `SET key=val`. Exécutez la commande SQL `SET -v` pour obtenir une liste complète des configurations disponibles. La valeur par default est `None`. Exemple : `{"spark.sql.variable.substitute": True}`
`http_headers`	`List[Tuple[str, str]]]`	Facultatif. Paires (clé, valeur) supplémentaires à définir dans les en-têtes HTTP de chaque requête RPC effectuée par le client. L'utilisation typique ne définira aucun en-tête HTTP supplémentaire. La valeur default est `None`.
`catalog`	`str`	Facultatif. Catalogue initial à utiliser pour la connexion. Defaults to `None` (auquel cas le catalogue default, typically `hive_metastore` will be used).
`schema`	`str`	Facultatif. Schéma initial à utiliser pour la connexion. Valeur par default : `None` (auquel cas le schéma par default `default` sera utilisé). Depuis la version 2.0
`use_cloud_fetch`	`bool`	Facultatif. S'il faut envoyer des requêtes de récupération directement au stockage d'objets cloud pour download des blocs de données. La valeur par défaut est `True`. Définissez sur `False` pour envoyer des requêtes de récupération directement à Databricks. Si `use_cloud_fetch` est défini sur `True` mais que l'accès réseau est bloqué, alors les requêtes de récupération échoueront. Depuis la version 2.8
`user_agent_entry`	`str`	Facultatif. L'entrée User-Agent à inclure dans l'en-tête de la requête HTTP pour le suivi de l'utilisation. La valeur par default est `PyDatabricksSqlConnector`.

`Connection` classe

Représente une connexion à un compute ou à un SQL Warehouse.

Méthodes

La classe Connection fournit les méthodes suivantes.

Méthode	Description
`close`	Ferme la connexion à la base de données et libère toutes les ressources associées sur le serveur. Tout appel supplémentaire à cette connexion déclenchera un `Error`. Aucun paramètre. Aucune valeur de retour.
`cursor`	Renvoie un nouvel objet Curseur qui permet le parcours des enregistrements dans une base de données. Aucun paramètre.

Méthode

Description

close

Ferme la connexion à la base de données et libère toutes les ressources associées sur le serveur. Tout appel supplémentaire à cette connexion déclenchera un Error.

Aucun paramètre.

Aucune valeur de retour.

cursor

Renvoie un nouvel objet Curseur qui permet le parcours des enregistrements dans une base de données.

Aucun paramètre.

Méthode	Description
`close`	Ferme la connexion à la base de données et libère toutes les ressources associées sur le serveur. Tout appel supplémentaire à cette connexion déclenchera un `Error`. Aucun paramètre. Aucune valeur de retour.
`cursor`	Renvoie un nouvel objet Curseur qui permet le parcours des enregistrements dans une base de données. Aucun paramètre.

Méthode

Description

close

Ferme la connexion à la base de données et libère toutes les ressources associées sur le serveur. Tout appel supplémentaire à cette connexion déclenchera un Error.

Aucun paramètre.

Aucune valeur de retour.

cursor

Renvoie un nouvel objet Curseur qui permet le parcours des enregistrements dans une base de données.

Aucun paramètre.

`Cursor` classe

Représente un mécanisme de parcours des enregistrements de données.

Pour créer un objet Cursor, appelez la méthode cursor de la classe `Connection`.

Attributs

Les Cursor attributs sélectionnés incluent les éléments suivants :

Attribut	Description
`arraysize`	Utilisé avec la méthode `fetchmany`, spécifie la taille du tampon interne, qui est également le nombre de lignes réellement récupérées du serveur à la fois. La valeur default est `10000`. Pour des résultats étroits (résultats dans lesquels chaque ligne ne contient pas beaucoup de données), vous devriez augmenter cette valeur pour de meilleures performances. Accès en lecture-écriture.
`description`	Contient un Python `list` de `tuple` objets. Chacun de ces objets `tuple` contient 7 valeurs, les 2 premiers éléments de chaque objet `tuple` contenant des informations décrivant une seule colonne de résultat comme suit : `name`: Le nom de la colonne. `type_code`: Une chaîne de caractères représentant le type de la colonne. Par exemple, une colonne de type entier aura un code de type de `int`. Les 5 éléments restants de chaque objet `tuple` de 7 éléments ne sont pas implémentés et leurs valeurs ne sont pas définies. Elles seront généralement renvoyées sous forme de 4 valeurs `None` suivies d'une seule valeur `True`. Accès en lecture seule.

Attribut

Description

arraysize

Utilisé avec la méthode fetchmany, spécifie la taille du tampon interne, qui est également le nombre de lignes réellement récupérées du serveur à la fois. La valeur default est 10000. Pour des résultats étroits (résultats dans lesquels chaque ligne ne contient pas beaucoup de données), vous devriez augmenter cette valeur pour de meilleures performances. Accès en lecture-écriture.

description

Contient un Python list de tuple objets. Chacun de ces objets tuple contient 7 valeurs, les 2 premiers éléments de chaque objet tuple contenant des informations décrivant une seule colonne de résultat comme suit :

name: Le nom de la colonne.
type_code: Une chaîne de caractères représentant le type de la colonne. Par exemple, une colonne de type entier aura un code de type de int. Les 5 éléments restants de chaque objet tuple de 7 éléments ne sont pas implémentés et leurs valeurs ne sont pas définies. Elles seront généralement renvoyées sous forme de 4 valeurs None suivies d'une seule valeur True. Accès en lecture seule.

Attribut	Description
`arraysize`	Utilisé avec la méthode `fetchmany`, spécifie la taille du tampon interne, qui est également le nombre de lignes réellement récupérées du serveur à la fois. La valeur default est `10000`. Pour des résultats étroits (résultats dans lesquels chaque ligne ne contient pas beaucoup de données), vous devriez augmenter cette valeur pour de meilleures performances. Accès en lecture-écriture.
`description`	Contient un Python `list` de `tuple` objets. Chacun de ces objets `tuple` contient 7 valeurs, les 2 premiers éléments de chaque objet `tuple` contenant des informations décrivant une seule colonne de résultat comme suit : `name`: Le nom de la colonne. `type_code`: Une chaîne de caractères représentant le type de la colonne. Par exemple, une colonne de type entier aura un code de type de `int`. Les 5 éléments restants de chaque objet `tuple` de 7 éléments ne sont pas implémentés et leurs valeurs ne sont pas définies. Elles seront généralement renvoyées sous forme de 4 valeurs `None` suivies d'une seule valeur `True`. Accès en lecture seule.

Attribut

Description

arraysize

description

name: Le nom de la colonne.
type_code: Une chaîne de caractères représentant le type de la colonne. Par exemple, une colonne de type entier aura un code de type de int. Les 5 éléments restants de chaque objet tuple de 7 éléments ne sont pas implémentés et leurs valeurs ne sont pas définies. Elles seront généralement renvoyées sous forme de 4 valeurs None suivies d'une seule valeur True. Accès en lecture seule.

Méthodes

Les Cursor méthodes sélectionnées incluent les éléments suivants :

Méthode	Description
`cancel`	Interrompt l'exécution de toute query ou commande de base de données que le curseur a start. Pour libérer les ressources associées sur le serveur, appelez la méthode `close` après avoir appelé la méthode `cancel`. Aucun paramètre. Aucune valeur de retour.
`close`	Ferme le curseur et libère les Ressources associées sur le serveur. La fermeture d'un curseur déjà fermé pourrait générer une erreur. Aucun paramètre. Aucune valeur de retour.
`execute`	Prépare et exécute ensuite une query ou une commande de base de données. Paramètres : `operation`: Obligatoire. The query ou la commande à préparer et à exécuter. Type : `str` Exemple sans le paramètre `parameters` : `cursor.execute('SELECT * FROM samples.nyctaxi.trips LIMIT 2')` Exemple avec le paramètre `parameters` (utilisant des paramètres positionnels natifs) : `cursor.execute('SELECT * FROM samples.nyctaxi.trips WHERE pickup_zip = ? LIMIT ?', ['10019', 2])` `parameters`Facultatif. Une séquence de paramètres à utiliser avec le paramètre `operation`. The default est `None`. Type : `dictionary` Aucune valeur de retour.
`executemany`	Prépare et exécute une requête ou une commande de base de données en utilisant toutes les séquences de paramètres dans l'argument `seq_of_parameters`. Seul le jeu de résultats final est conservé. Paramètres : `operation`: Obligatoire. The query ou la commande à préparer et à exécuter. Type : `str` `seq_of_parameters`: Obligatoire. Une séquence de nombreux ensembles de valeurs de parameter à utiliser avec le parameter `operation`. Type : `list` de `dict` Aucune valeur de retour.
`catalogs`	Exécutez une query de métadonnées concernant les catalogues. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_CAT`. Le nom du catalogue. Type : `str` Aucun paramètre. Aucune valeur de retour. Depuis la version 1,0
`schemas`	Exécutez une query de métadonnées concernant les schémas. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_SCHEM`. Le nom du schéma. Type : `str` Nom du champ : `TABLE_CATALOG`. Le catalogue auquel le schéma appartient. Type : `str` Paramètres : `catalog_name`Facultatif. Nom du catalogue pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `schema_name`Facultatif. Un nom de schéma pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` Aucune valeur de retour. Depuis la version 1,0
`tables`	Exécutez une query de métadonnées concernant les tables et les vues. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_CAT`. Le catalogue auquel appartient la table. Type : `str` Nom du champ : `TABLE_SCHEM`. Le schéma auquel la table appartient. Type : `str` Nom du champ : `TABLE_NAME`. Le nom de la table. Type : `str` Nom du champ : `TABLE_TYPE`. Le type de relation, par exemple `VIEW` ou `TABLE` (s'applique à Databricks Runtime 10,4 LTS et versions ultérieures ainsi qu'à Databricks SQL ; les versions antérieures de Databricks Runtime renvoient une chaîne vide). Type : `str` Paramètres : `catalog_name`Facultatif. Nom du catalogue pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `schema_name`Facultatif. Un nom de schéma pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `table_name`Facultatif. Un nom de table pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `table_types`Facultatif. Une liste de types de tables à faire correspondre, par exemple `TABLE` ou `VIEW`. Type : `List[str]` Aucune valeur de retour. Depuis la version 1,0
`columns`	Exécutez une query de métadonnées sur les colonnes. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_CAT`. Le catalogue auquel la colonne appartient. Type : `str` Nom du champ : `TABLE_SCHEM`. Le schéma auquel la colonne appartient. Type : `str` Nom du champ : `TABLE_NAME`. Le nom de la table à laquelle la colonne appartient. Type : `str` Nom du champ : `COLUMN_NAME`. Le nom de la colonne. Type : `str` Paramètres : `catalog_name`Facultatif. Nom du catalogue pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `schema_name`Facultatif. Un nom de schéma pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `table_name`Facultatif. Un nom de table pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `column_name`Facultatif. Nom de colonne pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` Aucune valeur de retour. Depuis la version 1,0
`fetchall`	Obtient toutes les lignes (ou toutes les lignes restantes) d'une query. Aucun paramètre. Retourne toutes (ou toutes les restantes) les lignes de la requête sous forme de `list` Python d'objets `Row`. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué.
`fetchmany`	Récupère les lignes suivantes d'une query. Paramètres : `size`Facultatif. Le nombre de lignes suivantes à obtenir. S'il n'est pas spécifié, la valeur de l'attribut `arraysize` est utilisée. Type : `int`. Exemple : `cursor.fetchmany(10)` Retourne jusqu'à `size` (ou l'attribut `arraysize` si `size` n'est pas spécifié) des lignes suivantes d'une query en tant que `list` Python d'objets `Row`. S'il reste moins de `size` lignes à récupérer, toutes les lignes restantes seront renvoyées. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué.
`fetchone`	Obtient la ligne suivante du dataset. Aucun paramètre. Renvoie la ligne suivante du dataset sous forme de séquence unique en tant qu’objet Python `tuple`, ou renvoie `None` s’il n’y a plus de données disponibles. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué.
`fetchall_arrow`	Récupère toutes les lignes (ou toutes les lignes restantes) d'une query, sous forme d'objet PyArrow `Table`. Les query retournant de très grandes quantités de données devraient utiliser `fetchmany_arrow` à la place pour réduire la consommation de mémoire. Aucun paramètre. Renvoie toutes les lignes (ou toutes les lignes restantes) de la query sous forme de table PyArrow. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué. Depuis la version 2.0
`fetchmany_arrow`	Récupère les lignes suivantes d'une query sous forme d'objet PyArrow `Table`. Paramètres : `size`Facultatif. Le nombre de lignes suivantes à obtenir. S'il n'est pas spécifié, la valeur de l'attribut `arraysize` est utilisée. Type : `int`. Exemple : `cursor.fetchmany_arrow(10)` Renvoie jusqu'à l'argument `size` (ou l'attribut `arraysize` si `size` n'est pas spécifié) des lignes suivantes d'une query en tant qu'objet Python PyArrow `Table`. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué. Depuis la version 2.0

Méthode	Description
`cancel`	Interrompt l'exécution de toute query ou commande de base de données que le curseur a start. Pour libérer les ressources associées sur le serveur, appelez la méthode `close` après avoir appelé la méthode `cancel`. Aucun paramètre. Aucune valeur de retour.
`close`	Ferme le curseur et libère les Ressources associées sur le serveur. La fermeture d'un curseur déjà fermé pourrait générer une erreur. Aucun paramètre. Aucune valeur de retour.
`execute`	Prépare et exécute ensuite une query ou une commande de base de données. Paramètres : `operation`: Obligatoire. The query ou la commande à préparer et à exécuter. Type : `str` Exemple sans le paramètre `parameters` : `cursor.execute('SELECT * FROM samples.nyctaxi.trips LIMIT 2')` Exemple avec le paramètre `parameters` (utilisant des paramètres positionnels natifs) : `cursor.execute('SELECT * FROM samples.nyctaxi.trips WHERE pickup_zip = ? LIMIT ?', ['10019', 2])` `parameters`Facultatif. Une séquence de paramètres à utiliser avec le paramètre `operation`. The default est `None`. Type : `dictionary` Aucune valeur de retour.
`executemany`	Prépare et exécute une requête ou une commande de base de données en utilisant toutes les séquences de paramètres dans l'argument `seq_of_parameters`. Seul le jeu de résultats final est conservé. Paramètres : `operation`: Obligatoire. The query ou la commande à préparer et à exécuter. Type : `str` `seq_of_parameters`: Obligatoire. Une séquence de nombreux ensembles de valeurs de parameter à utiliser avec le parameter `operation`. Type : `list` de `dict` Aucune valeur de retour.
`catalogs`	Exécutez une query de métadonnées concernant les catalogues. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_CAT`. Le nom du catalogue. Type : `str` Aucun paramètre. Aucune valeur de retour. Depuis la version 1,0
`schemas`	Exécutez une query de métadonnées concernant les schémas. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_SCHEM`. Le nom du schéma. Type : `str` Nom du champ : `TABLE_CATALOG`. Le catalogue auquel le schéma appartient. Type : `str` Paramètres : `catalog_name`Facultatif. Nom du catalogue pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `schema_name`Facultatif. Un nom de schéma pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` Aucune valeur de retour. Depuis la version 1,0
`tables`	Exécutez une query de métadonnées concernant les tables et les vues. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_CAT`. Le catalogue auquel appartient la table. Type : `str` Nom du champ : `TABLE_SCHEM`. Le schéma auquel la table appartient. Type : `str` Nom du champ : `TABLE_NAME`. Le nom de la table. Type : `str` Nom du champ : `TABLE_TYPE`. Le type de relation, par exemple `VIEW` ou `TABLE` (s'applique à Databricks Runtime 10,4 LTS et versions ultérieures ainsi qu'à Databricks SQL ; les versions antérieures de Databricks Runtime renvoient une chaîne vide). Type : `str` Paramètres : `catalog_name`Facultatif. Nom du catalogue pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `schema_name`Facultatif. Un nom de schéma pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `table_name`Facultatif. Un nom de table pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `table_types`Facultatif. Une liste de types de tables à faire correspondre, par exemple `TABLE` ou `VIEW`. Type : `List[str]` Aucune valeur de retour. Depuis la version 1,0
`columns`	Exécutez une query de métadonnées sur les colonnes. Les résultats réels devraient ensuite être récupérés en utilisant `fetchmany` ou `fetchall`. Les champs importants dans le jeu de résultats incluent : Nom du champ : `TABLE_CAT`. Le catalogue auquel la colonne appartient. Type : `str` Nom du champ : `TABLE_SCHEM`. Le schéma auquel la colonne appartient. Type : `str` Nom du champ : `TABLE_NAME`. Le nom de la table à laquelle la colonne appartient. Type : `str` Nom du champ : `COLUMN_NAME`. Le nom de la colonne. Type : `str` Paramètres : `catalog_name`Facultatif. Nom du catalogue pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `schema_name`Facultatif. Un nom de schéma pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `table_name`Facultatif. Un nom de table pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` `column_name`Facultatif. Nom de colonne pour récupérer des informations. Le caractère `%` est interprété comme un caractère générique. Type : `str` Aucune valeur de retour. Depuis la version 1,0
`fetchall`	Obtient toutes les lignes (ou toutes les lignes restantes) d'une query. Aucun paramètre. Retourne toutes (ou toutes les restantes) les lignes de la requête sous forme de `list` Python d'objets `Row`. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué.
`fetchmany`	Récupère les lignes suivantes d'une query. Paramètres : `size`Facultatif. Le nombre de lignes suivantes à obtenir. S'il n'est pas spécifié, la valeur de l'attribut `arraysize` est utilisée. Type : `int`. Exemple : `cursor.fetchmany(10)` Retourne jusqu'à `size` (ou l'attribut `arraysize` si `size` n'est pas spécifié) des lignes suivantes d'une query en tant que `list` Python d'objets `Row`. S'il reste moins de `size` lignes à récupérer, toutes les lignes restantes seront renvoyées. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué.
`fetchone`	Obtient la ligne suivante du dataset. Aucun paramètre. Renvoie la ligne suivante du dataset sous forme de séquence unique en tant qu’objet Python `tuple`, ou renvoie `None` s’il n’y a plus de données disponibles. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué.
`fetchall_arrow`	Récupère toutes les lignes (ou toutes les lignes restantes) d'une query, sous forme d'objet PyArrow `Table`. Les query retournant de très grandes quantités de données devraient utiliser `fetchmany_arrow` à la place pour réduire la consommation de mémoire. Aucun paramètre. Renvoie toutes les lignes (ou toutes les lignes restantes) de la query sous forme de table PyArrow. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué. Depuis la version 2.0
`fetchmany_arrow`	Récupère les lignes suivantes d'une query sous forme d'objet PyArrow `Table`. Paramètres : `size`Facultatif. Le nombre de lignes suivantes à obtenir. S'il n'est pas spécifié, la valeur de l'attribut `arraysize` est utilisée. Type : `int`. Exemple : `cursor.fetchmany_arrow(10)` Renvoie jusqu'à l'argument `size` (ou l'attribut `arraysize` si `size` n'est pas spécifié) des lignes suivantes d'une query en tant qu'objet Python PyArrow `Table`. Génère une `Error` si l'appel précédent à la méthode `execute` n'a renvoyé aucune donnée ou si aucun appel `execute` n'a encore été effectué. Depuis la version 2.0

`Row` classe

La classe de ligne est une structure de données de type tuple qui représente une ligne de résultat individuelle dans un résultat de requête SQL. Si la ligne contient une colonne nommée "my_column", vous pouvez accéder au champ "my_column" de row via row.my_column. Vous pouvez également utiliser des indices numériques pour accéder aux champs, par exemple row[0]. Si le nom de colonne n'est pas autorisé comme nom de méthode d'attribut (par exemple, il commence par un chiffre), alors vous pouvez accéder au champ en tant que row["1_my_column"].

Depuis la version 1,0

Les Row méthodes sélectionnées incluent :

Méthodes

Méthode	Description
`asDict`	Renvoie une représentation sous forme de dictionnaire de la ligne, qui est indexée par les noms de champs. S'il y a des noms de champs en double, l'un des champs en double (mais un seul) sera renvoyé dans le dictionnaire. Quel champ en double est renvoyé n'est pas défini.

Méthode	Description
`asDict`	Renvoie une représentation sous forme de dictionnaire de la ligne, qui est indexée par les noms de champs. S'il y a des noms de champs en double, l'un des champs en double (mais un seul) sera renvoyé dans le dictionnaire. Quel champ en double est renvoyé n'est pas défini.

Conversions de type

Le tableau suivant met en correspondance les types de données Apache Spark SQL avec leurs équivalents de type de données Python.

Type de données Apache Spark SQL	Type de données Python
`array`	`numpy.ndarray`
`bigint`	`int`
`binary`	`bytearray`
`boolean`	`bool`
`date`	`datetime.date`
`decimal`	`decimal.Decimal`
`double`	`float`
`int`	`int`
`map`	`str`
`null`	`NoneType`
`smallint`	`int`
`string`	`str`
`struct`	`str`
`timestamp`	`datetime.datetime`
`tinyint`	`int`

Type de données Apache Spark SQL	Type de données Python
`array`	`numpy.ndarray`
`bigint`	`int`
`binary`	`bytearray`
`boolean`	`bool`
`date`	`datetime.date`
`decimal`	`decimal.Decimal`
`double`	`float`
`int`	`int`
`map`	`str`
`null`	`NoneType`
`smallint`	`int`
`string`	`str`
`struct`	`str`
`timestamp`	`datetime.datetime`
`tinyint`	`int`

Collecte de la télémétrie

Le connecteur Databricks SQL pour Python recueille des données de télémétrie pour aider Databricks à améliorer la fiabilité et à résoudre les problèmes. La télémétrie est activée by default et recueille les données opérationnelles suivantes :

Détails de l'environnement client, tels que la version du driver, l'exécution Python et le système d'exploitation
Configurations de connexion Driver (à l'exclusion de toute information personnellement identifiable)
Mesures de latence des opérations
Formats de résultats d'exécution, tels que JSON intégré ou Apache Arrow
Types d'Opérations, tels que l'exécution de query, les query de métadonnées ou les Opérations de volume
Données de classification des erreurs
Nombre de tentatives

important

Databricks ne collecte pas le contenu de query, les résultats de query ou toute information d'identification personnelle (PII) par télémétrie.

Pour désactiver la collecte de télémétrie, définissez le paramètre enable_telemetry sur 0 lors de la création d’une connexion.

Dépannage

Message`tokenAuthWrapperInvalidAccessToken: Invalid access token`

Problème : Lorsque vous exécutez votre code, un message similaire à Error during request to server: tokenAuthWrapperInvalidAccessToken: Invalid access token s'affiche.

Cause possible : La valeur transmise à access_token n’est pas un jeton d’accès personnel Databricks valide.

**Correction recommandée** : Vérifiez que la valeur transmise à access_token est correcte et réessayez.

Message`gaierror(8, 'nodename nor servname provided, or not known')`

Problème : Lorsque vous exécutez votre code, un message similaire à Error during request to server: gaierror(8, 'nodename nor servname provided, or not known') s'affiche.

Cause possible : La valeur transmise à server_hostname n'est pas le host name correct.

**Correction recommandée** : Vérifiez que la valeur transmise à server_hostname est correcte et réessayez.

Pour plus d'informations sur la recherche du hostname du serveur, consultez Obtenir les détails de connexion pour une ressource de calcul Databricks.

Message`IpAclError`

Problème : Lorsque vous exécutez votre code, le message Error during request to server: IpAclValidation s’affiche lorsque vous essayez d’utiliser le connecteur sur un Notebook Databricks.

Cause possible : vous avez peut-être activé la liste d'autorisation d'adresses IP pour le workspace Databricks. Avec la liste d'autorisation d'adresses IP, les connexions depuis les clusters Spark vers le plan de contrôle ne sont pas autorisées par default.

Correction recommandée : Demandez à votre administrateur d'ajouter le sous-réseau du plan de compute à la liste d'autorisation IP.

Ressources supplémentaires

Pour plus d'informations, voir :

Le repository Databricks SQL Connector for Python sur GitHub
Types de données
Types intégrés (pour bool, bytearray, float, int et str) sur le site Web de Python
datetime (pour datetime.date et datatime.datetime) sur le site web Python
décimal (pour decimal.Decimal) sur le site web Python
Constantes intégrées (pour NoneType) sur le site web Python

Exigences​

Get start​

Authentification​

Authentification par jeton d'accès personnel Databricks​

Authentification OAuth machine à machine (M2M)​

Authentification OAuth d'utilisateur à machine (U2M)​

Exemples​

Définir User-Agent​

Query des données​

Tags de query​

Insérer des données​

Métadonnées de la query​

Gérer les curseurs et les connexions​

Gérer les fichiers dans les volumes Unity Catalog​

Configurer la journalisation​

Utilisez l'API d'exécution des instructions​

Test​

Référence de l'API​

Module​

méthode de connexion​

Connection classe​

Méthodes​

Cursor classe​

Attributs​

Méthodes​

Row classe​

Méthodes​

Conversions de type​

Collecte de la télémétrie​

Dépannage​

MessagetokenAuthWrapperInvalidAccessToken: Invalid access token​

Messagegaierror(8, 'nodename nor servname provided, or not known')​

MessageIpAclError​

Ressources supplémentaires​

Exigences

Get start

Authentification

Authentification par jeton d'accès personnel Databricks

Authentification OAuth machine à machine (M2M)

Authentification OAuth d'utilisateur à machine (U2M)

Exemples

Définir User-Agent

Query des données

Tags de query

Insérer des données

Métadonnées de la query

Gérer les curseurs et les connexions

Gérer les fichiers dans les volumes Unity Catalog

Configurer la journalisation

Utilisez l'API d'exécution des instructions

Test

Référence de l'API

Module

méthode de connexion

`Connection` classe

Méthodes

`Cursor` classe

Attributs

Méthodes

`Row` classe

Méthodes

Conversions de type

Collecte de la télémétrie

Dépannage

Message`tokenAuthWrapperInvalidAccessToken: Invalid access token`

Message`gaierror(8, 'nodename nor servname provided, or not known')`

Message`IpAclError`

Ressources supplémentaires