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.10 o versione successiva
Se Python non è già disponibile, installare il runtime Python e la gestione pacchetti pip da python.org.
Non si vuole usare il proprio ambiente? Segui Container e lo sviluppo locale per creare un devcontainer riproducibile o un ambiente di Codespaces su GitHub.
Visual Studio Code con le seguenti estensioni:
- Estensione Python per Visual Studio Code
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. Gli utenti Windows possono saltare questo passaggio. Per dettagli completi sulla piattaforma, vedi Installa mssql-python.

apk add libtool krb5-libs krb5-dev

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

Creare un database SQL

Crea o collegati a un database SQL su una delle seguenti piattaforme:

Creare un database SQL in pochi minuti usando il portale di Azure

Creare un nuovo progetto

Apri un prompt dei comandi nella directory di sviluppo. Se non ne hai una, crea una nuova directory, come python o scripts. Evita le cartelle sul tuo OneDrive, poiché la sincronizzazione può interferire con la gestione del tuo ambiente virtuale.

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

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

Aggiornare la descrizione in modo che sia più descrittiva.

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

Salva e chiudi il file.

Aggiornare main.py

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

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

if __name__ == "__main__":
    main()

In cima al file, aggiungi le seguenti importazioni prima della 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
```

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)

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

Trova questo codice.

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

Sostituirlo con questo codice.

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

Salvare e chiudere main.py.

Salvare la stringa di connessione

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
```
Nella directory corrente creare un nuovo file denominato .env.
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 ripetuti prompt di accesso, accedi una volta tramite la CLI di interfaccia della riga di comando di Azure eseguendo az login, poi usa ActiveDirectoryDefault, che riutilizza la credenziale memorizzata nella cache.

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
```
Il report viene aperto in una nuova scheda nel Web browser.
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.
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.

Passaggi successivi

Usa questi articoli per continuare a costruire:

Guida introduttiva: distribuzioni riproducibili per configurare correttamente un progetto con dipendenze vincolate a una versione specifica.
Costruisci stringhe di connessione per configurare connessioni per diversi tipi di database SQL e metodi di autenticazione.
Esecuzione di query per conoscere i modelli di query, le query parametrizzate e la gestione dei risultati.

Quickstart: Implementazioni ripetibili

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-07-22