Apakah SQLAlchemy setara dengan get_or_create Django?

Saya ingin mendapatkan objek dari database jika sudah ada (berdasarkan parameter yang disediakan) atau membuatnya jika tidak ada.

Django get_or_create(atau sumber ) melakukan ini. Apakah ada cara pintas yang setara di SQLAlchemy?

Saat ini saya menuliskannya secara eksplisit seperti ini:

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

Itu pada dasarnya cara untuk melakukannya, tidak ada jalan pintas yang tersedia AFAIK.

Anda dapat menggeneralisasikannya tentu saja:

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

Mengikuti solusi @WoLpH, ini adalah kode yang berfungsi untuk saya (versi sederhana):

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

Dengan ini, saya bisa mendapatkan_atau membuat objek model saya.

Misalkan objek model saya adalah:

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

Untuk mendapatkan atau membuat objek saya, saya menulis:

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

Saya telah bermain dengan masalah ini dan berakhir dengan solusi yang cukup kuat:

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

Saya hanya menulis posting blog yang cukup luas pada semua detail, tetapi beberapa ide mengapa saya menggunakan ini.

1. Itu membongkar ke sebuah tuple yang memberitahu Anda jika objek itu ada atau tidak. Ini sering berguna dalam alur kerja Anda.

2. Fungsi ini memberikan kemampuan untuk bekerja dengan @classmethodfungsi-fungsi pencipta yang didekorasi (dan atribut khusus untuk mereka).

3. Solusinya melindungi terhadap Kondisi Ras ketika Anda memiliki lebih dari satu proses yang terhubung ke datastore.

EDIT: Saya sudah berubah session.commit()menjadi session.flush()seperti yang dijelaskan dalam posting blog ini . Perhatikan bahwa keputusan ini khusus untuk datastore yang digunakan (Postgres dalam kasus ini).

EDIT 2: Saya telah memperbarui menggunakan {} sebagai nilai default dalam fungsi karena ini adalah gotcha khas Python. Terima kasih atas komentarnya , Nigel! Jika Anda penasaran dengan gotcha ini, lihat pertanyaan StackOverflow ini dan posting blog ini .

Versi modifikasi dari jawaban erik yang sangat baik

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

• Gunakan transaksi bersarang untuk hanya memutar kembali penambahan item baru alih-alih mengembalikan semuanya (Lihat jawaban ini untuk menggunakan transaksi bersarang dengan SQLite)
• Pindahkan create_method. Jika objek yang dibuat memiliki hubungan dan itu ditugaskan anggota melalui hubungan tersebut, itu secara otomatis ditambahkan ke sesi. Misalnya membuat book, yang memiliki user_iddan usersebagai hubungan yang sesuai, maka melakukan book.user=<user object>di dalam create_methodakan menambah booksesi. Ini berarti bahwa create_methodharus ada di dalam withuntuk mendapatkan keuntungan dari rollback akhirnya. Perhatikan bahwa begin_nestedsecara otomatis memicu flush.

Perhatikan bahwa jika menggunakan MySQL, level isolasi transaksi harus diatur agar READ COMMITTEDtidak REPEATABLE READberfungsi. Get_or_create Django (dan di sini ) menggunakan strategi yang sama, lihat juga dokumentasi Django .

Resep SQLALchemy ini melakukan pekerjaan dengan baik dan elegan.

Hal pertama yang harus dilakukan adalah mendefinisikan fungsi yang diberi Sesi untuk dikerjakan, dan mengaitkan kamus dengan Sesi () yang melacak kunci unik saat ini .

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

Contoh penggunaan fungsi ini adalah dalam 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
            )

Dan akhirnya membuat model get_or_create unik:

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

Resepnya masuk lebih dalam ke ide dan memberikan pendekatan yang berbeda tetapi saya telah menggunakan ini dengan sukses besar.

Semantik terdekat mungkin:

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

tidak yakin bagaimana halal bergantung pada yang didefinisikan secara global Sessiondalam sqlalchemy, tetapi versi Django tidak mengambil koneksi jadi ...

Tuple yang dikembalikan berisi instance dan boolean yang menunjukkan jika instance dibuat (yaitu False jika kita membaca instance dari db).

Django get_or_createsering digunakan untuk memastikan bahwa data global tersedia, jadi saya berkomitmen sedini mungkin.

Saya sedikit menyederhanakan @Kevin. solusi untuk menghindari pembungkus seluruh fungsi dalam if/ elsepernyataan. Dengan cara ini hanya ada satu return, yang saya temukan lebih bersih:

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

Tergantung pada tingkat isolasi yang Anda adopsi, tidak ada solusi di atas yang akan berfungsi. Solusi terbaik yang saya temukan adalah RAW SQL dalam bentuk berikut:

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

Ini aman secara transaksi apa pun tingkat isolasi dan tingkat paralelisme.

Hati-hati: untuk membuatnya efisien, akan lebih bijaksana untuk memiliki INDEX untuk kolom unik.