SqlAlchemy：Sub-Select 具有双重 EXISTS (OR) 和额外的布尔检查

Question

在 SqlAlchemy 中，我需要实现以下子查询，它在 PostgreSQL 中运行良好。它是一个 OR 条件，由 2 个 EXISTS 加上一个附加的 AND 块组成。整列结果为 True/False 布尔值。

SELECT
...
...
,

(SELECT 
    (
        EXISTS (SELECT id from participating_ic_t pi1 where pi1.id = agreement_t_1.participating_ic_id 
                AND pi1.ic_nihsac = substr(ned_person_t_2.nihsac, 1, 3))
     OR EXISTS (SELECT id from external_people_t ep1 where ep1.participating_ic_id = agreement_t_1.participating_ic_id 
                AND ep1.uniqueidentifier = ned_person_t_2.uniqueidentifier)
    )
    AND ned_person_t_2.current_flag = 'Y' and ned_person_t_2.inactive_date is null and ned_person_t_2.organizationalstat = 'EMPLOYEE'
) as ACTIVE_APPROVER1,

首先，如果我省略了额外的 AND 块，下面的 OR-EXISTS 本身就可以工作：

subq1 = db_session.query(ParticipatingIcT.id).filter((ParticipatingIcT.id == agreement.participating_ic_id),
                                                     (ParticipatingIcT.ic_nihsac == func.substr(approver.nihsac, 1, 3)))
                                             .subquery()
subq2 = db_session.query(ExternalPeopleT.id).filter((ExternalPeopleT.participating_ic_id == agreement.participating_ic_id),
                                                    (ExternalPeopleT.uniqueidentifier == approver.uniqueidentifier))
                                            .subquery()                                     
subqMain =  db_session.query(or_(exists(subq1), exists(subq2))
                      .subquery()

# ...
# Now we will select from subqMain.                   
agreements = (db_session.query(
                   ..,
                   subqMain

但是当我引入最后一个 AND 块时问题就开始了。从概念上讲，最终结果应如下所示：

subqMain = db_session.query(and_(
                                or_(exists(subq1), exists(subq2)), 
                                approver.current_flag == 'Y',
                                approver.inactive_date == None, 
                                approver.organizationalstat == 'EMPLOYEE'))
                      .subquery()

但这实际上在子查询中发出 " .. FROM APPROVER_T" ，而它应该链接到 的 FROM APPROVER_T main 查询在最后。我需要避免添加 .. FROM [table]，它会在我指定 and_(..) 时立即发生。我不明白为什么要这样做。所有子查询都被特别标记为subquery()。别名 approver 在最顶部定义为 approver = aliased(NedPersonT).

Answer 1

exists1 = db_session.query(
    ParticipatingIcT.id
).filter(
    (ParticipatingIcT.id == agreement.participating_ic_id),
    (ParticipatingIcT.ic_nihsac == func.substr(approver.nihsac, 1, 3))
).exists() # use exists here instead of subquery
exists2 = db_session.query(
    ExternalPeopleT.id
).filter(
    (ExternalPeopleT.participating_ic_id == agreement.participating_ic_id),                                                  
    (ExternalPeopleT.uniqueidentifier == approver.uniqueidentifier)
).exists()  # use exists again instead of subquery                                     

subqMain =  db_session.query(and_(
    or_(exists1, exists2),
    approver.current_flag == 'Y',
    approver.inactive_date == None, 
    approver.organizationalstat == 'EMPLOYEE')).subquery()

# ...
# Now we will select from subqMain.                   
agreements = (db_session.query(
                   OtherModel,
                   subqMain))

sqlalchemy.orm.Query.exists

半生不熟的例子

这里也用了aliased，因为不太明白把子查询包在括号里的操作方法。没有它似乎可以工作，但 RAW sql 读起来很混乱。这是我尝试查看生成的 SQL 是否无效的玩具示例。

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String, nullable=False)
    hobbies = relationship('Hobby', backref='user')

class Hobby(Base):
    __tablename__ = 'hobbies'
    id = Column(Integer, primary_key=True, autoincrement=True)
    user_id = Column(Integer, ForeignKey('users.id'), nullable = False)
    name = Column(String, nullable=False)


Base.metadata.create_all(engine, checkfirst=True)
with Session(engine) as session:
    user1 = User(name='user1')
    session.add(user1)
    session.add_all([
        Hobby(name='biking', user=user1),
        Hobby(name='running', user=user1),
        Hobby(name='eating', user=user1),
    ])
    user2 = User(name='user2')
    session.add(user2)
    session.add(Hobby(name='biking', user=user2))
    session.commit()


    nested_user = aliased(User)
    subq1 = session.query(Hobby.id).filter(nested_user.id ==Hobby.user_id, Hobby.name.like('bik%'))
    subq2 = session.query(Hobby.id).filter(nested_user.id ==Hobby.user_id, Hobby.name.like('eat%'))
    subqmain = session.query(nested_user).filter(or_(subq1.exists(), subq2.exists()), nested_user.id > 0).subquery()
    q = session.query(User).select_from(User).join(subqmain, User.id == subqmain.c.id)
    print (q)
    print ([user.name for user in q.all()])

SELECT users.id AS users_id, users.name AS users_name 
FROM users JOIN (SELECT users_1.id AS id, users_1.name AS name 
FROM users AS users_1 
WHERE ((EXISTS (SELECT 1 
FROM hobbies 
WHERE users_1.id = hobbies.user_id AND hobbies.name LIKE %(name_1)s)) OR (EXISTS (SELECT 1 
FROM hobbies 
WHERE users_1.id = hobbies.user_id AND hobbies.name LIKE %(name_2)s))) AND users_1.id > %(id_1)s) AS anon_1 ON users.id = anon_1.id
['user1', 'user2']

Answer 2

那个 Sub-Select 有问题，所以我将其重写为 CASE 语句 。现在它正在工作。此外，我必须在主查询中加入几个额外的表来促进这个新的 CASE。

casePrimaryApprover = case(
    [
        (and_(
            (agreement.approving_official_id.is_not(None)),
            (approver.current_flag == 'Y'),
            (approver.inactive_date.is_(None)), 
            (approver.organizationalstat == 'EMPLOYEE'),
            or_(
                (participatingIc.ic_nihsac == func.substr(approver.nihsac, 1, 3)), 
                (externalPeoplePrimaryApprover.id.is_not(None))
            )
        ), 'Y')
    ],
    else_ = 'N'
)


# Main Query
agreements = (db_session.query(
    agreement.id,
    ...
    casePrimaryApprover 
    
    ...
    .join(participatingIc, agreement.participating_ic_id == participatingIc.id)
    .outerjoin(externalPeoplePrimaryApprover, approver.uniqueidentifier == externalPeoplePrimaryApprover.uniqueidentifier)

SqlAlchemy：Sub-Select 具有双重 EXISTS (OR) 和额外的布尔检查

SqlAlchemy: Sub-Select with a Dual EXISTS (OR) and an additional boolean check

python

sqlalchemy

半生不熟的例子