Question

I have a SyncEntities class (shown below).

I have several other classes (such as CommodityTypes also shown below) related to the SyncEntities class.

All of my Base subclasses have this column uuidKey = Column(String, primary_key=True)

Assume se is an instance of SyncEntities.
se.entityKind is the name of a Base subclass.

How do I query for an object that is in the se.entityKind class filtering for se.uuidKey?

class SyncEntities(Base):
    __tablename__ = 'SyncEntities'

    uuidKey = Column(String, primary_key=True)
    dateCreated = Column(DateTime, index=True)
    dateModified = Column(DateTime, index=True)
    dateSynced = Column(DateTime, index=True)
    username = Column(String)
    entityKind = Column(String)
    deleted = Column(Boolean)

    def __init__(self, entity, security):
        self.uuidKey = newUUID()
        self.dateCreated = security.now
        self.dateModified = security.now
        self.dateSynced = security.then
        self.username = security.username
        self.entityKind = entity.__tablename__
        self.deleted = False

    def modified(self, security):
        self.dateModified = security.now
        self.username = security.username

class CommodityTypes(Base):
    __tablename__ = 'CommodityTypes'
    uuidKey = Column(String, ForeignKey('SyncEntities.uuidKey'), primary_key=True)
    myName = Column(String, unique = True)
    sortKey = Column(Integer, unique = True)

    mySyncEntity = relationship("SyncEntities")

    def __init__(self, security, myName, sortKey):
        self.syncEntity = SyncEntities(self, security)
        self.uuidKey = self.syncEntity.uuidKey
        self.myName = myName
        self.sortKey = sortKey

Answer 1

The structure here is similar, though not quite the same, as a “polymorphic association”, and you can read about this pattern over at this blog post: http://techspot.zzzeek.org/2007/05/29/polymorphic-associations-with-sqlalchemy/ . It’s an old post but the example at http://techspot.zzzeek.org/files/2007/discriminator_on_association.py was added later as an updated example.

This case is a little different in that an object like CommodityTypes only refers to a single SyncEntities, not multiple as in the usual polymorphic association. The SyncEntities also can only refer to a single type of related object since you have entityKind on it locally.

I would note that a potential problem with this design is that you could have rows in other tables that have a uuidKey pointing to a particular SyncEntities instance, but are not of a type that matches “entityKind”. If the relationship between CommodityTypes and SyncEntities is actually one-to-one, that changes everything – this pattern is really simple joined table inheritance and you’d use the patterns described at http://docs.sqlalchemy.org/en/rel_0_7/orm/inheritance.html.

You also don’t have backrefs between the target and SyncEntities, which is often a way to automate these styles of lookup. But you can still approximate things using a lookup of entityKind types to classes:

def lookup_related(se):
    types = {
        'commodity':CommodityTypes,
        'foobar':FooBarTypes
    }
    cls = types[se.entityKind]
    session = object_session(se)
    return session.query(cls).filter(cls.mySyncEntity==se).all()

here’s a mixin that could do it also, using a backref:

class HasSyncEntity(object):
    entity_kind = None
    "subclasses need to populate this"

    @declared_attr
    def uuidKey(cls):
        return Column(String, ForeignKey("SyncEntities.uuidKey"), primary_key=True)

    @declared_attr
    def mySyncEntity(cls):
        return relationship("SyncEntities", backref="_%s_collection" % cls.entity_kind)

CommodityTypes becomes:

class CommodityTypes(HasSyncEntity, Base):
    entity_kind = "commodity"
    # ...

You then add a method like this to SyncEntities, which looks up the appropriate backref, and you’re done:

def get_related(self):
    return getattr(self, "_%s_collection" % self.entityKind)