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 rapidement un rapport, ce qui vous permet de recueillir rapidement les commentaires des utilisateurs pour vous assurer que vous êtes sur la bonne voie. Vous utilisez le mssql-python pilote 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 | code | Package (PyPI) | Uv

Prerequisites

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

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 le projet et exécuter le code

Créer un projet

  1. 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.

  2. 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

  1. Pyproject.toml contient les métadonnées de votre projet. Ouvrez le fichier dans votre éditeur favori.

  2. Mettez à jour la description pour être plus descriptive.

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

  3. Enregistrez et fermez le fichier.

Mettre à jour main.py

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

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

if __name__ == "__main__":
    main()

  2. 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

  3. 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] c inner join SalesLT.SalesOrderHeader 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 sod inner join SalesLT.SalesOrderHeader soh on sod.salesorderid = soh.salesorderid inner join SalesLT.Product p on sod.productid = p.productid inner join SalesLT.ProductCategory 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 sod inner join SalesLT.SalesOrderHeader soh on sod.salesorderid = soh.salesorderid inner join SalesLT.Product p on sod.productid = p.productid inner join SalesLT.ProductCategory 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] 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] soh INNER JOIN SalesLT.SalesOrderDetail sod on soh.SalesOrderId = sod.SalesOrderId WHERE CustomerID = ?;"""
       st.dataframe(load_data(SQL_QUERY, params=(customer_id,)), hide_index=True, use_container_width=True)

  4. 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

  5. Recherchez ce code.

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

  6. Remplacez-le par ce code.

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

  7. Enregistrez et fermez main.py.

Enregistrer la chaîne de connexion

  1. Ouvrez le .gitignore fichier et ajoutez une exclusion pour .env les fichiers. Votre fichier doit être similaire à cet exemple. Veillez à l’enregistrer et à le fermer lorsque vous avez terminé.

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

# Virtual environments
.venv

# Connection strings and secrets
.env

  2. Dans le répertoire actif, créez un fichier nommé .env.

  3. Dans le .env fichier, ajoutez une entrée pour votre chaîne de connexion nommée SQL_CONNECTION_STRING. Remplacez l’exemple ici par votre valeur de chaîne de connexion réelle.

    SQL_CONNECTION_STRING="Server=<server_name>;Database=<database_name>;Encrypt=yes;TrustServerCertificate=no;Authentication=ActiveDirectoryInteractive"

    Conseil / Astuce

    La chaîne de connexion utilisée ici dépend en grande partie du type de base de données SQL à laquelle vous vous connectez. Si vous vous connectez à une base de données Azure SQL ou à une base de données SQL dans Fabric, utilisez la chaîne de connexion ODBC à partir de l’onglet chaînes de connexion. Vous devrez peut-être ajuster le type d’authentification en fonction de votre scénario. Pour plus d’informations sur les chaînes de connexion et leur syntaxe, consultez la référence de la syntaxe des chaînes de connexion.

Utilisez uv run pour exécuter le script

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.

  1. 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

  2. Votre rapport s’ouvre dans un nouvel onglet dans votre navigateur web.

  3. 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.

  4. 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.

Étapes suivantes

Utilisez ces articles pour continuer à construire :

Démarrage rapide : Déploiements répétables

  • Last updated on