SQLAlchemyにはDjangoのget_or_createに相当するものがありますか？

（提供されたパラメーターに基づいて）既に存在する場合はデータベースからオブジェクトを取得するか、存在しない場合は作成します。

Django get_or_create（またはsource）がこれを行います。SQLAlchemyに同等のショートカットはありますか？

私は現在、このように明示的に書いています：

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

それは基本的にそれを行う方法であり、すぐに利用できる近道はありません。

もちろん、一般化することもできます。

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の解決策に従って、これは私のために機能したコードです（単純なバージョン）：

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

これで、モデルのオブジェクトをget_or_createできます。

私のモデルオブジェクトが：

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

オブジェクトを取得または作成するには、次のように記述します。

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

私はこの問題で遊んでおり、かなり堅牢な解決策に終わりました：

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

私はすべての詳細についてかなり広大なブログ投稿を書いたばかりですが、これを使用した理由についていくつかのかなりのアイデアがあります。

1. オブジェクトが存在したかどうかを通知するタプルにアンパックします。これは多くの場合、ワークフローで役立ちます。

2. この関数は、@classmethod装飾されたクリエーター関数（およびそれらに固有の属性）を操作する機能を提供します。

3. このソリューションは、データストアに複数のプロセスが接続されている場合の競合状態から保護します。

編集：私はこのブログ投稿で説明さsession.commit()れsession.flush()ているように変更しました。これらの決定は、使用されるデータストア（この場合はPostgres）に固有であることに注意してください。

編集2：これは典型的なPythonの落とし穴なので、関数のデフォルト値として{}を使用して更新しました。コメントをありがとう、ナイジェル！この問題について知りたい場合は、StackOverflowの質問とブログの投稿をご覧ください。

エリクの優れた答えの修正版

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

• ネストされたトランザクションを使用して、すべてをロールバックするのではなく、新しいアイテムの追加のみをロールバックします（SQLiteでネストされたトランザクションを使用するには、この回答を参照してください）
• 移動しcreate_methodます。作成されたオブジェクトに関係があり、それらの関係を通じてメンバーが割り当てられている場合、オブジェクトはセッションに自動的に追加されます。たとえば、対応する関係bookを持つuser_idを作成し、内部で行うとセッションに追加されます。これは、最終的なロールバックの恩恵を受けるには、それが内部にある必要があることを意味します。フラッシュが自動的にトリガーされることに注意してください。userbook.user=<user object>create_methodbookcreate_methodwithbegin_nested

MySQLを使用している場合、これが機能するためにREAD COMMITTEDではなく、トランザクション分離レベルをに設定する必要があることに注意してくださいREPEATABLE READ。Djangoのget_or_create（およびここ）は同じ戦略を使用しています。Djangoのドキュメントも参照してください。

このSQLALchemyレシピは、仕事を素晴らしくエレガントに行います。

最初に、処理するセッションが与えられ、ディクショナリを現在の一意のキーを追跡するSession（）に関連付ける関数を定義します。

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

この関数を使用する例は、ミックスインになります。

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
            )

そして最後に、一意の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()

レシピはアイデアをさらに深くし、さまざまなアプローチを提供しますが、私はこれを使用して大成功を収めました。

意味的に最も近いのはおそらく：

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

グローバルに定義されたものに依存することがいかにコーシャかわからない Sessionsqlalchemyでれませんが、Djangoバージョンは接続を取りません...

返されるタプルには、インスタンスと、インスタンスが作成されたかどうかを示すブール値（つまり、dbからインスタンスを読み取った場合はFalse）が含まれます。

Django get_or_createは、グローバルデータが利用可能であることを確認するためによく使用されるため、できるだけ早い段階でコミットします。

@Kevinを少し簡略化しました。関数全体をif/ elseステートメントでラップしないようにするソリューション。このようにreturn、私はよりきれいであると思う1つだけがあります：

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

採用した分離レベルによっては、上記のソリューションはどれも機能しません。私が見つけた最良の解決策は、次の形式のRAW SQLです。

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

これは、分離レベルと並列処理の度合いが何であれ、トランザクション上安全です。

注意：効率的にするために、一意の列にINDEXを設定することをお勧めします。