sqlalchemy通过到同一表的两个外键联接到一个表（模糊列错误）

Question

I am trying to do a join on a table that has two foriegn keys to the same table. Namely, sourceToOutputRelation points twice to Entries, as shown in the code. Also, Entries have tags. I am trying to do a join so that I get every sourceToOutputRelation that has all the given tags (via Entries). I am just trying to understand the join (the filtering works, I think). Here is the code I have for the join and filter. :

'''
  tags is a list of strings that are supposed to match the Tags.tag strings
'''
    from sqlalchemy.orm import aliased


    q = SourceToOutputRelation.query.\
         join(Entries.source_entries, Entries.output_entries).\
         join(original_tag_registration).\
         join(Tags).\
         filter(Tags.tag == tags[0]) 
    print(q.all())

Here are my model definitions :

class SourceToOutputRelation(alchemyDB.Model):

    __tablename__ =  'sourceToOutputRel'
    id = alchemyDB.Column(alchemyDB.Integer, primary_key = True)
    source_article = alchemyDB.Column(alchemyDB.Integer, alchemyDB.ForeignKey('entries.id'))
    output_article = alchemyDB.Column(alchemyDB.Integer, alchemyDB.ForeignKey('entries.id'))

class Entries(alchemyDB.Model):

    __tablename__ = 'entries'
    id = alchemyDB.Column(alchemyDB.Integer, primary_key = True)    
    tags = alchemyDB.relationship('Tags',
                              secondary = original_tag_registration,
                              backref = alchemyDB.backref('relevant_entries', lazy = 'dynamic'),
                              lazy = 'dynamic')    
    source_entries = alchemyDB.relationship('SourceToOutputRelation',
                                            primaryjoin="SourceToOutputRelation.output_article==Entries.id",
                                            foreign_keys = [SourceToOutputRelation.output_article],
                                            backref = alchemyDB.backref('output', lazy = 'joined'),
                                            lazy = 'dynamic',
                                            cascade = 'all, delete-orphan')
    output_entries = alchemyDB.relationship('SourceToOutputRelation',                                            
                                            primaryjoin="SourceToOutputRelation.source_article==Entries.id",
                                            foreign_keys = [SourceToOutputRelation.source_article],
                                            backref = alchemyDB.backref('source', lazy = 'joined'),
                                            lazy = 'dynamic',
                                            cascade = 'all, delete-orphan')



original_tag_registration = alchemyDB.Table('original_tag_registration',
    alchemyDB.Column('tag_id', alchemyDB.Integer, alchemyDB.ForeignKey('tagTable.id')),
    alchemyDB.Column('entry_id', alchemyDB.Integer, alchemyDB.ForeignKey('entries.id'))
    )


class Tags(alchemyDB.Model):
    '''
        a table to hold unique tags
    '''
    __tablename__ = 'tagTable'
    id = alchemyDB.Column(alchemyDB.Integer, primary_key = True)
    tag = alchemyDB.Column(alchemyDB.String(64), unique=True)
    entries_with_this_tag = alchemyDB.relationship('Entries',
                                                secondary = original_tag_registration,
                                                backref = alchemyDB.backref('tag', lazy = 'dynamic'),
                                                lazy = 'dynamic') 

I get this error :

OperationalError: (OperationalError) ambiguous column name: sourceToOutputRel.id u'SELECT "sourceToOutputRel".id AS "sourceToOutputRel_id", "sourceToOutputRel".source_article AS "sourceToOutputRel_source_article", "sourceToOutputRel".output_article AS "sourceToOutputRel_output_article", "sourceToOutputRel".needs_processing AS "sourceToOutputRel_needs_processing", "sourceToOutputRel".number_of_votes AS "sourceToOutputRel_number_of_votes", "sourceToOutputRel".date_related AS "sourceToOutputRel_date_related", "sourceToOutputRel".confirmed_relationship_type AS "sourceToOutputRel_confirmed_relationship_type", entries_1.id AS entries_1_id, entries_1.title AS entries_1_title, entries_1.text AS entries_1_text, entries_1.body_html AS entries_1_body_html, entries_1.user_id AS entries_1_user_id, entries_1.date_posted AS entries_1_date_posted, entries_2.id AS entries_2_id, entries_2.title AS entries_2_title, entries_2.text AS entries_2_text, entries_2.body_html AS entries_2_body_html, entries_2.us er_id AS entries_2_user_id, entries_2.date_posted AS entries_2_date_posted \\nFROM entries JOIN "sourceToOutputRel" ON "sourceToOutputRel".output_article = entries.id JOIN "sourceToOutputRel" ON "sourceToOutputRel".source_article = entries.id JOIN original_tag_registration ON entries.id = original_tag_registration.entry_id JOIN "tagTable" ON "tagTable".id = original_tag_registration.tag_id LEFT OUTER JOIN entries AS entries_1 ON "sourceToOutputRel".output_article = entries_1.id LEFT OUTER JOIN entries AS entries_2 ON "sourceToOutputRel".source_article = entries_2.id \\nWHERE "tagTable".tag = ?' (u'brods',)

Answer 1

Look at the docs . Paragraph

Joins to a Target with an ON Clause

a_alias = aliased(Address)

q = session.query(User).\
    join(User.addresses).\
    join(a_alias, User.addresses).\
    filter(Address.email_address=='ed@foo.com').\
    filter(a_alias.email_address=='ed@bar.com')

There are multiple join on one table. You already import aliased funciton. Try this code

'''
  tags is a list of strings that are supposed to match the Tags.tag strings
'''
from sqlalchemy.orm import aliased

entry_alias = aliased(Entries)
q = SourceToOutputRelation.query.\
     join(Entries.source_entries).\
     join(entry_alias, Entries.output_entries).\
     join(original_tag_registration).\
     join(Tags).\
     filter(Tags.tag == tags[0])
print(q.all())