如何在单个查询中执行具有不同参数的多个连接

Question

我有两个表，question(question_id) 和 question_exclusion(question_type, question_sub_type, question_id)

如果我指定 question_type 和 question_sub_type，我就能做到。

SELECT *
FROM question AS t1
         LEFT JOIN (SELECT t.question_id
                    FROM question_exclusion as t
                    WHERE t.question_type = 'A'
                      AND t.question_sub_type = 'A_1') AS t2
                   ON t1.question_id = t2.question_id
WHERE t2.question_id is null;

但我想要实现的是在单个查询中获取所有带有 questions_ids 的问题，以获取所有可能的 question_type 和 questions_sub_type

question_type 和 questions_sub_type 是动态参数，在查询执行之前我不知道确切的值

更新 1：

实际数据：

表：question

question_id|
42
10
2
36
49

表：question_exclusion

question_type|question_sub_type|question_id|
A            | A_1             | 42
A            | A_1             | 10
A            | A_2             | 10
B            | B_1             | 36 
C            | null            | 2

预期结果：

question_type|question_sub_type|question_id
A            | A_1             | 2
A            | A_1             | 36
A            | A_1             | 49
A            | A_2             | 42
A            | A_2             | 2
A            | A_2             | 36
A            | A_2             | 49
B            | B_1             | 42
B            | B_1             | 10
B            | B_1             | 2
B            | B_1             | 49
C            | null            | 42
C            | null            | 10
C            | null            | 36
C            | null            | 49

它就像每个类型和子类型组合的列表列表 考虑到排除表

例如：

type=A, sub_type=A_1 -> (select * from questions) - (select * from question_exclusion where type='A' and sub_type='A_1')
+
type=A, sub_type=A_2 -> (select * from questions) - (select * from question_exclusion where type='A' and sub_type='A_2')
+
type=B, sub_type=B_1 -> (select * from questions) - (select * from question_exclusion where type='B' and sub_type='B_2')

当然我可以查询所有不同的（类型，子类型）并通过结合联合进行另一个查询

SELECT *
FROM question AS t1
         LEFT JOIN (SELECT t.question_id
                    FROM question_exclusion as t
                    WHERE t.question_type = 'A'
                      AND t.question_sub_type = 'A_1') AS t2
                   ON t1.question_id = t2.question_id
WHERE t2.question_id is null
UNION
SELECT *
FROM question AS t1
         LEFT JOIN (SELECT t.question_id
                    FROM question_exclusion as t
                    WHERE t.question_type = 'B'
                      AND t.question_sub_type = 'B_1') AS t2
                   ON t1.question_id = t2.question_id
WHERE t2.question_id is null
...
...
N times for all type and sub_type

我正在寻找另一种在单个查询中执行此操作的可靠方法

Answer 1

\i tmp.sql

create table question
        (question_id integer not null primary key)
        ;
INSERT INTO question(question_id) VALUES
( 42) , ( 10) , ( 2) , ( 36) , ( 49) ;

create table question_exclusion
        ( question_type text
        , question_sub_type text
        , question_id integer REFERENCES question( question_id)
        );

INSERT INTO question_exclusion(question_type, question_sub_type, question_id) VALUES
 ('A' , 'A_1' , 42 ) , ('A' , 'A_2' , 10 ) , ('B' , 'B_1' , 36  ) , ('C' , null  , 2 ) ;

WITH types AS (
        select distinct question_type, question_sub_type
        FROM question_exclusion
        )
SELECT t.question_type, t.question_sub_type, q.question_id
FROM question q
JOIN types t ON NOT EXISTS (
        SELECT * FROM question_exclusion x
        WHERE 1=1
        AND x.question_id = q.question_id
        AND x.question_type = t.question_type
        AND x.question_sub_type = t.question_sub_type
        )
ORDER BY t.question_type, t.question_sub_type
        ;

---

修改：

---

WITH types AS (
        select distinct question_type, question_sub_type
        FROM question_exclusion
        )
SELECT t.question_type, t.question_sub_type, q.question_id
FROM question q
CROSS JOIN types t
WHERE NOT EXISTS (
        SELECT * FROM question_exclusion x
        WHERE 1=1
        AND x.question_id = q.question_id
        AND x.question_type = t.question_type
        AND x.question_sub_type = t.question_sub_type
        )
ORDER BY t.question_type, t.question_sub_type
        ;

---

与

没有区别

---

WITH types AS (
        select distinct question_type, question_sub_type
        FROM question_exclusion
        )
SELECT t.question_type, t.question_sub_type, q.question_id
FROM question q
CROSS JOIN types t
WHERE NOT EXISTS (
        SELECT * FROM question_exclusion x
        WHERE 1=1
        AND x.question_id = q.question_id
        AND (x.question_type, x.question_sub_type) IS NOT DISTINCT FROM
            (t.question_type, t.question_sub_type)
        )
ORDER BY t.question_type, t.question_sub_type
        ;

Answer 2

我将行 (A | A_1 | 10) 添加到您的数据中的 question_exclusion 中以获得更干净的解决方案：

with question(question_id) as (
    select 42 union all
    select 10 union all
    select 2 union all
    select 36 union all
    select 49
),
question_exclusion(question_type, question_sub_type, question_id) as (
    select 'A', 'A_1', 42 union all
    select 'A', 'A_1', 10 union all
    select 'A', 'A_2', 10 union all
    select 'B', 'B_1', 36 union all 
    select 'C', null, 2
),
question_types(question_type, question_sub_type) as (
    select distinct question_type, question_sub_type from question_exclusion
)
select
    qt.question_type, qt.question_sub_type, q.question_id
from
    question q
    left join question_types qt on (1 = 1)
    left join question_exclusion qe on (q.question_id = qe.question_id and qt.question_type = qe.question_type and coalesce(qt.question_sub_type, '_') = coalesce(qe.question_sub_type, '_'))
where
    qe.question_id is null
order by 
    qt.question_type, qt.question_sub_type

Answer 3

with
    -- questions
    q(id) as (select * from unnest('{42,10,2,36,49}'::int[])),
    -- excluded questions
    qe(tp, stp, id) as (select * from unnest(
        '{A,A,A,B,C}'::text[],
        '{A_1,A_1,A_2,B_1,NULL}'::text[],
        '{42,10,10,36,2}'::int[])),
    -- combinations of types and subtypes
    qt(tp, stp) as (select distinct tp, stp from qe)
select qt.tp, qt.stp, q.id from q cross join qt
except
select tp, stp, id from qe
order by 1, 2, 3;

┌────┬──────┬────┐
│ tp │ stp  │ id │
├────┼──────┼────┤
│ A  │ A_1  │  2 │
│ A  │ A_1  │ 36 │
│ A  │ A_1  │ 49 │
│ A  │ A_2  │  2 │
│ A  │ A_2  │ 36 │
│ A  │ A_2  │ 42 │
│ A  │ A_2  │ 49 │
│ B  │ B_1  │  2 │
│ B  │ B_1  │ 10 │
│ B  │ B_1  │ 42 │
│ B  │ B_1  │ 49 │
│ C  │ ░░░░ │ 10 │
│ C  │ ░░░░ │ 36 │
│ C  │ ░░░░ │ 42 │
│ C  │ ░░░░ │ 49 │
└────┴──────┴────┘

demo

Answer 4

这是一个完成您描述的示例查询：

SELECT DISTINCT x.question_type, x.question_sub_type, q.question_id
FROM question_exclusion x
CROSS APPLY question q 
WHERE NOT EXISTS (
    SELECT 1
    FROM question_exclusion
    WHERE question_type = x.question_type
        AND (question_sub_type = x.question_sub_type OR (question_sub_type IS NULL AND x.question_sub_type IS NULL))
        AND question_id = q.question_id)
ORDER BY question_type, question_sub_type

这使用CROSS APPLY 创建两个表的笛卡尔积，NOT EXISTS 子查询过滤掉排除的行，并使用 DISTINCT 从笛卡尔积中删除重复项（因为 @ 中有多个记录987654325@ 与 question_type 和 question_sub_type 相同）。

也可以使用LEFT JOIN 来代替子查询，如下所示：

SELECT DISTINCT a.question_type, a.question_sub_type, a.question_id
FROM (
    SELECT x.question_type, x.question_sub_type, q.question_id
    FROM question_exclusion x
        CROSS APPLY question q
    ) a
    LEFT JOIN question_exclusion r
        ON a.question_id = r.question_id
            AND a.question_type = r.question_type
            AND (a.question_sub_type = r.question_sub_type OR (a.question_sub_type IS NULL AND r.question_sub_type IS NULL))
WHERE r.question_id IS NULL
ORDER BY question_type, question_sub_type