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

Dans ce guide de démarrage rapide, vous utilisez Streamlit pour créer un rapport rapidement, afin de recueillir les retours des utilisateurs rapidement. Vous utilisez le pilote mssql-python pour Python pour vous connecter à votre base de données et lire les données chargées dans votre rapport.

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.

documentation mssql-python | code source mssql-python | Package (PyPI) | uv

Prerequisites

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.
Visual Studio Code avec les extensions suivantes :
- Extension Python pour Visual Studio Code
Azure Command-Line Interface (CLI) pour l’authentification sans mot de passe sur macOS et Linux.
Si vous n’avez uvpas encore, suivez les instructions d’installation.
Base de données sur SQL Server, Azure SQL Database ou base de données SQL dans Fabric avec l’exemple AdventureWorks2025 de schéma et une chaîne de connexion valide.

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

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éer une base de données SQL en quelques minutes à l’aide du portail Azure

Créer un projet

Ouvrez une invite de commandes dans votre répertoire de développement. Si vous n’en avez pas, créez un nouveau répertoire, tel que python ou scripts. Évitez les dossiers sur votre OneDrive, car la synchronisation peut interférer avec la gestion de votre environnement virtuel.

Créez un projet avec uv.

uv init rapid-prototyping-qs
cd rapid-prototyping-qs

Ajouter des dépendances

Dans le même répertoire, installez les packages mssql-python, streamlit et python-dotenv.

uv add mssql-python python-dotenv streamlit

Lancer Visual Studio Code

Dans le même répertoire, exécutez la commande suivante.

code .

Mettre à jour pyproject.toml

Ouvrez le fichier pyproject.toml dans votre éditeur. Ce fichier contient les métadonnées de votre projet.

Mettez à jour la valeur description.

description = "A quick example of rapid prototyping using the mssql-python driver and Streamlit."

Enregistrez et fermez le fichier.

Mettre à jour main.py

Ouvrez le fichier nommé main.py. Il doit être similaire à cet exemple.

def main():
    print("Hello from rapid-prototyping-qs!")

if __name__ == "__main__":
    main()

En haut du fichier, ajoutez les importations suivantes avant la ligne avec def main().

Conseil / Astuce

Si Visual Studio Code rencontre des difficultés pour résoudre les packages, vous devez mettre à jour l’interpréteur pour utiliser l’environnement virtuel.
```
from os import getenv
from dotenv import load_dotenv
from mssql_python import connect, Connection
import pandas as pd
import streamlit as st
```

Entre les importations et la ligne avec def main(), ajoutez le code suivant.

def page_load() -> None:
    st.set_page_config(
        page_title="View Data",
        page_icon=":bar_chart:",
        layout="wide",
        initial_sidebar_state="expanded"
    )

    st.title("AdventureWorksLT Customer Order History")

    SQL_QUERY = """
    SELECT c.*
    FROM SalesLT.Customer AS c
    INNER JOIN SalesLT.SalesOrderHeader AS soh
        ON c.CustomerID = soh.CustomerID;
    """

    df = load_data(SQL_QUERY)

    event = st.dataframe(
        df,
        use_container_width=True,
        hide_index=True,
        on_select="rerun",
        selection_mode="single-row"
    )

    customer = event.selection.rows

    SPEND_QUERY_ALL = """
    SELECT
        soh.OrderDate,
        SUM(sod.OrderQty),
        SUM(sod.OrderQty * sod.UnitPrice) AS spend,
        pc.Name AS ProductCategory
    FROM SalesLT.SalesOrderDetail AS sod
    INNER JOIN SalesLT.SalesOrderHeader AS soh
        ON sod.SalesOrderID = soh.SalesOrderID
    INNER JOIN SalesLT.Product AS p
        ON sod.ProductID = p.ProductID
    INNER JOIN SalesLT.ProductCategory AS pc
        ON p.ProductCategoryID = pc.ProductCategoryID
    GROUP BY soh.OrderDate, pc.Name
    ORDER BY soh.OrderDate, pc.Name;
    """
    SPEND_QUERY_CUSTOMER = """
    SELECT
        soh.OrderDate,
        SUM(sod.OrderQty),
        SUM(sod.OrderQty * sod.UnitPrice) AS spend,
        pc.Name AS ProductCategory
    FROM SalesLT.SalesOrderDetail AS sod
    INNER JOIN SalesLT.SalesOrderHeader AS soh
        ON sod.SalesOrderID = soh.SalesOrderID
    INNER JOIN SalesLT.Product AS p
        ON sod.ProductID = p.ProductID
    INNER JOIN SalesLT.ProductCategory AS pc
        ON p.ProductCategoryID = pc.ProductCategoryID
    WHERE soh.CustomerID = ?
    GROUP BY soh.OrderDate, pc.Name
    ORDER BY soh.OrderDate, pc.Name;
    """
    if len(customer) == 0:
        spend_df = load_data(SPEND_QUERY_ALL)
    else:
        customer_id = int(df.loc[customer, 'CustomerID'].values[0])
        spend_df = load_data(SPEND_QUERY_CUSTOMER, params=(customer_id,))

    st.write("Here's a summary of spend by product category over time:")
    st.bar_chart(spend_df.set_index('ProductCategory')['spend'], use_container_width=True)

    if len(customer) > 0:
        st.write(f"Displaying orders for Customer ID: {df.loc[customer, 'CustomerID'].values[0]}")
        customer_id = int(df.loc[customer, 'CustomerID'].values[0])
        SQL_QUERY = """
        SELECT *
        FROM SalesLT.SalesOrderHeader AS soh
        WHERE soh.CustomerID = ?;
        """
        st.dataframe(load_data(SQL_QUERY, params=(customer_id,)), hide_index=True, use_container_width=True)
        SQL_QUERY = """
        SELECT sod.*
        FROM SalesLT.SalesOrderHeader AS soh
        INNER JOIN SalesLT.SalesOrderDetail AS sod
            ON soh.SalesOrderID = sod.SalesOrderID
        WHERE soh.CustomerID = ?;
        """
        st.dataframe(load_data(SQL_QUERY, params=(customer_id,)), hide_index=True, use_container_width=True)

Entre les importations et def page_load() -> None:, ajoutez ce code.

_connection = None

def get_connection() -> Connection:
    global _connection
    if not _connection:
        load_dotenv()
        _connection = connect(getenv("SQL_CONNECTION_STRING"))
    return _connection

@st.cache_data
def load_data(SQL_QUERY, params=None) -> pd.DataFrame:
    data = pd.read_sql_query(SQL_QUERY, get_connection(), params=params)
    return data

Recherchez ce code.

def main():
    print("Hello from rapid-prototyping-qs!")

Remplacez-le par ce code.

def main() -> None:
    page_load()
    if _connection:
        _connection.close()

Enregistrez et fermez main.py.

Enregistrer la chaîne de connexion

Ouvrez le .gitignore fichier et ajoutez une exclusion pour .env les fichiers. Votre fichier devrait être similaire à l’exemple suivant.

# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info

# Virtual environments
.venv

# Connection strings and secrets
.env

Enregistrez et fermez .gitignore.
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. Remplacez les espaces réservés par vos valeurs réelles.
```
SQL_CONNECTION_STRING="Server=<server>;Database=<database>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"
```
La chaîne de connexion dépend du type de base de données SQL à laquelle vous vous connectez. Pour Azure SQL Database ou SQL Database dans Fabric, utilisez la chaîne de connexion ODBC depuis l’onglet des chaînes de connexion, et ajustez le type d’authentification pour votre scénario. Pour plus d’informations sur la syntaxe des chaîne de connexion, voir Chaînes de connexion pour mssql-python.

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 invites de connexion répétées, connectez-vous une fois avec la commande Azure CLIaz login, et utilisez la commande ActiveDirectoryDefault. ActiveDirectoryDefault Réutilise les informations d’identification mises en cache.

Utilisez uv run pour exécuter le script

Dans la fenêtre de terminal à partir de l’avant, ou une nouvelle fenêtre de terminal ouverte au même répertoire, exécutez la commande suivante.
```
uv run streamlit run main.py
```
Votre rapport s’ouvre dans un nouvel onglet dans votre navigateur web.
Essayez votre rapport pour voir comment il fonctionne. Si vous modifiez quoi que ce soit, enregistrez main.py et utilisez l’option de rechargement dans le coin supérieur droit de la fenêtre du navigateur.
Pour partager votre prototype, copiez tous les fichiers à l’exception du .venv dossier sur l’autre ordinateur. Le .venv dossier est recréé avec la première exécution.

Commentaires

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

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