SQLAlchemy tem um equivalente ao get_or_create do Django?

Desejo obter um objeto do banco de dados, se ele já existir (com base nos parâmetros fornecidos) ou criá-lo, se não existir.

O Django get_or_create(ou fonte ) faz isso. Existe um atalho equivalente no SQLAlchemy?

Atualmente, estou escrevendo explicitamente assim:

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

Essa é basicamente a maneira de fazer isso, não há atalho prontamente disponível para o AFAIK.

Você pode generalizá-lo, é claro:

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

Seguindo a solução do @WoLpH, este é o código que funcionou para mim (versão simples):

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

Com isso, eu sou capaz de obter ou criar qualquer objeto do meu modelo.

Suponha que meu objeto de modelo seja:

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

Para obter ou criar meu objeto, escrevo:

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

Eu estou jogando com esse problema e acabei com uma solução bastante robusta:

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

Acabei de escrever um post bastante amplo sobre todos os detalhes, mas algumas idéias sobre o porquê disso.

1. Ele é descompactado em uma tupla que informa se o objeto existe ou não. Isso geralmente pode ser útil no seu fluxo de trabalho.

2. A função permite trabalhar com @classmethodfunções decoradas do criador (e atributos específicos a elas).

3. A solução protege contra condições de corrida quando você tem mais de um processo conectado ao armazenamento de dados.

EDIT: mudei session.commit()para session.flush()conforme explicado nesta postagem do blog . Observe que essas decisões são específicas para o armazenamento de dados usado (neste caso, o Postgres).

EDIT 2: Eu atualizei usando um {} como valor padrão na função, pois isso é uma pegadinha típica do Python. Obrigado pelo comentário , Nigel! Se você está curioso sobre isso, confira esta pergunta do StackOverflow e esta postagem no blog .

Uma versão modificada da excelente resposta de 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

• Use uma transação aninhada para reverter apenas a adição do novo item em vez de reverter tudo (consulte esta resposta para usar transações aninhadas com SQLite)
• Move create_method. Se o objeto criado tiver relações e receber membros por meio dessas relações, ele será adicionado automaticamente à sessão. Por exemplo, crie um book, que tenha user_ide usercomo relacionamento correspondente, e fazer book.user=<user object>dentro dele create_methodserá adicionado bookà sessão. Isso significa que create_methoddeve estar dentro withpara se beneficiar de uma eventual reversão. Observe que begin_nesteddispara automaticamente um flush.

Observe que, se você estiver usando o MySQL, o nível de isolamento da transação deve ser definido como READ COMMITTEDe não REPEATABLE READpara que isso funcione. O get_or_create do Django (e aqui ) usa o mesmo estratagema, veja também a documentação do Django .

Esta receita SQLALchemy faz o trabalho agradável e elegante.

A primeira coisa a fazer é definir uma função que recebe uma Sessão para trabalhar e associa um dicionário à Session () que controla as chaves exclusivas atuais .

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

Um exemplo de utilização dessa função seria em um 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
            )

E, finalmente, criando o modelo exclusivo 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()

A receita vai mais fundo na idéia e oferece abordagens diferentes, mas eu usei essa com muito sucesso.

O mais próximo semanticamente é provavelmente:

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

não tenho certeza de quão kosher é confiar em um definido globalmente Sessionno sqlalchemy, mas a versão do Django não aceita uma conexão, então ...

A tupla retornada contém a instância e um booleano indicando se a instância foi criada (ou seja, é False se lemos a instância no banco de dados).

O Django's get_or_createé frequentemente usado para garantir que dados globais estejam disponíveis, por isso estou comprometendo o mais cedo possível.

Simplifiquei levemente o @Kevin. solução para evitar agrupar toda a função em uma instrução if/ else. Desta forma, há apenas um return, que eu acho mais limpo:

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

Dependendo do nível de isolamento adotado, nenhuma das soluções acima funcionaria. A melhor solução que encontrei é um SQL RAW no seguinte formato:

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

Isso é transacionalmente seguro, independentemente do nível de isolamento e do grau de paralelismo.

Cuidado: para torná-lo eficiente, seria aconselhável ter um ÍNDICE para a coluna exclusiva.