Znajdź, czy kolumna ma unikalne ograniczenie

Question

W hipotetycznym scenariuszu jestem użytkownikiem bez uprawnień do tworzenia tabel. Chcę wiedzieć, czy kolumna w tabeli ma UNIQUE CONSTRAINT. Czy można to sprawdzić w jednostce SICTIONARY? Jak mógłbym to załatwić?

Answer 1

Obie odpowiedzi tutaj pominięto w jeden sposób wymuszenia jednoznaczności na kolumnie: tworząc unikalny indeks (bez definiowania unikalnego ograniczenia na kolumnie). Zobacz te dwa łącza (one, two), jeśli nie znasz tej opcji.

Kontrola ta powinna być wykonywana dodatkowo unikalnemu ograniczenia CHECK:

select count(*) from 
USER_IND_COLUMNS cols 
where cols.table_name='YOUR_TABLE_NAME' 
and cols.COLUMN_NAME='YOUR_COLUMN'; 

Aby sprawdzić unikatowy ograniczeń korzystać z już dostarczone metody:

select count(*) cnt 
from user_constraints uc 
where uc.table_name='YOUR_TABLE_NAME' 
and uc.constraint_type='U'; 

Alternatywnie można też spojrzeć w widoki ALL_CONSTRAINTS i .

Answer 2

unikalnych ograniczeń można zrobić coś takiego:

select cons.constraint_type, 
     all_cols.owner, all_cols.constraint_name, 
     all_cols.table_name, 
     all_cols.column_name, 
     all_cols.position 
    from all_cons_columns col 
     inner join all_cons_columns all_cols 
       on col.owner = all_cols.owner 
       and col.constraint_name = all_cols.constraint_name 
     inner join all_constraints cons 
       on col.owner = cons.owner 
       and col.constraint_name = cons.constraint_name 
where col.owner = 'SCHEMA' 
    and col.table_name = 'FOO' 
    and col.column_name = 'ID' 
    and cons.constraint_type in ('U', 'P') 
order by owner, constraint_name, position; 

ustawić właściciela, stół i kolumny zainteresowania i pokaże wszystkie ograniczenia, które dotyczą tej kolumnie

Zauważ, że to nie będzie pokaż wszystkie przypadki, w których istnieje unikalny indeks na kolumnie (ponieważ możliwe jest posiadanie unikalnego indeksu w miejscu bez obecności ograniczenia).

przykład:

SQL> create table foo(id number, id2 number, constraint foo_con unique(id, id2), constraint foo_con2 unique(id)); 

Table created. 

teraz listę wszystkich ograniczeń, które obejmują id:

SQL> col column_name format a20 
SQL> col constraint_name format a20 
SQL> col table_name format a15 
SQL> select cons.constraint_type, 
    2   all_cols.owner, all_cols.constraint_name, 
    3   all_cols.table_name, 
    4   all_cols.column_name, 
    5   all_cols.position 
    6 from all_cons_columns col 
    7   inner join all_cons_columns all_cols 
    8     on col.owner = all_cols.owner 
    9    and col.constraint_name = all_cols.constraint_name 
10   inner join all_constraints cons 
11     on col.owner = cons.owner 
12    and col.constraint_name = cons.constraint_name 
13 where col.owner = user 
14  and col.table_name = 'FOO' 
15  and col.column_name = 'ID' 
16  and cons.constraint_type in ('U', 'P') 
17 order by owner, constraint_name, position; 

C OWNER       CONSTRAINT_NAME  TABLE_NAME  COLUMN_NAME   POSITION 
- ------------------------------ -------------------- --------------- -------------------- ---------- 
U DTD_TRADE      FOO_CON    FOO    ID       1 
U DTD_TRADE      FOO_CON    FOO    ID2       2 
U DTD_TRADE      FOO_CON2    FOO    ID       1 

Answer 3

select count(*) cnt 
from user_constraints 
where table_name=your_table_name 
and constraint_type='U'; 

Jeśli count = 0, to nie ma UNIQUE ograniczenie indziej jest UNIQUE ograniczenie na stole.

Answer 4

Oto zapytanie, które właśnie wypróbowałem. Wymienia każdy unikatowości, zidentyfikowanego przez indeks że wymusza go i kolumn, które są wyjątkowe:

select x.index_name, c.column_name, c.column_position 
from USER_INDEXES x join USER_IND_COLUMNS c 
    on x.index_name = c.index_name and x.table_name = c.table_name 
    left join USER_CONSTRAINTS uc 
    on x.index_name = uc.index_name and x.table_name = uc.table_name 
where x.status = 'VALID' and 
     (x.uniqueness = 'UNIQUE' or 
     uc.constraint_type = 'U' and uc.status = 'ENABLED' and uc.validated = 'VALIDATED') 
     and x.table_name='<your table name_in_caps>' 
order by x.index_name, c.column_position; 

Wydaje się pracować dla kluczy głównych, unikalnych indeksów i dodał wyjątkowość ograniczeń.