Condividi tramite

Guida introduttiva: Creazione rapida di prototipi con il driver mssql-python per Python

In questo argomento di avvio rapido si usa Streamlit per creare rapidamente un report, consentendo di raccogliere rapidamente commenti e suggerimenti degli utenti per assicurarsi di essere sulla giusta strada. Usare il mssql-python driver per Python per connettersi al database e leggere i dati caricati nel report.

Il mssql-python driver non richiede dipendenze esterne nei computer Windows. Il driver installa tutti gli elementi necessari con un'unica pip installazione, consentendo di usare la versione più recente del driver per i nuovi script senza interrompere altri script che non è necessario aggiornare e testare.

Documentazione di mssql-python | Codice sorgente di mssql-python | Pacchetto (PyPI) | uv

Prerequisiti

  • Python 3

    • Se Python non è già disponibile, installare il runtime Python e la gestione pacchetti pip da python.org.

    • Non si vuole usare il proprio ambiente? Apri come devcontainer usando GitHub Codespaces.

  • Visual Studio Code con le seguenti estensioni:

  • Interfaccia Command-Line di Azure per l'autenticazione senza password in macOS e Linux.

  • Se non hai già uv, segui le istruzioni di installazione.

  • Un database su SQL Server, un database SQL di Azure o un database SQL in Fabric con lo AdventureWorks2025 schema di esempio e una stringa di connessione valida.

  • Installare prerequisiti specifici del sistema operativo monouso.

    apk add libtool krb5-libs krb5-dev

Creare un database SQL

Questa guida introduttiva richiede lo schema AdventureWorks2025 Lightweight, su Microsoft SQL Server, nel database SQL di Fabric o nel database SQL di Azure.

Creare il progetto ed eseguire il codice

Creare un nuovo progetto

  1. Apri un prompt dei comandi nella directory di sviluppo. Se non è disponibile, creare una nuova directory denominata python, scriptse così via. Evitare cartelle in OneDrive, la sincronizzazione può interferire con la gestione dell'ambiente virtuale.

  2. Creare un nuovo progetto con uv.

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

Aggiungere dipendenze

Nella stessa directory installare i pacchetti mssql-python, streamlit e python-dotenv.

uv add mssql-python python-dotenv streamlit

Avviare Visual Studio Code

Nella stessa directory eseguire il comando seguente.

code .

Aggiornare pyproject.toml

  1. Pyproject.toml contiene i metadati per il progetto. Aprire il file nell'editor preferito.

  2. Aggiornare la descrizione in modo che sia più descrittiva.

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

  3. Salva e chiudi il file.

Aggiornare main.py

  1. Aprire il file denominato main.py. Dovrebbe essere simile a questo esempio.

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

 if __name__ == "__main__":
   main()

  2. Nella parte superiore del file aggiungere le importazioni seguenti sopra la riga con def main().

    Suggerimento

    Se Visual Studio Code non riesce a risolvere i pacchetti, è necessario aggiornare l'interprete per usare l'ambiente virtuale.

    from os import getenv
from dotenv import load_dotenv
from mssql_python import connect, Connection
import pandas as pd
import streamlit as st

  3. Tra le importazioni e la riga con def main(), aggiungere il codice seguente.

    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. Tra le importazioni e def page_load() -> None:, aggiungere questo codice.

    _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. Trova questo codice.

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

  6. Sostituirlo con questo codice.

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

  7. Salvare e chiudere main.py.

Salvare la stringa di connessione

  1. Aprire il .gitignore file e aggiungere un'esclusione per .env i file. Il file dovrebbe essere simile a questo esempio. Assicurati di salvarlo e chiuderlo quando hai finito.

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

# Virtual environments
.venv

# Connection strings and secrets
.env

  2. Nella directory corrente creare un nuovo file denominato .env.

  3. All'interno del .env file aggiungere una voce per la stringa di connessione denominata SQL_CONNECTION_STRING. Sostituire l'esempio qui con il valore effettivo della stringa di connessione.

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

    Suggerimento

    La stringa di connessione usata qui dipende in gran parte dal tipo di database SQL a cui ci si connette. Se ci si connette a un database SQL di Azure o a un database SQL in Fabric, usare la stringa di connessione ODBC dalla scheda Stringhe di connessione. Potrebbe essere necessario modificare il tipo di autenticazione a seconda dello scenario. Per altre informazioni sulle stringhe di connessione e sulla relativa sintassi, vedere informazioni di riferimento sulla sintassi delle stringhe di connessione.

Usare uv run per eseguire lo script

Suggerimento

In macOS, entrambi ActiveDirectoryInteractive e ActiveDirectoryDefault funzionano per l'autenticazione di Microsoft Entra. ActiveDirectoryInteractive richiede di accedere ogni volta che si esegue lo script. Per evitare richieste di accesso ripetute, accedere una sola volta tramite l'interfaccia della riga di comando di Azure eseguendo az login, quindi usare ActiveDirectoryDefault, che riutilizza le credenziali memorizzate nella cache.

  1. Nella finestra del terminale precedente o in una nuova finestra del terminale aperta nella stessa directory eseguire il comando seguente.

     uv run streamlit run main.py

  2. Il report viene aperto in una nuova scheda nel Web browser.

  3. Prova il tuo report per vedere come funziona. Se si modifica qualcosa, salvare main.py e usare l'opzione ricarica nell'angolo superiore destro della finestra del browser.

  4. Per condividere il prototipo, copiare tutti i file ad eccezione della .venv cartella nell'altro computer. La .venv cartella viene ricreata con la prima esecuzione.

Passo successivo

Per altri esempi, visitare il mssql-python repository GitHub del driver per contribuire a idee o segnalare problemi.

Driver mssql-python su GitHub

  • Last updated on