Avvio rapido: Connettersi a un database SQL in Fabric con il Microsoft Python Driver per SQL Server

In questo quickstart si utilizza Streamlit per creare rapidamente un report, consentendo di raccogliere rapidamente commenti e suggerimenti degli utenti per assicurarsi di essere sulla giusta strada. Si utilizza il driver mssql-python per Python per connettersi al tuo database SQL in Fabric 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 mssql-python | Pacchetto (PyPi) | UV

Prerequisiti

Caricare i dati di esempio AdventureWorks nel database SQL.
Python 3
- Se Python non è già disponibile, installare la gestione pacchetti Python runtime e Python Package Index (PyPI) da python.org.
- Preferisce non usare il proprio ambiente? Apri come devcontainer usando GitHub Codespaces.
Visual Studio Code con le seguenti estensioni:
- Estensione Python per Visual Studio Code
- (Facoltativo) Azure Repos
(Facoltativo) Interfaccia Command-Line di Azure
Se non si dispone già di uv, eseguire l'installazione uv seguendo le istruzioni fornite da https://docs.astral.sh/uv/getting-started/installation/.

Installare prerequisiti specifici del sistema operativo monouso.

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 nuovo progetto

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.

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-protyping-qs!")

 if __name__ == "__main__":
   main()

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

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,
       width='stretch',
       hide_index=True,
       on_select="rerun",
       selection_mode="single-row"
   )

   customer = event.selection.rows

   if len(customer) == 0:
       SQL_QUERY = """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;"""
   else:
       SQL_QUERY = f"""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 = {df.loc    [customer, 'CustomerID'].values[0]} GROUP BY soh.OrderDate, pc.Name ORDER BY soh.OrderDate, pc.Name;"""

   st.write("Here's a summary of spend by product category over time:")
   st.bar_chart(load_data(SQL_QUERY).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]}")
       SQL_QUERY = f"""SELECT * FROM [SalesLT].[SalesOrderHeader] soh  WHERE soh.CustomerID = {df.loc[customer, 'CustomerID'].values[0]};"""
       st.dataframe(load_data(SQL_QUERY), hide_index=True, width='stretch')
       SQL_QUERY = f"""SELECT sod.* FROM [SalesLT].[SalesOrderHeader] soh INNER JOIN SalesLT.SalesOrderDetail sod on soh.SalesOrderId = sod.SalesOrderId WHERE CustomerID = {df.loc[customer, 'CustomerID'].values[0]};"""
       st.dataframe(load_data(SQL_QUERY), hide_index=True, width='stretch')

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) -> pd.DataFrame:
    data = pd.read_sql_query(SQL_QUERY, get_connection())
    return data

Trova questo codice.

def main():
    print("Hello from rapid-protyping-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"
```

Usare uv run per eseguire lo script

Suggerimento

Per usare l'autenticazione di Microsoft Entra in macOS, è necessario eseguire l'accesso tramite l'estensione Azure Repos in Visual Studio Code o utilizzando az login tramite l'interfaccia a riga di comando di Azure.

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.

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

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-11-18