如何保护 table 以避免重复数据

Question

我无法解决 table 的安全问题，以避免 attributes_positions 的重复组合。向您展示我的意思的最佳方式是下图

列id_combination表示组合数。组合由attributes_positions组成。所以组合是 attributes_positions.

的序列

现在我将确保 table 不插入与 attributes_positions.

相同的序列

当然如果已经插入的组合多了一个attributes_positions或者少一个插入组合也是可以的

图片我展示了不同的重复和非重复组合。

有什么方法可以做到这一点吗？？有点像 'before update'。但是如何实现这个例子。我不太擅长高级 sql。我试图保护 table 的数据库是 postgresql 9.4

我将不胜感激

Answer 1

我的回答假设目标没有重复，并且我们想插入一个新的集合——恰好是重复的。我选择 id_comb 为 1 的 4 人组。

您必须将 4 人组放入舞台 table。然后，您必须水平旋转暂存和目标 - 这样您就可以得到 5 列名为 attr_pos1 到 attr_pos5 的列（您的示例中最大的组是 5）。要进行数据透视，您需要一个序列号，我们使用 ROW_NUMBER() 获得该序列号。这适用于 tables、staging 和 target。然后，您将两者都旋转。然后，您尝试加入所有 5 attr_pos# 列的旋转分段和目标，并计算行数。如果你得到 0，你没有重复。如果你得到 1，你有重复。

这是整个场景：

    WITH
    -- input section: a) target table, no dupes
    target(id_comb,attr_pos) AS (
                        SELECT 2,1
    UNION ALL SELECT 2,2
    UNION ALL SELECT 2,3
    UNION ALL SELECT 2,4
    UNION ALL SELECT 3,1
    UNION ALL SELECT 3,2\
UNION ALL SELECT 3,3
UNION ALL SELECT 3,4
UNION ALL SELECT 3,5
UNION ALL SELECT 4,1
UNION ALL SELECT 4,2
UNION ALL SELECT 4,3
)
,
-- input section: b) staging, input, would be a dupe
staging(id_comb,attr_pos) AS (
          SELECT 1,1
UNION ALL SELECT 1,2
UNION ALL SELECT 1,3
UNION ALL SELECT 1,4
)
,
-- query section:
-- add sequence numbers to stage and target
target_s AS (
SELECT 
  ROW_NUMBER() OVER(PARTITION BY id_comb ORDER BY attr_pos) AS seq
, *
FROM target
)
,
staging_s AS (
SELECT 
  ROW_NUMBER() OVER(PARTITION BY id_comb ORDER BY attr_pos) AS seq
, *
FROM staging
)
,
-- horizontally pivot target, NULLS as -1 for later join
target_h AS (
SELECT 
  id_comb
, IFNULL(MAX(CASE seq WHEN 1 THEN attr_pos END),-1) AS attr_pos1
, IFNULL(MAX(CASE seq WHEN 2 THEN attr_pos END),-1) AS attr_pos2
, IFNULL(MAX(CASE seq WHEN 3 THEN attr_pos END),-1) AS attr_pos3
, IFNULL(MAX(CASE seq WHEN 4 THEN attr_pos END),-1) AS attr_pos4
, IFNULL(MAX(CASE seq WHEN 5 THEN attr_pos END),-1) AS attr_pos5
FROM target_s
GROUP BY id_comb ORDER BY id_comb
)
,
-- horizontally pivot staging, NULLS as -1 for later join
staging_h AS (
SELECT 
  id_comb
, IFNULL(MAX(CASE seq WHEN 1 THEN attr_pos END),-1) AS attr_pos1
, IFNULL(MAX(CASE seq WHEN 2 THEN attr_pos END),-1) AS attr_pos2
, IFNULL(MAX(CASE seq WHEN 3 THEN attr_pos END),-1) AS attr_pos3
, IFNULL(MAX(CASE seq WHEN 4 THEN attr_pos END),-1) AS attr_pos4
, IFNULL(MAX(CASE seq WHEN 5 THEN attr_pos END),-1) AS attr_pos5
FROM staging_s
GROUP BY id_comb ORDER BY id_comb
)
SELECT 
  COUNT(*)
FROM target_h
JOIN staging_h USING (
  attr_pos1
, attr_pos2
, attr_pos3
, attr_pos4
, attr_pos5
);

希望这对您有所帮助---- 马可

Answer 2

        -- The data
CREATE TABLE theset (
        set_id INTEGER NOT NULL PRIMARY KEY
        , set_name text UNIQUE
        );
INSERT INTO theset(set_id, set_name) VALUES
( 1, 'one'), ( 2, 'two'), ( 3, 'three'), ( 4, 'four');

CREATE TABLE theitem (
        item_id integer NOT NULL PRIMARY KEY
        , item_name text UNIQUE
        );
INSERT INTO theitem(item_id, item_name) VALUES
( 1, 'one'), ( 2, 'two'), ( 3, 'three'), ( 4, 'four'), ( 5, 'five');

CREATE TABLE set_item (
        set_id integer NOT NULL REFERENCES theset (set_id)
        , item_id integer NOT NULL REFERENCES theitem(item_id)
        , PRIMARY KEY (set_id,item_id)
        );
        -- swapped index is indicated for junction tables
CREATE UNIQUE INDEX ON set_item(item_id, set_id);

INSERT INTO set_item(set_id,item_id) VALUES
(1,1), (1,2), (1,3), (1,4),
(2,1), (2,2), (2,3), -- (2,4),
(3,1), (3,2), (3,3), (3,4), (3,5),
(4,1), (4,2), (4,4);

CREATE FUNCTION set_item_unique_set( ) RETURNS TRIGGER AS
$func$
BEGIN
IF EXISTS ( -- other set
        SELECT * FROM theset oth
        -- WHERE oth.set_id <> NEW.set_id -- only for insert/update
        WHERE TG_OP = 'DELETE' AND oth.set_id <> OLD.set_id
           OR TG_OP <> 'DELETE' AND oth.set_id <> NEW.set_id

        -- count (common) members in the two sets
        -- items not in common will have count=1
        AND NOT EXISTS (
                SELECT item_id FROM set_item x1
                WHERE (x1.set_id = NEW.set_id OR x1.set_id = oth.set_id )
                GROUP BY item_id
                HAVING COUNT(*) = 1
                )

        ) THEN
        RAISE EXCEPTION 'Not unique set';
        RETURN NULL;
ELSE
        RETURN NEW;
END IF;

END;
$func$ LANGUAGE 'plpgsql'
        ;

CREATE CONSTRAINT TRIGGER check_item_set_unique
        AFTER UPDATE OR INSERT OR DELETE
        -- BEFORE UPDATE OR INSERT
        ON set_item
        FOR EACH ROW
        EXECUTE PROCEDURE set_item_unique_set()
        ;

-- Test it
INSERT INTO set_item(set_id,item_id) VALUES(4,5); -- success
INSERT INTO set_item(set_id,item_id) VALUES(2,4); -- failure
DELETE FROM set_item WHERE set_id=1 AND item_id= 4; -- failure

注意：DELETE 案例也应该有触发器。

更新：添加了 DELETE

的处理

（删除的处理并不完美；想象一下删除集合中最后一个元素的情况）

Answer 3

@wildplasser 提出的有趣但不是很有用的解决方案。我创建脚本来插入样本数据：

WITH param AS (
    SELECT 8 AS max
), maxarray AS (
    SELECT array_agg(i) as ma FROM (SELECT generate_series(1, max) as i FROM param) as i
), pre AS (
    SELECT
        *
    FROM (
    SELECT
         *, CASE WHEN (id >> mbit) & 1 = 1 THEN ma[mbit + 1] END AS item_id
     FROM (
            SELECT *,
                generate_series(0, array_upper(ma, 1) - 1) as mbit
            FROM (
                    SELECT *,
                        generate_series(1,(2^max - 1)::int8) AS id
                    FROM param, maxarray
                ) AS pre1
        ) AS pre2
    ) AS pre3
    WHERE item_id IS NOT NULL
), ins_item AS (
    INSERT INTO theitem (item_id, item_name) SELECT i, i::text FROM generate_series(1, (SELECT max FROM param)) as i RETURNING *
), ins_set AS (
INSERT INTO theset (set_id, set_name)
SELECT id, id::text FROM generate_series(1, (SELECT 2^max - 1 FROM param)::int8) as id
RETURNING *
), ins_set_item AS (
INSERT INTO set_item (set_id, item_id)
SELECT id, item_id FROM pre WHERE (SELECT count(*) FROM ins_item) > 0 AND (SELECT count(*) FROM ins_set) > 0
RETURNING *
)
SELECT
    'sets', count(*)
FROM ins_set
UNION ALL
SELECT
    'items', count(*)
FROM ins_item
UNION ALL
SELECT
    'sets_items', count(*)
FROM ins_set_item
;

当我用 8（1024 - 2^8 行 set_item）调用它时，它运行 21 秒。太糟糕了。当我关闭触发器时，它花费了不到 1 毫秒。

我的提议

在这种情况下使用数组非常有趣。不幸的是，PostgreSQL 不支持数组的外键，但它可以通过 TRIGGER 来完成。我删除 set_item table 并为 theset 添加 items int[] 字段：

        -- The data
CREATE TABLE theitem (
        item_id integer NOT NULL PRIMARY KEY
        , item_name text UNIQUE
        );

CREATE TABLE theset (
        set_id INTEGER NOT NULL PRIMARY KEY
        , set_name text UNIQUE
        , items integer[] UNIQUE NOT NULL
        );

CREATE INDEX i1 ON theset USING gin (items);

CREATE OR REPLACE FUNCTION check_item_CU() RETURNS TRIGGER AS $sql$
BEGIN
    IF (SELECT count(*) > 0 FROM unnest(NEW.items) AS u LEFT JOIN theitem ON (item_id = u) WHERE item_id IS NULL) THEN
        RETURN NULL;
    END IF;

    NEW.items = ARRAY(SELECT unnest(NEW.items) ORDER BY 1);

    RETURN NEW;
END;
$sql$ LANGUAGE plpgsql; 

CREATE TRIGGER check_item_CU BEFORE INSERT OR UPDATE ON theset FOR EACH ROW EXECUTE PROCEDURE check_item_CU();

CREATE OR REPLACE FUNCTION check_item_UD() RETURNS TRIGGER AS $sql$
BEGIN
    IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE' AND NEW.item_id != OLD.item_id) AND (SELECT count(*) > 0 FROM theset WHERE OLD.item_id = ANY(items)) THEN
        RAISE EXCEPTION 'item_id % still used', OLD.item_id;
        RETURN NULL;
    END IF;

    RETURN NEW;
END;
$sql$ LANGUAGE plpgsql; 

CREATE TRIGGER check_item_UD BEFORE DELETE OR UPDATE ON theitem FOR EACH ROW EXECUTE PROCEDURE check_item_UD();

WITH param AS (
    SELECT 10 AS max
), maxarray AS (
    SELECT array_agg(i) as ma FROM (SELECT generate_series(1, max) as i FROM param) as i
), pre AS (
    SELECT
        *
    FROM (
    SELECT
         *, CASE WHEN (id >> mbit) & 1 = 1 THEN ma[mbit + 1] END AS item_id
     FROM (
            SELECT *,
                generate_series(0, array_upper(ma, 1) - 1) as mbit
            FROM (
                    SELECT *,
                        generate_series(1,(2^max - 1)::int8) AS id
                    FROM param, maxarray
                ) AS pre1
        ) AS pre2
    ) AS pre3
    WHERE item_id IS NOT NULL
), pre_arr AS (
SELECT id, array_agg(item_id) AS items
FROM pre
GROUP BY 1
), ins_item AS (
    INSERT INTO theitem (item_id, item_name) SELECT i, i::text FROM generate_series(1, (SELECT max FROM param)) as i RETURNING *
), ins_set AS (
INSERT INTO theset (set_id, set_name, items)
SELECT id, id::text, items FROM pre_arr WHERE (SELECT count(*) FROM ins_item) > 0
RETURNING *
)
SELECT
    'sets', count(*)
FROM ins_set
UNION ALL
SELECT
    'items', count(*)
FROM ins_item

;

此变体运行小于 1 毫秒

如何保护 table 以避免重复数据

How to secure table for avoid duplicate data

sql

postgresql

database-design

unique-constraint

relational-division

我的提议