SQLAlchemy连接两个模型并选择第一行

Question

Currently I have two tables: Server and Scan.
It is possible to have one server to many scans (one to many relationship).

What I am trying to achieve is to select a Server and then only the first Scan associated to that Server. The following query:

query = db.session.query(models.Server, models.Scan).outerjoin(models.Server.scans).all()

outputs:

(<Server u'Testing'>, <Scan u'bbd4f805-3966-d464-b2d1-0079eb89d69708c3a05ec2812bcf'>)
(<Server u'Testing'>, <Scan u'bbd4f805-3966-d464-b2d1-0079eb89d69708c3a05ec2812bcf'>)
(<Server u'Testing'>, <Scan u'testscan'>)
(<Server u'fasd'>, <Scan u'testscan'>)
(<Server u'fdaafas'>, None)

whereas I only want one " Testing " Server and the most recent Scan.

ADDITIONAL

When I loop through my query like so:

for a in query:
    print a, a.scans.all()

The output is:

<Server u'Testing'> [<Scan u'testscan'>, <Scan u'bbd4f805-3966-d464-b2d1-0079eb89d69708c3a05ec2812bcf'>, <Scan u'bbd4f805-3966-d464-b2d1-0079eb89d69708c3a05ec2812bcf'>]
<Server u'fasd'> [<Scan u'testscan'>]
<Server u'fdaafas'> []

The output I want should equal:

<Server u'Testing'> [<Scan u'bbd4f805-3966-d464-b2d1-0079eb89d69708c3a05ec2812bcf'>]
<Server u'fasd'> [<Scan u'testscan'>]
    <Server u'fdaafas'> []

Answer 1

You would need to add a subquery in which you select the Scan register you want to show, using some criteria. For the toy example below I assume you want the maximum value of some parameter.

I've created tables A and B ; A corresponds to Server and B to Scan .

In [2]:

class A(Base):
    __tablename__ = 'A'
​
    pk = Column('pk', Integer, primary_key=True)
    name = Column('name', String)

class B(Base):
    __tablename__ = 'B'
​
    pk = Column('pk', Integer, primary_key=True)
    fk = Column('fk', Integer, ForeignKey('A.pk'))
    attr = Column('attr', Integer)
​
    a = relationship("A", backref='B')

Inserted some data,

In [10]:

q = session.query(B)
print(q)
for x in q.all():
    print(x.pk, x.fk, x.attr)

q = session.query(A)
print(q)
for x in q.all():
    print(x.pk, x.name)
​
SELECT "B".pk AS "B_pk", "B".fk AS "B_fk", "B".attr AS "B_attr" 
FROM "B"
1 1 1
2 1 2
3 2 0
4 2 4
5 1 4
SELECT "A".pk AS "A_pk", "A".name AS "A_name" 
FROM "A"
1 one
2 two

And solved your problem adding a subquery that selects the maximum value of B.attr for every B.fk , ie for every A.pk . (In your example it would be the maximum Scan.attr for every Server .)

In [13]:


from sqlalchemy import func
from sqlalchemy import tuple_
​
s = session.query(func.max(B.attr), B.fk).group_by(B.fk)
print(s)
q = session.query(A, B).outerjoin(B).filter(tuple_(B.attr, B.fk).in_(s))
print(q)
for x in q.all():
    print(x.A.pk, x.A.name, x.B.pk, x.B.attr)

SELECT max("B".attr) AS max_1, "B".fk AS "B_fk" 
FROM "B" GROUP BY "B".fk
SELECT "A".pk AS "A_pk", "A".name AS "A_name", "B".pk AS "B_pk", "B".fk AS "B_fk", "B".attr AS "B_attr" 
FROM "A" LEFT OUTER JOIN "B" ON "A".pk = "B".fk 
WHERE ("B".attr, "B".fk) IN (SELECT max("B".attr) AS max_1, "B".fk AS "B_fk" 
FROM "B" GROUP BY "B".fk)
2 two 4 4
1 one 5 4

NOTE: you don't mention which database you are using, but just in case, please note that the in_ statement with multiple columns does not work in sqlite (which is quite annoying when you try it). But if you used one column only, something like,

s = session.query(func.max(B.attr)).group_by(B.fk)
q = session.query(A, B).outerjoin(B).filter(B.attr.in_(s))

however depending on your data you could get more than one B for each A (eg B.fk =1 has max( B.attr )=3, and B.fk =2 has max( B.attr )=4 but also a B.attr =3, you would get for B.fk =2 both B.attr =3 and B.attr =4.

However if the attribute you are using to select the maximum was unique, it would be fine. Anyway if you are with a database like postgres or oracle you can use the in_ with multiple columns.

Hope it helps.

EDIT added after comments: If you want to get also the Servers without a Scan , you just need to add an or_ to your query.

In [18]:

from sqlalchemy import func
from sqlalchemy import tuple_
from sqlalchemy import or_
​
s = session.query(func.max(B.attr), B.fk).group_by(B.fk)
q = session.query(A, B).outerjoin(B).filter(or_(tuple_(B.attr, B.fk).in_(s), B.fk==None))
print(q)
for x in q.all():
    if x.B:
        print(x.A.pk, x.A.name, x.B.pk, x.B.attr)
    else:
        print(x.A.pk, x.A.name)
​
SELECT "A".pk AS "A_pk", "A".name AS "A_name", "B".pk AS "B_pk", "B".fk AS "B_fk", "B".attr AS "B_attr" 
FROM "A" LEFT OUTER JOIN "B" ON "A".pk = "B".fk 
WHERE ("B".attr, "B".fk) IN (SELECT max("B".attr) AS max_1, "B".fk AS "B_fk" 
FROM "B" GROUP BY "B".fk) OR "B".fk IS NULL
2 two 4 4
1 one 5 4
3 three

As you see, you have to be careful with nulls. Note that outerjoin already performs a left join , which is what you needed, but because of the filter , you have to explicitly say that you want the null rows also. As usual, A is Server and B is Scan . Sorry for not using your table names, it makes it much more difficult to read.