SQLAlchemy ha un equivalente di get_or_create di Django?

Voglio ottenere un oggetto dal database se esiste già (in base ai parametri forniti) o crearlo in caso contrario.

Django get_or_create(o fonte ) fa questo. Esiste un collegamento equivalente in SQLAlchemy?

Attualmente sto scrivendo esplicitamente in questo modo:

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

Questo è fondamentalmente il modo di farlo, non esiste un collegamento disponibile AFAIK.

Potresti generalizzarlo naturalmente:

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

Seguendo la soluzione di @WoLpH, questo è il codice che ha funzionato per me (versione semplice):

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 questo, sono in grado di ottenere_o_creare qualsiasi oggetto del mio modello.

Supponiamo che il mio oggetto modello sia:

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

Per ottenere o creare il mio oggetto scrivo:

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

Ho giocato con questo problema e ho finito con una soluzione abbastanza solida:

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

Ho appena scritto un post sul blog abbastanza ampio su tutti i dettagli, ma alcune idee abbastanza sul perché l'ho usato.

1. Si decomprime in una tupla che ti dice se l'oggetto esiste o no. Questo può spesso essere utile nel tuo flusso di lavoro.

2. La funzione offre la possibilità di lavorare con @classmethod funzioni di creatore decorate (e attributi specifici per esse).

3. La soluzione protegge dalle condizioni di gara quando si dispone di più di un processo collegato all'archivio dati.

EDIT: Ho cambiato session.commit()a session.flush()come spiegato in questo post del blog . Si noti che queste decisioni sono specifiche per il datastore utilizzato (Postgres in questo caso).

EDIT 2: Ho aggiornato utilizzando un {} come valore predefinito nella funzione in quanto si tratta del tipico gotcha di Python. Grazie per il commento , Nigel! Se sei curioso di questo gotcha, dai un'occhiata a questa domanda StackOverflow e a questo post sul blog .

Una versione modificata dell'ottima risposta di 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

• Utilizzare una transazione nidificata per ripristinare solo l'aggiunta del nuovo elemento anziché ripristinare tutto (vedere questa risposta per utilizzare le transazioni nidificate con SQLite)
• Sposta create_method. Se l'oggetto creato ha relazioni e gli vengono assegnati membri tramite tali relazioni, viene automaticamente aggiunto alla sessione. Ad esempio creare un book, che ha user_ide usercome relazione corrispondente, quindi facendo book.user=<user object>all'interno di create_methodsi aggiungerà bookalla sessione. Ciò significa che create_methoddeve essere all'interno withper beneficiare di un eventuale rollback. Si noti che begin_nestedinnesca automaticamente un flush.

Si noti che se si utilizza MySQL, il livello di isolamento della transazione deve essere impostato READ COMMITTEDpiuttosto che REPEATABLE READper farlo funzionare. Get_or_create (e qui ) di Django usa lo stesso stratagemma, vedi anche la documentazione di Django .

Questa ricetta SQLALchemy fa il lavoro piacevole ed elegante.

La prima cosa da fare è definire una funzione a cui viene assegnata una Sessione con cui lavorare e associa un dizionario alla Sessione () che tiene traccia delle attuali chiavi univoche .

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 esempio di utilizzo di questa funzione sarebbe in 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
            )

E infine creando il modello unico 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()

La ricetta approfondisce l'idea e fornisce approcci diversi ma l'ho usata con grande successo.

Il semanticamente più vicino è probabilmente:

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

non sono sicuro di quanto sia kosher fare affidamento su una Sessionsqlalchemy definita globalmente , ma la versione Django non ha una connessione quindi ...

La tupla restituita contiene l'istanza e un valore booleano che indica se l'istanza è stata creata (ovvero è False se leggiamo l'istanza dal db).

Django get_or_createviene spesso utilizzato per assicurarsi che siano disponibili dati globali, quindi mi impegno al più presto possibile.

Ho semplificato leggermente @Kevin. soluzione per evitare di racchiudere l'intera funzione in un'istruzione if/ else. In questo modo ce n'è solo uno return, che trovo più pulito:

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

A seconda del livello di isolamento adottato, nessuna delle soluzioni sopra avrebbe funzionato. La migliore soluzione che ho trovato è un SQL RAW nella seguente forma:

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

Ciò è sicuro dal punto di vista delle transazioni qualunque sia il livello di isolamento e il grado di parallelismo.

Attenzione: per renderlo efficiente, sarebbe saggio disporre di un INDICE per la colonna unica.