Повторите логику и устойчивость соединений с помощью mssql-python

Временные сбои — это временные ошибки, которые могут возникать при подключении к SQL Server и Azure SQL через драйвер mssql-python. Эти ошибки часто решаются сами по себе:

• Кратковременные сбои сетевого подключения.
• Ограничения ресурсов сервера.
• Ограничение ресурсов Azure SQL
• Аварийные события.

Внедрение повторной логики повышает надёжность приложений, особенно для облачных баз данных.

Не используйте повторные попытки, чтобы скрыть ошибки в конфигурации или коде. Отсутствующая база данных, плохие учетные данные или исчерпанный пул соединений требуют исправления, а не новой попытки.

При пулировании и провайдере по умолчанию msodbcsql18 драйвер временно применяет нативный тайм-аут операции с соединением при проверке повторно использованного соединения: положительный тайм-аут входа, или 15 секунд, когда тайм-аут входа равен нулю или не указан. Это не полная проверка или крайний срок оформления заказа. Несколько нативных операций, очистка и открытие нового соединения могут увеличить время. Если проверка не проходит, драйвер пытается выполнить замену вместо того, чтобы ожидать каждое из оставшихся неактивных соединений. Это восстановление не повторяет ваши операторы и не выполняет повторную попытку при исчерпании пула. Для получения дополнительной информации см. раздел Пулирование соединений.

Выявление временных ошибок

MSSQL-python не показывает номер ошибки движка SQL Server в качестве атрибута при исключениях. Вместо этого драйвер отображает коды SQLSTATE с фиксированным набором подклассов исключений PEP 249 (OperationalError, ProgrammingErrorи так далее) и со стандартизированным английским текстом в атрибуте driver_error . Используйте эту комбинацию как основу для классификации временных объектов.

Надёжные переходные сигналы

Следующие значения SQLSTATE отображаются как OperationalError и указывают на состояние, которое стоит повторить. Правый столбец показывает точный driver_error текст, установленный драйвером:

SQLSTATE	driver_error Текст	Condition
HYT00	Timeout expired	Тайм-аут на уровне заявления.
HYT01	Connection timeout expired	Тайм-аут при подключении.
08001	Client unable to establish connection	Не удалось открыть соединение.
08S01	Communication link failure	Обрыв сети, сброс сервера, сбой TCP.
08007	Connection failure during transaction	Соединение прервалось во время выполнения транзакции.
40001	Serialization failure	Жертва тупика.
40003	Statement completion unknown	Неопределённое состояние транзакции.

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 (по мере возможности)

Ошибки ограничения скорости запросов в Azure SQL (40197, 40501, 40613, 49918, 49919, 49920 и связанные с ними коды) обычно передаются с SQLSTATE 42000, который mssql-python сопоставляет с ProgrammingError. Номер ошибки движка не отображается как атрибут, поэтому единственный сигнал — это текст сообщения сервера в атрибуте ddbc_error .

Проверьте ddbc_error на наличие известных номеров при наличии и стандартное английское сообщение об ошибке 40501. Номер может отсутствовать, а текст сообщения не является фиксированным соглашением. Локализованная или по-другому форматированная диагностика может не совпадать:

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)

Что не следует повторять

Примеры ошибок, которые должны завершаться немедленно вместо повторной попытки, включают недействительные учетные данные (OperationalError с драйверным текстом Invalid authorization specification), отсутствующую базу данных или недостаточные права доступа, синтаксические ошибки (ProgrammingError), отсутствующие объекты и исчерпание пула соединений. Приведённая is_transient_error выше функция исключает все эти функции по конструкции.

Базовый декоратор повторов

Простая повторная попытка с фиксированной задержкой

Декоратор, который повторно вызывает обёрнутую функцию фиксированное количество раз с постоянной задержкой:

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

Экспоненциальная задержка

Увеличите задержку между повторами экспоненциально с помощью опционального джиттера, чтобы распределить параллельные повторы:

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

Класс повторной попытки соединения

Устойчивый менеджер соединений

Обёртка соединения, которая обрабатывает как повторную попытку, так и автоматическое повторное подключение:

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

Используйте отображение исключений в mssql-python в разделе Identify transient errors, чтобы классифицировать ошибки из следующего каталога.

Следующие ошибки могут быть временными, когда возникают при установлении соединения или при отправке запроса на сервер. Повторите попытку на коротком, ограниченном обратном выходе. Ошибки, которые сохраняются после нескольких повторных попыток, обычно указывают на проблему с конфигурацией, например, неправильный сервер, отсутствующие права, несовместимые настройки шифрования или исчерпанный лимит, которые повторная попытка не исправит.

Error	Тип сбоя	Message	Troubleshooting
64	Транспорт во время входа	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-подключение удаляется в середине подтверждения. Это не ошибка учетных данных. Если он сохраняется, проверьте нестабильность сети на стороне клиента или промежуточное устройство, которое удаляет половину установленных подключений.
233	Транспорт до входа в систему или TLS	The client was unable to establish a connection because of an error during connection initialization process before login.	Сервер обычно возвращает эту ошибку, если не может принять соединение из-за исчерпания ресурсов, ограничения соединения или неподдерживаемого клиента. Это не ошибка учетных данных. Проверьте работоспособность сервера, а затем проверьте время ожидания входа клиента, параметры TLS и совместимость версий TLS клиента и сервера.
4060	Доступность или доступ к базе данных	Cannot open database "%.*ls" requested by the login. The login failed.	Вход в систему проходит проверку подлинности, но не удаётся открыть запрошенную базу данных. К временным причинам относятся переходное состояние базы данных (переключение на резервный ресурс, восстановление, масштабирование) или ее автоматическая приостановка. Постоянные причины (база данных не существует, логин не имеет доступа) не будут устранены повторной попыткой; проверьте имя базы данных, сопоставление логина и состояние базы данных.
4221	Переход между читаемыми и вторичными	Login to read-secondary failed due to long wait on 'HADR_DATABASE_WAIT_FOR_TRANSITION_TO_VERSIONING'.	Реплика недоступна для входа в систему, так как для транзакций, которые ещё выполнялись в момент пересоздания реплики, отсутствуют версии строк. Откатите или зафиксируйте активные транзакции на основном сервере, чтобы устранить проблему. Снизьте влияние этой проблемы, избегая длительных транзакций записи на основном сервере.
10053	Прерывание локального транспорта	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.)	Локальная сторона прерывает подключение. Проверьте работоспособность сети на стороне клиента и любой локальный брандмауэр или VPN-клиент.
10054	Удалённый сброс транспортировки	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.)	Удаленная сторона отправляет сброс TCP. Распространенные причины: сбой однорангового процесса, брандмауэр ввел сброс или шлюз Azure SQL закрыл неактивное подключение. Для сценариев сброса простаивающих соединений включите TCP keepalive на стороне клиента или сократите тайм-аут простоя пула подключений.
10060	Время соединения истекло	A connection attempt failed because the connected party did not properly respond after a period of time.	Сервер или промежуточное сетевое устройство не ответили до окончания тайм-аута соединения TCP. Проверьте состояние сервера, маршрутизацию, правила межсетевого экрана и доступны ли настроенный хост и порт.
10928	Лимит ресурсов базы данных	Resource ID: %d. The %s limit for the database is %d and has been reached.	База данных превышает ограничение Azure SQL управления ресурсами. Идентификатор ресурса 1 указывает на лимит рабочих процессов, а идентификатор ресурса 2 — на лимит сеансов. Определите тип ограничения из сообщения, а затем уменьшите параллелизм, масштабируйте базу данных или сократите длительные операции хранения ресурса.
10929	Ограничение пропускной способности базы данных	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.	База данных превысила минимально гарантированный уровень, и лежащий в ее основе сервер ограничивает производительность. Повторная попытка обычно бывает успешной, когда нагрузка на соседний узел снижается. Постоянное повторение таких случаев означает, что вам нужен более высокий тарифный план или менее шумная среда.
40020, 40143, 40166, 40540	подкод переключения при отказе Azure SQL	Сообщение в слоте Error code %d об ошибке 40197 во время переключения при отказе.	Подкоды, встроенные в сообщение о переходе на резервный ресурс 40197, которые в некоторых путях обработки отображаются как код ошибки верхнего уровня. Обработайте их так же, как 40197.
40197	Azure SQL failover	The service has encountered an error processing your request. Please try again. Error code %d.	Обновление программного обеспечения, сбой оборудования или другое событие переключения при отказе в Azure SQL. Повторное подключение маршрутизирует вас к работоспособной реплике. Встроенный код ошибки определяет тип переключения при отказе. Если ошибка сохраняется, запишите идентификатор трассировки сеанса и обратитесь в службу поддержки.
40501	Ограничение пропускной способности Azure SQL	The service is currently busy. Retry the request after 10 seconds. Incident ID: %ls. Code: %d.	Ограничение производительности ядра Azure SQL. Рекомендуемая минимальная задержка перед повторной попыткой — 10 секунд. Устойчивый троттлинг указывает на то, что рабочая нагрузка превысила объем ресурсов, выделенных базе данных; перейдите на более высокий уровень обслуживания или уменьшите степень параллелизма.
40613	База данных недоступна	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'.	База данных недоступна, как правило, во время переключения при отказе или ненадолго во время операции масштабирования. Повторите попытку с увеличивающейся задержкой; если проблема сохраняется дольше нескольких минут, запишите идентификатор трассировки сеанса и создайте обращение в службу поддержки.
42108	SQL-пул приостановлен	Can not connect to the SQL pool since it is paused. Please resume the SQL pool and try again.	Выделенный пул SQL (Synapse) находится в приостановленном состоянии. Повторная попытка будет успешной только после возобновления пула. Возобновите пул явным образом или запланируйте рабочую нагрузку после возобновления работы пула.
42109	Возобновление SQL-пула	The SQL pool is warming up. Please try again.	Выделенный пул SQL возобновляется. Повторяйте попытки с увеличивающейся задержкой, пока пул не перейдёт в состояние онлайн; прогрев обычно занимает несколько минут.
49918	Нехватка сервисных ресурсов	Cannot process request. Not enough resources to process request. The service is currently busy. Please retry the request later.	Сервер в настоящее время не может выделить достаточно ресурсов для удовлетворения запроса. Повторите попытку на обратном выходе. Если ошибка сохраняется, увеличьте вычислительные ресурсы базы данных или эластичного пула.
49919	Управление и эксплуатация троттлинга	Cannot process create or update request. Too many create or update operations in progress for subscription "%ld".	Ограничение параллелизма на уровне подписки для операций управления. Уменьшите количество параллельных вызовов создания и обновления или разнесите их по времени.
49920	Ограничивание подписочных операций	Cannot process request. Too many operations in progress for subscription "%ld".	Ограничение параллелизма на уровне подписки для операций в полете. Уменьшите параллелизм или дождитесь завершения выполняющихся операций.

Ошибки на уровне инструкций не входят в этот список, поскольку они возникают после установления соединения, и после такого сбоя сеанс остаётся пригодным для использования. Наиболее распространёнными ошибками инструкций, допускающих повторное выполнение, являются 1205 (жертва взаимоблокировки) и 1222 (превышение времени ожидания запроса блокировки). Повторите всю транзакцию, а не одну инструкцию сбоя.

Текст сообщения об ошибке взят из временных ошибок подключения к Azure SQL. При возникновении этих ошибок возможна повторная попытка в SQL Server, База данных SQL Azure, Управляемый экземпляр SQL Azure, базе данных SQL в Microsoft Fabric и выделенных пулах SQL в Azure Synapse Analytics.

Обработка троттлинга Azure

Ошибки ограничения Azure SQL требуют более длительных задержек и большего числа повторных попыток, чем обычные временные ошибки. Повторно используйте 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

Управление отказом

Повторно подключитесь и повторите попытку, если Azure SQL или аварийное переключение группы доступности прерывает подключение:

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

Обработка тупика

Повтор на тупиковом режиме

Взаимоблокировки (ошибка 1205) носят временный характер. Попробуйте повторить с короткой случайной задержкой, чтобы разорвать цикл тупика. Повторная попытка решает немедленный сбой, но повторяющиеся тупики указывают на конструктивную проблему, которую стоит проверить на серверной стороне. Для получения рекомендаций по анализу и устранению коренной причины см. раздел Deadlock errors.

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

Структурированная повторная попытка с настройкой

Класс политики повторных попыток

Инкапсулируйте конфигурацию повторных попыток в классе данных для повторного использования в различных операциях:

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)

Шаблон разбиения цепи

Предотвращайте каскадные сбои, отслеживая последовательные ошибки и временно блокируя вызовы при достижении порога:

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

Не повторяйте ошибки настройки

Не каждая ошибка временна. Повторная попытка ошибки настройки или кода тратит время и может скрыть настоящую проблему. Перепробуй только те ошибки, которые могут решиться сами по себе. Поскольку mssql-python не раскрывает номер ошибки движка как атрибут, классифицируйте по подклассу исключения плюс тексту driver_error .

Никогда не повторяйте это (исправьте код или конфигурацию):

Condition	Тип исключения	driver_error Текст	Исправление
Недопустимое имя объекта (движок 208)	ProgrammingError	Base table or view not found	Таблица не существует. Исправьте запрос или создайте таблицу.
Недопустимое название столбца (двигатель 207)	ProgrammingError	Column not found	Колонки не существует. Проверьте схему.
Неправильный синтаксис (движок 102)	ProgrammingError	Syntax error or access violation	Исправьте запрос.
Не удалось выполнить вход (подсистема 18456)	OperationalError	Invalid authorization specification	Неправильные удостоверения. Исправьте строку подключения.
Отсутствует база данных или запрещён доступ (модуль 4060)	OperationalError	Server rejected the connection	База данных не существует или недоступна для входа. Исправьте цель или разрешения.
Исчерпание пула подключений	OperationalError	(варьируется)	Увеличьте ёмкость пула, своевременно освобождайте соединения или уменьшите уровень параллелизма.
ConnectionStringParseError	Автономный	н/д	Опечатка в ключевом слове строка подключения. Починьте верёвку.
Неподдерживаемая функция	NotSupportedError	Optional feature not implemented	Используйте альтернативный подход.

Всегда повторяйте эти методы (они проходят сами по себе):

Condition	Тип исключения	driver_error Текст
Время простоя оператора	OperationalError	Timeout expired
Время ожидания подключения	OperationalError	Connection timeout expired
Не удалось открыть соединение	OperationalError	Client unable to establish connection
Потеря соединения с сетью	OperationalError	Communication link failure
Соединение прервано во время транзакции	OperationalError	Connection failure during transaction
Жертва тупика (двигатель 1205)	OperationalError	Serialization failure
Неопределённое состояние транзакции	OperationalError	Statement completion unknown
Azure SQL throttling (40197, 40501, 40613, 49918–49920)	ProgrammingError	Syntax error or access violation (используйте is_azure_throttling для сопоставления ddbc_error текста)

Связанные материалы

• Обработка ошибок и коды SQLSTATE для mssql-python
• Пул соединений с mssql-python
• Устранение неполадок mssql-python
• Устранение кратковременных ошибок подключения