¿SQLAlchemy tiene un equivalente de get_or_create de Django?

Quiero obtener un objeto de la base de datos si ya existe (según los parámetros proporcionados) o crearlo si no existe.

Django get_or_create(o fuente ) hace esto. ¿Hay un atajo equivalente en SQLAlchemy?

Actualmente lo estoy escribiendo explícitamente así:

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

Esa es básicamente la forma de hacerlo, no hay atajos disponibles AFAIK.

Puedes generalizarlo, por supuesto:

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

Siguiendo la solución de @WoLpH, este es el código que funcionó para mí (versión simple):

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

Con esto, puedo obtener o crear cualquier objeto de mi modelo.

Supongamos que mi objeto modelo es:

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

Para obtener o crear mi objeto escribo:

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

He estado jugando con este problema y terminé con una solución bastante sólida:

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

Acabo de escribir una publicación de blog bastante expansiva sobre todos los detalles, pero algunas ideas de por qué usé esto.

1. Se descomprime en una tupla que te dice si el objeto existió o no. Esto a menudo puede ser útil en su flujo de trabajo.

2. La función brinda la capacidad de trabajar con @classmethodfunciones de creador decoradas (y atributos específicos para ellas).

3. La solución protege contra las condiciones de carrera cuando tienes más de un proceso conectado al almacén de datos.

EDITAR: He cambiado session.commit()a session.flush()como se explica en esta publicación de blog . Tenga en cuenta que estas decisiones son específicas del almacén de datos utilizado (Postgres en este caso).

EDIT 2: He actualizado usando un {} como valor predeterminado en la función, ya que este es el típico problema de Python. Gracias por el comentario , Nigel! Si tiene curiosidad sobre este problema, consulte esta pregunta de StackOverflow y esta publicación de blog .

Una versión modificada de la excelente respuesta 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 una transacción anidada para revertir solo la adición del nuevo elemento en lugar de revertir todo (consulte esta respuesta para usar transacciones anidadas con SQLite)
• Mover create_method. Si el objeto creado tiene relaciones y se le asignan miembros a través de esas relaciones, se agrega automáticamente a la sesión. Por ejemplo, crear un book, que tiene user_idy usercomo relación correspondiente, luego hacer book.user=<user object>dentro de create_methodagregará booka la sesión. Esto significa que create_methoddebe estar adentro withpara beneficiarse de una eventual reversión. Tenga en cuenta que begin_nestedactiva automáticamente una descarga.

Tenga en cuenta que si usa MySQL, el nivel de aislamiento de la transacción debe establecerse en READ COMMITTEDlugar de que REPEATABLE READesto funcione. Get_or_create de Django (y aquí ) usa la misma estratagema, consulte también la documentación de Django .

Esta receta de SQLALchemy hace el trabajo agradable y elegante.

Lo primero que debe hacer es definir una función a la que se le asigna una sesión para trabajar, y asocia un diccionario con la sesión () que realiza un seguimiento de las claves únicas actuales .

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

Un ejemplo de utilización de esta función sería en un 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
            )

Y finalmente creando el modelo get_or_create único:

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

La receta profundiza en la idea y ofrece diferentes enfoques, pero he usado esta con gran éxito.

La semántica más cercana es probablemente:

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

no estoy seguro de cuán kosher es confiar en una definición global Sessionen sqlalchemy, pero la versión de Django no toma una conexión, así que ...

La tupla devuelta contiene la instancia y un booleano que indica si se creó la instancia (es decir, es Falso si leemos la instancia de la base de datos).

Django a get_or_createmenudo se usa para asegurarse de que haya datos globales disponibles, por lo que me comprometo lo antes posible.

Simplifiqué un poco a @Kevin. solución para evitar envolver toda la función en una declaración if/ else. De esta manera solo hay uno return, que encuentro más limpio:

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

Dependiendo del nivel de aislamiento que adoptó, ninguna de las soluciones anteriores funcionaría. La mejor solución que he encontrado es un SQL RAW en la siguiente forma:

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

Esto es transaccionalmente seguro sea cual sea el nivel de aislamiento y el grado de paralelismo.

Cuidado: para que sea eficiente, sería conveniente tener un ÍNDICE para la columna única.