¿SQLAlchemy tiene un equivalente de get_or_create de Django?

Question

Quiero obtener un objeto de la base de datos si ya existe (basado en los parámetros proporcionados) o crearlo si no lo hace.

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

Actualmente estoy escribiendo explícitamente como esto:

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 

Answer 1

Eso es básicamente la forma de hacerlo, no hay acceso directo disponible yo sepa.

Se podría generalizar que 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 

Answer 2

Siguiendo la solución de @WoLpH, este es el código que trabajó 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, estoy capaz de obtener_o_crear cualquier objeto de mi modelo.

Supongamos que mi modelo de objetos es:

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

Para obtener o crear mi objetivo escribo:

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

Answer 3

This SQLALchemy recipe hace el trabajo agradable y elegante.

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

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 la 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 la creación del 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 proporciona diferentes enfoques pero he usado este con gran éxito.

Answer 4

He estado jugando con este problema y he terminado con una solución 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(), True 

que acabo de escribir un fairly expansive blog post en todos los detalles, pero algunas ideas bastante de eso utilicé esto.

1. Se desempaqueta en una tupla que indica si el objeto existe o no. Esto a menudo puede ser útil en su flujo de trabajo.

2. La función ofrece la posibilidad de trabajar con @classmethod funciones de creador decoradas (y atributos específicos para ellas).

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

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

EDIT 2: He actualizado el uso de un {} como valor predeterminado en la función, ya que esto es típico de Python gotcha. Gracias por the comment, Nigel! Si tienes curiosidad acerca de esto, echa un vistazo a this StackOverflow question y this blog post.

Answer 5

Lo más cerca que semánticamente 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 está seguro de cómo kosher es confiar en un nivel global definido en Session sqlalchemy, pero la versión de Django no tiene una conexión tan ...

La tupla devuelta contiene la instancia y un valor booleano que indica si la instancia se creó (es decir, es False si leemos la instancia desde el archivo db).

Django's get_or_create se usa a menudo para garantizar que los datos globales estén disponibles, por lo que me comprometo lo antes posible.

Answer 6

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

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

Ésta es transaccionalmente segura cualquiera que sea el nivel de aislamiento y el grado de paralelismo son.

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

Answer 7

Una versión modificada de la excelente Erik answer

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 

• Utilice un nested transaction sólo a hacer retroceder la adición del nuevo elemento en lugar de hacer retroceder todo (ver este answer utilizar 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. P.ej. crear un book, que tiene user_id y user como relación correspondiente, luego haciendo book.user=<user object> dentro de create_method agregará book a la sesión. Esto significa que create_method debe estar dentro de with para beneficiarse de una reversión final. Tenga en cuenta que begin_nested activa automáticamente una descarga.

Tenga en cuenta que si el uso de MySQL, el nivel de aislamiento se debe establecer en READ COMMITTED en lugar de REPEATABLE READ para que esto funcione. Django's get_or_create (y here) utiliza la misma estratagema, ver también Django documentation.

Answer 8

I ligeramente simplificado @Kevin. solución para evitar envolver toda la función en una declaración if/else.De esta manera sólo hay una return, que me parece 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