在postgres中，使用連接表執行AND的最佳方法是什麼？

Question

我有不同的用戶類別和一個允許用戶在多個類別中的連接表。我的連接表稱爲categories_users，它由user_id和category_id組成。

我想篩選category1和category2中的用戶。例如，我想找到所有對棒球和足球都感興趣的人。

在PostgreSQL中這樣做的最好方法是什麼？我有以下工作：

select * from users 
    where users.id IN 
    (Select categories_users.user_id from categories_users 
     JOIN categories ON categories.id = categories_users.category_id 
     where categories.id = 1 OR categories.parent_id = 1) 
    AND users.id IN 
    (Select categories_users.user_id from categories_users 
    JOIN categories ON categories.id = categories_users.category_id 
    where categories.id = 2 OR categories.parent_id = 2) 

但是這種感覺笨重，我想知道是否有更好的方法來做到這一點。我嘗試了各種連接，但最終總是在categories_users表中搜索category_id爲1和2的行，這是不可能的。

編輯，我其實也需要對父類搜索，所以我已經改變了上面的查詢到包括PARENT_ID

Answer 1

與同桌剛剛加入兩次（使用化名）：

SELECT u.* 
    FROM users u 
    JOIN categories_users cu1 ON cu1.user_id = u.id 
    JOIN categories_users cu2 ON cu2.user_id = u.id 
    WHERE cu1.category_id = 1 AND cu2.category_id = 2 

Answer 2

select u.* 
from 
    users u 
    inner join (
     select user_id 
     from categories_users 
     group by user_id 
     having 
      bool_or(1 in (category_id, parent_id)) and 
      bool_or(2 in (category_id, parent_id)) 
    ) s on s.user_id = u.id 

Answer 3

您也可以在分區上使用COUNT（*）以查看用戶在搜索的類別集中有多少類別。

我創建了以下示例，以瞭解如何定義和參數化。 我創建了一個函數test.find_users_in_categories(BIGINT[])，它接受我們需要用戶列表的類別數組。 因此，該函數將返回所有給定類別中的所有用戶。

解決方案 - 讓所有給定的類別中找到的用戶

CREATE SCHEMA test; 

CREATE TABLE test.categories_users (
    category_id BIGINT NOT NULL, 
    user_id BIGINT NOT NULL 
); 

INSERT INTO test.categories_users 
    (user_id, category_id) 
    VALUES 
    (33, 103), 
    (34, 104), 
    (35, 105), 
    (37, 105), 
    (35, 106), 
    (37, 106); 

CREATE OR REPLACE FUNCTION test.find_users_in_categories(BIGINT[]) 
    RETURNS TABLE (
    user_id BIGINT 
) 
AS 
$$ 
DECLARE 
    categories ALIAS FOR $1; 
BEGIN 
    RETURN QUERY 
    SELECT t.user_id 
    FROM 
     (
     SELECT 
      cu.user_id, 
      cu.category_id, 
      COUNT(*) OVER (PARTITION BY cu.user_id) AS cnt 
     FROM test.categories_users AS cu 
     WHERE cu.category_id = ANY(categories) 
    ) AS t 
     WHERE t.cnt = array_length(categories, 1) 
     GROUP BY t.user_id; 
END; 
$$ 
LANGUAGE plpgsql; 

SELECT * FROM test.find_users_in_categories(ARRAY[105, 106]); 

DROP SCHEMA test CASCADE; 

編輯 - [遞歸解決方案]

解決方案 - 讓所有給定的類別和子發現用戶 - 類別

請參閱以下關於使用JOIN +遞歸CTE。我使用JOIN而不是COUNT（），因爲它對於這種情況看起來更好。

CREATE SCHEMA test; 

CREATE TABLE test.categories (
    category_id BIGINT PRIMARY KEY, 
    parent_id BIGINT REFERENCES test.categories(category_id) 
); 

CREATE TABLE test.categories_users (
    category_id BIGINT NOT NULL REFERENCES test.categories(category_id), 
    user_id BIGINT NOT NULL 
); 

INSERT INTO test.categories 
    (category_id, parent_id) 
    VALUES 
    (100, NULL), 
    (101, 100), 
    (102, 100), 
    (103, 101), 
    (104, 101), 
    (105, 101), 
    (106, NULL); 


INSERT INTO test.categories_users 
    (user_id, category_id) 
    VALUES 
    (33, 103), 
    (34, 104), 
    (35, 105), 
    (37, 105), 
    (35, 106), 
    (37, 106); 


CREATE OR REPLACE FUNCTION test.find_users_in_categories(BIGINT[]) 
    RETURNS TABLE (
    user_id BIGINT 
) 
AS 
$$ 
DECLARE 
    main_categories ALIAS FOR $1; 
BEGIN 
    RETURN QUERY 
    WITH 
    -- get all main categories and subcategories 
    RECURSIVE cte_categories (category_id, main_category_id) AS 
    (
     SELECT cat.category_id, cat.category_id AS main_category_id 
     FROM test.categories AS cat 
     WHERE cat.category_id = ANY(main_categories) 
     UNION ALL 
     SELECT cat.category_id, cte.main_category_id 
     FROM cte_categories AS cte 
     INNER JOIN test.categories AS cat 
      ON cte.category_id = cat.parent_id 
    ), 
    -- filter main categories that are found as children of other categories 
    cte_categories_unique AS 
    (
     SELECT cte.* 
     FROM cte_categories AS cte 
     LEFT JOIN 
     (
      SELECT category_id 
      FROM cte_categories 
      WHERE category_id <> main_category_id 
      GROUP BY category_id 
     ) AS to_exclude 
      ON cte.main_category_id = to_exclude.category_id 
     WHERE to_exclude.category_id IS NULL 
    ), 
    -- compute the count of main categories 
    cte_main_categories_count AS 
    (
     SELECT COUNT(DISTINCT main_category_id) AS cnt 
     FROM cte_categories_unique 
    ) 
    SELECT t.user_id 
    FROM 
     (
     -- get the users which are found in each category/sub-category then group them under the main category 
     SELECT 
      cu.user_id, 
      cte.main_category_id 
     FROM test.categories_users AS cu 
     INNER JOIN cte_categories_unique AS cte 
      ON cu.category_id = cte.category_id 
     GROUP BY cu.user_id, cte.main_category_id 
    ) AS t 
     GROUP BY t.user_id 
     -- filter users that do not have a match on all main categories or their sub-categories 
     HAVING COUNT(*) = (SELECT cnt FROM cte_main_categories_count); 
END; 
$$ 
LANGUAGE plpgsql; 


SELECT * FROM test.find_users_in_categories(ARRAY[101, 106]); 

DROP SCHEMA test CASCADE;