PL / pgSQL: поиск всех групп, к которым принадлежит человек (также косвенно) - PullRequest
Новая
       24

PL / pgSQL: поиск всех групп, к которым принадлежит человек (также косвенно)

3 голосов
/ 18 августа 2011

Простое вступление:

У меня есть база данных с пользователями и группами. Каждый пользователь может быть членом одной или нескольких групп. Каждая группа может иметь одну или несколько родительских групп.

Схема: 

CREATE TABLE users(
  username VARCHAR(64) NOT NULL PRIMARY KEY,
  password VARCHAR(64) NOT NULL,
  enabled BOOLEAN NOT NULL);

CREATE TABLE groups (
  id bigserial NOT NULL PRIMARY KEY,
  group_name VARCHAR(64) NOT NULL);

CREATE TABLE groups_inheritance (
  group_id bigint NOT NULL,
  parent_group_id bigint NOT NULL,
  CONSTRAINT fk_group_inheritance_group FOREIGN KEY(group_id) REFERENCES groups(id),
  CONSTRAINT fk_group_inheritance_group_2 FOREIGN KEY(parent_group_id) REFERENCES groups(id),
  CONSTRAINT unique_uk_groups_inheritance UNIQUE(group_id, parent_group_id));

CREATE TABLE group_members (
  id bigint PRIMARY KEY,
  username VARCHAR(64) NOT NULL,
  group_id bigint NOT NULL,
  CONSTRAINT fk_group_members_username FOREIGN KEY(username) REFERENCES users(username),
  CONSTRAINT fk_group_members_group FOREIGN KEY(group_id) REFERENCES groups(id));

Я ищу функцию PL / pgSQL, которая находит все группы (их имена), к которым принадлежит конкретный пользователь.

Пример:

название группы: Люди, родитель группы: нуль

название группы: студенты, родитель группы: люди

название группы: Football_players, родитель группы: люди

название группы: Basketball_players, родитель группы: люди

имя пользователя: Maciej, группы: студенты, футболисты

f ("Maciej") = {"Студенты", "Люди", "Football_players"}

Он принадлежит "Людям" только потому, что он принадлежит "Студентам" или "Football_players". Он не является прямым членом группы "Люди".

Заранее спасибо!

Ответы [ 2 ]

3 голосов
/ 18 августа 2011 
WITH RECURSIVE group_ancestry AS (
SELECT group_id, username
FROM group_members
UNION
SELECT groups_inheritance.parent_group_id, username
FROM group_ancestry
     JOIN groups_inheritance ON groups_inheritance.group_id = group_ancestry.group_id
)
SELECT username, group_id
FROM group_ancestry
1 голос
/ 18 августа 2011

Если у вас есть только один уровень наследования (как в примере), то вы можете использовать такой запрос: 

WITH group_ids AS
(
    SELECT group_id
    FROM group_members
    WHERE username LIKE 'Maciej'
)
SELECT group_name
FROM
    (SELECT group_id FROM group_ids
        UNION
    SELECT DISTINCT parent_group_id
    FROM groups_inheritance INNER JOIN group_ids USING(group_id)) g
INNER JOIN groups ON id = group_id;

Результат: 

    group_name    
------------------
 People
 Students
 Football_players
(3 rows)

Функция PL / pgSQL: 

DROP FUNCTION IF EXISTS f(varchar(64));
CREATE FUNCTION f(username varchar(64))
RETURNS text[] AS $$
DECLARE
    gId bigint;
    pgId bigint;
    gName text;
    result text[] = '{}';
BEGIN
    FOR gId IN SELECT group_id FROM group_members WHERE username LIKE username
    LOOP
        SELECT INTO gName group_name FROM groupS WHERE id = gId;
        result := result || gName;
        FOR pgId IN SELECT parent_group_id FROM groups_inheritance WHERE group_id = gId
        LOOP
            SELECT INTO gName group_name FROM groups WHERE id = pgId;
            IF NOT (result @> ARRAY[gName]) THEN
                result := result || gName;
            END IF;
        END LOOP;
    END LOOP;
    RETURN result;
END $$
LANGUAGE 'plpgsql';

Результат: 

SELECT f('Maciej');
                 f                  
------------------------------------
 {Students,People,Football_players}
(1 row)

Однако для вложенных родительских групп я думаю, что рекурсия должна подойти.

РЕДАКТИРОВАТЬ:

Вот вариант на основе рекурсии для вложенных родительских групп: 

CREATE OR REPLACE FUNCTION f_recursive(gIdParam bigint, resultArrayParam bigint[])
RETURNS bigint[] AS $$
DECLARE
    pgId bigint;
    resultArray bigint[];
BEGIN
    FOR pgId IN SELECT parent_group_id FROM groups_inheritance WHERE group_id = gIdParam
    LOOP
        IF NOT (resultArrayParam @> ARRAY[pgId]) THEN
            resultArray := resultArray || pgId;
            resultArray := resultArray || f_recursive(pgId, resultArray);
        END IF;
    END LOOP;
    RETURN resultArray;
END $$
LANGUAGE 'plpgsql';

CREATE OR REPLACE FUNCTION f(usernameParam varchar(64))
RETURNS text[] AS $$
DECLARE
    gId bigint;
    resultArray bigint[];
BEGIN
    FOR gId IN SELECT group_id FROM group_members WHERE username LIKE usernameParam
    LOOP
        resultArray := resultArray || gId;
        resultArray := resultArray || f_recursive(gId, resultArray);
    END LOOP;
    RETURN array_agg(group_name) 
            FROM groups INNER JOIN (SELECT unnest(resultArray)) u ON unnest = id;
END $$
LANGUAGE 'plpgsql';

Пример вставки: 

INSERT INTO groups (id, group_name) VALUES
    (1, 'People'), (2, 'Workers'), (3, 'Programmers'),
    (4, 'AI-Programmers'), (5, 'Administators'), (6, 'Managers');

INSERT INTO groups_inheritance (group_id, parent_group_id) VALUES
    (2, 1), (3, 2), (4, 3), (5, 2), (6, 2);

INSERT INTO users (username, password, enabled) VALUES
    ('Maciej', '12345', true);

INSERT INTO group_members (id, username, group_id) VALUES
    (1, 'Maciej', 4), (2, 'Maciej', 5);

Результат: 

SELECT f('Maciej');
                             f                             
-----------------------------------------------------------
 {AI-Programmers,Programmers,Workers,People,Administators}
(1 row)

Другой способ - использовать запрос WITH вместе с модификатором RECURSIVE, как показано в @araqnid.

...