Aggiunta di un nuovo valore a un tipo ENUM esistente

Ho una colonna della tabella che utilizza un enumtipo. Vorrei aggiornare quel enumtipo per avere un ulteriore valore possibile. Non voglio eliminare alcun valore esistente, basta aggiungere il nuovo valore. Qual è il modo più semplice per farlo?

NOTA se stai usando PostgreSQL 9.1 o versioni successive e sei d'accordo con le modifiche al di fuori di una transazione, vedi questa risposta per un approccio più semplice.

Ho avuto lo stesso problema qualche giorno fa e ho trovato questo post. Quindi la mia risposta può essere utile per qualcuno che sta cercando una soluzione :)

Se hai solo una o due colonne che usano il tipo enum che vuoi cambiare, puoi provare questo. Inoltre è possibile modificare l'ordine dei valori nel nuovo tipo.

-- 1. rename the enum type you want to change
alter type some_enum_type rename to _some_enum_type;
-- 2. create new type
create type some_enum_type as enum ('old', 'values', 'and', 'new', 'ones');
-- 3. rename column(s) which uses our enum type
alter table some_table rename column some_column to _some_column;
-- 4. add new column of new type
alter table some_table add some_column some_enum_type not null default 'new';
-- 5. copy values to the new column
update some_table set some_column = _some_column::text::some_enum_type;
-- 6. remove old column and type
alter table some_table drop column _some_column;
drop type _some_enum_type;

3-6 dovrebbe essere ripetuto se c'è più di 1 colonna.

PostgreSQL 9.1 introduce capacità di ALTER tipi Enum:

ALTER TYPE enum_type ADD VALUE 'new_value'; -- appends to list
ALTER TYPE enum_type ADD VALUE 'new_value' BEFORE 'old_value';
ALTER TYPE enum_type ADD VALUE 'new_value' AFTER 'old_value';

Una possibile soluzione è la seguente; condizione preliminare è che non vi siano conflitti nei valori enum usati. (ad es. quando si rimuove un valore enum, assicurarsi che questo valore non venga più utilizzato.)

-- rename the old enum
alter type my_enum rename to my_enum__;
-- create the new enum
create type my_enum as enum ('value1', 'value2', 'value3');

-- alter all you enum columns
alter table my_table
  alter column my_column type my_enum using my_column::text::my_enum;

-- drop the old enum
drop type my_enum__;

Anche in questo modo l'ordine delle colonne non verrà modificato.

Se ti trovi in ​​una situazione in cui dovresti aggiungere enumvalori nella transazione, eseguilo nella migrazione flyway sulla ALTER TYPEdichiarazione che riceverai un errore ERROR: ALTER TYPE ... ADD cannot run inside a transaction block(vedi il numero 350 della flyway ) potresti aggiungere tali valori pg_enumdirettamente come soluzione alternativa ( type_egais_unitsè il nome del target enum):

INSERT INTO pg_enum (enumtypid, enumlabel, enumsortorder)
    SELECT 'type_egais_units'::regtype::oid, 'NEW_ENUM_VALUE', ( SELECT MAX(enumsortorder) + 1 FROM pg_enum WHERE enumtypid = 'type_egais_units'::regtype )

Completamento di @Dariusz 1

Per Rails 4.2.1, c'è questa sezione doc:

== Migrazioni transazionali

Se la scheda di database supporta le transazioni DDL, tutte le migrazioni verranno automaticamente inserite in una transazione. Esistono query che non è possibile eseguire all'interno di una transazione e per queste situazioni è possibile disattivare le transazioni automatiche.

class ChangeEnum < ActiveRecord::Migration
  disable_ddl_transaction!

  def up
    execute "ALTER TYPE model_size ADD VALUE 'new_value'"
  end
end

Dalla documentazione di Postgres 9.1 :

ALTER TYPE name ADD VALUE new_enum_value [ { BEFORE | AFTER } existing_enum_value ]

Esempio:

ALTER TYPE user_status ADD VALUE 'PROVISIONAL' AFTER 'NORMAL'

Disclaimer: non ho provato questa soluzione, quindi potrebbe non funzionare ;-)

Dovresti guardare pg_enum. Se vuoi solo cambiare l'etichetta di un ENUM esistente, un semplice AGGIORNAMENTO lo farà.

Per aggiungere un nuovo valore ENUM:

• Innanzitutto inserire il nuovo valore in pg_enum. Se il nuovo valore deve essere l'ultimo, il gioco è fatto.
• In caso contrario (è necessario un nuovo valore ENUM tra quelli esistenti), dovrai aggiornare ciascun valore distinto nella tabella, passando dal più alto al più basso ...
• Quindi dovrai solo rinominarli pg_enum nell'ordine opposto.

Illustrazione
Sono disponibili le seguenti serie di etichette:

ENUM ('enum1', 'enum2', 'enum3')

e vuoi ottenere:

ENUM ('enum1', 'enum1b', 'enum2', 'enum3')

poi:

INSERT INTO pg_enum (OID, 'newenum3');
UPDATE TABLE SET enumvalue TO 'newenum3' WHERE enumvalue='enum3';
UPDATE TABLE SET enumvalue TO 'enum3' WHERE enumvalue='enum2';

poi:

UPDATE TABLE pg_enum SET name='enum1b' WHERE name='enum2' AND enumtypid=OID;

E così via...

Non riesco a pubblicare un commento, quindi dirò solo che l'aggiornamento di pg_enum funziona in Postgres 8.4. Per come sono impostati i nostri enum, ho aggiunto nuovi valori ai tipi di enum esistenti tramite:

INSERT INTO pg_enum (enumtypid, enumlabel)
  SELECT typelem, 'NEWENUM' FROM pg_type WHERE
    typname = '_ENUMNAME_WITH_LEADING_UNDERSCORE';

È un po 'spaventoso, ma ha senso dato il modo in cui Postgres memorizza effettivamente i suoi dati.

L'aggiornamento di pg_enum funziona, così come il trucco della colonna dell'intermediario evidenziato sopra. Si può anche usare USING magic per cambiare direttamente il tipo di colonna:

CREATE TYPE test AS enum('a', 'b');
CREATE TABLE foo (bar test);
INSERT INTO foo VALUES ('a'), ('b');

ALTER TABLE foo ALTER COLUMN bar TYPE varchar;

DROP TYPE test;
CREATE TYPE test as enum('a', 'b', 'c');

ALTER TABLE foo ALTER COLUMN bar TYPE test
USING CASE
WHEN bar = ANY (enum_range(null::test)::varchar[])
THEN bar::test
WHEN bar = ANY ('{convert, these, values}'::varchar[])
THEN 'c'::test
ELSE NULL
END;

Finché non hai funzioni che richiedono esplicitamente o restituiscono quell'enum, sei bravo. (pgsql si lamenterà quando si rilascia il tipo, se presente).

Inoltre, nota che PG9.1 sta introducendo un'istruzione ALTER TYPE, che funzionerà su enum:

http://developer.postgresql.org/pgdocs/postgres/release-9-1-alpha.html

Più semplice: sbarazzarsi di enumerazioni. Non sono facilmente modificabili e quindi dovrebbero essere usati molto raramente.

Impossibile aggiungere un commento nella posizione appropriata, ma ALTER TABLE foo ALTER COLUMN bar TYPE new_enum_type USING bar::text::new_enum_typecon un valore predefinito nella colonna non riuscito. Dovevo:

ALTER table ALTER COLUMN bar DROP DEFAULT;

e poi ha funzionato.

per ogni evenienza, se stai usando Rails e hai diverse affermazioni dovrai eseguirle una per una, come:

execute "ALTER TYPE XXX ADD VALUE IF NOT EXISTS 'YYY';"
execute "ALTER TYPE XXX ADD VALUE IF NOT EXISTS 'ZZZ';"

Ecco una soluzione più generale ma piuttosto rapida, che oltre a cambiare il tipo stesso aggiorna tutte le colonne del database utilizzandolo. Il metodo può essere applicato anche se una nuova versione di ENUM è diversa da più di un'etichetta o manca alcune di quelle originali. Il codice seguente sostituisce my_schema.my_type AS ENUM ('a', 'b', 'c')con ENUM ('a', 'b', 'd', 'e'):

CREATE OR REPLACE FUNCTION tmp() RETURNS BOOLEAN AS
$BODY$

DECLARE
    item RECORD;

BEGIN

    -- 1. create new type in replacement to my_type
    CREATE TYPE my_schema.my_type_NEW
        AS ENUM ('a', 'b', 'd', 'e');

    -- 2. select all columns in the db that have type my_type
    FOR item IN
        SELECT table_schema, table_name, column_name, udt_schema, udt_name
            FROM information_schema.columns
            WHERE
                udt_schema   = 'my_schema'
            AND udt_name     = 'my_type'
    LOOP
        -- 3. Change the type of every column using my_type to my_type_NEW
        EXECUTE
            ' ALTER TABLE ' || item.table_schema || '.' || item.table_name
         || ' ALTER COLUMN ' || item.column_name
         || ' TYPE my_schema.my_type_NEW'
         || ' USING ' || item.column_name || '::text::my_schema.my_type_NEW;';
    END LOOP;

    -- 4. Delete an old version of the type
    DROP TYPE my_schema.my_type;

    -- 5. Remove _NEW suffix from the new type
    ALTER TYPE my_schema.my_type_NEW
        RENAME TO my_type;

    RETURN true;

END
$BODY$
LANGUAGE 'plpgsql';

SELECT * FROM tmp();
DROP FUNCTION tmp();

L'intero processo verrà eseguito abbastanza rapidamente, perché se l'ordine delle etichette persiste, non si verificherà alcun cambiamento effettivo dei dati. Ho applicato il metodo su 5 tabelle usando my_typee avendo 50.000-70.000 righe in ciascuna e l'intero processo ha richiesto solo 10 secondi.

Naturalmente, la funzione restituirà un'eccezione nel caso in cui le etichette mancanti nella nuova versione di ENUM vengano utilizzate da qualche parte nei dati, ma in tale situazione si dovrebbe comunque fare qualcosa in anticipo.

Per coloro che cercano una soluzione in transazione, il seguente sembra funzionare.

Invece di an ENUM, a DOMAINdeve essere utilizzato sul tipo TEXTcon un vincolo che verifica che il valore sia compreso nell'elenco specificato di valori consentiti (come suggerito da alcuni commenti). L'unico problema è che nessun vincolo può essere aggiunto (e quindi né modificato) a un dominio se viene utilizzato da qualsiasi tipo composito (i documenti dicono semplicemente che "alla fine dovrebbe essere migliorato"). Tale restrizione può essere aggirata, tuttavia, usando un vincolo che chiama una funzione, come segue.

START TRANSACTION;

CREATE FUNCTION test_is_allowed_label(lbl TEXT) RETURNS BOOL AS $function$
    SELECT lbl IN ('one', 'two', 'three');
$function$ LANGUAGE SQL IMMUTABLE;

CREATE DOMAIN test_domain AS TEXT CONSTRAINT val_check CHECK (test_is_allowed_label(value));

CREATE TYPE test_composite AS (num INT, word test_domain);

CREATE TABLE test_table (val test_composite);
INSERT INTO test_table (val) VALUES ((1, 'one')::test_composite), ((3, 'three')::test_composite);
-- INSERT INTO test_table (val) VALUES ((4, 'four')::test_composite); -- restricted by the CHECK constraint

CREATE VIEW test_view AS SELECT * FROM test_table; -- just to show that the views using the type work as expected

CREATE OR REPLACE FUNCTION test_is_allowed_label(lbl TEXT) RETURNS BOOL AS $function$
    SELECT lbl IN ('one', 'two', 'three', 'four');
$function$ LANGUAGE SQL IMMUTABLE;

INSERT INTO test_table (val) VALUES ((4, 'four')::test_composite); -- allowed by the new effective definition of the constraint

SELECT * FROM test_view;

CREATE OR REPLACE FUNCTION test_is_allowed_label(lbl TEXT) RETURNS BOOL AS $function$
    SELECT lbl IN ('one', 'two', 'three');
$function$ LANGUAGE SQL IMMUTABLE;

-- INSERT INTO test_table (val) VALUES ((4, 'four')::test_composite); -- restricted by the CHECK constraint, again

SELECT * FROM test_view; -- note the view lists the restricted value 'four' as no checks are made on existing data

DROP VIEW test_view;
DROP TABLE test_table;
DROP TYPE test_composite;
DROP DOMAIN test_domain;
DROP FUNCTION test_is_allowed_label(TEXT);

COMMIT;

In precedenza, ho usato una soluzione simile alla risposta accettata, ma è lungi dall'essere buona una volta considerate le viste o le funzioni o i tipi compositi (e soprattutto le viste che utilizzano altre viste usando gli ENUM modificati ...). La soluzione proposta in questa risposta sembra funzionare in qualsiasi condizione.

L'unico svantaggio è che non vengono eseguiti controlli sui dati esistenti quando vengono rimossi alcuni valori consentiti (il che potrebbe essere accettabile, soprattutto per questa domanda). (Una chiamata a ALTER DOMAIN test_domain VALIDATE CONSTRAINT val_checkfinire con lo stesso errore dell'aggiunta di un nuovo vincolo al dominio utilizzato da un tipo composito, sfortunatamente.)

Si noti che una leggera modifica come CHECK (value = ANY(get_allowed_values())), dove la get_allowed_values()funzione ha restituito l'elenco dei valori consentiti, non funzionerebbe, il che è abbastanza strano, quindi spero che la soluzione proposta sopra funzioni in modo affidabile (lo fa per me, finora ...). (funziona, in realtà - è stato un mio errore)

Come discusso in precedenza, il ALTERcomando non può essere scritto all'interno di una transazione. Il modo suggerito è quello di inserire direttamente nella tabella pg_enum, con retrieving the typelem from pg_type tableecalculating the next enumsortorder number ;

Di seguito è riportato il codice che utilizzo. (Verifica se esiste un valore duplicato prima dell'inserimento (vincolo tra enumtypid e nome enumlabel)

INSERT INTO pg_enum (enumtypid, enumlabel, enumsortorder)
    SELECT typelem,
    'NEW_ENUM_VALUE',
    (SELECT MAX(enumsortorder) + 1 
        FROM pg_enum e
        JOIN pg_type p
        ON p.typelem = e.enumtypid
        WHERE p.typname = '_mytypename'
    )
    FROM pg_type p
    WHERE p.typname = '_mytypename'
    AND NOT EXISTS (
        SELECT * FROM 
        pg_enum e
        JOIN pg_type p
        ON p.typelem = e.enumtypid
        WHERE e.enumlabel = 'NEW_ENUM_VALUE'
        AND p.typname = '_mytypename'
    )

Si noti che il nome del tipo è preceduto da un trattino basso nella tabella pg_type. Inoltre, il nome tipografico deve essere tutto minuscolo nella clausola where.

Ora questo può essere scritto in modo sicuro nel tuo script di migrazione db.

Non so se hanno altre opzioni ma possiamo eliminare il valore usando:

select oid from pg_type where typname = 'fase';'
select * from pg_enum where enumtypid = 24773;'
select * from pg_enum where enumtypid = 24773 and enumsortorder = 6;
delete from pg_enum where enumtypid = 24773 and enumsortorder = 6;

Quando si utilizza Navicat è possibile accedere ai tipi (in vista -> altri -> tipi) - ottenere la vista di progettazione del tipo - e fare clic sul pulsante "Aggiungi etichetta".