Como uso currval() no PostgreSQL para obter o último id inserido?

Isso é direto do Stack Overflow

Como foi apontado por @a_horse_with_no_name e @Jack Douglas, currval funciona apenas com a sessão atual. Portanto, se você concorda com o fato de que o resultado pode ser afetado por uma transação não confirmada de outra sessão e ainda deseja algo que funcione nas sessões, pode usar isto:

SELECT last_value FROM your_sequence_name;

Use o link para SO para obter mais informações.

A partir da documentação do Postgres, porém, é claramente afirmado que

É um erro chamar lastval se nextval ainda não tiver sido chamado na sessão atual.

Então, estritamente falando, para usar corretamente currval ou last_value para uma sequência entre sessões, você precisaria fazer algo assim?

SELECT setval('serial_id_seq',nextval('serial_id_seq')-1);

Assumindo, claro, que você não terá um insert ou qualquer outra forma de usar o campo serial na sessão atual.

Se você criar uma coluna como serialPostgreSQL cria automaticamente uma sequência para isso.

O nome da sequência é gerado automaticamente e é sempre tablename_columnname_seq, no seu caso a sequência será names names_id_seq.

Depois de inserir na tabela, você pode chamar currval()com esse nome de sequência:

postgres=> CREATE TABLE names in schema_name (id serial, name varchar(20));
CREATE TABLE
postgres=> insert into names (name) values ('Arthur Dent');
INSERT 0 1
postgres=> select currval('names_id_seq');
 currval
---------
       1
(1 row)
postgres=>

Em vez de codificar o nome da sequência, você também pode usar pg_get_serial_sequence():

select currval(pg_get_serial_sequence('names', 'id'));

Dessa forma, você não precisa depender da estratégia de nomenclatura que o Postgres usa.

Ou se você não quiser usar o nome da sequência, uselastval()

Você precisa chamar nextvalessa sequência nesta sessão antescurrval :

create sequence serial;
select nextval('serial');
 nextval
---------
       1
(1 row)

select currval('serial');
 currval
---------
       1
(1 row)

então você não pode encontrar o 'último id inserido' da sequência, a menos que insertseja feito na mesma sessão (uma transação pode reverter, mas a sequência não)

como apontado na resposta de a_horse, create tablecom uma coluna do tipo serialcriará automaticamente uma sequência e a usará para gerar o valor padrão para a coluna, portanto, insertnormalmente acessa nextvalimplicitamente:

create table my_table(id serial);
NOTICE:  CREATE TABLE will create implicit sequence "my_table_id_seq" for 
         serial column "my_table.id"

\d my_table
                          Table "stack.my_table"
 Column |  Type   |                       Modifiers
--------+---------+-------------------------------------------------------
 id     | integer | not null default nextval('my_table_id_seq'::regclass)

insert into my_table default values;
select currval('my_table_id_seq');
 currval
---------
       1
(1 row)

Portanto, há alguns problemas com esses vários métodos:

Currval só pega o último valor gerado na sessão atual - o que é ótimo se você não tiver mais nada gerando valores, mas nos casos em que você pode chamar um trigger e/ou ter a sequência avançada mais de uma vez na transação atual é não vai retornar o valor correto. Isso não é um problema para 99% das pessoas lá fora - mas é algo que se deve levar em consideração.

A melhor maneira de obter o identificador exclusivo atribuído após uma operação de inserção é usando a cláusula RETURNING. O exemplo abaixo assume que a coluna vinculada à sequência é chamada de "id":

insert into table A (cola,colb,colc) values ('val1','val2','val3') returning id;

Observe que a utilidade da cláusula RETURNING vai muito além de apenas obter a sequência, pois ela também:

• Valores de retorno que foram usados ​​para a "inserção final" (depois, por exemplo, um gatilho BEFORE pode ter alterado os dados que estão sendo inseridos.)

• Retorne os valores que estavam sendo excluídos:

  delete da tabela A onde id > 100 retornando *

• Retorne as linhas modificadas após um UPDATE:

  atualizar tabela Um conjunto X='y' onde blah='blech' retornando *

• Use o resultado de uma exclusão para uma atualização:

  WITH A as (excluir * da tabela A como id de retorno) atualizar B set delete=true onde id in (selecionar id de A);

No PostgreSQL 11.2 você pode tratar a sequência como uma tabela que parece:

Exemplo se você tiver uma sequência chamada: 'names_id_seq'

select * from names_id_seq;
 last_value | log_cnt | is_called
------------+---------+-----------
          4 |      32 | t
(1 row)

Isso deve fornecer o último id inserido (4 neste caso), o que significa que o valor atual (ou o valor que deve ser usado para o próximo id) deve ser 5.

Eu tive que executar uma consulta apesar de usar SQLALchemy porque não consegui usar currval.

nextId = db.session.execute("select last_value from <table>_seq").fetchone()[0] + 1

Este foi um projeto de frasco python + postgresql.

Se você quiser obter o valor das sequências sem ter chamado nextval(), e sem ter que modificar a sequência, montei uma função PL/pgSQL para lidar com isso: Encontre o valor de todas as sequências do banco de dados

Você precisa GRANTusar no esquema, assim:

GRANT USAGE ON SCHEMA schema_name to user;

e

GRANT ALL PRIVILEGES ON schema_name.sequence_name TO user;

select  *, 'select '''||secuencia||''' as secuencia, nextval('''||secuencia||''') as currentval, (select max('||campo||') from '||tabla||') as maxtabla UNION ALL ' as sentencia from (
select 
relname as secuencia
, substr(relname,0, strpos(relname, SPLIT_PART(relname, '_', nseparadores))-1 ) as tabla -- tabla sobre el que hace referencia la secuencia
--, strpos(relname, SPLIT_PART(relname, '_', nseparadores)) as posicion_campo --posición donde comienza el nombre del campo
,SPLIT_PART(relname, '_', nseparadores) as campo -- campo sobre el que hace referencia la secuencia
from (
select nspname, relname, length(relname) - length(replace(relname, '_', '')) as nseparadores  from pg_class c join pg_namespace n on c.relnamespace=n.oid where relkind = 'S' order by nspname
) sentencia01
) sentencia02

Diferentes versões do PostgreSQL podem ter funções diferentes para obter o ID de sequência atual ou seguinte.

Primeiro, você precisa saber a versão do seu Postgres. Usando select version(); para obter a versão.

No PostgreSQL 8.2.15, você obtém o id de sequência atual usando select last_value from schemaName.sequence_name.

Se a declaração acima não funcionar, você pode usarselect currval('schemaName.sequence_name');