Empêcher SQLAlchemy de définir automatiquement IDENTITY_INSERT

Selon la Documentation SQLAlchemy 1.3 :

Dans le cas où cette génération par défaut de IDENTITY n'est pas souhaitée, spécifiez False pour l'indicateur Column.autoincrement , sur le premier entier colonne de clé primaire:

m = MetaData()
t = Table('t', m,
        Column('id', Integer, primary_key=True, autoincrement=False),
        Column('x', Integer))
m.create_all(engine)

Pourquoi ne pas simplement remplacer le constructeur?

import warnings

class AutoIncrMixin:
    id = Column('ID', Integer, primary_key=True, autoincrement=True)

    def __init__(self, id=None, **kwargs):
        if id is not None:
            warnings.warn("supplied `id` value was ignored")
        super().__init__(**kwargs)

class Tub(Base, AutoIncrMixin):
    tare_weight = ...

Si vous voulez que la même chose s'applique à de nombreuses classes, vous pouvez implémenter un mixin:

class Tub(Base):
    __tablename__ = 'Tub'

    id = Column('ID', Integer, primary_key=True, autoincrement=True)
    tare_weight = Column('TareWeight', Float(53), nullable=False)

    def __init__(self, id=None, **kwargs):
        if id is not None:
            raise ValueError("Hey, don't pass in `id`!")
            # or you could even just ignore that it was passed in and issue a warning.
        super().__init__(**kwargs)

À long terme, vous pourriez faire un patching complet de singe. Je ne pense pas que cela résout tous vos problèmes, mais cela empêche l'utilisation de SET IDENTITY_INSERT . Vous pourriez singe patcher MSExecutionContext s pre_exec et post_exec . Par exemple:

from sqlalchemy import engine
from sqlalchemy.dialects.mssql.base import MSExecutionContext

def pre_exec(self):
    if self.isinsert:
        tbl = self.compiled.statement.table
        seq_column = tbl._autoincrement_column
        insert_has_sequence = seq_column is not None

        self._select_lastrowid = (
            not self.compiled.inline
            and insert_has_sequence
            and not self.compiled.returning
            and not self._enable_identity_insert
            and not self.executemany
        )


def post_exec(self):
    conn = self.root_connection
    if self._select_lastrowid:
        if self.dialect.use_scope_identity:
            conn._cursor_execute(
                self.cursor,
                "SELECT scope_identity() AS lastrowid",
                (),
                self,
            )
        else:
            conn._cursor_execute(
                self.cursor, "SELECT @@identity AS lastrowid", (), self
            )
        # fetchall() ensures the cursor is consumed without closing it
        row = self.cursor.fetchall()[0]
        self._lastrowid = int(row[0])

    if (
        self.isinsert or self.isupdate or self.isdelete
    ) and self.compiled.returning:
        self._result_proxy = engine.FullyBufferedResultProxy(self)


MSExecutionContext.pre_exec = pre_exec
MSExecutionContext.post_exec = post_exec

Mon exemple brut de ceci en cours d'utilisation monkey corrige les fonctions qui utilisent la fonctionnalité _enable_identity_insert et supprime ces parties. Désormais, toute tentative pour INSÉRER spécifiquement un identifiant vous donnera l'erreur suivante:

sqlalchemy.exc.IntegrityError: (pyodbc.IntegrityError) ('23000', "[23000] [Microsoft] [SQL Server Native Client 11.0] [SQL Server] Impossible d'insérer une valeur explicite pour la colonne d'identité dans la table" Tub "lorsque IDENTITY_INSERT est réglé sur OFF. (544) (SQLExecDirectW) ")

Votre problème maintenant sera probablement que vous dépendez entièrement de la fonctionnalité d'incrémentation automatique, mais peut-être que cela sera utile à certains, ou vous trouverez un autre moyen de contourner cette fonctionnalité.