SQLAlchemy - Holen Sie sich alle Zeilen, die eine Gruppe von Spalten haben passende

Question

Ich habe eine Tabelle

class Term(CommonFunctions, Base): 
    __tablename__ = 'terms' 

    id = Column(Integer, primary_key=True,autoincrement=True) 
    term_begin = Column(Date, nullable=False) 
    term_end = Column(Date) 
    term_served = Column(Integer) # term_number # calculatable? 
    office_type_id = Column(Integer, ForeignKey(OfficeType.id)) 
    office_type = relationship('OfficeType', backref='terms') 
    state_id = Column(Integer, ForeignKey(State.id)) 
    state = relationship('State', backref='terms') 
    district_id = Column(Integer, ForeignKey(District.id)) 
    district = relationship('District', backref='terms') 
    office_class = Column(Integer) 
    # ... other fieldds 

Ich versuche, einen Bericht zu erstellen, die ID-Paare zu finden, die Zeilen, die den gleichen Satz von Daten für haben (state_id, district_id, office_type_id, office_class) für eine bestimmte office_type_id innerhalb eines bestimmten Datumsbereichs.

Die Abfrage habe ich jetzt - (Institution = office_type_id)

date = request.args.get('date') 
institution = request.args.get('institution') 
term_alias = aliased(schema.Term) 
composition = Session.query(schema.Term.id, term_alias.id).\ 
    filter(schema.Term.id != term_alias.id).\ 
    filter(schema.Term.office_class == term_alias.office_class).\ 
    filter(schema.Term.state_id == term_alias.state_id).\ 
    filter(schema.Term.office_type_id == term_alias.office_type_id).\ 
    filter(schema.Term.office_type_id == institution).\ 
    filter(schema.Term.office_class != 0).\ 
    filter(and_(schema.Term.term_begin <= date, or_(schema.Term.term_end >= date, 
                      schema.Term.term_end == None))).\ 
    all() 

Dies funktioniert - in gewissem Sinne. Ich bekomme gültige Ergebnisse zurück, aber es reproduziert das Ergebnis zweimal, einmal für jede Version des Paares.

Beispiel:

[(127,196), (196,127)]

Meine Frage ist: Wie kann ich die Abfrage aktualisieren, nur paarweise zu schließen, die durch einen logisch äquivalenten Paar nicht bereits vertreten sind.

Ich möchte, dass die oben genannten entweder [(127, 196)] oder [(196,127)] nicht beide sein.

Vielen Dank für

Answer 1

einen gemeinsamen Weg zu lesen ist, eine bestimmte (willkürliche) Ordnung aufzuzwingen:

Session.query(...).filter(..., schema.Term.id < term_alias.id) 

Wenn Sie wieder eine „reflexive“ Paar (zwei identische IDs) erhalten können, müssen Sie wenden Sie auch ein distinct an.

Session.query(...).filter(..., schema.Term.id < term_alias.id).distinct()