SQLAlchemy'nin Django'nun get_or_create eşdeğeri var mı?

Ben zaten (sağlanan parametrelere dayalı) varsa veritabanından bir nesne almak veya yoksa oluşturmak istiyorum.

Django's get_or_create(veya source ) bunu yapar. SQLAlchemy'de eşdeğer bir kısayol var mı?

Şu anda açıkça şöyle yazıyorum:

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

Temel olarak bunu yapmanın yolu, AFAIK'in hazır bir kısayolu yok.

Elbette genelleştirebilirsiniz:

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

@WoLpH çözümünün ardından, bu benim için çalışan kod (basit sürüm):

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

Bununla, modelimin herhangi bir nesnesini elde edebiliyorum.

Varsayalım benim model nesnem:

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

Nesnemi almak veya oluşturmak için şunu yazıyorum:

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

Bu sorunla oynuyorum ve oldukça sağlam bir çözüm buldum:

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

Tüm detaylar hakkında oldukça geniş bir blog yazısı yazdım , ancak bunu neden kullandığım hakkında birkaç fikir.

1. Nesnenin var olup olmadığını söyleyen bir demet açar. Bu genellikle iş akışınızda yararlı olabilir.

2. İşlev, @classmethodsüslü içerik oluşturucu işlevleriyle (ve bunlara özgü niteliklerle) çalışma yeteneği verir .

3. Veri deposuna bağlı birden fazla işleminiz olduğunda çözüm Yarış Koşullarına karşı koruma sağlar.

DÜZENLEME: ben değiştim session.commit()için session.flush()açıklandığı gibi bu blog yayınında . Bu kararların kullanılan veri deposuna özel olduğunu unutmayın (bu durumda Postgres).

DÜZENLEME 2: Tipik bir Python gotcha olduğundan işlevde varsayılan değer olarak bir {} kullanarak güncelledim. Yorum için teşekkürler Nigel! Bu sorun hakkında merak ediyorsanız, bu StackOverflow sorusuna ve bu blog gönderisine göz atın .

Erik'in mükemmel cevabının değiştirilmiş bir versiyonu

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

• Bir kullan iç içe işlem geri tek rulo yerine her şeyi geri haddeleme yeni ürünün eklenmesi (bu Bkz cevabı SQLite ile iç içe geçmiş işlem kullanmak için)
• Yürü create_method. Oluşturulan nesnenin ilişkileri varsa ve bu ilişkiler yoluyla üyelere atanırsa, otomatik olarak oturuma eklenir. Örneğin book, bir ilişkisi olan user_idve userbuna karşılık gelen bir ilişki oluşturmak, daha sonra book.user=<user object>içinde yapmak oturuma create_methodkatkıda bulunacaktır book. Bu, geri dönüşten yararlanmak create_methodiçin içeride olması gerektiği anlamına gelir with. begin_nestedBir yıkamayı otomatik olarak tetiklediğini unutmayın .

MySQL kullanılıyorsa, işlem yalıtım seviyesinin çalışması için bunun READ COMMITTEDyerine ayarlanması gerekir REPEATABLE READ. Django'nun get_or_create (ve burada ) aynı stratagem'i kullanır, ayrıca Django belgelerine de bakın .

Bu SQLALchemy tarifi işi güzel ve zarif yapıyor.

Yapılacak ilk şey, çalışmak için bir Oturum verilen bir işlevi tanımlamak ve geçerli benzersiz anahtarları izleyen Session () ile bir sözlük ilişkilendirmektir .

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

Bu işlevi kullanmanın bir örneği bir mixin'de olabilir:

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
            )

Ve son olarak benzersiz get_or_create modelini yaratın:

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

Tarif fikrin derinliklerine iner ve farklı yaklaşımlar sağlar, ancak bunu büyük bir başarıyla kullandım.

Anlamsal olarak en yakın olanı muhtemelen:

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

küresel olarak tanımlanmış bir güvenin ne kadar koşucu olduğundan emin değilim Sessionsqlalchemy'de güvenin koşucu değilim, ancak Django sürümü bir bağlantı almıyor bu yüzden ...

Döndürülen demet, örneği ve örneğin yaratıldığını belirten bir boole içerir (örneğin, örneği db'den okursak False olur).

Django's get_or_creategenellikle küresel verilerin mevcut olduğundan emin olmak için kullanılır, bu yüzden mümkün olan en erken noktada taahhüt ediyorum.

@Kevin'i biraz basitleştirdim. if/ elsedeyimine tüm işlevi sarmaktan kaçınmak için çözüm Bu şekilde returndaha temiz bulduğum sadece bir tane var :

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

Kabul ettiğiniz izolasyon seviyesine bağlı olarak, yukarıdaki çözümlerin hiçbiri işe yaramaz. Bulduğum en iyi çözüm aşağıdaki biçimde bir RAW SQL'dir:

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

İzolasyon seviyesi ve paralellik derecesi ne olursa olsun işlemsel olarak güvenlidir.

Dikkat: Verimli hale getirmek için, benzersiz sütun için bir INDEX'e sahip olmak akıllıca olacaktır.