Pattern asincroni con mssql-python

Il driver mssql-python utilizza I/O sincrono e non fornisce supporto nativo async/await . L'asincronismo nativo è presente nella roadmap dei driver. Fino ad allora, puoi integrare mssql-python con applicazioni asincrone utilizzando questi pattern di soluzione temporanea:

Esecutori di pool di thread per scaricare chiamate bloccanti.
Wrapper asincroni attorno alle operazioni sincrone.
Integrazione con framework asincroni come FastAPI.

Note

I pattern in questo articolo servono ThreadPoolExecutor a eseguire chiamate sincrone mssql-python in thread di background. Questo approccio introduce un overhead dovuto al threading rispetto ai driver asincroni nativi. Per i carichi di lavoro di database legati a I/O, l'overhead è generalmente accettabile.

Quando usare i pattern asincroni

L'approccio thread-pool funziona bene quando:

La tua applicazione già utilizza asyncio (ad esempio, FastAPI, aiohttp o bot Discord) e devi integrare chiamate al database senza bloccare il ciclo degli eventi.
Le query del database sono legate all'I/O, non alla CPU. Il pool di thread permette al ciclo di eventi di gestire altre richieste mentre aspetta Microsoft SQL.
Hai un livello di concorrenza moderato (decine di query concorrenti, non migliaia).

Per applicazioni puramente sincrone, si evitano questi pattern. Usa il driver direttamente con codice sincrono per un'esecuzione diretta e a basso sovraccarico.

Modello del pool di thread

I seguenti esempi mostrano come avvolgere chiamate sincrone mssql-python in un ThreadPoolExecutor per l'uso con asyncio.

Wrapper asincrono di base

Crea una semplice funzione helper che esegua operazioni sincrone mssql-python nel pool di thread e attenda il risultato.

import asyncio
from concurrent.futures import ThreadPoolExecutor
import mssql_python
from functools import partial
from typing import Any, Callable

# Create a dedicated thread pool for database operations
db_executor = ThreadPoolExecutor(max_workers=10, thread_name_prefix="db_")

async def run_in_executor(func: Callable, *args, **kwargs) -> Any:
    """Run a synchronous function in the thread pool."""
    loop = asyncio.get_running_loop()
    if kwargs:
        func = partial(func, **kwargs)
    return await loop.run_in_executor(db_executor, func, *args)

# Database functions
def _execute_query(connection_string: str, query: str, params: dict = None) -> list:
    """Synchronous query execution."""
    conn = mssql_python.connect(connection_string)
    cursor = conn.cursor()
    try:
        cursor.execute(query, params or {})
        if cursor.description:
            columns = [col[0] for col in cursor.description]
            return [dict(zip(columns, row)) for row in cursor.fetchall()]
        return []
    finally:
        cursor.close()
        conn.close()

def _execute_scalar(connection_string: str, query: str, params: dict = None) -> Any:
    """Synchronous scalar query."""
    conn = mssql_python.connect(connection_string)
    cursor = conn.cursor()
    try:
        cursor.execute(query, params or {})
        return cursor.fetchval()
    finally:
        cursor.close()
        conn.close()

# Async interfaces
async def async_query(connection_string: str, query: str, params: dict = None) -> list:
    """Execute query asynchronously."""
    return await run_in_executor(_execute_query, connection_string, query, params)

async def async_scalar(connection_string: str, query: str, params: dict = None) -> Any:
    """Execute scalar query asynchronously."""
    return await run_in_executor(_execute_scalar, connection_string, query, params)

# Usage
async def main():
    conn_str = "Server=<server>.database.windows.net;Database=<database>;Authentication=ActiveDirectoryDefault;Encrypt=yes"
    
    # Execute query asynchronously
    products = await async_query(conn_str, "SELECT * FROM Production.Product WHERE ProductSubcategoryID = %(cat)s", {"cat": 5})
    print(f"Found {len(products)} products")
    
    # Execute scalar asynchronously
    count = await async_scalar(conn_str, "SELECT COUNT(*) FROM Production.Product")
    print(f"Total products: {count}")

asyncio.run(main())

Note

Questo esempio attende le due query una dopo l'altra, quindi vengono eseguite in sequenza. La await parola chiave libera il ciclo eventi per eseguire altri compiti mentre ogni query è in attesa, ma non sovrappone queste due query tra loro. Per eseguire query indipendenti contemporaneamente, programmale insieme a asyncio.gather, come mostrato nella sezione Async connection pool :

products, count = await asyncio.gather(
    async_query(conn_str, "SELECT * FROM Production.Product WHERE ProductSubcategoryID = %(cat)s", {"cat": 5}),
    async_scalar(conn_str, "SELECT COUNT(*) FROM Production.Product"),
)

Pool di connessioni asincrone

Questa sezione mostra come costruire un wrapper async-friendly attorno al pool di connessione integrato di mssql-python per l'uso nelle asyncio applicazioni.

Note

Il driver mssql-python include un sistema di pooling delle connessioni integrato. Il pool asincrono mostrato qui avvolge connessioni pool sincrone con gestori di contesto asincroni per l'uso nelle asyncio applicazioni. Non è necessario gestire un pool personalizzato se chiami mssql-python solo da un thread pool executor.

Classe di database asincrono aggregato

Costruire una classe di pool di connessioni asincrone riutilizzabile che gestisca una coda di connessioni mssql-python e fornisca metodi asincronici per l'esecuzione delle query.

import asyncio
from concurrent.futures import ThreadPoolExecutor
from contextlib import asynccontextmanager
from typing import Any, Optional
import mssql_python
from dataclasses import dataclass
from queue import Queue, Empty
import threading

@dataclass
class PooledConnection:
    """Wrapper for pooled connection."""
    connection: Any
    cursor: Any
    in_use: bool = False

class AsyncDatabasePool:
    """Async-friendly connection pool for mssql-python."""
    
    def __init__(self, connection_string: str, pool_size: int = 10):
        self.connection_string = connection_string
        self.pool_size = pool_size
        self._pool: Queue[PooledConnection] = Queue(maxsize=pool_size)
        self._executor = ThreadPoolExecutor(max_workers=pool_size, thread_name_prefix="dbpool_")
        self._lock = threading.Lock()
        self._initialized = False
    
    async def initialize(self):
        """Initialize the connection pool."""
        if self._initialized:
            return
        
        loop = asyncio.get_running_loop()
        
        async def create_connection():
            def _create():
                conn = mssql_python.connect(self.connection_string)
                cursor = conn.cursor()
                return PooledConnection(connection=conn, cursor=cursor)
            return await loop.run_in_executor(self._executor, _create)
        
        # Create initial connections
        tasks = [create_connection() for _ in range(self.pool_size)]
        connections = await asyncio.gather(*tasks)
        
        for conn in connections:
            self._pool.put(conn)
        
        self._initialized = True
    
    async def acquire(self, timeout: float = 30.0) -> PooledConnection:
        """Acquire a connection from the pool."""
        loop = asyncio.get_running_loop()
        
        def _acquire():
            try:
                conn = self._pool.get(timeout=timeout)
                conn.in_use = True
                return conn
            except Empty:
                raise TimeoutError("Could not acquire connection from pool")
        
        return await loop.run_in_executor(self._executor, _acquire)
    
    def release(self, conn: PooledConnection):
        """Release a connection back to the pool."""
        conn.in_use = False
        try:
            conn.connection.commit()
        except Exception:
            conn.connection.rollback()
        self._pool.put(conn)
    
    @asynccontextmanager
    async def connection(self):
        """Async context manager for getting a connection."""
        conn = await self.acquire()
        try:
            yield conn
        except Exception:
            conn.connection.rollback()
            raise
        else:
            conn.connection.commit()
        finally:
            self.release(conn)
    
    async def execute(self, query: str, params: dict = None) -> list:
        """Execute query and return results."""
        async with self.connection() as conn:
            loop = asyncio.get_running_loop()
            
            def _execute():
                conn.cursor.execute(query, params or {})
                if conn.cursor.description:
                    columns = [col[0] for col in conn.cursor.description]
                    return [dict(zip(columns, row)) for row in conn.cursor.fetchall()]
                return []
            
            return await loop.run_in_executor(self._executor, _execute)
    
    async def execute_scalar(self, query: str, params: dict = None) -> Any:
        """Execute query and return single value."""
        async with self.connection() as conn:
            loop = asyncio.get_running_loop()
            
            def _execute():
                conn.cursor.execute(query, params or {})
                return conn.cursor.fetchval()
            
            return await loop.run_in_executor(self._executor, _execute)
    
    async def close(self):
        """Close all connections in the pool."""
        while not self._pool.empty():
            try:
                conn = self._pool.get_nowait()
                conn.cursor.close()
                conn.connection.close()
            except Empty:
                break
        
        self._executor.shutdown(wait=True)

# Usage
async def main():
    pool = AsyncDatabasePool("Server=<server>.database.windows.net;Database=<database>;Authentication=ActiveDirectoryDefault;Encrypt=yes", pool_size=5)
    await pool.initialize()
    
    try:
        # Execute queries concurrently
        tasks = [
            pool.execute("SELECT * FROM Production.Product WHERE ProductSubcategoryID = %(cat)s", {"cat": i})
            for i in range(1, 6)
        ]
        results = await asyncio.gather(*tasks)
        
        for i, products in enumerate(results, 1):
            print(f"Category {i}: {len(products)} products")
        
        # Single scalar query
        total = await pool.execute_scalar("SELECT COUNT(*) FROM Production.Product")
        print(f"Total: {total}")
    finally:
        await pool.close()

# Only run the demo when this file is executed directly, not when imported.
if __name__ == "__main__":
    asyncio.run(main())

Integrazione con FastAPI

Il context manager di FastAPI lifespan gestisce automaticamente l'inizializzazione e la pulizia del pool.

FastAPI async con mssql-python

Questo esempio si basa sulla sezione Async connection pool . Salva il codice di quella sezione in un file chiamato db.py, e poi crea la seguente app FastAPI in un file chiamato main.py accanto. L'esempio del pool protegge la demo con if __name__ == "__main__":, quindi l'importazione di db.py non esegue la demo. Questa app usa il gestore di contesto lifespan per inizializzare il pool all'avvio e pulirlo all'arresto.

from fastapi import FastAPI, Depends, HTTPException
from contextlib import asynccontextmanager
from typing import Optional
import asyncio

from db import AsyncDatabasePool  # The pool class from the previous section

# Initialize pool on startup
pool: Optional[AsyncDatabasePool] = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    """Manage database pool lifecycle."""
    global pool
    pool = AsyncDatabasePool(
        "Server=<server>.database.windows.net;Database=<database>;Authentication=ActiveDirectoryDefault;Encrypt=yes",
        pool_size=10
    )
    await pool.initialize()
    yield
    await pool.close()

app = FastAPI(lifespan=lifespan)

async def get_db():
    """Dependency for database access."""
    return pool

@app.get("/products")
async def list_products(db: AsyncDatabasePool = Depends(get_db)):
    products = await db.execute("SELECT ProductID, Name, ListPrice FROM Production.Product")
    return {"products": products}

@app.get("/products/{product_id}")
async def get_product(product_id: int, db: AsyncDatabasePool = Depends(get_db)):
    products = await db.execute(
        "SELECT ProductID, Name, ListPrice FROM Production.Product WHERE ProductID = %(id)s",
        {"id": product_id}
    )
    if not products:
        raise HTTPException(status_code=404, detail="Product not found")
    return products[0]

@app.get("/stats")
async def get_stats(db: AsyncDatabasePool = Depends(get_db)):
    # Execute multiple queries concurrently
    product_count, subcategory_count, total_value = await asyncio.gather(
        db.execute_scalar("SELECT COUNT(*) FROM Production.Product"),
        db.execute_scalar("SELECT COUNT(*) FROM Production.ProductSubcategory"),
        db.execute_scalar("SELECT SUM(ListPrice) FROM Production.Product"),
    )
    
    return {
        "products": product_count,
        "subcategories": subcategory_count,
        "total_value": float(total_value) if total_value else 0
    }

Installa le dipendenze ed esegui l'app con un server ASGI come Uvicorn. Esegui questo comando dalla cartella che contiene main.py e db.py:

pip install fastapi uvicorn mssql-python
uvicorn main:app --reload

Con il server in esecuzione, apri http://127.0.0.1:8000/products, http://127.0.0.1:8000/products/1 oppure http://127.0.0.1:8000/stats per richiamare ciascun endpoint.

Attività in background

Esegui operazioni periodiche sul database a intervalli pianificati senza bloccare il loop di eventi dell'applicazione.

Worker asincrono in background

Implementare un task runner che esegue operazioni di database registrate a intervalli specificati, prevenendo esecuzioni concorrenti duplicate. Questo esempio si basa sulla sezione del pool di connessioni asincrona , quindi salva il codice di quella sezione come db.py. Poi, salva il seguente codice accanto a worker.py. Configura la registrazione in modo che ogni esecuzione riporti il risultato.

import asyncio
from typing import Callable, Any
from dataclasses import dataclass
from datetime import datetime
import logging

from db import AsyncDatabasePool  # The pool class from the Async connection pool section

logger = logging.getLogger(__name__)

@dataclass
class Task:
    """Background task definition."""
    name: str
    func: Callable
    interval: float  # seconds
    last_run: datetime = None
    running: bool = False

class AsyncTaskRunner:
    """Run database tasks in the background."""
    
    def __init__(self, pool: AsyncDatabasePool):
        self.pool = pool
        self.tasks: dict[str, Task] = {}
        self._running = False
    
    def register(self, name: str, func: Callable, interval: float):
        """Register a periodic task."""
        self.tasks[name] = Task(name=name, func=func, interval=interval)
    
    async def _run_task(self, task: Task):
        """Execute a single task."""
        if task.running:
            return
        
        task.running = True
        try:
            await task.func(self.pool)
            task.last_run = datetime.now()
            logger.info(f"Task {task.name} completed")
        except Exception as e:
            logger.error(f"Task {task.name} failed: {e}")
        finally:
            task.running = False
    
    async def start(self):
        """Start the task runner."""
        self._running = True
        
        while self._running:
            now = datetime.now()
            
            for task in self.tasks.values():
                if task.last_run is None or \
                   (now - task.last_run).total_seconds() >= task.interval:
                    asyncio.create_task(self._run_task(task))
            
            await asyncio.sleep(1)  # Check every second
    
    def stop(self):
        """Stop the task runner."""
        self._running = False

# Example tasks
async def count_products(pool: AsyncDatabasePool):
    """Read-only task: report the current product count."""
    total = await pool.execute_scalar("SELECT COUNT(*) FROM Production.Product")
    logger.info("count_products: %s products", total)

async def check_low_inventory(pool: AsyncDatabasePool):
    """Report how many products are below an inventory threshold."""
    rows = await pool.execute(
        """
        SELECT ProductID, LocationID, Quantity
        FROM Production.ProductInventory
        WHERE Quantity < %(threshold)s
        """,
        {"threshold": 100},
    )
    logger.info("check_low_inventory: %s rows below threshold", len(rows))

# Usage
async def main():
    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")

    pool = AsyncDatabasePool(
        "Server=<server>.database.windows.net;Database=<database>;Authentication=ActiveDirectoryDefault;Encrypt=yes",
        pool_size=3,
    )
    await pool.initialize()

    runner = AsyncTaskRunner(pool)
    runner.register("count_products", count_products, interval=2)
    runner.register("low_inventory", check_low_inventory, interval=3)

    # Run the runner in the background, let it cycle a few times, then stop.
    # In a real app, run the runner for the application's lifetime instead,
    # for example from a FastAPI lifespan handler.
    runner_task = asyncio.create_task(runner.start())
    await asyncio.sleep(7)
    runner.stop()
    await runner_task
    await pool.close()

if __name__ == "__main__":
    asyncio.run(main())

Esegui il lavoratore:

python worker.py

Ogni task registrata registra quando viene eseguita, quindi vedi output ripetuto ogni pochi secondi:

2026-07-17 15:07:25 INFO count_products: 504 products
2026-07-17 15:07:25 INFO Task count_products completed
2026-07-17 15:07:26 INFO check_low_inventory: 179 rows below threshold
2026-07-17 15:07:26 INFO Task low_inventory completed

Esecuzione concorrente delle query

Usa asyncio.gather con un semaforo per limitare il numero di query che vengono eseguite simultaneamente. Gli esempi in questa sezione si basano sulla sezione del pool di connessione asincrona , quindi salva il codice di quella sezione come db.py ed esegui ogni esempio nel suo file accanto.

Query parallele con semaforo

Esegui più query contemporaneamente utilizzando un semaforo per limitare il numero di operazioni simultanee, prevenendo la saturazione del pool di thread.

import asyncio

from db import AsyncDatabasePool  # The pool class from the Async connection pool section

async def parallel_queries(pool: AsyncDatabasePool, queries: list[tuple[str, dict]],
                          max_concurrent: int = 5) -> list:
    """Execute multiple queries with concurrency limit."""
    semaphore = asyncio.Semaphore(max_concurrent)

    async def run_query(query: str, params: dict):
        async with semaphore:
            return await pool.execute(query, params)

    tasks = [run_query(q, p) for q, p in queries]
    return await asyncio.gather(*tasks)

# Usage
async def main():
    pool = AsyncDatabasePool(
        "Server=<server>.database.windows.net;Database=<database>;Authentication=ActiveDirectoryDefault;Encrypt=yes",
        pool_size=5,
    )
    await pool.initialize()
    try:
        queries = [
            ("SELECT * FROM Production.Product WHERE ProductSubcategoryID = %(cat)s", {"cat": 1}),
            ("SELECT * FROM Production.Product WHERE ProductSubcategoryID = %(cat)s", {"cat": 2}),
            ("SELECT * FROM Sales.SalesOrderHeader WHERE Status = %(status)s", {"status": 5}),
            ("SELECT * FROM Sales.Customer WHERE TerritoryID = %(territory)s", {"territory": 1}),
        ]

        results = await parallel_queries(pool, queries, max_concurrent=3)

        for i, rows in enumerate(results, 1):
            print(f"Query {i}: {len(rows)} rows")
    finally:
        await pool.close()

if __name__ == "__main__":
    asyncio.run(main())

Ogni query viene eseguita contemporaneamente e l'output riporta quante righe ciascuna ha restituito:

Query 1: 32 rows
Query 2: 43 rows
Query 3: 31465 rows
Query 4: 3520 rows

Per caricare grandi volumi di righe, non ricorrere alla concorrenza. Usa invece meno viaggi di andata e ritorno, come descritto nella copia Bulk.

Risultati grandi in streaming

Recupera righe da set di risultati di grandi dimensioni usando la paginazione OFFSET/FETCH per mantenere limitato l'uso della memoria. Questo esempio si basa sulla sezione del pool di connessione asincrona , quindi salva il codice di quella sezione come db.py ed esegui questo esempio accanto.

Generatore asincrono per grandi dataset

Implementa una funzione di generatore asincrono che recuperi le pagine dei risultati su richiesta, permettendo ai chiamanti di iterare su grandi dataset senza caricare tutto in memoria.

import asyncio

from db import AsyncDatabasePool  # The pool class from the Async connection pool section

async def stream_results(pool: AsyncDatabasePool, query: str,
                        params: dict = None, chunk_size: int = 1000):
    """Stream query results as async generator."""
    offset = 0

    while True:
        paged_query = f"""
            {query}
            ORDER BY (SELECT NULL)
            OFFSET %(offset)s ROWS
            FETCH NEXT %(limit)s ROWS ONLY
        """
        chunk_params = {**(params or {}), "offset": offset, "limit": chunk_size}

        results = await pool.execute(paged_query, chunk_params)

        if not results:
            break

        for row in results:
            yield row

        offset += chunk_size

        # Allow event loop to process other tasks
        await asyncio.sleep(0)

# Usage
async def main():
    pool = AsyncDatabasePool(
        "Server=<server>.database.windows.net;Database=<database>;Authentication=ActiveDirectoryDefault;Encrypt=yes",
        pool_size=5,
    )
    await pool.initialize()
    try:
        processed = 0
        async for order in stream_results(
            pool, "SELECT SalesOrderID FROM Sales.SalesOrderHeader", chunk_size=500
        ):
            processed += 1
        print(f"Streamed {processed} orders in chunks of 500.")
    finally:
        await pool.close()

if __name__ == "__main__":
    asyncio.run(main())

Il generatore recupera una pagina alla volta, così la memoria rimane limitata indipendentemente dalla dimensione del set di risultati:

Streamed 31465 orders in chunks of 500.

Procedure consigliate

Applica queste linee guida per mantenere i pattern asincroni sicuri ed efficienti.

Dimensionamento corretto degli executor

Dimensiona il pool di thread per adattarlo ai carichi di lavoro legati all'I/O, non solo al numero di CPU.

import os

# Rule of thumb: 2-4x CPU cores for I/O-bound database work
cpu_count = os.cpu_count() or 4
pool_size = cpu_count * 2

db_executor = ThreadPoolExecutor(max_workers=pool_size)

Arresto normale

Arresta l'esecutore di attività, completa il lavoro ancora in corso, quindi chiudi il pool e l'executor nell'ordine corretto.

async def graceful_shutdown(pool: AsyncDatabasePool, runner: AsyncTaskRunner):
    """Gracefully shut down all async components."""
    # Stop accepting new tasks
    runner.stop()
    
    # Wait for running tasks to complete
    await asyncio.sleep(2)
    
    # Close database pool
    await pool.close()
    
    # Shutdown executor
    db_executor.shutdown(wait=True)

Gestione degli errori

Riprova solo su guasti transitori, e riduci con un ritardo e un jitter limitati. Riutilizza il is_transient_error classificatore di Logica di ripetizione dei tentativi e resilienza delle connessioni in modo che errori permanenti, come credenziali errate o errori di sintassi, vengano segnalati immediatamente invece di attivare nuovi tentativi.

import asyncio
import random
import mssql_python

# Reuse is_transient_error() from the Retry logic article.

async def resilient_query(pool: AsyncDatabasePool, query: str,
                          params: dict = None, retries: int = 3,
                          base_delay: float = 1.0, max_delay: float = 30.0) -> list:
    """Execute a query, retrying only on transient failures."""
    for attempt in range(retries + 1):
        try:
            return await pool.execute(query, params)
        except mssql_python.Error as e:
            if not is_transient_error(e) or attempt == retries:
                raise
            delay = min(base_delay * (2 ** attempt), max_delay)
            delay *= 0.5 + random.random()  # Add jitter
            await asyncio.sleep(delay)

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-07-22

Pattern asincroni con mssql-python

Quando usare i pattern asincroni

Modello del pool di thread

Wrapper asincrono di base

Pool di connessioni asincrone

Classe di database asincrono aggregato

Integrazione con FastAPI

FastAPI async con mssql-python

Attività in background

Worker asincrono in background

Esecuzione concorrente delle query

Query parallele con semaforo

Risultati grandi in streaming

Generatore asincrono per grandi dataset

Procedure consigliate

Dimensionamento corretto degli executor

Arresto normale

Gestione degli errori

Contenuti correlati

Commenti e suggerimenti

Risorse aggiuntive