Démarrage rapide : Se connecter avec le pilote mssql-python pour Python

Dans ce guide de démarrage rapide, vous connectez un script Python à une base de données que vous avez créée et chargée avec des exemples de données. Vous utilisez le mssql-python pilote pour Python pour vous connecter à votre base de données et effectuer des opérations de base, telles que la lecture et l’écriture de données.

Le mssql-python pilote ne nécessite aucune dépendance externe sur les machines Windows. Le pilote installe tout ce dont il a besoin avec une seule pip installation, ce qui vous permet d’utiliser la dernière version du pilote pour les nouveaux scripts sans interrompre d’autres scripts que vous n’avez pas le temps de mettre à niveau et de tester.

Utilisez l’exemple d’authentification SQL locale dans cet article uniquement pour le développement local sur une instance SQL Server que vous contrôlez. Pour Azure SQL Database, SQL Database in Fabric, environnements de développement partagés, CI et déploiements en production, commencez par l’authentification Microsoft Entra ou un autre flux sans mot de passe.

documentation mssql-python | code source mssql-python | Package (PyPI) | Visual Studio Code

Conditions préalables

Python 3.10 ou version ultérieure
Si vous n’avez pas encore Python, installez le runtime Python et le gestionnaire de package pip à partir de python.org.
Ne souhaitez pas utiliser votre propre environnement ? Suivez Container et le développement local pour créer un devcontainer reproductible ou un environnement GitHub Codespaces.
(Facultatif) Interface Azure en ligne de commande (CLI)

Créez ou connectez-vous à une base de données sur SQL Server, Azure SQL Database ou base de données SQL dans Fabric. Utilisez les étapes suivantes pour configurer une base de données avec le schéma d’exempleAdventureWorks2025, et gardez la chaîne de connexion pour plus tard.

Créer une base de données SQL

Créer ou connecter une base de données SQL sur l’une des plateformes suivantes :

Créez une base de données SQL sur le portail Azure en quelques minutes

Configuration

Suivez ces étapes pour configurer votre environnement de développement pour développer une application à l’aide du mssql-python pilote Python.

Remarque

Ce pilote utilise le protocole Tabular Data Stream (TDS ). SQL Server, la base de données SQL dans Fabric et Azure SQL Database activent le TDS par défaut, donc aucune configuration supplémentaire n’est nécessaire.

Installer le package mssql-python

Obtenez le package mssql-python à partir de PyPI.

Ouvrez une invite de commandes dans un répertoire de fichiers vide.

Installez le package mssql-python.

pip install mssql-python

apk add libtool krb5-libs krb5-dev
pip install mssql-python

apt-get install -y libltdl7 libkrb5-3 libgssapi-krb5-2
pip install mssql-python

dnf install -y libtool-ltdl krb5-libs
pip install mssql-python

zypper install -y libltdl7 libkrb5-3 libgssapi-krb5-2
pip install mssql-python

zypper install -y libltdl7
pip install mssql-python

brew install openssl
pip install mssql-python

Installer le package python-dotenv

Obtenez le python-dotenv package depuis PyPI.

Dans le même répertoire, installez le python-dotenv package.
```
pip install python-dotenv
```

Vérifiez les packages installés

Vous pouvez utiliser l’outil en ligne de commande PyPI pour vérifier que les packages prévus sont installés.

Vérifiez la liste des packages installés avec pip list.
```
pip list
```

Exécuter le code

Créer un fichier
Exécuter une requête
Insérer une ligne en tant que transaction

Créer un nouveau fichier

Créez un nouveau fichier appelé app.py.

Ajoutez une description docstring du module.

"""
Connects to a SQL database using mssql-python
"""

Importer des packages, y compris mssql-python.

from os import getenv
from dotenv import load_dotenv
from mssql_python import connect

Utilisez la fonction mssql-python.connect pour vous connecter à une base de données SQL.
```
load_dotenv()
conn = connect(getenv("SQL_CONNECTION_STRING"))
```
Dans le répertoire actif, créez un fichier nommé .env.
Dans le .env fichier, ajoutez une entrée pour votre chaîne de connexion nommée SQL_CONNECTION_STRING. Utilisez l’un des exemples suivants et remplacez les espaces réservés par vos valeurs réelles.

Pour Azure SQL Database ou une base de données SQL dans Fabric, commencez par l’authentification Microsoft Entra :
```
SQL_CONNECTION_STRING="Server=<server_name>;Database=<database_name>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
Pour le SQL Server local pendant le développement, commencez par l’authentification SQL :
```
SQL_CONNECTION_STRING="Server=localhost,1433;Database=<database_name>;UID=<username>;PWD=<password>;Encrypt=yes;TrustServerCertificate=yes"
```
Caution

Considérez .env cela comme une commodité de développement local, pas comme un mécanisme de déploiement. Ne jamais le valider, ne jamais réutiliser cet exemple d’authentification SQL dans des environnements partagés ou de production, et garder la validation des certificats activée en dehors du développement local.

Utilisez des chaînes de connexion pour adapter l’échantillon aux instances nommées, conteneurs ou paramètres avancés. Si vous vous connectez à Azure SQL Database ou SQL Database dans Fabric, utilisez l'authentification Microsoft Entra pour des options de connexion interactive et sans mot de passe. Pour des conseils plus larges sur les secrets et certificats, consultez les meilleures pratiques en matière de sécurité.

Exécuter une requête

Utilisez une chaîne de requête SQL pour exécuter une requête et analyser les résultats.

Créez une variable pour la chaîne de requête SQL.

SQL_QUERY = """
SELECT
TOP 5 c.CustomerID,
c.CompanyName,
COUNT(soh.SalesOrderID) AS OrderCount
FROM
SalesLT.Customer AS c
LEFT OUTER JOIN SalesLT.SalesOrderHeader AS soh ON c.CustomerID = soh.CustomerID
GROUP BY
c.CustomerID,
c.CompanyName
ORDER BY
OrderCount DESC;
"""

Utilisez cursor.execute pour récupérer un jeu de résultats à partir d’une requête sur la base de données.
```
cursor = conn.cursor()
cursor.execute(SQL_QUERY)
```
Remarque

Cette fonction accepte essentiellement toute requête et renvoie un ensemble de résultats. Pour itérer sur l’ensemble de résultats, utilisez cursor.fetchone().
Utilisez cursor.fetchall avec une boucle for pour obtenir tous les enregistrements de la base de données. Ensuite, imprimez les dossiers.
```
records = cursor.fetchall()
for r in records:
  print(f"{r.CustomerID}\t{r.OrderCount}\t{r.CompanyName}")
```
Enregistrez le app.py fichier.

Conseil / Astuce

Sur macOS, les deux ActiveDirectoryInteractive et ActiveDirectoryDefault fonctionnent pour l’authentification Microsoft Entra. ActiveDirectoryInteractive vous invite à vous connecter chaque fois que vous exécutez le script. Pour éviter les demandes de connexion répétées, connectez-vous une fois via l’interface Azure CLI en exécutant az login, puis utilisez ActiveDirectoryDefault, qui réutilise l’identifiant mis en cache.

Ouvrez un terminal et testez l’application.

python app.py

Voici la sortie attendue.

29485   1       Professional Sales and Service
29531   1       Remarkable Bike Store
29546   1       Bulk Discount Store
29568   1       Coalition Bike Company
29584   1       Futuristic Bikes

Insérer une ligne en tant que transaction

Exécutez une INSERT instruction en toute sécurité et transmettez des paramètres. Le passage de paramètres en tant que valeurs protège votre application contre les attaques par injection SQL .

Ajoutez une instruction d'importation pour randrange depuis la bibliothèque random en haut de app.py.
```
from random import randrange
```
À la fin de app.py, ajoutez du code pour générer un numéro de produit aléatoire.
```
productNumber = randrange(1000)
```
Conseil / Astuce

Générer un numéro de produit aléatoire ici vous garantit de pouvoir exécuter cet exemple plusieurs fois.

Créez une chaîne d’instruction SQL.

SQL_STATEMENT = """
INSERT SalesLT.Product (
Name,
ProductNumber,
StandardCost,
ListPrice,
SellStartDate
) OUTPUT INSERTED.ProductID
VALUES (%(name)s, %(product_number)s, %(standard_cost)s, %(list_price)s, CURRENT_TIMESTAMP)
"""

Exécutez l’instruction à l’aide de cursor.execute.

cursor.execute(
   SQL_STATEMENT,
   {
      'name': f'Example Product {productNumber}',
      'product_number': f'EXAMPLE-{productNumber}',
      'standard_cost': 100,
      'list_price': 200
   }
)

Récupérez le résultat unique à l’aide de cursor.fetchone, imprimez l’identificateur unique du résultat, puis validez l’opération en tant que transaction à l’aide de connection.commit.
```
result = cursor.fetchone()
print(f"Inserted Product ID : {result.ProductID}")
conn.commit()
```
Conseil / Astuce

Si vous le souhaitez, vous pouvez utiliser connection.rollback pour restaurer la transaction.
Fermez le curseur et la connexion à l’aide de cursor.close et connection.close.
```
cursor.close()
conn.close()
```
Enregistrez le fichier et app.py à nouveau l’application.
```
python app.py
```
Voici la sortie attendue.
```
Inserted Product ID : 1001
```

Étapes suivantes

Utilisez ces articles pour continuer à construire :

Chaînes de connexion pour adapter l’exemple pour SQL Server local, Azure SQL, conteneurs et instances nommées.
Gestion de connexion pour utiliser des gestionnaires de contexte, le pooling et les paramètres de connexion.
Dépannage pour diagnostiquer les problèmes d’authentification, de certificat et de connectivité.

Chaînes de connexion

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-07-22