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

Eu tenho uma mesa:

CREATE TABLE names (id serial, name varchar(20))

Eu quero o "último ID inserido" dessa tabela, sem usar RETURNING idna inserção. Parece haver uma função CURRVAL(), mas não entendo como usá-la.

Eu tentei com:

SELECT CURRVAL() AS id FROM names_id_seq
SELECT CURRVAL('names_id_seq')
SELECT CURRVAL('names_id_seq'::regclass)

mas nenhum deles funciona. Como posso usar currval()para obter o último ID inserido?

Se você criar uma coluna, o serialPostgreSQL criará 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á nomes 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 confiar na estratégia de nomes que o Postgres usa.

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

Isso é direto do Stack Overflow

Como foi apontado por @a_horse_with_no_name e @Jack Douglas, o 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 entre as sessões, você pode usar o seguinte:

SELECT last_value FROM your_sequence_name;

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

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

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

Então, eu acho que, 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);

Supondo, é claro, que você não terá uma inserção ou qualquer outra maneira de usar o campo serial na sessão atual.

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

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

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

portanto, você não pode encontrar o 'último ID inserido' da sequência, a menos que isso 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 da coluna; portanto, um 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, existem alguns problemas com esses vários métodos:

Currval obtém apenas 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 gatilho e / ou ter a sequência avançada mais de uma vez na transação atual, é não retornará o valor correto. Isso não é um problema para 99% das pessoas por aí - 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 "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:

• Retornar valores 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:

  excluir 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 como (excluir * da tabela A como id de retorno) atualização B set delete = true onde id (selecione id de A);

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

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

Este foi um projeto python flask + postgresql.

Se você deseja obter o valor das seqüências sem ter chamado nextval()e sem precisar modificar a sequência, juntei 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;

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

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.

Versões diferentes do PostgreSQL podem ter funções diferentes para obter o ID da sequência atual ou a próxima.

Primeiro, você precisa conhecer a versão do seu Postgres. Usando a versão selecionada (); para obter a versão.

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

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