Próbáld meg újra a logikát és a kapcsolati rezilienciát mssql-pythonnal

Az átmeneti hibák ideiglenes hibák, amelyek akkor előfordulhatnak, amikor az mssql-python driveren keresztül csatlakoznak az SQL Server-hez és az Azure SQL-hez. Ezek a hibák gyakran maguktól oldódnak:

• Hálózati kapcsolódási zavarok.
• Szerver erőforrás-korlátok.
• Azure SQL szabályozása.
• Feladatátvételi események.

A retry-logika megvalósítása javítja az alkalmazás megbízhatóságát, különösen felhőalapú adatbázisok esetén.

Ne használj újrapróbálkozásokat konfigurációs vagy kódolási hibák elrejtésére. Egy hiányzó adatbázis, rossz hitelesítő adatok vagy kimerült kapcsolati pool javításra van szükség, nem egy újabb próbálkozásra.

Pooling és alapértelmezett msodbcsql18 szolgáltató esetén az illesztőprogram ideiglenesen natív kapcsolat-műveleti időkorlátot alkalmaz egy újrahasznosított kapcsolat érvényesítése során: a pozitív bejelentkezési időkorlát, vagy 15 másodperc, amikor a bejelentkezési időkorlát nulla vagy nem meghatározott. Ez nem teljes körű validálási vagy fizetési határidő. Több natív művelet, tisztítás és egy cserekapcsolat megnyitása több időt vehet igénybe. Ha az ellenőrzés sikertelen, az illesztőprogram megpróbál cserét végrehajtani ahelyett, hogy minden maradék tétlen kapcsolatot megvárna. Ez a helyreállítás nem játssza le újra az utasításaidat, és nem próbálja újra az újrapróbálkozási készlet kimerülését. További információkért lásd a Kapcsolatcsoportosítás című részt.

Átmeneti hibák azonosítása

Az mssql-python nem teszi ki az SQL Server motor hibaszámát attribútumként a kivételeknél. Ehelyett az illesztőprogram az SQLSTATE-kódokat a PEP 249 kivételalosztályainak egy rögzített csoportjához (OperationalError, ProgrammingError és így tovább), valamint a driver_error attribútumban szereplő szabványosított angol szöveghez rendeli. Ezt a kombinációt használd az átmeneti osztályozás alapjaként.

Megbízható átmeneti jelek

A következő SQLSTATE értékek úgy jelennek meg, OperationalError amelyek egy olyan állapotot jelölnek, amelyet érdemes újrapróbálni. A jobb oldali oszlop pontosan mutatja a meghajtó által beállított driver_error szöveget:

SQLSTATE	driver_error Szöveg	Condition
HYT00	Timeout expired	Jelentés szintű időkérés.
HYT01	Connection timeout expired	Kapcsolódási időtúllépés.
08001	Client unable to establish connection	Nem tudtam kapcsolatot nyitni.
08S01	Communication link failure	Hálózati megesés, szerver visszaállítása, TCP hiba.
08007	Connection failure during transaction	Kapcsolat elveszett a tranzakció közben.
40001	Serialization failure	Holtpont áldozata.
40003	Statement completion unknown	Határozatlan tranzakciós állapot.

import mssql_python


TRANSIENT_DRIVER_ERRORS = frozenset({
    "Timeout expired",
    "Connection timeout expired",
    "Client unable to establish connection",
    "Communication link failure",
    "Connection failure during transaction",
    "Serialization failure",
    "Statement completion unknown",
})


def is_transient_error(error: BaseException) -> bool:
    """Return True if the exception represents a retryable transient failure.

    Classification is based on the driver's PEP 249 exception subclass and
    on the standardized `driver_error` text that mssql-python sets from
    the SQLSTATE returned by the server.
    """
    if isinstance(error, mssql_python.OperationalError):
        return getattr(error, "driver_error", "") in TRANSIENT_DRIVER_ERRORS
    return False

Azure SQL korlátozás (megkísérelt)

Az Azure SQL korlátozás miatti hibái (40197, 40501, 40613, 49918, 49919, 49920 és a kapcsolódó kódok) jellemzően az SQLSTATE 42000 kóddal érkeznek, amelyet az mssql-python ProgrammingError-re képez le. A motor hibaszáma nem jelenik meg attribútumként, így az egyetlen jel a szerver üzenetének szövege az ddbc_error attribútumban.

Ellenőrizd a(z) ddbc_error elemet az ismert számok esetén, ha vannak ilyenek, valamint a szabványos angol 40501-es hibaüzenet szempontjából. A szám hiányozhat, és az üzenet szövege nem tekinthető stabil szerződésnek. A lokalizált vagy eltérő formátumú diagnosztika nem feltétlenül egyezik:

import re

# Azure SQL throttling and reconfiguration error numbers.
AZURE_THROTTLING_ERRORS = frozenset({
    40197, 40501, 40540, 40613, 40680, 49918, 49919, 49920, 10928, 10929,
})

_ERROR_NUMBER_RE = re.compile(r"\b(?:Error|Msg)\s+(\d+)\b")
_AZURE_40501_MESSAGE = "The service is currently busy. Retry the request after 10 seconds."


def is_azure_throttling(error: BaseException) -> bool:
    """Best-effort detection of Azure SQL throttling in ProgrammingError text."""
    if not isinstance(error, mssql_python.ProgrammingError):
        return False
    ddbc_text = getattr(error, "ddbc_error", "") or ""
    return (
        _AZURE_40501_MESSAGE in ddbc_text
        or any(int(m) in AZURE_THROTTLING_ERRORS for m in _ERROR_NUMBER_RE.findall(ddbc_text))
    )


def is_retryable(error: BaseException) -> bool:
    return is_transient_error(error) or is_azure_throttling(error)

Mit ne próbálkozzon újra?

Azon hibák példái, amelyek esetén az újrapróbálkozás helyett azonnal hibát kellene jelezniük, például az érvénytelen hitelesítő adatok (OperationalError illesztőprogram-üzenettel Invalid authorization specification), a hiányzó adatbázis vagy az elégtelen jogosultságok, a szintaxishibák (ProgrammingError), a hiányzó objektumok és a kapcsolatkészlet kimerülése. A is_transient_error fenti függvény mindezt kizárja konstrukció szerint.

Alap újrapróbálkozási dekorátor

Egyszerű újrapróbálkozás fix késleltetéssel

Egy dekorátor, aki fix számú alkalommal próbálja újra a csomagolt függvényt állandó késleltetéssel:

import time
import functools
import mssql_python

def retry_on_failure(max_retries: int = 3, delay: float = 1.0):
    """Decorator to retry database operations on transient failures."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            for attempt in range(max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except mssql_python.Error as e:
                    last_exception = e
                    if not is_transient_error(e) or attempt == max_retries:
                        raise
                    print(f"Attempt {attempt + 1} failed: {e}. Retrying in {delay}s...")
                    time.sleep(delay)
            raise last_exception
        return wrapper
    return decorator

# Usage
@retry_on_failure(max_retries=3, delay=2.0)
def get_user(cursor, user_id: int):
    cursor.execute("SELECT * FROM Person.Person WHERE BusinessEntityID = %(id)s", {"id": user_id})
    return cursor.fetchone()

Exponenciális visszalépés

Növelje exponenciálisan az újrapróbálkozások közötti késleltetést választható jitter használatával, hogy az egyidejű újrapróbálkozások eloszoljanak:

import time
import random

def retry_with_backoff(max_retries: int = 5, 
                       base_delay: float = 1.0,
                       max_delay: float = 30.0,
                       jitter: bool = True):
    """Retry with exponential backoff and optional jitter."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            for attempt in range(max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except mssql_python.Error as e:
                    last_exception = e
                    if not is_transient_error(e) or attempt == max_retries:
                        raise
                    
                    # Calculate delay with exponential backoff
                    delay = min(base_delay * (2 ** attempt), max_delay)
                    if jitter:
                        delay = delay * (0.5 + random.random())
                    
                    print(f"Attempt {attempt + 1} failed. Retrying in {delay:.2f}s...")
                    time.sleep(delay)
            raise last_exception
        return wrapper
    return decorator

@retry_with_backoff(max_retries=5, base_delay=1.0, max_delay=30.0)
def execute_query(cursor, query: str, params: dict):
    cursor.execute(query, params)
    return cursor.fetchall()

Kapcsolat újrapróbálkozási osztály

Ellenálló kapcsolatkezelő

Egy kapcsolati wrapper, amely egyszerre kezeli az újrapróbálást, mind az automatikus újrakapcsolást:

import mssql_python
import time
import logging

# This example uses is_transient_error from the "Identify transient errors"
# section earlier in this article. Include that helper in your module.

# Configure logging so the retry and reconnect messages are visible
logging.basicConfig(level=logging.INFO)

class ResilientConnection:
    """Connection wrapper with automatic retry and reconnection."""
    
    def __init__(self, connection_string: str, max_retries: int = 5,
                 base_delay: float = 1.0, max_delay: float = 60.0):
        self.connection_string = connection_string
        self.max_retries = max_retries
        self.base_delay = base_delay
        self.max_delay = max_delay
        self._conn = None
        self._logger = logging.getLogger(__name__)
    
    def _connect(self) -> mssql_python.Connection:
        """Establish connection with retry logic."""
        last_exception = None
        
        for attempt in range(self.max_retries + 1):
            try:
                self._logger.debug(f"Connection attempt {attempt + 1}")
                return mssql_python.connect(self.connection_string)
            except mssql_python.Error as e:
                last_exception = e
                if not is_transient_error(e) or attempt == self.max_retries:
                    self._logger.error(f"Connection failed: {e}")
                    raise
                
                delay = min(self.base_delay * (2 ** attempt), self.max_delay)
                self._logger.warning(f"Connection attempt {attempt + 1} failed. "
                                   f"Retrying in {delay:.1f}s...")
                time.sleep(delay)
        
        raise last_exception
    
    @property
    def connection(self) -> mssql_python.Connection:
        """Get or create connection."""
        if self._conn is None:
            self._conn = self._connect()
        return self._conn
    
    def execute(self, query: str, params: dict = None):
        """Execute query with automatic retry and reconnection."""
        return self._execute_with_retry(
            lambda c: self._do_execute(c, query, params)
        )
    
    def _do_execute(self, cursor, query: str, params: dict):
        cursor.execute(query, params or {})
        return cursor.fetchall()
    
    def _execute_with_retry(self, operation):
        """Execute an operation with retry logic."""
        last_exception = None
        
        for attempt in range(self.max_retries + 1):
            try:
                cursor = self.connection.cursor()
                return operation(cursor)
            except mssql_python.Error as e:
                last_exception = e
                
                if not is_transient_error(e):
                    raise
                
                if attempt == self.max_retries:
                    raise
                
                # Try to reconnect
                self._logger.warning(f"Operation failed. Reconnecting...")
                self._close()
                
                delay = min(self.base_delay * (2 ** attempt), self.max_delay)
                time.sleep(delay)
        
        raise last_exception
    
    def _close(self):
        """Close connection."""
        if self._conn:
            try:
                self._conn.close()
            except:
                pass
            self._conn = None
    
    def close(self):
        """Public close method."""
        self._close()
    
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()
        return False

# Usage
with ResilientConnection(connection_string) as db:
    users = db.execute("SELECT * FROM Person.Person WHERE EmailPromotion = %(promo)s", 
                       {"promo": 1})
    print(f"Retrieved {len(users)} rows")

Az Azure SQL speciális kezelése

Használd a mssql-python kivételleképezést az Identify transient errors részben, hogy osztályozd a hibákat a következő katalógusból.

Az alábbi hibák átmeneti lehetnek, amikor a kapcsolat létrehozása során vagy kérés küldése közben jelentkeznek. Próbálkozzon újra rövid, korlátozott várakozási idő után. A hibák, amelyek néhány ismétlés után is fennállnak, általában konfigurációs problémára utalnak, például rossz szerverre, hiányzó jogosultságokra, nem kompatibilis titkosítási beállításokra vagy kimerült kvóta, amit az újrapróbálkozás nem fog megoldani.

Error	Hiba típusa	Message	Troubleshooting
64	Adatátvitel bejelentkezés közben	A connection was successfully established with the server, but then an error occurred during the login process. (provider: TCP Provider, error: 0 - The specified network name is no longer available.)	A TCP-kapcsolat kézfogás közben megszakad. Ez nem hitelesítési hiba. Ha továbbra is fennáll, ellenőrizze az ügyféloldali hálózati instabilitást, vagy egy olyan köztes eszközt, amely megszakítja a félig létrehozott kapcsolatokat.
233	Bejelentkezés előtti átvitel vagy TLS	The client was unable to establish a connection because of an error during connection initialization process before login.	A szerver gyakran akkor adja vissza ezt a hibát, amikor nem tudja elfogadni a kapcsolatot erőforrás-kimerülés, kapcsolati korlát vagy támogatatlan kliens miatt. Ez nem hitelesítési hiba. Ellenőrizze a kiszolgáló állapotát, majd ellenőrizze az ügyfél bejelentkezési időtúllépését, a TLS-beállításokat és az ügyfél/kiszolgáló TLS-verziókompatibilitását.
4060	Adatbázis elérhetősége vagy hozzáférése	Cannot open database "%.*ls" requested by the login. The login failed.	A bejelentkezés hitelesít, de nem tudja megnyitni a kért adatbázist. Az átmeneti okok közé tartozik, ha az adatbázis átmeneti állapotban van (feladatátvétel, visszaállítás, skálázás miatt), vagy automatikusan szüneteltetve van. Az állandó okok (az adatbázis nem létezik, a bejelentkezés nem rendelkezik hozzáféréssel) nem lesznek javítva újrapróbálkozással; ellenőrizze az adatbázis nevét, a bejelentkezési leképezést és az adatbázis állapotát.
4221	Olvasható-másodlagos átmenet	Login to read-secondary failed due to long wait on 'HADR_DATABASE_WAIT_FOR_TRANSITION_TO_VERSIONING'.	A replika nem érhető el bejelentkezéshez, mert a sorverziók hiányoznak a replika újrafeldolgozásakor repülés közben végrehajtott tranzakciókhoz. A probléma megoldásához vonja vissza vagy véglegesítse az aktív tranzakciókat az elsődleges kiszolgálón. Csökkentse ezt azzal, hogy kerüli a hosszú írási tranzakciókat az elsődleges csomóponton.
10053	Helyi közlekedés megszakítása	A transport-level error has occurred when sending the request to the server. (provider: TCP Provider, error: 0 - An established connection was aborted by the software in your host machine.)	A helyi oldal megszakítja a kapcsolatot. Ellenőrizze az ügyféloldali hálózat állapotát, valamint a helyi tűzfal vagy VPN-ügyfél állapotát.
10054	Távoli szállítás visszaállítása	A transport-level error has occurred when sending the request to the server. (provider: TCP Provider, error: 0 - An existing connection was forcibly closed by the remote host.)	A távoli oldal TCP-alaphelyzetbe állítást küld. Gyakori okok: a partnerfolyamat összeomlott, egy tűzfal resetet küldött, vagy az Azure SQL-átjáró lezárt egy inaktív kapcsolatot. Tétlenség miatti kapcsolatbontási minták esetén engedélyezze a TCP keepalive funkciót az ügyféloldalon, vagy csökkentse a kapcsolatpool tétlenségi időkorlátját.
10060	Kapcsolati időkorlát	A connection attempt failed because the connected party did not properly respond after a period of time.	A szerver vagy egy köztes hálózati eszköz nem válaszolt a TCP csatlakozás időkorlátja előtt. Ellenőrizd a szerver állapotát, útvonaltervezését, tűzfal szabályait, és hogy a konfigurált host és port elérhető-e.
10928	Adatbázis-erőforrás korlát	Resource ID: %d. The %s limit for the database is %d and has been reached.	Az adatbázis túllépi a Azure SQL erőforrás-szabályozási korlátot. Az 1. erőforrás-azonosító a feldolgozói korlátot jelzi; A 2. erőforrás-azonosító a munkamenetkorlátot jelzi. Azonosítsa az üzenet korláttípusát, majd csökkentse az egyidejűséget, skálázza fel az adatbázist, vagy lerövidítse az erőforrást tartalmazó hosszú ideig futó műveleteket.
10929	Adatbázis korlátozása	Resource ID: %d. The %s minimum guarantee is %d, maximum limit is %d, and the current usage for the database is %d. However, the server is currently too busy to support requests greater than %d for this database.	Az adatbázis meghaladja a számára garantált minimumot, és a mögöttes kiszolgáló korlátozza a teljesítményét. Az újrapróbálkozás általában akkor sikeres, ha a szomszéd terhelés csökken. A tartós előfordulások azt jelzik, hogy magasabb szolgáltatási szintre vagy kevésbé zajos környezetre van szüksége.
40020, 40143, 40166, 40540	Azure SQL feladatátvételi alkód	Error code %d A 40197-es hibahelyen jelentve a feladatátvétel során.	A 40197-es failover üzenetbe ágyazott alkódok, amelyeket egyes elérési utak elsődleges hibakódként jelenítenek meg. Kezelje őket ugyanúgy, mint a 40197-et.
40197	Azure SQL failover	The service has encountered an error processing your request. Please try again. Error code %d.	Szoftverfrissítés, hardverhiba vagy más feladatátvételi esemény az Azure SQL-ben. Az újracsatlakozás egy működőképes replikához kapcsol. A beágyazott hibakód azonosítja a feladatátvétel típusát. Ha a hiba továbbra is fennáll, rögzítse a munkamenet-nyomkövetés azonosítóját, és forduljon az ügyfélszolgálathoz.
40501	Azure SQL throttling	The service is currently busy. Retry the request after 10 seconds. Incident ID: %ls. Code: %d.	Azure SQL motor szabályozása. Az ajánlott minimális várakozási idő 10 másodperc. A tartós fojtás azt jelzi, hogy a terhelés meghaladta az adatbázis erőforrás-kiosztását; növelje a szolgáltatási szintet, vagy csökkentse a párhuzamosságot.
40613	Az adatbázis nem érhető el	Database '%.*ls' on server '%.*ls' is not currently available. Please retry the connection later. If the problem persists, contact customer support, and provide them with the session tracing ID of '%.*ls'.	Az adatbázis nem érhető el, általában feladatátvétel alatt vagy rövid ideig egy skálázási művelet közben. Próbálkozzon újra egy visszalépéssel; ha néhány perc elteltével is megmarad, rögzítse a munkamenet nyomkövetési azonosítóját, és nyisson meg egy támogatási esetet.
42108	SQL-készlet szüneteltetve	Can not connect to the SQL pool since it is paused. Please resume the SQL pool and try again.	A dedikált SQL-készlet (Synapse) szüneteltetett állapotban van. Az újrapróbálás csak a készlet újraindítása után sikerül. Állítsa vissza explicit módon a készletet működő állapotba, vagy ütemezze a munkaterhelés futtatását a készlet folytatását követő időpontra.
42109	Az SQL-készlet folytatása	The SQL pool is warming up. Please try again.	A dedikált SQL-készlet újra működik. Próbálkozzon újra egyre hosszabb várakozási időkkel, amíg a pool online nem lesz; a bemelegítés általában néhány percet vesz igénybe.
49918	Szolgáltatási erőforrás-hiány	Cannot process request. Not enough resources to process request. The service is currently busy. Please retry the request later.	A kiszolgáló jelenleg nem tud elegendő erőforrást lefoglalni a kérés teljesítéséhez. Próbálkozzon újra egy visszalépéssel. Ha a hiba továbbra is fennáll, skálázza fel az adatbázist vagy a rugalmas készletet.
49919	Felügyeleti műveletek korlátozása	Cannot process create or update request. Too many create or update operations in progress for subscription "%ld".	Előfizetési szintű egyidejűségi korlát a felügyeleti műveletekre. Csökkentse a párhuzamos létrehozási vagy frissítési hívások számát, vagy időben tolja el őket.
49920	előfizetési műveletek korlátozása	Cannot process request. Too many operations in progress for subscription "%ld".	Előfizetésszintű egyidejűségi korlát a repülési műveletekre. Csökkentse a párhuzamosságot, vagy várja meg, amíg a folyamatban lévő műveletek befejeződnek.

Az utasításszintű hibák nem szerepelnek ezen a listán, mert a kapcsolat létrejötte után jelentkeznek, és a hiba ellenére a munkamenet továbbra is használható marad. A leggyakoribb újrapróbálkozható utasításhibák az 1205 (holtpont áldozata) és az 1222 (zárolási kérelem időtúllépése). Az egyetlen sikertelen utasítás helyett próbálkozzon újra a teljes tranzakcióval.

A hibaüzenet szövege Azure SQL átmeneti kapcsolati hibákból származik. Ezek a hibák újrapróbálhatók az SQL Server, Azure SQL Database, Azure SQL Managed Instance, SQL database a Microsoft Fabric-ben, valamint dedikált SQL poolok között az Azure Synapse Analytics-ben.

Az Azure-korlátozás kezelése

Az Azure SQL korlátozási hibákhoz hosszabb késleltetés és több újrapróbálkozás szükséges, mint a szokásos átmeneti hibák. Újrahasználás innen: is_azure_throttling:

def execute_with_throttle_handling(cursor, query: str, params: dict,
                                   max_retries: int = 10,
                                   base_delay: float = 10.0):
    """Execute with extended retry for Azure SQL throttling."""
    for attempt in range(max_retries + 1):
        try:
            cursor.execute(query, params)
            return cursor.fetchall()
        except mssql_python.Error as e:
            if is_azure_throttling(e):
                if attempt < max_retries:
                    # Longer delays for throttling
                    delay = base_delay * (2 ** min(attempt, 4))  # Cap at 16 times the base delay
                    print(f"Throttled. Waiting {delay}s before retry...")
                    time.sleep(delay)
                    continue
            raise

Feladatátvétel kezelése

Csatlakozz újra és próbáld újra, amikor Azure SQL vagy elérhetőségi csoport failover megszakít egy kapcsolatot:

def execute_with_failover_retry(connect, query: str, params: dict,
                                max_retries: int = 3,
                                recovery_delay: float = 10.0):
    """Reconnect and retry during Azure SQL failover scenarios."""
    failover_numbers = frozenset({40613, 40197, 40540})
    last_exception = None

    for attempt in range(max_retries + 1):
        conn = None
        try:
            conn = connect()
            cursor = conn.cursor()
            cursor.execute(query, params)
            return cursor.fetchall()
        except mssql_python.Error as e:
            last_exception = e

            # Failover surfaces either as a transient OperationalError or as
            # a ProgrammingError whose ddbc_error text contains the engine
            # error number. Treat both as recoverable.
            ddbc_text = getattr(e, "ddbc_error", "") or ""
            is_failover = is_transient_error(e) or any(
                int(m) in failover_numbers for m in _ERROR_NUMBER_RE.findall(ddbc_text)
            )

            if is_failover and attempt < max_retries:
                print(f"Failover detected. Reconnecting in {recovery_delay}s...")
                if conn is not None:
                    try:
                        conn.close()
                    except mssql_python.Error:
                        pass
                time.sleep(recovery_delay)
                continue
            raise

    raise last_exception


# Usage
connection_string = (
    "Server=tcp:<server>.database.windows.net,1433;"
    "Database=AdventureWorks2025;"
    "Authentication=ActiveDirectoryDefault;"
    "Encrypt=yes;TrustServerCertificate=no"
)

rows = execute_with_failover_retry(
    lambda: mssql_python.connect(connection_string),
    "SELECT TOP 10 ProductID, Name FROM Production.Product WHERE Color = %(color)s",
    {"color": "Silver"}
)

Holtpontkezelés

Újrapróbálkozás holtpont esetén

A holtpontok (1205-ös hiba) átmeneti jellegűek. Próbálkozz újra rövid, véletlenszerű késleléssel a holtpont ciklusának megtöréséhez. Az újrapróbálás kezeli az azonnali hibát, de az ismétlődő holtpont egy tervezési problémára utal, amit szerver oldalon is érdemes vizsgálni. Az alapvető ok elemzéséhez és megoldásához vonatkozó útmutatásért lásd: Holthelyzet hibák.

def execute_with_deadlock_retry(cursor, query: str, params: dict,
                                max_retries: int = 3):
    """Automatically retry deadlocked transactions.

    Deadlocks (SQL Server error 1205) surface as OperationalError with
    driver_error == "Serialization failure" (SQLSTATE 40001).
    """
    for attempt in range(max_retries + 1):
        try:
            cursor.execute(query, params)
            return cursor.fetchall()
        except mssql_python.OperationalError as e:
            if getattr(e, "driver_error", "") == "Serialization failure":
                if attempt < max_retries:
                    delay = random.uniform(0.1, 0.5) * (attempt + 1)
                    print(f"Deadlock detected. Retry {attempt + 1} in {delay:.2f}s")
                    time.sleep(delay)
                    continue
            raise

# Usage in transaction
conn.autocommit = False
try:
    cursor = conn.cursor()
    rows = execute_with_deadlock_retry(
        cursor,
        "SELECT TOP 5 Name, ListPrice FROM Production.Product WHERE ListPrice > %(price)s",
        {"price": 100}
    )
    conn.commit()
except Exception:
    conn.rollback()
    raise

Strukturált újrapróbálkozás konfigurációval

Újrapróbálkozási szabályzat osztály

Incapsuláld a újrapróbálkozás konfigurációját egy adatosztályban, hogy különböző műveletek során újra felhasználhassuk:

from dataclasses import dataclass, field
from typing import FrozenSet
import time
import random

# This example uses TRANSIENT_DRIVER_ERRORS from the "Identify transient errors"
# section earlier in this article. Include that allowlist in your module.

@dataclass
class RetryPolicy:
    """Configuration for retry behavior."""
    max_retries: int = 3
    base_delay: float = 1.0
    max_delay: float = 30.0
    exponential_base: float = 2.0
    jitter: bool = True
    transient_driver_errors: FrozenSet[str] = field(default_factory=lambda: TRANSIENT_DRIVER_ERRORS)

    def get_delay(self, attempt: int) -> float:
        """Calculate delay for given attempt number."""
        delay = min(
            self.base_delay * (self.exponential_base ** attempt),
            self.max_delay,
        )
        if self.jitter:
            delay *= (0.5 + random.random())
        return delay

    def should_retry(self, error: BaseException, attempt: int) -> bool:
        """Determine if operation should be retried."""
        if attempt >= self.max_retries:
            return False
        if isinstance(error, mssql_python.OperationalError):
            return getattr(error, "driver_error", "") in self.transient_driver_errors
        return False

def execute_with_policy(cursor, query: str, params: dict,
                        policy: RetryPolicy = None):
    """Execute query with configurable retry policy."""
    policy = policy or RetryPolicy()
    last_exception = None

    for attempt in range(policy.max_retries + 1):
        try:
            cursor.execute(query, params)
            return cursor.fetchall()
        except mssql_python.Error as e:
            last_exception = e
            if not policy.should_retry(e, attempt):
                raise

            delay = policy.get_delay(attempt)
            time.sleep(delay)

    raise last_exception

# Usage with custom policy
aggressive_retry = RetryPolicy(max_retries=10, base_delay=0.5, max_delay=60.0)
conservative_retry = RetryPolicy(max_retries=2, base_delay=5.0, max_delay=10.0)

results = execute_with_policy(cursor, query, params, aggressive_retry)

Áramköri megszakító minta

A kaszkádhibák megelőzése az egymást követő hibák követésével és ideiglenesen blokkolva a hívásokat, amikor elérik a küszöbértéket:

import time
from enum import Enum
from threading import Lock

class CircuitState(Enum):
    CLOSED = "closed"      # Normal operation
    OPEN = "open"          # Failing, reject all calls
    HALF_OPEN = "half_open"  # Testing if service recovered

class CircuitBreaker:
    """Circuit breaker to prevent cascading failures."""
    
    def __init__(self, failure_threshold: int = 5,
                 recovery_timeout: float = 30.0):
        self.failure_threshold = failure_threshold
        self.recovery_timeout = recovery_timeout
        self.state = CircuitState.CLOSED
        self.failure_count = 0
        self.last_failure_time = None
        self._lock = Lock()
    
    def can_execute(self) -> bool:
        """Check if circuit allows execution."""
        with self._lock:
            if self.state == CircuitState.CLOSED:
                return True
            
            if self.state == CircuitState.OPEN:
                # Check if recovery timeout has passed
                if time.time() - self.last_failure_time > self.recovery_timeout:
                    self.state = CircuitState.HALF_OPEN
                    return True
                return False
            
            # HALF_OPEN: allow one test request
            return True
    
    def record_success(self):
        """Record successful operation."""
        with self._lock:
            self.failure_count = 0
            self.state = CircuitState.CLOSED
    
    def record_failure(self):
        """Record failed operation."""
        with self._lock:
            self.failure_count += 1
            self.last_failure_time = time.time()
            
            if self.failure_count >= self.failure_threshold:
                self.state = CircuitState.OPEN

# Usage
circuit = CircuitBreaker(failure_threshold=5, recovery_timeout=30.0)

def execute_with_circuit_breaker(cursor, query: str, params: dict):
    if not circuit.can_execute():
        raise Exception("Circuit breaker is open")
    
    try:
        cursor.execute(query, params)
        result = cursor.fetchall()
        circuit.record_success()
        return result
    except mssql_python.Error as e:
        if is_transient_error(e):
            circuit.record_failure()
        raise

Ne próbáld újra a konfigurációs hibákat

Nem minden hiba múló. Egy konfigurációs vagy kódolási hibát újra próbálnak ki, időpazarlás, és elfedheti a valódi problémát. Csak azokat a hibákat próbálja meg újra, amelyek maguktól megoldódhatnak. Mivel az mssql-python nem mutatja fel a motor hibaszámát attribútumként, osztályozzuk kivétel alosztály és a driver_error szöveg szerint.

Soha ne próbáld újra ezeket (inkább javítsd meg a kódot vagy a konfigurációt):

Condition	Kivétel típusa	driver_error Szöveg	Kijavítás
Érvénytelen objektumnév (engine 208)	ProgrammingError	Base table or view not found	A tábla nem létezik. Javítsd meg a lekérdezést vagy készítsd el a táblát.
Érvénytelen oszlopnév (engine 207)	ProgrammingError	Column not found	Az oszlop nem létezik. Nézd meg a sémát.
Hibás szintaxis (102-es motor)	ProgrammingError	Syntax error or access violation	Javítsd meg a lekérdezést.
Bejelentkezés hibás (motor 18456)	OperationalError	Invalid authorization specification	Rossz képesítések. Javítsd meg a kapcsolati karakterlánc-t.
Hiányzó adatbázis vagy megtagadott hozzáférés (adatbázismotor 4060)	OperationalError	Server rejected the connection	Az adatbázis nem létezik, vagy nem érhető el a bejelentkezés számára. Javítsd ki a célpontot vagy a jogosultságokat.
Csatlakozási pool kimerülése	OperationalError	(változó)	Növelje a kapcsolatkészlet kapacitását, szabadítsa fel haladéktalanul a kapcsolatokat, vagy csökkentse a párhuzamosságot.
ConnectionStringParseError	Önálló rendszer	n. a.	Elírás a kapcsolati karakterlánc kulcsszóban. Javítsd meg a zsinórt.
Nem támogatott funkció	NotSupportedError	Optional feature not implemented	Használj alternatív megközelítést.

Mindig próbáld meg újra ezeket (maguktól oldódnak):

Condition	Kivétel típusa	driver_error Szöveg
Kijelentés időtúllépése	OperationalError	Timeout expired
Csatlakozási időkorlát	OperationalError	Connection timeout expired
Nem tudtam megnyitni a kapcsolatot	OperationalError	Client unable to establish connection
Hálózati kapcsolat megszakadása	OperationalError	Communication link failure
Kapcsolat megszakad a tranzakció közepén	OperationalError	Connection failure during transaction
Holtpont áldozata (1205-ös motor)	OperationalError	Serialization failure
Határozatlan tranzakciós állapot	OperationalError	Statement completion unknown
Azure SQL throttling (40197, 40501, 40613, 49918–49920)	ProgrammingError	Syntax error or access violation (a is_azure_throttling szöveghez igazításhoz használja a(z) ddbc_error elemet)

Kapcsolódó tartalom

• Hibakezelés és SQLSTATE kódok mssql-pythonhoz
• Kapcsolat-összevonás mssql-python használatával
• Troubleshoot mssql-python
• Átmeneti csatlakozási hibák elhárítása