Guida introduttiva: Connettersi utilizzando il driver mssql-python per Python

2025-06-26

In questa guida introduttiva si connette uno script Python a un database creato e caricato con dati di esempio. Usare il mssql-python driver per Python per connettersi al database ed eseguire operazioni di base, ad esempio la lettura e la scrittura di dati.

Documentazione di mssql-python | Codice sorgente mssql-python | Pacchetto (PyPi)

Prerequisiti

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.
mssql-python pacchetto di PyPI.
Un database su SQL Server, un database SQL di Azure o un database SQL in Fabric con lo AdventureWorks2022 schema di esempio e una stringa di connessione valida.

Configurazione

Seguire questa procedura per configurare l'ambiente di sviluppo per sviluppare un'applicazione usando il mssql-python driver Python.

Annotazioni

Questo driver usa il protocollo TDS , che è abilitato per impostazione predefinita in SQL Server, nel database SQL in Fabric e nel database SQL di Azure. Non è necessaria alcuna configurazione aggiuntiva.

Installare il pacchetto mssql-python

Ottieni il mssql-python pacchetto da PyPI.

Aprire un prompt dei comandi in una directory vuota.
Installare il pacchetto mssql-python.
```
pip install mssql-python
```

Controllare i pacchetti installati

È possibile usare lo strumento da riga di comando PyPI per verificare che i pacchetti previsti siano installati.

Controllare l'elenco dei pacchetti installati con pip list.
```
pip list
```

Creare un database SQL

Questa avvio rapido richiede lo schema AdventureWorks2022 Lightweight in Microsoft SQL Server, nel database SQL di Fabric o nel database SQL di Azure.

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

Creare un nuovo file

Creare un file denominato app.py.

Aggiungere una docstring del modulo.

"""
Connects to a SQL database using mssql-python
"""

Importare pacchetti, incluso mssql-python.

from os import getenv
from dotenv import load_dotenv
from mssql_python import connect

Usare la mssql-python.connect funzione per connettersi a un database SQL.
```
load_dotenv()
conn = connect(getenv("SQL_CONNECTION_STRING"))
```
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. Per altre informazioni sulle stringhe di connessione e sulla relativa sintassi, vedere informazioni di riferimento sulla sintassi delle stringhe di connessione.

Eseguire una query

Usare una stringa di query SQL per eseguire una query e analizzare i risultati.

Creare una variabile per la stringa di query SQL.

SQL_QUERY = """
SELECT
TOP 5 c.CustomerID,
c.CompanyName,
COUNT(soh.SalesOrderID) AS OrderCount
FROM
SalesLT.Customer AS c
LEFT OUTER JOIN SalesLT.SalesOrderHeader AS soh ON c.CustomerID = soh.CustomerID
GROUP BY
c.CustomerID,
c.CompanyName
ORDER BY
OrderCount DESC;
"""

Utilizzare cursor.execute per recuperare un set di risultati da una query sul database.
```
cursor = conn.cursor()
cursor.execute(SQL_QUERY)
```
Annotazioni

Questa funzione accetta essenzialmente qualsiasi query e restituisce un set di risultati, che può essere iterato con l'uso di cursor.fetchone().

Usare cursor.fetchall con un foreach ciclo per ottenere tutti i record dal database. Stampare quindi i record.

records = cursor.fetchall()
for r in records:
    print(f"{r.CustomerID}\t{r.OrderCount}\t{r.CompanyName}")

Salvare il app.py file.

Aprire un terminale e testare l'applicazione.

python app.py

Ecco l'output previsto.

29485   1       Professional Sales and Service
29531   1       Remarkable Bike Store
29546   1       Bulk Discount Store
29568   1       Coalition Bike Company
29584   1       Futuristic Bikes

Inserire una riga come transazione

Eseguire un'istruzione INSERT in modo sicuro e passare i parametri. Il passaggio di parametri come valori protegge l'applicazione da attacchi SQL injection .

Aggiungere un'importazione per randrange dalla libreria random all'inizio di app.py.
```
from random import randrange
```
Alla fine di app.py aggiungere codice per generare un numero di prodotto casuale.
```
productNumber = randrange(1000)
```
Suggerimento

La generazione di un numero di prodotto casuale qui garantisce che sia possibile eseguire questo esempio più volte.

Creare una stringa di istruzione SQL.

SQL_STATEMENT = """
INSERT SalesLT.Product (
Name,
ProductNumber,
StandardCost,
ListPrice,
SellStartDate
) OUTPUT INSERTED.ProductID
VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
"""

Eseguire l'istruzione usando cursor.execute.

cursor.execute(
    SQL_STATEMENT,
    (
        f'Example Product {productNumber}',
        f'EXAMPLE-{productNumber}',
        100,
        200
    )
)

Recuperare il singolo risultato usando cursor.fetchone, stampare l'identificatore univoco del risultato e quindi eseguire il commit dell'operazione come transazione usando connection.commit.
```
result = cursor.fetchone()
print(f"Inserted Product ID : {result['ProductID']}")
conn.commit()
```
Suggerimento

Facoltativamente, è possibile usare connection.rollback per eseguire il rollback della transazione.
Chiudere il cursore e la connessione usando cursor.close e connection.close.
```
cursor.close()
conn.close()
```
Salvare il app.py file e testare di nuovo l'applicazione.
```
python app.py
```
Ecco l'output previsto.
```
Inserted Product ID : 1001
```

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

Condividi tramite