Question

Is it possible to specify a discriminator column from another table? How do I do this with Declarative?

The reason for this is I have a joined table inheritance with

class User(Base):
    id = Column(...)

class Customer(User):
    customer_id = Column('id', ...)

class Mechanic(User):
    mechanic_id = Column('id', ...)

class Role(Base):
    id = Column(..)

but want to discriminate by Roles a user has. A user could have a buyer role or a seller role or both.

Is this the correct way to model this scenario?

As a note, there is Buyer specific data and Seller specific data as well, and that is why I am using the joined table inheritance.

Answer 1

Here’s an awkward and inefficient way to achieve the specific result, which will also fail if more than one Role is present on the target User:

from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

role_to_user = Table('role_to_user', Base.metadata,
    Column('role_id', Integer, ForeignKey('role.id'), primary_key=True),
    Column('user_id', Integer, ForeignKey('user.id'), primary_key=True),
)

class Role(Base):
    __tablename__ = 'role'
    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)

    discrim = select([Role.name])
    discrim_col = discrim.label("foo")
    type = column_property(discrim_col)
    roles = relationship("Role", secondary=role_to_user)
    __mapper_args__ = {'polymorphic_on': discrim_col}

User.discrim.append_whereclause(Role.id==role_to_user.c.role_id)
User.discrim.append_whereclause(role_to_user.c.user_id==User.id)

class Customer(User):
    __tablename__ = 'customer'
    id = Column(Integer, ForeignKey(User.id), primary_key=True)
    __mapper_args__ = {'polymorphic_identity':'customer'}

class Mechanic(User):
    __tablename__ = 'mechanic'
    id = Column(Integer, ForeignKey(User.id), primary_key=True)

    __mapper_args__ = {'polymorphic_identity':'mechanic'}

e = create_engine('sqlite://', echo=True)

Base.metadata.create_all(e)

s = Session(e)

m, c = Role(name='mechanic'), Role(name='customer')
s.add_all([m, c])
s.add_all([Mechanic(roles=[m]), Customer(roles=[c])])
s.commit()

print Session(e).query(User).all()

Next, here is how I would actually do it, if I had the issue of assigning behaviors based on zero or more Roles – I’d put the behavior in the Role, not the owner of the Role:

from sqlalchemy import *
from sqlalchemy.orm import *
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    roles = relationship("Role", secondary= Table(
                    'role_to_user', Base.metadata,
                    Column('role_id', Integer, 
                            ForeignKey('role.id'), 
                            primary_key=True),
                    Column('user_id', Integer, 
                            ForeignKey('user.id'), 
                            primary_key=True),
                    ),
                    lazy="subquery"
                )

    def operate_on_roles(self):
        for role in self.roles:
            role.operate(self)

class Role(Base):
    __tablename__ = 'role'
    id = Column(Integer, primary_key=True)
    type = Column(String, nullable=False)
    __mapper_args__ = {'polymorphic_on': type}

class CustomerRole(Role):
    __tablename__ = 'customer'
    id = Column(Integer, ForeignKey(Role.id), primary_key=True)
    __mapper_args__ = {'polymorphic_identity':'customer'}

    def operate(self, user):
        print "user %s getting my car fixed!" % user.name

class MechanicRole(Role):
    __tablename__ = 'mechanic'
    id = Column(Integer, ForeignKey(Role.id), primary_key=True)
    __mapper_args__ = {'polymorphic_identity':'mechanic'}

    def operate(self, user):
        print "user %s fixing cars!" % user.name

e = create_engine('sqlite://', echo=True)

Base.metadata.create_all(e)

s = Session(e)

m, c = MechanicRole(), CustomerRole()
s.add_all([m, c])
s.add_all([
        User(name='u1', roles=[m, c]),
        User(name='u2', roles=[c]),
        User(name='u3', roles=[m]),
    ])
s.commit()

for user in s.query(User):
    user.operate_on_roles()

The second example produces the output:

user u1 fixing cars!
user u1 getting my car fixed!
user u2 getting my car fixed!
user u3 fixing cars!

As you can see the second example is clear and efficient while the first is just a thought experiment.