在Flask SQL-Alchemy中通过ForeignKey中的多个实例进行过滤

Question

Let's say I have a model Toolbox, foreign key associated with a variety of Tools:

class Toolbox(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    tools = db.relationship('Tools')

class Tool(db.Model):
    id = db.Column(db.Integer)
    name = db.Column(db.String(64), index=True)
    quantity = db.Column(db.Integer)
    toolbox_id = db.Column(db.Integer, db.ForeignKey('toolbox.id'))
    toolbox = db.relationship(Toolbox)

and a dictionary of tools and their quantities:

tool_dict = {'screwdriver' : 3, 'wrench' : 1 }

How can I make query in SQLAlchemy that would return a list of Toolboxes that contain at least 3 screwdrivers and 1 wrench?

I got so far as:

t = Toolbox.query.join(Tool).filter(Tool.name.in_(tool_dict.keys()))

however this returns all toolboxes containing screwdrivers and wrenches regardless of quantity.

Answer 1

One way to approach this would be to first select from tool relation a union of sets of (toolbox_id, name) tuples, where quantity is satisfied. Then divide that found set with the names of the required tools, and you're left with the toolbox_id s you want.

Another, in this case a lot simpler, way would be to select the intersection of toolbox ids from tools that satisfy the quantity, and then select the toolboxes that match the ids.

Initial data

In [51]: db.session.add(Toolbox(tools=[
    ...:     Tool(name='hammer', quantity=1),
    ...:     Tool(name='screwdriver', quantity=3),
    ...:     Tool(name='wrench', quantity=1)]))

In [52]: db.session.add(Toolbox(tools=[
    ...:     Tool(name='hammer', quantity=1),
    ...:     Tool(name='screwdriver', quantity=2),
    ...:     Tool(name='wrench', quantity=1)]))

In [53]: db.session.add(Toolbox(tools=[
    ...:     Tool(name='hammer', quantity=1),
    ...:     Tool(name='screwdriver', quantity=3)]))

In [54]: db.session.add(Toolbox(tools=[
    ...:     Tool(name='hammer', quantity=1),
    ...:     Tool(name='wrench', quantity=1)]))

In [55]: db.session.add(Toolbox(tools=[
    ...:     Tool(name='hammer', quantity=1)]))

In [56]: db.session.commit()

Intersect

Form the intersection:

In [9]: tools = db.intersect(*(db.session.query(Tool.toolbox_id).
   ...:                        filter(Tool.name == name,
   ...:                               Tool.quantity >= quantity)
   ...:                        for name, quantity in tool_dict.items())).alias()

Then select the Toolbox es where id is in the intersection:

In [10]: db.session.query(Toolbox).filter(Toolbox.id.in_(tools)).all()
Out[10]: [<__main__.Toolbox at 0x7f7ca781c048>]

In [11]: _[0].id
Out[11]: 1

Division

Form a CTE from the selection of tools, and an alias of that CTE, as we have to use it in an inner NOT EXISTS later:

In [41]: tools = db.union(*(db.session.query(Tool.toolbox_id, Tool.name).
    ...:                    filter(Tool.name == name,
    ...:                           Tool.quantity >= quantity)
    ...:                    for name, quantity in tool_dict.items())).cte()

In [42]: tools_alias = tools.alias()

Form a relation of required tools:

In [38]: required_tools = db.union(
    ...:     *(db.select([db.literal(name).label('tool_name')])
    ...:       for name in tool_dict.keys())).alias()

This could be made a bit simpler in some DBs, for example in Postgresql you could do:

from sqlalchemy.dialects.postgresql import array
required_tools = func.unnest(array(list(tool_dict.keys()))).alias()

Perform division:

In [63]: db.session.query(tools.c.tool_toolbox_id.distinct()).\
    ...:     filter(~db.session.query().select_from(required_tools).
    ...:            filter(~db.session.query().select_from(tools_alias).
    ...:                   filter(tools_alias.c.tool_toolbox_id == tools.c.tool_toolbox_id,
    ...:                          tools_alias.c.tool_name == required_tools.c.tool_name).
    ...:                   exists().correlate_except(tools_alias)).
    ...:            exists()).all()
Out[63]: [(1)]

The doubly nested negation is an eyesore, but it answers the query "find those toolboxes (ids), for which no such required tool exists that is not in the toolbox".

To fetch the desired Toolbox es directly we can tweak the query a bit to select from toolbox relation at top level and the formed union at the innermost level only:

In [16]: tools = db.union(*(db.session.query(Tool.toolbox_id, Tool.name).
    ...:                    filter(Tool.name == name,
    ...:                           Tool.quantity >= quantity)
    ...:                    for name, quantity in tool_dict.items())).alias()

In [17]: db.session.query(Toolbox).\
    ...:     filter(~db.session.query().select_from(required_tools).
    ...:            filter(~db.session.query().select_from(tools).
    ...:                   filter(tools.c.tool_toolbox_id == Toolbox.id,
    ...:                          tools.c.tool_name == required_tools.c.tool_name).
    ...:                   exists().correlate_except(tools)).
    ...:            exists()).all()
Out[17]: [<__main__.Toolbox at 0x7f302f589898>]

In [18]: _[0].id
Out[18]: 1