sqlalchemy many-to-many, ma inversa?

Question

Mi dispiace se non è inversa la nomenclatura preferita, che potrebbe aver ostacolato la mia ricerca. In ogni caso, ho a che fare con due classi dichiarative di sqlalchemy, che è una relazione molti-a-molti. Il primo è Account e il secondo è Raccolta. Gli utenti "acquistano" collezioni, ma voglio mostrare le prime 10 collezioni che l'utente non ha ancora acquistato.

from sqlalchemy import * 
from sqlalchemy.orm import scoped_session, sessionmaker, relation 
from sqlalchemy.ext.declarative import declarative_base 

Base = declarative_base() 

engine = create_engine('sqlite:///:memory:', echo=True) 
Session = sessionmaker(bind=engine) 

account_to_collection_map = Table('account_to_collection_map', Base.metadata, 
           Column('account_id', Integer, ForeignKey('account.id')), 
           Column('collection_id', Integer, ForeignKey('collection.id'))) 

class Account(Base): 
    __tablename__ = 'account' 

    id = Column(Integer, primary_key=True) 
    email = Column(String) 

    collections = relation("Collection", secondary=account_to_collection_map) 

    # use only for querying? 
    dyn_coll = relation("Collection", secondary=account_to_collection_map, lazy='dynamic') 

    def __init__(self, email): 
     self.email = email 

    def __repr__(self): 
     return "<Acc(id=%s email=%s)>" % (self.id, self.email) 

class Collection(Base): 
    __tablename__ = 'collection' 

    id = Column(Integer, primary_key=True) 
    slug = Column(String) 

    def __init__(self, slug): 
     self.slug = slug 

    def __repr__(self): 
     return "<Coll(id=%s slug=%s)>" % (self.id, self.slug) 

Così, con account.collections, posso ottenere tutte le collezioni, e con dyn_coll.limit (1) .All() posso applicare alla query nell'elenco delle raccolte ... ma come faccio a fare il inverso? Mi piacerebbe avere le prime 10 collezioni che l'account fa non è stata mappata.

Qualsiasi aiuto è incredibilmente apprezzato. Grazie!

Answer 1

Non vorrei usare la relazione per lo scopo, poiché tecnicamente non è una relazione che si sta costruendo (quindi tutti i trucchi di tenerlo sincronizzato su entrambi i lati ecc non funzionerebbe).
IMO, il modo più pulito sarebbe quello di definire una semplice query che restituirà voi gli oggetti che stai cercando:

class Account(Base): 
    ... 
    # please note added *backref*, which is needed to build the 
    #query in Account.get_other_collections(...) 
    collections = relation("Collection", secondary=account_to_collection_map, backref="accounts") 

    def get_other_collections(self, maxrows=None): 
     """ Returns the collections this Account does not have yet. """ 
     q = Session.object_session(self).query(Collection) 
     q = q.filter(~Collection.accounts.any(id=self.id)) 
     # note: you might also want to order the results 
     return q[:maxrows] if maxrows else q.all() 
...