SQLAlchemy có tương đương với get_or_create của Django không?

Tôi muốn lấy một đối tượng từ cơ sở dữ liệu nếu nó đã tồn tại (dựa trên các tham số được cung cấp) hoặc tạo nó nếu nó không có.

Django get_or_create(hoặc nguồn ) làm điều này. Có một lối tắt tương đương trong SQLAlchemy không?

Tôi hiện đang viết nó ra một cách rõ ràng như thế này:

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

Về cơ bản đó là cách để làm điều đó, không có phím tắt nào có sẵn AFAIK.

Bạn có thể khái quát hóa nó:

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

Theo giải pháp của @WoLpH, đây là mã phù hợp với tôi (phiên bản đơn giản):

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

Với điều này, tôi có thể get_or_create bất kỳ đối tượng nào trong mô hình của tôi.

Giả sử đối tượng mô hình của tôi là:

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

Để có được hoặc tạo đối tượng của tôi, tôi viết:

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

Tôi đã chơi với vấn đề này và đã kết thúc với một giải pháp khá mạnh mẽ:

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ôi chỉ viết một bài đăng blog khá rộng rãi về tất cả các chi tiết, nhưng một vài ý tưởng khá lý do tại sao tôi sử dụng nó.

1. Nó giải nén thành một tuple cho bạn biết đối tượng có tồn tại hay không. Điều này thường có thể hữu ích trong quy trình làm việc của bạn.

2. Hàm cung cấp khả năng làm việc với các @classmethodchức năng của người tạo trang trí (và các thuộc tính dành riêng cho chúng).

3. Giải pháp bảo vệ chống lại Điều kiện cuộc đua khi bạn có nhiều hơn một quy trình được kết nối với kho dữ liệu.

EDIT: Tôi đã thay đổi session.commit()đến session.flush()như đã giải thích trong bài viết trên blog này . Lưu ý rằng các quyết định này là cụ thể cho kho dữ liệu được sử dụng (Postgres trong trường hợp này).

EDIT 2: Tôi đã cập nhật bằng cách sử dụng {} làm giá trị mặc định trong hàm vì đây là mã xác thực Python điển hình. Cảm ơn vì nhận xét , Nigel! Nếu bạn tò mò về gotcha này, hãy xem câu hỏi StackOverflow này và bài đăng trên blog này .

Một phiên bản sửa đổi của câu trả lời xuất sắc của 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

• Sử dụng giao dịch lồng nhau để chỉ quay lại việc thêm mục mới thay vì khôi phục mọi thứ (Xem câu trả lời này để sử dụng giao dịch lồng nhau với SQLite)
• Di chuyển create_method. Nếu đối tượng được tạo có quan hệ và nó được gán thành viên thông qua các quan hệ đó, nó sẽ tự động được thêm vào phiên. Ví dụ: tạo một book, có user_idvà usernhư mối quan hệ tương ứng, sau đó thực hiện book.user=<user object>bên trong create_methodsẽ thêm bookvào phiên. Điều này có nghĩa là create_methodphải ở bên trong withđể hưởng lợi từ việc khôi phục cuối cùng. Lưu ý rằng begin_nestedtự động kích hoạt một tuôn ra.

Lưu ý rằng nếu sử dụng MySQL, mức cô lập giao dịch phải được đặt thành READ COMMITTEDthay vì REPEATABLE READđể nó hoạt động. Get_or_create của Django (và ở đây ) sử dụng cùng một chiến lược, xem thêm tài liệu về Django .

Công thức SQLALchemy này thực hiện công việc tốt đẹp và thanh lịch.

Điều đầu tiên cần làm là xác định một chức năng được cung cấp một Phiên để làm việc và liên kết một từ điển với Phiên () để theo dõi các khóa duy nhất hiện tại .

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

Một ví dụ về việc sử dụng chức năng này sẽ có trong một 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
            )

Và cuối cùng tạo ra mô hình get_or_create độc ​​đáo:

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

Công thức đi sâu hơn vào ý tưởng và cung cấp các cách tiếp cận khác nhau nhưng tôi đã sử dụng phương pháp này rất thành công.

Về mặt ngữ nghĩa gần nhất có lẽ là:

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

không chắc nó sẽ dựa vào thế nào Sessiontrong việc xác định toàn cầu trong sqlalchemy, nhưng phiên bản Django không có kết nối nên ...

Bộ dữ liệu được trả về chứa cá thể và boolean cho biết nếu cá thể đó được tạo ra (tức là Sai nếu chúng ta đọc cá thể từ db).

Django get_or_createthường được sử dụng để đảm bảo rằng dữ liệu toàn cầu có sẵn, vì vậy tôi cam kết ở điểm sớm nhất có thể.

Tôi hơi đơn giản hóa @Kevin. giải pháp để tránh gói toàn bộ hàm trong một câu lệnh if/ else. Cách này chỉ có một return, mà tôi thấy sạch hơn:

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

Tùy thuộc vào mức độ cô lập mà bạn áp dụng, không có giải pháp nào ở trên sẽ hoạt động. Giải pháp tốt nhất tôi đã tìm thấy là một SQL RAW ở dạng sau:

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

Điều này là an toàn giao dịch bất kể mức độ cô lập và mức độ song song là gì.

Chú ý: để làm cho nó hiệu quả, sẽ là khôn ngoan khi có INDEX cho cột duy nhất.