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 Python pour vous connecter à votre base de données et effectuer des opérations basiques, comme lire et écrire des 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.
(Optionnel) Azure Command-Line Interface (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.

Prérequis pour installer le système d’exploitation

Installez les prérequis ponctuels spécifiques au système d'exploitation. Les utilisateurs Windows peuvent sauter cette étape. Pour tous les détails sur la plateforme, voir Installer mssql-python.

apk add libtool krb5-libs krb5-dev libstdc++

apt-get install -y libltdl7 libkrb5-3 libgssapi-krb5-2

dnf install -y libtool-ltdl krb5-libs

zypper install -y libltdl7 libkrb5-3 libgssapi-krb5-2

zypper install -y libltdl7

brew install openssl

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
```

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

Utilisez pip list pour vérifier que les packages prévus sont installés.

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>;Database=<database>;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>;UID=<user_id>;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é.

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 avec la commande Azure CLIaz login et utilisez ActiveDirectoryDefault. ActiveDirectoryDefault Réutilise les informations d’identification mises en cache.

Exécuter une requête

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

Créez une variable pour la chaîne de requête T-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 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.

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

Un nombre de produit aléatoire réduit le risque d’une erreur de clé en double lorsque vous exécutez cet échantillon plusieurs fois.

Créez une chaîne d’instruction T-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
```

Commentaires

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

Dernière mise à jour : 2026-10-19