SQLAlchemy a-t-il un équivalent de get_or_create de Django?

Je veux obtenir un objet de la base de données s'il existe déjà (en fonction des paramètres fournis) ou le créer si ce n'est pas le cas.

Django get_or_create(ou source ) le fait. Existe-t-il un raccourci équivalent dans SQLAlchemy?

Je l'écris actuellement explicitement comme ceci:

def get_or_create_instrument(session, serial_number):
    instrument = session.query(Instrument).filter_by(serial_number=serial_number).first()
    if instrument:
        return instrument
    else:
        instrument = Instrument(serial_number)
        session.add(instrument)
        return instrument

C'est fondamentalement la façon de le faire, il n'y a pas de raccourci facilement disponible AFAIK.

Vous pouvez bien sûr généraliser:

def get_or_create(session, model, defaults=None, **kwargs):
    instance = session.query(model).filter_by(**kwargs).first()
    if instance:
        return instance, False
    else:
        params = dict((k, v) for k, v in kwargs.iteritems() if not isinstance(v, ClauseElement))
        params.update(defaults or {})
        instance = model(**params)
        session.add(instance)
        return instance, True

Suite à la solution de @WoLpH, voici le code qui a fonctionné pour moi (version simple):

def get_or_create(session, model, **kwargs):
    instance = session.query(model).filter_by(**kwargs).first()
    if instance:
        return instance
    else:
        instance = model(**kwargs)
        session.add(instance)
        session.commit()
        return instance

Avec cela, je suis capable de get_or_create n'importe quel objet de mon modèle.

Supposons que mon objet modèle soit:

class Country(Base):
    __tablename__ = 'countries'
    id = Column(Integer, primary_key=True)
    name = Column(String, unique=True)

Pour obtenir ou créer mon objet, j'écris:

myCountry = get_or_create(session, Country, name=countryName)

J'ai joué avec ce problème et j'ai fini avec une solution assez robuste:

def get_one_or_create(session,
                      model,
                      create_method='',
                      create_method_kwargs=None,
                      **kwargs):
    try:
        return session.query(model).filter_by(**kwargs).one(), False
    except NoResultFound:
        kwargs.update(create_method_kwargs or {})
        created = getattr(model, create_method, model)(**kwargs)
        try:
            session.add(created)
            session.flush()
            return created, True
        except IntegrityError:
            session.rollback()
            return session.query(model).filter_by(**kwargs).one(), False

Je viens d'écrire un article de blog assez volumineux sur tous les détails, mais quelques idées assez détaillées sur les raisons pour lesquelles j'ai utilisé cela.

1. Il se décompresse en un tuple qui vous indique si l'objet existait ou non. Cela peut souvent être utile dans votre flux de travail.

2. La fonction donne la possibilité de travailler avec des @classmethodfonctions de créateur décorées (et des attributs qui leur sont spécifiques).

3. La solution protège contre les conditions de concurrence lorsque vous avez plus d'un processus connecté à la banque de données.

EDIT: Je l' ai changé session.commit()pour , session.flush()comme expliqué dans ce billet de blog . Notez que ces décisions sont spécifiques à la banque de données utilisée (Postgres dans ce cas).

EDIT 2: J'ai mis à jour en utilisant un {} comme valeur par défaut dans la fonction car c'est un gotcha typique de Python. Merci pour le commentaire , Nigel! Si vous êtes curieux de savoir ce que vous en pensez , consultez cette question StackOverflow et cet article de blog .

Une version modifiée de l'excellente réponse d'Erik

def get_one_or_create(session,
                      model,
                      create_method='',
                      create_method_kwargs=None,
                      **kwargs):
    try:
        return session.query(model).filter_by(**kwargs).one(), True
    except NoResultFound:
        kwargs.update(create_method_kwargs or {})
        try:
            with session.begin_nested():
                created = getattr(model, create_method, model)(**kwargs)
                session.add(created)
            return created, False
        except IntegrityError:
            return session.query(model).filter_by(**kwargs).one(), True

• Utilisez une transaction imbriquée pour annuler uniquement l'ajout du nouvel élément au lieu de tout annuler (voir cette réponse pour utiliser des transactions imbriquées avec SQLite)
• Bougez create_method. Si l'objet créé a des relations et que des membres lui sont affectés via ces relations, il est automatiquement ajouté à la session. Par exemple, créez un book, qui a user_idet usercomme relation correspondante, puis faire à l' book.user=<user object>intérieur de create_methodajoutera bookà la session. Cela signifie qu'il create_methoddoit être à l'intérieur withpour bénéficier d'un éventuel retour en arrière. Notez que begin_nesteddéclenche automatiquement un flush.

Notez que si vous utilisez MySQL, le niveau d'isolation des transactions doit être défini sur READ COMMITTEDplutôt que REPEATABLE READpour que cela fonctionne. Get_or_create de Django (et ici ) utilise le même stratagème, voir aussi la documentation Django .

Cette recette SQLALchemy fait le travail et élégant.

La première chose à faire est de définir une fonction qui reçoit une Session avec laquelle travailler, et associe un dictionnaire à Session () qui garde la trace des clés uniques actuelles .

def _unique(session, cls, hashfunc, queryfunc, constructor, arg, kw):
    cache = getattr(session, '_unique_cache', None)
    if cache is None:
        session._unique_cache = cache = {}

    key = (cls, hashfunc(*arg, **kw))
    if key in cache:
        return cache[key]
    else:
        with session.no_autoflush:
            q = session.query(cls)
            q = queryfunc(q, *arg, **kw)
            obj = q.first()
            if not obj:
                obj = constructor(*arg, **kw)
                session.add(obj)
        cache[key] = obj
        return obj

Un exemple d'utilisation de cette fonction serait dans un mixin:

class UniqueMixin(object):
    @classmethod
    def unique_hash(cls, *arg, **kw):
        raise NotImplementedError()

    @classmethod
    def unique_filter(cls, query, *arg, **kw):
        raise NotImplementedError()

    @classmethod
    def as_unique(cls, session, *arg, **kw):
        return _unique(
                    session,
                    cls,
                    cls.unique_hash,
                    cls.unique_filter,
                    cls,
                    arg, kw
            )

Et enfin la création du modèle unique get_or_create:

from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

engine = create_engine('sqlite://', echo=True)

Session = sessionmaker(bind=engine)

class Widget(UniqueMixin, Base):
    __tablename__ = 'widget'

    id = Column(Integer, primary_key=True)
    name = Column(String, unique=True, nullable=False)

    @classmethod
    def unique_hash(cls, name):
        return name

    @classmethod
    def unique_filter(cls, query, name):
        return query.filter(Widget.name == name)

Base.metadata.create_all(engine)

session = Session()

w1, w2, w3 = Widget.as_unique(session, name='w1'), \
                Widget.as_unique(session, name='w2'), \
                Widget.as_unique(session, name='w3')
w1b = Widget.as_unique(session, name='w1')

assert w1 is w1b
assert w2 is not w3
assert w2 is not w1

session.commit()

La recette approfondit l'idée et propose différentes approches, mais j'ai utilisé celle-ci avec beaucoup de succès.

Le plus proche sémantiquement est probablement:

def get_or_create(model, **kwargs):
    """SqlAlchemy implementation of Django's get_or_create.
    """
    session = Session()
    instance = session.query(model).filter_by(**kwargs).first()
    if instance:
        return instance, False
    else:
        instance = model(**kwargs)
        session.add(instance)
        session.commit()
        return instance, True

Je ne sais pas à quel point il est casher de s'appuyer sur une définition globale Sessiondans sqlalchemy, mais la version Django ne prend pas de connexion alors ...

Le tuple retourné contient l'instance et un booléen indiquant si l'instance a été créée (c'est-à-dire qu'il est faux si nous lisons l'instance à partir de la base de données).

Django get_or_createest souvent utilisé pour s'assurer que les données globales sont disponibles, donc je m'engage le plus tôt possible.

J'ai légèrement simplifié @Kevin. solution pour éviter d'encapsuler toute la fonction dans une instruction if/ else. De cette façon, il n'y en a qu'un return, que je trouve plus propre:

def get_or_create(session, model, **kwargs):
    instance = session.query(model).filter_by(**kwargs).first()

    if not instance:
        instance = model(**kwargs)
        session.add(instance)

    return instance

Selon le niveau d'isolement que vous avez adopté, aucune des solutions ci-dessus ne fonctionnerait. La meilleure solution que j'ai trouvée est un RAW SQL sous la forme suivante:

INSERT INTO table(f1, f2, unique_f3) 
SELECT 'v1', 'v2', 'v3' 
WHERE NOT EXISTS (SELECT 1 FROM table WHERE f3 = 'v3')

Ceci est transactionnellement sûr quels que soient le niveau d'isolement et le degré de parallélisme.

Attention: pour le rendre efficace, il serait judicieux d'avoir un INDEX pour la colonne unique.