Hat SQLAlchemy ein Äquivalent zu get_or_create von Django?

Ich möchte ein Objekt aus der Datenbank abrufen, wenn es bereits vorhanden ist (basierend auf den angegebenen Parametern), oder es erstellen, wenn dies nicht der Fall ist.

Djangos get_or_create(oder Quelle ) tut dies. Gibt es eine entsprechende Abkürzung in SQLAlchemy?

Ich schreibe es gerade explizit so aus:

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

Das ist im Grunde der Weg, es gibt keine Abkürzung AFAIK.

Sie könnten es natürlich verallgemeinern:

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

Nach der Lösung von @WoLpH ist dies der Code, der für mich funktioniert hat (einfache Version):

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

Damit kann ich jedes Objekt meines Modells abrufen oder erstellen.

Angenommen, mein Modellobjekt ist:

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

Um mein Objekt zu erhalten oder zu erstellen, schreibe ich:

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

Ich habe mit diesem Problem gespielt und eine ziemlich robuste Lösung gefunden:

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

Ich habe gerade einen ziemlich umfangreichen Blog-Beitrag über alle Details geschrieben, aber ein paar gute Ideen, warum ich das verwendet habe.

1. Es wird in ein Tupel entpackt, das Ihnen sagt, ob das Objekt vorhanden ist oder nicht. Dies kann in Ihrem Workflow häufig hilfreich sein.

2. Die Funktion bietet die Möglichkeit, mit @classmethoddekorierten Erstellerfunktionen (und spezifischen Attributen) zu arbeiten.

3. Die Lösung schützt vor Race-Bedingungen, wenn mehr als ein Prozess mit dem Datenspeicher verbunden ist.

EDIT: Ich habe zu geändert session.commit(), session.flush()wie in diesem Blog-Beitrag erklärt . Beachten Sie, dass diese Entscheidungen spezifisch für den verwendeten Datenspeicher sind (in diesem Fall Postgres).

BEARBEITEN 2: Ich habe mit einem {} als Standardwert in der Funktion aktualisiert, da dies ein typisches Python-Gotcha ist. Danke für den Kommentar , Nigel! Wenn Sie neugierig auf dieses Problem sind, lesen Sie diese StackOverflow-Frage und diesen Blog-Beitrag .

Eine modifizierte Version von eriks ausgezeichneter Antwort

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

• Verwenden Sie eine verschachtelte Transaktion, um nur das Hinzufügen des neuen Elements zurückzusetzen, anstatt alles zurückzusetzen (siehe diese Antwort , um verschachtelte Transaktionen mit SQLite zu verwenden).
• Bewegen Sie sich create_method. Wenn das erstellte Objekt Beziehungen hat und über diese Beziehungen Mitglieder zugewiesen werden, wird es automatisch zur Sitzung hinzugefügt. Erstellen Sie z. B. eine book, die eine entsprechende Beziehung hat, user_idund fügen Sie sie userdann book.user=<user object>innerhalb der Sitzung hinzu. Dies bedeutet, dass es sich im Inneren befinden muss , um von einem eventuellen Rollback zu profitieren. Beachten Sie, dass automatisch ein Flush ausgelöst wird.create_methodbookcreate_methodwithbegin_nested

Beachten Sie, dass MySQL , wenn verwenden, muss die Transaktionsisolationsstufe eingestellt werden , READ COMMITTEDanstatt REPEATABLE READdafür zu arbeiten. Djangos get_or_create (und hier ) verwendet dieselbe Strategie, siehe auch die Django- Dokumentation .

Dieses SQLALchemy-Rezept macht den Job schön und elegant.

Als Erstes müssen Sie eine Funktion definieren, die eine Sitzung erhält, mit der Sie arbeiten können, und der Sitzung () ein Wörterbuch zuordnen, das die aktuellen eindeutigen Schlüssel verfolgt.

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

Ein Beispiel für die Verwendung dieser Funktion wäre ein 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
            )

Und schließlich das einzigartige Modell get_or_create erstellen:

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

Das Rezept geht tiefer in die Idee ein und bietet verschiedene Ansätze, aber ich habe diesen mit großem Erfolg verwendet.

Das semantisch am nächsten ist wahrscheinlich:

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

SessionIch bin mir nicht sicher, wie koscher es ist, sich auf eine global in sqlalchemy definierte Version zu verlassen , aber die Django-Version nimmt keine Verbindung auf, also ...

Das zurückgegebene Tupel enthält die Instanz und einen Booleschen Wert, der angibt, ob die Instanz erstellt wurde (dh es ist falsch, wenn wir die Instanz aus der Datenbank lesen).

Django get_or_createwird oft verwendet, um sicherzustellen, dass globale Daten verfügbar sind, sodass ich mich zum frühestmöglichen Zeitpunkt verpflichte.

Ich habe @Kevin leicht vereinfacht. Lösung, um zu vermeiden, dass die gesamte Funktion in eine if/ else-Anweisung eingeschlossen wird. Auf diese Weise gibt es nur eine return, die ich sauberer finde:

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

Abhängig von der von Ihnen gewählten Isolationsstufe würde keine der oben genannten Lösungen funktionieren. Die beste Lösung, die ich gefunden habe, ist ein RAW-SQL in der folgenden Form:

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

Dies ist unabhängig von der Isolationsstufe und dem Grad der Parallelität transaktionssicher.

Achtung: Um die Effizienz zu steigern, ist es ratsam, einen INDEX für die eindeutige Spalte zu haben.