Il vincolo Postgres garantisce che una colonna di molti sia presente?

Question

Quali sono i buoni modi per aggiungere un vincolo a PostgreSQL per verificare che esattamente una colonna (da un insieme di colonne) contenga un valore non nullo?

Aggiornamento: E 'probabile che voglio usare un'espressione check come dettagliato nella Create Table e Alter Table.

Aggiornamento: Sto osservando lo functions disponibile.

Aggiornamento: Solo per lo sfondo, qui è la logica di convalida Rails Attualmente sto usando:

validate :multi_column_validation 
def multi_column_validation 
    n = 0 
    n += 1 if column_1 
    n += 1 if column_2 
    n += 1 if column_3 
    unless 1 == n 
    errors.add(:base, "Exactly one column from " + 
     "column_1, column_2, column_3 must be present") 
    end 
end 

Per essere chiari, io sto cercando PSQL, non Ruby, qui. Volevo solo mostrare la logica che sto usando poiché è più compatto di enumerare tutte le possibilità della "tavola della verità".

Answer 1

penso che il più pulito e genericamente soluzione è quella di creare una funzione di conta i valori nulli da alcuni argomenti. Per questo è possibile utilizzare il pseudo-type anyarray e una funzione SQL simile:

CREATE FUNCTION count_not_nulls(p_array anyarray) 
RETURNS BIGINT AS 
$$ 
    SELECT count(x) FROM unnest($1) AS x 
$$ LANGUAGE SQL IMMUTABLE; 

Con questa funzione, è possibile creare il CHECK CONSTRAINT come:

ALTER TABLE your_table 
ADD chk_only_one_is_not_null CHECK(count_not_nulls(array[col1, col2, col3]) = 1); 

Questo funziona solo se le colonne sono dello stesso tipo di dati.Se non è il caso, è possibile lanciare, come testo, per esempio (in quanto è sufficiente cura per il caso null):

ALTER TABLE your_table 
ADD chk_only_one_is_not_null CHECK(count_not_nulls(array[col1::text, col2::text, col3::text]) = 1); 

Come ben ricordato da @muistooshort, è possibile creare la funzione con variadic arguments, il che rende Chiama:

CREATE FUNCTION count_not_nulls(variadic p_array anyarray) 
RETURNS BIGINT AS 
$$ 
    SELECT count(x) FROM unnest($1) AS x 
$$ LANGUAGE SQL IMMUTABLE; 

ALTER TABLE your_table 
ADD chk_only_one_is_not_null CHECK(count_not_nulls(col1, col2, col3) = 1); 

Answer 2

Un po 'goffo, ma dovrebbe fare il trucco:

create table foo 
(
    col1 integer, 
    col2 integer, 
    col3 integer, 
    constraint one_is_not_null check 
     ( (col1 is not null and col2 is null and col3 is null) 
      or (col1 is null and col2 is not null and col3 is null) 
      or (col1 is null and col2 is null and col3 is not null) 
     ) 
) 

Answer 3

Qui è una soluzione elegante a due colonne secondo il "constraint -- one or the other column not null" PostgreSQL message board:

ALTER TABLE my_table ADD CONSTRAINT my_constraint CHECK (
    column_1 IS NULL != column_2 IS NULL); 

(Ma l'approccio di cui sopra non è generalizzabile a tre o più colonne.)

Se si dispone di tre o più colonne, è possibile utilizzare l'approccio della tabella di verità illustrato da a_horse_with_no_name. Tuttavia, ritengo che la segue per essere più facile da mantenere, perché non c'è bisogno di digitare le combinazioni logiche:

ALTER TABLE my_table 
ADD CONSTRAINT my_constraint CHECK (
    (CASE WHEN column_1 IS NULL THEN 0 ELSE 1 END) + 
    (CASE WHEN column_2 IS NULL THEN 0 ELSE 1 END) + 
    (CASE WHEN column_3 IS NULL THEN 0 ELSE 1 END) = 1; 

Per compattare questo, sarebbe utile per creare una funzione personalizzata in modo che il testo standard CASE WHEN column_k IS NULL THEN 0 ELSE 1 END potrebbe essere rimosso, lasciando qualcosa come:

(non_null_count(column_1) + 
non_null_count(column_2) + 
non_null_count(column_3)) = 1 

Che può essere il più compatto come PSQL consentirà (?). Detto questo, preferisco arrivare a questo tipo di sintassi, se possibile:

non_null_count(column_1, column_2, column_3) = 1 

Answer 4

Come accennato da mu is too short:

alter table t 
add constraint only_one_null check (
    (col1 is not null)::integer + (col2 is not null)::integer = 1 
)