Listar os privilégios do banco de dados usando o psql

postgres=> \l
                                  List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges   
-----------+----------+----------+-------------+-------------+-----------------------
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres

Os documentos sobre Privilégios fornecem uma explicação de como interpretar a saída. Para privilégios específicos em uma tabela do banco de dados atual, use \z myTable.

talvez você queira listar usuários e seus privilégios para um banco de dados - não posso dizer com a pergunta:

postgres=> \du
                             List of roles
    Role name    |  Attributes  |                    Member of
-----------------+--------------+------------------------------------------------
 dba             | Create role  | {util_user,helpdesk_user,helpdesk_admin}
 helpdesk_admin  | Cannot login | {helpdesk_user}
 helpdesk_user   | Cannot login | {helpdesk_reader}
 jack            |              | {helpdesk_admin}
 postgres        | Superuser    | {}
                 : Create role
                 : Create DB

Você pode fazer isso seguindo:

SELECT grantee, privilege_type 
FROM information_schema.role_table_grants 
WHERE table_name='mytable'

Isso lhe dá este tipo de saída:

mail=# select grantee, privilege_type from information_schema.role_table_grants where table_name='aliases';
   grantee    |  privilege_type
--------------+-----------------
 mailreader   |  INSERT
 mailreader   |  SELECT
 mailreader   |  UPDATE
 mailreader   |  DELETE
 mailreader   |  TRUNCATE
 mailreader   |  REFERENCES
 mailreader   |  TRIGGER
(7 rows)

mail=#

Usando psqlmeta-comandos:

https://www.postgresql.org/docs/current/static/app-psql.html

Percorrer a página com Ctrl + F dá:

\ddp [ pattern ] Lista as configurações de privilégio de acesso padrão.

\dp [ pattern ]Lista tabelas, visualizações e sequências com seus privilégios de acesso associados.

\l[+] [ pattern ]Liste os bancos de dados no servidor e mostre .... privilégios de acesso.

Também mencionado acima, mas não encontrado com a palavra "privilégios" na página de manual:

\du+para funções com login e \dg+para funções sem - terá um arquivo "Member of"onde você encontra funções concedidas a funções.

Eu deliberadamente pulo privilégios de função e idioma aqui, encontrados no psqlmanual como mal manipulados (e se você usar esses privilégios, não virá aqui para um conselho). mesmo para tipos definidos pelo usuário, domínios e assim por diante - usar "+" após o meta-comando mostrará privilégios, se aplicável.

Uma maneira um pouco extrema de verificar os privilégios é descartar o usuário na transação, por exemplo:

s=# begin; drop user x;
BEGIN
Time: 0.124 ms
ERROR:  role "x" cannot be dropped because some objects depend on it
DETAIL:  privileges for type "SO dT"
privileges for sequence so
privileges for schema bin
privileges for table xx
privileges for table "csTest"
privileges for table tmp_x
privileges for table s1
privileges for table test
Time: 0.211 ms
s=# rollback;
ROLLBACK
Time: 0.150 ms

Quando a lista é maior que N, (pelo menos em 9.3), o aviso com a lista de privilégios é recolhido, mas você ainda pode encontrá-lo cheio nos logs...

Undercovers psql usa a consulta abaixo quando você emite o \ducomando.

SELECT r.rolname, r.rolsuper, r.rolinherit,
  r.rolcreaterole, r.rolcreatedb, r.rolcanlogin,
  r.rolconnlimit, r.rolvaliduntil,
  ARRAY(SELECT b.rolname
        FROM pg_catalog.pg_auth_members m
        JOIN pg_catalog.pg_roles b ON (m.roleid = b.oid)
        WHERE m.member = r.oid) as memberof
, r.rolreplication
, r.rolbypassrls
FROM pg_catalog.pg_roles r
WHERE r.rolname !~ '^pg_'
ORDER BY 1;

É assim que você pode listar todos os privilégios de uma função (concedido):

SELECT grantor, grantee, table_schema, table_name, privilege_type
FROM information_schema.table_privileges
WHERE grantee = 'myuser'

Vai resultar em:

 grantor  | grantee  | table_schema | table_name | privilege_type
----------+----------+--------------+------------+----------------
 postgres | myuser   | myapp        | employees  | INSERT
 postgres | myuser   | myapp        | employees  | SELECT
 postgres | myuser   | myapp        | employees  | UPDATE
 postgres | myuser   | myapp        | employees  | DELETE

Funciona no PG 10

Uma etapa adicional (possivelmente óbvia) é se tornar o usuário postgres, caso contrário, você poderá obter erros sobre funções não existentes.

sudo su - postgres
psql -l

ou

psql
postgres=> \l

Esta é a minha consulta composta por várias respostas sobre esta pergunta:

SELECT grantee AS user, CONCAT(table_schema, '.', table_name) AS table, 
    CASE 
        WHEN COUNT(privilege_type) = 7 THEN 'ALL'
        ELSE ARRAY_TO_STRING(ARRAY_AGG(privilege_type), ', ')
    END AS grants
FROM information_schema.role_table_grants
GROUP BY table_name, table_schema, grantee;

Isso resulta em algo assim:

+------+--------------+----------------+
| user |    table     |     grants     |
+------+--------------+----------------+
| foo  | schema.table | ALL            |
| bar  | schema.table | SELECT, INSERT |
+------+--------------+----------------+

Você pode inserir seguindo:

SELECT * FROM pg_roles;

e você vai conseguir

rolname | rolsuper | rolinherit | rolcreaterole | rolcreatedb | rolcanlogin | rolreplication | rolconnlimit | rolpassword | rolvaliduntil | rolbypassrls | rolconfig | oid

talvez aqui você pense que há muitos papéis e, desta vez, você pode usar WHERE para selecionar qual papel deseja ver

SELECT * FROM pg_roles WHERE rolname='your role name';

Na verdade, você também pode simplesmente inserir

\du

e você verá todas as funções que criou em vez do padrão

listar proprietários de banco de dados

select d.datname, r.rolname
from pg_catalog.pg_database d, pg_catalog.pg_roles r
where d.datdba = r.oid;

docs: pg_database e pg_roles

relacionado: teste para um privilégio específico:

select has_database_privilege('dbname', 'CREATE');

docs: has_database_privilege ( via )