在PostgreSQL中插入表A期间如何有条件地在表B中插入记录？

Question

Given the following structure:

Table A ( aliases ):

user_id | alias 
---------------
   1      john
   2      peter

user_id references id in users .

Table B ( users ):

  id | password_hash | ...
---------------------------
   1        ...        ...
   2        ...        ...

(the idea is that users can have multiple aliases all of which point to the same main user account record)

I would like to do the following operation: given an alias, password, ... record:

• if alias exists in aliases , update the corresponding password in users
• if alias does not exist, create a new user in users with the given password and insert a row into aliases pointing to this new record.

How can I do that in a single query in Postgres?

Something along the lines of

WITH (
  INSERT INTO users(id, password, ...) VALUES(DEFAULT, password, ...) RETURNING id
)
INSERT INTO aliases(user_id, alias) VALUES(id, alias)
  ON CONFLICT {delete the temp row in users and update the one with the 
               known user_id instead}

Answer 1

Note : I'll assume that alias is the primary key (but at least, it's a unique key) of aliases .

Unfortunately, because the unique column ( alias ) is not on the target table (of the UPSERT ), you cannot do this with a single INSERT ... ON CONFLICT ... statement.

First, you'll need to define the foreign key on aliases.user_id (which refers to the users.id column) to be DEFERRABLE (it can be INITIALLY IMMEDIATE though).

After that, these statements should be able to run (despite any concurrent modifications to these tables):

set constraints fk_aliases_user_id deferred;

with params(alias, pwd) as (
  values ('john', 'pass3'),
         ('jane', 'pass4')
),
inserted_alias as (
  insert into aliases(alias, user_id)
  select      alias, coalesce((select user_id
                               from   aliases a
                               where  a.alias = p.alias),
                              nextval('users_id_seq'))
  from        params p
  on conflict (alias) do nothing
  returning   *
)
insert into users(id, password_hash)
select      coalesce(i.user_id, a.user_id),
            crypt(p.pwd, gen_salt('bf'))
from        params p
left join   inserted_alias i using (alias)
left join   aliases a using (alias)
on conflict (id) do update
set         password_hash = excluded.password_hash;

set constraints fk_aliases_user_id immediate;

Notes :

• I used the crypt() function form the pgcrypto module to generate password_hash from plain passwords. I hope you're doing something similar.
• This may cause gaps in the users_id_seq when the concurrency is high, but should always succeed (and I minimized the chances for that with the coalesce() part of the first insert).
• You can leave the set constraints statements, if your foreign key is INITIALLY DEFERRED .

http://rextester.com/YDY89070

Your other option is to use PL/pgSQL and a retry loop (what was the official recommendation before the ON CONFLICT support was added).

Edit : it seems immediate constraints are not checked between CTE boundaries (however, I have not found any evidence for this in the docs, yet), so the set constraints statements & to make the foreign key deferrable is not needed.

http://rextester.com/IUSM65192

Answer 2

This assumes that users_id_seq is the sequence used for users.id and that there is a UNIQUE constraint on aliases.alias :

WITH a AS (INSERT INTO aliases (user_id, alias)
              VALUES (nextval('users_id_seq'), p_alias)
           ON CONFLICT (alias)
              /* this does nothing, but is needed for RETURNING */
              DO UPDATE
                 SET user_id = aliases.user_id
           RETURNING user_id
          )
INSERT INTO users (id, password_hash, ...)
   SELECT user_id, p_password, ...
      FROM a
ON CONFLICT (id)
   DO UPDATE
      SET password_hash = EXCLUDED.password_hash;