Crea PostgreSQL ROLE (utente) se non esiste

Come scrivo uno script SQL per creare un RUOLO in PostgreSQL 9.1, ma senza generare un errore se esiste già?

Lo script corrente ha semplicemente:

CREATE ROLE my_user LOGIN PASSWORD 'my_password';

Questo fallisce se l'utente esiste già. Vorrei qualcosa del tipo:

IF NOT EXISTS (SELECT * FROM pg_user WHERE username = 'my_user')
BEGIN
    CREATE ROLE my_user LOGIN PASSWORD 'my_password';
END;

... ma non funziona - IFnon sembra essere supportato in SQL semplice.

Ho un file batch che crea un database PostgreSQL 9.1, un ruolo e poche altre cose. Chiama psql.exe, passando il nome di uno script SQL da eseguire. Finora tutti questi script sono semplici SQL e vorrei evitare PL / pgSQL e simili, se possibile.

Semplifica in modo simile a quello che avevi in ​​mente:

DO
$do$
BEGIN
   IF NOT EXISTS (
      SELECT FROM pg_catalog.pg_roles  -- SELECT list can be empty for this
      WHERE  rolname = 'my_user') THEN

      CREATE ROLE my_user LOGIN PASSWORD 'my_password';
   END IF;
END
$do$;

(Basandosi sulla risposta di @a_horse_with_no_name e migliorato con il commento di @ Gregory .)

A differenza, ad esempio, con CREATE TABLEnon esiste una IF NOT EXISTSclausola per CREATE ROLE(fino ad almeno pg 12). E non è possibile eseguire istruzioni DDL dinamiche in semplice SQL.

La tua richiesta di "evitare PL / pgSQL" è impossibile se non utilizzando un altro PL. L' DOistruzione utilizza plpgsql come linguaggio procedurale predefinito. La sintassi consente di omettere la dichiarazione esplicita:

DO [ LANGUAGE lang_name ] code
... Il nome della lingua procedurale in cui è scritto il codice. Se omesso, il valore predefinito è .
lang_name
plpgsql

La risposta accettata soffre di una condizione di competizione se due di tali script vengono eseguiti contemporaneamente sullo stesso cluster Postgres (server DB), come è comune negli ambienti di integrazione continua .

In genere è più sicuro provare a creare il ruolo e affrontare con garbo i problemi durante la creazione:

DO $$
BEGIN
  CREATE ROLE my_role WITH NOLOGIN;
  EXCEPTION WHEN DUPLICATE_OBJECT THEN
  RAISE NOTICE 'not creating role my_role -- it already exists';
END
$$;

O se il ruolo non è il proprietario di alcun oggetto db, è possibile utilizzare:

DROP ROLE IF EXISTS my_user;
CREATE ROLE my_user LOGIN PASSWORD 'my_password';

Ma solo se l'eliminazione di questo utente non causerà alcun danno.

Alternativa Bash (per script Bash ):

psql -h localhost -U postgres -tc \
"SELECT 1 FROM pg_user WHERE usename = 'my_user'" \
| grep -q 1 \
|| psql -h localhost -U postgres \
-c "CREATE ROLE my_user LOGIN PASSWORD 'my_password';"

(non è la risposta per la domanda! è solo per coloro che possono essere utili)

Ecco una soluzione generica che utilizza plpgsql:

CREATE OR REPLACE FUNCTION create_role_if_not_exists(rolename NAME) RETURNS TEXT AS
$$
BEGIN
    IF NOT EXISTS (SELECT * FROM pg_roles WHERE rolname = rolename) THEN
        EXECUTE format('CREATE ROLE %I', rolename);
        RETURN 'CREATE ROLE';
    ELSE
        RETURN format('ROLE ''%I'' ALREADY EXISTS', rolename);
    END IF;
END;
$$
LANGUAGE plpgsql;

Uso:

posgres=# SELECT create_role_if_not_exists('ri');
 create_role_if_not_exists 
---------------------------
 CREATE ROLE
(1 row)
posgres=# SELECT create_role_if_not_exists('ri');
 create_role_if_not_exists 
---------------------------
 ROLE 'ri' ALREADY EXISTS
(1 row)

Alcune risposte suggeriscono di utilizzare il pattern: controlla se il ruolo non esiste e in caso contrario emetti il CREATE ROLEcomando. Questo ha uno svantaggio: le condizioni di gara. Se qualcun altro crea un nuovo ruolo tra il controllo e l'emissione del CREATE ROLEcomando, CREATE ROLEovviamente fallisce con un errore fatale.

Per risolvere il problema di cui sopra, più altre risposte già menzionate nell'uso PL/pgSQL, emettendo CREATE ROLEincondizionatamente e quindi intercettando le eccezioni da quella chiamata. C'è solo un problema con queste soluzioni. Eliminano silenziosamente qualsiasi errore, inclusi quelli che non sono generati dal fatto che il ruolo esiste già. CREATE ROLEpuò generare anche altri errori e la simulazione IF NOT EXISTSdovrebbe tacitare solo l'errore quando il ruolo esiste già.

CREATE ROLEgenera un duplicate_objecterrore quando il ruolo esiste già. E il gestore delle eccezioni dovrebbe rilevare solo questo errore. Come menzionato in altre risposte, è una buona idea convertire l'errore fatale in semplice avviso. Altri IF NOT EXISTScomandi PostgreSQL si aggiungono , skippingal loro messaggio, quindi per coerenza lo aggiungo anche qui.

Ecco il codice SQL completo per la simulazione CREATE ROLE IF NOT EXISTScon l'eccezione corretta e la propagazione sqlstate:

DO $$
BEGIN
CREATE ROLE test;
EXCEPTION WHEN duplicate_object THEN RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
END
$$;

Uscita di prova (chiamata due volte tramite DO e poi direttamente):

$ sudo -u postgres psql
psql (9.6.12)
Type "help" for help.

postgres=# \set ON_ERROR_STOP on
postgres=# \set VERBOSITY verbose
postgres=# 
postgres=# DO $$
postgres$# BEGIN
postgres$# CREATE ROLE test;
postgres$# EXCEPTION WHEN duplicate_object THEN RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
postgres$# END
postgres$# $$;
DO
postgres=# 
postgres=# DO $$
postgres$# BEGIN
postgres$# CREATE ROLE test;
postgres$# EXCEPTION WHEN duplicate_object THEN RAISE NOTICE '%, skipping', SQLERRM USING ERRCODE = SQLSTATE;
postgres$# END
postgres$# $$;
NOTICE:  42710: role "test" already exists, skipping
LOCATION:  exec_stmt_raise, pl_exec.c:3165
DO
postgres=# 
postgres=# CREATE ROLE test;
ERROR:  42710: role "test" already exists
LOCATION:  CreateRole, user.c:337

Dato che sei su 9.x, puoi racchiuderlo in un'istruzione DO:

do 
$body$
declare 
  num_users integer;
begin
   SELECT count(*) 
     into num_users
   FROM pg_user
   WHERE usename = 'my_user';

   IF num_users = 0 THEN
      CREATE ROLE my_user LOGIN PASSWORD 'my_password';
   END IF;
end
$body$
;

Il mio team stava riscontrando una situazione con più database su un server, a seconda del database a cui ti connetti, il RUOLO in questione non è stato restituito da SELECT * FROM pg_catalog.pg_user, come proposto da @ erwin-brandstetter e @a_horse_with_no_name. Il blocco condizionale viene eseguito e noi premiamo role "my_user" already exists.

Sfortunatamente non siamo sicuri delle condizioni esatte, ma questa soluzione aggira il problema:

        DO  
        $body$
        BEGIN
            CREATE ROLE my_user LOGIN PASSWORD 'my_password';
        EXCEPTION WHEN others THEN
            RAISE NOTICE 'my_user role exists, not re-creating';
        END
        $body$

Probabilmente potrebbe essere reso più specifico per escludere altre eccezioni.

Puoi farlo nel tuo file batch analizzando l'output di:

SELECT * FROM pg_user WHERE usename = 'my_user'

e poi di psql.exenuovo in esecuzione se il ruolo non esiste.

La stessa soluzione di Simulate CREATE DATABASE IF NOT EXISTS per PostgreSQL? dovrebbe funzionare - invia un CREATE USER …a \gexec.

Soluzione alternativa dall'interno di psql

SELECT 'CREATE USER my_user'
WHERE NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'my_user')\gexec

Soluzione alternativa dalla shell

echo "SELECT 'CREATE USER my_user' WHERE NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'my_user')\gexec" | psql

Vedi la risposta accettata lì per maggiori dettagli.