Question

I have a situation where I need to ensure that there is only one active record with the same object_id and user_id at any time. Here is a representative table:

CREATE TABLE actions (
    id SERIAL PRIMARY KEY,
    object_id integer,
    user_id integer,
    active boolean default true,
    created_at timestamptz default now()
);

By only one active record at a time, I mean you could have a sequence of inserts like the following:

insert into actions (object_id, user_id, active) values (1, 1, true);
insert into actions (object_id, user_id, active) values (1, 1, false);

but doing a subsequent

insert into actions (object_id, user_id, active) values (1, 1, true);

should fail because at this point in time, there already exists 1 active tuple with object_id = 1 and user_id = 1.

I’m using PostgreSQL 8.4.

I saw this post which looks interesting, but its Oracle specific.

I also saw this post but it requires more care regarding the transaction isolation level. I don’t think it would work as-is in read committed mode.

My question is what other options are available to unsure this kind of constraint?

Edit: Removed the third insert in the first set. I think it was confusing the example. I also added the created_at time stamp to help with the context. To reiterate, there can be multiple (object_id, user_id, false) tuples, but only one (object_id, user_id, true) tuple.

Update: I accepted Craig’s answer, but for others who may stumble upon something similar, here is another possible (though suboptimal) solution.

CREATE TABLE action_consistency (
    object_id integer,
    user_id integer,
    count integer default 0,
    primary key (object_id, user_id),
    check (count >= 0 AND count <= 1)
);


CREATE OR REPLACE FUNCTION keep_action_consistency()
  RETURNS TRIGGER AS
$BODY$
    BEGIN

    IF NEW.active THEN
        UPDATE action_consistency
        SET count = count + 1
        WHERE object_id = NEW.object_id AND
        user_id   = NEW.user_id;

        INSERT INTO action_consistency (object_id, user_id, count)
        SELECT NEW.object_id, NEW.user_id, 1
        WHERE NOT EXISTS (SELECT 1 
                          FROM action_consistency
                          WHERE object_id = NEW.object_id AND
                                user_id   = NEW.user_id);
    ELSE
        -- assuming insert will be active for simplicity
        UPDATE action_consistency
        SET count = count - 1
        WHERE object_id = NEW.object_id AND
        user_id   = NEW.user_id;
    END IF;

    RETURN NEW;

    END;
$BODY$
LANGUAGE plpgsql;

CREATE TRIGGER ensure_action_consistency AFTER INSERT OR UPDATE ON actions
    FOR EACH ROW EXECUTE PROCEDURE keep_action_consistency();

It requires the use of a tracking table. For what I hope are obvious reasons, this is not at all desirable. It means that you have an additional row each distinct (object_id, user_id) in actions.

Another reason why I accepted @Craig Ringer’s answer is that there are foreign key references to actions.id in other tables that are also rendered inactive when a given action tuple changes state. This why the history table is less ideal in this scenario. Thank you for the comments and answers.

Answer 1

Given your specification that you want to limit only one entry to being active at a time, try:

CREATE TABLE actions (
    id SERIAL PRIMARY KEY,
    object_id integer,
    user_id integer,
    active boolean default true,
    created_at timestamptz default now()
);

CREATE UNIQUE INDEX actions_unique_active_y ON actions(object_id,user_id) WHERE (active = 't');

This is a partial unique index, a PostgreSQL specific feature – see partial indexes. It constrains the set such that only one (object_id,user_id) tuple may exist where active is true.

While that strictly answers your question as you explained further in comments, I think wildplasser’s answer describes the more correct choice and best approach.