J'ai une petite table (~ 30 lignes) dans ma base de données Postgres 9.0 avec un champ d'ID entier (la clé primaire) qui contient actuellement des entiers séquentiels uniques commençant à 1, mais qui n'a pas été créé à l'aide du mot-clé 'serial'.

Comment puis-je modifier cette table de sorte qu'à partir de maintenant, les insertions dans cette table provoquent le comportement de ce champ comme s'il avait été créé avec 'serial' comme type?

Regardez les commandes suivantes (en particulier le bloc commenté).

DROP TABLE foo;
DROP TABLE bar;

CREATE TABLE foo (a int, b text);
CREATE TABLE bar (a serial, b text);

INSERT INTO foo (a, b) SELECT i, 'foo ' || i::text FROM generate_series(1, 5) i;
INSERT INTO bar (b) SELECT 'bar ' || i::text FROM generate_series(1, 5) i;

-- blocks of commands to turn foo into bar
CREATE SEQUENCE foo_a_seq;
ALTER TABLE foo ALTER COLUMN a SET DEFAULT nextval('foo_a_seq');
ALTER TABLE foo ALTER COLUMN a SET NOT NULL;
ALTER SEQUENCE foo_a_seq OWNED BY foo.a;    -- 8.2 or later

SELECT MAX(a) FROM foo;
SELECT setval('foo_a_seq', 5);  -- replace 5 by SELECT MAX result

INSERT INTO foo (b) VALUES('teste');
INSERT INTO bar (b) VALUES('teste');

SELECT * FROM foo;
SELECT * FROM bar;

Vous pouvez également utiliser START WITHpour démarrer une séquence à partir d'un point particulier, bien que setval accomplisse la même chose, comme dans la réponse d'Euler, par exemple,

SELECT MAX(a) + 1 FROM foo;
CREATE SEQUENCE foo_a_seq START WITH 12345; -- replace 12345 with max above
ALTER TABLE foo ALTER COLUMN a SET DEFAULT nextval('foo_a_seq');

TL; DR

Voici une version où vous n'avez pas besoin d'un humain pour lire une valeur et la saisir lui-même.

CREATE SEQUENCE foo_a_seq OWNED BY foo.a;
SELECT setval('foo_a_seq', coalesce(max(a), 0) + 1, false) FROM foo;
ALTER TABLE foo ALTER COLUMN a SET DEFAULT nextval('foo_a_seq'); 

Une autre option serait d'utiliser le Functionpartage réutilisable à la fin de cette réponse.

Une solution non interactive

Il suffit d'ajouter aux deux autres réponses, pour ceux d'entre nous qui ont besoin de Sequencecréer ces s par un script non interactif , tout en corrigeant une base de données en direct par exemple.

Autrement dit, lorsque vous ne voulez pas SELECTla valeur manuellement et tapez-la vous-même dans une CREATEinstruction ultérieure .

Bref, vous ne pouvez pas faire:

CREATE SEQUENCE foo_a_seq
    START WITH ( SELECT max(a) + 1 FROM foo );

... puisque la START [WITH]clause in CREATE SEQUENCEattend une valeur , pas une sous-requête.

Note: En règle générale, applicable à tous les non-CRUD ( c. -à- : autre chose que INSERT, SELECT, UPDATE, DELETE) les déclarations pgSQL AFAIK.

Mais setval()oui! Ainsi, ce qui suit est absolument parfait:

SELECT setval('foo_a_seq', max(a)) FROM foo;

S'il n'y a pas de données et que vous ne (voulez) pas le savoir, utilisez coalesce()pour définir la valeur par défaut:

SELECT setval('foo_a_seq', coalesce(max(a), 0)) FROM foo;
--                         ^      ^         ^
--                       defaults to:       0

Cependant, avoir la valeur de séquence actuelle définie sur 0est maladroit, voire illégal.
L'utilisation de la forme à trois paramètres de setvalserait plus appropriée:

--                                             vvv
SELECT setval('foo_a_seq', coalesce(max(a), 0) + 1, false) FROM foo;
--                                                  ^   ^
--                                                is_called

La définition du troisième paramètre optionnel de setvalto falseempêchera le suivant nextvald'avancer la séquence avant de renvoyer une valeur, et donc:

le suivant nextvalrenverra exactement la valeur spécifiée et l'avancement de la séquence commence par ce qui suit nextval.

- à partir de cette entrée dans la documentation

Sur une note non liée, vous pouvez également spécifier la colonne possédant Sequencedirectement avec CREATE, vous n'avez pas à la modifier plus tard:

CREATE SEQUENCE foo_a_seq OWNED BY foo.a;

En résumé:

CREATE SEQUENCE foo_a_seq OWNED BY foo.a;
SELECT setval('foo_a_seq', coalesce(max(a), 0) + 1, false) FROM foo;
ALTER TABLE foo ALTER COLUMN a SET DEFAULT nextval('foo_a_seq'); 

Utilisant un Function

Sinon, si vous prévoyez de le faire pour plusieurs colonnes, vous pouvez opter pour l'utilisation d'un fichier réel Function.

CREATE OR REPLACE FUNCTION make_into_serial(table_name TEXT, column_name TEXT) RETURNS INTEGER AS $$
DECLARE
    start_with INTEGER;
    sequence_name TEXT;
BEGIN
    sequence_name := table_name || '_' || column_name || '_seq';
    EXECUTE 'SELECT coalesce(max(' || column_name || '), 0) + 1 FROM ' || table_name
            INTO start_with;
    EXECUTE 'CREATE SEQUENCE ' || sequence_name ||
            ' START WITH ' || start_with ||
            ' OWNED BY ' || table_name || '.' || column_name;
    EXECUTE 'ALTER TABLE ' || table_name || ' ALTER COLUMN ' || column_name ||
            ' SET DEFAULT nextVal(''' || sequence_name || ''')';
    RETURN start_with;
END;
$$ LANGUAGE plpgsql VOLATILE;

Utilisez-le comme ceci:

INSERT INTO foo (data) VALUES ('asdf');
-- ERROR: null value in column "a" violates not-null constraint

SELECT make_into_serial('foo', 'a');
INSERT INTO foo (data) VALUES ('asdf');
-- OK: 1 row(s) affected