Wie schreibe ich Unterabfragen?

Question

Ich versuche, diesen SQL-Ausdruck in eine Unterabfrage mit SQL Alchemy

Ich versuche, die Dokumentation für Unterabfragen zu lesen, aber ich bin verloren. Kann jemand das in SqlAlchemy schreiben, damit ich es verstehen kann?

SELECT from_ 
FROM uploaded_emails1 
WHERE from_ != 'test@email.com' 
AND from_ NOT IN (SELECT email FROM candidate_emails2) 

Answer 1

Erstens denke ich, Sie in einem wenig am tiefen Ende hier (die SQL-Abfrage ist wahrscheinlich nicht wirklich die richtige Art und Weise zu erreichen, was Sie wollen) tauchen könnten versuchen, so dass Sie vielleicht darüber nachdenken, einige SQL-Konzepte ein wenig klarer in den Kopf zu bekommen, bevor Sie in Unterabfragen in sqlalchemy tauchen. In Bezug darauf weist die Verwendung von Tabellen mit den Namen uploaded_emails1 und candidate_emails2 darauf hin, dass der zugrunde liegende Entwurf des Datenbankschemas möglicherweise etwas optimiert werden muss.

aber sagen, dass hier ein minimales Beispiel, das tun sollten, was Sie wollen (erhalten alle E-Mail-Adressen, die in den hochgeladenen E-Mails, die nicht auch in der Kandidaten E-Mails Tabelle sind)

from sqlalchemy import create_engine 
from sqlalchemy.ext.declarative import declarative_base 
import sqlalchemy as sq 
from sqlalchemy.orm import sessionmaker 

engine = create_engine('sqlite://', echo=True) 

Base = declarative_base() 


class UploadedUser(Base): 
    __tablename__ = 'uploaded_user' 
    uploaded_user_id = sq.Column(sq.Integer, primary_key=True) 
    email_address = sq.Column(sq.Text(100)) 


class CandidateUser(Base): 
    __tablename__ = 'candidate_user' 

    candidate_user_id = sq.Column(sq.Integer, primary_key=True) 
    email_address = sq.Column(sq.Text(100)) 

    def __repr__(self): 
     return '<Candidate User with email: {}>'.format(self.email_address) 


Base.metadata.create_all(engine) 

Session = sessionmaker(bind=engine) 
session = Session() 

uploaded_user = UploadedUser(email_address='email1@foo.com') 
session.add(uploaded_user) 

for idx in range(1, 3): 
    candidate_user = CandidateUser(email_address='email{}@foo.com'.format(idx)) 
    session.add(candidate_user) 

session.commit() 

query_result = session.query(CandidateUser.email_address, 
          UploadedUser.email_address).outerjoin(UploadedUser, 
                    CandidateUser.email_address == UploadedUser.email_address).filter(
    UploadedUser.email_address.isnot(None)).with_entities(UploadedUser.email_address).all() 

print(query_result) 

Die echo=True erzählt sqlalchemy die tatsächlichen Abfragen ausdrucken Ausführung ist so die Abfrage du redest wie ausgeführt ist:

SELECT uploaded_user.email_address AS uploaded_user_email_address 
FROM candidate_user LEFT OUTER JOIN uploaded_user ON 
candidate_user.email_address = uploaded_user.email_address 
WHERE uploaded_user.email_address IS NOT NULL 

, die auf die Abfrage ganz in der Nähe, die Sie schreiben wollen würden, wenn Sie rohen SQL geschrieben haben.

Answer 2

Wie wäre es ein LEFT JOIN anstelle von Unterabfrage:

SELECT from_ 
FROM uploaded_emails1 ue 
LEFT JOIN candidate_emails2 ce ON ue.from_ = ce.email 
WHERE ce.email IS NULL AND from_! = "test@email.com" 

Diese in SQLAlchemy ausgedrückt werden könnte, wie:

emails = dbsession.query(
    UploadedEmail.from_ 
).outerjoin(
    CandidateEmail, CandidateEmail.email == UploadedEmail.from_ 
).filter(
    CandidateEmail.email == None, 
    UploadedEmail.from_ != 'test@email.com', 
) 

Answer 3

for email, in db_session.query(Uploaded_Emails1.from_).filter(
     Uploaded_Emails1.from_ != 'test@email.com').filter(
     ~Uploaded_Emails1.from_.in_(db_session.query(Candidate_Emails2.email))): 
    print(email) 

das funktionierte