Czy SQLAlchemy ma odpowiednik get_or_create w Django?

Chcę pobrać obiekt z bazy danych, jeśli już istnieje (na podstawie podanych parametrów) lub utworzyć go, jeśli nie.

Django get_or_create(lub źródło ) robi to. Czy istnieje równoważny skrót w SQLAlchemy?

Obecnie piszę to wyraźnie w ten sposób:

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

W zasadzie tak to zrobić, nie ma łatwo dostępnego skrótu AFAIK.

Możesz to oczywiście uogólnić:

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

Po rozwiązaniu @WoLpH, oto kod, który działał dla mnie (wersja prosta):

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

Dzięki temu mogę get_or_create dowolny obiekt mojego modelu.

Załóżmy, że mój obiekt modelu to:

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

Aby pobrać lub stworzyć mój obiekt, piszę:

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

Bawiłem się tym problemem i otrzymałem dość solidne rozwiązanie:

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

Właśnie napisałem dość obszerny wpis na blogu ze wszystkimi szczegółami, ale kilka pomysłów, dlaczego go użyłem.

1. Rozpakowuje się do krotki, która mówi, czy obiekt istniał, czy nie. Często może to być przydatne w Twoim przepływie pracy.

2. Funkcja daje możliwość pracy z @classmethoddekorowanymi funkcjami kreatora (i specyficznymi dla nich atrybutami).

3. Rozwiązanie chroni przed warunkami wyścigu, gdy do magazynu danych jest podłączony więcej niż jeden proces.

EDYCJA: Zmieniłem session.commit()na, session.flush()jak wyjaśniono w tym poście na blogu . Należy zauważyć, że te decyzje są specyficzne dla używanego magazynu danych (w tym przypadku Postgres).

EDYCJA 2: Zaktualizowałem za pomocą {} jako wartości domyślnej w funkcji, ponieważ jest to typowa gotcha Pythona. Dzięki za komentarz , Nigel! Jeśli ciekawi Cię ten problem, sprawdź to pytanie StackOverflow i ten post na blogu .

Zmodyfikowana wersja doskonałej odpowiedzi Erika

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

• Użyj transakcji zagnieżdżonej, aby tylko wycofać dodawanie nowego elementu zamiast wycofywać wszystko (zobacz tę odpowiedź, aby użyć transakcji zagnieżdżonych z SQLite)
• Ruszaj się create_method. Jeśli utworzony obiekt ma relacje i przypisane są do niego członkowie za pośrednictwem tych relacji, jest on automatycznie dodawany do sesji. Np. Utwórz book, który ma user_idi userjako odpowiedni związek, a następnie wykonując book.user=<user object>wewnątrz create_method, dodasz bookdo sesji. Oznacza to, że create_methodmusi znajdować się w środku, withaby skorzystać z ewentualnego wycofania. Zauważ, że begin_nestedautomatycznie uruchamia kolor.

Zauważ, że jeśli używasz MySQL, poziom izolacji transakcji musi być ustawiony na, READ COMMITTEDa nie, REPEATABLE READaby to zadziałało. Django get_or_create (i tutaj ) używa tego samego podstępu, zobacz także dokumentację Django .

Ten przepis SQLALchemy wykonuje zadanie ładnie i elegancko.

Pierwszą rzeczą do zrobienia jest zdefiniowanie funkcji, której dana jest sesja do pracy i powiązanie słownika z funkcją Session (), która śledzi bieżące unikalne klucze.

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

Przykładem wykorzystania tej funkcji może być 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
            )

I wreszcie tworząc unikalny model 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()

Przepis zagłębia się w pomysł i zapewnia różne podejścia, ale użyłem tego z wielkim sukcesem.

Najbliższe semantycznie jest prawdopodobnie:

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

nie jestem pewien, jak koszerne jest poleganie na globalnie zdefiniowanym Sessionw sqlalchemy, ale wersja Django nie ma połączenia, więc ...

Zwrócona krotka zawiera instancję i wartość logiczną wskazującą, czy instancja została utworzona (tj. Jest fałszywa, jeśli odczytujemy instancję z bazy danych).

Django get_or_createjest często używane, aby upewnić się, że dane globalne są dostępne, więc zatwierdzam w możliwie najwcześniejszym momencie.

Trochę uprościłem @Kevin. rozwiązanie pozwalające uniknąć zawijania całej funkcji w instrukcji if/ else. W ten sposób jest tylko jeden return, który uważam za czystszy:

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

W zależności od przyjętego poziomu izolacji żadne z powyższych rozwiązań nie zadziała. Najlepsze rozwiązanie jakie znalazłem to RAW SQL w postaci:

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

Jest to bezpieczne transakcyjnie niezależnie od poziomu izolacji i stopnia równoległości.

Uwaga: aby było wydajne, dobrze byłoby mieć INDEKS dla unikalnej kolumny.