Försök om logik och anslutningsresiliens med mssql-python

Tillfälliga fel är tillfälliga fel som kan uppstå vid anslutning till SQL Server och Azure SQL via mssql-python-drivrutinen. Dessa fel löser sig ofta av sig själva:

• Tillfälliga avbrott i nätverksanslutningen.
• Serverresursbegränsningar.
• Azure SQL-begränsning.
• Failover-händelser.

Implementering av återförsökslogik förbättrar applikationens tillförlitlighet, särskilt för molnbaserade databaser.

Använd inte återförsök för att dölja konfigurations- eller kodfel. En saknad databas, dåliga inloggningsuppgifter eller en uttömd anslutningspool behöver en fix, inte ett nytt försök.

Med pooling och standardleverantör msodbcsql18 tillämpar drivrutinen tillfälligt en inbyggd anslutningsoperations-timeout under validering av en återanvänd anslutning: den positiva inloggningstimeouten, eller 15 sekunder när inloggningstimeouten är noll eller ospecificerad. Detta är inte en total deadline för validering eller utcheckning. Flera inbyggda operationer, rensning och att öppna en ersättningsanslutning kan ta extra tid. Om valideringen misslyckas försöker drivrutinen göra en ersättning i stället för att vänta på varje återstående inaktiv anslutning. Denna återställning spelar inte upp dina satser eller försöker igen uttömning av återförsökspoolen. Mer information finns i Anslutningspooler.

Identifiera övergående fel

mssql-python visar inte SQL Server-motorns felnummer som ett attribut på undantag. Istället mappar drivrutinen SQLSTATE-koder till en fast uppsättning PEP 249-undantagsunderklasser (OperationalError, ProgrammingError, och så vidare) och till standardiserad engelsk text i attributet driver_error . Använd den kombinationen som grund för övergående klassificering.

Tillförlitliga transientsignaler

Följande SQLSTATE-värden visas som OperationalError och indikerar ett villkor värt att försöka igen. Den högra kolumnen visar den exakta text som driver_error drivrutinen har angett:

SQLSTATE	driver_error text	Tillstånd
HYT00	Timeout expired	Timeout på statement-nivå.
HYT01	Connection timeout expired	Tidsgräns för anslutning.
08001	Client unable to establish connection	Kunde inte öppna en anslutning.
08S01	Communication link failure	Nätverksavbrott, serveråterställning, TCP-fel.
08007	Connection failure during transaction	Anslutningen bröts under transaktionen.
40001	Serialization failure	Dödlägesoffer.
40003	Statement completion unknown	Obestämt transaktionstillstånd.

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-begränsning (i möjligaste mån)

Azure SQL-begränsningsfel (40197, 40501, 40613, 49918, 49919, 49920 och relaterade koder) returneras vanligtvis med SQLSTATE 42000, vilket mssql-python mappar till ProgrammingError. Motorns felnummer visas inte som ett attribut, så den enda signalen är servermeddelandetexten i attributet ddbc_error .

Kontrollera ddbc_error efter kända nummer när de finns och efter det engelska standardfelmeddelandet 40501. Numret kan saknas, och meddelandetexten är inte ett stabilt kontrakt. Lokaliserade eller annorlunda formaterade diagnostikmeddelanden kanske inte stämmer överens:

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)

Vad du inte ska försöka igen

Exempel på fel som bör misslyckas snabbt istället för att försöka igen inkluderar ogiltiga inloggningsuppgifter (OperationalError med drivrutinstext Invalid authorization specification), en saknad databas eller otillräckliga behörigheter, syntaxfel (ProgrammingError), saknade objekt och uttömning av anslutningspoolen. Funktionen is_transient_error ovan utesluter alla dessa genom konstruktion.

Grundläggande återprovsdekoratör

Enkel omprövning med fast fördröjning

En dekoratör som försöker köra den omslutna funktionen igen ett fast antal gånger med konstant fördröjning:

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()

Exponentiell avbackning

Öka fördröjningen mellan omförsök exponentiellt med valfri slumpvariation för att fördela samtidiga omförsök:

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()

Klass för återförsök vid anslutning

Resilient anslutningshanterare

En anslutningswrapper som hanterar både omprövning och automatisk återanslutning:

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")

Azure SQL-specifik hantering

Använd mssql-python-undantagsmappningen i Identifiera tillfälliga fel för att klassificera fel från följande katalog.

Följande fel kan vara tillfälliga när de uppstår vid anslutningsetablering eller när en förfrågan skickas till servern. Försök igen på en kort, begränsad backoff. Fel som kvarstår efter några omförsök indikerar vanligtvis ett konfigurationsproblem, såsom fel server, saknade behörigheter, inkompatibla krypteringsinställningar eller uttömda kvoter, som omprövningar inte löser.

Error	Feltyp	Message	Troubleshooting
64	Transport vid inloggning	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.)	TCP-anslutningen bryts mitt under handskakningen. Inte ett autentiseringsfel. Om det kvarstår, kontrollera om det finns instabilitet i nätverket på klientsidan eller en mellanliggande enhet som bryter halvetablerade anslutningar.
233	Transport före inloggning eller TLS	The client was unable to establish a connection because of an error during connection initialization process before login.	Servern returnerar ofta detta fel när den inte kan acceptera anslutningen på grund av resursbrist, en anslutningsgräns eller en klient som inte stöds. Inte ett autentiseringsfel. Kontrollera serverns hälsotillstånd och kontrollera sedan tidsgränsen för klientinloggning, TLS-inställningar och kompatibiliteten för klient-/server-TLS-versionen.
4060	Databastillgänglighet eller åtkomst	Cannot open database "%.*ls" requested by the login. The login failed.	Inloggningen autentiserar men kan inte öppna den begärda databasen. Tillfälliga orsaker kan vara att databasen är i en övergångsfas (redundansväxling, återställning, skalning) eller har pausats automatiskt. Beständiga orsaker (databasen finns inte, inloggningen saknar åtkomst) kommer inte att åtgärdas genom ett nytt försök. kontrollera databasnamnet, inloggningsmappningen och databastillståndet.
4221	Läsbar sekundär övergång	Login to read-secondary failed due to long wait on 'HADR_DATABASE_WAIT_FOR_TRANSITION_TO_VERSIONING'.	Repliken är inte tillgänglig för inloggning eftersom radversioner saknas för transaktioner som kördes när repliken återvanns. Återställ eller genomför de aktiva transaktionerna på primärservern för att lösa problemet. Minska risken genom att undvika långa skrivtransaktioner på primärnoden.
10053	Lokalt transportavbrott	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.)	Den lokala sidan avbryter anslutningen. Kontrollera nätverkshälsa på klientsidan och eventuell lokal brandvägg eller VPN-klient.
10054	Återställning av fjärrtransport	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.)	Fjärrsidan skickar en TCP-återställning. Vanliga orsaker: peer-processen kraschade, en brandvägg injicerade en återställning eller Azure SQL gateway stängde en inaktiv anslutning. Vid återkommande återställningar efter inaktivitet aktiverar du TCP-keepalive på klienten eller förkortar anslutningspoolens tidsgräns för inaktivitet.
10060	Tidsgräns för anslutning	A connection attempt failed because the connected party did not properly respond after a period of time.	Servern eller en mellanliggande nätverksenhet svarade inte innan TCP-anslutningens timeout. Kontrollera serverns status, routning, brandväggsregler och om den konfigurerade värden och porten kan nås.
10928	Databasresursgräns	Resource ID: %d. The %s limit for the database is %d and has been reached.	Databasen överskrider en Azure SQL resursstyrningsgräns. Resurs-ID 1 anger arbetsgränsen. Resurs-ID 2 anger sessionsgränsen. Identifiera gränstypen från meddelandet och minska sedan samtidigheten, skala upp databasen eller förkorta långvariga åtgärder som innehåller resursen.
10929	Databasbegränsning	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.	Databasen överskrider sin garanterade miniminivå och den underliggande servern stryper prestandan. Återförsöket lyckas vanligtvis när grannbelastningen sjunker. Ihållande förekomster indikerar att du behöver en högre tjänstnivå eller en mindre bullrig miljö.
40020, 40143, 40166, 40540	Azure SQL failover-underkod	Rapporteras i platsen Error code %d för fel 40197 vid redundansväxling.	Underkoder som ingår i ett 40197-failovermeddelande och som i vissa fall visas som felkod på toppnivå. Behandla dem på samma sätt som 40197.
40197	Azure SQL failover	The service has encountered an error processing your request. Please try again. Error code %d.	En programvaruuppgradering, maskinvarufel eller annan redundanshändelse i Azure SQL. När du återansluter dirigeras du till en felfri replik. Den inbäddade felkoden identifierar redundanstypen. Om felet kvarstår samlar du in sessionsspårnings-ID:t och kontaktar supporten.
40501	Begränsning i Azure SQL	The service is currently busy. Retry the request after 10 seconds. Incident ID: %ls. Code: %d.	Begränsning i Azure SQL-databasmotorn Den rekommenderade miniminivån är en väntetid på 10 sekunder. Ihållande strypning indikerar att arbetsbelastningen översteg databasens resursallokering; Skala upp tjänstenivån eller minska samtidigheten.
40613	Databasen är inte tillgänglig	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'.	Databasen är inte tillgänglig, vanligtvis under en redundansväxling eller en kort stund under en skalningsåtgärd. Försök igen vid en backoff; Om det kvarstår efter några minuter samlar du in sessionsspårnings-ID:t och öppnar ett supportärende.
42108	SQL-pool pausad	Can not connect to the SQL pool since it is paused. Please resume the SQL pool and try again.	Den dedikerade SQL-poolen (Synapse) är i pausat tillstånd. Återförsöket lyckas först när poolen har återupptagits. Återuppta poolen uttryckligen, eller schemalägg arbetsbelastningen så att den körs efter att poolen har återupptagits.
42109	SQL-pool återupptar	The SQL pool is warming up. Please try again.	Den dedikerade SQL-poolen håller på att återupptas. Försök igen vid en backoff tills poolen är online. uppvärmning tar vanligtvis några minuter.
49918	Brist på serviceresurser	Cannot process request. Not enough resources to process request. The service is currently busy. Please retry the request later.	Servern kan för närvarande inte allokera tillräckligt med resurser för att uppfylla begäran. Försök igen vid en backoff. Om felet kvarstår skalar du upp databasen eller den elastiska poolen.
49919	Begränsning av hanteringsåtgärder	Cannot process create or update request. Too many create or update operations in progress for subscription "%ld".	Samtidighetsgräns på prenumerationsnivå för hanteringsoperationer. Minska antalet parallella anrop för att skapa eller uppdatera, eller fördela dem över tid.
49920	Begränsning av prenumerationsåtgärder	Cannot process request. Too many operations in progress for subscription "%ld".	Samtidighetsgräns på prenumerationsnivå för åtgärder under flygning. Minska graden av parallellism eller vänta tills pågående åtgärder har slutförts.

Fel på instruktionsnivå finns inte i den här listan eftersom de utlöses när anslutningen har upprättats och felet lämnar sessionen användbar. De vanligaste återförsöksbara instruktionsfelen är 1205 (deadlock victim) och 1222 (tidsgräns för låsbegäran). Försök igen hela transaktionen i stället för den enda misslyckade instruktionen.

Felmeddelandetexten kommer från Azure SQL tillfälliga anslutningsfel. Dessa fel kan försökas igen i SQL Server, Azure SQL Database, Azure SQL Managed Instance, SQL-databas i Microsoft Fabric och dedikerade SQL-pooler i Azure Synapse Analytics.

Hantera Azure-begränsning

Azure SQL-throttling-fel kräver längre fördröjningar och fler försök än standard transientfel. Återanvändning is_azure_throttling från Identifiera tillfälliga fel:

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

Hantera övergång

Återanslut och försök igen när Azure SQL eller tillgänglighetsgruppens failover avbryter en anslutning:

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"}
)

Hantering av deadlock

Omprövning vid deadlock

Deadlocks (fel 1205) är transienta. Försök igen med en kort slumpmässig fördröjning för att bryta deadlock-cykeln. Att försöka igen hanterar det omedelbara felet, men återkommande deadlocks indikerar ett designproblem som du bör undersöka på serversidan. För vägledning om hur man analyserar och löser grundorsaken, se Deadlock-fel.

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

Strukturerad omprövning med konfiguration

Principklass för återförsök

Kapsla in omprovkonfiguration i en dataklass för återanvändning över olika operationer:

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)

Kretsbrytarmönster

Förhindra kaskadfel genom att spåra på varandra följande fel och tillfälligt blockera samtal när en tröskel nås:

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

Försök inte igen vid konfigurationsfel

Inte alla fel är övergående. Att försöka om en konfigurations- eller kodningsfel slösar tid och kan dölja det verkliga problemet. Försök bara igen vid fel som kan lösa sig själva. Eftersom mssql-python inte exponerar motorfelnumret som ett attribut, klassificera efter undantagsunderklass plus texten driver_error .

Försök aldrig om dessa (fixa koden eller konfigurationen istället):

Tillstånd	Undantagstyp	driver_error text	Reparera
Ogiltigt objektnamn (motor 208)	ProgrammingError	Base table or view not found	Tabellen finns inte. Fixa frågan eller skapa tabellen.
Ogiltigt kolumnnamn (motor 207)	ProgrammingError	Column not found	Kolumnen existerar inte. Kolla schemat.
Felaktig syntax (motor 102)	ProgrammingError	Syntax error or access violation	Åtgärda frågan.
Inloggning misslyckades (motor 18456)	OperationalError	Invalid authorization specification	Fel behörighet. Åtgärda anslutningssträngen.
Databas saknas eller åtkomst nekad (databasmotor 4060)	OperationalError	Server rejected the connection	Databasen finns inte eller är inte tillgänglig för inloggningen. Fixa målet eller behörigheterna.
Uttömning av anslutningspoolen	OperationalError	(varierar)	Öka poolkapaciteten, släpp anslutningar snabbt eller minska samtidighet.
ConnectionStringParseError	Fristående	n/a	Stavfel i nyckelordet i anslutningssträngen. Fixa snöret.
Ej stödd funktion	NotSupportedError	Optional feature not implemented	Använd en alternativ metod.

Försök alltid om dessa (de löser sig av sig själva):

Tillstånd	Undantagstyp	driver_error text
Utdragstidsgräns	OperationalError	Timeout expired
Tidsgräns för anslutning	OperationalError	Connection timeout expired
Kunde inte öppna anslutningen	OperationalError	Client unable to establish connection
Nätverksnedsläpp	OperationalError	Communication link failure
Anslutningen avbruten mitt i transaktionen	OperationalError	Connection failure during transaction
Dödlägesoffer (motor 1205)	OperationalError	Serialization failure
Indeterminärt transaktionstillstånd	OperationalError	Statement completion unknown
Azure SQL throttling (40197, 40501, 40613, 49918–49920)	ProgrammingError	Syntax error or access violation (använd is_azure_throttling för att matcha ddbc_error texten)

Relaterat innehåll

• Felhantering och SQLSTATE-koder för mssql-python
• Anslutningspoolning med mssql-python
• Felsökning mssql-python
• Felsöka tillfälliga anslutningsfel