Como redefinir a sequência no postgres e preencher a coluna de identificação com novos dados?

Eu tenho uma mesa com mais de um milhão de linhas. Preciso redefinir a sequência e reatribuir a coluna id com novos valores (1, 2, 3, 4 ... etc ...). Existe alguma maneira fácil de fazer isso?

Se você não deseja manter a ordem dos IDs, pode

ALTER SEQUENCE seq RESTART WITH 1;
UPDATE t SET idcolumn=nextval('seq');

Duvido que exista uma maneira fácil de fazer isso na ordem de sua escolha, sem recriar toda a tabela.

Com o PostgreSQL 8.4 ou mais recente, não há mais a necessidade de especificar WITH 1. O valor inicial que foi registrado CREATE SEQUENCEou o último definido por ALTER SEQUENCE START WITHserá usado (provavelmente será 1).

Redefina a sequência:

ALTER SEQUENCE seq RESTART;

Atualize a coluna ID da tabela:

UPDATE foo SET id = DEFAULT;

Fonte: Docs do PostgreSQL

Redefina a sequência:

SELECT setval('sequence_name', 0);

Atualizando registros atuais:

UPDATE foo SET id = DEFAULT;

Ambas as soluções fornecidas não funcionaram para mim;

> SELECT setval('seq', 0);
ERROR:  setval: value 0 is out of bounds for sequence "seq" (1..9223372036854775807)

setval('seq', 1)inicia a numeração com 2 e também ALTER SEQUENCE seq START 1a numeração com 2, porque seq.is_called é verdadeiro (Postgres versão 9.0.4)

A solução que funcionou para mim é:

> ALTER SEQUENCE seq RESTART WITH 1;
> UPDATE foo SET id = DEFAULT;

Apenas para simplificar e esclarecer o uso adequado do setter ALTER SEQUENCE e SELECT para redefinir a sequência:

ALTER SEQUENCE sequence_name RESTART WITH 1;

é equivalente a

SELECT setval('sequence_name', 1, FALSE);

Qualquer uma das instruções pode ser usada para redefinir a sequência e você pode obter o próximo valor por nextval ('sequence_name'), como indicado aqui também:

nextval('sequence_name')

A melhor maneira de redefinir uma sequência para começar com o número 1 é executar o seguinte:

ALTER SEQUENCE <tablename>_<id>_seq RESTART WITH 1

Portanto, por exemplo, para a tabela de usuários, seria:

ALTER SEQUENCE users_id_seq RESTART WITH 1

Para manter a ordem das linhas:

UPDATE thetable SET rowid=col_serial FROM 
(SELECT rowid, row_number() OVER ( ORDER BY lngid) AS col_serial FROM thetable ORDER BY lngid) AS t1 
WHERE thetable.rowid=t1.rowid;

FYI: se você precisar especificar um novo valor inicial entre um intervalo de IDs (256 - 10000000, por exemplo):

SELECT setval('"Sequence_Name"', 
       (SELECT coalesce(MAX("ID"),255) 
           FROM "Table_Name" 
           WHERE "ID" < 10000000 and "ID" >= 256)+1
       ); 

Apenas redefinir a sequência e atualizar todas as linhas pode causar erros de identificação duplicados. Em muitos casos, você precisa atualizar todas as linhas duas vezes. Primeiro com IDs mais altos para evitar duplicatas, depois com os IDs que você realmente deseja.

Evite adicionar uma quantia fixa a todos os IDs (como recomendado em outros comentários). O que acontece se você tiver mais linhas que esse valor fixo? Supondo que o próximo valor da sequência seja maior que todos os IDs das linhas existentes (você só deseja preencher as lacunas), eu faria assim:

UPDATE table SET id = DEFAULT;
ALTER SEQUENCE seq RESTART;
UPDATE table SET id = DEFAULT;

No meu caso, consegui isso com:

ALTER SEQUENCE table_tabl_id_seq RESTART WITH 6;

Onde minha tabela se chama table

Inspirado pelas outras respostas aqui, criei uma função SQL para fazer uma migração de sequência. A função move uma sequência de teclas primárias para uma nova sequência contígua iniciando com qualquer valor (> = 1) dentro ou fora do intervalo de sequências existente.

Explico aqui como usei essa função na migração de dois bancos de dados com o mesmo esquema, mas com valores diferentes em um banco de dados.

Primeiro, a função (que imprime os comandos SQL gerados para que fique claro o que realmente está acontecendo):

CREATE OR REPLACE FUNCTION migrate_pkey_sequence
  ( arg_table      text
  , arg_column     text
  , arg_sequence   text
  , arg_next_value bigint  -- Must be >= 1
  )
RETURNS int AS $$
DECLARE
  result int;
  curr_value bigint = arg_next_value - 1;
  update_column1 text := format
    ( 'UPDATE %I SET %I = nextval(%L) + %s'
    , arg_table
    , arg_column
    , arg_sequence
    , curr_value
    );
  alter_sequence text := format
    ( 'ALTER SEQUENCE %I RESTART WITH %s'
    , arg_sequence
    , arg_next_value
    );
  update_column2 text := format
    ( 'UPDATE %I SET %I = DEFAULT'
    , arg_table
    , arg_column
    );
  select_max_column text := format
    ( 'SELECT coalesce(max(%I), %s) + 1 AS nextval FROM %I'
    , arg_column
    , curr_value
    , arg_table
    );
BEGIN
  -- Print the SQL command before executing it.
  RAISE INFO '%', update_column1;
  EXECUTE update_column1;
  RAISE INFO '%', alter_sequence;
  EXECUTE alter_sequence;
  RAISE INFO '%', update_column2;
  EXECUTE update_column2;
  EXECUTE select_max_column INTO result;
  RETURN result;
END $$ LANGUAGE plpgsql;

A função migrate_pkey_sequenceaceita os seguintes argumentos:

1. arg_table: nome da tabela (por exemplo 'example')
2. arg_column: nome da coluna da chave primária (por exemplo 'id')
3. arg_sequence: nome da sequência (por exemplo 'example_id_seq')
4. arg_next_value: próximo valor para a coluna após a migração

Ele executa as seguintes operações:

1. Mova os valores da chave primária para um intervalo livre. Suponho que se nextval('example_id_seq')segue max(id)e que a sequência começa com 1. Isso também lida com o caso em que arg_next_value > max(id).
2. Mova os valores da chave primária para o intervalo contíguo que começa com arg_next_value. A ordem dos valores-chave é preservada, mas os furos no intervalo não são preservados.
3. Imprima o próximo valor a seguir na sequência. Isso é útil se você deseja migrar as colunas de outra tabela e mesclar com esta.

Para demonstrar, usamos uma sequência e uma tabela definidas da seguinte forma (por exemplo, usando psql):

# CREATE SEQUENCE example_id_seq
  START WITH 1
  INCREMENT BY 1
  NO MINVALUE
  NO MAXVALUE
  CACHE 1;

# CREATE TABLE example
  ( id bigint NOT NULL DEFAULT nextval('example_id_seq'::regclass)
  );

Em seguida, inserimos alguns valores (começando, por exemplo, em 3):

# ALTER SEQUENCE example_id_seq RESTART WITH 3;
# INSERT INTO example VALUES (DEFAULT), (DEFAULT), (DEFAULT);
-- id: 3, 4, 5

Por fim, migramos os example.idvalores para começar com 1.

# SELECT migrate_pkey_sequence('example', 'id', 'example_id_seq', 1);
INFO:  00000: UPDATE example SET id = nextval('example_id_seq') + 0
INFO:  00000: ALTER SEQUENCE example_id_seq RESTART WITH 1
INFO:  00000: UPDATE example SET id = DEFAULT
 migrate_pkey_sequence
-----------------------
                     4
(1 row)

O resultado:

# SELECT * FROM example;
 id
----
  1
  2
  3
(3 rows)

Mesmo a coluna de incremento automático não é PK (neste exemplo, é chamada seq - também conhecida como sequência), você pode conseguir isso com um gatilho:

DROP TABLE SE EXISTE devops_guide CASCADE;

SELECT 'create the "devops_guide" table'
;
   CREATE TABLE devops_guide (
      guid           UUID NOT NULL DEFAULT gen_random_uuid()
    , level          integer NULL
    , seq            integer NOT NULL DEFAULT 1
    , name           varchar (200) NOT NULL DEFAULT 'name ...'
    , description    text NULL
    , CONSTRAINT pk_devops_guide_guid PRIMARY KEY (guid)
    ) WITH (
      OIDS=FALSE
    );

-- START trg_devops_guide_set_all_seq
CREATE OR REPLACE FUNCTION fnc_devops_guide_set_all_seq()
    RETURNS TRIGGER
    AS $$
       BEGIN
         UPDATE devops_guide SET seq=col_serial FROM
         (SELECT guid, row_number() OVER ( ORDER BY seq) AS col_serial FROM devops_guide ORDER BY seq) AS tmp_devops_guide
         WHERE devops_guide.guid=tmp_devops_guide.guid;

         RETURN NEW;
       END;
    $$ LANGUAGE plpgsql;

 CREATE TRIGGER trg_devops_guide_set_all_seq
  AFTER UPDATE OR DELETE ON devops_guide
  FOR EACH ROW
  WHEN (pg_trigger_depth() < 1)
  EXECUTE PROCEDURE fnc_devops_guide_set_all_seq();

Se você estiver usando o pgAdmin3, expanda 'Sequências', clique com o botão direito do mouse em uma sequência, vá para 'Propriedades' e, na guia 'Definição', altere 'Valor atual' para o valor que desejar. Não há necessidade de uma consulta.