Question

thanks in advance for your help.

I have two entities, Human and Chimp. Each has a collection of metrics, which can contain subclasses of a MetricBlock, for instance CompleteBloodCount (with fields WHITE_CELLS, RED_CELLS, PLATELETS).

So my object model looks like (forgive the ASCII art):

---------   metrics    ---------------      ----------------------
| Human | ---------->  | MetricBlock | <|-- | CompleteBloodCount |
---------              ---------------      ----------------------
                        ^
---------    metrics    |
| Chimp | --------------
---------

This is implemented with the following tables:

Chimp (id, …)
Human (id, …)

MetricBlock (id, dtype)
CompleteBloodCount (id, white_cells, red_cells, platelets)
CholesterolCount (id, hdl, ldl)

ChimpToMetricBlock(chimp_id, metric_block_id)
HumanToMetricBlock(human_id, metric_block_id)

So a human knows its metric blocks, but a metric block does not know its human or chimp.

I would like to write a query in SQLAlchemy to find all CompleteBloodCounts for a particular human. In SQL I could write something like:

SELECT cbc.id
FROM complete_blood_count cbc
WHERE EXISTS (
   SELECT 1
   FROM human h
       INNER JOIN human_to_metric_block h_to_m on h.id = h_to_m.human_id
   WHERE
       h_to_m.metric_block_id = cbc.id
)

I’m struggling though to write this in SQLAlchemy. I believe correlate(), any(), or an aliased join may be helpful, but the fact that a MetricBlock doesn’t know its Human or Chimp is a stumbling block for me.

Does anyone have any advice on how to write this query? Alternately, are there other strategies to define the model in a way that works better with SQLAlchemy?

Thank you for your assistance.

Python 2.6
SQLAlchemy 0.7.4
Oracle 11g

Edit:

HumanToMetricBlock is defined as:

humanToMetricBlock = Table(
    "human_to_metric_block",
    metadata,
    Column("human_id", Integer, ForeignKey("human.id"),
    Column("metric_block_id", Integer, ForeginKey("metric_block.id")
)

per the manual.

Answer 1

Each primate should have a unique ID, regardless of what type of primate they are. I’m not sure why each set of attributes (MB, CBC, CC) are separate tables, but I assume that they have more than one dimension (primate) such as time, otherwise I would only have one giant table.

Thus, I would structure this problem in the following manner:
Create a parent object Primate and derive humans and chimps from it. This example is using single table inheritance, though you may want to use joined table inheritance based on their attributes.

class Primate(Base):
    __tablename__ = 'primate'
    id = Column(Integer, primary_key=True)
    genus = Column(String)
    ...attributes all primates have...
    __mapper_args__ = {'polymorphic_on': genus, 'polymorphic_identity': 'primate'}

class Chimp(Primate):
    __mapper_args__ = {'polymorphic_identity': 'chimp'}
    ...attributes...

class Human(Primate):
    __mapper_args__ = {'polymorphic_identity': 'human'}
    ...attributes...

class MetricBlock(Base):
    id = ...

Then you create a single many-to-many table (you can use an association proxy instead):

class PrimateToMetricBlock(Base):
    id = Column(Integer, primary_key=True) # primary key is needed!
    primate_id = Column(Integer, ForeignKey('primate.id'))
    primate = relationship('Primate') # If you care for relationships. 
    metricblock_id = Column(Integer, ForeignKey('metric_block.id')
    metricblock = relationship('MetricBlock')

Then I would structure the query like so (note that the on clause is not necessary since SQLAlchemy can infer the relationships automatically since there’s no ambiguity):

query = DBSession.query(CompleteBloodCount).\
    join(PrimateToMetricBlock, PrimateToMetricBlock.metricblock_id == MetricBlock.id)

If you want to filter by primate type, join the Primate table and filter:

query = query.join(Primate, Primate.id == PrimateToMetricBlock.primate_id).\
    filter(Primate.genus == 'human')

Otherwise, if you know the ID of the primate (primate_id), no additional join is necessary:

query = query.filter(PrimateToMetricBlock.primate_id == primate_id)

If you’re only retrieving one object, end the query with:

return query.first()

Otherwise:

return query.all()

Forming your model like this should eliminate any confusion and actually make everything simpler. If I’m missing something, let me know.